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