Android 如何获取安卓设备已安装的外部存储列表

在这里，我们正在为android电视盒开发android应用程序。如何获取已装入的外部存储列表，如

USB记忆棒、SD卡和SATA HDD。

您可以使用

getExternalStorageDirectory（）

获取外部存储目录。文档很好地解释了它的用法

---

对于USB设备，您可能必须查看

UsbManager

类或更一般的

android.hardware.USB

环境。getExternalStorageState（）

返回内部SD装载点的路径，如“/mnt/sdcard”

否，

Environment.getExternalStorageDirectory（）

指设备制造商认为是“外部存储”的任何内容。在某些设备上，这是可移动介质，如SD卡。在某些设备上，这是设备闪存的一部分。在这里，“外部存储”是指“当安装在主机上时，通过USB大容量存储模式可以访问的东西”，至少对于Android 1.x和2.x来说是这样

但问题是关于外部SD。如何获得“/mnt/sdcard/external_sd”这样的路径（不同设备的路径可能不同）

如上所述，除了外部存储之外，Android没有“外部SD”的概念

如果设备制造商已选择将外部存储器作为板载闪存，并且还具有SD卡，则您需要与该制造商联系，以确定是否可以使用SD卡（不保证），以及使用SD卡的规则，例如使用SD卡的路径

试试这个：

Manifest.xml：

<receiver android:name=".MyReceiver">
    <intent-filter>
         <action android:name="android.intent.action.ums_connected" />
     </intent-filter>
  </receiver>

---

我使用/proc/mounts文件获取可用存储选项的列表

public class StorageUtils {

    private static final String TAG = "StorageUtils";

    public static class StorageInfo {

        public final String path;
        public final boolean readonly;
        public final boolean removable;     
        public final int number;

        StorageInfo(String path, boolean readonly, boolean removable, int number) {
            this.path = path;
            this.readonly = readonly;
            this.removable = removable;         
            this.number = number;
        }

        public String getDisplayName() {
            StringBuilder res = new StringBuilder();
            if (!removable) {
                res.append("Internal SD card");
            } else if (number > 1) {
                res.append("SD card " + number);
            } else {
                res.append("SD card");
            }
            if (readonly) {
                res.append(" (Read only)");
            }
            return res.toString();
        }
    }

    public static List<StorageInfo> getStorageList() {

        List<StorageInfo> list = new ArrayList<StorageInfo>();
        String def_path = Environment.getExternalStorageDirectory().getPath();
        boolean def_path_removable = Environment.isExternalStorageRemovable();
        String def_path_state = Environment.getExternalStorageState();
        boolean def_path_available = def_path_state.equals(Environment.MEDIA_MOUNTED)
                                    || def_path_state.equals(Environment.MEDIA_MOUNTED_READ_ONLY);
        boolean def_path_readonly = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED_READ_ONLY);

        HashSet<String> paths = new HashSet<String>();
        int cur_removable_number = 1;

        if (def_path_available) {
            paths.add(def_path);
            list.add(0, new StorageInfo(def_path, def_path_readonly, def_path_removable, def_path_removable ? cur_removable_number++ : -1));
        }

        BufferedReader buf_reader = null;
        try {
            buf_reader = new BufferedReader(new FileReader("/proc/mounts"));
            String line;
            Log.d(TAG, "/proc/mounts");
            while ((line = buf_reader.readLine()) != null) {
                Log.d(TAG, line);
                if (line.contains("vfat") || line.contains("/mnt")) {
                    StringTokenizer tokens = new StringTokenizer(line, " ");
                    String unused = tokens.nextToken(); //device
                    String mount_point = tokens.nextToken(); //mount point
                    if (paths.contains(mount_point)) {
                        continue;
                    }
                    unused = tokens.nextToken(); //file system
                    List<String> flags = Arrays.asList(tokens.nextToken().split(",")); //flags
                    boolean readonly = flags.contains("ro");

                    if (line.contains("/dev/block/vold")) {
                        if (!line.contains("/mnt/secure")
                            && !line.contains("/mnt/asec")
                            && !line.contains("/mnt/obb")
                            && !line.contains("/dev/mapper")
                            && !line.contains("tmpfs")) {
                            paths.add(mount_point);
                            list.add(new StorageInfo(mount_point, readonly, true, cur_removable_number++));
                        }
                    }
                }
            }

        } catch (FileNotFoundException ex) {
            ex.printStackTrace();
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            if (buf_reader != null) {
                try {
                    buf_reader.close();
                } catch (IOException ex) {}
            }
        }
        return list;
    }
}

公共类StorageUtils{
私有静态最终字符串TAG=“StorageUtils”；
公共静态类StorageInfo{
公共最终字符串路径；
公共最终布尔值只读；
公共财政；
公共最终整数；
StorageInfo（字符串路径、布尔只读、布尔可移动、整数）{
this.path=path；
this.readonly=readonly；
这个。可移动的=可移动的；
这个数字=数字；
}
公共字符串getDisplayName（）{
StringBuilder res=新的StringBuilder（）；
如果（！可移动）{
res.append（“内部SD卡”）；
}否则，如果（编号>1）{
res.append（“SD卡”+编号）；
}否则{
res.append（“SD卡”）；
}
如果（只读）{
res.append（“（只读）”）；
}
return res.toString（）；
}
}
公共静态列表getStorageList（）{
列表=新的ArrayList（）；
字符串def_path=Environment.getExternalStorageDirectory（）.getPath（）；
布尔def_path_removable=Environment.isExternalStorageRemovable（）；
字符串def_path_state=Environment.getExternalStorageState（）；
布尔def_path_available=def_path_state.equals（Environment.MEDIA_MOUNTED）
||def_path_state.equals（环境、媒体、挂载、只读）；
布尔def_path_readonly=Environment.getExternalStorageState（）.equals（Environment.MEDIA_MOUNTED_readonly）；
HashSet路径=新的HashSet（）；
int cur\u可移动\u编号=1；
如果（定义路径可用）{
添加（定义路径）；
列表.添加（0，新的存储信息（定义路径，定义路径只读，定义路径可移动，定义路径可移动？当前可移动编号++：-1））；
}
BufferedReader buf_reader=null；
试一试{
buf_reader=newbufferedreader（newfilereader（“/proc/mounts”）；
弦线；
Log.d（标记“/proc/mounts”）；
while（（line=buf_reader.readLine（））！=null）{
Log.d（标签、行）；
if（line.contains（“vfat”）| | line.contains（“/mnt”））{
StringTokenizer令牌=新的StringTokenizer（行“”）；
String unused=tokens.nextToken（）；//设备
String mount_point=tokens.nextToken（）；//装入点
if（路径包含（装入点））{
继续；
}
unused=tokens.nextToken（）；//文件系统
列表标志=Arrays.asList（tokens.nextToken（）.split（“，”）；//标志
boolean readonly=flags.contains（“ro”）；
if（行包含（“/dev/block/vold”））{
如果（！line.contains（“/mnt/secure”）
&&！line.contains（“/mnt/asec”）
&&！line.contains（“/mnt/obb”）
&&！line.contains（“/dev/mapper”）
&&！line.contains（“tmpfs”））{
路径。添加（挂载点）；
添加（新的存储信息（装入点、只读、真、当前可移动\u编号++）；
}
}
}
}
}捕获（FileNotFoundException ex）{
例如printStackTrace（）；
}捕获（IOEX异常）{
例如printStackTrace（）；
}最后{
if（buf_读取器！=null）{
试一试{
buf_reader.close（）；
}catch（IOException ex）{}
}
}
退货清单；
}
}

要获取所有可用的外部存储文件夹（包括SD卡），您可以使用以下方法：

File[] externalStorageFiles=ContextCompat.getExternalFilesDirs(this,null);

要转到每个外部存储器的“根目录”（即真正的装入文件夹路径），您可以使用我提供的以下功能：

  /** Given any file/folder inside an sd card, this will return the path of the sd card */
  private static String getRootOfInnerSdCardFolder(File file)
    {
    if(file==null)
      return null;
    final long totalSpace=file.getTotalSpace();
    while(true)
      {
      final File parentFile=file.getParentFile();
      if(parentFile==null||parentFile.getTotalSpace()!=totalSpace)
        return file.getAbsolutePath();
      file=parentFile;
      }
    }

---

我现在知道这个话题很老了，但这可能会有所帮助。你应该使用这种方法

System.getenv（）

请参阅project Environment 3以访问连接到设备的所有存储

另一种选择

首先获取所有外部文件目录

File[] externalStorageFiles=ContextCompat.getExternalFilesDirs(this,null);

那就叫这个吧

File[] externalStorageFiles=ContextCompat.getExternalFilesDirs(this,null);

private static String getRootOfExternalStorage(File file)
{
    if (file == null)
        return null;
    String path = file.getAbsolutePath();
    return path.replaceAll("/Android/data/" + getPackageName() + "/files", "");
}