Read/Write to external storage and persist after uninstallation

I need to create files and read/write to external storage and the files should persist after uninstallation of the application. It should work on Android 12.

import android.content.Context;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileUtil {

    public static void writeFileToExternalStorage(Context context, String fileName, String content) {
        File file = new File(context.getExternalFilesDir(null), fileName);

        try {
            FileOutputStream outputStream = new FileOutputStream(file);
            outputStream.write(content.getBytes());
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


String fileName = "my_file.txt";
String content = "Hello";

FileUtil.writeFileToExternalStorage(getApplicationContext(), fileName, content);

File my_file.txt will be deleted after uninstallation of the app. I need it to persist.
I will be writing text files and images related to it (e.g. one subdirectory of the app directory would contain files f1.txt, img1.jpg, f2.txt, img2.jpg ... fn.txt, imgn.jpg).
I don't want to use database or shared preferences for it.
How can I do it?

In this video there is said, that everytime the app reads/writes to a file, the user has to go through dialog, but this is what I don't want. It's very uncomfortable for the user.

You're totally right that Context#getExternalFilesDir returns app that will be uninstalled with your app.

For API 29 and above:

Documentation says that for Documents we should use Storage Access Framework.

You can create a new file using Intent#ACTION_CREATE_DOCUMENT

Similar to this:

// Request code for creating a PDF document.
const val CREATE_FILE = 1

private fun createFile(pickerInitialUri: Uri) {
    val intent = Intent(Intent.ACTION_CREATE_DOCUMENT).apply {
        addCategory(Intent.CATEGORY_OPENABLE)
        type = "application/text"
        putExtra(Intent.EXTRA_TITLE, "file.txt")
    }
    startActivityForResult(intent, CREATE_FILE)
}

You will see something similar to

After executing the command and receiving the result you can access the file using uri from Intent#getData. With a uri you can use contentResolver.openOutputStream(destination) to update the file's content.

Update 1: this is a similar code in Java

    private void createFile() {
        Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
        intent.addCategory(Intent.CATEGORY_OPENABLE);
        intent.setType("application/text");
        intent.putExtra(Intent.EXTRA_TITLE, "file.txt");

        launcher.launch(intent);
    }

And writing to the file:

OutputStream stream = getContentResolver().openOutputStream(uri);
PrintWriter writer = new PrintWriter(stream);

writer.println("Hello World");
writer.close();

For API below 29:

I see that documentation offers to use Environment#getExternalStoragePublicDirectory, especially, if files should be shared.

You can also access the root of the device using Environment#getExternalStorageDirectory. However, the usage is discouraged in favour of getExternalStoragePublicDirectory as files saved in root can pollute user's space.

> Applications should not directly use this top-level directory, in order to avoid polluting the user's root namespace. Any files that are private to the application should be placed in a directory returned by Context.getExternalFilesDir, which the system will take care of deleting if the application is uninstalled. Other shared files should be placed in one of the directories returned by getExternalStoragePublicDirectory(String).

The only place where you should create the subdirectory for your files is in public Download or Documents directory.

You will use getExternalPublicDirectory() to get the path. Use it. Deprecated or not it works on all Android versions.

Other public directories are not possible as they will not take files with different extensions.

The files will persist. You did not tell who and how those files will be used later.

If you reinstall your app use SAF to let the user choose your subdir.

On Android 12, to manage storage SAF is the recommended way.

But if you don't want to use then the only way is requesting permission MANAGE_EXTERNAL_STORAGE which allows full storage access. For more details check out this link.

Note: MANAGE_EXTERNAL_STORAGE is a sensitive permission so check out this Google play notice before using it.

• You can save the file to path Environment.getExternalStorageDirectory() + "/your_folder", However user can manual delete file.
  Refer

In Android, files saved to the external storage directory provided by context.getExternalFilesDir() are considered part of the application's private external storage. By default, these files are deleted when the application is uninstalled. However, if you want the files to persist even after uninstallation, you can save them to a different location on the external storage.

Here's an updated version of your code that saves files to a custom directory on the external storage

import android.content.Context;
import android.os.Environment;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileUtil {

    public static void writeFileToExternalStorage(Context context, String directoryName, String fileName, String content) {
        File directory = new File(Environment.getExternalStorageDirectory(), directoryName);
        if (!directory.exists()) {
            directory.mkdirs(); // Create the directory if it doesn't exist
        }

        File file = new File(directory, fileName);

        try {
            FileOutputStream outputStream = new FileOutputStream(file);
            outputStream.write(content.getBytes());
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Usage:

String directoryName = "my_files_directory";
String fileName = "my_file.txt";
String content = "Hello";

FileUtil.writeFileToExternalStorage(getApplicationContext(), directoryName, fileName, content);

In this code, the Environment.getExternalStorageDirectory() method provides the root directory of the external storage. By creating a custom directory within this root directory, you can save your files there. This custom directory will persist even after the application is uninstalled, allowing the files to remain intact.

Please note that starting from Android 10 (API level 29), there are restrictions on accessing external storage, and you'll need to request the necessary permissions from the user. Additionally, consider handling the storage access permission gracefully in case it is revoked by the user in the future.

Regarding the video you mentioned, it seems to be referring to the Scoped Storage changes introduced in Android 10. Scoped Storage imposes certain restrictions on accessing files outside the application's private directories. However, the approach described above should work for Android 12 as well, as it saves the files within the application's private external storage, which is not subject to Scoped Storage restrictions.

I hope I have been of assistance to you.