Android External Storage File Saving: Directory Creation and Permission Management

Problem Analysis and Solution

In Android development, saving files to external storage is a common requirement, but developers often encounter directory creation failures. The original code attempts to create multi-level subdirectories under the external storage root directory and save files, but fails with FileNotFoundException due to non-existent directories.

Correct Directory Creation Method

The key issue is that before creating a FileOutputStream, you must ensure the target directory exists. Android's file system does not automatically create non-existent parent directories, requiring explicit calls to the mkdirs() method. Here's the improved correct implementation:

private void saveFileToExternalStorage(byte[] fileData, String objectId) {
    // Define file path
    String directoryName = "MyApp/MediaTag";
    String fileName = "MediaTag-" + objectId + ".png";
    
    // Get external storage directory
    File externalDir = Environment.getExternalStorageDirectory();
    File appDirectory = new File(externalDir, directoryName);
    
    // Create directory (if it doesn't exist)
    if (!appDirectory.exists()) {
        boolean dirCreated = appDirectory.mkdirs();
        if (!dirCreated) {
            Log.e("FileSave", "Failed to create directory: " + appDirectory.getAbsolutePath());
            return;
        }
    }
    
    // Create file object
    File outputFile = new File(appDirectory, fileName);
    
    try {
        // Write file data
        FileOutputStream fos = new FileOutputStream(outputFile);
        fos.write(fileData);
        fos.flush();
        fos.close();
        Log.d("FileSave", "File saved successfully: " + outputFile.getAbsolutePath());
    } catch (IOException e) {
        Log.e("FileSave", "Error saving file: " + e.getMessage());
        e.printStackTrace();
    }
}

Permission Configuration Requirements

You must declare the WRITE_EXTERNAL_STORAGE permission in AndroidManifest.xml:

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

For Android 6.0 (API level 23) and higher, you also need to request this permission at runtime. According to the evolution of Android storage permissions, Android 10 and above introduced scoped storage, limiting apps' broad access to shared storage areas.

File Privacy Protection Strategy

To prevent saved files from appearing in the system gallery, you can use the following method:

private void savePrivateFile(byte[] data, String filename) {
    // Use app-specific external storage directory
    File privateDir = getExternalFilesDir(null);
    File outputFile = new File(privateDir, filename);
    
    try {
        FileOutputStream fos = new FileOutputStream(outputFile);
        fos.write(data);
        fos.flush();
        fos.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Directories created using getExternalFilesDir() are located in the app-specific area, inaccessible to other apps, and files won't appear in the system media library. When the app is uninstalled, these files are automatically deleted.

Storage Type Selection Guide

According to official Android documentation, storage selection should consider the following factors:

• App-specific storage: Suitable for app-private files, no permissions required, automatically deleted on uninstall
• Shared storage: Suitable for media files that need to be shared with other apps
• Internal storage: Suitable for sensitive data, always available
• External storage: Larger capacity, but may be unavailable (e.g., SD card removed)

Best Practice Recommendations

1. Always check if the directory exists before file operations

2. Use try-catch blocks to handle possible IOException

3. Properly handle storage permissions according to Android version

4. Consider using scoped storage to improve user privacy protection

5. Regularly clean up cache files that are no longer needed

By following these best practices, developers can ensure the reliability and security of file saving operations while providing a good user experience.