/**@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", /** 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 "vendor" partition that holds vendor-provided software that should persist across simple reflashing of the "system" partition. @hide */ getVendorDirectory : function( ) {}, /**Gets the system directory available for secure storage. If Encrypted File system is enabled, it returns an encrypted directory (/data/secure/system). Otherwise, it returns the unencrypted /data/system directory. @return {Object {java.io.File}} File object representing the secure storage system directory. @hide */ getSystemSecureDirectory : function( ) {}, /**Gets the data directory for secure storage. If Encrypted File system is enabled, it returns an encrypted directory (/data/secure). Otherwise, it returns the unencrypted /data directory. @return {Object {java.io.File}} File object representing the data directory for secure storage. @hide */ getSecureDataDirectory : 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. @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. @hide */ getUserConfigDirectory : function( ) {}, /**Returns whether the Encrypted File System feature is enabled on the device or not. @return {Boolean} <code>true</code> if Encrypted File System feature is enabled, <code>false</code> if disabled. @hide */ isEncryptedFilesystemEnabled : function( ) {}, /**Return the user data directory. */ getDataDirectory : function( ) {}, /**{@hide} */ getDataDirectory : function( ) {}, /**{@hide} */ getDataAppDirectory : function( ) {}, /**{@hide} */ getDataUserDirectory : function( ) {}, /**{@hide} */ getDataUserDirectory : function( ) {}, /**{@hide} */ getDataUserPackageDirectory : function( ) {}, /**Return the primary 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 external storage. Applications only have access to the external storage for the user they're running as. <p> In devices with multiple "external" storage directories, this directory represents the "primary" external storage that the user will interact with. Access to secondary storage is available through <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 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)} or {@link Context#getExternalCacheDir()}, 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() */ getExternalStorageDirectory : function( ) {}, /**{@hide} */ getLegacyExternalStorageDirectory : function( ) {}, /**{@hide} */ getLegacyExternalStorageObbDirectory : function( ) {}, /**Get a top-level public 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 external storage. Applications only have access to the external storage for the user they're running as.</p> <p>Here is an example of typical code to manipulate a picture on the public external 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}, or {@link #DIRECTORY_DCIM}. 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()}. */ 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( ) {}, /**Return the download/cache content directory. */ getDownloadCacheDirectory : function( ) {}, /**Returns the current state of the primary "external" storage device. @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 storage device that provides 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 "external" storage device is 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 storage device that provides the given path is 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 "external" storage device is emulated. If true, data stored on this device will be stored on a portion of the internal storage system. @see DevicePolicyManager#setStorageEncryption(android.content.ComponentName, boolean) */ isExternalStorageEmulated : function( ) {}, /**Returns whether the storage device that provides the given path is emulated. If true, data stored on this device will be stored on a portion of the internal storage system. @throws IllegalArgumentException if the path is not a valid storage device. */ isExternalStorageEmulated : 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. @hide */ maybeTranslateEmulatedPathToInternal : function( ) {}, };