react-native-security-suite 0.6.5 → 0.6.6

package/android/src/main/java/com/securitysuite/internal/data/har/log/entry/cache/SecondaryRequest.kt

@@ -0,0 +1,13 @@
+package com.securitysuite.internal.data.har.log.entry.cache
+
+import com.google.gson.annotations.SerializedName
+
+// https://github.com/ahmadnassri/har-spec/blob/master/versions/1.2.md#beforerequest--afterrequest
+// http://www.softwareishard.com/blog/har-12-spec/#cache
+internal data class SecondaryRequest(
+    @SerializedName("expires") val expires: String? = null,
+    @SerializedName("lastAccess") val lastAccess: String,
+    @SerializedName("eTag") val eTag: String,
+    @SerializedName("hitCount") val hitCount: Int,
+    @SerializedName("comment") val comment: String? = null,
+)

package/android/src/main/java/com/securitysuite/internal/data/har/log/entry/request/PostData.kt

@@ -0,0 +1,20 @@
+package com.securitysuite.internal.data.har.log.entry.request
+
+import com.securitysuite.internal.data.entity.HttpTransaction
+import com.securitysuite.internal.data.har.log.entry.request.postdata.Params
+import com.google.gson.annotations.SerializedName
+
+// https://github.com/ahmadnassri/har-spec/blob/master/versions/1.2.md#postdata
+// http://www.softwareishard.com/blog/har-12-spec/#postData
+// text and params fields are mutually exclusive.
+internal data class PostData(
+    @SerializedName("mimeType") val mimeType: String,
+    @SerializedName("params") val params: Params? = null,
+    @SerializedName("text") val text: String? = null,
+    @SerializedName("comment") val comment: String? = null,
+) {
+    constructor(transaction: HttpTransaction) : this(
+        mimeType = transaction.requestContentType ?: "application/octet-stream",
+        text = transaction.requestBody,
+    )
+}

package/android/src/main/java/com/securitysuite/internal/data/har/log/entry/request/QueryString.kt

@@ -0,0 +1,23 @@
+package com.securitysuite.internal.data.har.log.entry.request
+
+import com.google.gson.annotations.SerializedName
+import okhttp3.HttpUrl
+
+// https://github.com/ahmadnassri/har-spec/blob/master/versions/1.2.md#querystring
+// http://www.softwareishard.com/blog/har-12-spec/#queryString
+internal data class QueryString(
+    @SerializedName("name") val name: String,
+    @SerializedName("value") val value: String,
+    @SerializedName("comment") val comment: String? = null,
+) {
+    companion object {
+        fun fromUrl(url: HttpUrl): List<QueryString> {
+            return List(url.querySize) { index ->
+                QueryString(
+                    name = url.queryParameterName(index),
+                    value = url.queryParameterValue(index).orEmpty(),
+                )
+            }
+        }
+    }
+}

package/android/src/main/java/com/securitysuite/internal/data/har/log/entry/request/postdata/Params.kt

@@ -0,0 +1,13 @@
+package com.securitysuite.internal.data.har.log.entry.request.postdata
+
+import com.google.gson.annotations.SerializedName
+
+// https://github.com/ahmadnassri/har-spec/blob/master/versions/1.2.md#params
+// http://www.softwareishard.com/blog/har-12-spec/#params
+internal data class Params(
+    @SerializedName("name") val name: String,
+    @SerializedName("value") val value: String? = null,
+    @SerializedName("fileName") val fileName: String? = null,
+    @SerializedName("contentType") val contentType: String? = null,
+    @SerializedName("comment") val comment: String? = null,
+)

package/android/src/main/java/com/securitysuite/internal/data/har/log/entry/response/Content.kt

@@ -0,0 +1,30 @@
+package com.securitysuite.internal.data.har.log.entry.response
+
+import com.securitysuite.internal.data.entity.HttpTransaction
+import com.google.gson.annotations.SerializedName
+
+// https://github.com/ahmadnassri/har-spec/blob/master/versions/1.2.md#content
+// http://www.softwareishard.com/blog/har-12-spec/#content
+internal data class Content(
+    @SerializedName("size") val size: Long? = null,
+    @SerializedName("compression") val compression: Int? = null,
+    @SerializedName("mimeType") val mimeType: String,
+    @SerializedName("text") val text: String? = null,
+    @SerializedName("encoding") val encoding: String? = null,
+    @SerializedName("comment") val comment: String? = null,
+) {
+    companion object {
+        internal val EMPTY =
+            Content(
+                size = 0L,
+                compression = 0,
+                mimeType = "text/plain",
+                text = "",
+            )
+    }
+    constructor(transaction: HttpTransaction) : this(
+        size = transaction.responsePayloadSize,
+        mimeType = transaction.responseContentType ?: "application/octet-stream",
+        text = transaction.responseBody,
+    )
+}

package/android/src/main/java/com/securitysuite/internal/data/har/log/page/PageTimings.kt

@@ -0,0 +1,11 @@
+package com.securitysuite.internal.data.har.log.page
+
+import com.google.gson.annotations.SerializedName
+
+// https://github.com/ahmadnassri/har-spec/blob/master/versions/1.2.md#pagetimings
+// http://www.softwareishard.com/blog/har-12-spec/#pageTimings
+internal data class PageTimings(
+    @SerializedName("onContentLoad") val onContentLoad: Long? = null,
+    @SerializedName("onLoad") val onLoad: Long? = null,
+    @SerializedName("comment") val comment: String? = null,
+)

package/android/src/main/java/com/securitysuite/internal/data/model/DialogData.kt

@@ -0,0 +1,8 @@
+package com.securitysuite.internal.data.model
+
+internal data class DialogData(
+    val title: String,
+    val message: String,
+    val positiveButtonText: String?,
+    val negativeButtonText: String?,
+)

package/android/src/main/java/com/securitysuite/internal/data/repository/HttpTransactionDatabaseRepository.kt

@@ -0,0 +1,60 @@
+package com.securitysuite.internal.data.repository
+
+import androidx.lifecycle.LiveData
+import com.securitysuite.internal.data.entity.HttpTransaction
+import com.securitysuite.internal.data.entity.HttpTransactionTuple
+import com.securitysuite.internal.data.room.ChuckerDatabase
+import com.securitysuite.internal.support.distinctUntilChanged
+
+internal class HttpTransactionDatabaseRepository(private val database: ChuckerDatabase) : HttpTransactionRepository {
+    private val transactionDao get() = database.transactionDao()
+
+    override fun getFilteredTransactionTuples(
+        code: String,
+        path: String,
+    ): LiveData<List<HttpTransactionTuple>> {
+        val pathQuery = if (path.isNotEmpty()) "%$path%" else "%"
+        return transactionDao.getFilteredTuples(
+            "$code%",
+            pathQuery = pathQuery,
+            /*
+             * Refer <a href='https://github.com/ChuckerTeam/chucker/issues/847">Issue #847</a> for
+             * more context
+             */
+            graphQlQuery = pathQuery,
+        )
+    }
+
+    override fun getTransaction(transactionId: Long): LiveData<HttpTransaction?> {
+        return transactionDao.getById(transactionId)
+            .distinctUntilChanged { old, new -> old?.hasTheSameContent(new) != false }
+    }
+
+    override fun getSortedTransactionTuples(): LiveData<List<HttpTransactionTuple>> {
+        return transactionDao.getSortedTuples()
+    }
+
+    override suspend fun deleteAllTransactions() {
+        transactionDao.deleteAll()
+    }
+
+    override suspend fun insertTransaction(transaction: HttpTransaction) {
+        val id = transactionDao.insert(transaction)
+        transaction.id = id ?: 0
+    }
+
+    override suspend fun updateTransaction(transaction: HttpTransaction): Int {
+        return transactionDao.update(transaction)
+    }
+
+    override suspend fun deleteOldTransactions(threshold: Long) {
+        transactionDao.deleteBefore(threshold)
+    }
+
+    override suspend fun getAllTransactions(): List<HttpTransaction> = transactionDao.getAll()
+
+    override fun getTransactionsInTimeRange(minTimestamp: Long?): List<HttpTransaction> {
+        val timestamp = minTimestamp ?: 0L
+        return transactionDao.getTransactionsInTimeRange(timestamp)
+    }
+}

package/android/src/main/java/com/securitysuite/internal/data/repository/HttpTransactionRepository.kt

@@ -0,0 +1,33 @@
+package com.securitysuite.internal.data.repository
+
+import androidx.lifecycle.LiveData
+import com.securitysuite.internal.data.entity.HttpTransaction
+import com.securitysuite.internal.data.entity.HttpTransactionTuple
+
+/**
+ * Repository Interface representing all the operations that are needed to let Chucker work
+ * with [HttpTransaction] and [HttpTransactionTuple]. Please use [HttpTransactionDatabaseRepository] that
+ * uses Room and SqLite to run those operations.
+ */
+internal interface HttpTransactionRepository {
+    suspend fun insertTransaction(transaction: HttpTransaction)
+
+    suspend fun updateTransaction(transaction: HttpTransaction): Int
+
+    suspend fun deleteOldTransactions(threshold: Long)
+
+    suspend fun deleteAllTransactions()
+
+    fun getSortedTransactionTuples(): LiveData<List<HttpTransactionTuple>>
+
+    fun getFilteredTransactionTuples(
+        code: String,
+        path: String,
+    ): LiveData<List<HttpTransactionTuple>>
+
+    fun getTransaction(transactionId: Long): LiveData<HttpTransaction?>
+
+    suspend fun getAllTransactions(): List<HttpTransaction>
+
+    fun getTransactionsInTimeRange(minTimestamp: Long?): List<HttpTransaction>
+}

package/android/src/main/java/com/securitysuite/internal/data/repository/RepositoryProvider.kt

@@ -0,0 +1,38 @@
+package com.securitysuite.internal.data.repository
+
+import android.content.Context
+import androidx.annotation.VisibleForTesting
+import com.securitysuite.internal.data.repository.RepositoryProvider.initialize
+import com.securitysuite.internal.data.room.ChuckerDatabase
+
+/**
+ * A singleton to hold the [HttpTransactionRepository] instance.
+ * Make sure you call [initialize] before accessing the stored instance.
+ */
+internal object RepositoryProvider {
+    private var transactionRepository: HttpTransactionRepository? = null
+
+    fun transaction(): HttpTransactionRepository {
+        return checkNotNull(transactionRepository) {
+            "You can't access the transaction repository if you don't initialize it!"
+        }
+    }
+
+    /**
+     * Idempotent method. Must be called before accessing the repositories.
+     */
+    fun initialize(applicationContext: Context) {
+        if (transactionRepository == null) {
+            val db = ChuckerDatabase.create(applicationContext)
+            transactionRepository = HttpTransactionDatabaseRepository(db)
+        }
+    }
+
+    /**
+     * Cleanup stored singleton objects
+     */
+    @VisibleForTesting
+    fun close() {
+        transactionRepository = null
+    }
+}

package/android/src/main/java/com/securitysuite/internal/data/room/ChuckerDatabase.kt

@@ -0,0 +1,22 @@
+package com.securitysuite.internal.data.room
+
+import android.content.Context
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import com.securitysuite.internal.data.entity.HttpTransaction
+
+@Database(entities = [HttpTransaction::class], version = 9, exportSchema = false)
+internal abstract class ChuckerDatabase : RoomDatabase() {
+    abstract fun transactionDao(): HttpTransactionDao
+
+    companion object {
+        private const val DB_NAME = "chucker.db"
+
+        fun create(applicationContext: Context): ChuckerDatabase {
+            return Room.databaseBuilder(applicationContext, ChuckerDatabase::class.java, DB_NAME)
+                .fallbackToDestructiveMigration()
+                .build()
+        }
+    }
+}

package/android/src/main/java/com/securitysuite/internal/data/room/HttpTransactionDao.kt

@@ -0,0 +1,53 @@
+package com.securitysuite.internal.data.room
+
+import androidx.lifecycle.LiveData
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Update
+import com.securitysuite.internal.data.entity.HttpTransaction
+import com.securitysuite.internal.data.entity.HttpTransactionTuple
+
+@Dao
+internal interface HttpTransactionDao {
+    @Query(
+        "SELECT id, requestDate, tookMs, protocol, method, host, path, scheme, responseCode, " +
+            "requestPayloadSize, responsePayloadSize, error, graphQLDetected, graphQlOperationName FROM " +
+            "transactions ORDER BY requestDate DESC",
+    )
+    fun getSortedTuples(): LiveData<List<HttpTransactionTuple>>
+
+    @Query(
+        "SELECT id, requestDate, tookMs, protocol, method, host, path, scheme, responseCode, " +
+            "requestPayloadSize, responsePayloadSize, error, graphQLDetected, graphQlOperationName FROM " +
+            "transactions WHERE responseCode LIKE :codeQuery AND (path LIKE :pathQuery OR " +
+            "graphQlOperationName LIKE :graphQlQuery) ORDER BY requestDate DESC",
+    )
+    fun getFilteredTuples(
+        codeQuery: String,
+        pathQuery: String,
+        graphQlQuery: String = "",
+    ): LiveData<List<HttpTransactionTuple>>
+
+    @Insert
+    suspend fun insert(transaction: HttpTransaction): Long?
+
+    @Update(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun update(transaction: HttpTransaction): Int
+
+    @Query("DELETE FROM transactions")
+    suspend fun deleteAll(): Int
+
+    @Query("SELECT * FROM transactions WHERE id = :id")
+    fun getById(id: Long): LiveData<HttpTransaction?>
+
+    @Query("DELETE FROM transactions WHERE requestDate <= :threshold")
+    suspend fun deleteBefore(threshold: Long): Int
+
+    @Query("SELECT * FROM transactions")
+    suspend fun getAll(): List<HttpTransaction>
+
+    @Query("SELECT * FROM transactions WHERE requestDate >= :timestamp")
+    fun getTransactionsInTimeRange(timestamp: Long): List<HttpTransaction>
+}

package/android/src/main/java/com/securitysuite/internal/support/BitmapUtils.kt

@@ -0,0 +1,45 @@
+package com.securitysuite.internal.support
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Matrix
+import android.graphics.Paint
+import androidx.annotation.ColorInt
+import androidx.core.graphics.ColorUtils
+import androidx.palette.graphics.Palette
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+private val BITMAP_PAINT = Paint(Paint.FILTER_BITMAP_FLAG)
+
+internal suspend fun Bitmap.calculateLuminance(): Double? {
+    val color = Color.MAGENTA
+    return withContext(Dispatchers.Default) {
+        val alpha = replaceAlphaWithColor(color)
+        return@withContext alpha.getLuminance(color)
+    }
+}
+
+private fun Bitmap.replaceAlphaWithColor(
+    @ColorInt color: Int,
+): Bitmap {
+    val result = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+    result.eraseColor(color)
+    Canvas(result).apply {
+        drawBitmap(this@replaceAlphaWithColor, Matrix(), BITMAP_PAINT)
+    }
+    return result
+}
+
+private fun Bitmap.getLuminance(
+    @ColorInt alphaSubstitute: Int,
+): Double? {
+    val imagePalette =
+        Palette.from(this)
+            .clearFilters()
+            .addFilter { rgb, _ -> (rgb != alphaSubstitute) }
+            .generate()
+    val dominantSwatch = imagePalette.dominantSwatch
+    return dominantSwatch?.rgb?.let(ColorUtils::calculateLuminance)
+}

package/android/src/main/java/com/securitysuite/internal/support/CacheDirectoryProvider.kt

@@ -0,0 +1,11 @@
+package com.securitysuite.internal.support
+
+import java.io.File
+
+/**
+ * An interface that returns a reference to a cache directory where temporary files can be
+ * saved.
+ */
+internal fun interface CacheDirectoryProvider {
+    fun provide(): File?
+}

package/android/src/main/java/com/securitysuite/internal/support/ChessboardDrawable.kt

@@ -0,0 +1,76 @@
+package com.securitysuite.internal.support
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Bitmap.Config.ARGB_8888
+import android.graphics.BitmapShader
+import android.graphics.Canvas
+import android.graphics.ColorFilter
+import android.graphics.Paint
+import android.graphics.Paint.Style.FILL
+import android.graphics.PixelFormat
+import android.graphics.Rect
+import android.graphics.Shader.TileMode.REPEAT
+import android.graphics.drawable.Drawable
+import androidx.annotation.ColorInt
+import androidx.annotation.ColorRes
+import androidx.annotation.DimenRes
+import androidx.annotation.Px
+import androidx.core.content.ContextCompat
+
+internal class ChessboardDrawable(
+    @ColorInt evenColor: Int,
+    @ColorInt oddColor: Int,
+    @Px squareSize: Int,
+) : Drawable() {
+    private val chessboardPaint =
+        Paint().apply {
+            val patternBitmap = Bitmap.createBitmap(squareSize * 2, squareSize * 2, ARGB_8888)
+            patternBitmap.eraseColor(evenColor)
+
+            color = oddColor
+            style = FILL
+            val patternCanvas = Canvas(patternBitmap)
+            val squareRect = Rect(squareSize, 0, 2 * squareSize, squareSize)
+            patternCanvas.drawRect(squareRect, this)
+            squareRect.offsetTo(0, squareSize)
+            patternCanvas.drawRect(squareRect, this)
+
+            reset()
+            shader = BitmapShader(patternBitmap, REPEAT, REPEAT)
+        }
+
+    override fun draw(canvas: Canvas) {
+        canvas.drawPaint(chessboardPaint)
+    }
+
+    override fun setAlpha(alpha: Int) {
+        chessboardPaint.alpha = alpha
+    }
+
+    override fun getOpacity(): Int {
+        return if (chessboardPaint.colorFilter == null) {
+            PixelFormat.OPAQUE
+        } else {
+            PixelFormat.TRANSLUCENT
+        }
+    }
+
+    override fun setColorFilter(colorFilter: ColorFilter?) {
+        chessboardPaint.colorFilter = colorFilter
+    }
+
+    companion object {
+        fun createPattern(
+            context: Context,
+            @ColorRes evenColorId: Int,
+            @ColorRes oddColorId: Int,
+            @DimenRes sizeId: Int,
+        ): ChessboardDrawable {
+            val evenColor = ContextCompat.getColor(context, evenColorId)
+            val oddColor = ContextCompat.getColor(context, oddColorId)
+            val size = context.resources.getDimensionPixelSize(sizeId)
+            return ChessboardDrawable(evenColor, oddColor, size)
+        }
+    }
+}

package/android/src/main/java/com/securitysuite/internal/support/ChuckerFileProvider.kt

@@ -0,0 +1,9 @@
+package com.securitysuite.internal.support
+
+import androidx.core.content.FileProvider
+
+/**
+ * We need our own subclass so we don't conflict with other [FileProvider]s
+ * See: https://github.com/ChuckerTeam/chucker/issues/409
+ */
+internal class ChuckerFileProvider : FileProvider()

package/android/src/main/java/com/securitysuite/internal/support/ClearDatabaseJobIntentServiceReceiver.kt

@@ -0,0 +1,14 @@
+package com.securitysuite.internal.support
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+internal class ClearDatabaseJobIntentServiceReceiver : BroadcastReceiver() {
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
+        ClearDatabaseService.enqueueWork(context, intent)
+    }
+}

package/android/src/main/java/com/securitysuite/internal/support/ClearDatabaseService.kt

@@ -0,0 +1,32 @@
+package com.securitysuite.internal.support
+
+import android.content.Context
+import android.content.Intent
+import androidx.core.app.JobIntentService
+import com.securitysuite.internal.data.repository.RepositoryProvider
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.launch
+
+internal class ClearDatabaseService : JobIntentService() {
+    private val scope = MainScope()
+
+    override fun onHandleWork(intent: Intent) {
+        RepositoryProvider.initialize(applicationContext)
+        scope.launch {
+            RepositoryProvider.transaction().deleteAllTransactions()
+            NotificationHelper.clearBuffer()
+            NotificationHelper(applicationContext).dismissNotifications()
+        }
+    }
+
+    companion object {
+        private const val CLEAN_DATABASE_JOB_ID = 123321
+
+        fun enqueueWork(
+            context: Context,
+            work: Intent,
+        ) {
+            enqueueWork(context, ClearDatabaseService::class.java, CLEAN_DATABASE_JOB_ID, work)
+        }
+    }
+}

package/android/src/main/java/com/securitysuite/internal/support/ContextExt.kt

@@ -0,0 +1,22 @@
+package com.securitysuite.internal.support
+
+import android.content.Context
+import com.securitysuite.internal.data.model.DialogData
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+
+internal fun Context.showDialog(
+    dialogData: DialogData,
+    onPositiveClick: (() -> Unit)?,
+    onNegativeClick: (() -> Unit)?,
+) {
+    MaterialAlertDialogBuilder(this)
+        .setTitle(dialogData.title)
+        .setMessage(dialogData.message)
+        .setPositiveButton(dialogData.positiveButtonText) { _, _ ->
+            onPositiveClick?.invoke()
+        }
+        .setNegativeButton(dialogData.negativeButtonText) { _, _ ->
+            onNegativeClick?.invoke()
+        }
+        .show()
+}

package/android/src/main/java/com/securitysuite/internal/support/DepletingSource.kt

@@ -0,0 +1,37 @@
+package com.securitysuite.internal.support
+
+import okio.Buffer
+import okio.ForwardingSource
+import okio.Source
+import okio.blackholeSink
+import okio.buffer
+import java.io.IOException
+
+internal class DepletingSource(delegate: Source) : ForwardingSource(delegate) {
+    private var shouldDeplete = true
+
+    override fun read(
+        sink: Buffer,
+        byteCount: Long,
+    ) = try {
+        val bytesRead = super.read(sink, byteCount)
+        if (bytesRead == -1L) shouldDeplete = false
+        bytesRead
+    } catch (e: IOException) {
+        shouldDeplete = false
+        throw e
+    }
+
+    override fun close() {
+        if (shouldDeplete) {
+            try {
+                delegate.buffer().readAll(blackholeSink())
+            } catch (e: IOException) {
+                Logger.error("An error occurred while depleting the source", e)
+            }
+        }
+        shouldDeplete = false
+
+        super.close()
+    }
+}

package/android/src/main/java/com/securitysuite/internal/support/FileFactory.kt

@@ -0,0 +1,30 @@
+package com.securitysuite.internal.support
+
+import java.io.File
+import java.io.IOException
+import java.util.concurrent.atomic.AtomicLong
+
+internal object FileFactory {
+    private val uniqueIdGenerator = AtomicLong()
+
+    fun create(directory: File) = create(directory, fileName = "chucker-${uniqueIdGenerator.getAndIncrement()}")
+
+    fun create(
+        directory: File,
+        fileName: String,
+    ): File? =
+        try {
+            File(directory, fileName).apply {
+                if (exists() && !delete()) {
+                    throw IOException("Failed to delete file $this")
+                }
+                parentFile?.mkdirs()
+                if (!createNewFile()) {
+                    throw IOException("File $this already exists")
+                }
+            }
+        } catch (e: IOException) {
+            Logger.error("An error occurred while creating a file", e)
+            null
+        }
+}

package/android/src/main/java/com/securitysuite/internal/support/FileSaver.kt

@@ -0,0 +1,41 @@
+package com.securitysuite.internal.support
+
+import android.content.ContentResolver
+import android.net.Uri
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okio.Source
+import okio.buffer
+import okio.sink
+
+/**
+ * Utility class to save a file from a [Source] to a [Uri].
+ */
+public object FileSaver {
+    /**
+     * Saves the data from the [source] to the file at the [uri] using the [contentResolver].
+     *
+     * @param source The source of the data to save.
+     * @param uri The URI of the file to save the data to.
+     * @param contentResolver The content resolver to use to save the data.
+     * @return `true` if the data was saved successfully, `false` otherwise.
+     */
+    public suspend fun saveFile(
+        source: Source,
+        uri: Uri,
+        contentResolver: ContentResolver,
+    ): Boolean =
+        withContext(Dispatchers.IO) {
+            runCatching {
+                contentResolver.openOutputStream(uri)?.use { outputStream ->
+                    outputStream.sink().buffer().use { sink ->
+                        sink.writeAll(source)
+                    }
+                }
+            }.onFailure {
+                Logger.error("Failed to save data to a file", it)
+                return@withContext false
+            }
+            return@withContext true
+        }
+}