Reorganize MountService IPC (be857d42) · Commits · e / os / android_frameworks_base

Android.mk

+0 −4

Original line number	Diff line number	Diff line
		@@ -118,10 +118,6 @@ LOCAL_SRC_FILES += \
		core/java/android/net/IThrottleManager.aidl \
		core/java/android/os/IHardwareService.aidl \
		core/java/android/os/IMessenger.aidl \
		core/java/android/os/storage/IMountService.aidl \
		core/java/android/os/storage/IMountServiceListener.aidl \
		core/java/android/os/storage/IMountShutdownObserver.aidl \
		core/java/android/os/storage/IObbActionListener.aidl \
		core/java/android/os/INetworkManagementService.aidl \
		core/java/android/os/INetStatService.aidl \
		core/java/android/os/IPermissionController.aidl \

CleanSpec.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -67,6 +67,7 @@ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libequalizerte
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libreverb_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libreverbtest_intermediates)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/soundfx/)
		$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/framework_intermediates/src/core/java/android/os/storage/*)

		# ************************************************
		# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST

core/java/android/os/storage/IMountService.aidl

deleted100644 → 0

+0 −184

Original line number	Diff line number	Diff line
		/* //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);
		}

core/java/android/os/storage/IMountService.java

0 → 100644

+1046 −0

File added.

Preview size limit exceeded, changes collapsed.

core/java/android/os/storage/IMountServiceListener.java

0 → 100644

+176 −0

Original line number	Diff line number	Diff line
		/*
		* 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;
		}