android.os.Environment Maven / Gradle / Ivy
Show all versions of android-all Show documentation
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.os;
import android.content.res.Resources;
import android.os.storage.IMountService;
import android.os.storage.StorageVolume;
import android.util.Log;
import java.io.File;
/**
* Provides access to environment variables.
*/
public class Environment {
private static final String TAG = "Environment";
private static final File ROOT_DIRECTORY
= getDirectory("ANDROID_ROOT", "/system");
private static final String SYSTEM_PROPERTY_EFS_ENABLED = "persist.security.efs.enabled";
private static final Object mLock = new Object();
private volatile static StorageVolume mPrimaryVolume = null;
private static StorageVolume getPrimaryVolume() {
if (mPrimaryVolume == null) {
synchronized (mLock) {
if (mPrimaryVolume == null) {
try {
IMountService mountService = IMountService.Stub.asInterface(ServiceManager
.getService("mount"));
Parcelable[] volumes = mountService.getVolumeList();
mPrimaryVolume = (StorageVolume)volumes[0];
} catch (Exception e) {
Log.e(TAG, "couldn't talk to MountService", e);
}
}
}
}
return mPrimaryVolume;
}
/**
* Gets the Android root directory.
*/
public static File getRootDirectory() {
return ROOT_DIRECTORY;
}
/**
* 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() {
if (isEncryptedFilesystemEnabled()) {
return new File(SECURE_DATA_DIRECTORY, "system");
} else {
return new File(DATA_DIRECTORY, "system");
}
}
/**
* 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() {
if (isEncryptedFilesystemEnabled()) {
return SECURE_DATA_DIRECTORY;
} else {
return DATA_DIRECTORY;
}
}
/**
* Return directory used for internal media storage, which is protected by
* {@link android.Manifest.permission#WRITE_MEDIA_STORAGE}.
*
* @hide
*/
public static File getMediaStorageDirectory() {
return MEDIA_STORAGE_DIRECTORY;
}
/**
* Returns whether the Encrypted File System feature is enabled on the device or not.
* @return true if Encrypted File System feature is enabled, false
* if disabled.
* @hide
*/
public static boolean isEncryptedFilesystemEnabled() {
return SystemProperties.getBoolean(SYSTEM_PROPERTY_EFS_ENABLED, false);
}
private static final File DATA_DIRECTORY
= getDirectory("ANDROID_DATA", "/data");
/**
* @hide
*/
private static final File SECURE_DATA_DIRECTORY
= getDirectory("ANDROID_SECURE_DATA", "/data/secure");
/** @hide */
private static final File MEDIA_STORAGE_DIRECTORY
= getDirectory("MEDIA_STORAGE", "/data/media");
private static final File EXTERNAL_STORAGE_DIRECTORY
= getDirectory("EXTERNAL_STORAGE", "/storage/sdcard0");
private static final File EXTERNAL_STORAGE_ANDROID_DATA_DIRECTORY = new File(new File(
getDirectory("EXTERNAL_STORAGE", "/storage/sdcard0"), "Android"), "data");
private static final File EXTERNAL_STORAGE_ANDROID_MEDIA_DIRECTORY = new File(new File(
getDirectory("EXTERNAL_STORAGE", "/storage/sdcard0"), "Android"), "media");
private static final File EXTERNAL_STORAGE_ANDROID_OBB_DIRECTORY = new File(new File(
getDirectory("EXTERNAL_STORAGE", "/storage/sdcard0"), "Android"), "obb");
private static final File DOWNLOAD_CACHE_DIRECTORY
= getDirectory("DOWNLOAD_CACHE", "/cache");
/**
* Gets the Android data directory.
*/
public static File getDataDirectory() {
return DATA_DIRECTORY;
}
/**
* Gets the Android 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()}.
*
* 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.
*
* In devices with multiple "external" storage directories (such as
* both secure app storage and mountable shared storage), this directory
* represents the "primary" external storage that the user will interact
* with.
*
* 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}.
*
*
Here is an example of typical code to monitor the state of
* external storage:
*
* {@sample development/samples/ApiDemos/src/com/example/android/apis/content/ExternalStorage.java
* monitor_storage}
*
* @see #getExternalStorageState()
* @see #isExternalStorageRemovable()
*/
public static File getExternalStorageDirectory() {
return EXTERNAL_STORAGE_DIRECTORY;
}
/**
* 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";
/**
* 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.
*
* Here is an example of typical code to manipulate a picture on
* the public external storage:
*
* {@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) {
return new File(getExternalStorageDirectory(), type);
}
/**
* Returns the path for android-specific data on the SD card.
* @hide
*/
public static File getExternalStorageAndroidDataDir() {
return EXTERNAL_STORAGE_ANDROID_DATA_DIRECTORY;
}
/**
* Generates the raw path to an application's data
* @hide
*/
public static File getExternalStorageAppDataDirectory(String packageName) {
return new File(EXTERNAL_STORAGE_ANDROID_DATA_DIRECTORY, packageName);
}
/**
* Generates the raw path to an application's media
* @hide
*/
public static File getExternalStorageAppMediaDirectory(String packageName) {
return new File(EXTERNAL_STORAGE_ANDROID_MEDIA_DIRECTORY, packageName);
}
/**
* Generates the raw path to an application's OBB files
* @hide
*/
public static File getExternalStorageAppObbDirectory(String packageName) {
return new File(EXTERNAL_STORAGE_ANDROID_OBB_DIRECTORY, packageName);
}
/**
* Generates the path to an application's files.
* @hide
*/
public static File getExternalStorageAppFilesDirectory(String packageName) {
return new File(new File(EXTERNAL_STORAGE_ANDROID_DATA_DIRECTORY,
packageName), "files");
}
/**
* Generates the path to an application's cache.
* @hide
*/
public static File getExternalStorageAppCacheDirectory(String packageName) {
return new File(new File(EXTERNAL_STORAGE_ANDROID_DATA_DIRECTORY,
packageName), "cache");
}
/**
* Gets the Android Download/Cache content directory.
*/
public static File getDownloadCacheDirectory() {
return DOWNLOAD_CACHE_DIRECTORY;
}
/**
* {@link #getExternalStorageState()} returns MEDIA_REMOVED if the media is not present.
*/
public static final String MEDIA_REMOVED = "removed";
/**
* {@link #getExternalStorageState()} returns MEDIA_UNMOUNTED if the media is present
* but not mounted.
*/
public static final String MEDIA_UNMOUNTED = "unmounted";
/**
* {@link #getExternalStorageState()} returns MEDIA_CHECKING if the media is present
* and being disk-checked
*/
public static final String MEDIA_CHECKING = "checking";
/**
* {@link #getExternalStorageState()} returns MEDIA_NOFS if the media is present
* but is blank or is using an unsupported filesystem
*/
public static final String MEDIA_NOFS = "nofs";
/**
* {@link #getExternalStorageState()} returns MEDIA_MOUNTED if the media is present
* and mounted at its mount point with read/write access.
*/
public static final String MEDIA_MOUNTED = "mounted";
/**
* {@link #getExternalStorageState()} returns MEDIA_MOUNTED_READ_ONLY if the media is present
* and mounted at its mount point with read only access.
*/
public static final String MEDIA_MOUNTED_READ_ONLY = "mounted_ro";
/**
* {@link #getExternalStorageState()} returns MEDIA_SHARED if the media is present
* not mounted, and shared via USB mass storage.
*/
public static final String MEDIA_SHARED = "shared";
/**
* {@link #getExternalStorageState()} returns MEDIA_BAD_REMOVAL if the media was
* removed before it was unmounted.
*/
public static final String MEDIA_BAD_REMOVAL = "bad_removal";
/**
* {@link #getExternalStorageState()} returns MEDIA_UNMOUNTABLE if the media is present
* but cannot be mounted. Typically this happens if the file system on the
* media is corrupted.
*/
public static final String MEDIA_UNMOUNTABLE = "unmountable";
/**
* Gets the current state of the primary "external" storage device.
*
* See {@link #getExternalStorageDirectory()} for more information.
*/
public static String getExternalStorageState() {
try {
IMountService mountService = IMountService.Stub.asInterface(ServiceManager
.getService("mount"));
return mountService.getVolumeState(getExternalStorageDirectory()
.toString());
} catch (Exception rex) {
return Environment.MEDIA_REMOVED;
}
}
/**
* Returns whether the primary "external" storage device is removable.
* If true is returned, this device is for example an SD card that the
* user can remove. If false is returned, the storage is built into
* the device and can not be physically removed.
*
*
See {@link #getExternalStorageDirectory()} for more information.
*/
public static boolean isExternalStorageRemovable() {
StorageVolume volume = getPrimaryVolume();
return (volume != null && volume.isRemovable());
}
/**
* Returns whether the device has an external storage device which is
* emulated. If true, the device does not have real external storage, and the directory
* returned by {@link #getExternalStorageDirectory()} will be allocated using a portion of
* the internal storage system.
*
*
Certain system services, such as the package manager, use this
* to determine where to install an application.
*
*
Emulated external storage may also be encrypted - see
* {@link android.app.admin.DevicePolicyManager#setStorageEncryption(
* android.content.ComponentName, boolean)} for additional details.
*/
public static boolean isExternalStorageEmulated() {
StorageVolume volume = getPrimaryVolume();
return (volume != null && volume.isEmulated());
}
static File getDirectory(String variableName, String defaultPath) {
String path = System.getenv(variableName);
return path == null ? new File(defaultPath) : new File(path);
}
}