html2apk 0.4.0 → 0.5.0

package/README.md

@@ -356,7 +356,7 @@ Retorno:
 
 A v0.1 instala um plugin Cordova local com uma API global simples para recursos Android. Todas as funcoes retornam `Promise`, exceto os ouvintes `aoEvento`/atalhos, que retornam uma funcao para cancelar a escuta.
 
-O html2apk injeta `cordova.js` automaticamente no HTML inicial do APK. Se uma funcao nativa for chamada antes do `deviceready`, a bridge espera o Android ficar pronto antes de executar.
+O html2apk injeta `html2apk-early-bridge.js` e `cordova.js` automaticamente no HTML inicial do APK. A bridge inicial cria as funcoes interpretadas antes dos scripts do seu projeto; se uma funcao nativa for chamada antes do `deviceready`, ela espera o Android ficar pronto antes de executar.
 
 Cada funcao em portugues tambem tem alias em ingles. A interface grafica mostra a sintaxe PT-BR quando o idioma esta em portugues e mostra a sintaxe em ingles quando o usuario troca o idioma para English.
 
@@ -418,18 +418,29 @@ No seu JavaScript do app:
 toast("Mensagem");
 vibrar(250);
 
+await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir o app"
+});
+
 notificar({
   titulo: "Pedido aprovado",
   texto: "Toque para abrir os detalhes",
   acoes: [
-    { id: "abrir", titulo: "Abrir" },
-    { id: "cancelar", titulo: "Cancelar" }
+    {
+      id: "abrir",
+      titulo: "Abrir",
+      open: true,
+      aoClicar: { funcao: "abrirNoApp", argumentos: ["#/pedido/123"] }
+    },
+    {
+      id: "site",
+      titulo: "Ver site",
+      open: false,
+      aoClicar: { funcao: "abrirForaDoApp", argumentos: ["https://exemplo.com/pedido/123"], open: false }
+    }
   ],
-  aoClicar: {
-    acao: "abrir-rota",
-    rota: "/pedido/123",
-    dados: { id: 123 }
-  }
+  aoClicar: () => abrirForaDoApp("https://exemplo.com/pedido/123")
 });
 
 agendarNotificacao({
@@ -437,8 +448,8 @@ agendarNotificacao({
   texto: "Hora de abrir o app",
   quando: Date.now() + 60000,
   aoClicar: {
-    acao: "abrir-rota",
-    rota: "/lembretes"
+    funcao: "abrirNoApp",
+    argumentos: ["#/lembretes"]
   }
 });
 
@@ -466,8 +477,75 @@ const loop = await agendarLoopNotificacoes({
 fullscreen(true);
 ```
 
+`notificar()` nao obriga clique, botao nem funcao. So `titulo` e `texto` ja geram uma notificacao normal. `aoClicar`, `acoes`/`actions` e `open` sao opcionais.
+
 `agendarNotificacao()` agenda uma notificacao. Se voce passar um array para ela, ou usar `agendarNotificacoes()`, o html2apk agenda varias em sequencia. Cada item recebe `id` automatico se voce nao informar um.
 
+Em `aoClicar`, voce pode passar uma funcao diretamente:
+
+```js
+await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir os detalhes",
+  aoClicar: () => abrirForaDoApp("https://exemplo.com/pedido/123")
+});
+```
+
+Nao use `aoClicar: { acao: abrirForaDoApp("https://...") }`, porque os parenteses executam a funcao na hora em que a notificacao e criada. Para notificacao agendada, loop ou app fechado, prefira o formato serializavel:
+
+```js
+await agendarNotificacao({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir os detalhes",
+  quando: Date.now() + 60000,
+  aoClicar: {
+    funcao: "abrirForaDoApp",
+    argumentos: ["https://exemplo.com/pedido/123"]
+  }
+});
+```
+
+Esse formato tambem aceita funcoes suas, desde que elas existam em `window` quando o app abrir:
+
+```js
+window.abrirPedido = (id) => abrirNoApp("#/pedido/" + id);
+
+await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir os detalhes",
+  aoClicar: { funcao: "abrirPedido", argumentos: [123] }
+});
+```
+
+Para botoes na notificacao, use `acoes` ou `actions`. Cada botao tambem aceita `aoClicar`/`onClick`:
+
+```js
+window.marcarPedidoLido = (id) => {
+  localStorage.setItem("pedido:" + id, "lido");
+};
+
+await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Escolha uma acao",
+  acoes: [
+    {
+      id: "abrir",
+      titulo: "Abrir",
+      open: true,
+      aoClicar: { funcao: "abrirNoApp", argumentos: ["#/pedido/123"] }
+    },
+    {
+      id: "lido",
+      titulo: "Marcar lido",
+      open: false,
+      aoClicar: { funcao: "marcarPedidoLido", argumentos: [123], open: false }
+    }
+  ]
+});
+```
+
+`open: false` evita trazer a tela do app para frente. Se o app ainda estiver vivo em segundo plano, o html2apk dispara o evento e executa a funcao JavaScript. Se o Android tiver matado o app, JavaScript de WebView nao consegue rodar sem abrir o app; nesse caso, acoes externas como `{ funcao: "abrirForaDoApp", argumentos: ["https://..."], open: false }` ainda funcionam por fallback nativo.
+
 `agendarLoopNotificacoes()` cria um loop recorrente que funciona com o app fechado. Use `aCada`, `intervalo`, `every` ou `interval` em milissegundos ou como texto (`"30min"`, `"12h"`, `"1d"`). A cada disparo, o Android mostra a proxima notificacao da lista. Para parar:
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "html2apk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Node CLI and library to turn an HTML/CSS/JS folder into an Android APK through Cordova.",
   "main": "index.js",
   "bin": {

package/src/core/build-apk.js

@@ -14,6 +14,7 @@ const { installBridgePlugin } = require("../bridge/install-bridge");
 const { getRuntimeEnvironment } = require("../runtime-manager");
 
 const AUTO_THEME_SCRIPT_NAME = "html2apk-auto-theme.js";
+const EARLY_BRIDGE_SCRIPT_NAME = "html2apk-early-bridge.js";
 const ONESIGNAL_SCRIPT_NAME = "html2apk-onesignal.js";
 const ONESIGNAL_PLUGIN_PACKAGE = "onesignal-cordova-plugin";
 const DEFAULT_APP_ICON_NAME = "html2apk.png";
@@ -63,19 +64,25 @@ function scriptTag(scriptPath) {
   return `<script src="${scriptPath}"></script>`;
 }
 
-async function injectCordovaRuntimeIntoHtml(htmlPath, scriptPath = "cordova.js") {
+async function injectCordovaRuntimeIntoHtml(htmlPath, scriptPath = "cordova.js", earlyBridgePath = EARLY_BRIDGE_SCRIPT_NAME) {
   let html = await fs.readFile(htmlPath, "utf8");
-  if (/<script\b[^>]*\bsrc=["'][^"']*cordova\.js["'][^>]*>/i.test(html)) {
+  const hasCordova = /<script\b[^>]*\bsrc=["'][^"']*cordova\.js["'][^>]*>/i.test(html);
+  const hasEarlyBridge = /<script\b[^>]*\bsrc=["'][^"']*html2apk-early-bridge\.js["'][^>]*>/i.test(html);
+  if (hasCordova && hasEarlyBridge) {
     return false;
   }
 
-  const tag = scriptTag(scriptPath);
+  const tags = [
+    hasEarlyBridge ? null : scriptTag(earlyBridgePath),
+    hasCordova ? null : scriptTag(scriptPath)
+  ].filter(Boolean).join("\n  ");
+
   if (/<head\b[^>]*>/i.test(html)) {
-    html = html.replace(/<head\b[^>]*>/i, (match) => `${match}\n  ${tag}`);
+    html = html.replace(/<head\b[^>]*>/i, (match) => `${match}\n  ${tags}`);
   } else if (/<html\b[^>]*>/i.test(html)) {
-    html = html.replace(/<html\b[^>]*>/i, (match) => `${match}\n  ${tag}`);
+    html = html.replace(/<html\b[^>]*>/i, (match) => `${match}\n  ${tags}`);
   } else {
-    html = `${tag}\n${html}`;
+    html = `${tags}\n${html}`;
   }
 
   await fs.writeFile(htmlPath, html, "utf8");
@@ -86,12 +93,16 @@ async function installCordovaRuntimeScript(buildDir, options) {
   const wwwDir = path.join(buildDir, "www");
   const entryHtmlPath = path.resolve(wwwDir, options.entryFile || "index.html");
   const scriptPath = toCordovaPath(path.relative(path.dirname(entryHtmlPath), path.join(wwwDir, "cordova.js"))) || "cordova.js";
+  const earlyBridgeSource = path.resolve(__dirname, "..", "templates", EARLY_BRIDGE_SCRIPT_NAME);
+  const earlyBridgeTarget = path.join(wwwDir, EARLY_BRIDGE_SCRIPT_NAME);
+  const earlyBridgePath = toCordovaPath(path.relative(path.dirname(entryHtmlPath), earlyBridgeTarget)) || EARLY_BRIDGE_SCRIPT_NAME;
 
   if (!isInside(wwwDir, entryHtmlPath)) {
     throw new Error(`Entry file must stay inside the Cordova www folder: ${options.entryFile}`);
   }
 
-  return injectCordovaRuntimeIntoHtml(entryHtmlPath, scriptPath);
+  await copyFile(earlyBridgeSource, earlyBridgeTarget);
+  return injectCordovaRuntimeIntoHtml(entryHtmlPath, scriptPath, earlyBridgePath);
 }
 
 async function injectScriptIntoHtml(htmlPath, scriptPath) {

package/src/desktop/renderer/renderer.js

@@ -391,11 +391,11 @@ const nativeCodeEntries = [
     handling: { pt: "Limite duracoes longas e deixe a permissao `VIBRATE` no app; se falhar, siga sem bloquear o fluxo principal.", en: "Keep long durations under control and include the `VIBRATE` permission; if it fails, continue without blocking the main flow." }
   },
   {
-    syntax: { pt: "notificar({ titulo, texto, acoes })", en: "notify({ title, text, actions })" },
+    syntax: { pt: "notificar({ titulo, texto, aoClicar?, acoes?, open? })", en: "notify({ title, text, onClick?, actions?, open? })" },
     java: "notify",
-    description: { pt: "Cria notificacao Android imediata. `acoes` ou `actions` viram botoes clicaveis.", en: "Creates an immediate Android notification. `actions` or `acoes` become clickable buttons." },
-    returns: { pt: "Promise<void>; cliques chegam em `aoEvento('notificacao:clicada')` ou `aoClicarNotificacao()`.", en: "Promise<void>; clicks arrive through `onEvent('notification:clicked')` or `onNotificationClick()`." },
-    handling: { pt: "Ao chamar, o html2apk pede permissao automaticamente no Android 13+. Se o Android nao puder mostrar o pop-up, ele abre as configuracoes e retorna `settingsOpened`.", en: "When called, html2apk automatically requests permission on Android 13+. If Android cannot show the prompt, it opens settings and returns `settingsOpened`." }
+    description: { pt: "Cria notificacao Android imediata. So `titulo` e `texto` ja bastam; `aoClicar`, `acoes` e `open` sao opcionais.", en: "Creates an immediate Android notification. `title` and `text` are enough; `onClick`, `actions` and `open` are optional." },
+    returns: { pt: "Promise<void>; cliques chegam em `aoEvento('notificacao:clicada')` ou `aoClicarNotificacao()` e tambem podem executar `aoClicar` automaticamente.", en: "Promise<void>; clicks arrive through `onEvent('notification:clicked')` or `onNotificationClick()` and can also run `onClick` automatically." },
+    handling: { pt: "Use `aoClicar: () => funcao()` enquanto o app esta vivo. Para agendada ou app fechado, prefira `aoClicar: { funcao, argumentos }`. `open:false` evita abrir a tela; JavaScript so roda assim se o app ainda estiver vivo, mas acoes externas como `abrirForaDoApp` funcionam por fallback nativo.", en: "Use `onClick: () => functionName()` while the app process is alive. For scheduled notifications or a closed app, prefer `onClick: { functionName, args }`. `open:false` avoids opening the screen; JavaScript only runs this way if the app is still alive, but external actions like `openOutsideApp` work through a native fallback." }
   },
   {
     syntax: { pt: "agendarNotificacao({ titulo, texto, quando }) / agendarNotificacoes([...])", en: "scheduleNotification({ title, text, when }) / scheduleNotifications([...])" },
@@ -409,7 +409,7 @@ const nativeCodeEntries = [
     java: "AlarmManager + NotificationStore",
     description: { pt: "Cria um loop de notificacoes que continua funcionando com o app fechado e alterna os itens da lista.", en: "Creates a notification loop that keeps working with the app closed and rotates through the list items." },
     returns: { pt: "{ id, when, repeating, loop }. Guarde o `id` para cancelar depois.", en: "{ id, when, repeating, loop }. Store the `id` to cancel later." },
-    handling: { pt: "Use `aoClicarNotificacao()` ou `aoEvento('notificacao:clicada')` para chamar funcoes conforme `aoClicar`. Cancele com `cancelarNotificacao(id)`.", en: "Use `onNotificationClick()` or `onEvent('notification:clicked')` to call functions from `onClick`. Cancel with `cancelNotification(id)`." }
+    handling: { pt: "Cancele com `cancelarNotificacao(id)`. Se o clique precisar chamar funcao automaticamente mesmo apos o Android reabrir o app, use `funcao` + `argumentos` no `aoClicar`.", en: "Cancel with `cancelNotification(id)`. If the click must call a function automatically after Android reopens the app, use `functionName` + `args` in `onClick`." }
   },
   {
     syntax: { pt: "solicitarPermissaoNotificacoes()", en: "requestNotificationPermission()" },
@@ -668,17 +668,102 @@ const nativeCodeRecipes = [
     }
   },
   {
-    when: { pt: "Para mostrar uma notificacao agora. A permissao aparece automaticamente se o Android exigir.", en: "To show a notification now. Permission appears automatically if Android requires it." },
+    when: { pt: "Para mostrar uma notificacao simples agora. `aoClicar`, `acoes` e `open` sao opcionais.", en: "To show a simple notification now. `onClick`, `actions` and `open` are optional." },
+    example: {
+      pt: `await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir o app"
+});`,
+      en: `await notify({
+  title: "Order approved",
+  text: "Tap to open the app"
+});`
+    }
+  },
+  {
+    when: { pt: "Para executar algo quando a notificacao for clicada.", en: "To run something when the notification is clicked." },
     example: {
       pt: `await notificar({
   titulo: "Pedido aprovado",
   texto: "Toque para abrir os detalhes",
-  aoClicar: { acao: "abrir-pedido", id: 123 }
+  aoClicar: () => abrirForaDoApp("https://exemplo.com/pedidos/123")
 });`,
       en: `await notify({
   title: "Order approved",
   text: "Tap to open details",
-  onClick: { action: "open-order", id: 123 }
+  onClick: () => openOutsideApp("https://example.com/orders/123")
+});`
+    }
+  },
+  {
+    when: { pt: "Para colocar botoes na notificacao, cada um chamando uma funcao.", en: "To add buttons to the notification, each one calling a function." },
+    example: {
+      pt: `window.marcarPedidoLido = (id) => {
+  localStorage.setItem("pedido:" + id, "lido");
+};
+
+await notificar({
+  titulo: "Pedido aprovado",
+  texto: "Escolha uma acao",
+  acoes: [
+    {
+      id: "abrir",
+      titulo: "Abrir",
+      open: true,
+      aoClicar: { funcao: "abrirNoApp", argumentos: ["#/pedido/123"] }
+    },
+    {
+      id: "lido",
+      titulo: "Marcar lido",
+      open: false,
+      aoClicar: { funcao: "marcarPedidoLido", argumentos: [123], open: false }
+    }
+  ]
+});`,
+      en: `window.markOrderRead = (id) => {
+  localStorage.setItem("order:" + id, "read");
+};
+
+await notify({
+  title: "Order approved",
+  text: "Choose an action",
+  actions: [
+    {
+      id: "open",
+      title: "Open",
+      open: true,
+      onClick: { functionName: "openInApp", args: ["#/order/123"] }
+    },
+    {
+      id: "read",
+      title: "Mark read",
+      open: false,
+      onClick: { functionName: "markOrderRead", args: [123], open: false }
+    }
+  ]
+});`
+    }
+  },
+  {
+    when: { pt: "Para clique de notificacao agendada ou com app fechado.", en: "For scheduled notification clicks or when the app is closed." },
+    example: {
+      pt: `await agendarNotificacao({
+  titulo: "Pedido aprovado",
+  texto: "Toque para abrir os detalhes",
+  quando: Date.now() + 60 * 1000,
+  aoClicar: {
+    funcao: "abrirForaDoApp",
+    argumentos: ["https://exemplo.com/pedidos/123"]
+  }
+});`,
+      en: `await scheduleNotification({
+  title: "Order approved",
+  text: "Tap to open details",
+  when: Date.now() + 60 * 1000,
+  onClick: {
+    functionName: "openOutsideApp",
+    args: ["https://example.com/orders/123"]
+  }
 });`
     }
   },

package/src/templates/cordova-plugin-html2apk-bridge/plugin.xml

@@ -27,6 +27,7 @@
     <config-file target="AndroidManifest.xml" parent="/manifest/application">
       <service android:name="dev.html2apk.bridge.FloatingIconService" android:exported="false" />
       <receiver android:name="dev.html2apk.bridge.NotificationReceiver" android:exported="false" />
+      <receiver android:name="dev.html2apk.bridge.NotificationClickReceiver" android:exported="false" />
       <receiver android:name="dev.html2apk.bridge.BootReceiver" android:enabled="true" android:exported="true">
         <intent-filter>
           <action android:name="android.intent.action.BOOT_COMPLETED" />
@@ -38,6 +39,7 @@
     <source-file src="src/android/Html2ApkBridge.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
     <source-file src="src/android/FloatingIconService.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
     <source-file src="src/android/NotificationReceiver.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
+    <source-file src="src/android/NotificationClickReceiver.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
     <source-file src="src/android/BootReceiver.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
     <source-file src="src/android/NotificationStore.java" target-dir="app/src/main/java/dev/html2apk/bridge" />
     <framework src="androidx.core:core:1.12.0" />

package/src/templates/cordova-plugin-html2apk-bridge/src/android/Html2ApkBridge.java

@@ -73,6 +73,7 @@ public class Html2ApkBridge extends CordovaPlugin {
     private static final int REQUEST_PICK_FOLDER = 7413;
     private static final String PREFS_NAME = "html2apk_bridge";
     private static final String PREF_PERMISSION_PREFIX = "permission_requested_";
+    private static Html2ApkBridge activeBridge;
 
     private CallbackContext notificationPermissionCallback;
     private CallbackContext cameraPermissionCallback;
@@ -100,6 +101,7 @@ public class Html2ApkBridge extends CordovaPlugin {
     @Override
     public void initialize(CordovaInterface cordova, CordovaWebView webView) {
         super.initialize(cordova, webView);
+        activeBridge = this;
         handleNotificationIntent(cordova.getActivity().getIntent(), false);
         handleLinkIntent(cordova.getActivity().getIntent(), false);
         registerSystemReceiver();
@@ -131,6 +133,9 @@ public class Html2ApkBridge extends CordovaPlugin {
         stopMicRecorderSilently();
         unregisterSystemReceiver();
         dispatchEvent("app:fechado", baseEvent("app:fechado"));
+        if (activeBridge == this) {
+            activeBridge = null;
+        }
         super.onDestroy();
     }
 
@@ -757,11 +762,6 @@ public class Html2ApkBridge extends CordovaPlugin {
             return;
         }
 
-        if (shouldOpenSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS)) {
-            callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS, true, false));
-            return;
-        }
-
         notificationPermissionCallback = callbackContext;
         rememberRuntimePermissionRequest(Manifest.permission.POST_NOTIFICATIONS);
         cordova.requestPermission(this, REQUEST_POST_NOTIFICATIONS, Manifest.permission.POST_NOTIFICATIONS);
@@ -777,11 +777,6 @@ public class Html2ApkBridge extends CordovaPlugin {
             return false;
         }
 
-        if (shouldOpenSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS)) {
-            callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.POST_NOTIFICATIONS, true, false));
-            return true;
-        }
-
         pendingNotificationOptions = options;
         pendingNotificationSchedule = schedule;
         pendingNotificationCallback = callbackContext;
@@ -806,7 +801,7 @@ public class Html2ApkBridge extends CordovaPlugin {
             .setContentText(text)
             .setStyle(new NotificationCompat.BigTextStyle().bigText(text))
             .setAutoCancel(true)
-            .setContentIntent(createContentIntent(context(), id, detailPayload(options)))
+            .setContentIntent(createNotificationClickIntent(context(), id, detailPayload(options)))
             .setPriority(NotificationCompat.PRIORITY_DEFAULT);
 
         addNotificationActions(builder, context(), id, options);
@@ -1069,11 +1064,6 @@ public class Html2ApkBridge extends CordovaPlugin {
             return;
         }
 
-        if (shouldOpenSettingsForRuntimePermission(Manifest.permission.CAMERA)) {
-            callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.CAMERA, true, false));
-            return;
-        }
-
         cameraPermissionCallback = callbackContext;
         rememberRuntimePermissionRequest(Manifest.permission.CAMERA);
         cordova.requestPermission(this, REQUEST_CAMERA, Manifest.permission.CAMERA);
@@ -1092,11 +1082,6 @@ public class Html2ApkBridge extends CordovaPlugin {
             return;
         }
 
-        if (shouldOpenSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO)) {
-            callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO, true, false));
-            return;
-        }
-
         microphonePermissionCallback = callbackContext;
         rememberRuntimePermissionRequest(Manifest.permission.RECORD_AUDIO);
         cordova.requestPermission(this, REQUEST_RECORD_AUDIO, Manifest.permission.RECORD_AUDIO);
@@ -1131,11 +1116,6 @@ public class Html2ApkBridge extends CordovaPlugin {
         }
 
         if (!hasMicrophonePermission()) {
-            if (shouldOpenSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO)) {
-                callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.RECORD_AUDIO, true, false));
-                return;
-            }
-
             pendingMicStartCallback = callbackContext;
             rememberRuntimePermissionRequest(Manifest.permission.RECORD_AUDIO);
             cordova.requestPermission(this, REQUEST_RECORD_AUDIO, Manifest.permission.RECORD_AUDIO);
@@ -1319,11 +1299,6 @@ public class Html2ApkBridge extends CordovaPlugin {
 
     private void setFlashlightWithPermission(boolean enabled, boolean toggle, CallbackContext callbackContext) throws Exception {
         if (!hasCameraPermission()) {
-            if (shouldOpenSettingsForRuntimePermission(Manifest.permission.CAMERA)) {
-                callbackContext.success(openSettingsForRuntimePermission(Manifest.permission.CAMERA, true, false));
-                return;
-            }
-
             pendingFlashlightCallback = callbackContext;
             pendingFlashlightEnabled = enabled;
             pendingFlashlightToggle = toggle;
@@ -2016,6 +1991,167 @@ public class Html2ApkBridge extends CordovaPlugin {
         );
     }
 
+    static PendingIntent createNotificationClickIntent(Context context, int id, JSONObject detail) {
+        if (shouldOpenAppForNotificationClick(detail)) {
+            return createContentIntent(context, id, detail);
+        }
+
+        Intent intent = new Intent(context, NotificationClickReceiver.class);
+        intent.putExtra(EXTRA_NOTIFICATION_CLICKED, true);
+        intent.putExtra(EXTRA_NOTIFICATION_DETAIL, detail == null ? "{}" : detail.toString());
+
+        return PendingIntent.getBroadcast(
+            context,
+            id,
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
+    }
+
+    static void handleNotificationClickBroadcast(Context context, JSONObject detail) {
+        if (detail == null) {
+            return;
+        }
+
+        if (activeBridge != null && activeBridge.webView != null) {
+            activeBridge.dispatchNotificationClick(detail);
+            return;
+        }
+
+        handleNativeNotificationAction(context, detail);
+    }
+
+    private static void handleNativeNotificationAction(Context context, JSONObject detail) {
+        JSONObject action = notificationClickAction(detail);
+        if (action == null) {
+            return;
+        }
+
+        String functionName = action.optString("funcao",
+            action.optString("functionName",
+                action.optString("function",
+                    action.optString("fn", action.optString("nomeFuncao", "")))));
+
+        if (!isExternalUrlFunction(functionName)) {
+            return;
+        }
+
+        String url = firstActionArgument(action);
+        if (url.length() == 0) {
+            url = action.optString("url", action.optString("href", ""));
+        }
+        if (url.length() == 0) {
+            return;
+        }
+
+        Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+        try {
+            context.startActivity(intent);
+        } catch (Exception ignored) {
+        }
+    }
+
+    private static boolean isExternalUrlFunction(String functionName) {
+        return "abrirForaDoApp".equals(functionName)
+            || "abrirUrlExterno".equals(functionName)
+            || "abrirUrl".equals(functionName)
+            || "openOutsideApp".equals(functionName)
+            || "openExternalUrl".equals(functionName)
+            || "openUrl".equals(functionName);
+    }
+
+    private static String firstActionArgument(JSONObject action) {
+        JSONArray args = action.optJSONArray("argumentos");
+        if (args == null) {
+            args = action.optJSONArray("args");
+        }
+        if (args == null) {
+            args = action.optJSONArray("parametros");
+        }
+        if (args == null) {
+            args = action.optJSONArray("params");
+        }
+        if (args == null || args.length() == 0) {
+            return "";
+        }
+        return args.optString(0, "");
+    }
+
+    private static JSONObject notificationClickAction(JSONObject detail) {
+        if (detail == null) {
+            return null;
+        }
+
+        JSONObject action = detail.optJSONObject("action");
+        if (action != null) {
+            JSONObject nested = action.optJSONObject("aoClicar");
+            if (nested == null) {
+                nested = action.optJSONObject("onClick");
+            }
+            return nested == null ? action : nested;
+        }
+
+        action = detail.optJSONObject("acao");
+        if (action != null) {
+            JSONObject nested = action.optJSONObject("aoClicar");
+            if (nested == null) {
+                nested = action.optJSONObject("onClick");
+            }
+            return nested == null ? action : nested;
+        }
+
+        action = detail.optJSONObject("aoClicar");
+        if (action == null) {
+            action = detail.optJSONObject("onClick");
+        }
+        return action;
+    }
+
+    private static boolean shouldOpenAppForNotificationClick(JSONObject detail) {
+        Boolean open = openFlag(detail);
+        JSONObject action;
+
+        if (open != null) {
+            return open.booleanValue();
+        }
+
+        action = detail == null ? null : detail.optJSONObject("action");
+        open = openFlag(action);
+        if (open != null) {
+            return open.booleanValue();
+        }
+
+        action = detail == null ? null : detail.optJSONObject("acao");
+        open = openFlag(action);
+        if (open != null) {
+            return open.booleanValue();
+        }
+
+        action = notificationClickAction(detail);
+        open = openFlag(action);
+        return open == null || open.booleanValue();
+    }
+
+    private static Boolean openFlag(JSONObject object) {
+        if (object == null) {
+            return null;
+        }
+        if (object.has("open")) {
+            return Boolean.valueOf(object.optBoolean("open", true));
+        }
+        if (object.has("abrir")) {
+            return Boolean.valueOf(object.optBoolean("abrir", true));
+        }
+        if (object.has("openApp")) {
+            return Boolean.valueOf(object.optBoolean("openApp", true));
+        }
+        if (object.has("abrirApp")) {
+            return Boolean.valueOf(object.optBoolean("abrirApp", true));
+        }
+        return null;
+    }
+
     static boolean canScheduleExactAlarms(Context context) {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
             return true;
@@ -2219,9 +2355,13 @@ public class Html2ApkBridge extends CordovaPlugin {
     static JSONObject detailPayload(JSONObject options) throws Exception {
         JSONObject detail = new JSONObject();
         JSONObject click = options.optJSONObject("aoClicar");
+        Boolean open = openFlag(options);
         if (click == null) {
             click = options.optJSONObject("onClick");
         }
+        if (open == null) {
+            open = openFlag(click);
+        }
 
         detail.put("id", notificationId(options));
         detail.put("title", title(options));
@@ -2232,6 +2372,10 @@ public class Html2ApkBridge extends CordovaPlugin {
         detail.put("clickedAt", System.currentTimeMillis());
         detail.put("onClick", click == null ? new JSONObject().put("action", "open-app") : click);
         detail.put("aoClicar", click == null ? new JSONObject().put("acao", "abrir-app") : click);
+        if (open != null) {
+            detail.put("open", open.booleanValue());
+            detail.put("abrir", open.booleanValue());
+        }
         return detail;
     }
 
@@ -2259,7 +2403,7 @@ public class Html2ApkBridge extends CordovaPlugin {
                 builder.addAction(
                     context.getApplicationInfo().icon,
                     title,
-                    createContentIntent(context, notificationId * 100 + index + 1, detail)
+                    createNotificationClickIntent(context, notificationId * 100 + index + 1, detail)
                 );
             } catch (Exception ignored) {
             }