/**@class android.os.storage.StorageManager @extends java.lang.Object StorageManager is the interface to the systems storage service. The storage manager handles storage-related items such as Opaque Binary Blobs (OBBs). <p> 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. */ var StorageManager = { /**{@hide} */ PROP_PRIMARY_PHYSICAL : "ro.vold.primary_physical", /**{@hide} */ PROP_HAS_ADOPTABLE : "vold.has_adoptable", /**{@hide} */ PROP_HAS_RESERVED : "vold.has_reserved", /**{@hide} */ PROP_ADOPTABLE : "persist.sys.adoptable", /**{@hide} */ PROP_EMULATE_FBE : "persist.sys.emulate_fbe", /**{@hide} */ PROP_SDCARDFS : "persist.sys.sdcardfs", /**{@hide} */ PROP_VIRTUAL_DISK : "persist.sys.virtual_disk", /**{@hide} */ PROP_ISOLATED_STORAGE : "persist.sys.isolated_storage", /**{@hide} */ PROP_ISOLATED_STORAGE_SNAPSHOT : "sys.isolated_storage_snapshot", /**{@hide} */ UUID_PRIVATE_INTERNAL : "null", /**{@hide} */ UUID_PRIMARY_PHYSICAL : "primary_physical", /**{@hide} */ UUID_SYSTEM : "system", /** UUID representing the default internal storage of this device which provides {@link Environment#getDataDirectory()}. <p> 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 */ UUID_DEFAULT : "null", /**{@hide} */ UUID_PRIMARY_PHYSICAL_ : "null", /**{@hide} */ UUID_SYSTEM_ : "null", /** 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. <p> 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. <p> 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. */ 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) */ EXTRA_UUID : "android.os.storage.extra.UUID", /** Extra used to indicate the total size (in bytes) that an application is interested in allocating. <p> 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 */ EXTRA_REQUESTED_BYTES : "android.os.storage.extra.REQUESTED_BYTES", /**{@hide} */ DEBUG_ADOPTABLE_FORCE_ON : "1", /**{@hide} */ DEBUG_ADOPTABLE_FORCE_OFF : "2", /**{@hide} */ DEBUG_EMULATE_FBE : "4", /**{@hide} */ DEBUG_SDCARDFS_FORCE_ON : "8", /**{@hide} */ DEBUG_SDCARDFS_FORCE_OFF : "16", /**{@hide} */ DEBUG_VIRTUAL_DISK : "32", /**{@hide} */ DEBUG_ISOLATED_STORAGE_FORCE_ON : "64", /**{@hide} */ DEBUG_ISOLATED_STORAGE_FORCE_OFF : "128", /**{@hide} */ FLAG_STORAGE_DE : "null", /**{@hide} */ FLAG_STORAGE_CE : "null", /**{@hide} */ FLAG_STORAGE_EXTERNAL : "null", /**{@hide} */ FLAG_FOR_WRITE : "256", /**{@hide} */ FLAG_REAL_STATE : "512", /**{@hide} */ FLAG_INCLUDE_INVISIBLE : "1024", /**{@hide} */ FSTRIM_FLAG_DEEP : "null", /**@hide The volume is not encrypted. */ ENCRYPTION_STATE_NONE : "null", /**@hide The volume has been encrypted succesfully. */ ENCRYPTION_STATE_OK : "null", /**@hide The volume is in a bad state. */ ENCRYPTION_STATE_ERROR_UNKNOWN : "null", /**@hide Encryption is incomplete */ ENCRYPTION_STATE_ERROR_INCOMPLETE : "null", /**@hide Encryption is incomplete and irrecoverable */ ENCRYPTION_STATE_ERROR_INCONSISTENT : "null", /**@hide Underlying data is corrupt */ ENCRYPTION_STATE_ERROR_CORRUPT : "null", /** Flag indicating that a disk space allocation request should operate in an aggressive mode. This flag should only be rarely used in situations that are critical to system health or security. <p> When set, the system is more aggressive about the data that it considers for possible deletion when allocating disk space. <p class="note"> Note: your app must hold the {@link android.Manifest.permission#ALLOCATE_AGGRESSIVE} permission for this flag to take effect. </p> @see #getAllocatableBytes(UUID, int) @see #allocateBytes(UUID, long, int) @see #allocateBytes(FileDescriptor, long, int) @hide */ FLAG_ALLOCATE_AGGRESSIVE : "1", /** Flag indicating that a disk space allocation request should be allowed to clear up to all reserved disk space. @hide */ FLAG_ALLOCATE_DEFY_ALL_RESERVED : "2", /** Flag indicating that a disk space allocation request should be allowed to clear up to half of all reserved disk space. @hide */ FLAG_ALLOCATE_DEFY_HALF_RESERVED : "4", /**@hide */ CRYPT_TYPE_PASSWORD : "null", /**@hide */ CRYPT_TYPE_DEFAULT : "null", /**@hide */ CRYPT_TYPE_PATTERN : "null", /**@hide */ CRYPT_TYPE_PIN : "null", /**@hide */ SYSTEM_LOCALE_KEY : "SystemLocale", /**@hide */ OWNER_INFO_KEY : "OwnerInfo", /**@hide */ PATTERN_VISIBLE_KEY : "PatternVisible", /**@hide */ PASSWORD_VISIBLE_KEY : "PasswordVisible", /**{@hide} */ from : function( ) {}, /**Registers a {@link android.os.storage.StorageEventListener StorageEventListener}. @param {Object {StorageEventListener}} listener A {@link android.os.storage.StorageEventListener StorageEventListener} object. @hide */ registerListener : function( ) {}, /**Unregisters a {@link android.os.storage.StorageEventListener StorageEventListener}. @param {Object {StorageEventListener}} listener A {@link android.os.storage.StorageEventListener StorageEventListener} object. @hide */ unregisterListener : function( ) {}, /**Enables USB Mass Storage (UMS) on the device. @hide */ enableUsbMassStorage : function( ) {}, /**Disables USB Mass Storage (UMS) on the device. @hide */ disableUsbMassStorage : function( ) {}, /**Query if a USB Mass Storage (UMS) host is connected. @return {Boolean} true if UMS host is connected. @hide */ isUsbMassStorageConnected : function( ) {}, /**Query if a USB Mass Storage (UMS) is enabled on the device. @return {Boolean} true if UMS host is enabled. @hide */ isUsbMassStorageEnabled : function( ) {}, /**Mount an Opaque Binary Blob (OBB) file. If a <code>key</code> is specified, it is supplied to the mounting process to be used in any encryption used in the OBB. <p> 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 android.os.storage.OnObbStateChangeListener} registered with this call will receive the success or failure of this operation. <p> <em>Note:</em> 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 {String} rawPath the path to the OBB file @param {String} key secret used to encrypt the OBB; may be <code>null</code> if no encryption was used on the OBB. @param {Object {OnObbStateChangeListener}} listener will receive the success or failure of the operation @return {Boolean} whether the mount call was successfully queued or not */ mountObb : function( ) {}, /**Unmount an Opaque Binary Blob (OBB) file asynchronously. If the <code>force</code> flag is true, it will kill any application needed to unmount the given OBB (even the calling application). <p> The {@link android.os.storage.OnObbStateChangeListener} registered with this call will receive the success or failure of this operation. <p> <em>Note:</em> 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. <p> @param {String} rawPath path to the OBB file @param {Boolean} force whether to kill any programs using this in order to unmount it @param {Object {OnObbStateChangeListener}} listener will receive the success or failure of the operation @return {Boolean} whether the unmount call was successfully queued or not */ unmountObb : function( ) {}, /**Check whether an Opaque Binary Blob (OBB) is mounted or not. @param {String} rawPath path to OBB image @return {Boolean} true if OBB is mounted; false if not mounted or on error */ isObbMounted : function( ) {}, /**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 {String} rawPath path to OBB image @return {String} absolute path to mounted OBB image data or <code>null</code> if not mounted or exception encountered trying to read status */ getMountedObbPath : function( ) {}, /**{@hide} */ getDisks : function( ) {}, /**{@hide} */ findDiskById : function( ) {}, /**{@hide} */ findVolumeById : function( ) {}, /**{@hide} */ findVolumeByUuid : function( ) {}, /**{@hide} */ findRecordByUuid : function( ) {}, /**{@hide} */ findPrivateForEmulated : function( ) {}, /**{@hide} */ findEmulatedForPrivate : function( ) {}, /**{@hide} */ findVolumeByQualifiedUuid : function( ) {}, /**Return a UUID identifying the storage volume that hosts the given filesystem path. <p> 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. */ getUuidForPath : function( ) {}, /**{@hide} */ findPathForUuid : function( ) {}, /**Test if the given file descriptor supports allocation of disk space using {@link #allocateBytes(FileDescriptor, long)}. */ isAllocationSupported : function( ) {}, /**{@hide} */ getVolumes : function( ) {}, /**{@hide} */ getWritablePrivateVolumes : function( ) {}, /**{@hide} */ getVolumeRecords : function( ) {}, /**{@hide} */ getBestVolumeDescription : function( ) {}, /**{@hide} */ getPrimaryPhysicalVolume : function( ) {}, /**{@hide} */ mount : function( ) {}, /**{@hide} */ unmount : function( ) {}, /**{@hide} */ format : function( ) {}, /**{@hide} */ benchmark : function( ) {}, /**{@hide} */ benchmark : function( ) {}, /**{@hide} */ partitionPublic : function( ) {}, /**{@hide} */ partitionPrivate : function( ) {}, /**{@hide} */ partitionMixed : function( ) {}, /**{@hide} */ wipeAdoptableDisks : function( ) {}, /**{@hide} */ setVolumeNickname : function( ) {}, /**{@hide} */ setVolumeInited : function( ) {}, /**{@hide} */ setVolumeSnoozed : function( ) {}, /**{@hide} */ forgetVolume : function( ) {}, /**This is not the API you're looking for. @see PackageManager#getPrimaryStorageCurrentVolume() @hide */ getPrimaryStorageUuid : function( ) {}, /**This is not the API you're looking for. @see PackageManager#movePrimaryStorage(VolumeInfo) @hide */ setPrimaryStorageUuid : function( ) {}, /**Return the {@link android.os.storage.StorageVolume} that contains the given file, or {@code null} if none. */ getStorageVolume : function( ) {}, /**Return the {@link android.os.storage.StorageVolume} that contains the given {@link MediaStore} item. */ getStorageVolume : function( ) {}, /**{@hide} */ getStorageVolume : function( ) {}, /**Gets the state of a volume via its mountpoint. @hide */ getVolumeState : function( ) {}, /**Return the list of shared/external storage volumes available to the current user. This includes both the primary shared storage device and any attached external volumes including SD cards and USB drives. @see Environment#getExternalStorageDirectory() @see StorageVolume#createAccessIntent(String) */ getStorageVolumes : function( ) {}, /**Return the primary shared/external storage volume available to the current user. This volume is the same storage device returned by {@link Environment#getExternalStorageDirectory()} and {@link Context#getExternalFilesDir(String)}. */ getPrimaryStorageVolume : function( ) {}, /**{@hide} */ getPrimaryStoragePathAndSize : function( ) {}, /**{@hide} */ getPrimaryStorageSize : function( ) {}, /**{@hide} */ mkdirs : function( ) {}, /** @removed */ getVolumeList : function( ) {}, /**{@hide} */ getVolumeList : function( ) {}, /**Returns list of paths for all mountable volumes. @hide */ getVolumePaths : function( ) {}, /** @removed */ getPrimaryVolume : function( ) {}, /**{@hide} */ getPrimaryVolume : function( ) {}, /**Return the number of available bytes until the given path is considered running low on storage. @hide */ getStorageBytesUntilLow : function( ) {}, /**Return the number of available bytes at which the given path is considered running low on storage. @hide */ getStorageLowBytes : function( ) {}, /**Return the minimum number of bytes of storage on the device that should be reserved for cached data. @hide */ getStorageCacheBytes : function( ) {}, /**Return the number of available bytes at which the given path is considered full. @hide */ getStorageFullBytes : function( ) {}, /**{@hide} */ createUserKey : function( ) {}, /**{@hide} */ destroyUserKey : function( ) {}, /**{@hide} */ unlockUserKey : function( ) {}, /**{@hide} */ lockUserKey : function( ) {}, /**{@hide} */ prepareUserStorage : function( ) {}, /**{@hide} */ destroyUserStorage : function( ) {}, /**{@hide} */ isUserKeyUnlocked : function( ) {}, /**Return if data stored at or under the given path will be encrypted while at rest. This can help apps avoid the overhead of double-encrypting data. */ isEncrypted : function( ) {}, /**{@hide} Is this device encryptable or already encrypted? @return {Boolean} true for encryptable or encrypted false not encrypted and not encryptable */ isEncryptable : function( ) {}, /**{@hide} Is this device already encrypted? @return {Boolean} true for encrypted. (Implies isEncryptable() == true) false not encrypted */ isEncrypted : function( ) {}, /**{@hide} Is this device file encrypted? @return {Boolean} true for file encrypted. (Implies isEncrypted() == true) false not encrypted or block encrypted */ isFileEncryptedNativeOnly : function( ) {}, /**{@hide} Is this device block encrypted? @return {Boolean} true for block encrypted. (Implies isEncrypted() == true) false not encrypted or file encrypted */ isBlockEncrypted : function( ) {}, /**{@hide} Is this device block encrypted with credentials? @return {Boolean} true for crediential block encrypted. (Implies isBlockEncrypted() == true) false not encrypted, file encrypted or default block encrypted */ isNonDefaultBlockEncrypted : function( ) {}, /**{@hide} Is this device in the process of being block encrypted? @return {Boolean} true for encrypting. false otherwise Whether device isEncrypted at this point is undefined Note that only system services and CryptKeeper will ever see this return true - no app will ever be launched in this state. Also note that this state will not change without a teardown of the framework, so no service needs to check for changes during their lifespan */ isBlockEncrypting : function( ) {}, /**{@hide} Is this device non default block encrypted and in the process of prompting for credentials? @return {Boolean} true for prompting for credentials. (Implies isNonDefaultBlockEncrypted() == true) false otherwise Note that only system services and CryptKeeper will ever see this return true - no app will ever be launched in this state. Also note that this state will not change without a teardown of the framework, so no service needs to check for changes during their lifespan */ inCryptKeeperBounce : function( ) {}, /**{@hide} */ isFileEncryptedEmulatedOnly : function( ) {}, /**{@hide} Is this device running in a file encrypted mode, either native or emulated? @return {Boolean} true for file encrypted, false otherwise */ isFileEncryptedNativeOrEmulated : function( ) {}, /**{@hide} */ hasAdoptable : function( ) {}, /**Return if the currently booted device has the "isolated storage" feature flag enabled. This will eventually be fully enabled in the final {@link android.os.Build.VERSION_CODES#Q} release. @hide */ hasIsolatedStorage : function( ) {}, /** @deprecated disabled now that FUSE has been replaced by sdcardfs @hide */ maybeTranslateEmulatedPathToInternal : function( ) {}, /**Translate given shared storage path from a path in an app sandbox namespace to a path in the system namespace. @hide */ translateAppToSystem : function( ) {}, /**Translate given shared storage path from a path in the system namespace to a path in an app sandbox namespace. @hide */ translateSystemToApp : function( ) {}, /**Check that given app holds both permission and appop. @hide */ checkPermissionAndAppOp : function( ) {}, /**Check that given app holds both permission and appop but do not noteOp. @hide */ checkPermissionAndCheckOp : function( ) {}, /**{@hide} */ checkPermissionReadAudio : function( ) {}, /**{@hide} */ checkPermissionWriteAudio : function( ) {}, /**{@hide} */ checkPermissionReadVideo : function( ) {}, /**{@hide} */ checkPermissionWriteVideo : function( ) {}, /**{@hide} */ checkPermissionReadImages : function( ) {}, /**{@hide} */ checkPermissionWriteImages : function( ) {}, /**{@hide} */ openProxyFileDescriptor : function( ) {}, /**{@hide} */ openProxyFileDescriptor : function( ) {}, /**Opens a seekable {@link ParcelFileDescriptor} that proxies all low-level I/O requests back to the given {@link ProxyFileDescriptorCallback}. <p> 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. <p> 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 {Number} 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 {Object {ProxyFileDescriptorCallback}} callback Callback to process file operation requests issued on returned file descriptor. @param {Object {Handler}} handler Handler that invokes callback methods. @return {Object {android.os.ParcelFileDescriptor}} Seekable ParcelFileDescriptor. @throws IOException */ openProxyFileDescriptor : function( ) {}, /**{@hide} */ getProxyFileDescriptorMountPointId : function( ) {}, /**Return quota size in bytes for all cached data belonging to the calling app on the given storage volume. <p> 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. <p> 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. <p class="note"> 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. </p> @param {Object {UUID}} storageUuid the UUID of the storage volume that you're interested in. The UUID for a specific path can be obtained using {@link #getUuidForPath(File)}. @throws IOException when the storage device isn't present, or when it doesn't support cache quotas. @see #getCacheSizeBytes(UUID) */ getCacheQuotaBytes : function( ) {}, /**Return total size in bytes of all cached data belonging to the calling app on the given storage volume. <p> 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. <p class="note"> 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. </p> @param {Object {UUID}} storageUuid the UUID of the storage volume that you're interested in. The UUID for a specific path can be obtained using {@link #getUuidForPath(File)}. @throws IOException when the storage device isn't present, or when it doesn't support cache quotas. @see #getCacheQuotaBytes(UUID) */ getCacheSizeBytes : function( ) {}, /**Return the maximum number of new bytes that your app can allocate for itself on the given storage volume. This value is typically larger than {@link File#getUsableSpace()}, since the system may be willing to delete cached files to satisfy an allocation request. You can then allocate space for yourself using {@link #allocateBytes(UUID, long)} or {@link #allocateBytes(FileDescriptor, long)}. <p> 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. <p> 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. <p> 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. <p class="note"> 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. </p> @param {Object {UUID}} storageUuid the UUID of the storage volume where you're considering allocating disk space, since allocatable space can vary widely depending on the underlying storage device. The UUID for a specific path can be obtained using {@link #getUuidForPath(File)}. @return {Number} the maximum number of new bytes that the calling app can allocate using {@link #allocateBytes(UUID, long)} or {@link #allocateBytes(FileDescriptor, long)}. @throws IOException when the storage device isn't present, or when it doesn't support allocating space. */ getAllocatableBytes : function( ) {}, /** @hide */ getAllocatableBytes : function( ) {}, /**Allocate the requested number of bytes for your application to use on the given storage volume. This will cause the system to delete any cached files necessary to satisfy your request. <p> Attempts to allocate disk space beyond the value returned by {@link #getAllocatableBytes}(UUID) will fail. <p> 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. <p> 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 {Object {UUID}} 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 {Number} 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) */ allocateBytes : function( ) {}, /** @hide */ allocateBytes : function( ) {}, /**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. <p> Attempts to allocate disk space beyond the value returned by {@link #getAllocatableBytes}(UUID) will fail. <p> 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. <p> 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 {Object {FileDescriptor}} fd the open file that you'd like to allocate disk space for. @param {Number} 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 #isAllocationSupported(FileDescriptor) @see Environment#isExternalStorageEmulated(File) */ allocateBytes : function( ) {}, /** @hide */ allocateBytes : function( ) {}, /**Enable or disable special cache behavior that treats this directory and its contents as an entire group. <p> 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. <p> When enabled, the <em>newest</em> {@link File#lastModified()} value of any contained files is considered the modified time of the entire directory. <p> This behavior can only be set on a directory, and it applies recursively to all contained files and directories. */ setCacheBehaviorGroup : function( ) {}, /**Read the current value set by {@link #setCacheBehaviorGroup(File, boolean)}. */ isCacheBehaviorGroup : function( ) {}, /**Enable or disable special cache behavior that leaves deleted cache files intact as tombstones. <p> 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. <p> This behavior can only be set on a directory, and it applies recursively to all contained files and directories. <p class="note"> Note: this behavior is ignored completely if the user explicitly requests that all cached data be cleared. </p> */ setCacheBehaviorTombstone : function( ) {}, /**Read the current value set by {@link #setCacheBehaviorTombstone(File, boolean)}. */ isCacheBehaviorTombstone : function( ) {}, /**{@hide} */ convert : function( ) {}, /**{@hide} */ convert : function( ) {}, };