自定义下载目录技术咨询：外部存储自定义目录代码相关问题

Looking at your code snippet, I can tell you’re trying to set up a custom download directory on external storage—but there are a few gaps and compatibility issues to address, especially for modern Android versions. Let’s break down the logic, fix the code, and cover key best practices you’ll need.

First, Let’s Spot the Gaps in Your Original Code #

• Outdated API Usage: Environment.getExternalStorageDirectory() is deprecated starting from Android 10 (API 29) due to Scoped Storage restrictions. Directly using this path will cause errors or be blocked on newer devices.
• Incomplete Logic: Your code cuts off before finishing the downloadSubPath assignment and doesn’t include actual directory creation or failure handling.
• Missing Permission Checks: Pre-Android 10 devices require the WRITE_EXTERNAL_STORAGE permission, and you need to handle runtime permission requests for this.
• No Error Validation: There’s no check to confirm if the directory was successfully created, which can lead to silent failures when trying to save files later.

Improved, Version-Compatible Code Implementation #

Below are two complete implementations—choose based on whether you need files tied to your app or visible to other apps:

Option 1: App-Specific Directory (Recommended) #

This directory is linked to your app: no extra permissions needed (even on Android 10+), and it gets deleted automatically when the app is uninstalled.

import android.content.Context;
import android.os.Environment;
import java.io.File;
import android.util.Log;

public class StorageManager {
    public static File downloadDir;
    public static String downloadStorage;
    public static String downloadSubPath;

    // Call this with your app context and desired subpath (e.g., "/MyAppCustomDownloads")
    public static boolean checkDownloadDir(Context context, String subPath) {
        // Fallback to internal storage if external is unavailable
        downloadDir = context.getFilesDir();
        
        // Verify external storage is mounted and writable
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            // Use app-specific external download directory (API 19+)
            File externalBaseDir = context.getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS);
            if (externalBaseDir != null) {
                downloadStorage = externalBaseDir.getAbsolutePath();
                downloadSubPath = downloadStorage + subPath;
                downloadDir = new File(downloadSubPath);
                
                // Create directory (including parent folders if needed)
                if (!downloadDir.exists()) {
                    boolean creationSuccess = downloadDir.mkdirs();
                    if (!creationSuccess) {
                        Log.e("StorageManager", "Failed to create external directory: " + downloadDir.getAbsolutePath());
                        return false;
                    }
                }
                return true;
            }
        }
        
        // Fallback to internal storage if external is inaccessible
        downloadStorage = downloadDir.getAbsolutePath();
        downloadSubPath = downloadStorage + subPath;
        downloadDir = new File(downloadSubPath);
        
        if (!downloadDir.exists()) {
            boolean creationSuccess = downloadDir.mkdirs();
            if (!creationSuccess) {
                Log.e("StorageManager", "Failed to create internal directory: " + downloadDir.getAbsolutePath());
                return false;
            }
        }
        return true;
    }
}

Option 2: Public Download Directory (Files Visible to Other Apps) #

If you need files to be accessible outside your app, you’ll need to handle Scoped Storage rules:

• Android 10-12 (API 29-32): Use MediaStore to create files in the public Downloads folder (no permission needed for this approach).
• Android 13+: Use ACTION_OPEN_DOCUMENT_TREE to let users select the directory, or request READ_MEDIA_* permissions for media files.
• Pre-Android 10: Request WRITE_EXTERNAL_STORAGE runtime permission first.

Simplified snippet for pre-Android 10 public directory creation:

public static boolean checkPublicDownloadDir(String subPath) {
    if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
        File publicDownloadBase = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
        downloadSubPath = publicDownloadBase.getAbsolutePath() + subPath;
        downloadDir = new File(downloadSubPath);
        
        if (!downloadDir.exists()) {
            boolean creationSuccess = downloadDir.mkdirs();
            if (!creationSuccess) {
                Log.e("StorageManager", "Failed to create public directory: " + downloadDir.getAbsolutePath());
                return false;
            }
        }
        return true;
    }
    Log.e("StorageManager", "External storage is not mounted or writable");
    return false;
}

Key Best Practices to Follow #

• Prioritize App-Specific Storage: It’s safer, requires no permissions, and avoids Scoped Storage complications.
• Always Check Storage State: Never assume external storage is available—validate Environment.getExternalStorageState() before writing.
• Handle Runtime Permissions: For pre-Android 10, request WRITE_EXTERNAL_STORAGE and confirm user approval before creating directories.
• Log Failures: Add logging for directory creation issues to debug problems quickly.
• Avoid Deprecated APIs: Replace getExternalStorageDirectory() and getExternalStoragePublicDirectory() with context-based methods like getExternalFilesDir() for long-term compatibility.

内容的提问来源于stack exchange，提问作者Imacisco