How to save an image in Android Q using MediaStore?

Question

Here is a link to the new Android Q Scoped Storage. According to this Android Developers Best Practices Blog, `storing shared media files` (which is my case) should be done using the MediaStore API. Digging into the docs and I cannot find a relevant function. Here is my trial in Kotlin: ``` val bitmap = getImageBitmap() // I have a bitmap from a function or callback or whatever val name = "example.png" // I have a name val picturesDirectory = getExternalFilesDir(Environment.DIRECTORY_PICTURES)!! // Make sure the directory "Android/data/com.mypackage.etc/files/Pictures" exists if (!picturesDirectory.exists()) { picturesDirectory.mkdirs() } try { val out = FileOutputStream(File(picturesDirectory, name)) bitmap.compress(Bitmap.CompressFormat.PNG, 100, out) out.flush() out.close() } catch(e: Exception) { // handle the error } ``` The result is that my image is saved here `Android/data/com.mypackage.etc/files/Pictures/example.png` as described in the Best Practices Blog as `Storing app-int…

Accepted Answer

Try the next method. Android Q (and above) already takes care of creating the folders if they don’t exist. The example is hard-coded to output into the DCIM folder. If you need a sub-folder then append the sub-folder name as next:

```
final String relativeLocation = Environment.DIRECTORY_DCIM + File.separator + “YourSubforderName”;
```

Consider that the compress format should be related to the mime-type parameter. For example, with a JPEG compress format the mime-type would be "image/jpeg", and so on. Probably you may also want to pass the compress quality as a parameter, in this example is hardcoded to 95.

Java:

```
@NonNull
public Uri saveBitmap(@NonNull final Context context, @NonNull final Bitmap bitmap,
                      @NonNull final Bitmap.CompressFormat format,
                      @NonNull final String mimeType,
                      @NonNull final String displayName) throws IOException {

final ContentValues values = new ContentValues();
    values.put(MediaStore.MediaColumns.DISPLAY_NAME, displayName);
    values.put(MediaStore.MediaColumns.MIME_TYPE, mimeType);
    values.put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DCIM);

final ContentResolver resolver = context.getContentResolver();
    Uri uri = null;

try {
        final Uri contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
        uri = resolver.insert(contentUri, values);

if (uri == null)
            throw new IOException("Failed to create new MediaStore record.");

try (final OutputStream stream = resolver.openOutputStream(uri)) {
            if (stream == null)
                throw new IOException("Failed to open output stream.");
         
            if (!bitmap.compress(format, 95, stream))
                throw new IOException("Failed to save bitmap.");
        }

return uri;
    }
    catch (IOException e) {

if (uri != null) {
            // Don't leave an orphan entry in the MediaStore
            resolver.delete(uri, null, null);
        }

throw e;
    }
}
```

Kotlin:

```
@Throws(IOException::class)
fun saveBitmap(
    context: Context, bitmap: Bitmap, format: Bitmap.CompressFormat,
    mimeType: String, displayName: String
): Uri {

val values = ContentValues().apply {
        put(MediaStore.MediaColumns.DISPLAY_NAME, displayName)
        put(MediaStore.MediaColumns.MIME_TYPE, mimeType)
        put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DCIM)
    }

val resolver = context.contentResolver
    var uri: Uri? = null

try {
        uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
            ?: throw IOException("Failed to create new MediaStore record.")

resolver.openOutputStream(uri)?.use {
            if (!bitmap.compress(format, 95, it))
                throw IOException("Failed to save bitmap.")
        } ?: throw IOException("Failed to open output stream.")

return uri

} catch (e: IOException) {

uri?.let { orphanUri ->
            // Don't leave an orphan entry in the MediaStore
            resolver.delete(orphanUri, null, null)
        }

throw e
    }
}
```

Kotlin variant, with a more functional style:

```
@Throws(IOException::class)
fun saveBitmap(
    context: Context, bitmap: Bitmap, format: Bitmap.CompressFormat,
    mimeType: String, displayName: String
): Uri {

val values = ContentValues().apply {
        put(MediaStore.MediaColumns.DISPLAY_NAME, displayName)
        put(MediaStore.MediaColumns.MIME_TYPE, mimeType)
        put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_DCIM)
    }

var uri: Uri? = null

return runCatching {
        with(context.contentResolver) {
            insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)?.also {
                uri = it // Keep uri reference so it can be removed on failure

openOutputStream(it)?.use { stream ->
                    if (!bitmap.compress(format, 95, stream))
                        throw IOException("Failed to save bitmap.")
                } ?: throw IOException("Failed to open output stream.")

} ?: throw IOException("Failed to create new MediaStore record.")
        }
    }.getOrElse {
        uri?.let { orphanUri ->
            // Don't leave an orphan entry in the MediaStore
            context.contentResolver.delete(orphanUri, null, null)
        }

throw it
    }
}
```

How to save an image in Android Q using MediaStore?

Solution

Problem

Related problems