pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/android/src/main/java/com/pythonnative/runtime/modules/BuiltinModules.kt

@@ -0,0 +1,73 @@
+package com.pythonnative.runtime.modules
+
+import android.app.Activity
+import android.content.Intent
+import com.pythonnative.runtime.bridge.PNRegistry
+
+/**
+ * Registers the built-in modules and forwards activity callbacks to
+ * the modules that need them. The app's `MainActivity` calls the
+ * `on*` hooks; nothing here touches Python directly.
+ */
+object BuiltinModules {
+    val host = HostModule()
+    val device = DeviceModule()
+    val alert = AlertModule()
+    val storage = StorageModule()
+    val secureStore = SecureStoreModule()
+    val clipboard = ClipboardModule()
+    val share = ShareModule()
+    val linking = LinkingModule()
+    val haptics = HapticsModule()
+    val battery = BatteryModule()
+    val netInfo = NetInfoModule()
+    val appState = AppStateModule()
+    val permissions = PermissionsModule()
+    val notifications = NotificationsModule()
+    val camera = CameraModule()
+    val location = LocationModule()
+    val biometrics = BiometricsModule()
+
+    private val all: List<NativeModule> = listOf(
+        host, device, alert, storage, secureStore, clipboard, share, linking, haptics,
+        battery, netInfo, appState, permissions, notifications, camera, location, biometrics,
+    )
+
+    fun register(registry: PNRegistry) {
+        for (module in all) registry.registerModule { module }
+    }
+
+    /** Called from `PNBridge.setContext`; starts the observers that need a context. */
+    fun onContextAttached(activity: Activity) {
+        battery.attach(activity)
+        netInfo.attach(activity)
+        activity.intent?.dataString?.let { linking.onDeepLink(it) }
+    }
+
+    /** Forward `Activity.onActivityResult`. Returns `true` when a module consumed it. */
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean =
+        camera.onActivityResult(requestCode, resultCode, data) || share.onActivityResult(requestCode)
+
+    /** Forward `Activity.onRequestPermissionsResult`. Returns `true` when a module consumed it. */
+    fun onRequestPermissionsResult(
+        requestCode: Int,
+        @Suppress("UNUSED_PARAMETER") permissionNames: Array<out String>,
+        grantResults: IntArray,
+    ): Boolean = permissions.onRequestPermissionsResult(requestCode, grantResults)
+
+    /** Forward `Activity.onNewIntent` (deep links). */
+    fun onNewIntent(intent: Intent?) {
+        intent?.dataString?.let { linking.onDeepLink(it) }
+    }
+
+    /** Forward activity lifecycle transitions to the `AppState` module. */
+    fun onActivityResumed() = appState.transition("active")
+    fun onActivityPaused() = appState.transition("inactive")
+    fun onActivityStopped() = appState.transition("background")
+
+    /** Release observers when the activity is destroyed. */
+    fun onActivityDestroyed(activity: Activity) {
+        battery.detach(activity)
+        netInfo.detach(activity)
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/modules/DeviceModules.kt

@@ -0,0 +1,316 @@
+package com.pythonnative.runtime.modules
+
+import android.app.AlertDialog
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
+import android.provider.Settings
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.Locale
+
+/** `Device.info()`: static facts about the OS, hardware, and app directories. */
+class DeviceModule : NativeModule {
+    override val name = "Device"
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "info" -> {
+                val ctx = PNBridge.context()
+                val locale = Locale.getDefault()
+                promise.resolve(
+                    mapOf(
+                        "os" to "android",
+                        "os_version" to Build.VERSION.RELEASE,
+                        "sdk_int" to Build.VERSION.SDK_INT,
+                        "model" to Build.MODEL,
+                        "manufacturer" to Build.MANUFACTURER,
+                        "app_dir" to ctx.filesDir.absolutePath,
+                        "cache_dir" to ctx.cacheDir.absolutePath,
+                        "locale" to locale.toLanguageTag(),
+                        "density" to PNBridge.density().toDouble(),
+                    ),
+                )
+            }
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+}
+
+/**
+ * `Alert.show({title, message, buttons:[{label, style}], style})`:
+ * an `AlertDialog` resolving to the selected button index, or `-1`
+ * on dismiss. `AlertDialog` has three slots; the first `default`
+ * button takes positive, the first `cancel` negative, the first
+ * `destructive` neutral, and leftovers spill into free slots.
+ */
+class AlertModule : NativeModule {
+    override val name = "Alert"
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "present" -> present(args, promise, fireAndForget = false)
+            "show" -> present(args, promise, fireAndForget = true)
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+
+    /**
+     * Build and show the dialog. `present` resolves with the tapped button
+     * index (or -1 on dismiss); `show` resolves immediately so the Python
+     * side's synchronous `call("show")` returns before the dialog closes.
+     */
+    private fun present(args: JSONObject, promise: Promise, fireAndForget: Boolean) {
+        val activity = PNBridge.activity()
+        if (activity == null) {
+            if (fireAndForget) promise.resolve(null) else promise.reject("no activity", "no_activity")
+            return
+        }
+        if (fireAndForget) promise.resolve(null)
+        val builder = AlertDialog.Builder(activity)
+        builder.setTitle(args.str("title") ?: "")
+        args.str("message")?.let { builder.setMessage(it) }
+        val buttons = args.value("buttons") as? JSONArray
+        val specs = ArrayList<JSONObject>()
+        if (buttons != null) for (i in 0 until buttons.length()) buttons.optJSONObject(i)?.let { specs.add(it) }
+        if (specs.isEmpty()) specs.add(JSONObject().put("label", "OK").put("style", "default"))
+
+        val slotFor = HashMap<Int, String>()
+        val free = arrayListOf("positive", "negative", "neutral")
+        specs.forEachIndexed { i, spec ->
+            val preferred = when (spec.str("style") ?: "default") {
+                "cancel" -> "negative"
+                "destructive" -> "neutral"
+                else -> "positive"
+            }
+            if (free.remove(preferred)) slotFor[i] = preferred
+        }
+        specs.forEachIndexed { i, _ ->
+            if (!slotFor.containsKey(i) && free.isNotEmpty()) slotFor[i] = free.removeAt(0)
+        }
+        var delivered = false
+        fun deliver(index: Int) {
+            if (delivered) return
+            delivered = true
+            if (!fireAndForget) promise.resolve(index)
+        }
+        specs.forEachIndexed { i, spec ->
+            val label = spec.str("label") ?: "OK"
+            when (slotFor[i]) {
+                "positive" -> builder.setPositiveButton(label) { _, _ -> deliver(i) }
+                "negative" -> builder.setNegativeButton(label) { _, _ -> deliver(i) }
+                "neutral" -> builder.setNeutralButton(label) { _, _ -> deliver(i) }
+            }
+        }
+        builder.setOnCancelListener { deliver(-1) }
+        builder.setOnDismissListener { deliver(-1) }
+        builder.show()
+    }
+}
+
+/** `Clipboard.set_string(value)` / `get_string()`. */
+class ClipboardModule : NativeModule {
+    override val name = "Clipboard"
+
+    private fun manager(): ClipboardManager? =
+        PNBridge.context().getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "set_string" -> {
+                manager()?.setPrimaryClip(ClipData.newPlainText("pythonnative", args.str("value") ?: ""))
+                promise.resolve(null)
+            }
+            "get_string" -> {
+                val clip = manager()?.primaryClip
+                val text = if (clip != null && clip.itemCount > 0) clip.getItemAt(0).text?.toString() else null
+                promise.resolve(text ?: "")
+            }
+            "has_string" -> {
+                val clip = manager()?.primaryClip
+                promise.resolve(clip != null && clip.itemCount > 0 && !clip.getItemAt(0).text.isNullOrEmpty())
+            }
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+}
+
+/** `Share.share({message, url, title})`: an `ACTION_SEND` chooser resolving `true` when it returns. */
+class ShareModule : NativeModule {
+    override val name = "Share"
+    private var pending: Promise? = null
+    private var pendingCode = 0
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "share" -> share(args, promise)
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+
+    private fun share(args: JSONObject, promise: Promise) {
+        val activity = PNBridge.activity() ?: return promise.reject("no activity", "no_activity")
+        val message = args.str("message")
+        val url = args.str("url")
+        val body = listOfNotNull(message, url).joinToString("\n")
+        if (body.isEmpty()) return promise.resolve(false)
+        val intent = Intent(Intent.ACTION_SEND)
+        intent.type = "text/plain"
+        intent.putExtra(Intent.EXTRA_TEXT, body)
+        args.str("title")?.let { intent.putExtra(Intent.EXTRA_SUBJECT, it) }
+        try {
+            pending?.resolve(true)
+            pending = promise
+            pendingCode = RequestCodes.next()
+            @Suppress("DEPRECATION")
+            activity.startActivityForResult(Intent.createChooser(intent, args.str("title")), pendingCode)
+        } catch (e: Exception) {
+            pending = null
+            promise.resolve(false)
+        }
+    }
+
+    /** Resolve the pending share when the chooser activity returns. */
+    fun onActivityResult(requestCode: Int): Boolean {
+        if (requestCode != pendingCode || pending == null) return false
+        val p = pending
+        pending = null
+        // The chooser gives no success signal; returning to the app counts as shared.
+        p?.resolve(true)
+        return true
+    }
+}
+
+/**
+ * `Linking`: `open_url`, `can_open_url`, `open_settings` (sync bools)
+ * plus `url` events for deep links, buffered until a `PythonHost` is
+ * installed.
+ */
+class LinkingModule : NativeModule {
+    override val name = "Linking"
+    private val buffered = ArrayList<String>()
+    private var initialUrl: String? = null
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "open_url" -> promise.resolve(openUrl(args.str("url") ?: ""))
+            "can_open_url" -> promise.resolve(canOpen(args.str("url") ?: ""))
+            "open_settings" -> promise.resolve(openSettings())
+            "get_initial_url" -> promise.resolve(initialUrl)
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+
+    /** Record a deep link and emit it once Python can receive it. */
+    fun onDeepLink(url: String) {
+        if (initialUrl == null) initialUrl = url
+        buffered.add(url)
+        PNBridge.runWhenHostReady { flush() }
+    }
+
+    private fun flush() {
+        val urls = ArrayList(buffered)
+        buffered.clear()
+        for (url in urls) ModuleEvents.emit(name, "url", JSONObject().put("url", url))
+    }
+
+    private fun openUrl(url: String): Boolean {
+        if (url.isEmpty()) return false
+        return try {
+            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            PNBridge.context().startActivity(intent)
+            true
+        } catch (e: Exception) {
+            PNLog.swallowed("Linking.open_url", e)
+            false
+        }
+    }
+
+    private fun canOpen(url: String): Boolean {
+        if (url.isEmpty()) return false
+        return try {
+            val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
+            intent.resolveActivity(PNBridge.context().packageManager) != null
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    private fun openSettings(): Boolean {
+        return try {
+            val ctx = PNBridge.context()
+            val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+            intent.data = Uri.fromParts("package", ctx.packageName, null)
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            ctx.startActivity(intent)
+            true
+        } catch (e: Exception) {
+            false
+        }
+    }
+}
+
+/** `Haptics`: `impact(style)`, `notification(type)`, `selection()`, `vibrate(duration_ms)`, `cancel()`. */
+class HapticsModule : NativeModule {
+    override val name = "Haptics"
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "impact" -> buzz(IMPACT_MS[args.str("style") ?: "medium"] ?: 20L)
+            "notification" -> buzz(NOTIFICATION_MS[args.str("type") ?: args.str("type_") ?: "success"] ?: 30L)
+            "selection" -> buzz(10L)
+            "vibrate" -> buzz(JsonUtil.toLong(args.opt("duration_ms"), 400L))
+            "cancel" -> vibrator()?.cancel()
+            else -> return promise.rejectUnknownMethod(method)
+        }
+        promise.resolve(null)
+    }
+
+    private fun vibrator(): Vibrator? {
+        val ctx = PNBridge.context()
+        return if (Build.VERSION.SDK_INT >= 31) {
+            (ctx.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as? VibratorManager)?.defaultVibrator
+        } else {
+            @Suppress("DEPRECATION")
+            ctx.getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator
+        }
+    }
+
+    private fun buzz(durationMs: Long) {
+        val v = vibrator() ?: return
+        try {
+            if (Build.VERSION.SDK_INT >= 26) {
+                v.vibrate(VibrationEffect.createOneShot(durationMs, VibrationEffect.DEFAULT_AMPLITUDE))
+            } else {
+                @Suppress("DEPRECATION")
+                v.vibrate(durationMs)
+            }
+        } catch (e: Exception) {
+            PNLog.swallowed("Haptics.buzz", e)
+        }
+    }
+
+    private companion object {
+        val IMPACT_MS = mapOf("light" to 10L, "medium" to 20L, "heavy" to 40L, "soft" to 15L, "rigid" to 30L)
+        val NOTIFICATION_MS = mapOf("success" to 30L, "warning" to 50L, "error" to 70L)
+    }
+}
+
+/** Monotonic request codes for `startActivityForResult` / `requestPermissions`. */
+object RequestCodes {
+    private var next = 50001
+
+    fun next(): Int = next++
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/modules/HostModule.kt

@@ -0,0 +1,61 @@
+package com.pythonnative.runtime.modules
+
+import androidx.fragment.app.FragmentActivity
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import com.pythonnative.runtime.screens.PNScreenFragment
+import com.pythonnative.runtime.screens.ScreenRegistry
+import org.json.JSONObject
+
+/**
+ * `Host`: screen hosting and navigation. Screens are the integer ids
+ * assigned by [ScreenRegistry] when a [PNScreenFragment] is created.
+ */
+class HostModule : NativeModule {
+    override val name = "Host"
+
+    private fun screen(args: JSONObject): PNScreenFragment? = ScreenRegistry.get(JsonUtil.toInt(args.opt("screen")))
+
+    private fun activity(): FragmentActivity? = PNBridge.activity() as? FragmentActivity
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "cache_state" -> {
+                screen(args)?.cachedStateJSON = args.str("state")
+                promise.resolve(null)
+            }
+            "attach_root" -> {
+                val fragment = screen(args) ?: return promise.reject("unknown screen", "unknown_screen")
+                val record = PNBridge.registry.get(JsonUtil.toLong(args.opt("tag")))
+                    ?: return promise.reject("unknown tag", "unknown_tag")
+                fragment.attachRoot(record.view)
+                promise.resolve(null)
+            }
+            "detach_root" -> {
+                val fragment = screen(args)
+                val record = PNBridge.registry.get(JsonUtil.toLong(args.opt("tag")))
+                if (record != null) {
+                    if (fragment != null) fragment.detachRoot(record.view) else (record.view.parent as? android.view.ViewGroup)?.removeView(record.view)
+                }
+                promise.resolve(null)
+            }
+            "finish" -> { activity()?.finish(); promise.resolve(null) }
+            "set_options" -> {
+                val options = args.value("options") as? JSONObject ?: JSONObject()
+                options.str("title")?.let { title -> activity()?.title = title }
+                promise.resolve(null)
+            }
+            "viewport" -> {
+                val fragment = screen(args) ?: ScreenRegistry.get(ScreenRegistry.activeId())
+                val payload = fragment?.viewport() ?: activity()?.window?.decorView?.let {
+                    com.pythonnative.runtime.screens.Viewport.describe(it)
+                } ?: JSONObject()
+                promise.resolve(payload)
+            }
+            "active_screen" -> promise.resolve(ScreenRegistry.activeId())
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/modules/MediaModules.kt

@@ -0,0 +1,200 @@
+package com.pythonnative.runtime.modules
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.location.Location
+import android.location.LocationListener
+import android.location.LocationManager
+import android.os.Bundle
+import android.provider.MediaStore
+import androidx.biometric.BiometricManager
+import androidx.biometric.BiometricPrompt
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.FragmentActivity
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.MainThread
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.str
+import org.json.JSONObject
+import java.io.File
+import java.io.FileOutputStream
+
+/**
+ * `Camera.take_photo()` / `pick_from_gallery()`: launch the system
+ * capture or pick intent and resolve to the resulting path (a content
+ * URI string, or a JPEG written to the cache dir for thumbnails) or
+ * `null` when cancelled.
+ */
+class CameraModule : NativeModule {
+    override val name = "Camera"
+    private val pending = HashMap<Int, Promise>()
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "take_photo" -> launch(Intent(MediaStore.ACTION_IMAGE_CAPTURE), promise)
+            "pick_from_gallery" -> launch(Intent(Intent.ACTION_PICK).apply { type = "image/*" }, promise)
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+
+    private fun launch(intent: Intent, promise: Promise) {
+        val activity = PNBridge.activity() ?: return promise.resolve(null)
+        val code = RequestCodes.next()
+        pending[code] = promise
+        try {
+            @Suppress("DEPRECATION")
+            activity.startActivityForResult(intent, code)
+        } catch (e: Exception) {
+            pending.remove(code)
+            PNLog.swallowed("Camera.launch", e)
+            promise.resolve(null)
+        }
+    }
+
+    /** Route `Activity.onActivityResult`; `true` when a pending picker matched. */
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean {
+        val promise = pending.remove(requestCode) ?: return false
+        var path: String? = null
+        if (resultCode == Activity.RESULT_OK && data != null) {
+            val uri = data.data
+            if (uri != null) {
+                path = uri.toString()
+            } else {
+                @Suppress("DEPRECATION")
+                val thumb = data.extras?.get("data") as? Bitmap
+                if (thumb != null) path = writeBitmapToCache(thumb)
+            }
+        }
+        promise.resolve(path)
+        return true
+    }
+
+    private fun writeBitmapToCache(bitmap: Bitmap): String? {
+        return try {
+            val target = File(PNBridge.context().cacheDir, "pn-camera-${System.currentTimeMillis()}.jpg")
+            FileOutputStream(target).use { bitmap.compress(Bitmap.CompressFormat.JPEG, 85, it) }
+            target.absolutePath
+        } catch (e: Exception) {
+            PNLog.swallowed("Camera.writeBitmapToCache", e)
+            null
+        }
+    }
+}
+
+/**
+ * `Location.get_current()`: the last known fix if fresh enough,
+ * otherwise a single `network`/`gps` update with a 15 s timeout.
+ * Resolves to `{latitude, longitude}` or `null`.
+ */
+class LocationModule : NativeModule {
+    override val name = "Location"
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "get_current" -> getCurrent(promise)
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    private fun getCurrent(promise: Promise) {
+        val ctx = PNBridge.context()
+        val lm = ctx.getSystemService(Context.LOCATION_SERVICE) as? LocationManager ?: return promise.resolve(null)
+        try {
+            for (provider in listOf(LocationManager.GPS_PROVIDER, LocationManager.NETWORK_PROVIDER)) {
+                val last = lm.getLastKnownLocation(provider) ?: continue
+                if (System.currentTimeMillis() - last.time < 60_000) return promise.resolve(coords(last))
+            }
+        } catch (e: SecurityException) {
+            return promise.resolve(null)
+        } catch (e: Exception) {
+            PNLog.swallowed("Location.lastKnown", e)
+        }
+        var settled = false
+        val listener = object : LocationListener {
+            override fun onLocationChanged(location: Location) {
+                if (settled) return
+                settled = true
+                lm.removeUpdates(this)
+                promise.resolve(coords(location))
+            }
+
+            @Deprecated("Deprecated in Java")
+            override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {}
+            override fun onProviderEnabled(provider: String) {}
+            override fun onProviderDisabled(provider: String) {}
+        }
+        try {
+            val provider = when {
+                lm.isProviderEnabled(LocationManager.NETWORK_PROVIDER) -> LocationManager.NETWORK_PROVIDER
+                lm.isProviderEnabled(LocationManager.GPS_PROVIDER) -> LocationManager.GPS_PROVIDER
+                else -> return promise.resolve(null)
+            }
+            lm.requestLocationUpdates(provider, 1000L, 0f, listener)
+            MainThread.postDelayed({
+                if (settled) return@postDelayed
+                settled = true
+                lm.removeUpdates(listener)
+                promise.resolve(null)
+            }, 15_000L)
+        } catch (e: Exception) {
+            PNLog.swallowed("Location.requestUpdates", e)
+            promise.resolve(null)
+        }
+    }
+
+    private fun coords(location: Location): Map<String, Any?> = mapOf(
+        "latitude" to location.latitude,
+        "longitude" to location.longitude,
+        "accuracy" to location.accuracy.toDouble(),
+        "altitude" to if (location.hasAltitude()) location.altitude else null,
+        "timestamp" to location.time,
+    )
+}
+
+/** `Biometrics.is_available()` (sync bool) and `authenticate(reason)` (async bool via `BiometricPrompt`). */
+class BiometricsModule : NativeModule {
+    override val name = "Biometrics"
+
+    override fun call(method: String, args: JSONObject, promise: Promise) {
+        when (method) {
+            "is_available" -> promise.resolve(isAvailable())
+            "authenticate" -> authenticate(args.str("reason") ?: "Authenticate", promise)
+            else -> promise.rejectUnknownMethod(method)
+        }
+    }
+
+    private fun isAvailable(): Boolean {
+        return try {
+            val manager = BiometricManager.from(PNBridge.context())
+            manager.canAuthenticate(BiometricManager.Authenticators.BIOMETRIC_WEAK) == BiometricManager.BIOMETRIC_SUCCESS
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    private fun authenticate(reason: String, promise: Promise) {
+        val activity = PNBridge.activity() as? FragmentActivity ?: return promise.resolve(false)
+        if (!isAvailable()) return promise.resolve(false)
+        try {
+            val executor = ContextCompat.getMainExecutor(activity)
+            val prompt = BiometricPrompt(activity, executor, object : BiometricPrompt.AuthenticationCallback() {
+                override fun onAuthenticationSucceeded(result: BiometricPrompt.AuthenticationResult) = promise.resolve(true)
+                override fun onAuthenticationError(errorCode: Int, errString: CharSequence) = promise.resolve(false)
+                override fun onAuthenticationFailed() {}
+            })
+            val info = BiometricPrompt.PromptInfo.Builder()
+                .setTitle(reason)
+                .setNegativeButtonText("Cancel")
+                .setAllowedAuthenticators(BiometricManager.Authenticators.BIOMETRIC_WEAK)
+                .build()
+            prompt.authenticate(info)
+        } catch (e: Exception) {
+            PNLog.swallowed("Biometrics.authenticate", e)
+            promise.resolve(false)
+        }
+    }
+}