1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.os.storage; 18 19 import android.annotation.NonNull; 20 import android.annotation.Nullable; 21 import android.content.Context; 22 import android.content.Intent; 23 import android.content.res.Resources; 24 import android.net.Uri; 25 import android.os.Environment; 26 import android.os.IVold; 27 import android.os.Parcel; 28 import android.os.Parcelable; 29 import android.os.UserHandle; 30 import android.provider.DocumentsContract; 31 import android.text.TextUtils; 32 import android.util.ArrayMap; 33 import android.util.DebugUtils; 34 import android.util.SparseArray; 35 import android.util.SparseIntArray; 36 37 import com.android.internal.R; 38 import com.android.internal.util.IndentingPrintWriter; 39 import com.android.internal.util.Preconditions; 40 41 import java.io.CharArrayWriter; 42 import java.io.File; 43 import java.util.Comparator; 44 import java.util.Objects; 45 46 /** 47 * Information about a storage volume that may be mounted. A volume may be a 48 * partition on a physical {@link DiskInfo}, an emulated volume above some other 49 * storage medium, or a standalone container like an ASEC or OBB. 50 * <p> 51 * Volumes may be mounted with various flags: 52 * <ul> 53 * <li>{@link #MOUNT_FLAG_PRIMARY} means the volume provides primary external 54 * storage, historically found at {@code /sdcard}. 55 * <li>{@link #MOUNT_FLAG_VISIBLE} means the volume is visible to third-party 56 * apps for direct filesystem access. The system should send out relevant 57 * storage broadcasts and index any media on visible volumes. Visible volumes 58 * are considered a more stable part of the device, which is why we take the 59 * time to index them. In particular, transient volumes like USB OTG devices 60 * <em>should not</em> be marked as visible; their contents should be surfaced 61 * to apps through the Storage Access Framework. 62 * </ul> 63 * 64 * @hide 65 */ 66 public class VolumeInfo implements Parcelable { 67 public static final String ACTION_VOLUME_STATE_CHANGED = 68 "android.os.storage.action.VOLUME_STATE_CHANGED"; 69 public static final String EXTRA_VOLUME_ID = 70 "android.os.storage.extra.VOLUME_ID"; 71 public static final String EXTRA_VOLUME_STATE = 72 "android.os.storage.extra.VOLUME_STATE"; 73 74 /** Stub volume representing internal private storage */ 75 public static final String ID_PRIVATE_INTERNAL = "private"; 76 /** Real volume representing internal emulated storage */ 77 public static final String ID_EMULATED_INTERNAL = "emulated"; 78 79 public static final int TYPE_PUBLIC = IVold.VOLUME_TYPE_PUBLIC; 80 public static final int TYPE_PRIVATE = IVold.VOLUME_TYPE_PRIVATE; 81 public static final int TYPE_EMULATED = IVold.VOLUME_TYPE_EMULATED; 82 public static final int TYPE_ASEC = IVold.VOLUME_TYPE_ASEC; 83 public static final int TYPE_OBB = IVold.VOLUME_TYPE_OBB; 84 85 public static final int STATE_UNMOUNTED = IVold.VOLUME_STATE_UNMOUNTED; 86 public static final int STATE_CHECKING = IVold.VOLUME_STATE_CHECKING; 87 public static final int STATE_MOUNTED = IVold.VOLUME_STATE_MOUNTED; 88 public static final int STATE_MOUNTED_READ_ONLY = IVold.VOLUME_STATE_MOUNTED_READ_ONLY; 89 public static final int STATE_FORMATTING = IVold.VOLUME_STATE_FORMATTING; 90 public static final int STATE_EJECTING = IVold.VOLUME_STATE_EJECTING; 91 public static final int STATE_UNMOUNTABLE = IVold.VOLUME_STATE_UNMOUNTABLE; 92 public static final int STATE_REMOVED = IVold.VOLUME_STATE_REMOVED; 93 public static final int STATE_BAD_REMOVAL = IVold.VOLUME_STATE_BAD_REMOVAL; 94 95 public static final int MOUNT_FLAG_PRIMARY = IVold.MOUNT_FLAG_PRIMARY; 96 public static final int MOUNT_FLAG_VISIBLE = IVold.MOUNT_FLAG_VISIBLE; 97 98 private static SparseArray<String> sStateToEnvironment = new SparseArray<>(); 99 private static ArrayMap<String, String> sEnvironmentToBroadcast = new ArrayMap<>(); 100 private static SparseIntArray sStateToDescrip = new SparseIntArray(); 101 102 private static final Comparator<VolumeInfo> 103 sDescriptionComparator = new Comparator<VolumeInfo>() { 104 @Override 105 public int compare(VolumeInfo lhs, VolumeInfo rhs) { 106 if (VolumeInfo.ID_PRIVATE_INTERNAL.equals(lhs.getId())) { 107 return -1; 108 } else if (lhs.getDescription() == null) { 109 return 1; 110 } else if (rhs.getDescription() == null) { 111 return -1; 112 } else { 113 return lhs.getDescription().compareTo(rhs.getDescription()); 114 } 115 } 116 }; 117 118 static { 119 sStateToEnvironment.put(VolumeInfo.STATE_UNMOUNTED, Environment.MEDIA_UNMOUNTED); 120 sStateToEnvironment.put(VolumeInfo.STATE_CHECKING, Environment.MEDIA_CHECKING); 121 sStateToEnvironment.put(VolumeInfo.STATE_MOUNTED, Environment.MEDIA_MOUNTED); 122 sStateToEnvironment.put(VolumeInfo.STATE_MOUNTED_READ_ONLY, Environment.MEDIA_MOUNTED_READ_ONLY); 123 sStateToEnvironment.put(VolumeInfo.STATE_FORMATTING, Environment.MEDIA_UNMOUNTED); 124 sStateToEnvironment.put(VolumeInfo.STATE_EJECTING, Environment.MEDIA_EJECTING); 125 sStateToEnvironment.put(VolumeInfo.STATE_UNMOUNTABLE, Environment.MEDIA_UNMOUNTABLE); 126 sStateToEnvironment.put(VolumeInfo.STATE_REMOVED, Environment.MEDIA_REMOVED); 127 sStateToEnvironment.put(VolumeInfo.STATE_BAD_REMOVAL, Environment.MEDIA_BAD_REMOVAL); 128 129 sEnvironmentToBroadcast.put(Environment.MEDIA_UNMOUNTED, Intent.ACTION_MEDIA_UNMOUNTED); 130 sEnvironmentToBroadcast.put(Environment.MEDIA_CHECKING, Intent.ACTION_MEDIA_CHECKING); 131 sEnvironmentToBroadcast.put(Environment.MEDIA_MOUNTED, Intent.ACTION_MEDIA_MOUNTED); 132 sEnvironmentToBroadcast.put(Environment.MEDIA_MOUNTED_READ_ONLY, Intent.ACTION_MEDIA_MOUNTED); 133 sEnvironmentToBroadcast.put(Environment.MEDIA_EJECTING, Intent.ACTION_MEDIA_EJECT); 134 sEnvironmentToBroadcast.put(Environment.MEDIA_UNMOUNTABLE, Intent.ACTION_MEDIA_UNMOUNTABLE); 135 sEnvironmentToBroadcast.put(Environment.MEDIA_REMOVED, Intent.ACTION_MEDIA_REMOVED); 136 sEnvironmentToBroadcast.put(Environment.MEDIA_BAD_REMOVAL, Intent.ACTION_MEDIA_BAD_REMOVAL); 137 138 sStateToDescrip.put(VolumeInfo.STATE_UNMOUNTED, R.string.ext_media_status_unmounted); 139 sStateToDescrip.put(VolumeInfo.STATE_CHECKING, R.string.ext_media_status_checking); 140 sStateToDescrip.put(VolumeInfo.STATE_MOUNTED, R.string.ext_media_status_mounted); 141 sStateToDescrip.put(VolumeInfo.STATE_MOUNTED_READ_ONLY, R.string.ext_media_status_mounted_ro); 142 sStateToDescrip.put(VolumeInfo.STATE_FORMATTING, R.string.ext_media_status_formatting); 143 sStateToDescrip.put(VolumeInfo.STATE_EJECTING, R.string.ext_media_status_ejecting); 144 sStateToDescrip.put(VolumeInfo.STATE_UNMOUNTABLE, R.string.ext_media_status_unmountable); 145 sStateToDescrip.put(VolumeInfo.STATE_REMOVED, R.string.ext_media_status_removed); 146 sStateToDescrip.put(VolumeInfo.STATE_BAD_REMOVAL, R.string.ext_media_status_bad_removal); 147 } 148 149 /** vold state */ 150 public final String id; 151 public final int type; 152 public final DiskInfo disk; 153 public final String partGuid; 154 public int mountFlags = 0; 155 public int mountUserId = -1; 156 public int state = STATE_UNMOUNTED; 157 public String fsType; 158 public String fsUuid; 159 public String fsLabel; 160 public String path; 161 public String internalPath; 162 163 public VolumeInfo(String id, int type, DiskInfo disk, String partGuid) { 164 this.id = Preconditions.checkNotNull(id); 165 this.type = type; 166 this.disk = disk; 167 this.partGuid = partGuid; 168 } 169 170 public VolumeInfo(Parcel parcel) { 171 id = parcel.readString(); 172 type = parcel.readInt(); 173 if (parcel.readInt() != 0) { 174 disk = DiskInfo.CREATOR.createFromParcel(parcel); 175 } else { 176 disk = null; 177 } 178 partGuid = parcel.readString(); 179 mountFlags = parcel.readInt(); 180 mountUserId = parcel.readInt(); 181 state = parcel.readInt(); 182 fsType = parcel.readString(); 183 fsUuid = parcel.readString(); 184 fsLabel = parcel.readString(); 185 path = parcel.readString(); 186 internalPath = parcel.readString(); 187 } 188 189 public static @NonNull String getEnvironmentForState(int state) { 190 final String envState = sStateToEnvironment.get(state); 191 if (envState != null) { 192 return envState; 193 } else { 194 return Environment.MEDIA_UNKNOWN; 195 } 196 } 197 198 public static @Nullable String getBroadcastForEnvironment(String envState) { 199 return sEnvironmentToBroadcast.get(envState); 200 } 201 202 public static @Nullable String getBroadcastForState(int state) { 203 return getBroadcastForEnvironment(getEnvironmentForState(state)); 204 } 205 206 public static @NonNull Comparator<VolumeInfo> getDescriptionComparator() { 207 return sDescriptionComparator; 208 } 209 210 public @NonNull String getId() { 211 return id; 212 } 213 214 public @Nullable DiskInfo getDisk() { 215 return disk; 216 } 217 218 public @Nullable String getDiskId() { 219 return (disk != null) ? disk.id : null; 220 } 221 222 public int getType() { 223 return type; 224 } 225 226 public int getState() { 227 return state; 228 } 229 230 public int getStateDescription() { 231 return sStateToDescrip.get(state, 0); 232 } 233 234 public @Nullable String getFsUuid() { 235 return fsUuid; 236 } 237 238 public int getMountUserId() { 239 return mountUserId; 240 } 241 242 public @Nullable String getDescription() { 243 if (ID_PRIVATE_INTERNAL.equals(id) || ID_EMULATED_INTERNAL.equals(id)) { 244 return Resources.getSystem().getString(com.android.internal.R.string.storage_internal); 245 } else if (!TextUtils.isEmpty(fsLabel)) { 246 return fsLabel; 247 } else { 248 return null; 249 } 250 } 251 252 public boolean isMountedReadable() { 253 return state == STATE_MOUNTED || state == STATE_MOUNTED_READ_ONLY; 254 } 255 256 public boolean isMountedWritable() { 257 return state == STATE_MOUNTED; 258 } 259 260 public boolean isPrimary() { 261 return (mountFlags & MOUNT_FLAG_PRIMARY) != 0; 262 } 263 264 public boolean isPrimaryPhysical() { 265 return isPrimary() && (getType() == TYPE_PUBLIC); 266 } 267 268 public boolean isVisible() { 269 return (mountFlags & MOUNT_FLAG_VISIBLE) != 0; 270 } 271 272 public boolean isVisibleForUser(int userId) { 273 if (type == TYPE_PUBLIC && mountUserId == userId) { 274 return isVisible(); 275 } else if (type == TYPE_EMULATED) { 276 return isVisible(); 277 } else { 278 return false; 279 } 280 } 281 282 public boolean isVisibleForRead(int userId) { 283 return isVisibleForUser(userId); 284 } 285 286 public boolean isVisibleForWrite(int userId) { 287 return isVisibleForUser(userId); 288 } 289 290 public File getPath() { 291 return (path != null) ? new File(path) : null; 292 } 293 294 public File getInternalPath() { 295 return (internalPath != null) ? new File(internalPath) : null; 296 } 297 298 public File getPathForUser(int userId) { 299 if (path == null) { 300 return null; 301 } else if (type == TYPE_PUBLIC) { 302 return new File(path); 303 } else if (type == TYPE_EMULATED) { 304 return new File(path, Integer.toString(userId)); 305 } else { 306 return null; 307 } 308 } 309 310 /** 311 * Path which is accessible to apps holding 312 * {@link android.Manifest.permission#WRITE_MEDIA_STORAGE}. 313 */ 314 public File getInternalPathForUser(int userId) { 315 if (type == TYPE_PUBLIC) { 316 // TODO: plumb through cleaner path from vold 317 return new File(path.replace("/storage/", "/mnt/media_rw/")); 318 } else { 319 return getPathForUser(userId); 320 } 321 } 322 323 public StorageVolume buildStorageVolume(Context context, int userId, boolean reportUnmounted) { 324 final StorageManager storage = context.getSystemService(StorageManager.class); 325 326 final boolean removable; 327 final boolean emulated; 328 final boolean allowMassStorage = false; 329 final String envState = reportUnmounted 330 ? Environment.MEDIA_UNMOUNTED : getEnvironmentForState(state); 331 332 File userPath = getPathForUser(userId); 333 if (userPath == null) { 334 userPath = new File("/dev/null"); 335 } 336 File internalPath = getInternalPathForUser(userId); 337 if (internalPath == null) { 338 internalPath = new File("/dev/null"); 339 } 340 341 String description = null; 342 String derivedFsUuid = fsUuid; 343 long maxFileSize = 0; 344 345 if (type == TYPE_EMULATED) { 346 emulated = true; 347 348 final VolumeInfo privateVol = storage.findPrivateForEmulated(this); 349 if (privateVol != null) { 350 description = storage.getBestVolumeDescription(privateVol); 351 derivedFsUuid = privateVol.fsUuid; 352 } 353 354 if (ID_EMULATED_INTERNAL.equals(id)) { 355 removable = false; 356 } else { 357 removable = true; 358 } 359 360 } else if (type == TYPE_PUBLIC) { 361 emulated = false; 362 removable = true; 363 364 description = storage.getBestVolumeDescription(this); 365 366 if ("vfat".equals(fsType)) { 367 maxFileSize = 4294967295L; 368 } 369 370 } else { 371 throw new IllegalStateException("Unexpected volume type " + type); 372 } 373 374 if (description == null) { 375 description = context.getString(android.R.string.unknownName); 376 } 377 378 return new StorageVolume(id, userPath, internalPath, description, isPrimary(), removable, 379 emulated, allowMassStorage, maxFileSize, new UserHandle(userId), 380 derivedFsUuid, envState); 381 } 382 383 public static int buildStableMtpStorageId(String fsUuid) { 384 if (TextUtils.isEmpty(fsUuid)) { 385 return StorageVolume.STORAGE_ID_INVALID; 386 } else { 387 int hash = 0; 388 for (int i = 0; i < fsUuid.length(); ++i) { 389 hash = 31 * hash + fsUuid.charAt(i); 390 } 391 hash = (hash ^ (hash << 16)) & 0xffff0000; 392 // Work around values that the spec doesn't allow, or that we've 393 // reserved for primary 394 if (hash == 0x00000000) hash = 0x00020000; 395 if (hash == 0x00010000) hash = 0x00020000; 396 if (hash == 0xffff0000) hash = 0xfffe0000; 397 return hash | 0x0001; 398 } 399 } 400 401 // TODO: avoid this layering violation 402 private static final String DOCUMENT_AUTHORITY = "com.android.externalstorage.documents"; 403 private static final String DOCUMENT_ROOT_PRIMARY_EMULATED = "primary"; 404 405 /** 406 * Build an intent to browse the contents of this volume. Only valid for 407 * {@link #TYPE_EMULATED} or {@link #TYPE_PUBLIC}. 408 */ 409 public @Nullable Intent buildBrowseIntent() { 410 return buildBrowseIntentForUser(UserHandle.myUserId()); 411 } 412 413 public @Nullable Intent buildBrowseIntentForUser(int userId) { 414 final Uri uri; 415 if (type == VolumeInfo.TYPE_PUBLIC && mountUserId == userId) { 416 uri = DocumentsContract.buildRootUri(DOCUMENT_AUTHORITY, fsUuid); 417 } else if (type == VolumeInfo.TYPE_EMULATED && isPrimary()) { 418 uri = DocumentsContract.buildRootUri(DOCUMENT_AUTHORITY, 419 DOCUMENT_ROOT_PRIMARY_EMULATED); 420 } else { 421 return null; 422 } 423 424 final Intent intent = new Intent(Intent.ACTION_VIEW); 425 intent.addCategory(Intent.CATEGORY_DEFAULT); 426 intent.setDataAndType(uri, DocumentsContract.Root.MIME_TYPE_ITEM); 427 428 // note that docsui treats this as *force* show advanced. So sending 429 // false permits advanced to be shown based on user preferences. 430 intent.putExtra(DocumentsContract.EXTRA_SHOW_ADVANCED, isPrimary()); 431 return intent; 432 } 433 434 @Override 435 public String toString() { 436 final CharArrayWriter writer = new CharArrayWriter(); 437 dump(new IndentingPrintWriter(writer, " ", 80)); 438 return writer.toString(); 439 } 440 441 public void dump(IndentingPrintWriter pw) { 442 pw.println("VolumeInfo{" + id + "}:"); 443 pw.increaseIndent(); 444 pw.printPair("type", DebugUtils.valueToString(getClass(), "TYPE_", type)); 445 pw.printPair("diskId", getDiskId()); 446 pw.printPair("partGuid", partGuid); 447 pw.printPair("mountFlags", DebugUtils.flagsToString(getClass(), "MOUNT_FLAG_", mountFlags)); 448 pw.printPair("mountUserId", mountUserId); 449 pw.printPair("state", DebugUtils.valueToString(getClass(), "STATE_", state)); 450 pw.println(); 451 pw.printPair("fsType", fsType); 452 pw.printPair("fsUuid", fsUuid); 453 pw.printPair("fsLabel", fsLabel); 454 pw.println(); 455 pw.printPair("path", path); 456 pw.printPair("internalPath", internalPath); 457 pw.decreaseIndent(); 458 pw.println(); 459 } 460 461 @Override 462 public VolumeInfo clone() { 463 final Parcel temp = Parcel.obtain(); 464 try { 465 writeToParcel(temp, 0); 466 temp.setDataPosition(0); 467 return CREATOR.createFromParcel(temp); 468 } finally { 469 temp.recycle(); 470 } 471 } 472 473 @Override 474 public boolean equals(Object o) { 475 if (o instanceof VolumeInfo) { 476 return Objects.equals(id, ((VolumeInfo) o).id); 477 } else { 478 return false; 479 } 480 } 481 482 @Override 483 public int hashCode() { 484 return id.hashCode(); 485 } 486 487 public static final Creator<VolumeInfo> CREATOR = new Creator<VolumeInfo>() { 488 @Override 489 public VolumeInfo createFromParcel(Parcel in) { 490 return new VolumeInfo(in); 491 } 492 493 @Override 494 public VolumeInfo[] newArray(int size) { 495 return new VolumeInfo[size]; 496 } 497 }; 498 499 @Override 500 public int describeContents() { 501 return 0; 502 } 503 504 @Override 505 public void writeToParcel(Parcel parcel, int flags) { 506 parcel.writeString(id); 507 parcel.writeInt(type); 508 if (disk != null) { 509 parcel.writeInt(1); 510 disk.writeToParcel(parcel, flags); 511 } else { 512 parcel.writeInt(0); 513 } 514 parcel.writeString(partGuid); 515 parcel.writeInt(mountFlags); 516 parcel.writeInt(mountUserId); 517 parcel.writeInt(state); 518 parcel.writeString(fsType); 519 parcel.writeString(fsUuid); 520 parcel.writeString(fsLabel); 521 parcel.writeString(path); 522 parcel.writeString(internalPath); 523 } 524 } 525
