feat(feature:ui): implement iOS file sharing and improve Android logic (#1884)

Co-authored-by: Sk Niyaj Ali <[email protected]>

Author: HekmatullahAmin

core/ui/build.gradle.kts

@@ -40,8 +40,8 @@ kotlin {
             implementation(compose.components.resources)
             implementation(compose.components.uiToolingPreview)
             implementation(libs.jb.composeNavigation)
-            implementation(libs.filekit.compose)
             implementation(libs.filekit.core)
+            implementation(libs.filekit.dialogs.compose)
         }
         androidInstrumentedTest.dependencies {
             implementation(libs.bundles.androidx.compose.ui.test)

core/ui/src/androidMain/kotlin/org/mifospay/core/ui/utils/ShareUtils.android.kt

@@ -12,22 +12,28 @@ package org.mifospay.core.ui.utils
 import android.app.Activity
 import android.content.Context
 import android.content.Intent
-import android.graphics.Bitmap
-import android.net.Uri
-import android.util.Log
-import androidx.compose.ui.graphics.ImageBitmap
-import androidx.compose.ui.graphics.asAndroidBitmap
 import androidx.core.content.FileProvider
+import co.touchlab.kermit.Logger
+import io.github.vinceglb.filekit.FileKit
+import io.github.vinceglb.filekit.ImageFormat
+import io.github.vinceglb.filekit.compressImage
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.jetbrains.compose.resources.ExperimentalResourceApi
-import org.jetbrains.compose.resources.decodeToImageBitmap
 import java.io.File
-import java.io.FileOutputStream
-import java.io.IOException
 
+/**
+ * Actual implementation of [ShareUtils] for Android platform.
+ *
+ * This utility enables sharing of text and files (PDF, image, text) through Android's
+ * native `Intent`-based sharing system.
+ */
 actual object ShareUtils {
 
+    /**
+     * Provider function to retrieve the current [Activity].
+     * This must be set before using [shareText] or [shareFile].
+     */
     private var activityProvider: () -> Activity = {
         throw IllegalArgumentException(
             "You need to implement the 'activityProvider' to provide the required Activity. " +
@@ -36,11 +42,23 @@ actual object ShareUtils {
         )
     }
 
+    /**
+     * Sets the activity provider function to be used internally for context retrieval.
+     *
+     * This is required to initialize before calling any sharing methods.
+     *
+     * @param provider A lambda that returns the current [Activity].
+     */
     fun setActivityProvider(provider: () -> Activity) {
         activityProvider = provider
     }
 
-    actual fun shareText(text: String) {
+    /**
+     * Shares plain text content using an Android share sheet (`Intent.ACTION_SEND`).
+     *
+     * @param text The text content to share.
+     */
+    actual suspend fun shareText(text: String) {
         val intent = Intent(Intent.ACTION_SEND).apply {
             type = "text/plain"
             putExtra(Intent.EXTRA_TEXT, text)
@@ -49,57 +67,93 @@ actual object ShareUtils {
         activityProvider.invoke().startActivity(intentChooser)
     }
 
-    actual suspend fun shareImage(title: String, image: ImageBitmap) {
-        val context = activityProvider.invoke().application.baseContext
-
-        val uri = saveImage(image.asAndroidBitmap(), context)
-
-        val sendIntent: Intent = Intent().apply {
-            action = Intent.ACTION_SEND
-            putExtra(Intent.EXTRA_STREAM, uri)
-            setDataAndType(uri, "image/png")
-            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-        }
-
-        val shareIntent = Intent.createChooser(sendIntent, title)
-        activityProvider.invoke().startActivity(shareIntent)
-    }
-
+    /**
+     * Shares a file (e.g. PDF, text, image) using Android's file sharing mechanism.
+     *
+     * If the file is an image, it is compressed before sharing.
+     * The file is temporarily saved to internal cache and shared using a `FileProvider`.
+     *
+     * @param file A [ShareFileModel] containing file metadata and binary content.
+     */
     @OptIn(ExperimentalResourceApi::class)
-    actual suspend fun shareImage(title: String, byte: ByteArray) {
+    actual suspend fun shareFile(file: ShareFileModel) {
         val context = activityProvider.invoke().application.baseContext
-        val imageBitmap = byte.decodeToImageBitmap()
 
-        val uri = saveImage(imageBitmap.asAndroidBitmap(), context)
-
-        val sendIntent: Intent = Intent().apply {
-            action = Intent.ACTION_SEND
-            putExtra(Intent.EXTRA_STREAM, uri)
-            setDataAndType(uri, "image/png")
-            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+        try {
+            withContext(Dispatchers.IO) {
+                val compressedBytes = if (file.mime == MimeType.IMAGE) {
+                    compressImage(file.bytes)
+                } else {
+                    file.bytes
+                }
+
+                val savedFile = saveFile(file.fileName, compressedBytes, context = context)
+                val uri = FileProvider.getUriForFile(
+                    context,
+                    "${context.packageName}.provider",
+                    savedFile,
+                )
+
+                withContext(Dispatchers.Main) {
+                    val intent = Intent(Intent.ACTION_SEND).apply {
+                        putExtra(Intent.EXTRA_STREAM, uri)
+                        flags += Intent.FLAG_ACTIVITY_NEW_TASK
+                        flags += Intent.FLAG_GRANT_READ_URI_PERMISSION
+                        setDataAndType(uri, file.mime.toAndroidMimeType())
+                    }
+                    val chooser = Intent.createChooser(intent, null)
+                    activityProvider.invoke().startActivity(chooser)
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            Logger.e(e) { "Failed to share file: ${e.message}" }
         }
-
-        val shareIntent = Intent.createChooser(sendIntent, title)
-        activityProvider.invoke().startActivity(shareIntent)
     }
 
-    private suspend fun saveImage(image: Bitmap, context: Context): Uri? {
-        return withContext(Dispatchers.IO) {
-            try {
-                val imagesFolder = File(context.cacheDir, "images")
-                imagesFolder.mkdirs()
-                val file = File(imagesFolder, "shared_image.png")
+    /**
+     * Saves the provided byte array as a temporary file in the internal cache directory.
+     *
+     * @param name The name of the file to be saved.
+     * @param data Byte array representing the file content.
+     * @param context Android [Context] used to access the cache directory.
+     * @return The saved [File] object.
+     */
+    private fun saveFile(name: String, data: ByteArray, context: Context): File {
+        val cache = context.cacheDir
+        val savedFile = File(cache, name)
+        savedFile.writeBytes(data)
+        return savedFile
+    }
 
-                val stream = FileOutputStream(file)
-                image.compress(Bitmap.CompressFormat.PNG, 100, stream)
-                stream.flush()
-                stream.close()
+    /**
+     * Maps [MimeType] to a corresponding Android MIME type string.
+     *
+     * @return Android-compatible MIME type string.
+     */
+    private fun MimeType.toAndroidMimeType(): String = when (this) {
+        MimeType.PDF -> "application/pdf"
+        MimeType.TEXT -> "text/plain"
+        MimeType.IMAGE -> "image/*"
+    }
 
-                FileProvider.getUriForFile(context, "${context.packageName}.provider", file)
-            } catch (e: IOException) {
-                Log.d("saving bitmap", "saving bitmap error ${e.message}")
-                null
-            }
-        }
+    /**
+     * Compresses an image file using [FileKit] logic.
+     *
+     * @param imageBytes The original image byte array.
+     * @return A compressed image as a byte array.
+     */
+    private suspend fun compressImage(imageBytes: ByteArray): ByteArray {
+        return FileKit.compressImage(
+            bytes = imageBytes,
+            // Compression quality (0–100)
+            quality = 100,
+            // Max width in pixels
+            maxWidth = 1024,
+            // Max height in pixels
+            maxHeight = 1024,
+            // Image format (e.g., PNG or JPEG)
+            imageFormat = ImageFormat.PNG,
+        )
     }
 }

core/ui/src/commonMain/kotlin/org/mifospay/core/ui/utils/ShareUtils.kt

@@ -9,13 +9,70 @@
  */
 package org.mifospay.core.ui.utils
 
-import androidx.compose.ui.graphics.ImageBitmap
-
+/**
+ * Platform-specific utilities for sharing content such as text and files.
+ *
+ * This expect declaration should be implemented for each platform (e.g., Android, iOS) to handle
+ * the specifics of sharing functionality.
+ */
 expect object ShareUtils {
 
-    fun shareText(text: String)
+    /**
+     * Shares plain text content using the platform's native sharing mechanism.
+     *
+     * @param text The text content to be shared.
+     */
+    suspend fun shareText(text: String)
+
+    /**
+     * Shares a file using the platform's native sharing mechanism.
+     *
+     * This is a suspend function, allowing for asynchronous operations such as file preparation
+     * or permission handling if needed.
+     *
+     * @param file A [ShareFileModel] containing the file's metadata and content.
+     */
+    suspend fun shareFile(file: ShareFileModel)
+}
+
+/**
+ * Represents supported MIME types for file sharing.
+ */
+enum class MimeType {
+    PDF,
+    TEXT,
+    IMAGE,
+}
+
+/**
+ * Model representing a file to be shared.
+ *
+ * @property mime The MIME type of the file. Defaults to [MimeType.PDF].
+ * @property fileName The name of the file, including its extension.
+ * @property bytes The binary content of the file.
+ */
+data class ShareFileModel(
+    val mime: MimeType = MimeType.PDF,
+    val fileName: String,
+    val bytes: ByteArray,
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as ShareFileModel
+
+        if (mime != other.mime) return false
+        if (fileName != other.fileName) return false
+        if (!bytes.contentEquals(other.bytes)) return false
 
-    suspend fun shareImage(title: String, image: ImageBitmap)
+        return true
+    }
 
-    suspend fun shareImage(title: String, byte: ByteArray)
+    override fun hashCode(): Int {
+        var result = mime.hashCode()
+        result = 31 * result + fileName.hashCode()
+        result = 31 * result + bytes.contentHashCode()
+        return result
+    }
 }

core/ui/src/desktopMain/kotlin/org/mifospay/core/ui/utils/ShareUtils.desktop.kt

@@ -9,27 +9,46 @@
  */
 package org.mifospay.core.ui.utils
 
-import androidx.compose.ui.graphics.ImageBitmap
-import androidx.compose.ui.graphics.asSkiaBitmap
-import io.github.vinceglb.filekit.core.FileKit
+import io.github.vinceglb.filekit.FileKit
+import io.github.vinceglb.filekit.dialogs.openFileSaver
+import io.github.vinceglb.filekit.write
 
+/**
+ * JVM-specific implementation of [ShareUtils] for desktop platforms.
+ *
+ * This object simulates file sharing by prompting the user with a "Save As" dialog
+ * using [FileKit.openFileSaver]. It allows the user to save the content locally,
+ * which is the most suitable alternative to "sharing" in desktop environments.
+ */
 actual object ShareUtils {
-    actual fun shareText(text: String) {
-    }
 
-    actual suspend fun shareImage(title: String, image: ImageBitmap) {
-        FileKit.saveFile(
-            bytes = image.asSkiaBitmap().readPixels(),
-            baseName = "MifosQrCode",
-            extension = "png",
+    /**
+     * Prompts the user to save the given text content as a file on their system.
+     *
+     * This method uses [FileKit.openFileSaver] to open a native "Save As" dialog,
+     * and writes the provided text to the selected file location.
+     *
+     * @param text The plain text content the user will save to disk.
+     */
+    actual suspend fun shareText(text: String) {
+        val newFile = FileKit.openFileSaver(
+            suggestedName = "text.txt",
         )
+        newFile?.write(text.encodeToByteArray())
     }
 
-    actual suspend fun shareImage(title: String, byte: ByteArray) {
-        FileKit.saveFile(
-            bytes = byte,
-            baseName = "MifosQrCode",
-            extension = "png",
+    /**
+     * Prompts the user to save a binary file (e.g., image, PDF) to their local system.
+     *
+     * This is used as a desktop-friendly alternative to file sharing, using
+     * [FileKit.openFileSaver] to let the user choose the destination file path.
+     *
+     * @param file The file to be "shared", including its filename and byte content.
+     */
+    actual suspend fun shareFile(file: ShareFileModel) {
+        val newFile = FileKit.openFileSaver(
+            suggestedName = file.fileName,
         )
+        newFile?.write(file.bytes)
     }
 }