/**@class android.os.Environment @extends java.lang.Object Provides access to environment variables. */ var Environment = { /**{@hide} */ DIR_ANDROID : "Android", /**{@hide} */ DIRECTORY_ANDROID : "Android", /** Standard directory in which to place any audio files that should be in the regular list of music for the user. This may be combined with {@link #DIRECTORY_PODCASTS}, {@link #DIRECTORY_NOTIFICATIONS}, {@link #DIRECTORY_ALARMS}, and {@link #DIRECTORY_RINGTONES} as a series of directories to categories a particular audio file as more than one type. */ DIRECTORY_MUSIC : "null", /** Standard directory in which to place any audio files that should be in the list of podcasts that the user can select (not as regular music). This may be combined with {@link #DIRECTORY_MUSIC}, {@link #DIRECTORY_NOTIFICATIONS}, {@link #DIRECTORY_ALARMS}, and {@link #DIRECTORY_RINGTONES} as a series of directories to categories a particular audio file as more than one type. */ DIRECTORY_PODCASTS : "null", /** Standard directory in which to place any audio files that should be in the list of ringtones that the user can select (not as regular music). This may be combined with {@link #DIRECTORY_MUSIC}, {@link #DIRECTORY_PODCASTS}, {@link #DIRECTORY_NOTIFICATIONS}, and {@link #DIRECTORY_ALARMS} as a series of directories to categories a particular audio file as more than one type. */ DIRECTORY_RINGTONES : "null", /** Standard directory in which to place any audio files that should be in the list of alarms that the user can select (not as regular music). This may be combined with {@link #DIRECTORY_MUSIC}, {@link #DIRECTORY_PODCASTS}, {@link #DIRECTORY_NOTIFICATIONS}, and {@link #DIRECTORY_RINGTONES} as a series of directories to categories a particular audio file as more than one type. */ DIRECTORY_ALARMS : "null", /** Standard directory in which to place any audio files that should be in the list of notifications that the user can select (not as regular music). This may be combined with {@link #DIRECTORY_MUSIC}, {@link #DIRECTORY_PODCASTS}, {@link #DIRECTORY_ALARMS}, and {@link #DIRECTORY_RINGTONES} as a series of directories to categories a particular audio file as more than one type. */ DIRECTORY_NOTIFICATIONS : "null", /** Standard directory in which to place pictures that are available to the user. Note that this is primarily a convention for the top-level public directory, as the media scanner will find and collect pictures in any directory. */ DIRECTORY_PICTURES : "null", /** Standard directory in which to place movies that are available to the user. Note that this is primarily a convention for the top-level public directory, as the media scanner will find and collect movies in any directory. */ DIRECTORY_MOVIES : "null", /** Standard directory in which to place files that have been downloaded by the user. Note that this is primarily a convention for the top-level public directory, you are free to download files anywhere in your own private directories. Also note that though the constant here is named DIRECTORY_DOWNLOADS (plural), the actual file name is non-plural for backwards compatibility reasons. */ DIRECTORY_DOWNLOADS : "null", /** The traditional location for pictures and videos when mounting the device as a camera. Note that this is primarily a convention for the top-level public directory, as this convention makes no sense elsewhere. */ DIRECTORY_DCIM : "null", /** Standard directory in which to place documents that have been created by the user. */ DIRECTORY_DOCUMENTS : "null", /** Standard directory in which to place screenshots that have been taken by the user. Typically used as a secondary directory under {@link #DIRECTORY_PICTURES}. */ DIRECTORY_SCREENSHOTS : "null", /** Standard directory in which to place any audio files which are audiobooks. */ DIRECTORY_AUDIOBOOKS : "null", /** List of standard storage directories. <p> Each of its values have its own constant: <ul> <li>{@link #DIRECTORY_MUSIC} <li>{@link #DIRECTORY_PODCASTS} <li>{@link #DIRECTORY_ALARMS} <li>{@link #DIRECTORY_RINGTONES} <li>{@link #DIRECTORY_NOTIFICATIONS} <li>{@link #DIRECTORY_PICTURES} <li>{@link #DIRECTORY_MOVIES} <li>{@link #DIRECTORY_DOWNLOADS} <li>{@link #DIRECTORY_DCIM} <li>{@link #DIRECTORY_DOCUMENTS} <li>{@link #DIRECTORY_AUDIOBOOKS} </ul> @hide */ STANDARD_DIRECTORIES : "null", /**{@hide} */ HAS_MUSIC : "1", /**{@hide} */ HAS_PODCASTS : "2", /**{@hide} */ HAS_RINGTONES : "4", /**{@hide} */ HAS_ALARMS : "8", /**{@hide} */ HAS_NOTIFICATIONS : "16", /**{@hide} */ HAS_PICTURES : "32", /**{@hide} */ HAS_MOVIES : "64", /**{@hide} */ HAS_DOWNLOADS : "128", /**{@hide} */ HAS_DCIM : "256", /**{@hide} */ HAS_DOCUMENTS : "512", /**{@hide} */ HAS_AUDIOBOOKS : "1024", /**{@hide} */ HAS_ANDROID : "65536", /**{@hide} */ HAS_OTHER : "131072", /** Unknown storage state, such as when a path isn't backed by known storage media. @see #getExternalStorageState(File) */ MEDIA_UNKNOWN : "unknown", /** Storage state if the media is not present. @see #getExternalStorageState(File) */ MEDIA_REMOVED : "removed", /** Storage state if the media is present but not mounted. @see #getExternalStorageState(File) */ MEDIA_UNMOUNTED : "unmounted", /** Storage state if the media is present and being disk-checked. @see #getExternalStorageState(File) */ MEDIA_CHECKING : "checking", /** Storage state if the media is present but is blank or is using an unsupported filesystem. @see #getExternalStorageState(File) */ MEDIA_NOFS : "nofs", /** Storage state if the media is present and mounted at its mount point with read/write access. @see #getExternalStorageState(File) */ MEDIA_MOUNTED : "mounted", /** Storage state if the media is present and mounted at its mount point with read-only access. @see #getExternalStorageState(File) */ MEDIA_MOUNTED_READ_ONLY : "mounted_ro", /** Storage state if the media is present not mounted, and shared via USB mass storage. @see #getExternalStorageState(File) */ MEDIA_SHARED : "shared", /** Storage state if the media was removed before it was unmounted. @see #getExternalStorageState(File) */ MEDIA_BAD_REMOVAL : "bad_removal", /** Storage state if the media is present but cannot be mounted. Typically this happens if the file system on the media is corrupted. @see #getExternalStorageState(File) */ MEDIA_UNMOUNTABLE : "unmountable", /** Storage state if the media is in the process of being ejected. @see #getExternalStorageState(File) */ MEDIA_EJECTING : "ejecting", /**{@hide} */ initForCurrentUser : function( ) {}, /**Return root of the "system" partition holding the core Android OS. Always present and mounted read-only. */ getRootDirectory : function( ) {}, /**{@hide} */ getStorageDirectory : function( ) {}, /**Return root directory of the "oem" partition holding OEM customizations, if any. If present, the partition is mounted read-only. @hide */ getOemDirectory : function( ) {}, /**Return root directory of the "odm" partition holding ODM customizations, if any. If present, the partition is mounted read-only. @hide */ getOdmDirectory : function( ) {}, /**Return root directory of the "vendor" partition that holds vendor-provided software that should persist across simple reflashing of the "system" partition. @hide */ getVendorDirectory : function( ) {}, /**Return root directory of the "product" partition holding product-specific customizations if any. If present, the partition is mounted read-only. @hide */ getProductDirectory : function( ) {}, /**Return root directory of the "product_services" partition holding middleware services if any. If present, the partition is mounted read-only. @hide */ getProductServicesDirectory : function( ) {}, /**Return the system directory for a user. This is for use by system services to store files relating to the user. This directory will be automatically deleted when the user is removed. @deprecated This directory is valid and still exists, but but callers should <em>strongly</em> consider switching to using either {@link #getDataSystemCeDirectory(int)} or {@link #getDataSystemDeDirectory(int)}, both of which support fast user wipe. @hide */ getUserSystemDirectory : function( ) {}, /**Returns the config directory for a user. This is for use by system services to store files relating to the user which should be readable by any app running as that user. @deprecated This directory is valid and still exists, but callers should <em>strongly</em> consider switching to {@link #getDataMiscCeDirectory(int)} which is protected with user credentials or {@link #getDataMiscDeDirectory(int)} which supports fast user wipe. @hide */ getUserConfigDirectory : function( ) {}, /**Return the user data directory. */ getDataDirectory : function( ) {}, /**{@hide} */ getDataDirectory : function( ) {}, /**{@hide} */ getExpandDirectory : function( ) {}, /**{@hide} */ getDataSystemDirectory : function( ) {}, /**Returns the base directory for per-user system directory, device encrypted. {@hide} */ getDataSystemDeDirectory : function( ) {}, /**Returns the base directory for per-user system directory, credential encrypted. {@hide} */ getDataSystemCeDirectory : function( ) {}, /**Return the "credential encrypted" system directory for a user. This is for use by system services to store files relating to the user. This directory supports fast user wipe, and will be automatically deleted when the user is removed. <p> Data stored under this path is "credential encrypted", which uses an encryption key that is entangled with user credentials, such as a PIN or password. The contents will only be available once the user has been unlocked, as reported by {@code SystemService.onUnlockUser()}. <p> New code should <em>strongly</em> prefer storing sensitive data in these credential encrypted areas. @hide */ getDataSystemCeDirectory : function( ) {}, /**Return the "device encrypted" system directory for a user. This is for use by system services to store files relating to the user. This directory supports fast user wipe, and will be automatically deleted when the user is removed. <p> Data stored under this path is "device encrypted", which uses an encryption key that is tied to the physical device. The contents will only be available once the device has finished a {@code dm-verity} protected boot. <p> New code should <em>strongly</em> avoid storing sensitive data in these device encrypted areas. @hide */ getDataSystemDeDirectory : function( ) {}, /**{@hide} */ getDataMiscDirectory : function( ) {}, /**{@hide} */ getDataMiscCeDirectory : function( ) {}, /**{@hide} */ getDataMiscCeDirectory : function( ) {}, /**{@hide} */ getDataMiscDeDirectory : function( ) {}, /**{@hide} */ getDataVendorCeDirectory : function( ) {}, /**{@hide} */ getDataVendorDeDirectory : function( ) {}, /**{@hide} */ getDataRefProfilesDePackageDirectory : function( ) {}, /**{@hide} */ getDataProfilesDePackageDirectory : function( ) {}, /**{@hide} */ getDataAppDirectory : function( ) {}, /**{@hide} */ getDataStagingDirectory : function( ) {}, /**{@hide} */ getDataUserCeDirectory : function( ) {}, /**{@hide} */ getDataUserCeDirectory : function( ) {}, /**{@hide} */ getDataUserCePackageDirectory : function( ) {}, /**{@hide} */ getDataUserDeDirectory : function( ) {}, /**{@hide} */ getDataUserDeDirectory : function( ) {}, /**{@hide} */ getDataUserDePackageDirectory : function( ) {}, /**Return preloads directory. <p>This directory may contain pre-loaded content such as {@link #getDataPreloadsDemoDirectory() demo videos} and {@link #getDataPreloadsAppsDirectory() APK files} . {@hide} */ getDataPreloadsDirectory : function( ) {}, /** @see #getDataPreloadsDirectory() {@hide} */ getDataPreloadsDemoDirectory : function( ) {}, /** @see #getDataPreloadsDirectory() {@hide} */ getDataPreloadsAppsDirectory : function( ) {}, /** @see #getDataPreloadsDirectory() {@hide} */ getDataPreloadsMediaDirectory : function( ) {}, /**Returns location of preloaded cache directory for package name @see #getDataPreloadsDirectory() {@hide} */ getDataPreloadsFileCacheDirectory : function( ) {}, /**Returns location of preloaded cache directory. @see #getDataPreloadsDirectory() {@hide} */ getDataPreloadsFileCacheDirectory : function( ) {}, /**Returns location of packages cache directory. {@hide} */ getPackageCacheDirectory : function( ) {}, /**Return the primary shared/external storage directory. This directory may not currently be accessible if it has been mounted by the user on their computer, has been removed from the device, or some other problem has happened. You can determine its current state with {@link #getExternalStorageState}(). <p> <em>Note: don't be confused by the word "external" here. This directory can better be thought as media/shared storage. It is a filesystem that can hold a relatively large amount of data and that is shared across all applications (does not enforce permissions). Traditionally this is an SD card, but it may also be implemented as built-in storage in a device that is distinct from the protected internal storage and can be mounted as a filesystem on a computer.</em> <p> On devices with multiple users (as described by {@link android.os.UserManager}), each user has their own isolated shared storage. Applications only have access to the shared storage for the user they're running as. <p> In devices with multiple shared/external storage directories, this directory represents the primary storage that the user will interact with. Access to secondary storage is available through {@link Context#getExternalFilesDirs(String)}, {@link Context#getExternalCacheDirs()}, and {@link Context#getExternalMediaDirs()}. <p> Applications should not directly use this top-level directory, in order to avoid polluting the user's root namespace. Any files that are private to the application should be placed in a directory returned by {@link android.content.Context#getExternalFilesDir Context.getExternalFilesDir}, which the system will take care of deleting if the application is uninstalled. Other shared files should be placed in one of the directories returned by {@link #getExternalStoragePublicDirectory}. <p> Writing to this path requires the {@link android.Manifest.permission#WRITE_EXTERNAL_STORAGE} permission, and starting in {@link android.os.Build.VERSION_CODES#KITKAT}, read access requires the {@link android.Manifest.permission#READ_EXTERNAL_STORAGE} permission, which is automatically granted if you hold the write permission. <p> Starting in {@link android.os.Build.VERSION_CODES#KITKAT}, if your application only needs to store internal data, consider using {@link Context#getExternalFilesDir(String)}, {@link Context#getExternalCacheDir()}, or {@link Context#getExternalMediaDirs()}, which require no permissions to read or write. <p> This path may change between platform versions, so applications should only persist relative paths. <p> Here is an example of typical code to monitor the state of external storage: <p> {@sample development/samples/ApiDemos/src/com/example/android/apis/content/ExternalStorage.java monitor_storage} @see #getExternalStorageState() @see #isExternalStorageRemovable() @deprecated To improve user privacy, direct access to shared/external storage devices is deprecated. When an app targets {@link android.os.Build.VERSION_CODES#Q}, the path returned from this method is no longer directly accessible to apps. Apps can continue to access content stored on shared/external storage by migrating to alternatives such as {@link Context#getExternalFilesDir(String)}, {@link MediaStore}, or {@link Intent#ACTION_OPEN_DOCUMENT}. */ getExternalStorageDirectory : function( ) {}, /**{@hide} */ getLegacyExternalStorageDirectory : function( ) {}, /**{@hide} */ getLegacyExternalStorageObbDirectory : function( ) {}, /** @hide */ isStandardDirectory : function( ) {}, /**Classify the content types present on the given external storage device. <p> This is typically useful for deciding if an inserted SD card is empty, or if it contains content like photos that should be preserved. @hide */ classifyExternalStorageDirectory : function( ) {}, /**Get a top-level shared/external storage directory for placing files of a particular type. This is where the user will typically place and manage their own files, so you should be careful about what you put here to ensure you don't erase their files or get in the way of their own organization. <p> On devices with multiple users (as described by {@link android.os.UserManager}), each user has their own isolated shared storage. Applications only have access to the shared storage for the user they're running as. </p> <p> Here is an example of typical code to manipulate a picture on the public shared storage: </p> {@sample development/samples/ApiDemos/src/com/example/android/apis/content/ExternalStorage.java public_picture} @param {String} type The type of storage directory to return. Should be one of {@link #DIRECTORY_MUSIC}, {@link #DIRECTORY_PODCASTS}, {@link #DIRECTORY_RINGTONES}, {@link #DIRECTORY_ALARMS}, {@link #DIRECTORY_NOTIFICATIONS}, {@link #DIRECTORY_PICTURES}, {@link #DIRECTORY_MOVIES}, {@link #DIRECTORY_DOWNLOADS}, {@link #DIRECTORY_DCIM}, or {@link #DIRECTORY_DOCUMENTS}. May not be null. @return {Object {java.io.File}} Returns the File path for the directory. Note that this directory may not yet exist, so you must make sure it exists before using it such as with {@link File#mkdirs File.mkdirs()}. @deprecated To improve user privacy, direct access to shared/external storage devices is deprecated. When an app targets {@link android.os.Build.VERSION_CODES#Q}, the path returned from this method is no longer directly accessible to apps. Apps can continue to access content stored on shared/external storage by migrating to alternatives such as {@link Context#getExternalFilesDir(String)}, {@link MediaStore}, or {@link Intent#ACTION_OPEN_DOCUMENT}. */ getExternalStoragePublicDirectory : function( ) {}, /**Returns the path for android-specific data on the SD card. @hide */ buildExternalStorageAndroidDataDirs : function( ) {}, /**Generates the raw path to an application's data @hide */ buildExternalStorageAppDataDirs : function( ) {}, /**Generates the raw path to an application's media @hide */ buildExternalStorageAppMediaDirs : function( ) {}, /**Generates the raw path to an application's OBB files @hide */ buildExternalStorageAppObbDirs : function( ) {}, /**Generates the path to an application's files. @hide */ buildExternalStorageAppFilesDirs : function( ) {}, /**Generates the path to an application's cache. @hide */ buildExternalStorageAppCacheDirs : function( ) {}, /** @hide */ buildExternalStoragePublicDirs : function( ) {}, /**Return the download/cache content directory. */ getDownloadCacheDirectory : function( ) {}, /**Returns the current state of the primary shared/external storage media. @see #getExternalStorageDirectory() @return {String} one of {@link #MEDIA_UNKNOWN}, {@link #MEDIA_REMOVED}, {@link #MEDIA_UNMOUNTED}, {@link #MEDIA_CHECKING}, {@link #MEDIA_NOFS}, {@link #MEDIA_MOUNTED}, {@link #MEDIA_MOUNTED_READ_ONLY}, {@link #MEDIA_SHARED}, {@link #MEDIA_BAD_REMOVAL}, or {@link #MEDIA_UNMOUNTABLE}. */ getExternalStorageState : function( ) {}, /** @deprecated use {@link #getExternalStorageState(File)} */ getStorageState : function( ) {}, /**Returns the current state of the shared/external storage media at the given path. @return {String} one of {@link #MEDIA_UNKNOWN}, {@link #MEDIA_REMOVED}, {@link #MEDIA_UNMOUNTED}, {@link #MEDIA_CHECKING}, {@link #MEDIA_NOFS}, {@link #MEDIA_MOUNTED}, {@link #MEDIA_MOUNTED_READ_ONLY}, {@link #MEDIA_SHARED}, {@link #MEDIA_BAD_REMOVAL}, or {@link #MEDIA_UNMOUNTABLE}. */ getExternalStorageState : function( ) {}, /**Returns whether the primary shared/external storage media is physically removable. @return {Boolean} true if the storage device can be removed (such as an SD card), or false if the storage device is built in and cannot be physically removed. */ isExternalStorageRemovable : function( ) {}, /**Returns whether the shared/external storage media at the given path is physically removable. @return {Boolean} true if the storage device can be removed (such as an SD card), or false if the storage device is built in and cannot be physically removed. @throws IllegalArgumentException if the path is not a valid storage device. */ isExternalStorageRemovable : function( ) {}, /**Returns whether the primary shared/external storage media is emulated. <p> The contents of emulated storage devices are backed by a private user data partition, which means there is little benefit to apps storing data here instead of the private directories returned by {@link Context#getFilesDir()}, etc. <p> This returns true when emulated storage is backed by either internal storage or an adopted storage device. @see DevicePolicyManager#setStorageEncryption(android.content.ComponentName, boolean) */ isExternalStorageEmulated : function( ) {}, /**Returns whether the shared/external storage media at the given path is emulated. <p> The contents of emulated storage devices are backed by a private user data partition, which means there is little benefit to apps storing data here instead of the private directories returned by {@link Context#getFilesDir()}, etc. <p> This returns true when emulated storage is backed by either internal storage or an adopted storage device. @throws IllegalArgumentException if the path is not a valid storage device. */ isExternalStorageEmulated : function( ) {}, /**Returns whether the primary shared/external storage media is a legacy view that includes files not owned by the app. <p> This value may be different from the value requested by {@code requestLegacyExternalStorage} in the app's manifest, since an app may inherit its legacy state based on when it was first installed. <p> Non-legacy apps can continue to discover and read media belonging to other apps via {@link android.provider.MediaStore}. */ isExternalStorageLegacy : function( ) {}, /**Returns whether the shared/external storage media at the given path is a legacy view that includes files not owned by the app. <p> This value may be different from the value requested by {@code requestLegacyExternalStorage} in the app's manifest, since an app may inherit its legacy state based on when it was first installed. <p> Non-legacy apps can continue to discover and read media belonging to other apps via {@link android.provider.MediaStore}. @throws IllegalArgumentException if the path is not a valid storage device. */ isExternalStorageLegacy : function( ) {}, /**{@hide} */ setUserRequired : function( ) {}, /**Append path segments to each given base path, returning result. @hide */ buildPaths : function( ) {}, /**Append path segments to given base path, returning result. @hide */ buildPath : function( ) {}, /**If the given path exists on emulated external storage, return the translated backing path hosted on internal storage. This bypasses any emulation later, improving performance. This is <em>only</em> suitable for read-only access. <p> Returns original path if given path doesn't meet these criteria. Callers must hold {@link android.Manifest.permission#WRITE_MEDIA_STORAGE} permission. @deprecated disabled now that FUSE has been replaced by sdcardfs @hide */ maybeTranslateEmulatedPathToInternal : function( ) {}, };