413 lines
16 KiB
Java
413 lines
16 KiB
Java
|
/*
|
||
|
|
* 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 java.io.File;
|
||
|
|
|
||
|
|
import android.content.res.Resources;
|
||
|
|
import android.os.storage.IMountService;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Provides access to environment variables.
|
||
|
|
*/
|
||
|
|
public class 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 IMountService mMntSvc = null;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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() {
|
||
|
|
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");
|
||
|
|
|
||
|
|
private static final File EXTERNAL_STORAGE_DIRECTORY
|
||
|
|
= getDirectory("EXTERNAL_STORAGE", "/sdcard");
|
||
|
|
|
||
|
|
private static final File EXTERNAL_STORAGE_ANDROID_DATA_DIRECTORY
|
||
|
|
= new File (new File(getDirectory("EXTERNAL_STORAGE", "/sdcard"),
|
||
|
|
"Android"), "data");
|
||
|
|
|
||
|
|
private static final File EXTERNAL_STORAGE_ANDROID_MEDIA_DIRECTORY
|
||
|
|
= new File (new File(getDirectory("EXTERNAL_STORAGE", "/sdcard"),
|
||
|
|
"Android"), "media");
|
||
|
|
|
||
|
|
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()}.
|
||
|
|
*
|
||
|
|
* <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>
|
||
|
|
*
|
||
|
|
* <p>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.</p>
|
||
|
|
*
|
||
|
|
* <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>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() {
|
||
|
|
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.
|
||
|
|
*
|
||
|
|
* <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) {
|
||
|
|
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 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;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* getExternalStorageState() returns MEDIA_REMOVED if the media is not present.
|
||
|
|
*/
|
||
|
|
public static final String MEDIA_REMOVED = "removed";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* getExternalStorageState() returns MEDIA_UNMOUNTED if the media is present
|
||
|
|
* but not mounted.
|
||
|
|
*/
|
||
|
|
public static final String MEDIA_UNMOUNTED = "unmounted";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* getExternalStorageState() returns MEDIA_CHECKING if the media is present
|
||
|
|
* and being disk-checked
|
||
|
|
*/
|
||
|
|
public static final String MEDIA_CHECKING = "checking";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* getExternalStorageState() returns MEDIA_SHARED if the media is present
|
||
|
|
* not mounted, and shared via USB mass storage.
|
||
|
|
*/
|
||
|
|
public static final String MEDIA_SHARED = "shared";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* getExternalStorageState() returns MEDIA_BAD_REMOVAL if the media was
|
||
|
|
* removed before it was unmounted.
|
||
|
|
*/
|
||
|
|
public static final String MEDIA_BAD_REMOVAL = "bad_removal";
|
||
|
|
|
||
|
|
/**
|
||
|
|
* 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.
|
||
|
|
*
|
||
|
|
* <p>See {@link #getExternalStorageDirectory()} for more information.
|
||
|
|
*/
|
||
|
|
public static String getExternalStorageState() {
|
||
|
|
try {
|
||
|
|
if (mMntSvc == null) {
|
||
|
|
mMntSvc = IMountService.Stub.asInterface(ServiceManager
|
||
|
|
.getService("mount"));
|
||
|
|
}
|
||
|
|
return mMntSvc.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.
|
||
|
|
*
|
||
|
|
* <p>See {@link #getExternalStorageDirectory()} for more information.
|
||
|
|
*/
|
||
|
|
public static boolean isExternalStorageRemovable() {
|
||
|
|
return Resources.getSystem().getBoolean(
|
||
|
|
com.android.internal.R.bool.config_externalStorageRemovable);
|
||
|
|
}
|
||
|
|
|
||
|
|
static File getDirectory(String variableName, String defaultPath) {
|
||
|
|
String path = System.getenv(variableName);
|
||
|
|
return path == null ? new File(defaultPath) : new File(path);
|
||
|
|
}
|
||
|
|
}
|