tauri-plugin-intent 0.1.0

package com.plugin.intent

import android.app.Activity
import android.content.Intent
import android.net.Uri
import android.util.Log
import app.tauri.annotation.Command
import app.tauri.annotation.InvokeArg
import app.tauri.annotation.TauriPlugin
import app.tauri.plugin.JSObject
import app.tauri.plugin.Plugin
import app.tauri.plugin.Invoke

@InvokeArg
class OpenIntentArgs {
    var action: String = ""
    var data: String? = null
    var category: String? = null
    var mimeType: String? = null
    var packageName: String? = null
    var className: String? = null
    var flags: List<String>? = null
    var extras: Map<String, Any>? = null
}

@TauriPlugin
class IntentPlugin(private val activity: Activity): Plugin(activity) {
    companion object {
        private const val TAG = "IntentPlugin"
    }

    @Command
    fun openIntent(invoke: Invoke) {
        try {
            val args = invoke.parseArgs(OpenIntentArgs::class.java)

            val intent = Intent().apply {
                action = args.action

                // Set data if provided
                args.data?.let { data = Uri.parse(it) }

                // Set category if provided
                args.category?.let { addCategory(it) }

                // Set MIME type if provided
                args.mimeType?.let { type = it }

                // Set package and class if provided
                args.packageName?.let { packageName ->
                    setPackage(packageName)
                    args.className?.let { className ->
                        setClassName(packageName, className)
                    }
                }

                // Set flags if provided
                args.flags?.forEach { flagStr ->
                    val flag = when (flagStr) {
                        "FLAG_ACTIVITY_NEW_TASK" -> Intent.FLAG_ACTIVITY_NEW_TASK
                        "FLAG_ACTIVITY_CLEAR_TOP" -> Intent.FLAG_ACTIVITY_CLEAR_TOP
                        "FLAG_ACTIVITY_CLEAR_TASK" -> Intent.FLAG_ACTIVITY_CLEAR_TASK
                        "FLAG_ACTIVITY_SINGLE_TOP" -> Intent.FLAG_ACTIVITY_SINGLE_TOP
                        "FLAG_ACTIVITY_NO_HISTORY" -> Intent.FLAG_ACTIVITY_NO_HISTORY
                        "FLAG_ACTIVITY_MULTIPLE_TASK" -> Intent.FLAG_ACTIVITY_MULTIPLE_TASK
                        else -> {
                            Log.w(TAG, "Unknown flag: $flagStr")
                            0
                        }
                    }
                    if (flag != 0) {
                        addFlags(flag)
                    }
                }

                // Set extras if provided
                args.extras?.forEach { (key, value) ->
                    when (value) {
                        is String -> putExtra(key, value)
                        is Int -> putExtra(key, value)
                        is Long -> putExtra(key, value)
                        is Float -> putExtra(key, value)
                        is Double -> putExtra(key, value)
                        is Boolean -> putExtra(key, value)
                        is List<*> -> {
                            when {
                                value.all { it is String } -> {
                                    putStringArrayListExtra(key, ArrayList(value as List<String>))
                                }
                                value.all { it is Int } -> {
                                    putIntegerArrayListExtra(key, ArrayList(value as List<Int>))
                                }
                                else -> {
                                    Log.w(TAG, "Unsupported array type for extra: $key")
                                }
                            }
                        }
                        is Map<*, *> -> {
                            // Handle nested maps if needed
                            Log.w(TAG, "Map extras are not supported: $key")
                        }
                        else -> {
                            // Try to convert to string as fallback
                            Log.i(TAG, "Converting extra to string: $key")
                            putExtra(key, value.toString())
                        }
                    }
                }
            }

            // Try to start the intent
            activity.startActivity(intent)

            val ret = JSObject()
            ret.put("success", true)
            ret.put("error", null)
            invoke.resolve(ret)

        } catch (e: Exception) {
            Log.e(TAG, "Failed to open intent", e)

            val ret = JSObject()
            ret.put("success", false)
            ret.put("error", e.message ?: "Unknown error occurred")
            invoke.resolve(ret)
        }
    }
}