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)
}
时间： 2024-08-26 05:02:47