From b104340496e3a531e26c8f428c808eca0e039f50 Mon Sep 17 00:00:00 2001 From: San Mehat Date: Fri, 5 Feb 2010 08:26:50 -0800 Subject: [PATCH] Framework: Clean up / Refactor Mount APIs - Move android.storage.* -> android.os.storage.* and refactor users - Refactor generic shares back to explicit ums enable/disable/isEnabled - Remove media insert/removed event callbacks (not ready for Froyo) - Remove 'label' from volume state change callbacks - Add public API functions for enabling/disabling USB mass storage (permissions enforced in MountSevice) - Remove some stray un-needed import lines - Move android.os.IMountService / android.os.IMountServiceListener -> android.os.storage - Improve code comments Updated: MountService: Add dup state check and move debugging behind a conditional UsbStorageActivity: Fix review comments + a TODO StorageNotification: Add @Override tags StorageManager: Don't use a static Listener list MountService: Reduce bloat and fix == where I meant .equals() PackageManagerTests: Update for new API Signed-off-by: San Mehat --- Android.mk | 4 +- api/current.xml | 332 +++++++++++------- core/java/android/app/ContextImpl.java | 2 +- core/java/android/content/Context.java | 6 +- core/java/android/os/Environment.java | 2 +- .../android/os/IMountServiceListener.aidl | 66 ---- .../java/android/os/MountServiceListener.java | 69 ---- core/java/android/os/Power.java | 2 +- .../os/{ => storage}/IMountService.aidl | 31 +- .../os/storage/IMountServiceListener.aidl | 43 +++ .../os/storage/MountServiceListener.java | 44 +++ .../os/storage/StorageEventListener.java | 38 ++ .../android/os/storage/StorageManager.java | 297 ++++++++++++++++ .../StorageResultCode.java} | 40 ++- .../android/storage/StorageEventListener.java | 57 --- core/java/android/storage/StorageManager.java | 304 ---------------- .../app/ExternalMediaFormatActivity.java | 2 +- .../internal/app/NetInitiatedActivity.java | 1 - .../android/internal/app/ShutdownThread.java | 2 +- .../internal/app/StorageNotification.java | 177 ++++++---- .../android/internal/app/TetherActivity.java | 1 - .../internal/app/UsbStorageActivity.java | 93 ++--- .../defcontainer/DefaultContainerService.java | 12 +- .../java/com/android/server/MountService.java | 237 ++++++------- .../server/NotificationManagerService.java | 2 +- .../android/server/PackageManagerService.java | 16 +- .../android/server/PowerManagerService.java | 2 +- .../unit_tests/PackageManagerTests.java | 10 +- 28 files changed, 961 insertions(+), 931 deletions(-) delete mode 100644 core/java/android/os/IMountServiceListener.aidl delete mode 100644 core/java/android/os/MountServiceListener.java rename core/java/android/os/{ => storage}/IMountService.aidl (82%) create mode 100644 core/java/android/os/storage/IMountServiceListener.aidl create mode 100644 core/java/android/os/storage/MountServiceListener.java create mode 100644 core/java/android/os/storage/StorageEventListener.java create mode 100644 core/java/android/os/storage/StorageManager.java rename core/java/android/os/{MountServiceResultCode.java => storage/StorageResultCode.java} (57%) delete mode 100644 core/java/android/storage/StorageEventListener.java delete mode 100644 core/java/android/storage/StorageManager.java diff --git a/Android.mk b/Android.mk index ab1e7ea0ea12d..ec6f96b2ac2d4 100644 --- a/Android.mk +++ b/Android.mk @@ -111,8 +111,8 @@ LOCAL_SRC_FILES += \ core/java/android/net/INetworkManagementEventObserver.aidl \ core/java/android/os/ICheckinService.aidl \ core/java/android/os/IMessenger.aidl \ - core/java/android/os/IMountService.aidl \ - core/java/android/os/IMountServiceListener.aidl \ + core/java/android/os/storage/IMountService.aidl \ + core/java/android/os/storage/IMountServiceListener.aidl \ core/java/android/os/INetworkManagementService.aidl \ core/java/android/os/INetStatService.aidl \ core/java/android/os/IParentalControlCallback.aidl \ diff --git a/api/current.xml b/api/current.xml index e673f0fc77c6d..b155c4565241f 100644 --- a/api/current.xml +++ b/api/current.xml @@ -117646,6 +117646,218 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - mListeners = new ArrayList(); + + private class MountServiceBinderListener extends IMountServiceListener.Stub { + public void onUsbMassStorageConnectionChanged(boolean available) { + final int size = mListeners.size(); + for (int i = 0; i < size; i++) { + mListeners.get(i).sendShareAvailabilityChanged(available); + } + } + + public void onStorageStateChanged(String path, String oldState, String newState) { + final int size = mListeners.size(); + for (int i = 0; i < size; i++) { + mListeners.get(i).sendStorageStateChanged(path, oldState, newState); + } + } + } + + /** + * Private base class for messages sent between the callback thread + * and the target looper handler. + */ + private class StorageEvent { + public static final int EVENT_UMS_CONNECTION_CHANGED = 1; + public static final int EVENT_STORAGE_STATE_CHANGED = 2; + + private Message mMessage; + + public StorageEvent(int what) { + mMessage = Message.obtain(); + mMessage.what = what; + mMessage.obj = this; + } + + public Message getMessage() { + return mMessage; + } + } + + /** + * Message sent on a USB mass storage connection change. + */ + private class UmsConnectionChangedStorageEvent extends StorageEvent { + public boolean available; + + public UmsConnectionChangedStorageEvent(boolean a) { + super(EVENT_UMS_CONNECTION_CHANGED); + available = a; + } + } + + /** + * Message sent on volume state change. + */ + private class StorageStateChangedStorageEvent extends StorageEvent { + public String path; + public String oldState; + public String newState; + + public StorageStateChangedStorageEvent(String p, String oldS, String newS) { + super(EVENT_STORAGE_STATE_CHANGED); + path = p; + oldState = oldS; + newState = newS; + } + } + + /** + * Private class containing sender and receiver code for StorageEvents. + */ + private class ListenerDelegate { + final StorageEventListener mStorageEventListener; + private final Handler mHandler; + + ListenerDelegate(StorageEventListener listener) { + mStorageEventListener = listener; + mHandler = new Handler(mTgtLooper) { + @Override + public void handleMessage(Message msg) { + StorageEvent e = (StorageEvent) msg.obj; + + if (msg.what == StorageEvent.EVENT_UMS_CONNECTION_CHANGED) { + UmsConnectionChangedStorageEvent ev = (UmsConnectionChangedStorageEvent) e; + mStorageEventListener.onUsbMassStorageConnectionChanged(ev.available); + } else if (msg.what == StorageEvent.EVENT_STORAGE_STATE_CHANGED) { + StorageStateChangedStorageEvent ev = (StorageStateChangedStorageEvent) e; + mStorageEventListener.onStorageStateChanged(ev.path, ev.oldState, ev.newState); + } else { + Log.e(TAG, "Unsupported event " + msg.what); + } + } + }; + } + + StorageEventListener getListener() { + return mStorageEventListener; + } + + void sendShareAvailabilityChanged(boolean available) { + UmsConnectionChangedStorageEvent e = new UmsConnectionChangedStorageEvent(available); + mHandler.sendMessage(e.getMessage()); + } + + void sendStorageStateChanged(String path, String oldState, String newState) { + StorageStateChangedStorageEvent e = new StorageStateChangedStorageEvent(path, oldState, newState); + mHandler.sendMessage(e.getMessage()); + } + } + + /** + * Constructs a StorageManager object through which an application can + * can communicate with the systems mount service. + * + * @param tgtLooper The {@android.os.Looper} which events will be received on. + * + *

Applications can get instance of this class by calling + * {@link android.content.Context#getSystemService(java.lang.String)} with an argument + * of {@link android.content.Context#STORAGE_SERVICE}. + * + * @hide + */ + public StorageManager(Looper tgtLooper) throws RemoteException { + mMountService = IMountService.Stub.asInterface(ServiceManager.getService("mount")); + if (mMountService == null) { + Log.e(TAG, "Unable to connect to mount service! - is it running yet?"); + return; + } + mTgtLooper = tgtLooper; + mBinderListener = new MountServiceBinderListener(); + mMountService.registerListener(mBinderListener); + } + + + /** + * Registers a {@link android.os.storage.StorageEventListener StorageEventListener}. + * + * @param listener A {@link android.os.storage.StorageEventListener StorageEventListener} object. + * + */ + public void registerListener(StorageEventListener listener) { + if (listener == null) { + return; + } + + synchronized (mListeners) { + mListeners.add(new ListenerDelegate(listener)); + } + } + + /** + * Unregisters a {@link android.os.storage.StorageEventListener StorageEventListener}. + * + * @param listener A {@link android.os.storage.StorageEventListener StorageEventListener} object. + * + */ + public void unregisterListener(StorageEventListener listener) { + if (listener == null) { + return; + } + + synchronized (mListeners) { + final int size = mListeners.size(); + for (int i=0 ; i sListeners = new ArrayList(); - - private class MountServiceBinderListener extends IMountServiceListener.Stub { - public void onShareAvailabilityChanged(String method, boolean available) { - final int size = sListeners.size(); - for (int i = 0; i < size; i++) { - sListeners.get(i).sendShareAvailabilityChanged(method, available); - } - } - - public void onMediaInserted(String label, String path, int major, int minor) { - final int size = sListeners.size(); - for (int i = 0; i < size; i++) { - sListeners.get(i).sendMediaInserted(label, path, major, minor); - } - } - - public void onMediaRemoved(String label, String path, int major, int minor, boolean clean) { - final int size = sListeners.size(); - for (int i = 0; i < size; i++) { - sListeners.get(i).sendMediaRemoved(label, path, major, minor, clean); - } - } - - public void onVolumeStateChanged(String label, String path, String oldState, String newState) { - final int size = sListeners.size(); - for (int i = 0; i < size; i++) { - sListeners.get(i).sendVolumeStateChanged(label, path, oldState, newState); - } - } - } - - /** - * Private base class for messages sent between the callback thread - * and the target looper handler - */ - private class StorageEvent { - public static final int EVENT_SHARE_AVAILABILITY_CHANGED = 1; - public static final int EVENT_MEDIA_INSERTED = 2; - public static final int EVENT_MEDIA_REMOVED = 3; - public static final int EVENT_VOLUME_STATE_CHANGED = 4; - - private Message mMessage; - - public StorageEvent(int what) { - mMessage = Message.obtain(); - mMessage.what = what; - mMessage.obj = this; - } - - public Message getMessage() { - return mMessage; - } - } - - /** - * Message sent on a share availability change. - */ - private class ShareAvailabilityChangedStorageEvent extends StorageEvent { - public String method; - public boolean available; - - public ShareAvailabilityChangedStorageEvent(String m, boolean a) { - super(EVENT_SHARE_AVAILABILITY_CHANGED); - method = m; - available = a; - } - } - - /** - * Message sent on media insertion - */ - private class MediaInsertedStorageEvent extends StorageEvent { - public String label; - public String path; - public int major; - public int minor; - - public MediaInsertedStorageEvent(String l, String p, int maj, int min) { - super(EVENT_MEDIA_INSERTED); - label = l; - path = p; - major = maj; - minor = min; - } - } - - /** - * Message sent on media removal - */ - private class MediaRemovedStorageEvent extends StorageEvent { - public String label; - public String path; - public int major; - public int minor; - public boolean clean; - - public MediaRemovedStorageEvent(String l, String p, int maj, int min, boolean c) { - super(EVENT_MEDIA_REMOVED); - label = l; - path = p; - major = maj; - minor = min; - clean = c; - } - } - - /** - * Message sent on volume state change - */ - private class VolumeStateChangedStorageEvent extends StorageEvent { - public String label; - public String path; - public String oldState; - public String newState; - - public VolumeStateChangedStorageEvent(String l, String p, String oldS, String newS) { - super(EVENT_VOLUME_STATE_CHANGED); - label = l; - path = p; - oldState = oldS; - newState = newS; - } - } - - /** - * Private class containing sender and receiver code for StorageEvents - */ - private class ListenerDelegate { - final StorageEventListener mStorageEventListener; - private final Handler mHandler; - - ListenerDelegate(StorageEventListener listener) { - mStorageEventListener = listener; - mHandler = new Handler(mTgtLooper) { - @Override - public void handleMessage(Message msg) { - StorageEvent e = (StorageEvent) msg.obj; - - if (msg.what == StorageEvent.EVENT_SHARE_AVAILABILITY_CHANGED) { - ShareAvailabilityChangedStorageEvent ev = (ShareAvailabilityChangedStorageEvent) e; - mStorageEventListener.onShareAvailabilityChanged(ev.method, ev.available); - } else if (msg.what == StorageEvent.EVENT_MEDIA_INSERTED) { - MediaInsertedStorageEvent ev = (MediaInsertedStorageEvent) e; - mStorageEventListener.onMediaInserted(ev.label, ev.path, ev.major, ev.minor); - } else if (msg.what == StorageEvent.EVENT_MEDIA_REMOVED) { - MediaRemovedStorageEvent ev = (MediaRemovedStorageEvent) e; - mStorageEventListener.onMediaRemoved(ev.label, ev.path, ev.major, ev.minor, ev.clean); - } else if (msg.what == StorageEvent.EVENT_VOLUME_STATE_CHANGED) { - VolumeStateChangedStorageEvent ev = (VolumeStateChangedStorageEvent) e; - mStorageEventListener.onVolumeStateChanged(ev.label, ev.path, ev.oldState, ev.newState); - } else { - Log.e(TAG, "Unsupported event " + msg.what); - } - } - }; - } - - StorageEventListener getListener() { - return mStorageEventListener; - } - - void sendShareAvailabilityChanged(String method, boolean available) { - ShareAvailabilityChangedStorageEvent e = new ShareAvailabilityChangedStorageEvent(method, available); - mHandler.sendMessage(e.getMessage()); - } - - void sendMediaInserted(String label, String path, int major, int minor) { - MediaInsertedStorageEvent e = new MediaInsertedStorageEvent(label, path, major, minor); - mHandler.sendMessage(e.getMessage()); - } - - void sendMediaRemoved(String label, String path, int major, int minor, boolean clean) { - MediaRemovedStorageEvent e = new MediaRemovedStorageEvent(label, path, major, minor, clean); - mHandler.sendMessage(e.getMessage()); - } - - void sendVolumeStateChanged(String label, String path, String oldState, String newState) { - VolumeStateChangedStorageEvent e = new VolumeStateChangedStorageEvent(label, path, oldState, newState); - mHandler.sendMessage(e.getMessage()); - } - } - - /** - * {@hide} - */ - public StorageManager(Looper tgtLooper) throws RemoteException { - mMountService = IMountService.Stub.asInterface(ServiceManager.getService("mount")); - if (mMountService == null) { - Log.e(TAG, "Unable to connect to mount service! - is it running yet?"); - return; - } - mTgtLooper = tgtLooper; - mBinderListener = new MountServiceBinderListener(); - mMountService.registerListener(mBinderListener); - } - - - /** - * Registers a {@link android.storage.StorageEventListener StorageEventListener}. - * - * @param listener A {@link android.storage.StorageEventListener StorageEventListener} object. - * - */ - public void registerListener(StorageEventListener listener) { - if (listener == null) { - return; - } - - synchronized (sListeners) { - sListeners.add(new ListenerDelegate(listener)); - } - } - - /** - * Unregisters a {@link android.storage.StorageEventListener StorageEventListener}. - * - * @param listener A {@link android.storage.StorageEventListener StorageEventListener} object. - * - */ - public void unregisterListener(StorageEventListener listener) { - if (listener == null) { - return; - } - synchronized (sListeners) { - final int size = sListeners.size(); - for (int i=0 ; i * This is lazily created, so use {@link #setMediaStorageNotification()}. */ - private Notification mMediaStorageNotification; - - private boolean mShowSafeUnmountNotificationWhenUnmounted; - private boolean mUmsAvailable; - private IMountService mMountService; // XXX: This should go away soon + private Notification mMediaStorageNotification; + private boolean mUmsAvailable; + private StorageManager mStorageManager; public StorageNotification(Context context) { mContext = context; - /* - * XXX: This needs to be exposed via StorageManager - */ - mMountService = IMountService.Stub.asInterface(ServiceManager.getService("mount")); - try { - mUmsAvailable = mMountService.getShareMethodAvailable("ums"); - } catch (Exception e) { - Log.e(TAG, "Failed to get ums availability", e); - } + mStorageManager = (StorageManager) context.getSystemService(Context.STORAGE_SERVICE); + mUmsAvailable = mStorageManager.isUsbMassStorageConnected(); + Log.d(TAG, String.format( "Startup with UMS connection %s (media state %s)", mUmsAvailable, + Environment.getExternalStorageState())); } - public void onShareAvailabilityChanged(String method, boolean available) { - if (method.equals("ums")) { - mUmsAvailable = available; + /* + * @override com.android.os.storage.StorageEventListener + */ + @Override + public void onUsbMassStorageConnectionChanged(boolean connected) { + mUmsAvailable = connected; + /* + * Even though we may have a UMS host connected, we the SD card + * may not be in a state for export. + */ + String st = Environment.getExternalStorageState(); + + Log.i(TAG, String.format("UMS connection changed to %s (media state %s)", connected, st)); + + if (connected && (st.equals( + Environment.MEDIA_REMOVED) || st.equals(Environment.MEDIA_CHECKING))) { /* - * Even though we may have a UMS host connected, we the SD card - * may not be in a state for export. + * No card or card being checked = don't display */ - String st = Environment.getExternalStorageState(); - if (available && (st.equals( - Environment.MEDIA_REMOVED) || st.equals(Environment.MEDIA_CHECKING))) { - /* - * No card or card being checked = don't display - */ - available = false; - } - - updateUsbMassStorageNotification(available); + connected = false; } + updateUsbMassStorageNotification(connected); } - public void onMediaInserted(String label, String path, int major, int minor) { - } - - public void onMediaRemoved(String label, String path, int major, int minor, boolean clean) { - /* - * Media removed - first clear the USB storage notification (if any) - */ - updateUsbMassStorageNotification(false); - - if (clean) { - setMediaStorageNotification( - com.android.internal.R.string.ext_media_nomedia_notification_title, - com.android.internal.R.string.ext_media_nomedia_notification_message, - com.android.internal.R.drawable.stat_notify_sdcard_usb, - true, false, null); - } else { - setMediaStorageNotification( - com.android.internal.R.string.ext_media_badremoval_notification_title, - com.android.internal.R.string.ext_media_badremoval_notification_message, - com.android.internal.R.drawable.stat_sys_warning, - true, true, null); - } - } - - public void onVolumeStateChanged(String label, String path, String oldState, String newState) { + /* + * @override com.android.os.storage.StorageEventListener + */ + @Override + public void onStorageStateChanged(String path, String oldState, String newState) { + Log.i(TAG, String.format( + "Media {%s} state changed from {%s} -> {%s}", path, oldState, newState)); if (newState.equals(Environment.MEDIA_SHARED)) { + /* + * Storage is now shared. Modify the UMS notification + * for stopping UMS. + */ Intent intent = new Intent(); intent.setClass(mContext, com.android.internal.app.UsbStorageActivity.class); PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); @@ -143,26 +126,60 @@ public class StorageNotification implements StorageEventListener { com.android.internal.R.string.usb_storage_stop_notification_message, com.android.internal.R.drawable.stat_sys_warning, false, true, pi); } else if (newState.equals(Environment.MEDIA_CHECKING)) { + /* + * Storage is now checking. Update media notification and disable + * UMS notification. + */ setMediaStorageNotification( com.android.internal.R.string.ext_media_checking_notification_title, com.android.internal.R.string.ext_media_checking_notification_message, com.android.internal.R.drawable.stat_notify_sdcard_prepare, true, false, null); updateUsbMassStorageNotification(false); } else if (newState.equals(Environment.MEDIA_MOUNTED)) { + /* + * Storage is now mounted. Dismiss any media notifications, + * and enable UMS notification if connected. + */ setMediaStorageNotification(0, 0, 0, false, false, null); updateUsbMassStorageNotification(mUmsAvailable); } else if (newState.equals(Environment.MEDIA_UNMOUNTED)) { - if (mShowSafeUnmountNotificationWhenUnmounted) { - setMediaStorageNotification( - com.android.internal.R.string.ext_media_safe_unmount_notification_title, - com.android.internal.R.string.ext_media_safe_unmount_notification_message, - com.android.internal.R.drawable.stat_notify_sdcard, true, true, null); - mShowSafeUnmountNotificationWhenUnmounted = false; + /* + * Storage is now unmounted. We may have been unmounted + * because the user is enabling/disabling UMS, in which case we don't + * want to display the 'safe to unmount' notification. + */ + if (!mStorageManager.isUsbMassStorageEnabled()) { + if (oldState.equals(Environment.MEDIA_SHARED)) { + /* + * The unmount was due to UMS being enabled. Dismiss any + * media notifications, and enable UMS notification if connected + */ + setMediaStorageNotification(0, 0, 0, false, false, null); + updateUsbMassStorageNotification(mUmsAvailable); + } else { + /* + * Show safe to unmount media notification, and enable UMS + * notification if connected. + */ + setMediaStorageNotification( + com.android.internal.R.string.ext_media_safe_unmount_notification_title, + com.android.internal.R.string.ext_media_safe_unmount_notification_message, + com.android.internal.R.drawable.stat_notify_sdcard, true, true, null); + updateUsbMassStorageNotification(mUmsAvailable); + } } else { + /* + * The unmount was due to UMS being enabled. Dismiss any + * media notifications, and disable the UMS notification + */ setMediaStorageNotification(0, 0, 0, false, false, null); + updateUsbMassStorageNotification(false); } - updateUsbMassStorageNotification(mUmsAvailable); } else if (newState.equals(Environment.MEDIA_NOFS)) { + /* + * Storage has no filesystem. Show blank media notification, + * and enable UMS notification if connected. + */ Intent intent = new Intent(); intent.setClass(mContext, com.android.internal.app.ExternalMediaFormatActivity.class); PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); @@ -173,6 +190,10 @@ public class StorageNotification implements StorageEventListener { com.android.internal.R.drawable.stat_notify_sdcard_usb, true, false, pi); updateUsbMassStorageNotification(mUmsAvailable); } else if (newState.equals(Environment.MEDIA_UNMOUNTABLE)) { + /* + * Storage is corrupt. Show corrupt media notification, + * and enable UMS notification if connected. + */ Intent intent = new Intent(); intent.setClass(mContext, com.android.internal.app.ExternalMediaFormatActivity.class); PendingIntent pi = PendingIntent.getActivity(mContext, 0, intent, 0); @@ -182,6 +203,30 @@ public class StorageNotification implements StorageEventListener { com.android.internal.R.string.ext_media_unmountable_notification_message, com.android.internal.R.drawable.stat_notify_sdcard_usb, true, false, pi); updateUsbMassStorageNotification(mUmsAvailable); + } else if (newState.equals(Environment.MEDIA_REMOVED)) { + /* + * Storage has been removed. Show nomedia media notification, + * and disable UMS notification regardless of connection state. + */ + setMediaStorageNotification( + com.android.internal.R.string.ext_media_nomedia_notification_title, + com.android.internal.R.string.ext_media_nomedia_notification_message, + com.android.internal.R.drawable.stat_notify_sdcard_usb, + true, false, null); + updateUsbMassStorageNotification(false); + } else if (newState.equals(Environment.MEDIA_BAD_REMOVAL)) { + /* + * Storage has been removed unsafely. Show bad removal media notification, + * and disable UMS notification regardless of connection state. + */ + setMediaStorageNotification( + com.android.internal.R.string.ext_media_badremoval_notification_title, + com.android.internal.R.string.ext_media_badremoval_notification_message, + com.android.internal.R.drawable.stat_sys_warning, + true, true, null); + updateUsbMassStorageNotification(false); + } else { + Log.w(TAG, String.format("Ignoring unknown state {%s}", newState)); } } diff --git a/core/java/com/android/internal/app/TetherActivity.java b/core/java/com/android/internal/app/TetherActivity.java index 2b93dbc8c082e..cb268b378883f 100644 --- a/core/java/com/android/internal/app/TetherActivity.java +++ b/core/java/com/android/internal/app/TetherActivity.java @@ -25,7 +25,6 @@ import android.content.IntentFilter; import android.net.ConnectivityManager; import android.os.Bundle; import android.os.Handler; -import android.os.IMountService; import android.os.Message; import android.os.RemoteException; import android.os.ServiceManager; diff --git a/core/java/com/android/internal/app/UsbStorageActivity.java b/core/java/com/android/internal/app/UsbStorageActivity.java index 34ae2b4acd102..991f04b5c4704 100644 --- a/core/java/com/android/internal/app/UsbStorageActivity.java +++ b/core/java/com/android/internal/app/UsbStorageActivity.java @@ -25,8 +25,9 @@ import android.content.IntentFilter; import android.os.Bundle; import android.os.Handler; import android.os.Environment; -import android.os.IMountService; -import android.os.MountServiceResultCode; +import android.os.storage.StorageManager; +import android.os.storage.StorageEventListener; +import android.os.storage.StorageResultCode; import android.os.Message; import android.os.RemoteException; import android.os.ServiceManager; @@ -35,6 +36,7 @@ import android.widget.Button; import android.widget.TextView; import android.widget.Toast; import android.view.View; +import android.util.Log; /** * This activity is shown to the user for him/her to enable USB mass storage @@ -42,11 +44,13 @@ import android.view.View; * dialog style. It will be launched from a notification. */ public class UsbStorageActivity extends Activity { + private static final String TAG = "UsbStorageActivity"; private Button mMountButton; private Button mUnmountButton; private TextView mBanner; private TextView mMessage; private ImageView mIcon; + private StorageManager mStorageManager = null; /** Used to detect when the USB cable is unplugged, so we can call finish() */ private BroadcastReceiver mBatteryReceiver = new BroadcastReceiver() { @@ -57,11 +61,30 @@ public class UsbStorageActivity extends Activity { } } }; + + private StorageEventListener mStorageListener = new StorageEventListener() { + @Override + public void onStorageStateChanged(String path, String oldState, String newState) { + if (newState.equals(Environment.MEDIA_SHARED)) { + switchDisplay(true); + } else { + switchDisplay(false); + } + } + }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); + if (mStorageManager == null) { + mStorageManager = (StorageManager) getSystemService(Context.STORAGE_SERVICE); + if (mStorageManager == null) { + Log.w(TAG, "Failed to get StorageManager"); + } + mStorageManager.registerListener(mStorageListener); + } + setTitle(getString(com.android.internal.R.string.usb_storage_activity_title)); setContentView(com.android.internal.R.layout.usb_storage_activity); @@ -74,9 +97,11 @@ public class UsbStorageActivity extends Activity { mMountButton.setOnClickListener( new View.OnClickListener() { public void onClick(View v) { - mountAsUsbStorage(); - // TODO: replace with forthcoming MountService callbacks - switchDisplay(true); + int rc = mStorageManager.enableUsbMassStorage(); + if (rc != StorageResultCode.OperationSucceeded) { + Log.e(TAG, String.format("UMS enable failed (%d)", rc)); + showSharingError(); + } } }); @@ -84,9 +109,11 @@ public class UsbStorageActivity extends Activity { mUnmountButton.setOnClickListener( new View.OnClickListener() { public void onClick(View v) { - stopUsbStorage(); - // TODO: replace with forthcoming MountService callbacks - switchDisplay(false); + int rc = mStorageManager.disableUsbMassStorage(); + if (rc != StorageResultCode.OperationSucceeded) { + Log.e(TAG, String.format("UMS disable failed (%d)", rc)); + showStoppingError(); + } } }); } @@ -112,19 +139,11 @@ public class UsbStorageActivity extends Activity { super.onResume(); registerReceiver(mBatteryReceiver, new IntentFilter(Intent.ACTION_BATTERY_CHANGED)); - - boolean umsOn = false; try { - IMountService mountService = IMountService.Stub.asInterface(ServiceManager - .getService("mount")); - if (mountService != null) { - umsOn = mountService.getVolumeShared( - Environment.getExternalStorageDirectory().getPath(), "ums"); - } - } catch (android.os.RemoteException exc) { - // pass + switchDisplay(mStorageManager.isUsbMassStorageEnabled()); + } catch (Exception ex) { + Log.e(TAG, "Failed to read UMS enable state", ex); } - switchDisplay(umsOn); } @Override @@ -134,42 +153,6 @@ public class UsbStorageActivity extends Activity { unregisterReceiver(mBatteryReceiver); } - private void mountAsUsbStorage() { - IMountService mountService = IMountService.Stub.asInterface(ServiceManager - .getService("mount")); - if (mountService == null) { - showSharingError(); - return; - } - - try { - if (mountService.shareVolume( - Environment.getExternalStorageDirectory().getPath(), "ums") != - MountServiceResultCode.OperationSucceeded) { - showSharingError(); - } - } catch (RemoteException e) { - showSharingError(); - } - } - - private void stopUsbStorage() { - IMountService mountService = IMountService.Stub.asInterface(ServiceManager - .getService("mount")); - if (mountService == null) { - showStoppingError(); - return; - } - - try { - mountService.unshareVolume( - Environment.getExternalStorageDirectory().getPath(), "ums"); - } catch (RemoteException e) { - showStoppingError(); - return; - } - } - private void handleBatteryChanged(Intent intent) { int pluggedType = intent.getIntExtra("plugged", 0); if (pluggedType == 0) { diff --git a/packages/DefaultContainerService/src/com/android/defcontainer/DefaultContainerService.java b/packages/DefaultContainerService/src/com/android/defcontainer/DefaultContainerService.java index d23b7d09e3400..fecd3662b9232 100644 --- a/packages/DefaultContainerService/src/com/android/defcontainer/DefaultContainerService.java +++ b/packages/DefaultContainerService/src/com/android/defcontainer/DefaultContainerService.java @@ -6,8 +6,8 @@ import android.content.Intent; import android.net.Uri; import android.os.Debug; import android.os.IBinder; -import android.os.IMountService; -import android.os.MountServiceResultCode; +import android.os.storage.IMountService; +import android.os.storage.StorageResultCode; import android.os.ParcelFileDescriptor; import android.os.Process; import android.os.RemoteException; @@ -158,12 +158,12 @@ public class DefaultContainerService extends Service { int rc = mountService.createSecureContainer( containerId, mbLen, "vfat", sdEncKey, ownerUid); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.e(TAG, String.format("Container creation failed (%d)", rc)); // XXX: This destroy should not be necessary rc = mountService.destroySecureContainer(containerId); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.e(TAG, String.format("Container creation-cleanup failed (%d)", rc)); return null; } @@ -171,7 +171,7 @@ public class DefaultContainerService extends Service { // XXX: Does this ever actually succeed? rc = mountService.createSecureContainer( containerId, mbLen, "vfat", sdEncKey, ownerUid); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.e(TAG, String.format("Container creation retry failed (%d)", rc)); } } @@ -226,7 +226,7 @@ public class DefaultContainerService extends Service { private String mountSdDir(String containerId, String key) { try { int rc = getMountService().mountSecureContainer(containerId, key, Process.myUid()); - if (rc == MountServiceResultCode.OperationSucceeded) { + if (rc == StorageResultCode.OperationSucceeded) { return getMountService().getSecureContainerPath(containerId); } else { Log.e(TAG, String.format("Failed to mount id %s with rc %d ", containerId, rc)); diff --git a/services/java/com/android/server/MountService.java b/services/java/com/android/server/MountService.java index 0e44858f29955..6de2effe388ed 100644 --- a/services/java/com/android/server/MountService.java +++ b/services/java/com/android/server/MountService.java @@ -23,9 +23,9 @@ import android.content.IntentFilter; import android.content.pm.PackageManager; import android.content.res.Resources; import android.net.Uri; -import android.os.IMountService; -import android.os.IMountServiceListener; -import android.os.MountServiceResultCode; +import android.os.storage.IMountService; +import android.os.storage.IMountServiceListener; +import android.os.storage.StorageResultCode; import android.os.RemoteException; import android.os.IBinder; import android.os.Environment; @@ -42,11 +42,14 @@ import java.io.File; import java.io.FileReader; /** - * MountService implements an to the mount service daemon - * @hide + * MountService implements back-end services for platform storage + * management. + * @hide - Applications should use android.os.storage.StorageManager + * to access the MountService. */ class MountService extends IMountService.Stub implements INativeDaemonConnectorCallbacks { + private static final boolean LOCAL_LOGD = false; private static final String TAG = "MountService"; @@ -135,7 +138,7 @@ class MountService extends IMountService.Stub String path = Environment.getExternalStorageDirectory().getPath(); if (getVolumeState(path).equals(Environment.MEDIA_UNMOUNTED)) { int rc = doMountVolume(path); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.e(TAG, String.format("Boot-time mount failed (%d)", rc)); } } @@ -152,7 +155,7 @@ class MountService extends IMountService.Stub } public void binderDied() { - Log.d(TAG, "An IMountServiceListener has died!"); + if (LOCAL_LOGD) Log.d(TAG, "An IMountServiceListener has died!"); synchronized(mListeners) { mListeners.remove(this); mListener.asBinder().unlinkToDeath(this, 0); @@ -173,9 +176,9 @@ class MountService extends IMountService.Stub */ String vs = getVolumeState(path); if (enable && vs.equals(Environment.MEDIA_MOUNTED)) { - mUmsEnabling = enable; // Supress unmounted events + mUmsEnabling = enable; // Override for isUsbMassStorageEnabled() doUnmountVolume(path); - mUmsEnabling = false; // Unsupress unmounted events + mUmsEnabling = false; // Clear override } try { @@ -183,14 +186,14 @@ class MountService extends IMountService.Stub "volume %sshare %s %s", (enable ? "" : "un"), path, method)); } catch (NativeDaemonConnectorException e) { Log.e(TAG, "Failed to share/unshare", e); - return MountServiceResultCode.OperationFailedInternalError; + return StorageResultCode.OperationFailedInternalError; } /* * If we disabled UMS then mount the volume */ if (!enable) { - if (doMountVolume(path) != MountServiceResultCode.OperationSucceeded) { + if (doMountVolume(path) != StorageResultCode.OperationSucceeded) { Log.e(TAG, String.format( "Failed to remount %s after disabling share method %s", path, method)); /* @@ -201,7 +204,7 @@ class MountService extends IMountService.Stub } } - return MountServiceResultCode.OperationSucceeded; + return StorageResultCode.OperationSucceeded; } private void updatePublicVolumeState(String path, String state) { @@ -209,7 +212,11 @@ class MountService extends IMountService.Stub Log.w(TAG, "Multiple volumes not currently supported"); return; } - Log.i(TAG, "State for {" + path + "} = {" + state + "}"); + + if (mLegacyState.equals(state)) { + Log.w(TAG, String.format("Duplicate state transition (%s -> %s)", mLegacyState, state)); + return; + } String oldState = mLegacyState; mLegacyState = state; @@ -218,7 +225,7 @@ class MountService extends IMountService.Stub for (int i = mListeners.size() -1; i >= 0; i--) { MountServiceBinderListener bl = mListeners.get(i); try { - bl.mListener.onVolumeStateChanged("", path, oldState, state); + bl.mListener.onStorageStateChanged(path, oldState, state); } catch (RemoteException rex) { Log.e(TAG, "Listener dead"); mListeners.remove(i); @@ -296,13 +303,11 @@ class MountService extends IMountService.Stub } /** - * * Callback from NativeDaemonConnector */ public boolean onEvent(int code, String raw, String[] cooked) { Intent in = null; - // Log.d(TAG, "event {" + raw + "}"); if (code == VoldResponseCode.VolumeStateChange) { /* * One of the volumes we're managing has changed state. @@ -339,34 +344,12 @@ class MountService extends IMountService.Stub Log.e(TAG, "Failed to parse major/minor", ex); } - synchronized (mListeners) { - for (int i = mListeners.size() -1; i >= 0; i--) { - MountServiceBinderListener bl = mListeners.get(i); - try { - if (code == VoldResponseCode.VolumeDiskInserted) { - bl.mListener.onMediaInserted(label, path, major, minor); - } else if (code == VoldResponseCode.VolumeDiskRemoved) { - bl.mListener.onMediaRemoved(label, path, major, minor, true); - } else if (code == VoldResponseCode.VolumeBadRemoval) { - bl.mListener.onMediaRemoved(label, path, major, minor, false); - } else { - Log.e(TAG, String.format("Unknown code {%d}", code)); - } - } catch (RemoteException rex) { - Log.e(TAG, "Listener dead"); - mListeners.remove(i); - } catch (Exception ex) { - Log.e(TAG, "Listener failed", ex); - } - } - } - if (code == VoldResponseCode.VolumeDiskInserted) { new Thread() { public void run() { try { int rc; - if ((rc = doMountVolume(path)) != MountServiceResultCode.OperationSucceeded) { + if ((rc = doMountVolume(path)) != StorageResultCode.OperationSucceeded) { Log.w(TAG, String.format("Insertion mount failed (%d)", rc)); } } catch (Exception ex) { @@ -489,7 +472,7 @@ class MountService extends IMountService.Stub } private int doMountVolume(String path) { - int rc = MountServiceResultCode.OperationSucceeded; + int rc = StorageResultCode.OperationSucceeded; try { mConnector.doCommand(String.format("volume mount %s", path)); @@ -503,23 +486,23 @@ class MountService extends IMountService.Stub /* * Attempt to mount but no media inserted */ - rc = MountServiceResultCode.OperationFailedNoMedia; + rc = StorageResultCode.OperationFailedNoMedia; } else if (code == VoldResponseCode.OpFailedMediaBlank) { /* * Media is blank or does not contain a supported filesystem */ updatePublicVolumeState(path, Environment.MEDIA_NOFS); in = new Intent(Intent.ACTION_MEDIA_NOFS, Uri.parse("file://" + path)); - rc = MountServiceResultCode.OperationFailedMediaBlank; + rc = StorageResultCode.OperationFailedMediaBlank; } else if (code == VoldResponseCode.OpFailedMediaCorrupt) { /* * Volume consistency check failed */ updatePublicVolumeState(path, Environment.MEDIA_UNMOUNTABLE); in = new Intent(Intent.ACTION_MEDIA_UNMOUNTABLE, Uri.parse("file://" + path)); - rc = MountServiceResultCode.OperationFailedMediaCorrupt; + rc = StorageResultCode.OperationFailedMediaCorrupt; } else { - rc = MountServiceResultCode.OperationFailedInternalError; + rc = StorageResultCode.OperationFailedInternalError; } /* @@ -544,15 +527,15 @@ class MountService extends IMountService.Stub mPms.updateExternalMediaStatus(false); try { mConnector.doCommand(String.format("volume unmount %s", path)); - return MountServiceResultCode.OperationSucceeded; + return StorageResultCode.OperationSucceeded; } catch (NativeDaemonConnectorException e) { // Don't worry about mismatch in PackageManager since the // call back will handle the status changes any way. int code = e.getCode(); if (code == VoldResponseCode.OpFailedVolNotMounted) { - return MountServiceResultCode.OperationFailedVolumeNotMounted; + return StorageResultCode.OperationFailedVolumeNotMounted; } else { - return MountServiceResultCode.OperationFailedInternalError; + return StorageResultCode.OperationFailedInternalError; } } } @@ -561,19 +544,45 @@ class MountService extends IMountService.Stub try { String cmd = String.format("volume format %s", path); mConnector.doCommand(cmd); - return MountServiceResultCode.OperationSucceeded; + return StorageResultCode.OperationSucceeded; } catch (NativeDaemonConnectorException e) { int code = e.getCode(); if (code == VoldResponseCode.OpFailedNoMedia) { - return MountServiceResultCode.OperationFailedNoMedia; + return StorageResultCode.OperationFailedNoMedia; } else if (code == VoldResponseCode.OpFailedMediaCorrupt) { - return MountServiceResultCode.OperationFailedMediaCorrupt; + return StorageResultCode.OperationFailedMediaCorrupt; } else { - return MountServiceResultCode.OperationFailedInternalError; + return StorageResultCode.OperationFailedInternalError; } } } + private boolean doGetVolumeShared(String path, String method) { + String cmd = String.format("volume shared %s %s", path, method); + ArrayList rsp = mConnector.doCommand(cmd); + + for (String line : rsp) { + String []tok = line.split(" "); + int code; + try { + code = Integer.parseInt(tok[0]); + } catch (NumberFormatException nfe) { + Log.e(TAG, String.format("Error parsing code %s", tok[0])); + return false; + } + if (code == VoldResponseCode.ShareEnabledResult) { + if (tok[2].equals("enabled")) + return true; + return false; + } else { + Log.e(TAG, String.format("Unexpected response code %d", code)); + return false; + } + } + Log.e(TAG, "Got an empty response"); + return false; + } + private void notifyShareAvailabilityChange(String method, final boolean avail) { if (!method.equals("ums")) { Log.w(TAG, "Ignoring unsupported share method {" + method + "}"); @@ -584,7 +593,7 @@ class MountService extends IMountService.Stub for (int i = mListeners.size() -1; i >= 0; i--) { MountServiceBinderListener bl = mListeners.get(i); try { - bl.mListener.onShareAvailabilityChanged(method, avail); + bl.mListener.onUsbMassStorageConnectionChanged(avail); } catch (RemoteException rex) { Log.e(TAG, "Listener dead"); mListeners.remove(i); @@ -685,7 +694,7 @@ class MountService extends IMountService.Stub * the UMS host could have dirty FAT cache entries * yet to flush. */ - if (unshareVolume(path, "ums") != MountServiceResultCode.OperationSucceeded) { + if (setUsbMassStorageEnabled(false) != StorageResultCode.OperationSucceeded) { Log.e(TAG, "UMS disable on shutdown failed"); } } else if (state.equals(Environment.MEDIA_CHECKING)) { @@ -713,58 +722,30 @@ class MountService extends IMountService.Stub /* * If the media is mounted, then gracefully unmount it. */ - if (doUnmountVolume(path) != MountServiceResultCode.OperationSucceeded) { + if (doUnmountVolume(path) != StorageResultCode.OperationSucceeded) { Log.e(TAG, "Failed to unmount media for shutdown"); } } } - public String[] getShareMethodList() { - String[] rdata = new String[1]; - rdata[0] = "ums"; - return rdata; - } - - public boolean getShareMethodAvailable(String method) { + public boolean isUsbMassStorageConnected() { waitForReady(); - return doGetShareMethodAvailable(method); - } - public int shareVolume(String path, String method) { - waitForReady(); - return doShareUnshareVolume(path, method, true); - } - - public int unshareVolume(String path, String method) { - waitForReady(); - return doShareUnshareVolume(path, method, false); - } - - public boolean getVolumeShared(String path, String method) { - waitForReady(); - String cmd = String.format("volume shared %s %s", path, method); - ArrayList rsp = mConnector.doCommand(cmd); - - for (String line : rsp) { - String []tok = line.split(" "); - int code; - try { - code = Integer.parseInt(tok[0]); - } catch (NumberFormatException nfe) { - Log.e(TAG, String.format("Error parsing code %s", tok[0])); - return false; - } - if (code == VoldResponseCode.ShareEnabledResult) { - if (tok[2].equals("enabled")) - return true; - return false; - } else { - Log.e(TAG, String.format("Unexpected response code %d", code)); - return false; - } + if (mUmsEnabling) { + return true; } - Log.e(TAG, "Got an empty response"); - return false; + return doGetShareMethodAvailable("ums"); + } + + public int setUsbMassStorageEnabled(boolean enable) { + waitForReady(); + + return doShareUnshareVolume(Environment.getExternalStorageDirectory().getPath(), "ums", enable); + } + + public boolean isUsbMassStorageEnabled() { + waitForReady(); + return doGetVolumeShared(Environment.getExternalStorageDirectory().getPath(), "ums"); } /** @@ -804,12 +785,16 @@ class MountService extends IMountService.Stub return doFormatVolume(path); } + private void warnOnNotMounted() { + if (!Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { + Log.w(TAG, "getSecureContainerList() called when storage not mounted"); + } + } + public String[] getSecureContainerList() { validatePermission(android.Manifest.permission.ASEC_ACCESS); waitForReady(); - if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) { - Log.w(TAG, "getSecureContainerList() called when storage not mounted"); - } + warnOnNotMounted(); try { return mConnector.doListCommand("asec list", VoldResponseCode.AsecListResult); @@ -822,31 +807,27 @@ class MountService extends IMountService.Stub String key, int ownerUid) { validatePermission(android.Manifest.permission.ASEC_CREATE); waitForReady(); - if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) { - Log.w(TAG, "createSecureContainer() called when storage not mounted"); - } + warnOnNotMounted(); - int rc = MountServiceResultCode.OperationSucceeded; + int rc = StorageResultCode.OperationSucceeded; String cmd = String.format("asec create %s %d %s %s %d", id, sizeMb, fstype, key, ownerUid); try { mConnector.doCommand(cmd); } catch (NativeDaemonConnectorException e) { - rc = MountServiceResultCode.OperationFailedInternalError; + rc = StorageResultCode.OperationFailedInternalError; } return rc; } public int finalizeSecureContainer(String id) { validatePermission(android.Manifest.permission.ASEC_CREATE); - if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) { - Log.w(TAG, "finalizeSecureContainer() called when storage not mounted"); - } + warnOnNotMounted(); - int rc = MountServiceResultCode.OperationSucceeded; + int rc = StorageResultCode.OperationSucceeded; try { mConnector.doCommand(String.format("asec finalize %s", id)); } catch (NativeDaemonConnectorException e) { - rc = MountServiceResultCode.OperationFailedInternalError; + rc = StorageResultCode.OperationFailedInternalError; } return rc; } @@ -854,15 +835,13 @@ class MountService extends IMountService.Stub public int destroySecureContainer(String id) { validatePermission(android.Manifest.permission.ASEC_DESTROY); waitForReady(); - if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) { - Log.w(TAG, "destroySecureContainer() called when storage not mounted"); - } + warnOnNotMounted(); - int rc = MountServiceResultCode.OperationSucceeded; + int rc = StorageResultCode.OperationSucceeded; try { mConnector.doCommand(String.format("asec destroy %s", id)); } catch (NativeDaemonConnectorException e) { - rc = MountServiceResultCode.OperationFailedInternalError; + rc = StorageResultCode.OperationFailedInternalError; } return rc; } @@ -870,16 +849,14 @@ class MountService extends IMountService.Stub public int mountSecureContainer(String id, String key, int ownerUid) { validatePermission(android.Manifest.permission.ASEC_MOUNT_UNMOUNT); waitForReady(); - if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) { - Log.w(TAG, "mountSecureContainer() called when storage not mounted"); - } + warnOnNotMounted(); - int rc = MountServiceResultCode.OperationSucceeded; + int rc = StorageResultCode.OperationSucceeded; String cmd = String.format("asec mount %s %s %d", id, key, ownerUid); try { mConnector.doCommand(cmd); } catch (NativeDaemonConnectorException e) { - rc = MountServiceResultCode.OperationFailedInternalError; + rc = StorageResultCode.OperationFailedInternalError; } return rc; } @@ -887,16 +864,14 @@ class MountService extends IMountService.Stub public int unmountSecureContainer(String id) { validatePermission(android.Manifest.permission.ASEC_MOUNT_UNMOUNT); waitForReady(); - if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) { - Log.w(TAG, "unmountSecureContainer() called when storage not mounted"); - } + warnOnNotMounted(); - int rc = MountServiceResultCode.OperationSucceeded; + int rc = StorageResultCode.OperationSucceeded; String cmd = String.format("asec unmount %s", id); try { mConnector.doCommand(cmd); } catch (NativeDaemonConnectorException e) { - rc = MountServiceResultCode.OperationFailedInternalError; + rc = StorageResultCode.OperationFailedInternalError; } return rc; } @@ -904,16 +879,14 @@ class MountService extends IMountService.Stub public int renameSecureContainer(String oldId, String newId) { validatePermission(android.Manifest.permission.ASEC_RENAME); waitForReady(); - if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) { - Log.w(TAG, "renameSecureContainer() called when storage not mounted"); - } + warnOnNotMounted(); - int rc = MountServiceResultCode.OperationSucceeded; + int rc = StorageResultCode.OperationSucceeded; String cmd = String.format("asec rename %s %s", oldId, newId); try { mConnector.doCommand(cmd); } catch (NativeDaemonConnectorException e) { - rc = MountServiceResultCode.OperationFailedInternalError; + rc = StorageResultCode.OperationFailedInternalError; } return rc; } @@ -921,9 +894,7 @@ class MountService extends IMountService.Stub public String getSecureContainerPath(String id) { validatePermission(android.Manifest.permission.ASEC_ACCESS); waitForReady(); - if (Environment.getExternalStorageState() != Environment.MEDIA_MOUNTED) { - Log.w(TAG, "getSecureContainerPath() called when storage not mounted"); - } + warnOnNotMounted(); ArrayList rsp = mConnector.doCommand("asec path " + id); diff --git a/services/java/com/android/server/NotificationManagerService.java b/services/java/com/android/server/NotificationManagerService.java index 80fd51f94eb04..ad8ab84bb9fdc 100755 --- a/services/java/com/android/server/NotificationManagerService.java +++ b/services/java/com/android/server/NotificationManagerService.java @@ -50,7 +50,7 @@ import android.os.Message; import android.os.Power; import android.os.Process; import android.os.RemoteException; -import android.storage.StorageManager; +import android.os.storage.StorageManager; import android.os.SystemProperties; import android.os.Vibrator; import android.provider.Settings; diff --git a/services/java/com/android/server/PackageManagerService.java b/services/java/com/android/server/PackageManagerService.java index f27ef8efc1a55..c99480f0b80ae 100644 --- a/services/java/com/android/server/PackageManagerService.java +++ b/services/java/com/android/server/PackageManagerService.java @@ -74,7 +74,7 @@ import android.os.Environment; import android.os.FileObserver; import android.os.FileUtils; import android.os.Handler; -import android.os.MountServiceResultCode; +import android.os.storage.StorageResultCode; import android.os.ParcelFileDescriptor; import android.os.Process; import android.os.ServiceManager; @@ -8295,17 +8295,17 @@ class PackageManagerService extends IPackageManager.Stub { int rc = mountService.createSecureContainer( pkgName, mbLen, "vfat", sdEncKey, Process.SYSTEM_UID); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.e(TAG, String.format("Failed to create container (%d)", rc)); rc = mountService.destroySecureContainer(pkgName); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.e(TAG, String.format("Failed to cleanup container (%d)", rc)); return null; } rc = mountService.createSecureContainer( pkgName, mbLen, "vfat", sdEncKey, Process.SYSTEM_UID); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.e(TAG, String.format("Failed to create container (2nd try) (%d)", rc)); return null; } @@ -8325,7 +8325,7 @@ class PackageManagerService extends IPackageManager.Stub { int rc = getMountService().mountSecureContainer(pkgName, sdEncKey, ownerUid); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.i(TAG, "Failed to mount container for pkg : " + pkgName + " rc : " + rc); return null; } @@ -8336,7 +8336,7 @@ class PackageManagerService extends IPackageManager.Stub { private boolean unMountSdDir(String pkgName) { // STOPSHIP unmount directory int rc = getMountService().unmountSecureContainer(pkgName); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.e(TAG, "Failed to unmount : " + pkgName + " with rc " + rc); return false; } @@ -8360,7 +8360,7 @@ class PackageManagerService extends IPackageManager.Stub { private boolean finalizeSdDir(String pkgName) { int rc = getMountService().finalizeSecureContainer(pkgName); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.i(TAG, "Failed to finalize container for pkg : " + pkgName); return false; } @@ -8369,7 +8369,7 @@ class PackageManagerService extends IPackageManager.Stub { private boolean destroySdDir(String pkgName) { int rc = getMountService().destroySecureContainer(pkgName); - if (rc != MountServiceResultCode.OperationSucceeded) { + if (rc != StorageResultCode.OperationSucceeded) { Log.i(TAG, "Failed to destroy container for pkg : " + pkgName); return false; } diff --git a/services/java/com/android/server/PowerManagerService.java b/services/java/com/android/server/PowerManagerService.java index 1e7dd992c4a02..1ccae861e0d19 100644 --- a/services/java/com/android/server/PowerManagerService.java +++ b/services/java/com/android/server/PowerManagerService.java @@ -41,7 +41,7 @@ import android.os.Environment; import android.os.Handler; import android.os.HandlerThread; import android.os.IBinder; -import android.os.IMountService; +import android.os.storage.IMountService; import android.os.IPowerManager; import android.os.LocalPowerManager; import android.os.Power; diff --git a/tests/AndroidTests/src/com/android/unit_tests/PackageManagerTests.java b/tests/AndroidTests/src/com/android/unit_tests/PackageManagerTests.java index a1370eadd5537..3a4d38c9679b5 100755 --- a/tests/AndroidTests/src/com/android/unit_tests/PackageManagerTests.java +++ b/tests/AndroidTests/src/com/android/unit_tests/PackageManagerTests.java @@ -16,7 +16,7 @@ package com.android.unit_tests; -import android.os.IMountService.Stub; +import android.os.storage.IMountService.Stub; import android.net.Uri; import android.os.FileUtils; @@ -54,8 +54,8 @@ import android.util.Log; import android.os.Environment; import android.os.Handler; import android.os.IBinder; -import android.os.IMountService; -import android.os.MountServiceResultCode; +import android.os.storage.IMountService; +import android.os.storage.StorageResultCode; import android.os.RemoteException; import android.os.ServiceManager; import android.os.StatFs; @@ -662,7 +662,7 @@ public class PackageManagerTests extends AndroidTestCase { try { String mPath = Environment.getExternalStorageDirectory().toString(); int ret = getMs().mountVolume(mPath); - return ret == MountServiceResultCode.OperationSucceeded; + return ret == StorageResultCode.OperationSucceeded; } catch (RemoteException e) { return false; } @@ -675,7 +675,7 @@ public class PackageManagerTests extends AndroidTestCase { try { String mPath = Environment.getExternalStorageDirectory().toString(); int ret = getMs().unmountVolume(mPath); - return ret == MountServiceResultCode.OperationSucceeded; + return ret == StorageResultCode.OperationSucceeded; } catch (RemoteException e) { return true; }