| /* |
| * Copyright (C) 2015 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.annotation.NonNull; |
| import android.annotation.Nullable; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.res.Resources; |
| import android.net.Uri; |
| import android.os.Environment; |
| import android.os.IVold; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.os.UserHandle; |
| import android.provider.DocumentsContract; |
| import android.text.TextUtils; |
| import android.util.ArrayMap; |
| import android.util.DebugUtils; |
| import android.util.SparseArray; |
| import android.util.SparseIntArray; |
| |
| import com.android.internal.R; |
| import com.android.internal.util.IndentingPrintWriter; |
| import com.android.internal.util.Preconditions; |
| |
| import java.io.CharArrayWriter; |
| import java.io.File; |
| import java.util.Comparator; |
| import java.util.Objects; |
| |
| /** |
| * Information about a storage volume that may be mounted. A volume may be a |
| * partition on a physical {@link DiskInfo}, an emulated volume above some other |
| * storage medium, or a standalone container like an ASEC or OBB. |
| * <p> |
| * Volumes may be mounted with various flags: |
| * <ul> |
| * <li>{@link #MOUNT_FLAG_PRIMARY} means the volume provides primary external |
| * storage, historically found at {@code /sdcard}. |
| * <li>{@link #MOUNT_FLAG_VISIBLE} means the volume is visible to third-party |
| * apps for direct filesystem access. The system should send out relevant |
| * storage broadcasts and index any media on visible volumes. Visible volumes |
| * are considered a more stable part of the device, which is why we take the |
| * time to index them. In particular, transient volumes like USB OTG devices |
| * <em>should not</em> be marked as visible; their contents should be surfaced |
| * to apps through the Storage Access Framework. |
| * </ul> |
| * |
| * @hide |
| */ |
| public class VolumeInfo implements Parcelable { |
| public static final String ACTION_VOLUME_STATE_CHANGED = |
| "android.os.storage.action.VOLUME_STATE_CHANGED"; |
| public static final String EXTRA_VOLUME_ID = |
| "android.os.storage.extra.VOLUME_ID"; |
| public static final String EXTRA_VOLUME_STATE = |
| "android.os.storage.extra.VOLUME_STATE"; |
| |
| /** Stub volume representing internal private storage */ |
| public static final String ID_PRIVATE_INTERNAL = "private"; |
| /** Real volume representing internal emulated storage */ |
| public static final String ID_EMULATED_INTERNAL = "emulated"; |
| |
| public static final int TYPE_PUBLIC = IVold.VOLUME_TYPE_PUBLIC; |
| public static final int TYPE_PRIVATE = IVold.VOLUME_TYPE_PRIVATE; |
| public static final int TYPE_EMULATED = IVold.VOLUME_TYPE_EMULATED; |
| public static final int TYPE_ASEC = IVold.VOLUME_TYPE_ASEC; |
| public static final int TYPE_OBB = IVold.VOLUME_TYPE_OBB; |
| |
| public static final int STATE_UNMOUNTED = IVold.VOLUME_STATE_UNMOUNTED; |
| public static final int STATE_CHECKING = IVold.VOLUME_STATE_CHECKING; |
| public static final int STATE_MOUNTED = IVold.VOLUME_STATE_MOUNTED; |
| public static final int STATE_MOUNTED_READ_ONLY = IVold.VOLUME_STATE_MOUNTED_READ_ONLY; |
| public static final int STATE_FORMATTING = IVold.VOLUME_STATE_FORMATTING; |
| public static final int STATE_EJECTING = IVold.VOLUME_STATE_EJECTING; |
| public static final int STATE_UNMOUNTABLE = IVold.VOLUME_STATE_UNMOUNTABLE; |
| public static final int STATE_REMOVED = IVold.VOLUME_STATE_REMOVED; |
| public static final int STATE_BAD_REMOVAL = IVold.VOLUME_STATE_BAD_REMOVAL; |
| |
| public static final int MOUNT_FLAG_PRIMARY = IVold.MOUNT_FLAG_PRIMARY; |
| public static final int MOUNT_FLAG_VISIBLE = IVold.MOUNT_FLAG_VISIBLE; |
| |
| private static SparseArray<String> sStateToEnvironment = new SparseArray<>(); |
| private static ArrayMap<String, String> sEnvironmentToBroadcast = new ArrayMap<>(); |
| private static SparseIntArray sStateToDescrip = new SparseIntArray(); |
| |
| private static final Comparator<VolumeInfo> |
| sDescriptionComparator = new Comparator<VolumeInfo>() { |
| @Override |
| public int compare(VolumeInfo lhs, VolumeInfo rhs) { |
| if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(lhs.getId())) { |
| return -1; |
| } else if (lhs.getDescription() == null) { |
| return 1; |
| } else if (rhs.getDescription() == null) { |
| return -1; |
| } else { |
| return lhs.getDescription().compareTo(rhs.getDescription()); |
| } |
| } |
| }; |
| |
| static { |
| sStateToEnvironment.put(VolumeInfo.STATE_UNMOUNTED, Environment.MEDIA_UNMOUNTED); |
| sStateToEnvironment.put(VolumeInfo.STATE_CHECKING, Environment.MEDIA_CHECKING); |
| sStateToEnvironment.put(VolumeInfo.STATE_MOUNTED, Environment.MEDIA_MOUNTED); |
| sStateToEnvironment.put(VolumeInfo.STATE_MOUNTED_READ_ONLY, Environment.MEDIA_MOUNTED_READ_ONLY); |
| sStateToEnvironment.put(VolumeInfo.STATE_FORMATTING, Environment.MEDIA_UNMOUNTED); |
| sStateToEnvironment.put(VolumeInfo.STATE_EJECTING, Environment.MEDIA_EJECTING); |
| sStateToEnvironment.put(VolumeInfo.STATE_UNMOUNTABLE, Environment.MEDIA_UNMOUNTABLE); |
| sStateToEnvironment.put(VolumeInfo.STATE_REMOVED, Environment.MEDIA_REMOVED); |
| sStateToEnvironment.put(VolumeInfo.STATE_BAD_REMOVAL, Environment.MEDIA_BAD_REMOVAL); |
| |
| sEnvironmentToBroadcast.put(Environment.MEDIA_UNMOUNTED, Intent.ACTION_MEDIA_UNMOUNTED); |
| sEnvironmentToBroadcast.put(Environment.MEDIA_CHECKING, Intent.ACTION_MEDIA_CHECKING); |
| sEnvironmentToBroadcast.put(Environment.MEDIA_MOUNTED, Intent.ACTION_MEDIA_MOUNTED); |
| sEnvironmentToBroadcast.put(Environment.MEDIA_MOUNTED_READ_ONLY, Intent.ACTION_MEDIA_MOUNTED); |
| sEnvironmentToBroadcast.put(Environment.MEDIA_EJECTING, Intent.ACTION_MEDIA_EJECT); |
| sEnvironmentToBroadcast.put(Environment.MEDIA_UNMOUNTABLE, Intent.ACTION_MEDIA_UNMOUNTABLE); |
| sEnvironmentToBroadcast.put(Environment.MEDIA_REMOVED, Intent.ACTION_MEDIA_REMOVED); |
| sEnvironmentToBroadcast.put(Environment.MEDIA_BAD_REMOVAL, Intent.ACTION_MEDIA_BAD_REMOVAL); |
| |
| sStateToDescrip.put(VolumeInfo.STATE_UNMOUNTED, R.string.ext_media_status_unmounted); |
| sStateToDescrip.put(VolumeInfo.STATE_CHECKING, R.string.ext_media_status_checking); |
| sStateToDescrip.put(VolumeInfo.STATE_MOUNTED, R.string.ext_media_status_mounted); |
| sStateToDescrip.put(VolumeInfo.STATE_MOUNTED_READ_ONLY, R.string.ext_media_status_mounted_ro); |
| sStateToDescrip.put(VolumeInfo.STATE_FORMATTING, R.string.ext_media_status_formatting); |
| sStateToDescrip.put(VolumeInfo.STATE_EJECTING, R.string.ext_media_status_ejecting); |
| sStateToDescrip.put(VolumeInfo.STATE_UNMOUNTABLE, R.string.ext_media_status_unmountable); |
| sStateToDescrip.put(VolumeInfo.STATE_REMOVED, R.string.ext_media_status_removed); |
| sStateToDescrip.put(VolumeInfo.STATE_BAD_REMOVAL, R.string.ext_media_status_bad_removal); |
| } |
| |
| /** vold state */ |
| public final String id; |
| public final int type; |
| public final DiskInfo disk; |
| public final String partGuid; |
| public int mountFlags = 0; |
| public int mountUserId = -1; |
| public int state = STATE_UNMOUNTED; |
| public String fsType; |
| public String fsUuid; |
| public String fsLabel; |
| public String path; |
| public String internalPath; |
| |
| public VolumeInfo(String id, int type, DiskInfo disk, String partGuid) { |
| this.id = Preconditions.checkNotNull(id); |
| this.type = type; |
| this.disk = disk; |
| this.partGuid = partGuid; |
| } |
| |
| public VolumeInfo(Parcel parcel) { |
| id = parcel.readString(); |
| type = parcel.readInt(); |
| if (parcel.readInt() != 0) { |
| disk = DiskInfo.CREATOR.createFromParcel(parcel); |
| } else { |
| disk = null; |
| } |
| partGuid = parcel.readString(); |
| mountFlags = parcel.readInt(); |
| mountUserId = parcel.readInt(); |
| state = parcel.readInt(); |
| fsType = parcel.readString(); |
| fsUuid = parcel.readString(); |
| fsLabel = parcel.readString(); |
| path = parcel.readString(); |
| internalPath = parcel.readString(); |
| } |
| |
| public static @NonNull String getEnvironmentForState(int state) { |
| final String envState = sStateToEnvironment.get(state); |
| if (envState != null) { |
| return envState; |
| } else { |
| return Environment.MEDIA_UNKNOWN; |
| } |
| } |
| |
| public static @Nullable String getBroadcastForEnvironment(String envState) { |
| return sEnvironmentToBroadcast.get(envState); |
| } |
| |
| public static @Nullable String getBroadcastForState(int state) { |
| return getBroadcastForEnvironment(getEnvironmentForState(state)); |
| } |
| |
| public static @NonNull Comparator<VolumeInfo> getDescriptionComparator() { |
| return sDescriptionComparator; |
| } |
| |
| public @NonNull String getId() { |
| return id; |
| } |
| |
| public @Nullable DiskInfo getDisk() { |
| return disk; |
| } |
| |
| public @Nullable String getDiskId() { |
| return (disk != null) ? disk.id : null; |
| } |
| |
| public int getType() { |
| return type; |
| } |
| |
| public int getState() { |
| return state; |
| } |
| |
| public int getStateDescription() { |
| return sStateToDescrip.get(state, 0); |
| } |
| |
| public @Nullable String getFsUuid() { |
| return fsUuid; |
| } |
| |
| public int getMountUserId() { |
| return mountUserId; |
| } |
| |
| public @Nullable String getDescription() { |
| if (ID_PRIVATE_INTERNAL.equals(id) || ID_EMULATED_INTERNAL.equals(id)) { |
| return Resources.getSystem().getString(com.android.internal.R.string.storage_internal); |
| } else if (!TextUtils.isEmpty(fsLabel)) { |
| return fsLabel; |
| } else { |
| return null; |
| } |
| } |
| |
| public boolean isMountedReadable() { |
| return state == STATE_MOUNTED || state == STATE_MOUNTED_READ_ONLY; |
| } |
| |
| public boolean isMountedWritable() { |
| return state == STATE_MOUNTED; |
| } |
| |
| public boolean isPrimary() { |
| return (mountFlags & MOUNT_FLAG_PRIMARY) != 0; |
| } |
| |
| public boolean isPrimaryPhysical() { |
| return isPrimary() && (getType() == TYPE_PUBLIC); |
| } |
| |
| public boolean isVisible() { |
| return (mountFlags & MOUNT_FLAG_VISIBLE) != 0; |
| } |
| |
| public boolean isVisibleForRead(int userId) { |
| if (type == TYPE_PUBLIC) { |
| if (isPrimary() && mountUserId != userId) { |
| // Primary physical is only visible to single user |
| return false; |
| } else { |
| return isVisible(); |
| } |
| } else if (type == TYPE_EMULATED) { |
| return isVisible(); |
| } else { |
| return false; |
| } |
| } |
| |
| public boolean isVisibleForWrite(int userId) { |
| if (type == TYPE_PUBLIC && mountUserId == userId) { |
| return isVisible(); |
| } else if (type == TYPE_EMULATED) { |
| return isVisible(); |
| } else { |
| return false; |
| } |
| } |
| |
| public File getPath() { |
| return (path != null) ? new File(path) : null; |
| } |
| |
| public File getInternalPath() { |
| return (internalPath != null) ? new File(internalPath) : null; |
| } |
| |
| public File getPathForUser(int userId) { |
| if (path == null) { |
| return null; |
| } else if (type == TYPE_PUBLIC) { |
| return new File(path); |
| } else if (type == TYPE_EMULATED) { |
| return new File(path, Integer.toString(userId)); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Path which is accessible to apps holding |
| * {@link android.Manifest.permission#WRITE_MEDIA_STORAGE}. |
| */ |
| public File getInternalPathForUser(int userId) { |
| if (type == TYPE_PUBLIC) { |
| // TODO: plumb through cleaner path from vold |
| return new File(path.replace("/storage/", "/mnt/media_rw/")); |
| } else { |
| return getPathForUser(userId); |
| } |
| } |
| |
| public StorageVolume buildStorageVolume(Context context, int userId, boolean reportUnmounted) { |
| final StorageManager storage = context.getSystemService(StorageManager.class); |
| |
| final boolean removable; |
| final boolean emulated; |
| final boolean allowMassStorage = false; |
| final String envState = reportUnmounted |
| ? Environment.MEDIA_UNMOUNTED : getEnvironmentForState(state); |
| |
| File userPath = getPathForUser(userId); |
| if (userPath == null) { |
| userPath = new File("/dev/null"); |
| } |
| |
| String description = null; |
| String derivedFsUuid = fsUuid; |
| long maxFileSize = 0; |
| |
| if (type == TYPE_EMULATED) { |
| emulated = true; |
| |
| final VolumeInfo privateVol = storage.findPrivateForEmulated(this); |
| if (privateVol != null) { |
| description = storage.getBestVolumeDescription(privateVol); |
| derivedFsUuid = privateVol.fsUuid; |
| } |
| |
| if (ID_EMULATED_INTERNAL.equals(id)) { |
| removable = false; |
| } else { |
| removable = true; |
| } |
| |
| } else if (type == TYPE_PUBLIC) { |
| emulated = false; |
| removable = true; |
| |
| description = storage.getBestVolumeDescription(this); |
| |
| if ("vfat".equals(fsType)) { |
| maxFileSize = 4294967295L; |
| } |
| |
| } else { |
| throw new IllegalStateException("Unexpected volume type " + type); |
| } |
| |
| if (description == null) { |
| description = context.getString(android.R.string.unknownName); |
| } |
| |
| return new StorageVolume(id, userPath, description, isPrimary(), removable, |
| emulated, allowMassStorage, maxFileSize, new UserHandle(userId), |
| derivedFsUuid, envState); |
| } |
| |
| public static int buildStableMtpStorageId(String fsUuid) { |
| if (TextUtils.isEmpty(fsUuid)) { |
| return StorageVolume.STORAGE_ID_INVALID; |
| } else { |
| int hash = 0; |
| for (int i = 0; i < fsUuid.length(); ++i) { |
| hash = 31 * hash + fsUuid.charAt(i); |
| } |
| hash = (hash ^ (hash << 16)) & 0xffff0000; |
| // Work around values that the spec doesn't allow, or that we've |
| // reserved for primary |
| if (hash == 0x00000000) hash = 0x00020000; |
| if (hash == 0x00010000) hash = 0x00020000; |
| if (hash == 0xffff0000) hash = 0xfffe0000; |
| return hash | 0x0001; |
| } |
| } |
| |
| // TODO: avoid this layering violation |
| private static final String DOCUMENT_AUTHORITY = "com.android.externalstorage.documents"; |
| private static final String DOCUMENT_ROOT_PRIMARY_EMULATED = "primary"; |
| |
| /** |
| * Build an intent to browse the contents of this volume. Only valid for |
| * {@link #TYPE_EMULATED} or {@link #TYPE_PUBLIC}. |
| */ |
| public Intent buildBrowseIntent() { |
| final Uri uri; |
| if (type == VolumeInfo.TYPE_PUBLIC) { |
| uri = DocumentsContract.buildRootUri(DOCUMENT_AUTHORITY, fsUuid); |
| } else if (type == VolumeInfo.TYPE_EMULATED && isPrimary()) { |
| uri = DocumentsContract.buildRootUri(DOCUMENT_AUTHORITY, |
| DOCUMENT_ROOT_PRIMARY_EMULATED); |
| } else { |
| return null; |
| } |
| |
| final Intent intent = new Intent(Intent.ACTION_VIEW); |
| intent.addCategory(Intent.CATEGORY_DEFAULT); |
| intent.setDataAndType(uri, DocumentsContract.Root.MIME_TYPE_ITEM); |
| |
| // note that docsui treats this as *force* show advanced. So sending |
| // false permits advanced to be shown based on user preferences. |
| intent.putExtra(DocumentsContract.EXTRA_SHOW_ADVANCED, isPrimary()); |
| return intent; |
| } |
| |
| @Override |
| public String toString() { |
| final CharArrayWriter writer = new CharArrayWriter(); |
| dump(new IndentingPrintWriter(writer, " ", 80)); |
| return writer.toString(); |
| } |
| |
| public void dump(IndentingPrintWriter pw) { |
| pw.println("VolumeInfo{" + id + "}:"); |
| pw.increaseIndent(); |
| pw.printPair("type", DebugUtils.valueToString(getClass(), "TYPE_", type)); |
| pw.printPair("diskId", getDiskId()); |
| pw.printPair("partGuid", partGuid); |
| pw.printPair("mountFlags", DebugUtils.flagsToString(getClass(), "MOUNT_FLAG_", mountFlags)); |
| pw.printPair("mountUserId", mountUserId); |
| pw.printPair("state", DebugUtils.valueToString(getClass(), "STATE_", state)); |
| pw.println(); |
| pw.printPair("fsType", fsType); |
| pw.printPair("fsUuid", fsUuid); |
| pw.printPair("fsLabel", fsLabel); |
| pw.println(); |
| pw.printPair("path", path); |
| pw.printPair("internalPath", internalPath); |
| pw.decreaseIndent(); |
| pw.println(); |
| } |
| |
| @Override |
| public VolumeInfo clone() { |
| final Parcel temp = Parcel.obtain(); |
| try { |
| writeToParcel(temp, 0); |
| temp.setDataPosition(0); |
| return CREATOR.createFromParcel(temp); |
| } finally { |
| temp.recycle(); |
| } |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (o instanceof VolumeInfo) { |
| return Objects.equals(id, ((VolumeInfo) o).id); |
| } else { |
| return false; |
| } |
| } |
| |
| @Override |
| public int hashCode() { |
| return id.hashCode(); |
| } |
| |
| public static final Creator<VolumeInfo> CREATOR = new Creator<VolumeInfo>() { |
| @Override |
| public VolumeInfo createFromParcel(Parcel in) { |
| return new VolumeInfo(in); |
| } |
| |
| @Override |
| public VolumeInfo[] newArray(int size) { |
| return new VolumeInfo[size]; |
| } |
| }; |
| |
| @Override |
| public int describeContents() { |
| return 0; |
| } |
| |
| @Override |
| public void writeToParcel(Parcel parcel, int flags) { |
| parcel.writeString(id); |
| parcel.writeInt(type); |
| if (disk != null) { |
| parcel.writeInt(1); |
| disk.writeToParcel(parcel, flags); |
| } else { |
| parcel.writeInt(0); |
| } |
| parcel.writeString(partGuid); |
| parcel.writeInt(mountFlags); |
| parcel.writeInt(mountUserId); |
| parcel.writeInt(state); |
| parcel.writeString(fsType); |
| parcel.writeString(fsUuid); |
| parcel.writeString(fsLabel); |
| parcel.writeString(path); |
| parcel.writeString(internalPath); |
| } |
| } |