Environment中有大量访问目录的函数

public class Environment {

    /**

     * Return root of the "system" partition holding the core Android OS.

     * Always present and mounted read-only.

     */

    public static File getRootDirectory() 

    /**

     * Return root directory of the "oem" partition holding OEM customizations,

     * if any. If present, the partition is mounted read-only.

     *

     * @hide

     */

    public static File getOemDirectory() 

    /**

     * Return root directory of the "vendor" partition that holds vendor-provided

     * software that should persist across simple reflashing of the "system" partition.

     * @hide

     */

    public static File getVendorDirectory() 

    /**

     * 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 File object representing the secure storage system directory.

     * @hide

     */

    public static File getSystemSecureDirectory() 

    /**

     * 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 File object representing the data directory for secure storage.

     * @hide

     */

    public static File getSecureDataDirectory() 

    /**

     * Return directory used for internal media storage, which is protected by

     * {@link android.Manifest.permission#WRITE_MEDIA_STORAGE}.

     *

     * @hide

     */

    public static File getMediaStorageDirectory() 

    /**

     * 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

     */

    public static File getUserSystemDirectory(int userId)

    /**

     * 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

     */

    public static File getUserConfigDirectory(int userId) 

    /**

     * Returns whether the Encrypted File System feature is enabled on the device or not.

     * @return <code>true</code> if Encrypted File System feature is enabled, <code>false</code>

     * if disabled.

     * @hide

     */

    public static boolean isEncryptedFilesystemEnabled() 

    private static final File DATA_DIRECTORY

            = getDirectory("ANDROID_DATA", "/data");

    /**

     * @hide

     */

    private static final File SECURE_DATA_DIRECTORY

            = getDirectory("ANDROID_SECURE_DATA", "/data/secure");

    private static final File DOWNLOAD_CACHE_DIRECTORY = getDirectory("DOWNLOAD_CACHE", "/cache");

    /**

     * Return the user data directory.

     */

    public static File getDataDirectory() 

    /**

     * 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 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()

     */

    public static File getExternalStorageDirectory() 

    /** {@hide} */

    public static File getLegacyExternalStorageDirectory() 

    /** {@hide} */

    public static File getLegacyExternalStorageObbDirectory() 

    /** {@hide} */

    public static File getEmulatedStorageSource(int userId) 

    /** {@hide} */

    public static File getEmulatedStorageObbSource() 

    /**

     * 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.

     */

    public static String DIRECTORY_MUSIC = "Music";

    /**

     * 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.

     */

    public static String DIRECTORY_PODCASTS = "Podcasts";

    /**

     * 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.

     */

    public static String DIRECTORY_RINGTONES = "Ringtones";

    /**

     * 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.

     */

    public static String DIRECTORY_ALARMS = "Alarms";

    /**

     * 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.

     */

    public static String DIRECTORY_NOTIFICATIONS = "Notifications";

    /**

     * 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.

     */

    public static String DIRECTORY_PICTURES = "Pictures";

    /**

     * 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.

     */

    public static String DIRECTORY_MOVIES = "Movies";

    /**

     * 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.

     */

    public static String DIRECTORY_DOWNLOADS = "Download";

    /**

     * 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.

     */

    public static String DIRECTORY_DCIM = "DCIM";

    /**

     * Standard directory in which to place documents that have been created by

     * the user.

     */

    public static String DIRECTORY_DOCUMENTS = "Documents";

    /**

     * 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 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 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 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()}.

     */

    public static File getExternalStoragePublicDirectory(String type)

    /**

     * Returns the path for android-specific data on the SD card.

     * @hide

     */

    public static File[] buildExternalStorageAndroidDataDirs() 

    /**

     * Generates the raw path to an application's data

     * @hide

     */

    public static File[] buildExternalStorageAppDataDirs(String packageName) 

    /**

     * Generates the raw path to an application's media

     * @hide

     */

    public static File[] buildExternalStorageAppMediaDirs(String packageName)

    /**

     * Generates the raw path to an application's OBB files

     * @hide

     */

    public static File[] buildExternalStorageAppObbDirs(String packageName)

    /**

     * Generates the path to an application's files.

     * @hide

     */

    public static File[] buildExternalStorageAppFilesDirs(String packageName) 

    /**

     * Generates the path to an application's cache.

     * @hide

     */

    public static File[] buildExternalStorageAppCacheDirs(String packageName) 

    /**

     * Return the download/cache content directory.

     */

    public static File getDownloadCacheDirectory() 

    /**

     * Unknown storage state, such as when a path isn't backed by known storage

     * media.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String MEDIA_UNKNOWN = "unknown";

    /**

     * Storage state if the media is not present.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String MEDIA_REMOVED = "removed";

    /**

     * Storage state if the media is present but not mounted.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String MEDIA_UNMOUNTED = "unmounted";

    /**

     * Storage state if the media is present and being disk-checked.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String MEDIA_CHECKING = "checking";

    /**

     * Storage state if the media is present but is blank or is using an

     * unsupported filesystem.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String MEDIA_NOFS = "nofs";

    /**

     * Storage state if the media is present and mounted at its mount point with

     * read/write access.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String MEDIA_MOUNTED = "mounted";

    /**

     * Storage state if the media is present and mounted at its mount point with

     * read-only access.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String MEDIA_MOUNTED_READ_ONLY = "mounted_ro";

    /**

     * Storage state if the media is present not mounted, and shared via USB

     * mass storage.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String MEDIA_SHARED = "shared";

    /**

     * Storage state if the media was removed before it was unmounted.

     *

     * @see #getExternalStorageState(File)

     */

    public static final String 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)

     */

    public static final String MEDIA_UNMOUNTABLE = "unmountable";

    /**

     * Returns the current state of the primary "external" storage device.

     *

     * @see #getExternalStorageDirectory()

     * @return 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}.

     */

    public static String getExternalStorageState() 

    /**

     * @deprecated use {@link #getExternalStorageState(File)}

     */

    @Deprecated

    public static String getStorageState(File path) 

    /**

     * Returns the current state of the storage device that provides the given

     * path.

     *

     * @return 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}.

     */

    public static String getExternalStorageState(File path) 

    /**

     * Returns whether the primary "external" storage device is removable.

     *

     * @return 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.

     */

    public static boolean isExternalStorageRemovable() 

    /**

     * Returns whether the storage device that provides the given path is

     * removable.

     *

     * @return 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.

     */

    public static boolean isExternalStorageRemovable(File path) 

    /**

     * 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)

     */

    public static boolean isExternalStorageEmulated() 

    /**

     * 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.

     */

    public static boolean isExternalStorageEmulated(File path)

    static File getDirectory(String variableName, String defaultPath)

    /** {@hide} */

    public static void setUserRequired(boolean userRequired) 

    /**

     * Append path segments to each given base path, returning result.

     *

     * @hide

     */

    public static File[] buildPaths(File[] base, String... segments) 

    /**

     * Append path segments to given base path, returning result.

     *

     * @hide

     */

    public static File buildPath(File base, String... segments) 

    private static boolean isStorageDisabled() 

    private static StorageVolume getStorageVolume(File path) 

    /**

     * 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

     */

    public static File maybeTranslateEmulatedPathToInternal(File path)

}