expo-clipboard 2.1.1 → 3.0.0

package/CHANGELOG.md

@@ -10,7 +10,30 @@
 
 ### 💡 Others
 
-## 2.1.1 — 2022-02-01
+## 3.0.0 — 2022-04-18
+
+### 🛠 Breaking changes
+
+- The `content` property of the clipboard event listener is now deprecated and always returns empty string and logs a warning message to the console. Use `getStringAsync()` instead.
+
+### 🎉 New features
+
+- Native module on Android is now written in Kotlin using the new API. ([#16269](https://github.com/expo/expo/pull/16269) by [@barthap](https://github.com/barthap))
+- Added support for setting and getting images (`setImageAsync`, `hasImageAsync`, `getImageAsync`). ([#16391](https://github.com/expo/expo/pull/16391), [#16413](https://github.com/expo/expo/pull/16413), [#16481](https://github.com/expo/expo/pull/16481) by [@barthap](https://github.com/barthap))
+- On iOS added support for setting and getting URLs (`setUrlAsync`, `hasUrlAsync`, `getUrlAsync`). ([#16391](https://github.com/expo/expo/pull/16391) by [@graszka22](https://github.com/graszka22), [@barthap](https://github.com/barthap))
+- Added new method `hasStringAsync` that checks whether clipboard has text content. ([#16524](https://github.com/expo/expo/pull/16524) by [@barthap](https://github.com/barthap))
+- Added support for HTML content in `getStringAsync` and `setStringAsync`. ([#16551](https://github.com/expo/expo/pull/16551), [#16687](https://github.com/expo/expo/pull/16687) by [@barthap](https://github.com/barthap))
+- Added new property `contentTypes` to the clipboard event listener describing contents of the clipboard. ([#16787](https://github.com/expo/expo/pull/16787) by [@barthap](https://github.com/barthap))
+
+### ⚠ Notices
+
+- Deprecated `setString`. Use `setStringAsync` instead. ([#16320](https://github.com/expo/expo/pull/16320) by [@barthap](https://github.com/barthap))
+
+### ⚠️ Notices
+
+- On Android bump `compileSdkVersion` to `31`, `targetSdkVersion` to `31` and `Java` version to `11`. ([#16941](https://github.com/expo/expo/pull/16941) by [@bbarthec](https://github.com/bbarthec))
+
+## 2.1.1 - 2022-02-01
 
 ### 🐛 Bug fixes
 

package/README.md

@@ -4,7 +4,7 @@
 
 ## API documentation
 
-Please refer to the [API documentation for the latest stable release](https://docs.expo.io/versions/latest/sdk/clipboard/).
+Please refer to the [API documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/clipboard/).
 
 ## Installation in managed Expo projects
 

package/android/build.gradle

@@ -3,20 +3,35 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven-publish'
 
 group = 'host.exp.exponent'
-version = '2.1.1'
+version = '3.0.0'
 
 buildscript {
+  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+  if (expoModulesCorePlugin.exists()) {
+    apply from: expoModulesCorePlugin
+    applyKotlinExpoModulesCorePlugin()
+  }
+
   // Simple helper that allows the root project to override versions declared by this library.
   ext.safeExtGet = { prop, fallback ->
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
   }
 
+  // Ensures backward compatibility
+  ext.getKotlinVersion = {
+    if (ext.has("kotlinVersion")) {
+      ext.kotlinVersion()
+    } else {
+      ext.safeExtGet("kotlinVersion", "1.6.10")
+    }
+  }
+
   repositories {
     mavenCentral()
   }
 
   dependencies {
-    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', '1.4.21')}")
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
   }
 }
 
@@ -44,18 +59,22 @@ afterEvaluate {
 }
 
 android {
-  compileSdkVersion rootProject.ext.compileSdkVersion
+  compileSdkVersion safeExtGet("compileSdkVersion", 31)
 
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
+    sourceCompatibility JavaVersion.VERSION_11
+    targetCompatibility JavaVersion.VERSION_11
+  }
+
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_11.majorVersion
   }
 
   defaultConfig {
-    minSdkVersion rootProject.ext.minSdkVersion
-    targetSdkVersion rootProject.ext.targetSdkVersion
+    minSdkVersion safeExtGet("minSdkVersion", 21)
+    targetSdkVersion safeExtGet("targetSdkVersion", 31)
     versionCode 3
-    versionName '2.1.1'
+    versionName '3.0.0'
   }
   lintOptions {
     abortOnError false
@@ -68,10 +87,12 @@ repositories {
 
 dependencies {
   implementation project(':expo-modules-core')
-  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${safeExtGet('kotlinVersion', '1.4.21')}"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  implementation "androidx.core:core-ktx:1.6.0"
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.1")
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.2")
 
-  if (project.findProject(':unimodules-test-core')) {
-    testImplementation project(':unimodules-test-core')
+  if (project.findProject(':expo-modules-test-core')) {
+    testImplementation project(':expo-modules-test-core')
   }
-  testImplementation "org.robolectric:robolectric:4.3.1"
 }

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,13 @@
-<manifest package="expo.modules.clipboard">
+<manifest package="expo.modules.clipboard"
+  xmlns:android="http://schemas.android.com/apk/res/android">
+  <application>
+    <provider
+      android:name=".ClipboardFileProvider"
+      android:authorities="${applicationId}.ClipboardFileProvider"
+      android:exported="true">
+      <meta-data
+        android:name="expo.modules.clipboard.CLIPBOARD_FILE_PROVIDER_PATHS"
+        android:resource="@xml/clipboard_provider_paths"/>
+    </provider>
+  </application>
 </manifest>

package/android/src/main/java/expo/modules/clipboard/ClipboardExceptions.kt

@@ -0,0 +1,23 @@
+package expo.modules.clipboard
+
+import expo.modules.kotlin.exception.CodedException
+
+internal class ClipboardUnavailableException :
+  CodedException("'CLIPBOARD_SERVICE' is unavailable on this device", null)
+
+internal class NoPermissionException(cause: SecurityException?) :
+  CodedException("App has no permission to read this clipboard item", cause)
+
+internal class PasteFailureException(cause: Throwable?, kind: String = "item") :
+  CodedException("Failed to get $kind from clipboard", cause)
+
+internal class CopyFailureException(cause: Throwable?, kind: String = "item") :
+  CodedException("Failed to save $kind into clipboard", cause)
+
+internal class InvalidImageException(image: String, cause: Throwable?) :
+  CodedException(
+    "Invalid base64 image: ${
+    image.run { substring(0, minOf(length, 32)) + if (length > 32) "..." else ""}
+    }",
+    cause
+  )

package/android/src/main/java/expo/modules/clipboard/ClipboardFileProvider.kt

@@ -0,0 +1,360 @@
+package expo.modules.clipboard
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.content.Context
+import android.content.pm.PackageManager
+import android.content.pm.ProviderInfo
+import android.database.Cursor
+import android.database.MatrixCursor
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.os.ParcelFileDescriptor
+import android.provider.OpenableColumns
+import android.text.TextUtils
+import android.webkit.MimeTypeMap
+import androidx.annotation.RequiresApi
+import androidx.core.content.FileProvider
+import org.xmlpull.v1.XmlPullParser.END_DOCUMENT
+import org.xmlpull.v1.XmlPullParser.START_TAG
+import org.xmlpull.v1.XmlPullParserException
+import java.io.File
+import java.io.FileNotFoundException
+import java.io.IOException
+
+/**
+ * This is a modified version of [FileProvider]
+ * that facilitates exposing files associated with an app by creating
+ * a `content://` uri without using Androids URI permission mechanism.
+ * In contrast to [FileProvider], this provider _must_ be exported.
+ *
+ * The difference is that [FileProvider] forbids provider to be _exported_
+ * which means it cannot easily grant access to any app installed
+ * on the device. This becomes even more problematic with API 31, when
+ * [PackageManager.getInstalledApplications] doesn't return all
+ * installed apps, so we cannot iterate and use [Context.grantUriPermission]
+ * easily
+ *
+ * For usage details, see [FileProvider] documentation
+ */
+@RequiresApi(Build.VERSION_CODES.KITKAT)
+class ClipboardFileProvider : ContentProvider() {
+  private val defaultProjectionColumns = arrayOf(OpenableColumns.DISPLAY_NAME, OpenableColumns.SIZE)
+
+  private lateinit var strategy: PathStrategy
+
+  override fun onCreate() = true
+
+  /**
+   * After the [ClipboardFileProvider] is instantiated, this method is called to provide the system with
+   * information about the provider.
+   *
+   * @param context A [Context] for the current component.
+   * @param info A [ProviderInfo] for the new provider.
+   */
+  override fun attachInfo(context: Context, info: ProviderInfo) {
+    super.attachInfo(context, info)
+
+    if (!info.exported) {
+      throw AssertionError("ClipboardFileProvider must be exported")
+    }
+
+    strategy = getPathStrategy(context, info.authority)
+  }
+
+  /**
+   * Returns the MIME type of a content URI returned by
+   * [getUriForFile()][getUriForFile].
+   *
+   * @param uri A content URI returned by
+   * [getUriForFile()][getUriForFile].
+   * @return If the associated file has an extension, the MIME type associated with that
+   * extension; otherwise `application/octet-stream`.
+   */
+  override fun getType(uri: Uri): String {
+    val file: File = strategy.getFileForUri(uri)
+    val lastDot = file.name.lastIndexOf('.')
+    if (lastDot >= 0) {
+      val extension = file.name.substring(lastDot + 1)
+      MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension)?.let {
+        return it
+      }
+    }
+    return "application/octet-stream"
+  }
+
+  override fun query(uri: Uri, projection: Array<out String>?, selection: String?, selectionArgs: Array<out String>?, sortOrder: String?): Cursor? {
+    val projection = projection ?: defaultProjectionColumns
+    val file: File = strategy.getFileForUri(uri)
+    var columns = arrayOfNulls<String>(projection.size)
+    var values = arrayOfNulls<Any>(projection.size)
+    var i = 0
+    for (column in projection) {
+      when (column) {
+        OpenableColumns.DISPLAY_NAME -> {
+          columns[i] = OpenableColumns.DISPLAY_NAME
+          values[i++] = file.name
+        }
+        OpenableColumns.SIZE -> {
+          columns[i] = OpenableColumns.SIZE
+          values[i++] = file.length()
+        }
+      }
+    }
+    columns = columns.copyOf(i)
+    values = values.copyOf(i)
+    return MatrixCursor(columns, 1).apply {
+      addRow(values)
+    }
+  }
+
+  override fun insert(uri: Uri, values: ContentValues?): Uri =
+    throw UnsupportedOperationException("This is a read-only provider")
+
+  override fun update(uri: Uri, values: ContentValues?, selection: String?, selectionArgs: Array<out String>?): Int =
+    throw UnsupportedOperationException("This is a read-only provider")
+
+  override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int =
+    throw UnsupportedOperationException("This is a read-only provider")
+
+  @Throws(FileNotFoundException::class)
+  override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor? {
+    require("r" == mode) { "mode must be \"r\"" }
+    val file = strategy.getFileForUri(uri)
+    return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
+  }
+
+  companion object {
+    private const val META_DATA_FILE_PROVIDER_PATHS =
+      "expo.modules.clipboard.CLIPBOARD_FILE_PROVIDER_PATHS"
+
+    private const val TAG_ROOT_PATH = "root-path"
+    private const val TAG_FILES_PATH = "files-path"
+    private const val TAG_CACHE_PATH = "cache-path"
+    private const val TAG_EXTERNAL = "external-path"
+    private const val TAG_EXTERNAL_FILES = "external-files-path"
+    private const val TAG_EXTERNAL_CACHE = "external-cache-path"
+
+    private const val ATTR_NAME = "name"
+    private const val ATTR_PATH = "path"
+
+    private val DEVICE_ROOT = File("/")
+
+    private val cache: HashMap<String, PathStrategy> = HashMap()
+
+    /**
+     * Return a content URI for a given [File]. A PublicFileProvider can only return a
+     * `content` [Uri] for file paths defined in their `<paths>`
+     * meta-data element. See the Class Overview for more information.
+     *
+     * @param context A [Context] for the current component.
+     * @param authority The authority of a [ClipboardFileProvider] defined in a
+     * `<provider>` element in your app's manifest.
+     * @param file A [File] pointing to the filename for which you want a
+     * `content` [Uri].
+     * @return A content URI for the file.
+     * @throws IllegalArgumentException When the given [File] is outside
+     * the paths supported by the provider.
+     */
+    fun getUriForFile(context: Context, authority: String, file: File): Uri? {
+      val strategy = getPathStrategy(context, authority)
+      return strategy.getUriForFile(file)
+    }
+
+    /**
+     * Return {@link PathStrategy} for given authority, either by parsing or
+     * returning from cache.
+     */
+    internal fun getPathStrategy(context: Context, authority: String): PathStrategy {
+      var pathStrategy: PathStrategy
+      synchronized(cache) {
+        pathStrategy = cache[authority] ?: run {
+          try {
+            pathStrategy = parsePathStrategy(context, authority)
+          } catch (e: IOException) {
+            throw IllegalArgumentException(
+              "Failed to parse $META_DATA_FILE_PROVIDER_PATHS meta-data", e
+            )
+          } catch (e: XmlPullParserException) {
+            throw IllegalArgumentException(
+              "Failed to parse $META_DATA_FILE_PROVIDER_PATHS meta-data", e
+            )
+          }
+          cache[authority] = pathStrategy
+          pathStrategy
+        }
+      }
+      return pathStrategy
+    }
+
+    /**
+     * Parse and return [PathStrategy] for given authority as defined in
+     * [META_DATA_FILE_PROVIDER_PATHS] `<meta-data>`.
+     *
+     * @see .getPathStrategy
+     */
+    @Throws(IOException::class, XmlPullParserException::class)
+    private fun parsePathStrategy(context: Context, authority: String): PathStrategy {
+      val pathStrategy = SimplePathStrategy(authority)
+      val packageManager = context.packageManager
+      val info = packageManager.resolveContentProvider(authority, PackageManager.GET_META_DATA)
+        ?: throw IllegalArgumentException("Couldn't find meta-data for provider with authority $authority")
+      val parser = info.loadXmlMetaData(packageManager, META_DATA_FILE_PROVIDER_PATHS)
+        ?: throw IllegalArgumentException("Missing $META_DATA_FILE_PROVIDER_PATHS meta-data")
+      var type: Int
+      while (parser.next().also { type = it } != END_DOCUMENT) {
+        if (type != START_TAG) continue
+
+        val tag = parser.name
+        val target: File? = targetFileFromTag(tag, context)
+        target?.let {
+          val name = parser.getAttributeValue(null, ATTR_NAME)
+          val path = parser.getAttributeValue(null, ATTR_PATH)
+          pathStrategy.addRoot(name, buildPath(it, path))
+        }
+      }
+      return pathStrategy
+    }
+
+    private fun targetFileFromTag(tag: String, context: Context): File? = when (tag) {
+      TAG_ROOT_PATH -> DEVICE_ROOT
+      TAG_FILES_PATH -> context.filesDir
+      TAG_CACHE_PATH -> context.cacheDir
+      TAG_EXTERNAL -> Environment.getExternalStorageDirectory()
+      TAG_EXTERNAL_FILES -> {
+        val externalFilesDirs: Array<File> = context.getExternalFilesDirs(null)
+        externalFilesDirs.takeIf { it.isNotEmpty() }?.let { it[0] }
+      }
+      TAG_EXTERNAL_CACHE -> {
+        val externalCacheDirs: Array<File> = context.externalCacheDirs
+        externalCacheDirs.takeIf { it.isNotEmpty() }?.let { it[0] }
+      }
+      else -> null
+    }
+
+    private fun buildPath(base: File, vararg segments: String?): File {
+      var cur = base
+      for (segment in segments) {
+        if (segment != null) {
+          cur = File(cur, segment)
+        }
+      }
+      return cur
+    }
+  }
+
+  /**
+   * Strategy for mapping between [File] and [Uri].
+   *
+   *
+   * Strategies must be symmetric so that mapping a [File] to a
+   * [Uri] and then back to a [File] points at the original
+   * target.
+   *
+   *
+   * Strategies must remain consistent across app launches, and not rely on
+   * dynamic state. This ensures that any generated [Uri] can still be
+   * resolved if your process is killed and later restarted.
+   *
+   * @see SimplePathStrategy
+   */
+  internal interface PathStrategy {
+    /**
+     * Return a [Uri] that represents the given [File].
+     */
+    fun getUriForFile(file: File): Uri?
+
+    /**
+     * Return a [File] that represents the given [Uri].
+     */
+    fun getFileForUri(uri: Uri): File
+  }
+
+  /**
+   * Strategy that provides access to files living under a narrow whitelist of
+   * filesystem roots. It will throw [SecurityException] if callers try
+   * accessing files outside the configured roots.
+   *
+   *
+   * For example, if configured with
+   * `addRoot("myfiles", context.getFilesDir())`, then
+   * `context.getFileStreamPath("foo.txt")` would map to
+   * `content://myauthority/myfiles/foo.txt`.
+   */
+  internal class SimplePathStrategy(private val authority: String) : PathStrategy {
+    private val roots: HashMap<String, File> = HashMap()
+
+    /**
+     * Add a mapping from a name to a filesystem root. The provider only offers
+     * access to files that live under configured roots.
+     */
+    fun addRoot(name: String?, root: File) {
+      require(name != null && !TextUtils.isEmpty(name)) { "Name must not be empty" }
+      val newRoot = try {
+        // Resolve to canonical path to keep path checking fast
+        root.canonicalFile
+      } catch (e: IOException) {
+        throw IllegalArgumentException("Failed to resolve canonical path for $root", e)
+      }
+      roots[name] = newRoot
+    }
+
+    override fun getUriForFile(file: File): Uri? {
+      var path: String = try {
+        file.canonicalPath
+      } catch (e: IOException) {
+        throw java.lang.IllegalArgumentException("Failed to resolve canonical path for $file")
+      }
+
+      // Find the most-specific root path
+      var mostSpecific: Map.Entry<String, File>? = null
+      for (root in roots.entries) {
+        val rootPath = root.value.path
+        if (path.startsWith(rootPath) && (
+          mostSpecific == null ||
+            rootPath.length > mostSpecific.value.path.length
+          )
+        ) {
+          mostSpecific = root
+        }
+      }
+      requireNotNull(mostSpecific) { "Failed to find configured root that contains $path" }
+
+      // Start at first char of path under root
+      val rootPath = mostSpecific.value.path
+      path = if (rootPath.endsWith("/")) {
+        path.substring(rootPath.length)
+      } else {
+        path.substring(rootPath.length + 1)
+      }
+
+      // Encode the tag and path separately
+      path = Uri.encode(mostSpecific.key) + '/' + Uri.encode(path, "/")
+      return Uri.Builder()
+        .scheme("content")
+        .authority(authority)
+        .encodedPath(path)
+        .build()
+    }
+
+    override fun getFileForUri(uri: Uri): File {
+      var path = uri.encodedPath!!
+      val splitIndex = path.indexOf('/', 1)
+      val tag = Uri.decode(path.substring(1, splitIndex))
+      path = Uri.decode(path.substring(splitIndex + 1))
+      val root = roots[tag]
+        ?: throw java.lang.IllegalArgumentException("Unable to find configured root for $uri")
+      var file = File(root, path)
+      file = try {
+        file.canonicalFile
+      } catch (e: IOException) {
+        throw java.lang.IllegalArgumentException("Failed to resolve canonical path for $file")
+      }
+      if (!file.path.startsWith(root.path)) {
+        throw SecurityException("Resolved path jumped beyond configured root")
+      }
+      return file
+    }
+  }
+}

package/android/src/main/java/expo/modules/clipboard/ClipboardImage.kt

@@ -0,0 +1,163 @@
+package expo.modules.clipboard
+
+import android.content.ClipData
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.ImageDecoder
+import android.net.Uri
+import android.os.Build
+import android.provider.MediaStore
+import android.util.Base64
+import androidx.core.os.bundleOf
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+import kotlinx.coroutines.yield
+import java.io.BufferedOutputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.lang.StringBuilder
+import java.util.*
+
+// region Structs and interfaces
+data class ImageResult(
+  val base64Image: String,
+  val width: Int,
+  val height: Int
+) {
+  fun toBundle() = bundleOf(
+    "data" to base64Image,
+    "size" to bundleOf(
+      "width" to width,
+      "height" to height
+    ),
+  )
+}
+// endregion
+
+// region Module functions
+
+/**
+ * Gets the [imageUri] and returns the [ImageResult] object containing base64 encoded image
+ * and its metadata
+ *
+ * @param context
+ * @param imageUri `content://` uri of the image to be resolved
+ *
+ * @throws IOException
+ * @throws SecurityException when app has no permission to access the content uri
+ */
+internal suspend fun imageFromContentUri(
+  context: Context,
+  imageUri: Uri,
+  options: GetImageOptions
+): ImageResult {
+  // 1. Retrieve bitmap from URI
+  val bitmap = bitmapFromContentUriAsync(context, imageUri)
+
+  // 2. Compress it to target format
+  val format = options.imageFormat
+  val quality = (options.jpegQuality * 100).toInt()
+  val outputStream = ByteArrayOutputStream().also {
+    bitmap.compress(format.compressFormat, quality, it)
+  }
+  yield()
+
+  // 3. Convert to base64
+  val byteArray = outputStream.toByteArray()
+  val encodedString = Base64.encodeToString(byteArray, Base64.DEFAULT)
+  val builder = StringBuilder("data:${format.mimeType};base64,").append(encodedString)
+
+  return ImageResult(
+    base64Image = builder.toString(),
+    width = bitmap.width,
+    height = bitmap.height
+  )
+}
+
+/**
+ * Gets base64-encoded image data and prepares it to be accessible by other applications
+ * when pasting from clipboard
+ *
+ * Saves the image to the [clipboardCacheDir] directory, then uses [ClipboardFileProvider]
+ * to create a `content://` URI which then is packed to the [ClipData] object.
+ *
+ * @param context
+ * @param base64Image base64-encoded JPEG image data. Should not be prefixed
+ * @param clipboardCacheDir directory where the copied image is stored, must be accessible by
+ * the [ClipboardFileProvider]
+ * @return clip data ready to be shared by the [android.content.ClipboardManager]
+ */
+internal suspend fun clipDataFromBase64Image(
+  context: Context,
+  base64Image: String,
+  clipboardCacheDir: File,
+): ClipData {
+  // 1. Get bitmap from base64 string
+  val bitmap = bitmapFromBase64String(base64Image)
+
+  // 2. Create file in cache dir, it will be overwritten if already exists
+  val file = File(clipboardCacheDir, "copied_image.jpeg").also {
+    it.ensureExists()
+  }
+
+  // 3. Write bitmap to the file
+  val fileStream = runInterruptible { FileOutputStream(file, false) }
+  BufferedOutputStream(fileStream).use { outputStream ->
+    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream)
+    runInterruptible { outputStream.flush() }
+  }
+
+  // 4. Get content:// URI to the image file and put it to the clipboard data
+  val imageUri = ClipboardFileProvider.getUriForFile(
+    context,
+    context.applicationInfo.packageName + ".ClipboardFileProvider",
+    file
+  )
+  return ClipData.newUri(context.contentResolver, "image", imageUri)
+}
+// endregion
+
+// region Utility functions
+
+/**
+ * Retrieves [Bitmap] from `content://` image uri
+ * @throws SecurityException when app has no permission to access the content uri
+ * @throws IOException
+ */
+internal suspend fun bitmapFromContentUriAsync(context: Context, imageUri: Uri): Bitmap =
+  runInterruptible(Dispatchers.IO) {
+    val contentResolver = context.contentResolver
+    when {
+      Build.VERSION.SDK_INT < 28 -> MediaStore.Images.Media.getBitmap(
+        contentResolver,
+        imageUri
+      )
+      else -> {
+        val source = ImageDecoder.createSource(contentResolver, imageUri)
+        ImageDecoder.decodeBitmap(source)
+      }
+    }
+  }
+
+internal fun bitmapFromBase64String(base64Image: String): Bitmap = try {
+  val byteArray = Base64.decode(base64Image, Base64.DEFAULT)
+  BitmapFactory.decodeByteArray(byteArray, 0, byteArray.size)
+    ?: throw RuntimeException("Failed to convert base64 into Bitmap")
+} catch (e: RuntimeException) {
+  // Base64.decode throws IllegalArgumentException on invalid data, but
+  // BitmapFactory.decodeByteArray returns null if data cannot be converted
+  // so we aggregate both errors here
+  throw InvalidImageException(base64Image, e)
+}
+
+/**
+ * Creates the file and all its parent directories if they don't exist already.
+ */
+private suspend fun File.ensureExists() = runInterruptible(Dispatchers.IO) {
+  parentFile?.mkdirs()
+  createNewFile()
+}
+// endregion