logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Android 获取内置和外置存储卡的路径及总共、可用空间

 昵称48946089 2019-05-28

在实现这个功能之前可以弄清几个获取系统路径的方法：

  1. Context.getCacheDir().getPath() ;  对应路径：/ data /user / 0 / <应用程序包>/ cache（路径不可见）

  3. Context.getFilesDir().getPath() ;  对应路径：/ data / user / 0 / <应用程序包> /files（路径不可见）

  5. Context.getExternalCacheDir().getPath();  对应路径：Android/data/<应用程序包>/cache  （如果想缓存文件可用这个，内存不足时删除，节约用户空间）

  7. Context.getExternalFilesDir("glide").getPath();  对应路径：Android/data/<应用程序包>/files/glide  （如果想缓存文件可用这个，会随应用删除而删除，节约用户空间）

  9. context.getDir("config", Context.MODE_PRIVATE);  对应路径：Android/data/包名/app_config （其中包名后面的app_是为调用时，系统自己加上的，Context.MODE_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问）

  11. Context.getPackageName()  : <应用程序包>

  13. Context.getPackageResourcePath()  : /data/app/com.zhd-1.apk

  15. Context.getPackageResourcePath() ：用于获取该程序的安装包路径

  17. Context.getDatabasePath()：用于获取/ data / <应用程序包> / databases 目录

  19. Environment.getRootDirectory().getPath()    : /system

  21. Environment.getDataDirectory().getPath(): /data

  23. Environment.getExternalStorageDirectory().getPath() ：用于获得内部存储卡路径

如何获取外置SD卡路径，由于不同厂商定制系统不同，没有统一的方法，可以通过运行时解析安装信息，详细可看下文

在开发中可能会遇到，向SD卡存储文件或让用户选择存储路径，你只有知道了路径才能创建文件，如内置存储卡路径innerPath =“/存储/模拟/ 0”，外置存储卡路径externalPath = “/存储/ extSdCard”。内置存储卡的路径好弄，一行代码就行，而外置内存卡路径就比较难搞定，因为还要兼顾不同手机的适配问题，不同手机路径名字不同，因为不同手机系统可能被定制过，你懂的。

第一种方式（推荐）：

5.0版本及以上可用ContextCompat.getExternalFilesDirs() 获取到内置和外置存储卡路径

  1. if (android.os.Build.VERSION.SDK_INT >= 19) {
  2. File[] files = ContextCompat.getExternalFilesDirs(
  3. BaseApplication.mContext, null)
  4. }

5.0版本以下可以用反射

 pathsTmp = (String[]) methodGetPaths.invoke(sManager);

详细代码代码地址：https://github.com/gaoleicoding/StorageCard

第二种方式：

根据安装信息解析SD卡路径。测试通很多型号手机项目中以运用，主要代码如下：

  1. <span style="font-size:14px;">public class SDCardUtil {
  3. public final String TAG = "SDCardUtils";
  5. public final static String DIR_SINGLE_SDCARD_NAME = "内置存储卡";
  6. public final static String DIR_SDCARD_NAME = "内置存储卡";
  7. public final static String DIR_EXT_SDCARD_NAME = "扩展存储卡";
  8. // public final static String DIR_UDISK_NAME = "USB存储设备";
  10. private static String SDCARD_PATH = getSDCardPath();
  12. // 系统目录链接，key是linkPath，value是realPath
  13. public static HashMap<String, String> sysLinkToReal = new HashMap<String, String>();
  14. // 系统目录的反向链接， key是realPath，value是linkPath
  15. public static HashMap<String, String> sysRealToLink = new HashMap<String, String>();
  17. public static boolean isMounted() {
  18. return Environment.getExternalStorageState().equals(
  19. Environment.MEDIA_MOUNTED);
  20. }
  22. public static String getSDCardPath() {
  23. return Environment.getExternalStorageDirectory().getAbsolutePath();
  24. }
  26. /**
  27. * 是否能通过基本过滤
  28. *
  29. * @param str
  30. * @return
  31. */
  32. private static boolean testBasicFilter(String str) {
  33. String[] keys = new String[] { "sd", "emmc", "hwuserdata", "udisk",
  34. "ext_card", "usbotg", "disk1", "disk2", "disk3", "disk4",
  35. "usbdrivea", "usbdriveb", "usbdrivec", "usbdrived", "storage",
  36. "external" };
  37. int len = keys.length;
  38. for (int i = 0; i < len; i++) {
  39. if (str.contains(keys[i])) {
  40. return true;
  41. }
  42. }
  43. return false;
  44. }
  46. public static boolean sdCardCanWrite(String path) {
  47. if (path == null) {
  48. return false;
  49. }
  51. File SdCardRoot = new File(path);
  52. if (SdCardRoot.canWrite() == false) {
  53. return false;
  54. }
  56. if (Build.VERSION.SDK_INT >= 19) {
  57. // canWrite() 在4.4系统不起作用，只要路径存在总是返回true
  58. File testPath = new File(new File(path), ".testwrite"
  59. + String.valueOf(System.currentTimeMillis()));
  61. if (testPath.mkdirs()) {
  62. testPath.delete();
  63. return true;
  64. } else {
  65. return false;
  66. }
  67. } else {
  68. return true;
  69. }
  70. }
  72. public static ArrayList<SDCardStat> getSDCardStats(Context context) {
  73. ArrayList<SDCardStat> list = new ArrayList<SDCardStat>();
  75. try {
  76. Process process = Runtime.getRuntime().exec("mount");
  77. BufferedReader br = new BufferedReader(new InputStreamReader(
  78. process.getInputStream()));
  79. // BufferedReader br = new BufferedReader(new InputStreamReader(new
  80. // FileInputStream("/mnt/sdcard/sdcards_info/mount.log")));
  81. String str, lowerStr;
  82. while ((str = br.readLine()) != null) {
  83. lowerStr = str.toLowerCase();
  84. //                Log.d("gaolei", "str---------line-----"+str);
  85. if(str.contains("/storage/")){
  86. //                	 MainActivity.filterBuilder.append("\nstorage:\n");
  87. MainActivity.filterBuilder.append("storage----:  "+str+"\n\n");
  88. }
  89. //                if(str.contains("/sd/")){
  90. //                	MainActivity.filterBuilder.append("sd:\n\n");
  91. //                	MainActivity.filterBuilder.append(str+"\n\n");
  92. //                }
  93. // Utils.writeLog("getSDCardStats: " + lowerStr);
  94. if (!testBasicFilter(lowerStr)) {
  95. continue;
  96. }
  97. String[] cols = str.split("\\s+");
  98. if (cols == null) {
  99. continue;
  100. }
  102. String path = findSDCardPath(cols);
  103. Log.d("gaolei", "path--------0-------"+path);
  104. if (TextUtils.isEmpty(path)) {
  105. // path = findUDiskPath(cols);
  106. // if (!TextUtils.isEmpty(path)) {
  107. // SDCardStat.Format format = findSDCardFormat(cols);
  108. // if (format != null) {
  109. // UDiskStat = new SDCardStat(path,
  110. // format, 1025);
  111. // }
  112. // }
  113. continue;
  114. }
  115. SDCardStat.Format format = findSDCardFormat(cols);
  116. if (format == null) {
  117. continue;
  118. }
  120. int minorIdx = (Format.vfat == format || Format.exfat == format || Format.texfat == format) ? findVoldDevNodeMinorIndex(cols)
  121. : -100;
  122. SDCardStat stat = new SDCardStat(path, format, minorIdx);
  123. Log.d("gaolei", "path--------1-------"+path);
  124. 				if (!compareData(list, stat.totalSize)) {
  125. 					continue;
  126. 				}
  128. //                MainActivity.filterBuilder.append("path----:  "+path+"\n\n");
  129. // 4.4以上版本修改trootPath路径，因为4.4及以上版本不支持往外置SD卡根目录写权限
  130. if (android.os.Build.VERSION.SDK_INT >= 19) {
  131. if (!SDCardUtil.sdCardCanWrite(path)) {
  132. stat.canWrite = false;
  133. File[] filePath = ContextCompat.getExternalFilesDirs(
  134. context, null);
  135. if (filePath != null) {
  136. for (File f : filePath) {
  137. if (f != null) {
  138. if (f.getAbsolutePath().startsWith(path)) {
  139. stat.rootPath = f.getAbsolutePath();
  140. Log.d("gaolei", "path--------if-------"+path);
  141. MainActivity.filterBuilder.append("path--if--:  "+path+"\n\n");
  142. list.add(stat);
  143. break;
  144. }
  145. }
  146. }
  147. }
  148. } else {
  149.                     	Log.d("gaolei", "path--------else-------"+path);
  150.                     	MainActivity.filterBuilder.append("path--else--:  "+path+"\n\n");
  151. list.add(stat);
  152. }
  153. } else {
  154.                 	MainActivity.filterBuilder.append("path--other--:  "+path+"\n\n");
  155.                 	Log.d("gaolei", "path--------other-------"+path);
  156. list.add(stat);
  157. }
  158. }
  159. } catch (IOException e) {
  160. e.printStackTrace();
  161. return list;
  162. }
  164. list = sortSDCardList(list);
  166. for (int idx = 0, size = list.size(); idx < size; idx++) {
  167. if (idx == 0) {
  168. list.get(0).name = (size == 1) ? DIR_SINGLE_SDCARD_NAME
  169. : DIR_SDCARD_NAME;
  170. } else if (idx == 1) {
  171. list.get(1).name = DIR_EXT_SDCARD_NAME;
  172. } else {
  173. list.get(idx).name = DIR_EXT_SDCARD_NAME + idx;
  174. }
  175. }
  177. // 将U盘放最后
  178. // if (UDiskStat != null) {
  179. // UDiskStat.name = DIR_UDISK_NAME;
  180. // list.add(UDiskStat);
  181. // }
  183. return list;
  184. }
  186. private static boolean checkSDCardExistByRootPath(String path,
  187. ArrayList<SDCardStat> list) {
  188. boolean existFlag = false;
  189. for (SDCardStat stat : list) {
  190. if (SDCARD_PATH.equals(stat.rootPath)) {
  191. existFlag = true;
  192. break;
  193. }
  194. }
  195. return existFlag;
  196. }
  198. /**
  199. * 根据设备挂载次序排序SDCard
  200. *
  201. * @param list
  202. * @return
  203. */
  204. private static ArrayList<SDCardStat> sortSDCardList(
  205. ArrayList<SDCardStat> list) {
  206. ArrayList<SDCardStat> resultList = new ArrayList<SDCardStat>();
  207. int minIdx = 0;
  208. for (SDCardStat stat : list) {
  209. if (minIdx == 0) {
  210. resultList.add(stat);
  211. minIdx = stat.voldMinorIdx;
  212. continue;
  213. }
  215. if (stat.voldMinorIdx < minIdx
  216. || isInnerSdcard(stat.rootPath, stat.totalSize)) {
  217. resultList.add(0, stat);
  218. minIdx = stat.voldMinorIdx;
  219. } else {
  220. resultList.add(stat);
  221. }
  222. }
  223. return resultList;
  224. }
  226. private final static long SD_PHY_SIZE_1G = 1000 * 1000 * 1000;
  227. private final static long SD_LOGIC_SIZE_1G = 1024 * 1024 * 1024;
  228. private final static double SD_LOGIC_DIFF = SD_LOGIC_SIZE_1G
  229. / (double) SD_PHY_SIZE_1G;
  231. static boolean nCF3(int n) {
  232. boolean boo = true;
  234. String s = Integer.toBinaryString(n);
  236. byte[] b = s.getBytes();
  238. for (int i = 1; i < b.length; i++) {
  239. if (b[i] != 48) {
  240. boo = false;
  241. break;
  242. }
  243. }
  245. return boo;
  246. }
  248. private static boolean isPhySize(long totalSize) {
  249. boolean result = false;
  250. long count = totalSize / SD_PHY_SIZE_1G;
  251. if (count % 2 == 0) {
  252. count = count + 0;
  253. } else {
  254. count = count + 1;
  255. }
  256. if (!nCF3((int) count) || 0 >= totalSize) {
  257. return result;
  258. }
  259. double real_diff = SD_LOGIC_SIZE_1G * count / (double) totalSize;
  260. // 1.063 <= real_diff <= 1.083
  261. result = real_diff >= SD_LOGIC_DIFF - 0.01
  262. && real_diff <= SD_LOGIC_DIFF + 0.01;
  263. return result;
  264. }
  266. private static boolean isInnerSdcard(String path, long totalSize) {
  267. try {
  268. if (!path.endsWith("/")) {
  269. path = path + "/";
  270. }
  271. return !isPhySize(totalSize)
  272. && (Environment.getExternalStorageDirectory()
  273. .getAbsoluteFile().getCanonicalPath() + "/")
  274. .equals(path);
  275. } catch (IOException e) {
  276. return false;
  277. }
  278. }
  280. /**
  281. * 根据mount信息解析sdcard路径
  282. *
  283. * @param mountInfo
  284. * @return
  285. */
  286. private static String findSDCardPath(String[] mountInfo) {
  287. String lowerStr;
  288. for (String col : mountInfo) {
  289. lowerStr = col.toLowerCase();
  290. //            Log.d("gaolei", "lowerStr--------------"+lowerStr);
  291. // lenovo 部分手机会把扩展卡bind镜像 /mnt/extrasd_bind
  293. if ((lowerStr.contains("sd") && !lowerStr.contains("extrasd_bind"))
  294. || lowerStr.contains("emmc")
  295. || lowerStr.contains("ext_card")
  296. || lowerStr.contains("external_sd")
  297. || lowerStr.contains("usbstorage")) {
  298. String pDir = getParentPath(col);
  299. // onda平板 扩展卡 /mnt/sdcard/external_sdcard, 三星note扩展卡
  300. // /mnt/sdcard/external_sd
  301. // Sony C6603 扩展卡 /storage/removable/sdcard1
  302. if (pDir.equals(getParentPath(SDCARD_PATH))
  303. || pDir.equals(SDCARD_PATH)
  304. || pDir.equals(SDCARD_PATH + "/")
  305. || pDir.equals("/storage/")
  306. || pDir.equals("/storage/removable/")) {
  307. return col;
  308. }
  309. }
  311. if ((col.contains("/storage/") && !col.contains("self") && !col
  312. 					.contains("legacy"))) {
  313.             	Log.d("gaolei", "storage--------------"+col);
  314. 				return col;
  315. 			}
  316. if (col.equals("/mnt/ext_sdcard")) {
  317. // 华为p6扩展卡
  318. return col;
  319. }
  320. if (col.equals("/udisk")) {
  321. // coolpad 内置卡 /udisk
  322. return col;
  323. }
  324. if (col.equals("/HWUserData")) {
  325. // 部分 huawei 内置卡 /HWUserData
  326. return col;
  327. }
  328. if (col.equals("/storage/external")) {
  329. // coolpad8720l 外置卡
  330. return col;
  331. }
  332. if (col.equals("/Removable/MicroSD")) {
  333. // ASUS_T00G
  334. return col;
  335. }
  336. }
  337. return null;
  338. }
  340. /**
  341. * 获取SD卡显示路径.<br>
  342. * 类似<strong>/storage/emulated/0</strong>不需要显示路径.<br>
  343. * 类似<strong>/storage/extSdCard/Android/data/{pageageName}/files</strong>
  344. * 只显示从<strong>/Android</strong>开头的路径.
  345. *
  346. * @param path
  347. * @return
  348. */
  349. public static String getShowSDPath(SDCardStat stat) {
  350. String showPath = "";
  351. String path = stat.rootPath;
  352. if (android.os.Build.VERSION.SDK_INT >= 19 && !stat.canWrite) {
  353. int index = path.indexOf("Android/data/");
  354. if (index != -1) {
  355. showPath = path.substring(index);
  356. }
  357. } else {
  358. showPath = path.substring(path.lastIndexOf(File.separator) + 1);
  359. if (showPath.equals("0")) {
  360. showPath = "";
  361. }
  362. }
  363. return showPath;
  364. }
  367. /**
  368. * 根据mount信息解析sdcard分区格式
  369. *
  370. * @param mountInfo
  371. * @return
  372. */
  373. private static SDCardStat.Format findSDCardFormat(String[] mountInfo) {
  374. int formatMinLength = 0;
  375. int formatMaxLength = 0;
  376. for (SDCardStat.Format format : SDCardStat.Format.values()) {
  377. int len = format.toString().length();
  378. if (len > formatMaxLength) {
  379. formatMaxLength = len;
  380. } else if (len < formatMinLength) {
  381. formatMinLength = len;
  382. }
  383. }
  385. for (String col : mountInfo) {
  386. if (col.length() < formatMinLength
  387. || col.length() > formatMaxLength) {
  388. continue;
  389. }
  390. for (SDCardStat.Format format : SDCardStat.Format.values()) {
  391. if (format.toString().equals(col)) {
  392. return format;
  393. }
  394. }
  395. }
  396. return null;
  397. }
  399. /**
  400. * 解析Vold设备号
  401. *
  402. * @param mountInfo
  403. * @return
  404. */
  405. private static String findVoldDevNodeIndex(String[] mountInfo) {
  406. if (mountInfo == null || mountInfo.length <= 0) {
  407. return null;
  408. }
  410. String voldInfo = mountInfo[0];
  411. if (TextUtils.isEmpty(voldInfo)) {
  412. return null;
  413. }
  415. return voldInfo.replaceFirst("/dev/block/vold/", "");
  416. }
  418. /**
  419. * 解析Vold(vfat格式)次设备号
  420. *
  421. * @param mountInfo
  422. * @return
  423. */
  424. private static int findVoldDevNodeMinorIndex(String[] mountInfo) {
  425. String voldInfo = findVoldDevNodeIndex(mountInfo);
  426. if (TextUtils.isEmpty(voldInfo)) {
  427. return -1;
  428. }
  430. String[] infos = voldInfo.split(":");
  431. if (infos == null || infos.length < 2) {
  432. return -1;
  433. }
  434. return Integer.valueOf(infos[1]);
  435. }
  437. /**
  438. * 计算目标路径的磁盘使用情况
  439. *
  440. * @param path
  441. * @return
  442. */
  443. private static DiskStat getDiskCapacity(String path) {
  444. File file = new File(path);
  445. if (!file.exists()) {
  446. return null;
  447. }
  449. StatFs stat = new StatFs(path);
  450. long blockSize = stat.getBlockSize();
  451. long totalBlockCount = stat.getBlockCount();
  452. long feeBlockCount = stat.getAvailableBlocks();
  453. return new DiskStat(blockSize * feeBlockCount, blockSize
  454. * totalBlockCount);
  455. }
  457. /**
  458. * 取上一级路径
  459. *
  460. * @param path
  461. * @return
  462. */
  463. public static String getParentPath(String path) {
  464. if (path != null && path.length() > 0) {
  465. path = path.substring(0, path.length() - 1); // 去掉最后一个字符 ， 以兼容以“/”
  466. // 结尾的路径
  467. return path.substring(0, path.lastIndexOf(File.separator) + 1);
  468. } else {
  469. return "";
  470. }
  471. }
  472. // 1.判断如果总容量小于2G,则排除 2.排除内置或外置重复路径
  473.  	public static boolean compareData(ArrayList<SDCardStat> list,
  474.  			long capacity) {
  475.  		//排除内置或外置重复路径
  476.  		if (list.size() > 0) {
  477.  			for (int i = 0; i < list.size(); i++) {
  478.  				if (list.get(i).totalSize==capacity) {
  479.  					Log.d("gaolei", "duplicate-------------------------");
  480.  					return false;
  482.  				}
  483.  			}
  485.  		}
  486.  		//判断如果总容量小于2G
  487.  		if (capacity/ 1073741824<2) {
  488.  			Log.d("gaolei", "capacity/ 1073741824-------------------------"+capacity/ 1073741824);
  489.  				return false;
  490.  		}
  491.  		return true;
  492.  	}
  493. public static class SDCardStat {
  495. public String rootPath;
  496. public String excludePath; // 排除路径， 某些手机会将扩展卡挂载在sdcard下面
  497. public String name;
  498. public Format format;
  499. // public long usedSize;
  500. public long totalSize;
  501. public long freeSize;
  502. public boolean isCaseSensitive;
  503. public int voldMinorIdx;
  504. // voldMinorIdx 小于此值的为sdcard内置设备，大于此值的是u盘
  505. public static int SDCARD_MAX_COUNT = 1024;
  506. /**
  507. * Android4.4增加了SD卡读写权限设置，分为内置存储和外置SD卡，对权限见下表：<br>
  508. * <table width="60%" border="1" align="center">
  509. * <tr>
  510. * <th align="center">Action</th>
  511. * <th align="center">Primary</th>
  512. * <th align="center">Secondary</th>
  513. * </tr>
  514. * <tbody>
  515. * <tr>
  516. * <td>Read Top-Level Directories</td>
  517. * <td align="center">R</td>
  518. * <td align="center">R</td>
  519. * </tr>
  520. * <tr>
  521. * <td>Write Top-Level Directories</td>
  522. * <td align="center">W</td>
  523. * <td align="center">N</td>
  524. * </tr>
  525. * <tr>
  526. * <td>Read My Package’s Android Data Directory</td>
  527. * <td align="center">Y</td>
  528. * <td align="center">Y</td>
  529. * </tr>
  530. * <tr>
  531. * <td>Write My Package’s Android Data Directory</td>
  532. * <td align="center">Y</td>
  533. * <td align="center">Y</td>
  534. * </tr>
  535. * <tr>
  536. * <td>Read Another Package’s Android Data Directory</td>
  537. * <td align="center">R</td>
  538. * <td align="center">R</td>
  539. * </tr>
  540. * <tr>
  541. * <td>Write Another Package’s Android Data Directory</td>
  542. * <td align="center">W</td>
  543. * <td align="center">N</td>
  544. * </tr>
  545. * </tbody>
  546. * </table>
  547. * <p style="text-align: center;">
  548. * <strong>R = With Read Permission, W = With Write Permission, Y =
  549. * Always, N = Never </strong>
  550. * </p>
  551. * 根据上面表格判断SD类型，这个属性代表了Write Top-Level Directories的Secondary(外置SD卡).<br>
  552. * 由于部分手机厂商没有遵循Google新的SD卡规范，所以在部分Android4.4手机上外置SD卡的根目录仍然有读写
  553. * 权限.所以只有在Android4.4以上手机，并且外置SD卡不可写的情况此属性才为<strong>false</strong>.
  554. */
  555. public boolean canWrite = true;
  557. public SDCardStat(String path, Format format, int voldMinorIdx,
  558. String excludePath) {
  559. DiskStat stat = getDiskCapacity(path);
  560. if (stat != null) {
  561. this.freeSize = stat.free;
  562. this.totalSize = stat.total;
  563. }
  564. this.rootPath = path;
  565. this.format = format;
  566. this.isCaseSensitive = checkCaseSensitive(format);
  567. // this.name = getSDCardName(path);
  568. this.voldMinorIdx = voldMinorIdx;
  569. this.excludePath = excludePath;
  570. }
  572. public SDCardStat(String path, Format format, int voldMinorIdx) {
  573. this(path, format, voldMinorIdx, "");
  574. }
  576. public static enum Format {
  577. vfat, exfat, ext4, fuse, sdcardfs, texfat
  578. }
  580. public boolean checkCaseSensitive(Format format) {
  581. return (format == Format.vfat || format == Format.exfat) ? false
  582. : true;
  583. }
  585. public void setExcludePath(String excludePath) {
  586. DiskStat excludeStat = getDiskCapacity(excludePath);
  587. if (excludeStat != null) {
  588. this.freeSize -= excludeStat.free;
  589. this.totalSize -= excludeStat.total;
  591. }
  592. this.excludePath = excludePath;
  593. }
  595. public void refreshDiskCapacity() {
  596. DiskStat stat = getDiskCapacity(this.rootPath);
  597. if (stat != null) {
  598. this.freeSize = stat.free;
  599. this.totalSize = stat.total;
  601. }
  602. }
  603. }
  605. public static class DiskStat {
  606. public long free;
  607. public long total;
  609. public DiskStat(long free, long total) {
  610. this.free = free;
  611. this.total = total;
  612. }
  613. }
  615. }</span>

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 昵称48946089 > 《anddroid》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多