Android 4.4 SD 和 U盘 的状态

通过获取StorageVolume 类来判断 是sd还是U盘。我们来看一下这个类

package android.os.storage;

import android.content.Context;

import android.os.Parcel;

import android.os.Parcelable;

import android.os.UserHandle;

import com.android.internal.util.IndentingPrintWriter;

import java.io.CharArrayWriter;

import java.io.File;

/**

* Description of a storage volume and its capabilities, including the

* filesystem path where it may be mounted.

*

* @hide

*/

public class StorageVolume implements Parcelable {

// TODO: switch to more durable token

private int mStorageId;

private final File mPath;

private final int mDescriptionId;

private final boolean mPrimary;

private final boolean mRemovable;

private final boolean mEmulated;

private final int mMtpReserveSpace;

private final boolean mAllowMassStorage;

/** Maximum file size for the storage, or zero for no limit */

private final long mMaxFileSize;

/** When set, indicates exclusive ownership of this volume */

private final UserHandle mOwner;

private String mUuid;

private String mUserLabel;

private String mState;

// StorageVolume extra for ACTION_MEDIA_REMOVED, ACTION_MEDIA_UNMOUNTED, ACTION_MEDIA_CHECKING,

// ACTION_MEDIA_NOFS, ACTION_MEDIA_MOUNTED, ACTION_MEDIA_SHARED, ACTION_MEDIA_UNSHARED,

// ACTION_MEDIA_BAD_REMOVAL, ACTION_MEDIA_UNMOUNTABLE and ACTION_MEDIA_EJECT broadcasts.

public static final String EXTRA_STORAGE_VOLUME = "storage_volume";

// About storage volume format fs type

public static final String EXTRA_FORMAT_FSTYPE = "format_fstype";

public StorageVolume(File path, int descriptionId, boolean primary, boolean removable,

boolean emulated, int mtpReserveSpace, boolean allowMassStorage, long maxFileSize,

UserHandle owner) {

mPath = path;

mDescriptionId = descriptionId;

mPrimary = primary;

mRemovable = removable;

mEmulated = emulated;

mMtpReserveSpace = mtpReserveSpace;

mAllowMassStorage = allowMassStorage;

mMaxFileSize = maxFileSize;

mOwner = owner;

}

private StorageVolume(Parcel in) {

mStorageId = in.readInt();

mPath = new File(in.readString());

mDescriptionId = in.readInt();

mPrimary = in.readInt() != 0;

mRemovable = in.readInt() != 0;

mEmulated = in.readInt() != 0;

mMtpReserveSpace = in.readInt();

mAllowMassStorage = in.readInt() != 0;

mMaxFileSize = in.readLong();

mOwner = in.readParcelable(null);

mUuid = in.readString();

mUserLabel = in.readString();

mState = in.readString();

}

public static StorageVolume fromTemplate(StorageVolume template, File path, UserHandle owner) {

return new StorageVolume(path, template.mDescriptionId, template.mPrimary,

template.mRemovable, template.mEmulated, template.mMtpReserveSpace,

template.mAllowMassStorage, template.mMaxFileSize, owner);

}

/**

* Returns the mount path for the volume.

*

* @return the mount path

*/

public String getPath() {

return mPath.toString();

}

public File getPathFile() {

return mPath;

}

/**

* Returns a user visible description of the volume.

*

* @return the volume description

*/

public String getDescription(Context context) {

return context.getResources().getString(mDescriptionId);

}

public int getDescriptionId() {

return mDescriptionId;

}

public boolean isPrimary() {

return mPrimary;

}

/**

* Returns true if the volume is removable.

*

* @return is removable

*/

public boolean isRemovable() {

return mRemovable;

}

/**

* Returns true if the volume is emulated.

*

* @return is removable

*/

public boolean isEmulated() {

return mEmulated;

}

/**

* Returns the MTP storage ID for the volume.

* this is also used for the storage_id column in the media provider.

*

* @return MTP storage ID

*/

public int getStorageId() {

return mStorageId;

}

/**

* Do not call this unless you are MountService

*/

public void setStorageId(int index) {

// storage ID is 0x00010001 for primary storage,

// then 0x00020001, 0x00030001, etc. for secondary storages

mStorageId = ((index + 1) << 16) + 1;

}

/**

* Number of megabytes of space to leave unallocated by MTP.

* MTP will subtract this value from the free space it reports back

* to the host via GetStorageInfo, and will not allow new files to

* be added via MTP if there is less than this amount left free in the storage.

* If MTP has dedicated storage this value should be zero, but if MTP is

* sharing storage with the rest of the system, set this to a positive value

* to ensure that MTP activity does not result in the storage being

* too close to full.

*

* @return MTP reserve space

*/

public int getMtpReserveSpace() {

return mMtpReserveSpace;

}

/**

* Returns true if this volume can be shared via USB mass storage.

*

* @return whether mass storage is allowed

*/

public boolean allowMassStorage() {

return mAllowMassStorage;

}

/**

* Returns maximum file size for the volume, or zero if it is unbounded.

*

* @return maximum file size

*/

public long getMaxFileSize() {

return mMaxFileSize;

}

public UserHandle getOwner() {

return mOwner;

}

public void setUuid(String uuid) {

mUuid = uuid;

}

public String getUuid() {

return mUuid;

}

/**

* Parse and return volume UUID as FAT volume ID, or return -1 if unable to

* parse or UUID is unknown.

*/

public int getFatVolumeId() {

if (mUuid == null || mUuid.length() != 9) {

return -1;

}

try {

return Integer.parseInt(mUuid.replace("-", ""), 16);

} catch (NumberFormatException e) {

return -1;

}

}

public void setUserLabel(String userLabel) {

mUserLabel = userLabel;

}

public String getUserLabel() {

return mUserLabel;

}

public void setState(String state) {

mState = state;

}

public String getState() {

return mState;

}

@Override

public boolean equals(Object obj) {

if (obj instanceof StorageVolume && mPath != null) {

StorageVolume volume = (StorageVolume)obj;

return (mPath.equals(volume.mPath));

}

return false;

}

@Override

public int hashCode() {

return mPath.hashCode();

}

@Override

public String toString() {

final CharArrayWriter writer = new CharArrayWriter();

dump(new IndentingPrintWriter(writer, " ", 80));

return writer.toString();

}

public void dump(IndentingPrintWriter pw) {

pw.println("StorageVolume:");

pw.increaseIndent();

pw.printPair("mStorageId", mStorageId);

pw.printPair("mPath", mPath);

pw.printPair("mDescriptionId", mDescriptionId);

pw.printPair("mPrimary", mPrimary);

pw.printPair("mRemovable", mRemovable);

pw.printPair("mEmulated", mEmulated);

pw.printPair("mMtpReserveSpace", mMtpReserveSpace);

pw.printPair("mAllowMassStorage", mAllowMassStorage);

pw.printPair("mMaxFileSize", mMaxFileSize);

pw.printPair("mOwner", mOwner);

pw.printPair("mUuid", mUuid);

pw.printPair("mUserLabel", mUserLabel);

pw.printPair("mState", mState);

pw.decreaseIndent();

}

public static final Creator CREATOR = new Creator() {

@Override

public StorageVolume createFromParcel(Parcel in) {

return new StorageVolume(in);

}

@Override

public StorageVolume[] newArray(int size) {

return new StorageVolume[size];

}

};

@Override

public int describeContents() {

return 0;

}

@Override

public void writeToParcel(Parcel parcel, int flags) {

parcel.writeInt(mStorageId);

parcel.writeString(mPath.toString());

parcel.writeInt(mDescriptionId);

parcel.writeInt(mPrimary ? 1 : 0);

parcel.writeInt(mRemovable ? 1 : 0);

parcel.writeInt(mEmulated ? 1 : 0);

parcel.writeInt(mMtpReserveSpace);

parcel.writeInt(mAllowMassStorage ? 1 : 0);

parcel.writeLong(mMaxFileSize);

parcel.writeParcelable(mOwner, flags);

parcel.writeString(mUuid);

parcel.writeString(mUserLabel);

parcel.writeString(mState);

}

}

这个类用来描述存储状态，有几个重要的参数：

File mPath 路径

mRemovable 是否可移除，(U盘，SD)返回 true

getDescription(context) 获取设备的描述 "sd" 就是SD卡，“USB”就是usb设备

获取存储设备

mStorageManager = StorageManager.from(this);

final StorageVolume[] storageVolumes = mStorageManager.getVolumeList();

for (StorageVolume mVolume : storageVolumes) {

if(mVolume != null){

String description = mVolume.getDescription(context);

Log.d(getClass().getName(), "description is: " + description);

if(description != null && (description.contains("SD") || description.contains("sd"))){

//这是sd

}

else if(description != null && (description.contains("USB") || description.contains("usb")

|| description.contains("Usb"))){

//这是usb

}

}

}

}

存储设备状态和路径

import android.os.storage.StorageManager;

import android.os.storage.StorageEventListener;

private StorageManager mStorageManager;

mStorageManager = StorageManager.from(this);

//注册和反注册

mStorageManager.registerListener(mStorageListener);

if (mStorageManager != null && mStorageListener != null) {

mStorageManager.unregisterListener(mStorageListener);

}

/**

*

* 监听 path 路径 oldState 上一个状态 newState 当前状态

* 所有状态 mounted unmounted removed checking

*/

StorageEventListener mStorageListener = new StorageEventListener() {

@Override

public void onStorageStateChanged(String path, String oldState, String newState) {

Log.i("qkmin -voolesettings"," StorageEventListener Received storage state changed notification that " + path +

" changed state from " + oldState + " to " + newState);

}

};