@thelacanians/vue-native-cli 0.4.2 → 0.4.4

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

@@ -0,0 +1,193 @@
+package com.vuenative.core
+
+import android.content.Context
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import java.io.File
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+import android.util.Base64
+
+class FileSystemModule : NativeModule {
+    override val moduleName = "FileSystem"
+    private var appContext: Context? = null
+
+    private val client = OkHttpClient.Builder()
+        .connectTimeout(30, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .build()
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        appContext = context
+    }
+
+    override fun invoke(
+        method: String,
+        args: List<Any?>,
+        bridge: NativeBridge,
+        callback: (Any?, String?) -> Unit
+    ) {
+        when (method) {
+            "readFile" -> {
+                val path = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "readFile: missing path"); return }
+                val encoding = args.getOrNull(1)?.toString() ?: "utf8"
+                val file = File(path)
+                if (!file.exists()) {
+                    callback(null, "readFile: file not found at $path"); return
+                }
+                try {
+                    if (encoding == "base64") {
+                        val bytes = file.readBytes()
+                        callback(Base64.encodeToString(bytes, Base64.NO_WRAP), null)
+                    } else {
+                        callback(file.readText(Charsets.UTF_8), null)
+                    }
+                } catch (e: Exception) {
+                    callback(null, "readFile: ${e.message}")
+                }
+            }
+            "writeFile" -> {
+                val path = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "writeFile: missing path"); return }
+                val content = args.getOrNull(1)?.toString()
+                    ?: run { callback(null, "writeFile: missing content"); return }
+                val encoding = args.getOrNull(2)?.toString() ?: "utf8"
+                try {
+                    val file = File(path)
+                    file.parentFile?.mkdirs()
+                    if (encoding == "base64") {
+                        val bytes = Base64.decode(content, Base64.DEFAULT)
+                        file.writeBytes(bytes)
+                    } else {
+                        file.writeText(content, Charsets.UTF_8)
+                    }
+                    callback(null, null)
+                } catch (e: Exception) {
+                    callback(null, "writeFile: ${e.message}")
+                }
+            }
+            "deleteFile" -> {
+                val path = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "deleteFile: missing path"); return }
+                val file = File(path)
+                if (!file.exists()) {
+                    callback(null, "deleteFile: file not found at $path"); return
+                }
+                try {
+                    if (file.isDirectory) {
+                        file.deleteRecursively()
+                    } else {
+                        file.delete()
+                    }
+                    callback(null, null)
+                } catch (e: Exception) {
+                    callback(null, "deleteFile: ${e.message}")
+                }
+            }
+            "exists" -> {
+                val path = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "exists: missing path"); return }
+                callback(File(path).exists(), null)
+            }
+            "listDirectory" -> {
+                val path = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "listDirectory: missing path"); return }
+                val dir = File(path)
+                if (!dir.exists() || !dir.isDirectory) {
+                    callback(null, "listDirectory: not a directory at $path"); return
+                }
+                callback(dir.list()?.toList() ?: emptyList<String>(), null)
+            }
+            "downloadFile" -> {
+                val url = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "downloadFile: missing url"); return }
+                val destPath = args.getOrNull(1)?.toString()
+                    ?: run { callback(null, "downloadFile: missing destPath"); return }
+                val request = Request.Builder().url(url).build()
+                client.newCall(request).enqueue(object : okhttp3.Callback {
+                    override fun onFailure(call: okhttp3.Call, e: IOException) {
+                        callback(null, "downloadFile: ${e.message}")
+                    }
+                    override fun onResponse(call: okhttp3.Call, response: okhttp3.Response) {
+                        try {
+                            val bytes = response.body?.bytes()
+                                ?: run { callback(null, "downloadFile: empty response"); return }
+                            val file = File(destPath)
+                            file.parentFile?.mkdirs()
+                            file.writeBytes(bytes)
+                            callback(destPath, null)
+                        } catch (e: Exception) {
+                            callback(null, "downloadFile: ${e.message}")
+                        }
+                    }
+                })
+            }
+            "getDocumentsPath" -> {
+                val ctx = appContext
+                    ?: run { callback(null, "FileSystem not initialized"); return }
+                callback(ctx.filesDir.absolutePath, null)
+            }
+            "getCachesPath" -> {
+                val ctx = appContext
+                    ?: run { callback(null, "FileSystem not initialized"); return }
+                callback(ctx.cacheDir.absolutePath, null)
+            }
+            "stat" -> {
+                val path = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "stat: missing path"); return }
+                val file = File(path)
+                if (!file.exists()) {
+                    callback(null, "stat: file not found at $path"); return
+                }
+                callback(mapOf(
+                    "size" to file.length(),
+                    "isDirectory" to file.isDirectory,
+                    "modified" to file.lastModified()
+                ), null)
+            }
+            "mkdir" -> {
+                val path = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "mkdir: missing path"); return }
+                val dir = File(path)
+                if (dir.mkdirs() || dir.exists()) {
+                    callback(null, null)
+                } else {
+                    callback(null, "mkdir: could not create directory at $path")
+                }
+            }
+            "copyFile" -> {
+                val srcPath = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "copyFile: missing srcPath"); return }
+                val destPath = args.getOrNull(1)?.toString()
+                    ?: run { callback(null, "copyFile: missing destPath"); return }
+                try {
+                    val src = File(srcPath)
+                    val dest = File(destPath)
+                    dest.parentFile?.mkdirs()
+                    src.copyTo(dest, overwrite = true)
+                    callback(null, null)
+                } catch (e: Exception) {
+                    callback(null, "copyFile: ${e.message}")
+                }
+            }
+            "moveFile" -> {
+                val srcPath = args.getOrNull(0)?.toString()
+                    ?: run { callback(null, "moveFile: missing srcPath"); return }
+                val destPath = args.getOrNull(1)?.toString()
+                    ?: run { callback(null, "moveFile: missing destPath"); return }
+                try {
+                    val src = File(srcPath)
+                    val dest = File(destPath)
+                    dest.parentFile?.mkdirs()
+                    src.copyTo(dest, overwrite = true)
+                    src.delete()
+                    callback(null, null)
+                } catch (e: Exception) {
+                    callback(null, "moveFile: ${e.message}")
+                }
+            }
+            else -> callback(null, "Unknown method: $method")
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.vuenative.core
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import androidx.core.content.ContextCompat
+import com.google.android.gms.location.LocationServices
+import com.google.android.gms.location.FusedLocationProviderClient
+
+class GeolocationModule : NativeModule {
+    override val moduleName = "Geolocation"
+
+    private var fusedClient: FusedLocationProviderClient? = null
+    private var context: Context? = null
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        this.context = context
+        fusedClient = LocationServices.getFusedLocationProviderClient(context)
+    }
+
+    override fun invoke(
+        method: String,
+        args: List<Any?>,
+        bridge: NativeBridge,
+        callback: (Any?, String?) -> Unit
+    ) {
+        when (method) {
+            "getCurrentPosition" -> {
+                val ctx = context ?: run { callback(null, "Not initialized"); return }
+                if (ContextCompat.checkSelfPermission(ctx, Manifest.permission.ACCESS_FINE_LOCATION)
+                    != PackageManager.PERMISSION_GRANTED
+                ) {
+                    callback(null, "Location permission not granted. Request permission first.")
+                    return
+                }
+                fusedClient?.lastLocation
+                    ?.addOnSuccessListener { location ->
+                        if (location != null) {
+                            callback(
+                                mapOf(
+                                    "coords" to mapOf(
+                                        "latitude"  to location.latitude,
+                                        "longitude" to location.longitude,
+                                        "accuracy"  to location.accuracy.toDouble(),
+                                        "altitude"  to location.altitude,
+                                        "speed"     to location.speed.toDouble(),
+                                        "heading"   to location.bearing.toDouble()
+                                    ),
+                                    "timestamp" to location.time
+                                ), null
+                            )
+                        } else {
+                            callback(null, "Location unavailable — no last known position")
+                        }
+                    }
+                    ?.addOnFailureListener { e ->
+                        callback(null, e.message ?: "Location error")
+                    }
+            }
+            "requestAuthorization" -> {
+                // Authorization must be handled via PermissionsModule / Activity; signal success
+                // so composables can call getCurrentPosition without a separate step.
+                callback(mapOf("status" to "whenInUse"), null)
+            }
+            else -> callback(null, "Unknown method: $method")
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+package com.vuenative.core
+
+import android.content.Context
+import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
+
+class HapticsModule : NativeModule {
+    override val moduleName = "Haptics"
+    private var vibrator: Vibrator? = null
+
+    override fun initialize(context: Context, bridge: NativeBridge) {
+        vibrator = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val vm = context.getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
+            vm.defaultVibrator
+        } else {
+            @Suppress("DEPRECATION")
+            context.getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+        }
+    }
+
+    override fun invoke(method: String, args: List<Any?>, bridge: NativeBridge, callback: (Any?, String?) -> Unit) {
+        when (method) {
+            "vibrate", "impact" -> {
+                val style = args.getOrNull(0)?.toString() ?: "medium"
+                vibrate(style)
+                callback(null, null)
+            }
+            "selectionChanged" -> {
+                vibrate("light")
+                callback(null, null)
+            }
+            "notificationOccurred" -> {
+                val type = args.getOrNull(0)?.toString() ?: "success"
+                vibrate(type)
+                callback(null, null)
+            }
+            else -> callback(null, "Unknown method: $method")
+        }
+    }
+
+    private fun vibrate(style: String) {
+        val vib = vibrator ?: return
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val effect = when (style) {
+                "light"   -> VibrationEffect.createOneShot(30, 80)
+                "medium"  -> VibrationEffect.createOneShot(50, 150)
+                "heavy"   -> VibrationEffect.createOneShot(80, 200)
+                "success" -> VibrationEffect.createWaveform(longArrayOf(0, 50, 50, 50), intArrayOf(0, 180, 0, 100), -1)
+                "warning" -> VibrationEffect.createOneShot(100, 200)
+                "error"   -> VibrationEffect.createWaveform(longArrayOf(0, 100, 50, 100), intArrayOf(0, 255, 0, 255), -1)
+                else      -> VibrationEffect.createOneShot(50, 150)
+            }
+            vib.vibrate(effect)
+        } else {
+            @Suppress("DEPRECATION")
+            vib.vibrate(50)
+        }
+    }
+}

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

@@ -0,0 +1,111 @@
+package com.vuenative.core
+
+import okhttp3.CertificatePinner
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+
+/**
+ * HttpModule — backs the useHttp() composable.
+ * Provides a request() method that handles arbitrary HTTP calls from JS with
+ * support for baseURL, custom headers, all HTTP methods, and certificate pinning.
+ */
+class HttpModule : NativeModule {
+    override val moduleName = "Http"
+
+    /** Default client without certificate pinning. */
+    private val defaultClient = OkHttpClient.Builder()
+        .connectTimeout(30, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .writeTimeout(30, TimeUnit.SECONDS)
+        .build()
+
+    /** Client with certificate pinning — rebuilt when pins are configured. */
+    private var pinnedClient: OkHttpClient? = null
+
+    /** Current certificate pinner, if any. */
+    private var certificatePinner: CertificatePinner? = null
+
+    override fun invoke(
+        method: String,
+        args: List<Any?>,
+        bridge: NativeBridge,
+        callback: (Any?, String?) -> Unit
+    ) {
+        when (method) {
+            "configurePins" -> {
+                @Suppress("UNCHECKED_CAST")
+                val pinsMap = args.getOrNull(0) as? Map<String, List<String>>
+                    ?: run { callback(null, "Invalid args — expected pins object"); return }
+
+                val builder = CertificatePinner.Builder()
+                for ((domain, pins) in pinsMap) {
+                    for (pin in pins) {
+                        // OkHttp expects pins in "sha256/base64hash" format
+                        builder.add(domain, pin)
+                    }
+                }
+                certificatePinner = builder.build()
+                pinnedClient = defaultClient.newBuilder()
+                    .certificatePinner(certificatePinner!!)
+                    .build()
+                callback(true, null)
+            }
+            "request" -> {
+                val opts = args.getOrNull(0) as? Map<*, *>
+                    ?: run { callback(null, "Invalid args — expected options object"); return }
+
+                val url = opts["url"]?.toString()
+                    ?: run { callback(null, "Missing required field: url"); return }
+                val baseURL = opts["baseURL"]?.toString() ?: ""
+                val httpMethod = opts["method"]?.toString()?.uppercase() ?: "GET"
+                val body = opts["body"]?.toString() ?: ""
+                @Suppress("UNCHECKED_CAST")
+                val headers = opts["headers"] as? Map<String, String>
+
+                val fullUrl = if (url.startsWith("http")) url else "$baseURL$url"
+
+                val builder = Request.Builder().url(fullUrl)
+                headers?.forEach { (k, v) -> builder.addHeader(k, v) }
+
+                val contentType = headers?.get("Content-Type")
+                    ?: headers?.get("content-type")
+                    ?: "application/json"
+
+                val requestBody = when {
+                    body.isNotEmpty() -> body.toRequestBody(contentType.toMediaTypeOrNull())
+                    httpMethod != "GET" && httpMethod != "HEAD" -> "".toRequestBody()
+                    else -> null
+                }
+                builder.method(httpMethod, requestBody)
+
+                // Use pinned client when configured, otherwise default
+                val client = pinnedClient ?: defaultClient
+
+                client.newCall(builder.build()).enqueue(object : okhttp3.Callback {
+                    override fun onFailure(call: okhttp3.Call, e: IOException) {
+                        callback(null, e.message ?: "Network error")
+                    }
+
+                    override fun onResponse(call: okhttp3.Call, response: okhttp3.Response) {
+                        val responseBody = response.body?.string() ?: ""
+                        val responseHeaders = mutableMapOf<String, String>()
+                        response.headers.forEach { (k, v) -> responseHeaders[k] = v }
+                        callback(
+                            mapOf(
+                                "status"  to response.code,
+                                "ok"      to (response.code in 200..299),
+                                "data"    to responseBody,
+                                "headers" to responseHeaders
+                            ), null
+                        )
+                    }
+                })
+            }
+            else -> callback(null, "Unknown method: $method")
+        }
+    }
+}