android - 在 KitKat 4.4.2 中获取 SDard(s) 路径和大小

Question

我在 Google Play 上有一个设备信息应用程序，在该应用程序中我有存储信息。我知道在 Android 4.4 中，在访问外部 SD 卡方面发生了一些变化。内部似乎没有给我一个问题。我的问题是，如何可靠地获取 KitKat 上 SD 卡的大小？

我列出了所需的权限，因为这在早期版本的 Android 上运行良好。我在这里搜索过 SO，但我似乎总是遇到相同的错误之一。我不需要写入 SD 卡，只需要读取大小可用性。

我有一个来自 SO 的 StorageUtils 类，抱歉我不记得链接了。

public class StorageUtils {

private static final String TAG = "StorageUtils";

public static class StorageInfo {

    public final String path;
    public final boolean internal;
    public final boolean readonly;
    public final int display_number;

    StorageInfo(String path, boolean internal, boolean readonly,
            int display_number) {
        this.path = path;
        this.internal = internal;
        this.readonly = readonly;
        this.display_number = display_number;
    }
}

public static ArrayList<StorageInfo> getStorageList() {

    ArrayList<StorageInfo> list = new ArrayList<StorageInfo>();
    String def_path = Environment.getExternalStorageDirectory().getPath();
    boolean def_path_internal = !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);
    BufferedReader buf_reader = null;
    try {
        HashSet<String> paths = new HashSet<String>();
        buf_reader = new BufferedReader(new FileReader("/proc/mounts"));
        String line;
        int cur_display_number = 1;
        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 (mount_point.equals(def_path)) {
                    paths.add(def_path);
                    list.add(new StorageInfo(def_path, def_path_internal,
                            readonly, -1));
                } else 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, false,
                                readonly, cur_display_number++));
                    }
                }
            }
        }

        if (!paths.contains(def_path) && def_path_available) {
            list.add(new StorageInfo(def_path, def_path_internal,
                    def_path_readonly, -1));
        }

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

public static String getReadableFileSize(long bytes, boolean si) {
    int unit = si ? 1000 : 1024;
    if (bytes < unit)
        return bytes + " B";
    int exp = (int) (Math.log(bytes) / Math.log(unit));
    String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp - 1)
            + (si ? "" : "i");
    return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
}

@SuppressLint("NewApi")
public static long getFreeSpace(String path) {
    StatFs statFs = new StatFs(path);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
        long sdAvailSize = statFs.getFreeBlocksLong()
                * statFs.getBlockSizeLong();
        return sdAvailSize;
    } else {
        @SuppressWarnings("deprecation")
        double sdAvailSize = (double) statFs.getFreeBlocks()
                * (double) statFs.getBlockSize();

        return (long) sdAvailSize;
    }
}

public static long getUsedSpace(String path) {
    return getTotalSpace(path) - getFreeSpace(path);
}

@SuppressLint("NewApi")
public static long getTotalSpace(String path) {
    StatFs statFs = new StatFs(path);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
        long sdTotalSize = statFs.getBlockCountLong()
                * statFs.getBlockSizeLong();
        return sdTotalSize;
    } else {
        @SuppressWarnings("deprecation")
        double sdTotalSize = (double) statFs.getBlockCount()
                * statFs.getBlockSize();

        return (long) sdTotalSize;
    }
}

/**
 * getSize()[0] is /mnt/sdcard. getSize()[1] is size of sd (example 12.0G),
 * getSize()[2] is used, [3] is free, [4] is blksize
 * 
 * @return
 * @throws IOException
 */
public static String[] getSize() throws IOException {
    String memory = "";
    Process p = Runtime.getRuntime().exec("df /mnt/sdcard");
    InputStream is = p.getInputStream();
    int by = -1;
    while ((by = is.read()) != -1) {
        memory += new String(new byte[] { (byte) by });
    }
    for (String df : memory.split("/n")) {
        if (df.startsWith("/mnt/sdcard")) {
            String[] par = df.split(" ");
            List<String> pp = new ArrayList<String>();
            for (String pa : par) {
                if (!pa.isEmpty()) {
                    pp.add(pa);
                }
            }
            return pp.toArray(new String[pp.size()]);

        }
    }
    return null;
}

}

这是我尝试显示 SD 卡路径和大小的 fragment 。

public class CpuMemFragment extends Fragment {
// CPU
String devCpuInfo;
TextView tvCpuInfo;

// RAM
String devRamInfo;
TextView tvRamInfo;

// Storage
String devStorageA, devStorageB;
TextView tvStorageAName, tvStorageA, tvStorageB, tvStorageBName;

AdView adView;

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
        Bundle savedInstanceState) {

    View rootView = inflater.inflate(R.layout.cpu_mem, container, false);

    return rootView;
}

@Override
public void onActivityCreated(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onActivityCreated(savedInstanceState);

    // *** CPU ***
    //
    devCpuInfo = readCpuInfo();
    //
    // #################################

    // *** RAM ***
    //
    devRamInfo = readTotalRam();
    //
    // #################################

    // *** STORAGE ***
    //

    ArrayList<StorageInfo> storageInfoList = StorageUtils.getStorageList();

    tvStorageAName = (TextView) getView().findViewById(R.id.tvStorageAName);

    tvStorageBName = (TextView) getView().findViewById(R.id.tvStorageBName);

    if (storageInfoList.size() > 0) {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT
                && !storageInfoList.get(0).internal) {
            kitKatWorkaround(0);
        }
        tvStorageAName.setText(storageInfoList.get(0).path);

        devStorageA = StorageUtils.getReadableFileSize(
                (StorageUtils.getUsedSpace(storageInfoList.get(0).path)),
                true)
                + "/"
                + StorageUtils.getReadableFileSize((StorageUtils
                        .getTotalSpace(storageInfoList.get(0).path)), true);

        if (storageInfoList.size() > 1) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT
                    && !storageInfoList.get(0).internal) {
                kitKatWorkaround(1);
            }
            tvStorageBName.setText(storageInfoList.get(1).path);

            devStorageB = StorageUtils.getReadableFileSize(
                    StorageUtils.getUsedSpace(storageInfoList.get(1).path)
                            + (StorageUtils.getUsedSpace("system/")), true)
                    + "/"
                    + StorageUtils.getReadableFileSize((StorageUtils
                            .getTotalSpace(storageInfoList.get(1).path)),
                            true);
        } else {
            devStorageB = "N/A";
        }
    } else {
        devStorageA = "N/A";
        devStorageB = "N/A";
    }
    //
    // #################################

    // CPU
    tvCpuInfo = (TextView) getView().findViewById(R.id.tvCpuInfo);
    tvCpuInfo.setText(devCpuInfo);
    //
    // #################################

    // RAM
    tvRamInfo = (TextView) getView().findViewById(R.id.tvRamInfo);
    tvRamInfo.setText(devRamInfo);
    //
    // #################################

    // STORAGE
    tvStorageA = (TextView) getView().findViewById(R.id.tvStorageA);
    tvStorageA.setText(devStorageA);

    tvStorageB = (TextView) getView().findViewById(R.id.tvStorageB);
    tvStorageB.setText(devStorageB);
    //
    // #################################

    // Look up the AdView as a resource and load a request.
    adView = (AdView) getActivity().findViewById(R.id.adCpuMemBanner);
    AdRequest adRequest = new AdRequest.Builder().build();
    adView.loadAd(adRequest);
}

@Override
public void onPause() {
    if (adView != null) {
        adView.pause();
    }
    super.onPause();
}

@Override
public void onResume() {
    super.onResume();
    if (adView != null) {
        adView.resume();
    }
}

@Override
public void onDestroy() {
    if (adView != null) {
        adView.destroy();
    }
    super.onDestroy();
}

private static synchronized String readCpuInfo() {
    ProcessBuilder cmd;
    String result = "";

    try {
        String[] args = { "/system/bin/cat", "/proc/cpuinfo" };
        cmd = new ProcessBuilder(args);

        Process process = cmd.start();
        InputStream in = process.getInputStream();
        byte[] re = new byte[1024];
        while (in.read(re) != -1) {
            System.out.println(new String(re));
            result = result + new String(re);
        }
        in.close();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
    return result;
}

public static synchronized String readTotalRam() {
    String load = "";
    try {
        RandomAccessFile reader = new RandomAccessFile("/proc/meminfo", "r");
        load = reader.readLine();
        reader.close();
    } catch (IOException ex) {
        ex.printStackTrace();
    }
    return load;
}

public void kitKatWorkaround(int index) {
    String path1 = Environment.getExternalStorageDirectory().getPath();

            //Storage A
    if (index == 0) {

        tvStorageAName.setText(path1);

        devStorageA = StorageUtils.getReadableFileSize(
                (StorageUtils.getUsedSpace(path1)), true)
                + "/"
                + StorageUtils.getReadableFileSize(
                        (StorageUtils.getTotalSpace(path1)), true);
    }

            //Storage B
    if (index == 1) {
        tvStorageBName.setText(path1);

        devStorageB = StorageUtils.getReadableFileSize(
                StorageUtils.getUsedSpace(path1)), true)
                + "/"
                + StorageUtils.getReadableFileSize(
                        (StorageUtils.getTotalSpace(path1)), true);

    }
}
}

这会导致 EACCES 错误，或 KitKat 上的无效路径(拒绝访问)。请提供帮助，非常感谢您抽出宝贵时间。

Answer 1

您可以通过调用Context.getExternalFilesDirs() 或Context.getExternalCacheDirs() 找到所有共享存储设备。然后，您可以调用 File.getUsableSpace() 或使用 android.os.StatFs 检查每个位置的可用磁盘空间。

这些 API 也可在支持库的 ContextCompat 中使用，以便在 pre-KitKat 设备上无缝工作。