@thelacanians/vue-native-cli 0.4.3 → 0.4.5

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/BluetoothModule.kt

@@ -0,0 +1,302 @@
+package com.vuenative.core
+
+import android.Manifest
+import android.bluetooth.*
+import android.bluetooth.le.*
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.Base64
+import androidx.core.content.ContextCompat
+import java.util.UUID
+
+class BluetoothModule : NativeModule {
+    override val moduleName = "Bluetooth"
+
+    private var context: Context? = null
+    private var bridge: NativeBridge? = null
+    private var bluetoothAdapter: BluetoothAdapter? = null
+    private var scanner: BluetoothLeScanner? = null
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    private val discoveredDevices = mutableMapOf<String, BluetoothDevice>()
+    private val gattConnections = mutableMapOf<String, BluetoothGatt>()
+    private val connectCallbacks = mutableMapOf<String, (Any?, String?) -> Unit>()
+    private val readCallbacks = mutableMapOf<String, (Any?, String?) -> Unit>()
+    private val writeCallbacks = mutableMapOf<String, (Any?, String?) -> Unit>()
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        this.context = context
+        this.bridge = bridge
+        val bluetoothManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager
+        bluetoothAdapter = bluetoothManager?.adapter
+        scanner = bluetoothAdapter?.bluetoothLeScanner
+    }
+
+    override fun invoke(method: String, args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
+        when (method) {
+            "startScan" -> {
+                if (!hasBluetoothPermission()) {
+                    callback(null, "Bluetooth permission not granted")
+                    return
+                }
+                val serviceUUIDs = (args.getOrNull(0) as? List<*>)?.filterIsInstance<String>()
+                startScan(serviceUUIDs)
+                callback(null, null)
+            }
+            "stopScan" -> {
+                stopScan()
+                callback(null, null)
+            }
+            "connect" -> {
+                val deviceId = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing deviceId"); return
+                }
+                connect(deviceId, callback)
+            }
+            "disconnect" -> {
+                val deviceId = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing deviceId"); return
+                }
+                disconnect(deviceId, callback)
+            }
+            "readCharacteristic" -> {
+                val deviceId = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing deviceId"); return }
+                val serviceUUID = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing serviceUUID"); return }
+                val charUUID = args.getOrNull(2)?.toString() ?: run { callback(null, "Missing charUUID"); return }
+                readCharacteristic(deviceId, serviceUUID, charUUID, callback)
+            }
+            "writeCharacteristic" -> {
+                val deviceId = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing deviceId"); return }
+                val serviceUUID = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing serviceUUID"); return }
+                val charUUID = args.getOrNull(2)?.toString() ?: run { callback(null, "Missing charUUID"); return }
+                val dataBase64 = args.getOrNull(3)?.toString() ?: run { callback(null, "Missing data"); return }
+                writeCharacteristic(deviceId, serviceUUID, charUUID, dataBase64, callback)
+            }
+            "subscribeToCharacteristic" -> {
+                val deviceId = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing deviceId"); return }
+                val serviceUUID = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing serviceUUID"); return }
+                val charUUID = args.getOrNull(2)?.toString() ?: run { callback(null, "Missing charUUID"); return }
+                subscribeToCharacteristic(deviceId, serviceUUID, charUUID, callback)
+            }
+            "unsubscribeFromCharacteristic" -> {
+                val deviceId = args.getOrNull(0)?.toString() ?: run { callback(null, "Missing deviceId"); return }
+                val serviceUUID = args.getOrNull(1)?.toString() ?: run { callback(null, "Missing serviceUUID"); return }
+                val charUUID = args.getOrNull(2)?.toString() ?: run { callback(null, "Missing charUUID"); return }
+                unsubscribeFromCharacteristic(deviceId, serviceUUID, charUUID, callback)
+            }
+            "getState" -> {
+                val state = when {
+                    bluetoothAdapter == null -> "unsupported"
+                    bluetoothAdapter?.isEnabled != true -> "poweredOff"
+                    else -> "poweredOn"
+                }
+                callback(state, null)
+            }
+            else -> callback(null, "Unknown method: $method")
+        }
+    }
+
+    private fun hasBluetoothPermission(): Boolean {
+        val ctx = context ?: return false
+        return if (Build.VERSION.SDK_INT >= 31) {
+            ContextCompat.checkSelfPermission(ctx, Manifest.permission.BLUETOOTH_SCAN) == PackageManager.PERMISSION_GRANTED &&
+            ContextCompat.checkSelfPermission(ctx, Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED
+        } else {
+            ContextCompat.checkSelfPermission(ctx, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
+        }
+    }
+
+    @Suppress("MissingPermission")
+    private fun startScan(serviceUUIDs: List<String>?) {
+        val filters = serviceUUIDs?.map { uuid ->
+            ScanFilter.Builder().setServiceUuid(android.os.ParcelUuid(UUID.fromString(uuid))).build()
+        }
+        val settings = ScanSettings.Builder()
+            .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+            .build()
+        scanner?.startScan(filters, settings, scanCallback)
+    }
+
+    @Suppress("MissingPermission")
+    private fun stopScan() {
+        scanner?.stopScan(scanCallback)
+    }
+
+    @Suppress("MissingPermission")
+    private fun connect(deviceId: String, callback: (Any?, String?) -> Unit) {
+        val device = discoveredDevices[deviceId]
+        if (device == null) {
+            callback(null, "Device not found: $deviceId")
+            return
+        }
+        connectCallbacks[deviceId] = callback
+        device.connectGatt(context, false, gattCallback)
+    }
+
+    @Suppress("MissingPermission")
+    private fun disconnect(deviceId: String, callback: (Any?, String?) -> Unit) {
+        val gatt = gattConnections[deviceId]
+        if (gatt == null) {
+            callback(null, "Device not connected: $deviceId")
+            return
+        }
+        gatt.disconnect()
+        gatt.close()
+        gattConnections.remove(deviceId)
+        callback(null, null)
+    }
+
+    @Suppress("MissingPermission")
+    private fun readCharacteristic(deviceId: String, serviceUUID: String, charUUID: String, callback: (Any?, String?) -> Unit) {
+        val gatt = gattConnections[deviceId] ?: run { callback(null, "Device not connected"); return }
+        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run { callback(null, "Characteristic not found"); return }
+        val key = "$deviceId:$serviceUUID:$charUUID"
+        readCallbacks[key] = callback
+        gatt.readCharacteristic(char)
+    }
+
+    @Suppress("MissingPermission")
+    private fun writeCharacteristic(deviceId: String, serviceUUID: String, charUUID: String, dataBase64: String, callback: (Any?, String?) -> Unit) {
+        val gatt = gattConnections[deviceId] ?: run { callback(null, "Device not connected"); return }
+        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run { callback(null, "Characteristic not found"); return }
+        val data = Base64.decode(dataBase64, Base64.DEFAULT)
+        val key = "$deviceId:$serviceUUID:$charUUID"
+        writeCallbacks[key] = callback
+        char.value = data
+        gatt.writeCharacteristic(char)
+    }
+
+    @Suppress("MissingPermission")
+    private fun subscribeToCharacteristic(deviceId: String, serviceUUID: String, charUUID: String, callback: (Any?, String?) -> Unit) {
+        val gatt = gattConnections[deviceId] ?: run { callback(null, "Device not connected"); return }
+        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run { callback(null, "Characteristic not found"); return }
+        gatt.setCharacteristicNotification(char, true)
+        val descriptor = char.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"))
+        descriptor?.let {
+            it.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+            gatt.writeDescriptor(it)
+        }
+        callback(null, null)
+    }
+
+    @Suppress("MissingPermission")
+    private fun unsubscribeFromCharacteristic(deviceId: String, serviceUUID: String, charUUID: String, callback: (Any?, String?) -> Unit) {
+        val gatt = gattConnections[deviceId] ?: run { callback(null, "Device not connected"); return }
+        val char = findCharacteristic(gatt, serviceUUID, charUUID) ?: run { callback(null, "Characteristic not found"); return }
+        gatt.setCharacteristicNotification(char, false)
+        callback(null, null)
+    }
+
+    private fun findCharacteristic(gatt: BluetoothGatt, serviceUUID: String, charUUID: String): BluetoothGattCharacteristic? {
+        val service = gatt.getService(UUID.fromString(serviceUUID)) ?: return null
+        return service.getCharacteristic(UUID.fromString(charUUID))
+    }
+
+    private val scanCallback = object : ScanCallback() {
+        override fun onScanResult(callbackType: Int, result: ScanResult) {
+            val device = result.device
+            @Suppress("MissingPermission")
+            val name = device.name ?: ""
+            val id = device.address
+            discoveredDevices[id] = device
+            mainHandler.post {
+                bridge?.dispatchGlobalEvent("ble:deviceFound", mapOf(
+                    "id" to id,
+                    "name" to name,
+                    "rssi" to result.rssi,
+                ))
+            }
+        }
+    }
+
+    private val gattCallback = object : BluetoothGattCallback() {
+        @Suppress("MissingPermission")
+        override fun onConnectionStateChange(gatt: BluetoothGatt, status: Int, newState: Int) {
+            val deviceId = gatt.device.address
+            mainHandler.post {
+                when (newState) {
+                    BluetoothProfile.STATE_CONNECTED -> {
+                        gattConnections[deviceId] = gatt
+                        gatt.discoverServices()
+                        val payload = mapOf("id" to deviceId, "name" to (gatt.device.name ?: ""))
+                        bridge?.dispatchGlobalEvent("ble:connected", payload)
+                        connectCallbacks.remove(deviceId)?.invoke(payload, null)
+                    }
+                    BluetoothProfile.STATE_DISCONNECTED -> {
+                        gattConnections.remove(deviceId)
+                        gatt.close()
+                        bridge?.dispatchGlobalEvent("ble:disconnected", mapOf("id" to deviceId))
+                    }
+                }
+            }
+        }
+
+        override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
+            // Services are now available for read/write/subscribe
+        }
+
+        override fun onCharacteristicRead(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) {
+            val deviceId = gatt.device.address
+            val serviceUUID = characteristic.service.uuid.toString()
+            val charUUID = characteristic.uuid.toString()
+            val key = "$deviceId:$serviceUUID:$charUUID"
+            val valueBase64 = Base64.encodeToString(characteristic.value ?: ByteArray(0), Base64.NO_WRAP)
+            mainHandler.post {
+                val cb = readCallbacks.remove(key)
+                if (status == BluetoothGatt.GATT_SUCCESS) {
+                    cb?.invoke(mapOf(
+                        "value" to valueBase64,
+                        "characteristicUUID" to charUUID,
+                        "serviceUUID" to serviceUUID,
+                    ), null)
+                } else {
+                    cb?.invoke(null, "Read failed with status: $status")
+                }
+            }
+        }
+
+        override fun onCharacteristicWrite(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) {
+            val deviceId = gatt.device.address
+            val serviceUUID = characteristic.service.uuid.toString()
+            val charUUID = characteristic.uuid.toString()
+            val key = "$deviceId:$serviceUUID:$charUUID"
+            mainHandler.post {
+                val cb = writeCallbacks.remove(key)
+                if (status == BluetoothGatt.GATT_SUCCESS) {
+                    cb?.invoke(null, null)
+                } else {
+                    cb?.invoke(null, "Write failed with status: $status")
+                }
+            }
+        }
+
+        override fun onCharacteristicChanged(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic) {
+            val deviceId = gatt.device.address
+            val serviceUUID = characteristic.service.uuid.toString()
+            val charUUID = characteristic.uuid.toString()
+            val valueBase64 = Base64.encodeToString(characteristic.value ?: ByteArray(0), Base64.NO_WRAP)
+            mainHandler.post {
+                bridge?.dispatchGlobalEvent("ble:characteristicChanged", mapOf(
+                    "deviceId" to deviceId,
+                    "serviceUUID" to serviceUUID,
+                    "characteristicUUID" to charUUID,
+                    "value" to valueBase64,
+                ))
+            }
+        }
+    }
+
+    override fun destroy() {
+        @Suppress("MissingPermission")
+        scanner?.stopScan(scanCallback)
+        gattConnections.values.forEach {
+            @Suppress("MissingPermission")
+            it.disconnect()
+            it.close()
+        }
+        gattConnections.clear()
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/CalendarModule.kt

@@ -0,0 +1,198 @@
+package com.vuenative.core
+
+import android.Manifest
+import android.content.ContentValues
+import android.content.Context
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.provider.CalendarContract
+import androidx.core.content.ContextCompat
+
+class CalendarModule : NativeModule {
+    override val moduleName = "Calendar"
+
+    private var context: Context? = null
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        this.context = context.applicationContext
+    }
+
+    override fun invoke(method: String, args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
+        val ctx = context ?: run { callback(null, "Not initialized"); return }
+
+        when (method) {
+            "requestAccess" -> {
+                val granted = ContextCompat.checkSelfPermission(ctx, Manifest.permission.READ_CALENDAR) ==
+                    PackageManager.PERMISSION_GRANTED
+                callback(mapOf("granted" to granted), null)
+            }
+
+            "getEvents" -> {
+                val startMs = (args.getOrNull(0) as? Number)?.toLong() ?: run {
+                    callback(null, "Missing startDate"); return
+                }
+                val endMs = (args.getOrNull(1) as? Number)?.toLong() ?: run {
+                    callback(null, "Missing endDate"); return
+                }
+
+                if (!hasCalendarReadPermission(ctx)) {
+                    callback(null, "Calendar read permission not granted"); return
+                }
+
+                try {
+                    val events = mutableListOf<Map<String, Any?>>()
+                    val projection = arrayOf(
+                        CalendarContract.Events._ID,
+                        CalendarContract.Events.TITLE,
+                        CalendarContract.Events.DTSTART,
+                        CalendarContract.Events.DTEND,
+                        CalendarContract.Events.ALL_DAY,
+                        CalendarContract.Events.CALENDAR_ID,
+                        CalendarContract.Events.DESCRIPTION,
+                        CalendarContract.Events.EVENT_LOCATION,
+                    )
+                    val selection = "${CalendarContract.Events.DTSTART} >= ? AND ${CalendarContract.Events.DTEND} <= ?"
+                    val selectionArgs = arrayOf(startMs.toString(), endMs.toString())
+
+                    ctx.contentResolver.query(
+                        CalendarContract.Events.CONTENT_URI,
+                        projection, selection, selectionArgs, "${CalendarContract.Events.DTSTART} ASC"
+                    )?.use { cursor ->
+                        while (cursor.moveToNext()) {
+                            events.add(mapOf(
+                                "id" to cursor.getLong(0).toString(),
+                                "title" to (cursor.getString(1) ?: ""),
+                                "startDate" to cursor.getLong(2),
+                                "endDate" to cursor.getLong(3),
+                                "isAllDay" to (cursor.getInt(4) == 1),
+                                "calendarId" to cursor.getLong(5).toString(),
+                                "notes" to (cursor.getString(6) ?: ""),
+                                "location" to (cursor.getString(7) ?: ""),
+                            ))
+                        }
+                    }
+                    callback(events, null)
+                } catch (e: Exception) {
+                    callback(null, e.message)
+                }
+            }
+
+            "createEvent" -> {
+                val title = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing title"); return
+                }
+                val startMs = (args.getOrNull(1) as? Number)?.toLong() ?: run {
+                    callback(null, "Missing startDate"); return
+                }
+                val endMs = (args.getOrNull(2) as? Number)?.toLong() ?: run {
+                    callback(null, "Missing endDate"); return
+                }
+                val notes = args.getOrNull(3)?.toString()
+                val calendarId = args.getOrNull(4)?.toString()
+
+                if (!hasCalendarWritePermission(ctx)) {
+                    callback(null, "Calendar write permission not granted"); return
+                }
+
+                try {
+                    val values = ContentValues().apply {
+                        put(CalendarContract.Events.TITLE, title)
+                        put(CalendarContract.Events.DTSTART, startMs)
+                        put(CalendarContract.Events.DTEND, endMs)
+                        put(CalendarContract.Events.EVENT_TIMEZONE, java.util.TimeZone.getDefault().id)
+                        if (notes != null) put(CalendarContract.Events.DESCRIPTION, notes)
+                        if (calendarId != null) {
+                            put(CalendarContract.Events.CALENDAR_ID, calendarId.toLong())
+                        } else {
+                            put(CalendarContract.Events.CALENDAR_ID, getDefaultCalendarId(ctx))
+                        }
+                    }
+                    val uri: Uri? = ctx.contentResolver.insert(CalendarContract.Events.CONTENT_URI, values)
+                    val eventId = uri?.lastPathSegment ?: ""
+                    callback(mapOf("eventId" to eventId), null)
+                } catch (e: Exception) {
+                    callback(null, e.message)
+                }
+            }
+
+            "deleteEvent" -> {
+                val eventId = args.getOrNull(0)?.toString() ?: run {
+                    callback(null, "Missing eventId"); return
+                }
+
+                if (!hasCalendarWritePermission(ctx)) {
+                    callback(null, "Calendar write permission not granted"); return
+                }
+
+                try {
+                    val uri = CalendarContract.Events.CONTENT_URI.buildUpon().appendPath(eventId).build()
+                    ctx.contentResolver.delete(uri, null, null)
+                    callback(null, null)
+                } catch (e: Exception) {
+                    callback(null, e.message)
+                }
+            }
+
+            "getCalendars" -> {
+                if (!hasCalendarReadPermission(ctx)) {
+                    callback(null, "Calendar read permission not granted"); return
+                }
+
+                try {
+                    val calendars = mutableListOf<Map<String, Any?>>()
+                    val projection = arrayOf(
+                        CalendarContract.Calendars._ID,
+                        CalendarContract.Calendars.CALENDAR_DISPLAY_NAME,
+                        CalendarContract.Calendars.CALENDAR_COLOR,
+                        CalendarContract.Calendars.ACCOUNT_TYPE,
+                    )
+                    ctx.contentResolver.query(
+                        CalendarContract.Calendars.CONTENT_URI,
+                        projection, null, null, null
+                    )?.use { cursor ->
+                        while (cursor.moveToNext()) {
+                            val color = cursor.getInt(2)
+                            calendars.add(mapOf(
+                                "id" to cursor.getLong(0).toString(),
+                                "title" to (cursor.getString(1) ?: ""),
+                                "color" to String.format("#%06X", 0xFFFFFF and color),
+                                "type" to (cursor.getString(3) ?: "local"),
+                            ))
+                        }
+                    }
+                    callback(calendars, null)
+                } catch (e: Exception) {
+                    callback(null, e.message)
+                }
+            }
+
+            else -> callback(null, "Unknown method: $method")
+        }
+    }
+
+    private fun hasCalendarReadPermission(ctx: Context): Boolean =
+        ContextCompat.checkSelfPermission(ctx, Manifest.permission.READ_CALENDAR) == PackageManager.PERMISSION_GRANTED
+
+    private fun hasCalendarWritePermission(ctx: Context): Boolean =
+        ContextCompat.checkSelfPermission(ctx, Manifest.permission.WRITE_CALENDAR) == PackageManager.PERMISSION_GRANTED
+
+    private fun getDefaultCalendarId(ctx: Context): Long {
+        ctx.contentResolver.query(
+            CalendarContract.Calendars.CONTENT_URI,
+            arrayOf(CalendarContract.Calendars._ID),
+            "${CalendarContract.Calendars.IS_PRIMARY} = 1",
+            null, null
+        )?.use { cursor ->
+            if (cursor.moveToFirst()) return cursor.getLong(0)
+        }
+        // Fallback: first available calendar
+        ctx.contentResolver.query(
+            CalendarContract.Calendars.CONTENT_URI,
+            arrayOf(CalendarContract.Calendars._ID),
+            null, null, null
+        )?.use { cursor ->
+            if (cursor.moveToFirst()) return cursor.getLong(0)
+        }
+        return 1L
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/CameraModule.kt

@@ -0,0 +1,64 @@
+package com.vuenative.core
+
+import android.content.Context
+
+/**
+ * CameraModule — backs the useCamera() composable.
+ *
+ * Camera capture (launchCamera, launchImageLibrary, captureVideo) requires Activity-level
+ * startActivityForResult / registerForActivityResult hook. This stub ensures
+ * the module exists so JS composables can import it without crashing.
+ *
+ * QR code scanning is implemented using the device camera and ZXing/ML Kit
+ * when available. The host Activity must provide the implementation.
+ *
+ * To enable camera in your app:
+ * 1. Override onActivityResult in your VueNativeActivity subclass.
+ * 2. Register a concrete CameraModule implementation that stores the Activity reference.
+ *
+ * Methods:
+ *   - launchCamera(options)       -- photo capture
+ *   - launchImageLibrary(options) -- photo picker
+ *   - captureVideo(options)       -- video capture with options: quality, maxDuration, frontCamera
+ *   - scanQRCode()                -- start QR code scanning, emits camera:qrDetected events
+ *   - stopQRScan()                -- stop QR code scanning
+ */
+class CameraModule : NativeModule {
+    override val moduleName = "Camera"
+    private var bridge: NativeBridge? = null
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        this.bridge = bridge
+    }
+
+    override fun invoke(
+        method: String,
+        args: List<Any?>,
+        bridge: NativeBridge,
+        callback: (Any?, String?) -> Unit
+    ) {
+        when (method) {
+            "launchCamera", "launchImageLibrary", "captureVideo" -> {
+                callback(
+                    null,
+                    "Camera.$method requires Activity integration. " +
+                    "Register a CameraModule subclass with your VueNativeActivity that " +
+                    "implements $method via registerForActivityResult."
+                )
+            }
+            "scanQRCode" -> {
+                callback(
+                    null,
+                    "Camera.scanQRCode requires Activity integration and ML Kit dependency. " +
+                    "Add com.google.mlkit:barcode-scanning to your app's build.gradle and " +
+                    "register a CameraModule subclass that implements QR scanning."
+                )
+            }
+            "stopQRScan" -> {
+                // No-op in stub
+                callback(null, null)
+            }
+            else -> callback(null, "Unknown Camera method: $method")
+        }
+    }
+}

package/native/android/VueNativeCore/src/main/kotlin/com/vuenative/core/Modules/ClipboardModule.kt

@@ -0,0 +1,36 @@
+package com.vuenative.core
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+
+class ClipboardModule : NativeModule {
+    override val moduleName = "Clipboard"
+    private var clipboard: ClipboardManager? = null
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
+    }
+
+    override fun invoke(method: String, args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
+        val cb = clipboard ?: run { callback(null, "Clipboard not available"); return }
+        when (method) {
+            "setString", "setContent" -> {
+                val text = args.getOrNull(0)?.toString() ?: ""
+                cb.setPrimaryClip(ClipData.newPlainText("VueNative", text))
+                callback(null, null)
+            }
+            "getString", "getContent" -> {
+                val clip = cb.primaryClip
+                val text = if (clip != null && clip.itemCount > 0) {
+                    clip.getItemAt(0)?.text?.toString()
+                } else null
+                callback(text, null)
+            }
+            "hasString" -> {
+                callback(cb.hasPrimaryClip(), null)
+            }
+            else -> callback(null, "Unknown method: $method")
+        }
+    }
+}