vaderjs-native 1.0.10 → 1.0.11

package/app-template/app/src/main/java/myapp/MainActivity.kt

@@ -1,24 +1,34 @@
 package com.example.myapplication
-import androidx.activity.OnBackPressedCallback
 
+import android.app.AlertDialog
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.pm.PackageManager
 import android.os.Bundle
 import android.os.Message
 import android.view.KeyEvent
 import android.webkit.JavascriptInterface
+import android.webkit.WebChromeClient
 import android.webkit.WebView
 import android.webkit.WebViewClient
-import android.webkit.WebChromeClient
 import android.widget.Toast
 import androidx.activity.ComponentActivity
+import androidx.activity.OnBackPressedCallback
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import org.json.JSONArray
+import java.io.FileNotFoundException
 import java.net.HttpURLConnection
 import java.net.URL
 
 class MainActivity : ComponentActivity() {
+
     lateinit var webView: WebView
+    lateinit var androidBridge: AndroidBridge
 
-    private var baseUrl =  "file:///android_asset/myapp/"
+    private val baseUrl = "file:///android_asset/myapp/index.html"
+
+    @SuppressLint("SetJavaScriptEnabled", "AddJavascriptInterface")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
@@ -26,63 +36,95 @@ class MainActivity : ComponentActivity() {
         setContentView(webView)
 
         // --- WebView Settings ---
-        val settings = webView.settings
-        settings.javaScriptEnabled = true
-        settings.allowFileAccess = true
-        settings.allowContentAccess = true
-        settings.allowFileAccessFromFileURLs = true
-        settings.allowUniversalAccessFromFileURLs = true
-        settings.domStorageEnabled = true
-        settings.mediaPlaybackRequiresUserGesture = false
+        webView.settings.apply {
+            javaScriptEnabled = true
+            allowFileAccess = true
+            allowContentAccess = true
+            allowFileAccessFromFileURLs = true
+            allowUniversalAccessFromFileURLs = true
+            domStorageEnabled = true
+            databaseEnabled = true
+            mediaPlaybackRequiresUserGesture = false
+
+            // Basic compatibility settings
+            setSupportMultipleWindows(false)
+            loadWithOverviewMode = true
+            useWideViewPort = true
+            builtInZoomControls = true
+            displayZoomControls = false
+            setSupportZoom(true)
+
+            // Performance optimizations
+            javaScriptCanOpenWindowsAutomatically = false
+            loadsImagesAutomatically = true
+        }
+
         webView.isFocusable = true
         webView.isFocusableInTouchMode = true
         webView.requestFocus()
-        // --- WebViewClient to block external URLs ---
+
+        // --- JS Bridge ---
+        androidBridge = AndroidBridge(this, webView, baseUrl)
+        webView.addJavascriptInterface(androidBridge, "Android")
+
+        // --- WebViewClient ---
         webView.webViewClient = object : WebViewClient() {
+
             override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
-                if (url != null && url.startsWith("file:///android_asset/myapp/")) {
-                    return false
+                return if (url != null && url.startsWith(baseUrl)) {
+                    false
+                } else {
+                    Toast.makeText(
+                        this@MainActivity,
+                        "Blocked external navigation",
+                        Toast.LENGTH_SHORT
+                    ).show()
+                    true
                 }
-                Toast.makeText(this@MainActivity, "Blocked external navigation", Toast.LENGTH_SHORT)
-                    .show()
-                return true
+            }
+
+            override fun onPageFinished(view: WebView?, url: String?) {
+                view?.evaluateJavascript(
+                    "console.log('Android bridge ready:', !!window.Android)",
+                    null
+                )
             }
         }
 
-        // --- Optional WebChromeClient for popups ---
+        // --- Block popups ---
         webView.webChromeClient = object : WebChromeClient() {
             override fun onCreateWindow(
                 view: WebView?,
                 isDialog: Boolean,
                 isUserGesture: Boolean,
                 resultMsg: Message?
-            ): Boolean {
-                // Block popups completely
-                return false
-            }
+            ): Boolean = false
         }
 
-        // --- Add JS bridge ---
-        webView.addJavascriptInterface(AndroidBridge(this, webView, baseUrl), "Android")
+        // --- Back button → JS ---
         onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
-                // Forward back key to JS
                 webView.evaluateJavascript(
-                    "(function(){if(window.onNativeKey){window.onNativeKey(4);}})()",
+                    "window.onNativeKey && window.onNativeKey(4)",
                     null
                 )
-                // Do NOT call super, JS will handle closing modals/player
             }
         })
-        webView.webViewClient = object : WebViewClient() {
-            override fun onPageFinished(view: WebView?, url: String?) {
-                view?.evaluateJavascript("console.log('JS ready')", null)
-            }
-        }
-        // --- Load local HTML ---
+
         webView.loadUrl(baseUrl)
     }
 
+    // --- Permission result forwarding ---
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        androidBridge.onPermissionResult(requestCode, grantResults)
+    }
+
+    // --- DPAD / media keys ---
     @SuppressLint("RestrictedApi")
     override fun dispatchKeyEvent(event: KeyEvent): Boolean {
         if (event.action == KeyEvent.ACTION_DOWN) {
@@ -102,7 +144,6 @@ class MainActivity : ComponentActivity() {
                     }
                     true
                 }
-
                 else -> false
             }
             if (handled) return true
@@ -111,13 +152,164 @@ class MainActivity : ComponentActivity() {
     }
 }
 
-    class AndroidBridge(private val context: Context, private val webView: WebView, private val baseUrl: String) {
+// ---------------- JS BRIDGE ----------------
+
+class AndroidBridge(
+    private val activity: ComponentActivity,
+    private val webView: WebView,
+    private val baseUrl: String
+) {
+
+    private val PERMISSION_REQUEST_CODE = 9001
 
+    // ---- Toast ----
     @JavascriptInterface
     fun showToast(message: String) {
-        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
+        activity.runOnUiThread {
+            Toast.makeText(activity, message, Toast.LENGTH_SHORT).show()
+        }
     }
 
+   // ---- File System Methods ----
+@JavascriptInterface
+fun writeFile(path: String, content: String): Boolean {
+    return try {
+        // Create directories if needed
+        val file = File(activity.filesDir, path)
+        file.parentFile?.mkdirs()
+        
+        file.bufferedWriter().use { writer ->
+            writer.write(content)
+        }
+        true
+    } catch (e: Exception) {
+        e.printStackTrace()
+        false
+    }
+}
+
+@JavascriptInterface
+fun readFile(path: String): String {
+    return try {
+        val file = File(activity.filesDir, path)
+        if (!file.exists()) {
+            return "{\"error\":\"File not found\"}"
+        }
+        file.bufferedReader().use { it.readText() }
+    } catch (e: Exception) {
+        e.printStackTrace()
+        "{\"error\":\"${e.message}\"}"
+    }
+}
+
+@JavascriptInterface
+fun deleteFile(path: String): Boolean {
+    return try {
+        val file = File(activity.filesDir, path)
+        file.delete()
+    } catch (e: Exception) {
+        e.printStackTrace()
+        false
+    }
+}
+
+@JavascriptInterface
+fun listFiles(path: String = ""): String {
+    return try {
+        val dir = File(activity.filesDir, path)
+        val files = if (dir.exists() && dir.isDirectory) {
+            dir.list()?.toList() ?: emptyList()
+        } else {
+            emptyList()
+        }
+        JSONArray(files).toString()
+    } catch (e: Exception) {
+        e.printStackTrace()
+        "[]"
+    }
+}
+ 
+    // ---- Permissions ----
+    @JavascriptInterface
+    fun hasPermission(name: String): Boolean {
+        val permissions = mapPermission(name)
+        return permissions.all {
+            ContextCompat.checkSelfPermission(activity, it) ==
+                    PackageManager.PERMISSION_GRANTED
+        }
+    }
+
+    @JavascriptInterface
+    fun requestPermission(name: String) {
+        val permissions = mapPermission(name)
+
+        if (permissions.isEmpty()) {
+            sendPermissionResult(true)
+            return
+        }
+
+        val granted = permissions.all {
+            ContextCompat.checkSelfPermission(activity, it) ==
+                    PackageManager.PERMISSION_GRANTED
+        }
+
+        if (granted) {
+            sendPermissionResult(true)
+            return
+        }
+
+        ActivityCompat.requestPermissions(
+            activity,
+            permissions,
+            PERMISSION_REQUEST_CODE
+        )
+    }
+
+    fun onPermissionResult(requestCode: Int, grantResults: IntArray) {
+        if (requestCode != PERMISSION_REQUEST_CODE) return
+        val granted = grantResults.all { it == PackageManager.PERMISSION_GRANTED }
+        sendPermissionResult(granted)
+    }
+
+    private fun sendPermissionResult(granted: Boolean) {
+        webView.post {
+            webView.evaluateJavascript(
+                "window.onNativePermissionResult && window.onNativePermissionResult($granted)",
+                null
+            )
+        }
+    }
+
+    // ---- Dialog ----
+    @JavascriptInterface
+    fun showDialog(
+        title: String,
+        message: String,
+        okText: String = "OK",
+        cancelText: String = "Cancel"
+    ) {
+        activity.runOnUiThread {
+            AlertDialog.Builder(activity)
+                .setTitle(title)
+                .setMessage(message)
+                .setPositiveButton(okText) { _, _ ->
+                    webView.evaluateJavascript(
+                        "window.onNativeDialogResult && window.onNativeDialogResult(true)",
+                        null
+                    )
+                }
+                .setNegativeButton(cancelText) { _, _ ->
+                    webView.evaluateJavascript(
+                        "window.onNativeDialogResult && window.onNativeDialogResult(false)",
+                        null
+                    )
+                }
+                .setCancelable(false)
+                .show()
+        }
+    }
+
+    // ---- Native fetch ----
     @JavascriptInterface
     fun nativeFetch(url: String, method: String): String {
         return try {
@@ -125,26 +317,35 @@ class MainActivity : ComponentActivity() {
             connection.requestMethod = method
             connection.connectTimeout = 5000
             connection.readTimeout = 5000
-
-            val responseText = connection.inputStream.bufferedReader().use { it.readText() }
+            val response = connection.inputStream.bufferedReader().use { it.readText() }
             connection.disconnect()
-            responseText
+            response
         } catch (e: Exception) {
-            "{\"error\": \"${e.message}\"}"
+            "{\"error\":\"${e.message}\"}"
         }
     }
 
-        @JavascriptInterface
-        fun navigate(path: String?) {
-            // Ensure path starts with a clean structure
-            val cleanPath = path?.trimStart('/') ?: ""
+    // ---- Navigation ----
+    @JavascriptInterface
+    fun navigate(path: String?) {
+        val clean = path?.trimStart('/') ?: ""
+        webView.post {
+            val finalUrl = "$baseUrl$clean/index.html".replace("//index", "/index")
+            webView.loadUrl(finalUrl)
+        }
+    }
 
-            webView.post {
-                // Concatenate the base (Dev or Prod) with the path
-                // Example Dev: http://192.168.1.x:3000/settings/index.html
-                // Example Prod: file:///android_asset/myapp/settings/index.html
-                val finalUrl = "${baseUrl}${cleanPath}/index.html".replace("//index", "/index")
-                webView.loadUrl(finalUrl)
-            }
+    // ---- Permission map ----
+    private fun mapPermission(name: String): Array<String> {
+        return when (name) {
+            "storage" -> arrayOf(
+                android.Manifest.permission.READ_EXTERNAL_STORAGE,
+                android.Manifest.permission.WRITE_EXTERNAL_STORAGE
+            )
+            "camera" -> arrayOf(android.Manifest.permission.CAMERA)
+            "microphone" -> arrayOf(android.Manifest.permission.RECORD_AUDIO)
+            "notifications" -> arrayOf(android.Manifest.permission.POST_NOTIFICATIONS)
+            else -> emptyArray()
         }
-}
+    }
+}

package/index.ts

@@ -1,4 +1,19 @@
-// Android key code to key mapping
+;(window as any).onNativeDialogResult = function (confirmed: boolean) {
+  if (dialogResolver) {
+    dialogResolver(confirmed);
+    dialogResolver = null;
+  }
+};
+
+/**
+ * Called by Android
+ */
+;(window as any).onNativePermissionResult = function (granted: boolean) {
+  if (permissionResolver) {
+    permissionResolver(granted);
+    permissionResolver = null;
+  }
+};
 const ANDROID_KEY_MAP: Record<number, string> = {
   19: "ArrowUp",    // DPAD_UP
   20: "ArrowDown",  // DPAD_DOWN
@@ -970,16 +985,335 @@ export function  Show({ when, children }: { when: boolean, children: VNode[] }):
    //@ts-ignore
   return when ? children : null;
 }
-export function showToast  (message: string, duration = 3000)   {
-  //@ts-ignore
-  if (window.Android && typeof window.Android.showToast === "function") {
-     //@ts-ignore
-    window.Android.showToast(message, duration);
-  } else {
-    console.log(`[showToast] ${message}`);
+/**
+ * @description Show toast allows you to invoke system level toast api to show data to user
+ * @param message 
+ * @param duration 
+ */
+export function showToast(message: string, duration = 3000) {
+  if (typeof window !== "undefined" && (window as any).Android?.showToast) {
+    console.log("[Vader] Android Toast");
+    (window as any).Android.showToast(message);
+    return;
+  }
+
+  // Web fallback
+  console.log("[Toast]", message);
+
+  const toast = document.createElement("div");
+  toast.textContent = message;
+  Object.assign(toast.style, {
+    position: "fixed",
+    bottom: "24px",
+    left: "50%",
+    transform: "translateX(-50%)",
+    background: "rgba(0,0,0,0.85)",
+    color: "white",
+    padding: "10px 14px",
+    borderRadius: "8px",
+    zIndex: 9999,
+    fontSize: "14px",
+  });
+
+  document.body.appendChild(toast);
+  setTimeout(() => toast.remove(), duration);
+}
+
+type PermissionName =
+  | "storage"
+  | "internet"
+  | "camera"
+  | "microphone"
+  | "notifications"; 
+
+let permissionResolver: ((granted: boolean) => void) | null = null;
+
+export function usePermission() {
+  const isAndroid =
+    typeof window !== "undefined" &&
+    (window as any).Android?.requestPermission;
+
+  function request(name: PermissionName): Promise<boolean> {
+    if (isAndroid) {
+      return new Promise<boolean>((resolve) => {
+        permissionResolver = resolve;
+        (window as any).Android.requestPermission(name);
+      });
+    }
+
+    // ---- Web fallback ----
+    console.warn(`[Permission] ${name} auto-granted on web`);
+    return Promise.resolve(true);
+  }
+
+  function has(name: PermissionName): Promise<boolean> {
+    if (isAndroid && (window as any).Android.hasPermission) {
+      return Promise.resolve(
+        (window as any).Android.hasPermission(name)
+      );
+    }
+    return Promise.resolve(true);
+  }
+
+  return {
+    request,
+    has,
+
+    // ergonomic helpers
+    storage: () => request("storage"),
+    camera: () => request("camera"),
+    microphone: () => request("microphone"),
+    notifications: () => request("notifications"),
+    internet: () => request("internet")
+  };
+}
+
+type FS = {
+  readFile(path: string): Promise<string>
+  writeFile(path: string, content: string): Promise<boolean>
+  deleteFile(path: string): Promise<boolean>
+  listDir(path: string): Promise<string[]>
+}
+
+export const FS: FS = {
+  async writeFile(path: string, content: string): Promise<boolean> {
+    try {
+      if (!window.Android) {
+        console.error('Android bridge not available')
+        return false
+      }
+      
+      // Call Android bridge method
+      const result = window.Android.writeFile(path, content)
+      return result === true || result === 'true'
+    } catch (error) {
+      console.error('Error writing file:', error)
+      return false
+    }
+  },
+
+  async readFile(path: string): Promise<string> {
+    try {
+      if (!window.Android) {
+        return JSON.stringify({ error: 'Android bridge not available' })
+      }
+      
+      const result = window.Android.readFile(path)
+      
+      // Handle both string and boolean returns
+      if (typeof result === 'boolean') {
+        return result ? 'true' : 'false'
+      }
+      
+      return result || ''
+    } catch (error) {
+      console.error('Error reading file:', error)
+      return JSON.stringify({ error: error.message })
+    }
+  },
+
+  async deleteFile(path: string): Promise<boolean> {
+    try {
+      if (!window.Android) {
+        console.error('Android bridge not available')
+        return false
+      }
+      
+      // Check if deleteFile method exists on Android bridge
+      if (typeof window.Android.deleteFile === 'function') {
+        const result = window.Android.deleteFile(path)
+        return result === true || result === 'true'
+      } else {
+        // Fallback: Try to write empty content
+        console.warn('deleteFile not available, using writeFile fallback')
+        return await this.writeFile(path, '')
+      }
+    } catch (error) {
+      console.error('Error deleting file:', error)
+      return false
+    }
+  },
+
+  async listDir(path: string = ''): Promise<string[]> {
+    try {
+      if (!window.Android) {
+        console.error('Android bridge not available')
+        return []
+      }
+      
+      // Check if listFiles method exists on Android bridge
+      if (typeof window.Android.listFiles === 'function') {
+        const result = window.Android.listFiles(path)
+        
+        // Parse JSON array from string
+        if (typeof result === 'string') {
+          try {
+            const parsed = JSON.parse(result)
+            return Array.isArray(parsed) ? parsed : []
+          } catch {
+            // If not JSON, return as single item array or empty
+            return result ? [result] : []
+          }
+        }
+        
+        // If result is already an array
+        if (Array.isArray(result)) {
+          return result
+        }
+        
+        return []
+      } else {
+        console.warn('listFiles not available on Android bridge')
+        return []
+      }
+    } catch (error) {
+      console.error('Error listing directory:', error)
+      return []
+    }
+  },
+
+  // Alias for backward compatibility
+  write(path: string, data: string): Promise<boolean> {
+    return this.writeFile(path, data)
+  },
+
+  read(path: string): Promise<string> {
+    return this.readFile(path)
   }
+}
+
+// TypeScript declarations for Android bridge
+declare global {
+  interface Window {
+    Android?: {
+      writeFile?: (path: string, content: string) => boolean | string
+      readFile?: (path: string) => string
+      deleteFile?: (path: string) => boolean | string
+      listFiles?: (path?: string) => string[] | string
+      // Other Android bridge methods...
+      showToast?: (message: string) => void
+      hasPermission?: (name: string) => boolean
+      requestPermission?: (name: string) => void
+      showDialog?: (title: string, message: string, okText?: string, cancelText?: string) => void
+      nativeFetch?: (url: string, method: string) => string
+      navigate?: (path: string) => void
+    }
+  }
+}
+
+// Utility functions for common operations
+export const FileSystem = {
+  // Save JSON data
+  async saveJSON(path: string, data: any): Promise<boolean> {
+    return await FS.writeFile(path, JSON.stringify(data, null, 2))
+  },
+
+  // Load JSON data
+  async loadJSON<T = any>(path: string): Promise<T | null> {
+    try {
+      const content = await FS.readFile(path)
+      if (!content || content.includes('error')) {
+        return null
+      }
+      return JSON.parse(content)
+    } catch (error) {
+      console.error('Error parsing JSON:', error)
+      return null
+    }
+  },
+
+  // Check if file exists
+  async exists(path: string): Promise<boolean> {
+    try {
+      const content = await FS.readFile(path)
+      return !content.includes('File not found') && !content.includes('error')
+    } catch {
+      return false
+    }
+  },
+
+  // Append to file
+  async appendFile(path: string, content: string): Promise<boolean> {
+    try {
+      const existing = await FS.readFile(path)
+      const newContent = existing + content
+      return await FS.writeFile(path, newContent)
+    } catch (error) {
+      console.error('Error appending to file:', error)
+      return false
+    }
+  },
+
+  // Create directory (by creating a dummy file)
+  async createDirectory(path: string): Promise<boolean> {
+    // Create a .nomedia file in the directory
+    const dirPath = path.endsWith('/') ? path : path + '/'
+    return await FS.writeFile(dirPath + '.nomedia', '')
+  }
+}
+type DialogOptions = {
+  title?: string;
+  message: string;
+  okText?: string;
+  cancelText?: string;
 };
 
+let dialogResolver: ((value: boolean) => void) | null = null;
+
+export function useDialog() {
+  // ---- ANDROID IMPLEMENTATION ----
+  if (typeof window !== "undefined" && (window as any).Android?.showDialog) {
+    return {
+      alert({ title = "", message, okText = "OK" }: DialogOptions) {
+        return new Promise<void>((resolve) => {
+          dialogResolver = () => resolve();
+
+          (window as any).Android.showDialog(
+            title,
+            message,
+            okText,
+            "" // no cancel
+          );
+        });
+      },
+
+      confirm({
+        title = "",
+        message,
+        okText = "OK",
+        cancelText = "Cancel",
+      }: DialogOptions) {
+        return new Promise<boolean>((resolve) => {
+          dialogResolver = resolve;
+
+          (window as any).Android.showDialog(
+            title,
+            message,
+            okText,
+            cancelText
+          );
+        });
+      },
+    };
+  }
+
+  // ---- WEB FALLBACK ----
+  return {
+    alert({ title = "", message }: DialogOptions) {
+      window.alert(title ? `${title}\n\n${message}` : message);
+      return Promise.resolve();
+    },
+
+    confirm({ title = "", message }: DialogOptions) {
+      const result = window.confirm(
+        title ? `${title}\n\n${message}` : message
+      );
+      return Promise.resolve(result);
+    },
+  };
+}
+
+
 /**
  * A React-like useRef hook for mutable references.
  * @template T

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vaderjs-native",
-    "version": "1.0.10",
+    "version": "1.0.11",
     "description": "Build Native Applications using Vaderjs framework.",
     "bin": {
         "vaderjs": "./main.ts"