snapshot of https://github.com/tauri-apps/plugins-workspace.git (v2, 2026-09-23; blobs > 131072B omitted)

plugins/dialog/android/.gitignore

@@ -0,0 +1,2 @@
+/build
+/.tauri

plugins/dialog/android/build.gradle.kts

@@ -0,0 +1,35 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "app.tauri.dialog"
+    compileSdk = 36
+
+    defaultConfig {
+        minSdk = 24
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles("consumer-rules.pro")
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+dependencies {
+
+    implementation("androidx.core:core-ktx:1.9.0")
+    implementation("androidx.appcompat:appcompat:1.7.1")
+    implementation("com.google.android.material:material:1.13.0")
+    testImplementation("junit:junit:4.13.2")
+    androidTestImplementation("androidx.test.ext:junit:1.1.5")
+    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
+    implementation(project(":tauri-android"))
+}

plugins/dialog/android/consumer-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

plugins/dialog/android/settings.gradle

@@ -0,0 +1,2 @@
+include ':tauri-android'
+project(':tauri-android').projectDir = new File('./.tauri/tauri-api')

plugins/dialog/android/src/androidTest/java/ExampleInstrumentedTest.kt

@@ -0,0 +1,28 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+package app.tauri.dialog
+
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.ext.junit.runners.AndroidJUnit4
+
+import org.junit.Test
+import org.junit.runner.RunWith
+
+import org.junit.Assert.*
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+@RunWith(AndroidJUnit4::class)
+class ExampleInstrumentedTest {
+    @Test
+    fun useAppContext() {
+        // Context of the app under test.
+        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
+        assertEquals("app.tauri.dialog", appContext.packageName)
+    }
+}

plugins/dialog/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

plugins/dialog/android/src/main/java/DialogPlugin.kt

@@ -0,0 +1,246 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+package app.tauri.dialog
+
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+import android.os.Handler
+import android.os.Looper
+import android.webkit.MimeTypeMap
+import androidx.activity.result.ActivityResult
+import app.tauri.Logger
+import app.tauri.annotation.ActivityCallback
+import app.tauri.annotation.Command
+import app.tauri.annotation.InvokeArg
+import app.tauri.annotation.TauriPlugin
+import app.tauri.plugin.Invoke
+import app.tauri.plugin.JSArray
+import app.tauri.plugin.JSObject
+import app.tauri.plugin.Plugin
+import com.google.android.material.dialog.MaterialAlertDialogBuilder
+
+@InvokeArg
+class Filter {
+  lateinit var extensions: Array<String>
+}
+
+@InvokeArg
+class FilePickerOptions {
+  lateinit var filters: Array<Filter>
+  var multiple: Boolean? = null
+  var pickerMode: String? = null
+}
+
+@InvokeArg
+class MessageOptions {
+  var title: String? = null
+  lateinit var message: String
+  var okButtonLabel: String? = null
+  var noButtonLabel: String? = null
+  var cancelButtonLabel: String? = null
+}
+
+@InvokeArg
+class SaveFileDialogOptions {
+  var fileName: String? = null
+  lateinit var filters: Array<Filter>
+}
+
+@TauriPlugin
+class DialogPlugin(private val activity: Activity): Plugin(activity) {
+  var filePickerOptions: FilePickerOptions? = null
+
+  @Command
+  fun showFilePicker(invoke: Invoke) {
+    try {
+      val args = invoke.parseArgs(FilePickerOptions::class.java)
+      val parsedTypes = parseFiltersOption(args.filters)
+
+      // TODO: ACTION_OPEN_DOCUMENT ??
+      val intent = Intent(Intent.ACTION_GET_CONTENT)
+      intent.addCategory(Intent.CATEGORY_OPENABLE)
+
+      if (args.pickerMode == "image") {
+        intent.type = "image/*"
+      } else if (args.pickerMode == "video") {
+        intent.type = "video/*"
+      } else if (args.pickerMode == "media") {
+        intent.type = "*/*"
+        intent.putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("video/*", "image/*"))
+      } else if (parsedTypes.isNotEmpty()) {
+        intent.type = "*/*"
+        intent.putExtra(Intent.EXTRA_MIME_TYPES, parsedTypes)
+      } else {
+        intent.type = "*/*"
+      }
+
+      intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, args.multiple ?: false)
+
+      startActivityForResult(invoke, intent, "filePickerResult")
+    } catch (ex: Exception) {
+      val message = ex.message ?: "Failed to pick file"
+      Logger.error(message)
+      invoke.reject(message)
+    }
+  }
+
+  @ActivityCallback
+  fun filePickerResult(invoke: Invoke, result: ActivityResult) {
+    try {
+      when (result.resultCode) {
+        Activity.RESULT_OK -> {
+          val callResult = createPickFilesResult(result.data)
+          invoke.resolve(callResult)
+        }
+        Activity.RESULT_CANCELED -> invoke.reject("File picker cancelled")
+        else -> invoke.reject("Failed to pick files")
+      }
+    } catch (ex: java.lang.Exception) {
+      val message = ex.message ?: "Failed to read file pick result"
+      Logger.error(message)
+      invoke.reject(message)
+    }
+  }
+
+  private fun createPickFilesResult(data: Intent?): JSObject {
+    val callResult = JSObject()
+    if (data == null) {
+      callResult.put("files", null)
+      return callResult
+    }
+    val uris: MutableList<String?> = ArrayList()
+    if (data.clipData == null) {
+      val uri: Uri? = data.data
+      uris.add(uri?.toString())
+    } else {
+      for (i in 0 until data.clipData!!.itemCount) {
+        val uri: Uri = data.clipData!!.getItemAt(i).uri
+        uris.add(uri.toString())
+      }
+    }
+    callResult.put("files", JSArray.from(uris.toTypedArray()))
+    return callResult
+  }
+
+  private fun parseFiltersOption(filters: Array<Filter>): Array<String> {
+    val mimeTypes = mutableListOf<String>()
+    for (filter in filters) {
+      for (ext in filter.extensions) {
+        if (ext.contains('/')) {
+          mimeTypes.add(if (ext == "text/csv") "text/comma-separated-values" else ext)
+        } else {
+          MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext)?.let {
+            mimeTypes.add(it)
+          }
+        }
+      }
+    }
+    return mimeTypes.toTypedArray()
+  }
+
+  @Command
+  fun showMessageDialog(invoke: Invoke) {
+    val args = invoke.parseArgs(MessageOptions::class.java)
+
+    if (activity.isFinishing) {
+      invoke.reject("App is finishing")
+      return
+    }
+
+    val handler = { value: String ->
+      val ret = JSObject()
+      ret.put("value", value)
+      invoke.resolve(ret)
+    }
+
+    Handler(Looper.getMainLooper())
+      .post {
+        val builder = MaterialAlertDialogBuilder(activity)
+
+        if (args.title != null) {
+          builder.setTitle(args.title)
+        }
+
+        val okButtonLabel = args.okButtonLabel ?: "Ok"
+
+        builder
+          .setMessage(args.message)
+          .setPositiveButton(okButtonLabel) { dialog, _ ->
+            dialog.dismiss()
+            handler(okButtonLabel)
+          }
+          .setOnCancelListener { dialog ->
+            dialog.dismiss()
+            handler(args.cancelButtonLabel ?: "Cancel")
+          }
+
+        if (args.noButtonLabel != null) {
+          builder.setNeutralButton(args.noButtonLabel) { dialog, _ ->
+            dialog.dismiss()
+            handler(args.noButtonLabel!!)
+          }
+        }
+
+        if (args.cancelButtonLabel != null) {
+          builder.setNegativeButton( args.cancelButtonLabel) { dialog, _ ->
+            dialog.dismiss()
+            handler(args.cancelButtonLabel!!)
+          }
+        }
+
+        builder.show()
+      }
+  }
+
+  @Command
+  fun saveFileDialog(invoke: Invoke) {
+    try {
+      val args = invoke.parseArgs(SaveFileDialogOptions::class.java)
+      val parsedTypes = parseFiltersOption(args.filters)
+
+      val intent = Intent(Intent.ACTION_CREATE_DOCUMENT)
+      intent.addCategory(Intent.CATEGORY_OPENABLE)
+      intent.putExtra(Intent.EXTRA_TITLE, args.fileName ?: "")
+      if (parsedTypes.size == 1) {
+        intent.type = parsedTypes.first()
+      } else {
+        intent.type = "*/*"
+        intent.putExtra(Intent.EXTRA_MIME_TYPES, parsedTypes)
+      }
+
+      startActivityForResult(invoke, intent, "saveFileDialogResult")
+    } catch (ex: Exception) {
+      val message = ex.message ?: "Failed to pick save file"
+      Logger.error(message)
+      invoke.reject(message)
+    }
+  }
+
+  @ActivityCallback
+  fun saveFileDialogResult(invoke: Invoke, result: ActivityResult) {
+    try {
+      when (result.resultCode) {
+        Activity.RESULT_OK -> {
+          val callResult = JSObject()
+          val intent: Intent? = result.data
+          if (intent != null) {
+            val uri = intent.data
+            if (uri != null) {
+              callResult.put("file", uri.toString())
+            }
+          }
+          invoke.resolve(callResult)
+        }
+        Activity.RESULT_CANCELED -> invoke.reject("File picker cancelled")
+        else -> invoke.reject("Failed to pick files")
+      }
+    } catch (ex: java.lang.Exception) {
+      val message = ex.message ?: "Failed to read file pick result"
+      Logger.error(message)
+      invoke.reject(message)
+    }
+  }
+}

plugins/dialog/android/src/main/java/FilePickerUtils.kt

@@ -0,0 +1,230 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+package app.tauri.dialog
+
+
+import android.content.ContentUris
+import android.database.Cursor
+import android.provider.MediaStore
+import android.content.Context
+import android.graphics.BitmapFactory
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Environment
+import android.provider.DocumentsContract
+import android.provider.OpenableColumns
+import android.util.Base64
+import app.tauri.Logger
+import java.io.ByteArrayOutputStream
+import java.io.FileNotFoundException
+import java.io.IOException
+import java.io.InputStream
+
+class FilePickerUtils {
+  class FileResolution(var height: Int, var width: Int)
+
+  companion object {
+    fun getPathFromUri(context: Context, uri: Uri): String? {
+      if (DocumentsContract.isDocumentUri(context, uri)) {
+        if (isExternalStorageDocument(uri)) {
+          val docId = DocumentsContract.getDocumentId(uri)
+          val split = docId.split(":")
+          return if ("primary".equals(split[0], ignoreCase = true)) {
+            "${Environment.getExternalStorageDirectory()}/${split[1]}"
+          } else {
+            null
+          }
+        } else if (isDownloadsDocument(uri)) {
+          val id = DocumentsContract.getDocumentId(uri)
+          val contentUri = ContentUris.withAppendedId(
+            Uri.parse("content://downloads/public_downloads"), java.lang.Long.valueOf(id))
+          return getDataColumn(context, contentUri, null, null)
+        } else if (isMediaDocument(uri)) {
+          val docId = DocumentsContract.getDocumentId(uri)
+          val split = docId.split(":")
+          val contentUri: Uri? = when (split[0]) {
+            "image" -> MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+            "video" -> MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+            "audio" -> MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+            else -> null
+          }
+          val selection = "_id=?"
+          val selectionArgs = arrayOf(split[1])
+          return getDataColumn(context, contentUri, selection, selectionArgs)
+        }
+      } else if ("content".equals(uri.scheme, ignoreCase = true)) {
+        return getDataColumn(context, uri, null, null)
+      } else if ("file".equals(uri.scheme, ignoreCase = true)) {
+        return uri.path
+      }
+      return null
+    }
+
+    fun getNameFromUri(context: Context, uri: Uri): String? {
+      var displayName: String? = ""
+      val projection = arrayOf(OpenableColumns.DISPLAY_NAME)
+      val cursor =
+        context.contentResolver.query(uri, projection, null, null, null)
+      if (cursor != null) {
+        cursor.moveToFirst()
+        val columnIdx = cursor.getColumnIndex(projection[0])
+        displayName = cursor.getString(columnIdx)
+        cursor.close()
+      }
+      if (displayName.isNullOrEmpty()) {
+        displayName = uri.lastPathSegment
+      }
+      return displayName
+    }
+
+    fun getDataFromUri(context: Context, uri: Uri): String {
+      try {
+        val stream = context.contentResolver.openInputStream(uri) ?: return ""
+        val bytes = getBytesFromInputStream(stream)
+        return Base64.encodeToString(bytes, Base64.NO_WRAP)
+      } catch (e: FileNotFoundException) {
+        Logger.error("openInputStream failed.", e)
+      } catch (e: IOException) {
+        Logger.error("getBytesFromInputStream failed.", e)
+      }
+      return ""
+    }
+
+    fun getMimeTypeFromUri(context: Context, uri: Uri): String? {
+      return context.contentResolver.getType(uri)
+    }
+
+    fun getModifiedAtFromUri(context: Context, uri: Uri): Long? {
+      return try {
+        var modifiedAt: Long = 0
+        val cursor =
+          context.contentResolver.query(uri, null, null, null, null)
+        if (cursor != null) {
+          cursor.moveToFirst()
+          val columnIdx =
+            cursor.getColumnIndex(DocumentsContract.Document.COLUMN_LAST_MODIFIED)
+          modifiedAt = cursor.getLong(columnIdx)
+          cursor.close()
+        }
+        modifiedAt
+      } catch (e: Exception) {
+        Logger.error("getModifiedAtFromUri failed.", e)
+        null
+      }
+    }
+
+    fun getSizeFromUri(context: Context, uri: Uri): Long {
+      var size: Long = 0
+      val projection = arrayOf(OpenableColumns.SIZE)
+      val cursor =
+        context.contentResolver.query(uri, projection, null, null, null)
+      if (cursor != null) {
+        cursor.moveToFirst()
+        val columnIdx = cursor.getColumnIndex(projection[0])
+        size = cursor.getLong(columnIdx)
+        cursor.close()
+      }
+      return size
+    }
+
+    fun getDurationFromUri(context: Context, uri: Uri): Long? {
+      if (isVideoUri(context, uri)) {
+        val retriever = MediaMetadataRetriever()
+        retriever.setDataSource(context, uri)
+        val time = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)
+        val durationMs = time?.toLong() ?: 0
+        try {
+          retriever.release()
+        } catch (e: Exception) {
+          Logger.error("MediaMetadataRetriever.release() failed.", e)
+        }
+        return durationMs / 1000L
+      }
+      return null
+    }
+    
+    fun getHeightAndWidthFromUri(context: Context, uri: Uri): FileResolution? {
+      if (isImageUri(context, uri)) {
+        val options = BitmapFactory.Options()
+        options.inJustDecodeBounds = true
+        return try {
+          BitmapFactory.decodeStream(
+            context.contentResolver.openInputStream(uri),
+            null,
+            options
+          )
+          FileResolution(options.outHeight, options.outWidth)
+        } catch (exception: FileNotFoundException) {
+          exception.printStackTrace()
+          null
+        }
+      } else if (isVideoUri(context, uri)) {
+        val retriever = MediaMetadataRetriever()
+        retriever.setDataSource(context, uri)
+        val width =
+          Integer.valueOf(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH) ?: "0")
+        val height =
+          Integer.valueOf(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT) ?: "0")
+        try {
+          retriever.release()
+        } catch (e: Exception) {
+          Logger.error("MediaMetadataRetriever.release() failed.", e)
+        }
+        return FileResolution(height, width)
+      }
+      return null
+    }
+
+    private fun isImageUri(context: Context, uri: Uri): Boolean {
+      val mimeType = getMimeTypeFromUri(context, uri) ?: return false
+      return mimeType.startsWith("image")
+    }
+
+    private fun isVideoUri(context: Context, uri: Uri): Boolean {
+      val mimeType = getMimeTypeFromUri(context, uri) ?: return false
+      return mimeType.startsWith("video")
+    }
+    
+    @Throws(IOException::class)
+    private fun getBytesFromInputStream(`is`: InputStream): ByteArray {
+      val os = ByteArrayOutputStream()
+      val buffer = ByteArray(0xFFFF)
+      var len = `is`.read(buffer)
+      while (len != -1) {
+        os.write(buffer, 0, len)
+        len = `is`.read(buffer)
+      }
+      return os.toByteArray()
+    }
+  }
+}
+
+private fun getDataColumn(context: Context, uri: Uri?, selection: String?, selectionArgs: Array<String>?): String? {
+  var cursor: Cursor? = null
+  val column = "_data"
+  val projection = arrayOf(column)
+  try {
+    cursor = context.contentResolver.query(uri!!, projection, selection, selectionArgs, null)
+    if (cursor != null && cursor.moveToFirst()) {
+      val columnIndex = cursor.getColumnIndexOrThrow(column)
+      return cursor.getString(columnIndex)
+    }
+  } finally {
+    cursor?.close()
+  }
+  return null
+}
+
+private fun isExternalStorageDocument(uri: Uri): Boolean {
+  return "com.android.externalstorage.documents" == uri.authority
+}
+
+private fun isDownloadsDocument(uri: Uri): Boolean {
+  return "com.android.providers.downloads.documents" == uri.authority
+}
+
+private fun isMediaDocument(uri: Uri): Boolean {
+  return "com.android.providers.media.documents" == uri.authority
+}

plugins/dialog/android/src/test/java/ExampleUnitTest.kt

@@ -0,0 +1,21 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+package app.tauri.dialog
+
+import org.junit.Test
+
+import org.junit.Assert.*
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * See [testing documentation](http://d.android.com/tools/testing).
+ */
+class ExampleUnitTest {
+    @Test
+    fun addition_isCorrect() {
+        assertEquals(4, 2 + 2)
+    }
+}