/**@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(  ) {},


};