Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reorganize MountService IPC

Browse Source 
Remove auto-generated AIDL files and replace them with manually edited
.java and .cpp/.h files so that binder calls can be made from either
Java or C++.

Update the makefiles to not attempt to generate the AIDL files and also
remove the old auto-generated .java files.

Put all the storage-related C++ things in libstorage so that we don't
pollute other libraries.

Change-Id: I82d1631295452709f12ff1270f36c3100e652806
This commit is contained in:
Kenny Root
2010-08-18 15:59:25 -07:00
parent 6be237120e
commit be857d4284
21 changed files with 2570 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

184
core/java/android/os/storage/IMountService.aidl
View File

@@ -1,184 +0,0 @@
/* //device/java/android/android/os/IUsb.aidl
**
** Copyright 2007, 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.storage.IMountServiceListener;
import android.os.storage.IMountShutdownObserver;
import android.os.storage.IObbActionListener;
/** 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.
*/
interface IMountService
{
/**
* Registers an IMountServiceListener for receiving async
* notifications.
*/
void registerListener(IMountServiceListener listener);
/**
* Unregisters an IMountServiceListener
*/
void unregisterListener(IMountServiceListener listener);
/**
* Returns true if a USB mass storage host is connected
*/
boolean isUsbMassStorageConnected();
/**
* Enables / disables USB mass storage.
* The caller should check actual status of enabling/disabling
* USB mass storage via StorageEventListener.
*/
void setUsbMassStorageEnabled(boolean enable);
/**
* Returns true if a USB mass storage host is enabled (media is shared)
*/
boolean isUsbMassStorageEnabled();
/**
* Mount external storage at given mount point.
* Returns an int consistent with MountServiceResultCode
*/
int mountVolume(String mountPoint);
/**
* Safely unmount external storage at given mount point.
* The unmount is an asynchronous operation. Applications
* should register StorageEventListener for storage related
* status changes.
*
*/
void unmountVolume(String mountPoint, boolean force);
/**
* Format external storage given a mount point.
* Returns an int consistent with MountServiceResultCode
*/
int formatVolume(String mountPoint);
/**
* Returns an array of pids with open files on
* the specified path.
*/
int[] getStorageUsers(String path);
/**
* Gets the state of a volume via its mountpoint.
*/
String getVolumeState(String mountPoint);
/*
* Creates a secure container with the specified parameters.
* Returns an int consistent with MountServiceResultCode
*/
int createSecureContainer(String id, int sizeMb, String fstype, String key, int ownerUid);
/*
* Finalize a container which has just been created and populated.
* After finalization, the container is immutable.
* Returns an int consistent with MountServiceResultCode
*/
int finalizeSecureContainer(String id);
/*
* 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
*/
int destroySecureContainer(String id, boolean force);
/*
* Mount a secure container with the specified key and owner UID.
* Returns an int consistent with MountServiceResultCode
*/
int mountSecureContainer(String id, String key, int ownerUid);
/*
* Unount a secure container.
* Returns an int consistent with MountServiceResultCode
*/
int unmountSecureContainer(String id, boolean force);
/*
* Returns true if the specified container is mounted
*/
boolean isSecureContainerMounted(String id);
/*
* Rename an unmounted secure container.
* Returns an int consistent with MountServiceResultCode
*/
int renameSecureContainer(String oldId, String newId);
/*
* Returns the filesystem path of a mounted secure container.
*/
String getSecureContainerPath(String id);
/**
* Gets an Array of currently known secure container IDs
*/
String[] getSecureContainerList();
/**
* Shuts down the MountService and gracefully unmounts all external media.
* Invokes call back once the shutdown is complete.
*/
void shutdown(IMountShutdownObserver observer);
/**
* Call into MountService by PackageManager to notify that its done
* processing the media status update request.
*/
void finishMediaUpdate();
/**
* 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.
*/
void mountObb(String filename, String key, IObbActionListener token);
/**
* 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.
*/
void unmountObb(String filename, boolean force, IObbActionListener token);
/**
* Checks whether the specified Opaque Binary Blob (OBB) is mounted somewhere.
*/
boolean isObbMounted(String filename);
/**
* Gets the path to the mounted Opaque Binary Blob (OBB).
*/
String getMountedObbPath(String filename);
}

1046
core/java/android/os/storage/IMountService.java Normal file
View File

File diff suppressed because it is too large Load Diff

43
core/java/android/os/storage/IMountServiceListener.aidl
View File

@@ -1,43 +0,0 @@
/*
* Copyright (C) 2009 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;
/**
* Callback class for receiving events from MountService.
*
* @hide - Applications should use android.os.storage.IStorageEventListener
* for storage event callbacks.
*/
interface IMountServiceListener {
/**
* Detection state of USB Mass Storage has changed
*
* @param available true if a UMS host is connected.
*/
void onUsbMassStorageConnectionChanged(boolean connected);
/**
* Storage state has changed.
*
* @param path The volume mount path.
* @param oldState The old state of the volume.
* @param newState The new state of the volume.
*
* Note: State is one of the values returned by Environment.getExternalStorageState()
*/
void onStorageStateChanged(String path, String oldState, String newState);
}

176
core/java/android/os/storage/IMountServiceListener.java Normal file
View File

@@ -0,0 +1,176 @@
/*
* Copyright (C) 2009 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;
/**
* Callback class for receiving events from MountService.
*
* @hide - Applications should use IStorageEventListener for storage event
* callbacks.
*/
public interface IMountServiceListener extends IInterface {
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends Binder implements IMountServiceListener {
private static final String DESCRIPTOR = "IMountServiceListener";
/** Construct the stub at attach it to the interface. */
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an IMountServiceListener interface,
* generating a proxy if needed.
*/
public static IMountServiceListener asInterface(IBinder obj) {
if ((obj == null)) {
return null;
}
IInterface iin = (IInterface) obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof IMountServiceListener))) {
return ((IMountServiceListener) iin);
}
return new IMountServiceListener.Stub.Proxy(obj);
}
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_onUsbMassStorageConnectionChanged: {
data.enforceInterface(DESCRIPTOR);
boolean connected;
connected = (0 != data.readInt());
this.onUsbMassStorageConnectionChanged(connected);
reply.writeNoException();
return true;
}
case TRANSACTION_onStorageStateChanged: {
data.enforceInterface(DESCRIPTOR);
String path;
path = data.readString();
String oldState;
oldState = data.readString();
String newState;
newState = data.readString();
this.onStorageStateChanged(path, oldState, newState);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements IMountServiceListener {
private IBinder mRemote;
Proxy(IBinder remote) {
mRemote = remote;
}
public IBinder asBinder() {
return mRemote;
}
public String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* Detection state of USB Mass Storage has changed
*
* @param available true if a UMS host is connected.
*/
public void onUsbMassStorageConnectionChanged(boolean connected) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(((connected) ? (1) : (0)));
mRemote.transact(Stub.TRANSACTION_onUsbMassStorageConnectionChanged, _data,
_reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Storage state has changed.
*
* @param path The volume mount path.
* @param oldState The old state of the volume.
* @param newState The new state of the volume. Note: State is one
* of the values returned by
* Environment.getExternalStorageState()
*/
public void onStorageStateChanged(String path, String oldState, String newState)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(path);
_data.writeString(oldState);
_data.writeString(newState);
mRemote.transact(Stub.TRANSACTION_onStorageStateChanged, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_onUsbMassStorageConnectionChanged = (IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_onStorageStateChanged = (IBinder.FIRST_CALL_TRANSACTION + 1);
}
/**
* Detection state of USB Mass Storage has changed
*
* @param available true if a UMS host is connected.
*/
public void onUsbMassStorageConnectionChanged(boolean connected) throws RemoteException;
/**
* Storage state has changed.
*
* @param path The volume mount path.
* @param oldState The old state of the volume.
* @param newState The new state of the volume. Note: State is one of the
* values returned by Environment.getExternalStorageState()
*/
public void onStorageStateChanged(String path, String oldState, String newState)
throws RemoteException;
}

33
core/java/android/os/storage/IMountShutdownObserver.aidl
View File

@@ -1,33 +0,0 @@
/*
* Copyright (C) 2009 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;
/**
* Callback class for receiving events related
* to shutdown.
*
* @hide - For internal consumption only.
*/
interface IMountShutdownObserver {
/**
* This method is called when the shutdown
* of MountService completed.
* @param statusCode indicates success or failure
* of the shutdown.
*/
void onShutDownComplete(int statusCode);
}

124
core/java/android/os/storage/IMountShutdownObserver.java Normal file
View File

@@ -0,0 +1,124 @@
/*
* Copyright (C) 2009 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;
/**
* Callback class for receiving events related to shutdown.
*
* @hide - For internal consumption only.
*/
public interface IMountShutdownObserver extends IInterface {
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends Binder implements IMountShutdownObserver {
private static final java.lang.String DESCRIPTOR = "IMountShutdownObserver";
/** Construct the stub at attach it to the interface. */
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an IMountShutdownObserver interface,
* generating a proxy if needed.
*/
public static IMountShutdownObserver asInterface(IBinder obj) {
if ((obj == null)) {
return null;
}
IInterface iin = (IInterface) obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof IMountShutdownObserver))) {
return ((IMountShutdownObserver) iin);
}
return new IMountShutdownObserver.Stub.Proxy(obj);
}
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_onShutDownComplete: {
data.enforceInterface(DESCRIPTOR);
int statusCode;
statusCode = data.readInt();
this.onShutDownComplete(statusCode);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements IMountShutdownObserver {
private IBinder mRemote;
Proxy(IBinder remote) {
mRemote = remote;
}
public IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* This method is called when the shutdown of MountService
* completed.
*
* @param statusCode indicates success or failure of the shutdown.
*/
public void onShutDownComplete(int statusCode) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(statusCode);
mRemote.transact(Stub.TRANSACTION_onShutDownComplete, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_onShutDownComplete = (IBinder.FIRST_CALL_TRANSACTION + 0);
}
/**
* This method is called when the shutdown of MountService completed.
*
* @param statusCode indicates success or failure of the shutdown.
*/
public void onShutDownComplete(int statusCode) throws RemoteException;
}

34
core/java/android/os/storage/IObbActionListener.aidl
View File

@@ -1,34 +0,0 @@
/*
* 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;
/**
* Callback class for receiving events from MountService about
* Opaque Binary Blobs (OBBs).
*
* @hide - Applications should use android.os.storage.StorageManager
* to interact with OBBs.
*/
interface IObbActionListener {
/**
* Return from an OBB action result.
*
* @param filename the path to the OBB the operation was performed on
* @param returnCode status of the operation
*/
void onObbResult(String filename, String status);
}

130
core/java/android/os/storage/IObbActionListener.java Normal file
View File

@@ -0,0 +1,130 @@
/*
* 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;
/**
* Callback class for receiving events from MountService about Opaque Binary
* Blobs (OBBs).
*
* @hide - Applications should use StorageManager to interact with OBBs.
*/
public interface IObbActionListener extends IInterface {
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends Binder implements IObbActionListener {
private static final String DESCRIPTOR = "IObbActionListener";
/** Construct the stub at attach it to the interface. */
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an IObbActionListener interface,
* generating a proxy if needed.
*/
public static IObbActionListener asInterface(IBinder obj) {
if ((obj == null)) {
return null;
}
IInterface iin = (IInterface) obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof IObbActionListener))) {
return ((IObbActionListener) iin);
}
return new IObbActionListener.Stub.Proxy(obj);
}
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_onObbResult: {
data.enforceInterface(DESCRIPTOR);
String filename;
filename = data.readString();
String status;
status = data.readString();
this.onObbResult(filename, status);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements IObbActionListener {
private IBinder mRemote;
Proxy(IBinder remote) {
mRemote = remote;
}
public IBinder asBinder() {
return mRemote;
}
public String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* Return from an OBB action result.
*
* @param filename the path to the OBB the operation was performed
* on
* @param returnCode status of the operation
*/
public void onObbResult(String filename, String status) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(filename);
_data.writeString(status);
mRemote.transact(Stub.TRANSACTION_onObbResult, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_onObbResult = (IBinder.FIRST_CALL_TRANSACTION + 0);
}
/**
* Return from an OBB action result.
*
* @param filename the path to the OBB the operation was performed on
* @param returnCode status of the operation
*/
public void onObbResult(String filename, String status) throws RemoteException;
}