/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.os.storage;
import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;
/**
* WARNING! Update IMountService.h and IMountService.cpp if you change this
* file. In particular, the ordering of the methods below must match the
* _TRANSACTION enum in IMountService.cpp
*
* @hide - Applications should use android.os.storage.StorageManager to access
* storage functions.
*/
public interface IMountService extends IInterface {
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends Binder implements IMountService {
private static class Proxy implements IMountService {
private final IBinder mRemote;
Proxy(IBinder remote) {
mRemote = remote;
}
public IBinder asBinder() {
return mRemote;
}
public String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* Registers an IMountServiceListener for receiving async
* notifications.
*/
public void registerListener(IMountServiceListener listener) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeStrongBinder((listener != null ? listener.asBinder() : null));
mRemote.transact(Stub.TRANSACTION_registerListener, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Unregisters an IMountServiceListener
*/
public void unregisterListener(IMountServiceListener listener) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeStrongBinder((listener != null ? listener.asBinder() : null));
mRemote.transact(Stub.TRANSACTION_unregisterListener, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Returns true if a USB mass storage host is connected
*/
public boolean isUsbMassStorageConnected() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
boolean _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_isUsbMassStorageConnected, _data, _reply, 0);
_reply.readException();
_result = 0 != _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Enables / disables USB mass storage. The caller should check
* actual status of enabling/disabling USB mass storage via
* StorageEventListener.
*/
public void setUsbMassStorageEnabled(boolean enable) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt((enable ? 1 : 0));
mRemote.transact(Stub.TRANSACTION_setUsbMassStorageEnabled, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Returns true if a USB mass storage host is enabled (media is
* shared)
*/
public boolean isUsbMassStorageEnabled() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
boolean _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_isUsbMassStorageEnabled, _data, _reply, 0);
_reply.readException();
_result = 0 != _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Mount external storage at given mount point. Returns an int
* consistent with MountServiceResultCode
*/
public int mountVolume(String mountPoint) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(mountPoint);
mRemote.transact(Stub.TRANSACTION_mountVolume, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Safely unmount external storage at given mount point. The unmount
* is an asynchronous operation. Applications should register
* StorageEventListener for storage related status changes.
*/
public void unmountVolume(String mountPoint, boolean force, boolean removeEncryption)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(mountPoint);
_data.writeInt((force ? 1 : 0));
_data.writeInt((removeEncryption ? 1 : 0));
mRemote.transact(Stub.TRANSACTION_unmountVolume, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Format external storage given a mount point. Returns an int
* consistent with MountServiceResultCode
*/
public int formatVolume(String mountPoint) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(mountPoint);
mRemote.transact(Stub.TRANSACTION_formatVolume, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Returns an array of pids with open files on the specified path.
*/
public int[] getStorageUsers(String path) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int[] _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(path);
mRemote.transact(Stub.TRANSACTION_getStorageUsers, _data, _reply, 0);
_reply.readException();
_result = _reply.createIntArray();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Gets the state of a volume via its mountpoint.
*/
public String getVolumeState(String mountPoint) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(mountPoint);
mRemote.transact(Stub.TRANSACTION_getVolumeState, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Creates a secure container with the specified parameters. Returns
* an int consistent with MountServiceResultCode
*/
public int createSecureContainer(String id, int sizeMb, String fstype, String key,
int ownerUid, boolean external) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
_data.writeInt(sizeMb);
_data.writeString(fstype);
_data.writeString(key);
_data.writeInt(ownerUid);
_data.writeInt(external ? 1 : 0);
mRemote.transact(Stub.TRANSACTION_createSecureContainer, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Destroy a secure container, and free up all resources associated
* with it. NOTE: Ensure all references are released prior to
* deleting. Returns an int consistent with MountServiceResultCode
*/
public int destroySecureContainer(String id, boolean force) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
_data.writeInt((force ? 1 : 0));
mRemote.transact(Stub.TRANSACTION_destroySecureContainer, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Finalize a container which has just been created and populated.
* After finalization, the container is immutable. Returns an int
* consistent with MountServiceResultCode
*/
public int finalizeSecureContainer(String id) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
mRemote.transact(Stub.TRANSACTION_finalizeSecureContainer, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Mount a secure container with the specified key and owner UID.
* Returns an int consistent with MountServiceResultCode
*/
public int mountSecureContainer(String id, String key, int ownerUid, boolean readOnly)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
_data.writeString(key);
_data.writeInt(ownerUid);
_data.writeInt(readOnly ? 1 : 0);
mRemote.transact(Stub.TRANSACTION_mountSecureContainer, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Unount a secure container. Returns an int consistent with
* MountServiceResultCode
*/
public int unmountSecureContainer(String id, boolean force) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
_data.writeInt((force ? 1 : 0));
mRemote.transact(Stub.TRANSACTION_unmountSecureContainer, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Returns true if the specified container is mounted
*/
public boolean isSecureContainerMounted(String id) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
boolean _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
mRemote.transact(Stub.TRANSACTION_isSecureContainerMounted, _data, _reply, 0);
_reply.readException();
_result = 0 != _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Rename an unmounted secure container. Returns an int consistent
* with MountServiceResultCode
*/
public int renameSecureContainer(String oldId, String newId) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(oldId);
_data.writeString(newId);
mRemote.transact(Stub.TRANSACTION_renameSecureContainer, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Returns the filesystem path of a mounted secure container.
*/
public String getSecureContainerPath(String id) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
mRemote.transact(Stub.TRANSACTION_getSecureContainerPath, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Gets an Array of currently known secure container IDs
*/
public String[] getSecureContainerList() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
String[] _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getSecureContainerList, _data, _reply, 0);
_reply.readException();
_result = _reply.createStringArray();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Shuts down the MountService and gracefully unmounts all external
* media. Invokes call back once the shutdown is complete.
*/
public void shutdown(IMountShutdownObserver observer)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeStrongBinder((observer != null ? observer.asBinder() : null));
mRemote.transact(Stub.TRANSACTION_shutdown, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Call into MountService by PackageManager to notify that its done
* processing the media status update request.
*/
public void finishMediaUpdate() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_finishMediaUpdate, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Mounts an Opaque Binary Blob (OBB) with the specified decryption
* key and only allows the calling process's UID access to the
* contents. MountService will call back to the supplied
* IObbActionListener to inform it of the terminal state of the
* call.
*/
public void mountObb(String rawPath, String canonicalPath, String key,
IObbActionListener token, int nonce) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(rawPath);
_data.writeString(canonicalPath);
_data.writeString(key);
_data.writeStrongBinder((token != null ? token.asBinder() : null));
_data.writeInt(nonce);
mRemote.transact(Stub.TRANSACTION_mountObb, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Unmounts an Opaque Binary Blob (OBB). When the force flag is
* specified, any program using it will be forcibly killed to
* unmount the image. MountService will call back to the supplied
* IObbActionListener to inform it of the terminal state of the
* call.
*/
public void unmountObb(
String rawPath, boolean force, IObbActionListener token, int nonce)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(rawPath);
_data.writeInt((force ? 1 : 0));
_data.writeStrongBinder((token != null ? token.asBinder() : null));
_data.writeInt(nonce);
mRemote.transact(Stub.TRANSACTION_unmountObb, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Checks whether the specified Opaque Binary Blob (OBB) is mounted
* somewhere.
*/
public boolean isObbMounted(String rawPath) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
boolean _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(rawPath);
mRemote.transact(Stub.TRANSACTION_isObbMounted, _data, _reply, 0);
_reply.readException();
_result = 0 != _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Gets the path to the mounted Opaque Binary Blob (OBB).
*/
public String getMountedObbPath(String rawPath) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(rawPath);
mRemote.transact(Stub.TRANSACTION_getMountedObbPath, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Returns whether the external storage is emulated.
*/
public boolean isExternalStorageEmulated() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
boolean _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_isExternalStorageEmulated, _data, _reply, 0);
_reply.readException();
_result = 0 != _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public int getEncryptionState() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getEncryptionState, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public int decryptStorage(String password) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(password);
mRemote.transact(Stub.TRANSACTION_decryptStorage, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public int encryptStorage(int type, String password) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(type);
_data.writeString(password);
mRemote.transact(Stub.TRANSACTION_encryptStorage, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public int changeEncryptionPassword(int type, String password) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(type);
_data.writeString(password);
mRemote.transact(Stub.TRANSACTION_changeEncryptionPassword, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public int verifyEncryptionPassword(String password) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(password);
mRemote.transact(Stub.TRANSACTION_verifyEncryptionPassword, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public int getPasswordType() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getPasswordType, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public String getPassword() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getPassword, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public void clearPassword() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_clearPassword, _data, _reply, IBinder.FLAG_ONEWAY);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
public void setField(String field, String data) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(field);
_data.writeString(data);
mRemote.transact(Stub.TRANSACTION_setField, _data, _reply, IBinder.FLAG_ONEWAY);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
public String getField(String field) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(field);
mRemote.transact(Stub.TRANSACTION_getField, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
public StorageVolume[] getVolumeList() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
StorageVolume[] _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getVolumeList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArray(StorageVolume.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/*
* Returns the filesystem path of a mounted secure container.
*/
public String getSecureContainerFilesystemPath(String id) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
mRemote.transact(Stub.TRANSACTION_getSecureContainerFilesystemPath, _data, _reply, 0);
_reply.readException();
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
/**
* Fix permissions in a container which has just been created and
* populated. Returns an int consistent with MountServiceResultCode
*/
public int fixPermissionsSecureContainer(String id, int gid, String filename)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
_data.writeInt(gid);
_data.writeString(filename);
mRemote.transact(Stub.TRANSACTION_fixPermissionsSecureContainer, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public int mkdirs(String callingPkg, String path) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(callingPkg);
_data.writeString(path);
mRemote.transact(Stub.TRANSACTION_mkdirs, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public int resizeSecureContainer(String id, int sizeMb, String key)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(id);
_data.writeInt(sizeMb);
_data.writeString(key);
mRemote.transact(Stub.TRANSACTION_resizeSecureContainer, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public long lastMaintenance() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
long _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_lastMaintenance, _data, _reply, 0);
_reply.readException();
_result = _reply.readLong();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void runMaintenance() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_runMaintenance, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
return;
}
}
private static final String DESCRIPTOR = "IMountService";
static final int TRANSACTION_registerListener = IBinder.FIRST_CALL_TRANSACTION + 0;
static final int TRANSACTION_unregisterListener = IBinder.FIRST_CALL_TRANSACTION + 1;
static final int TRANSACTION_isUsbMassStorageConnected = IBinder.FIRST_CALL_TRANSACTION + 2;
static final int TRANSACTION_setUsbMassStorageEnabled = IBinder.FIRST_CALL_TRANSACTION + 3;
static final int TRANSACTION_isUsbMassStorageEnabled = IBinder.FIRST_CALL_TRANSACTION + 4;
static final int TRANSACTION_mountVolume = IBinder.FIRST_CALL_TRANSACTION + 5;
static final int TRANSACTION_unmountVolume = IBinder.FIRST_CALL_TRANSACTION + 6;
static final int TRANSACTION_formatVolume = IBinder.FIRST_CALL_TRANSACTION + 7;
static final int TRANSACTION_getStorageUsers = IBinder.FIRST_CALL_TRANSACTION + 8;
static final int TRANSACTION_getVolumeState = IBinder.FIRST_CALL_TRANSACTION + 9;
static final int TRANSACTION_createSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 10;
static final int TRANSACTION_finalizeSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 11;
static final int TRANSACTION_destroySecureContainer = IBinder.FIRST_CALL_TRANSACTION + 12;
static final int TRANSACTION_mountSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 13;
static final int TRANSACTION_unmountSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 14;
static final int TRANSACTION_isSecureContainerMounted = IBinder.FIRST_CALL_TRANSACTION + 15;
static final int TRANSACTION_renameSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 16;
static final int TRANSACTION_getSecureContainerPath = IBinder.FIRST_CALL_TRANSACTION + 17;
static final int TRANSACTION_getSecureContainerList = IBinder.FIRST_CALL_TRANSACTION + 18;
static final int TRANSACTION_shutdown = IBinder.FIRST_CALL_TRANSACTION + 19;
static final int TRANSACTION_finishMediaUpdate = IBinder.FIRST_CALL_TRANSACTION + 20;
static final int TRANSACTION_mountObb = IBinder.FIRST_CALL_TRANSACTION + 21;
static final int TRANSACTION_unmountObb = IBinder.FIRST_CALL_TRANSACTION + 22;
static final int TRANSACTION_isObbMounted = IBinder.FIRST_CALL_TRANSACTION + 23;
static final int TRANSACTION_getMountedObbPath = IBinder.FIRST_CALL_TRANSACTION + 24;
static final int TRANSACTION_isExternalStorageEmulated = IBinder.FIRST_CALL_TRANSACTION + 25;
static final int TRANSACTION_decryptStorage = IBinder.FIRST_CALL_TRANSACTION + 26;
static final int TRANSACTION_encryptStorage = IBinder.FIRST_CALL_TRANSACTION + 27;
static final int TRANSACTION_changeEncryptionPassword = IBinder.FIRST_CALL_TRANSACTION + 28;
static final int TRANSACTION_getVolumeList = IBinder.FIRST_CALL_TRANSACTION + 29;
static final int TRANSACTION_getSecureContainerFilesystemPath = IBinder.FIRST_CALL_TRANSACTION + 30;
static final int TRANSACTION_getEncryptionState = IBinder.FIRST_CALL_TRANSACTION + 31;
static final int TRANSACTION_verifyEncryptionPassword = IBinder.FIRST_CALL_TRANSACTION + 32;
static final int TRANSACTION_fixPermissionsSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 33;
static final int TRANSACTION_mkdirs = IBinder.FIRST_CALL_TRANSACTION + 34;
static final int TRANSACTION_getPasswordType = IBinder.FIRST_CALL_TRANSACTION + 35;
static final int TRANSACTION_getPassword = IBinder.FIRST_CALL_TRANSACTION + 36;
static final int TRANSACTION_clearPassword = IBinder.FIRST_CALL_TRANSACTION + 37;
static final int TRANSACTION_setField = IBinder.FIRST_CALL_TRANSACTION + 38;
static final int TRANSACTION_getField = IBinder.FIRST_CALL_TRANSACTION + 39;
static final int TRANSACTION_resizeSecureContainer = IBinder.FIRST_CALL_TRANSACTION + 40;
static final int TRANSACTION_lastMaintenance = IBinder.FIRST_CALL_TRANSACTION + 41;
static final int TRANSACTION_runMaintenance = IBinder.FIRST_CALL_TRANSACTION + 42;
/**
* Cast an IBinder object into an IMountService interface, generating a
* proxy if needed.
*/
public static IMountService asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (iin != null && iin instanceof IMountService) {
return (IMountService) iin;
}
return new IMountService.Stub.Proxy(obj);
}
/** Construct the stub at attach it to the interface. */
public Stub() {
attachInterface(this, DESCRIPTOR);
}
public IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply,
int flags) throws RemoteException {
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_registerListener: {
data.enforceInterface(DESCRIPTOR);
IMountServiceListener listener;
listener = IMountServiceListener.Stub.asInterface(data.readStrongBinder());
registerListener(listener);
reply.writeNoException();
return true;
}
case TRANSACTION_unregisterListener: {
data.enforceInterface(DESCRIPTOR);
IMountServiceListener listener;
listener = IMountServiceListener.Stub.asInterface(data.readStrongBinder());
unregisterListener(listener);
reply.writeNoException();
return true;
}
case TRANSACTION_isUsbMassStorageConnected: {
data.enforceInterface(DESCRIPTOR);
boolean result = isUsbMassStorageConnected();
reply.writeNoException();
reply.writeInt((result ? 1 : 0));
return true;
}
case TRANSACTION_setUsbMassStorageEnabled: {
data.enforceInterface(DESCRIPTOR);
boolean enable;
enable = 0 != data.readInt();
setUsbMassStorageEnabled(enable);
reply.writeNoException();
return true;
}
case TRANSACTION_isUsbMassStorageEnabled: {
data.enforceInterface(DESCRIPTOR);
boolean result = isUsbMassStorageEnabled();
reply.writeNoException();
reply.writeInt((result ? 1 : 0));
return true;
}
case TRANSACTION_mountVolume: {
data.enforceInterface(DESCRIPTOR);
String mountPoint;
mountPoint = data.readString();
int resultCode = mountVolume(mountPoint);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_unmountVolume: {
data.enforceInterface(DESCRIPTOR);
String mountPoint;
mountPoint = data.readString();
boolean force = 0 != data.readInt();
boolean removeEncrypt = 0 != data.readInt();
unmountVolume(mountPoint, force, removeEncrypt);
reply.writeNoException();
return true;
}
case TRANSACTION_formatVolume: {
data.enforceInterface(DESCRIPTOR);
String mountPoint;
mountPoint = data.readString();
int result = formatVolume(mountPoint);
reply.writeNoException();
reply.writeInt(result);
return true;
}
case TRANSACTION_getStorageUsers: {
data.enforceInterface(DESCRIPTOR);
String path;
path = data.readString();
int[] pids = getStorageUsers(path);
reply.writeNoException();
reply.writeIntArray(pids);
return true;
}
case TRANSACTION_getVolumeState: {
data.enforceInterface(DESCRIPTOR);
String mountPoint;
mountPoint = data.readString();
String state = getVolumeState(mountPoint);
reply.writeNoException();
reply.writeString(state);
return true;
}
case TRANSACTION_createSecureContainer: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
int sizeMb;
sizeMb = data.readInt();
String fstype;
fstype = data.readString();
String key;
key = data.readString();
int ownerUid;
ownerUid = data.readInt();
boolean external;
external = 0 != data.readInt();
int resultCode = createSecureContainer(id, sizeMb, fstype, key, ownerUid,
external);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_finalizeSecureContainer: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
int resultCode = finalizeSecureContainer(id);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_destroySecureContainer: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
boolean force;
force = 0 != data.readInt();
int resultCode = destroySecureContainer(id, force);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_mountSecureContainer: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
String key;
key = data.readString();
int ownerUid;
ownerUid = data.readInt();
boolean readOnly;
readOnly = data.readInt() != 0;
int resultCode = mountSecureContainer(id, key, ownerUid, readOnly);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_unmountSecureContainer: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
boolean force;
force = 0 != data.readInt();
int resultCode = unmountSecureContainer(id, force);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_isSecureContainerMounted: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
boolean status = isSecureContainerMounted(id);
reply.writeNoException();
reply.writeInt((status ? 1 : 0));
return true;
}
case TRANSACTION_renameSecureContainer: {
data.enforceInterface(DESCRIPTOR);
String oldId;
oldId = data.readString();
String newId;
newId = data.readString();
int resultCode = renameSecureContainer(oldId, newId);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_getSecureContainerPath: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
String path = getSecureContainerPath(id);
reply.writeNoException();
reply.writeString(path);
return true;
}
case TRANSACTION_getSecureContainerList: {
data.enforceInterface(DESCRIPTOR);
String[] ids = getSecureContainerList();
reply.writeNoException();
reply.writeStringArray(ids);
return true;
}
case TRANSACTION_shutdown: {
data.enforceInterface(DESCRIPTOR);
IMountShutdownObserver observer;
observer = IMountShutdownObserver.Stub.asInterface(data
.readStrongBinder());
shutdown(observer);
reply.writeNoException();
return true;
}
case TRANSACTION_finishMediaUpdate: {
data.enforceInterface(DESCRIPTOR);
finishMediaUpdate();
reply.writeNoException();
return true;
}
case TRANSACTION_mountObb: {
data.enforceInterface(DESCRIPTOR);
final String rawPath = data.readString();
final String canonicalPath = data.readString();
final String key = data.readString();
IObbActionListener observer;
observer = IObbActionListener.Stub.asInterface(data.readStrongBinder());
int nonce;
nonce = data.readInt();
mountObb(rawPath, canonicalPath, key, observer, nonce);
reply.writeNoException();
return true;
}
case TRANSACTION_unmountObb: {
data.enforceInterface(DESCRIPTOR);
String filename;
filename = data.readString();
boolean force;
force = 0 != data.readInt();
IObbActionListener observer;
observer = IObbActionListener.Stub.asInterface(data.readStrongBinder());
int nonce;
nonce = data.readInt();
unmountObb(filename, force, observer, nonce);
reply.writeNoException();
return true;
}
case TRANSACTION_isObbMounted: {
data.enforceInterface(DESCRIPTOR);
String filename;
filename = data.readString();
boolean status = isObbMounted(filename);
reply.writeNoException();
reply.writeInt((status ? 1 : 0));
return true;
}
case TRANSACTION_getMountedObbPath: {
data.enforceInterface(DESCRIPTOR);
String filename;
filename = data.readString();
String mountedPath = getMountedObbPath(filename);
reply.writeNoException();
reply.writeString(mountedPath);
return true;
}
case TRANSACTION_isExternalStorageEmulated: {
data.enforceInterface(DESCRIPTOR);
boolean emulated = isExternalStorageEmulated();
reply.writeNoException();
reply.writeInt(emulated ? 1 : 0);
return true;
}
case TRANSACTION_decryptStorage: {
data.enforceInterface(DESCRIPTOR);
String password = data.readString();
int result = decryptStorage(password);
reply.writeNoException();
reply.writeInt(result);
return true;
}
case TRANSACTION_encryptStorage: {
data.enforceInterface(DESCRIPTOR);
int type = data.readInt();
String password = data.readString();
int result = encryptStorage(type, password);
reply.writeNoException();
reply.writeInt(result);
return true;
}
case TRANSACTION_changeEncryptionPassword: {
data.enforceInterface(DESCRIPTOR);
int type = data.readInt();
String password = data.readString();
int result = changeEncryptionPassword(type, password);
reply.writeNoException();
reply.writeInt(result);
return true;
}
case TRANSACTION_getVolumeList: {
data.enforceInterface(DESCRIPTOR);
StorageVolume[] result = getVolumeList();
reply.writeNoException();
reply.writeTypedArray(result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
return true;
}
case TRANSACTION_getSecureContainerFilesystemPath: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
String path = getSecureContainerFilesystemPath(id);
reply.writeNoException();
reply.writeString(path);
return true;
}
case TRANSACTION_getEncryptionState: {
data.enforceInterface(DESCRIPTOR);
int result = getEncryptionState();
reply.writeNoException();
reply.writeInt(result);
return true;
}
case TRANSACTION_fixPermissionsSecureContainer: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
int gid;
gid = data.readInt();
String filename;
filename = data.readString();
int resultCode = fixPermissionsSecureContainer(id, gid, filename);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_mkdirs: {
data.enforceInterface(DESCRIPTOR);
String callingPkg = data.readString();
String path = data.readString();
int result = mkdirs(callingPkg, path);
reply.writeNoException();
reply.writeInt(result);
return true;
}
case TRANSACTION_getPasswordType: {
data.enforceInterface(DESCRIPTOR);
int result = getPasswordType();
reply.writeNoException();
reply.writeInt(result);
return true;
}
case TRANSACTION_getPassword: {
data.enforceInterface(DESCRIPTOR);
String result = getPassword();
reply.writeNoException();
reply.writeString(result);
return true;
}
case TRANSACTION_clearPassword: {
data.enforceInterface(DESCRIPTOR);
clearPassword();
reply.writeNoException();
return true;
}
case TRANSACTION_setField: {
data.enforceInterface(DESCRIPTOR);
String field = data.readString();
String contents = data.readString();
setField(field, contents);
reply.writeNoException();
return true;
}
case TRANSACTION_getField: {
data.enforceInterface(DESCRIPTOR);
String field = data.readString();
String contents = getField(field);
reply.writeNoException();
reply.writeString(contents);
return true;
}
case TRANSACTION_resizeSecureContainer: {
data.enforceInterface(DESCRIPTOR);
String id;
id = data.readString();
int sizeMb;
sizeMb = data.readInt();
String key;
key = data.readString();
int resultCode = resizeSecureContainer(id, sizeMb, key);
reply.writeNoException();
reply.writeInt(resultCode);
return true;
}
case TRANSACTION_lastMaintenance: {
data.enforceInterface(DESCRIPTOR);
long lastMaintenance = lastMaintenance();
reply.writeNoException();
reply.writeLong(lastMaintenance);
return true;
}
case TRANSACTION_runMaintenance: {
data.enforceInterface(DESCRIPTOR);
runMaintenance();
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
}
/*
* Creates a secure container with the specified parameters. Returns an int
* consistent with MountServiceResultCode
*/
public int createSecureContainer(String id, int sizeMb, String fstype, String key,
int ownerUid, boolean external) throws RemoteException;
/*
* Destroy a secure container, and free up all resources associated with it.
* NOTE: Ensure all references are released prior to deleting. Returns an
* int consistent with MountServiceResultCode
*/
public int destroySecureContainer(String id, boolean force) throws RemoteException;
/*
* Finalize a container which has just been created and populated. After
* finalization, the container is immutable. Returns an int consistent with
* MountServiceResultCode
*/
public int finalizeSecureContainer(String id) throws RemoteException;
/**
* Call into MountService by PackageManager to notify that its done
* processing the media status update request.
*/
public void finishMediaUpdate() throws RemoteException;
/**
* Format external storage given a mount point. Returns an int consistent
* with MountServiceResultCode
*/
public int formatVolume(String mountPoint) throws RemoteException;
/**
* Gets the path to the mounted Opaque Binary Blob (OBB).
*/
public String getMountedObbPath(String rawPath) throws RemoteException;
/**
* Gets an Array of currently known secure container IDs
*/
public String[] getSecureContainerList() throws RemoteException;
/*
* Returns the filesystem path of a mounted secure container.
*/
public String getSecureContainerPath(String id) throws RemoteException;
/**
* Returns an array of pids with open files on the specified path.
*/
public int[] getStorageUsers(String path) throws RemoteException;
/**
* Gets the state of a volume via its mountpoint.
*/
public String getVolumeState(String mountPoint) throws RemoteException;
/**
* Checks whether the specified Opaque Binary Blob (OBB) is mounted
* somewhere.
*/
public boolean isObbMounted(String rawPath) throws RemoteException;
/*
* Returns true if the specified container is mounted
*/
public boolean isSecureContainerMounted(String id) throws RemoteException;
/**
* Returns true if a USB mass storage host is connected
*/
public boolean isUsbMassStorageConnected() throws RemoteException;
/**
* Returns true if a USB mass storage host is enabled (media is shared)
*/
public boolean isUsbMassStorageEnabled() throws RemoteException;
/**
* Mounts an Opaque Binary Blob (OBB) with the specified decryption key and
* only allows the calling process's UID access to the contents.
* MountService will call back to the supplied IObbActionListener to inform
* it of the terminal state of the call.
*/
public void mountObb(String rawPath, String canonicalPath, String key,
IObbActionListener token, int nonce) throws RemoteException;
/*
* Mount a secure container with the specified key and owner UID. Returns an
* int consistent with MountServiceResultCode
*/
public int mountSecureContainer(String id, String key, int ownerUid, boolean readOnly)
throws RemoteException;
/**
* Mount external storage at given mount point. Returns an int consistent
* with MountServiceResultCode
*/
public int mountVolume(String mountPoint) throws RemoteException;
/**
* Registers an IMountServiceListener for receiving async notifications.
*/
public void registerListener(IMountServiceListener listener) throws RemoteException;
/*
* Rename an unmounted secure container. Returns an int consistent with
* MountServiceResultCode
*/
public int renameSecureContainer(String oldId, String newId) throws RemoteException;
/**
* Enables / disables USB mass storage. The caller should check actual
* status of enabling/disabling USB mass storage via StorageEventListener.
*/
public void setUsbMassStorageEnabled(boolean enable) throws RemoteException;
/**
* Shuts down the MountService and gracefully unmounts all external media.
* Invokes call back once the shutdown is complete.
*/
public void shutdown(IMountShutdownObserver observer) throws RemoteException;
/**
* Unmounts an Opaque Binary Blob (OBB). When the force flag is specified,
* any program using it will be forcibly killed to unmount the image.
* MountService will call back to the supplied IObbActionListener to inform
* it of the terminal state of the call.
*/
public void unmountObb(String rawPath, boolean force, IObbActionListener token, int nonce)
throws RemoteException;
/*
* Unount a secure container. Returns an int consistent with
* MountServiceResultCode
*/
public int unmountSecureContainer(String id, boolean force) throws RemoteException;
/**
* Safely unmount external storage at given mount point. The unmount is an
* asynchronous operation. Applications should register StorageEventListener
* for storage related status changes.
* @param mountPoint the mount point
* @param force whether or not to forcefully unmount it (e.g. even if programs are using this
* data currently)
* @param removeEncryption whether or not encryption mapping should be removed from the volume.
* This value implies {@code force}.
*/
public void unmountVolume(String mountPoint, boolean force, boolean removeEncryption)
throws RemoteException;
/**
* Unregisters an IMountServiceListener
*/
public void unregisterListener(IMountServiceListener listener) throws RemoteException;
/**
* Returns whether or not the external storage is emulated.
*/
public boolean isExternalStorageEmulated() throws RemoteException;
/** The volume is not encrypted. */
static final int ENCRYPTION_STATE_NONE = 1;
/** The volume has been encrypted succesfully. */
static final int ENCRYPTION_STATE_OK = 0;
/** The volume is in a bad state.*/
static final int ENCRYPTION_STATE_ERROR_UNKNOWN = -1;
/** Encryption is incomplete */
static final int ENCRYPTION_STATE_ERROR_INCOMPLETE = -2;
/** Encryption is incomplete and irrecoverable */
static final int ENCRYPTION_STATE_ERROR_INCONSISTENT = -3;
/** Underlying data is corrupt */
static final int ENCRYPTION_STATE_ERROR_CORRUPT = -4;
/**
* Determines the encryption state of the volume.
* @return a numerical value. See {@code ENCRYPTION_STATE_*} for possible values.
*/
public int getEncryptionState() throws RemoteException;
/**
* Decrypts any encrypted volumes.
*/
public int decryptStorage(String password) throws RemoteException;
/**
* Encrypts storage.
*/
public int encryptStorage(int type, String password) throws RemoteException;
/**
* Changes the encryption password.
*/
public int changeEncryptionPassword(int type, String password)
throws RemoteException;
/**
* Verify the encryption password against the stored volume. This method
* may only be called by the system process.
*/
public int verifyEncryptionPassword(String password) throws RemoteException;
/**
* Returns list of all mountable volumes.
*/
public StorageVolume[] getVolumeList() throws RemoteException;
/**
* Gets the path on the filesystem for the ASEC container itself.
*
* @param cid ASEC container ID
* @return path to filesystem or {@code null} if it's not found
* @throws RemoteException
*/
public String getSecureContainerFilesystemPath(String cid) throws RemoteException;
/*
* Fix permissions in a container which has just been created and populated.
* Returns an int consistent with MountServiceResultCode
*/
public int fixPermissionsSecureContainer(String id, int gid, String filename)
throws RemoteException;
/**
* Ensure that all directories along given path exist, creating parent
* directories as needed. Validates that given path is absolute and that it
* contains no relative "." or ".." paths or symlinks. Also ensures that
* path belongs to a volume managed by vold, and that path is either
* external storage data or OBB directory belonging to calling app.
*/
public int mkdirs(String callingPkg, String path) throws RemoteException;
/**
* Determines the type of the encryption password
* @return PasswordType
*/
public int getPasswordType() throws RemoteException;
/**
* Get password from vold
* @return password or empty string
*/
public String getPassword() throws RemoteException;
/**
* Securely clear password from vold
*/
public void clearPassword() throws RemoteException;
/**
* Set a field in the crypto header.
* @param field field to set
* @param contents contents to set in field
*/
public void setField(String field, String contents) throws RemoteException;
/**
* Gets a field from the crypto header.
* @param field field to get
* @return contents of field
*/
public String getField(String field) throws RemoteException;
public int resizeSecureContainer(String id, int sizeMb, String key) throws RemoteException;
/**
* Report the time of the last maintenance operation such as fstrim.
* @return Timestamp of the last maintenance operation, in the
* System.currentTimeMillis() time base
* @throws RemoteException
*/
public long lastMaintenance() throws RemoteException;
/**
* Kick off an immediate maintenance operation
* @throws RemoteException
*/
public void runMaintenance() throws RemoteException;
}
|
