/* * Copyright (C) 2008 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 static android.net.TrafficStats.GB_IN_BYTES; import static android.net.TrafficStats.MB_IN_BYTES; import android.annotation.BytesLong; import android.annotation.IntDef; import android.annotation.NonNull; import android.annotation.Nullable; import android.annotation.RequiresPermission; import android.annotation.SdkConstant; import android.annotation.SuppressLint; import android.annotation.SystemApi; import android.annotation.SystemService; import android.annotation.WorkerThread; import android.app.Activity; import android.app.ActivityThread; import android.content.ContentResolver; import android.content.Context; import android.content.Intent; import android.content.pm.ApplicationInfo; import android.content.pm.IPackageMoveObserver; import android.content.pm.PackageManager; import android.os.Binder; import android.os.Environment; import android.os.FileUtils; import android.os.Handler; import android.os.Looper; import android.os.Message; import android.os.ParcelFileDescriptor; import android.os.ParcelableException; import android.os.ProxyFileDescriptorCallback; import android.os.RemoteException; import android.os.ServiceManager; import android.os.ServiceManager.ServiceNotFoundException; import android.os.SystemProperties; import android.os.UserHandle; import android.provider.Settings; import android.system.ErrnoException; import android.system.Os; import android.system.OsConstants; import android.text.TextUtils; import android.util.Log; import android.util.Pair; import android.util.Slog; import android.util.SparseArray; import com.android.internal.annotations.GuardedBy; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.logging.MetricsLogger; import com.android.internal.os.AppFuseMount; import com.android.internal.os.FuseAppLoop; import com.android.internal.os.FuseUnavailableMountException; import com.android.internal.os.RoSystemProperties; import com.android.internal.os.SomeArgs; import com.android.internal.util.Preconditions; import java.io.File; import java.io.FileDescriptor; import java.io.FileNotFoundException; import java.io.IOException; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.ref.WeakReference; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Iterator; import java.util.List; import java.util.Objects; import java.util.UUID; import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicInteger; /** * StorageManager is the interface to the systems storage service. The storage * manager handles storage-related items such as Opaque Binary Blobs (OBBs). *
* OBBs contain a filesystem that maybe be encrypted on disk and mounted * on-demand from an application. OBBs are a good way of providing large amounts * of binary assets without packaging them into APKs as they may be multiple * gigabytes in size. However, due to their size, they're most likely stored in * a shared storage pool accessible from all programs. The system does not * guarantee the security of the OBB file itself: if any program modifies the * OBB, there is no guarantee that a read from that OBB will produce the * expected output. */ @SystemService(Context.STORAGE_SERVICE) public class StorageManager { private static final String TAG = "StorageManager"; /** {@hide} */ public static final String PROP_PRIMARY_PHYSICAL = "ro.vold.primary_physical"; /** {@hide} */ public static final String PROP_HAS_ADOPTABLE = "vold.has_adoptable"; /** {@hide} */ public static final String PROP_FORCE_ADOPTABLE = "persist.fw.force_adoptable"; /** {@hide} */ public static final String PROP_EMULATE_FBE = "persist.sys.emulate_fbe"; /** {@hide} */ public static final String PROP_SDCARDFS = "persist.sys.sdcardfs"; /** {@hide} */ public static final String PROP_VIRTUAL_DISK = "persist.sys.virtual_disk"; /** {@hide} */ public static final String PROP_ADOPTABLE_FBE = "persist.sys.adoptable_fbe"; /** {@hide} */ public static final String UUID_PRIVATE_INTERNAL = null; /** {@hide} */ public static final String UUID_PRIMARY_PHYSICAL = "primary_physical"; /** {@hide} */ public static final String UUID_SYSTEM = "system"; // NOTE: UUID constants below are namespaced // uuid -v5 ad99aa3d-308e-4191-a200-ebcab371c0ad default // uuid -v5 ad99aa3d-308e-4191-a200-ebcab371c0ad primary_physical // uuid -v5 ad99aa3d-308e-4191-a200-ebcab371c0ad system /** * UUID representing the default internal storage of this device which * provides {@link Environment#getDataDirectory()}. *
* This value is constant across all devices and it will never change, and * thus it cannot be used to uniquely identify a particular physical device. * * @see #getUuidForPath(File) * @see ApplicationInfo#storageUuid */ public static final UUID UUID_DEFAULT = UUID .fromString("41217664-9172-527a-b3d5-edabb50a7d69"); /** {@hide} */ public static final UUID UUID_PRIMARY_PHYSICAL_ = UUID .fromString("0f95a519-dae7-5abf-9519-fbd6209e05fd"); /** {@hide} */ public static final UUID UUID_SYSTEM_ = UUID .fromString("5d258386-e60d-59e3-826d-0089cdd42cc0"); /** * Activity Action: Allows the user to manage their storage. This activity * provides the ability to free up space on the device by deleting data such * as apps. *
* If the sending application has a specific storage device or allocation * size in mind, they can optionally define {@link #EXTRA_UUID} or * {@link #EXTRA_REQUESTED_BYTES}, respectively. *
* This intent should be launched using * {@link Activity#startActivityForResult(Intent, int)} so that the user * knows which app is requesting the storage space. The returned result will * be {@link Activity#RESULT_OK} if the requested space was made available, * or {@link Activity#RESULT_CANCELED} otherwise. */ @SdkConstant(SdkConstant.SdkConstantType.ACTIVITY_INTENT_ACTION) public static final String ACTION_MANAGE_STORAGE = "android.os.storage.action.MANAGE_STORAGE"; /** * Extra {@link UUID} used to indicate the storage volume where an * application is interested in allocating or managing disk space. * * @see #ACTION_MANAGE_STORAGE * @see #UUID_DEFAULT * @see #getUuidForPath(File) * @see Intent#putExtra(String, java.io.Serializable) */ public static final String EXTRA_UUID = "android.os.storage.extra.UUID"; /** * Extra used to indicate the total size (in bytes) that an application is * interested in allocating. *
* When defined, the management UI will help guide the user to free up
* enough disk space to reach this requested value.
*
* @see #ACTION_MANAGE_STORAGE
*/
public static final String EXTRA_REQUESTED_BYTES = "android.os.storage.extra.REQUESTED_BYTES";
/** {@hide} */
public static final int DEBUG_FORCE_ADOPTABLE = 1 << 0;
/** {@hide} */
public static final int DEBUG_EMULATE_FBE = 1 << 1;
/** {@hide} */
public static final int DEBUG_SDCARDFS_FORCE_ON = 1 << 2;
/** {@hide} */
public static final int DEBUG_SDCARDFS_FORCE_OFF = 1 << 3;
/** {@hide} */
public static final int DEBUG_VIRTUAL_DISK = 1 << 4;
// NOTE: keep in sync with installd
/** {@hide} */
public static final int FLAG_STORAGE_DE = 1 << 0;
/** {@hide} */
public static final int FLAG_STORAGE_CE = 1 << 1;
/** {@hide} */
public static final int FLAG_FOR_WRITE = 1 << 8;
/** {@hide} */
public static final int FLAG_REAL_STATE = 1 << 9;
/** {@hide} */
public static final int FLAG_INCLUDE_INVISIBLE = 1 << 10;
/** {@hide} */
public static final int FSTRIM_FLAG_DEEP = 1 << 0;
/** {@hide} */
public static final int FSTRIM_FLAG_BENCHMARK = 1 << 1;
/** @hide The volume is not encrypted. */
public static final int ENCRYPTION_STATE_NONE = 1;
/** @hide The volume has been encrypted succesfully. */
public static final int ENCRYPTION_STATE_OK = 0;
/** @hide The volume is in a bad state.*/
public static final int ENCRYPTION_STATE_ERROR_UNKNOWN = -1;
/** @hide Encryption is incomplete */
public static final int ENCRYPTION_STATE_ERROR_INCOMPLETE = -2;
/** @hide Encryption is incomplete and irrecoverable */
public static final int ENCRYPTION_STATE_ERROR_INCONSISTENT = -3;
/** @hide Underlying data is corrupt */
public static final int ENCRYPTION_STATE_ERROR_CORRUPT = -4;
private static volatile IStorageManager sStorageManager = null;
private final Context mContext;
private final ContentResolver mResolver;
private final IStorageManager mStorageManager;
private final Looper mLooper;
private final AtomicInteger mNextNonce = new AtomicInteger(0);
private final ArrayList 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(Context context, Looper looper) throws ServiceNotFoundException {
mContext = context;
mResolver = context.getContentResolver();
mLooper = looper;
mStorageManager = IStorageManager.Stub.asInterface(ServiceManager.getServiceOrThrow("mount"));
}
/**
* Registers a {@link android.os.storage.StorageEventListener StorageEventListener}.
*
* @param listener A {@link android.os.storage.StorageEventListener StorageEventListener} object.
*
* @hide
*/
public void registerListener(StorageEventListener listener) {
synchronized (mDelegates) {
final StorageEventListenerDelegate delegate = new StorageEventListenerDelegate(listener,
mLooper);
try {
mStorageManager.registerListener(delegate);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
mDelegates.add(delegate);
}
}
/**
* Unregisters a {@link android.os.storage.StorageEventListener StorageEventListener}.
*
* @param listener A {@link android.os.storage.StorageEventListener StorageEventListener} object.
*
* @hide
*/
public void unregisterListener(StorageEventListener listener) {
synchronized (mDelegates) {
for (Iterator
* The OBB will remain mounted for as long as the StorageManager reference
* is held by the application. As soon as this reference is lost, the OBBs
* in use will be unmounted. The {@link OnObbStateChangeListener} registered
* with this call will receive the success or failure of this operation.
*
* Note: you can only mount OBB files for which the OBB tag on the
* file matches a package ID that is owned by the calling program's UID.
* That is, shared UID applications can attempt to mount any other
* application's OBB that shares its UID.
*
* @param rawPath the path to the OBB file
* @param key secret used to encrypt the OBB; may be
* The {@link OnObbStateChangeListener} registered with this call will
* receive the success or failure of this operation.
*
* Note: you can only mount OBB files for which the OBB tag on the
* file matches a package ID that is owned by the calling program's UID.
* That is, shared UID applications can obtain access to any other
* application's OBB that shares its UID.
*
*
* @param rawPath path to the OBB file
* @param force whether to kill any programs using this in order to unmount
* it
* @param listener will receive the success or failure of the operation
* @return whether the unmount call was successfully queued or not
*/
public boolean unmountObb(String rawPath, boolean force, OnObbStateChangeListener listener) {
Preconditions.checkNotNull(rawPath, "rawPath cannot be null");
Preconditions.checkNotNull(listener, "listener cannot be null");
try {
final int nonce = mObbActionListener.addListener(listener);
mStorageManager.unmountObb(rawPath, force, mObbActionListener, nonce);
return true;
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Check whether an Opaque Binary Blob (OBB) is mounted or not.
*
* @param rawPath path to OBB image
* @return true if OBB is mounted; false if not mounted or on error
*/
public boolean isObbMounted(String rawPath) {
Preconditions.checkNotNull(rawPath, "rawPath cannot be null");
try {
return mStorageManager.isObbMounted(rawPath);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Check the mounted path of an Opaque Binary Blob (OBB) file. This will
* give you the path to where you can obtain access to the internals of the
* OBB.
*
* @param rawPath path to OBB image
* @return absolute path to mounted OBB image data or
* If this path is hosted by the default internal storage of the device at
* {@link Environment#getDataDirectory()}, the returned value will be
* {@link #UUID_DEFAULT}.
*
* @throws IOException when the storage device hosting the given path isn't
* present, or when it doesn't have a valid UUID.
*/
public @NonNull UUID getUuidForPath(@NonNull File path) throws IOException {
Preconditions.checkNotNull(path);
final String pathString = path.getCanonicalPath();
if (FileUtils.contains(Environment.getDataDirectory().getAbsolutePath(), pathString)) {
return UUID_DEFAULT;
}
try {
for (VolumeInfo vol : mStorageManager.getVolumes(0)) {
if (vol.path != null && FileUtils.contains(vol.path, pathString)) {
// TODO: verify that emulated adopted devices have UUID of
// underlying volume
return convert(vol.fsUuid);
}
}
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
throw new FileNotFoundException("Failed to find a storage device for " + path);
}
/** {@hide} */
public @NonNull File findPathForUuid(String volumeUuid) throws FileNotFoundException {
final VolumeInfo vol = findVolumeByQualifiedUuid(volumeUuid);
if (vol != null) {
return vol.getPath();
}
throw new FileNotFoundException("Failed to find a storage device for " + volumeUuid);
}
/**
* Test if the given file descriptor supports allocation of disk space using
* {@link #allocateBytes(FileDescriptor, long)}.
*/
public boolean isAllocationSupported(@NonNull FileDescriptor fd) {
try {
getUuidForPath(ParcelFileDescriptor.getFile(fd));
return true;
} catch (IOException e) {
return false;
}
}
/** {@hide} */
public @NonNull List
* This can be useful when you want to provide quick access to a large file
* that isn't backed by a real file on disk, such as a file on a network
* share, cloud storage service, etc. As an example, you could respond to a
* {@link ContentResolver#openFileDescriptor(android.net.Uri, String)}
* request by returning a {@link ParcelFileDescriptor} created with this
* method, and then stream the content on-demand as requested.
*
* Another useful example might be where you have an encrypted file that
* you're willing to decrypt on-demand, but where you want to avoid
* persisting the cleartext version.
*
* @param mode The desired access mode, must be one of
* {@link ParcelFileDescriptor#MODE_READ_ONLY},
* {@link ParcelFileDescriptor#MODE_WRITE_ONLY}, or
* {@link ParcelFileDescriptor#MODE_READ_WRITE}
* @param callback Callback to process file operation requests issued on
* returned file descriptor.
* @param handler Handler that invokes callback methods.
* @return Seekable ParcelFileDescriptor.
* @throws IOException
*/
public @NonNull ParcelFileDescriptor openProxyFileDescriptor(
int mode, ProxyFileDescriptorCallback callback, Handler handler)
throws IOException {
Preconditions.checkNotNull(handler);
return openProxyFileDescriptor(mode, callback, handler, null);
}
/** {@hide} */
@VisibleForTesting
public int getProxyFileDescriptorMountPointId() {
synchronized (mFuseAppLoopLock) {
return mFuseAppLoop != null ? mFuseAppLoop.getMountPointId() : -1;
}
}
/**
* Return quota size in bytes for all cached data belonging to the calling
* app on the given storage volume.
*
* If your app goes above this quota, your cached files will be some of the
* first to be deleted when additional disk space is needed. Conversely, if
* your app stays under this quota, your cached files will be some of the
* last to be deleted when additional disk space is needed.
*
* This quota will change over time depending on how frequently the user
* interacts with your app, and depending on how much system-wide disk space
* is used.
*
* Note: if your app uses the {@code android:sharedUserId} manifest feature,
* then cached data for all packages in your shared UID is tracked together
* as a single unit.
*
* Cached data tracked by this method always includes
* {@link Context#getCacheDir()} and {@link Context#getCodeCacheDir()}, and
* it also includes {@link Context#getExternalCacheDir()} if the primary
* shared/external storage is hosted on the same storage device as your
* private data.
*
* Note: if your app uses the {@code android:sharedUserId} manifest feature,
* then cached data for all packages in your shared UID is tracked together
* as a single unit.
*
* When set, the system is more aggressive about the data that it considers
* for possible deletion when allocating disk space.
*
* Note: your app must hold the
* {@link android.Manifest.permission#ALLOCATE_AGGRESSIVE} permission for
* this flag to take effect.
*
* This method is best used as a pre-flight check, such as deciding if there
* is enough space to store an entire music album before you allocate space
* for each audio file in the album. Attempts to allocate disk space beyond
* the returned value will fail.
*
* If the returned value is not large enough for the data you'd like to
* persist, you can launch {@link #ACTION_MANAGE_STORAGE} with the
* {@link #EXTRA_UUID} and {@link #EXTRA_REQUESTED_BYTES} options to help
* involve the user in freeing up disk space.
*
* If you're progressively allocating an unbounded amount of storage space
* (such as when recording a video) you should avoid calling this method
* more than once every 30 seconds.
*
* Note: if your app uses the {@code android:sharedUserId} manifest feature,
* then allocatable space for all packages in your shared UID is tracked
* together as a single unit.
*
* Attempts to allocate disk space beyond the value returned by
* {@link #getAllocatableBytes(UUID)} will fail.
*
* Since multiple apps can be running simultaneously, this method may be
* subject to race conditions. If possible, consider using
* {@link #allocateBytes(FileDescriptor, long)} which will guarantee
* that bytes are allocated to an opened file.
*
* If you're progressively allocating an unbounded amount of storage space
* (such as when recording a video) you should avoid calling this method
* more than once every 60 seconds.
*
* @param storageUuid the UUID of the storage volume where you'd like to
* allocate disk space. The UUID for a specific path can be
* obtained using {@link #getUuidForPath(File)}.
* @param bytes the number of bytes to allocate.
* @throws IOException when the storage device isn't present, or when it
* doesn't support allocating space, or if the device had
* trouble allocating the requested space.
* @see #getAllocatableBytes(UUID)
*/
@WorkerThread
public void allocateBytes(@NonNull UUID storageUuid, @BytesLong long bytes)
throws IOException {
allocateBytes(storageUuid, bytes, 0);
}
/** @hide */
@SystemApi
@WorkerThread
@SuppressLint("Doclava125")
public void allocateBytes(@NonNull UUID storageUuid, @BytesLong long bytes,
@RequiresPermission @AllocateFlags int flags) throws IOException {
try {
mStorageManager.allocateBytes(convert(storageUuid), bytes, flags,
mContext.getOpPackageName());
} catch (ParcelableException e) {
e.maybeRethrow(IOException.class);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Allocate the requested number of bytes for your application to use in the
* given open file. This will cause the system to delete any cached files
* necessary to satisfy your request.
*
* Attempts to allocate disk space beyond the value returned by
* {@link #getAllocatableBytes(UUID)} will fail.
*
* This method guarantees that bytes have been allocated to the opened file,
* otherwise it will throw if fast allocation is not possible. Fast
* allocation is typically only supported in private app data directories,
* and on shared/external storage devices which are emulated.
*
* If you're progressively allocating an unbounded amount of storage space
* (such as when recording a video) you should avoid calling this method
* more than once every 60 seconds.
*
* @param fd the open file that you'd like to allocate disk space for.
* @param bytes the number of bytes to allocate. This is the desired final
* size of the open file. If the open file is smaller than this
* requested size, it will be extended without modifying any
* existing contents. If the open file is larger than this
* requested size, it will be truncated.
* @throws IOException when the storage device isn't present, or when it
* doesn't support allocating space, or if the device had
* trouble allocating the requested space.
* @see #getAllocatableBytes(UUID, int)
* @see #isAllocationSupported(FileDescriptor)
* @see Environment#isExternalStorageEmulated(File)
*/
@WorkerThread
public void allocateBytes(FileDescriptor fd, @BytesLong long bytes) throws IOException {
allocateBytes(fd, bytes, 0);
}
/** @hide */
@SystemApi
@WorkerThread
@SuppressLint("Doclava125")
public void allocateBytes(FileDescriptor fd, @BytesLong long bytes,
@RequiresPermission @AllocateFlags int flags) throws IOException {
final File file = ParcelFileDescriptor.getFile(fd);
final UUID uuid = getUuidForPath(file);
for (int i = 0; i < 3; i++) {
try {
final long haveBytes = Os.fstat(fd).st_blocks * 512;
final long needBytes = bytes - haveBytes;
if (needBytes > 0) {
allocateBytes(uuid, needBytes, flags);
}
try {
Os.posix_fallocate(fd, 0, bytes);
return;
} catch (ErrnoException e) {
if (e.errno == OsConstants.ENOSYS || e.errno == OsConstants.ENOTSUP) {
Log.w(TAG, "fallocate() not supported; falling back to ftruncate()");
Os.ftruncate(fd, bytes);
return;
} else {
throw e;
}
}
} catch (ErrnoException e) {
if (e.errno == OsConstants.ENOSPC) {
Log.w(TAG, "Odd, not enough space; let's try again?");
continue;
}
throw e.rethrowAsIOException();
}
}
throw new IOException(
"Well this is embarassing; we can't allocate " + bytes + " for " + file);
}
private static final String XATTR_CACHE_GROUP = "user.cache_group";
private static final String XATTR_CACHE_TOMBSTONE = "user.cache_tombstone";
/** {@hide} */
private static void setCacheBehavior(File path, String name, boolean enabled)
throws IOException {
if (!path.isDirectory()) {
throw new IOException("Cache behavior can only be set on directories");
}
if (enabled) {
try {
Os.setxattr(path.getAbsolutePath(), name,
"1".getBytes(StandardCharsets.UTF_8), 0);
} catch (ErrnoException e) {
throw e.rethrowAsIOException();
}
} else {
try {
Os.removexattr(path.getAbsolutePath(), name);
} catch (ErrnoException e) {
if (e.errno != OsConstants.ENODATA) {
throw e.rethrowAsIOException();
}
}
}
}
/** {@hide} */
private static boolean isCacheBehavior(File path, String name) throws IOException {
try {
Os.getxattr(path.getAbsolutePath(), name);
return true;
} catch (ErrnoException e) {
if (e.errno != OsConstants.ENODATA) {
throw e.rethrowAsIOException();
} else {
return false;
}
}
}
/**
* Enable or disable special cache behavior that treats this directory and
* its contents as an entire group.
*
* When enabled and this directory is considered for automatic deletion by
* the OS, all contained files will either be deleted together, or not at
* all. This is useful when you have a directory that contains several
* related metadata files that depend on each other, such as movie file and
* a subtitle file.
*
* When enabled, the newest {@link File#lastModified()} value of
* any contained files is considered the modified time of the entire
* directory.
*
* This behavior can only be set on a directory, and it applies recursively
* to all contained files and directories.
*/
public void setCacheBehaviorGroup(File path, boolean group) throws IOException {
setCacheBehavior(path, XATTR_CACHE_GROUP, group);
}
/**
* Read the current value set by
* {@link #setCacheBehaviorGroup(File, boolean)}.
*/
public boolean isCacheBehaviorGroup(File path) throws IOException {
return isCacheBehavior(path, XATTR_CACHE_GROUP);
}
/**
* Enable or disable special cache behavior that leaves deleted cache files
* intact as tombstones.
*
* When enabled and a file contained in this directory is automatically
* deleted by the OS, the file will be truncated to have a length of 0 bytes
* instead of being fully deleted. This is useful if you need to distinguish
* between a file that was deleted versus one that never existed.
*
* This behavior can only be set on a directory, and it applies recursively
* to all contained files and directories.
*
* Note: this behavior is ignored completely if the user explicitly requests
* that all cached data be cleared.
* key
is
* specified, it is supplied to the mounting process to be used in any
* encryption used in the OBB.
* null
if no
* encryption was used on the OBB.
* @param listener will receive the success or failure of the operation
* @return whether the mount call was successfully queued or not
*/
public boolean mountObb(String rawPath, String key, OnObbStateChangeListener listener) {
Preconditions.checkNotNull(rawPath, "rawPath cannot be null");
Preconditions.checkNotNull(listener, "listener cannot be null");
try {
final String canonicalPath = new File(rawPath).getCanonicalPath();
final int nonce = mObbActionListener.addListener(listener);
mStorageManager.mountObb(rawPath, canonicalPath, key, mObbActionListener, nonce);
return true;
} catch (IOException e) {
throw new IllegalArgumentException("Failed to resolve path: " + rawPath, e);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Unmount an Opaque Binary Blob (OBB) file asynchronously. If the
* force
flag is true, it will kill any application needed to
* unmount the given OBB (even the calling application).
* null
if
* not mounted or exception encountered trying to read status
*/
public String getMountedObbPath(String rawPath) {
Preconditions.checkNotNull(rawPath, "rawPath cannot be null");
try {
return mStorageManager.getMountedObbPath(rawPath);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** {@hide} */
public @NonNull List