html2apk 0.3.0 → 0.5.0

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

@@ -0,0 +1,28 @@
+package dev.html2apk.bridge;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+import androidx.core.app.NotificationManagerCompat;
+
+import org.json.JSONObject;
+
+public class NotificationClickReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (intent == null || !intent.getBooleanExtra(Html2ApkBridge.EXTRA_NOTIFICATION_CLICKED, false)) {
+            return;
+        }
+
+        JSONObject detail;
+        try {
+            detail = new JSONObject(intent.getStringExtra(Html2ApkBridge.EXTRA_NOTIFICATION_DETAIL));
+        } catch (Exception ignored) {
+            detail = new JSONObject();
+        }
+
+        Html2ApkBridge.handleNotificationClickBroadcast(context, detail);
+        NotificationManagerCompat.from(context).cancel(detail.optInt("id", 0));
+    }
+}

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

@@ -58,7 +58,7 @@ public class NotificationReceiver extends BroadcastReceiver {
             .setContentText(text)
             .setStyle(new NotificationCompat.BigTextStyle().bigText(text))
             .setAutoCancel(true)
-            .setContentIntent(Html2ApkBridge.createContentIntent(context, id, detail))
+            .setContentIntent(Html2ApkBridge.createNotificationClickIntent(context, id, detail))
             .setPriority(NotificationCompat.PRIORITY_DEFAULT);
 
         Html2ApkBridge.addNotificationActions(builder, context, id, displayOptions);

package/src/templates/cordova-plugin-html2apk-bridge/www/html2apk-bridge.js

@@ -1,12 +1,17 @@
 "use strict";
 
 var exec = require("cordova/exec");
+var channel = require("cordova/channel");
 
 var notificationListeners = [];
 var eventListeners = {};
 var initialNotification = null;
 var initialLink = null;
 var scheduledNotificationCounter = 0;
+var notificationActionCounter = 0;
+var notificationActionCallbacks = {};
+var deviceReady = typeof document === "undefined";
+var deviceReadyCallbacks = [];
 var eventAliases = {
   "app:ready": "app:pronto",
   "app:paused": "app:pausado",
@@ -20,13 +25,212 @@ var eventAliases = {
   "notification:clicked": "notificacao:clicada"
 };
 
+function markDeviceReady() {
+  if (deviceReady) {
+    return;
+  }
+
+  deviceReady = true;
+  deviceReadyCallbacks.splice(0).forEach(function (callback) {
+    callback();
+  });
+}
+
+function whenDeviceReady() {
+  if (deviceReady) {
+    return Promise.resolve();
+  }
+
+  return new Promise(function (resolve) {
+    deviceReadyCallbacks.push(resolve);
+  });
+}
+
+if (typeof document !== "undefined") {
+  document.addEventListener("deviceready", markDeviceReady, false);
+}
+
 function call(action, args) {
+  return whenCordovaBridgeReady().then(function () {
+    return new Promise(function (resolve, reject) {
+      try {
+        exec(resolve, reject, "Html2ApkBridge", action, args || []);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
+function whenCordovaBridgeReady() {
+  var timer;
+
+  if (!channel || !channel.onCordovaReady || channel.onCordovaReady.state === 2) {
+    return Promise.resolve();
+  }
+
   return new Promise(function (resolve, reject) {
-    exec(resolve, reject, "Html2ApkBridge", action, args || []);
+    timer = setTimeout(function () {
+      reject(new Error("html2apk native bridge is not ready. Make sure cordova.js finished loading."));
+    }, 10000);
+
+    channel.onCordovaReady.subscribe(function () {
+      clearTimeout(timer);
+      resolve();
+    });
+  });
+}
+
+function asyncThrow(error) {
+  setTimeout(function () {
+    throw error;
+  }, 0);
+}
+
+function cloneSerializable(value) {
+  var output;
+
+  if (typeof value === "function" || typeof value === "undefined") {
+    return undefined;
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    output = [];
+    value.forEach(function (item) {
+      var cloned = cloneSerializable(item);
+      if (typeof cloned !== "undefined") {
+        output.push(cloned);
+      }
+    });
+    return output;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  output = {};
+  Object.keys(value).forEach(function (key) {
+    var cloned = cloneSerializable(value[key]);
+    if (typeof cloned !== "undefined") {
+      output[key] = cloned;
+    }
+  });
+  return output;
+}
+
+function registerNotificationAction(handler, source) {
+  var id = "html2apk-click-" + Date.now() + "-" + (++notificationActionCounter);
+  notificationActionCallbacks[id] = function (detail) {
+    return handler(detail, source || {});
+  };
+  return id;
+}
+
+function normalizeNotificationClick(click) {
+  var normalized;
+  var callbackId;
+  var actionHandler;
+  var functionName;
+
+  if (typeof click === "function") {
+    callbackId = registerNotificationAction(click);
+    return {
+      action: "run-function",
+      acao: "executar-funcao",
+      callbackId: callbackId
+    };
+  }
+
+  if (!click || typeof click !== "object") {
+    return {
+      action: "open-app",
+      acao: "abrir-app"
+    };
+  }
+
+  normalized = cloneSerializable(click) || {};
+  actionHandler = click.acao || click.action;
+  if (typeof actionHandler === "function") {
+    callbackId = registerNotificationAction(actionHandler, click);
+    normalized.callbackId = callbackId;
+    normalized.action = normalized.action || "run-function";
+    normalized.acao = normalized.acao || "executar-funcao";
+  }
+
+  functionName = normalized.funcao || normalized.functionName || normalized.function || normalized.fn || normalized.nomeFuncao;
+  if (typeof functionName === "string" && functionName.trim()) {
+    normalized.funcao = functionName.trim();
+    normalized.functionName = normalized.funcao;
+    normalized.action = normalized.action || "run-function";
+    normalized.acao = normalized.acao || "executar-funcao";
+  }
+
+  if (normalized.action && !normalized.acao) {
+    normalized.acao = normalized.action;
+  }
+  if (normalized.acao && !normalized.action) {
+    normalized.action = normalized.acao;
+  }
+
+  return normalized;
+}
+
+function notificationOpenValue(source) {
+  if (!source || typeof source !== "object") {
+    return undefined;
+  }
+  if (Object.prototype.hasOwnProperty.call(source, "open")) {
+    return source.open !== false;
+  }
+  if (Object.prototype.hasOwnProperty.call(source, "abrir")) {
+    return source.abrir !== false;
+  }
+  if (Object.prototype.hasOwnProperty.call(source, "abrirApp")) {
+    return source.abrirApp !== false;
+  }
+  if (Object.prototype.hasOwnProperty.call(source, "openApp")) {
+    return source.openApp !== false;
+  }
+  return undefined;
+}
+
+function normalizeNotificationActions(actions) {
+  if (!Array.isArray(actions)) {
+    return actions;
+  }
+
+  return actions.map(function (action) {
+    var normalized = cloneSerializable(action) || {};
+    var click = action && (action.aoClicar || action.onClick);
+    if (!click && action && (
+      typeof action.funcao === "string" ||
+      typeof action.functionName === "string" ||
+      typeof action.fn === "string"
+    )) {
+      click = action;
+    }
+    if (click) {
+      normalized.aoClicar = normalizeNotificationClick(click);
+      normalized.onClick = normalized.aoClicar;
+    }
+    if (typeof notificationOpenValue(action) !== "undefined") {
+      normalized.open = notificationOpenValue(action);
+      if (normalized.aoClicar && typeof normalized.aoClicar.open === "undefined") {
+        normalized.aoClicar.open = normalized.open;
+        normalized.onClick = normalized.aoClicar;
+      }
+    }
+    return normalized;
   });
 }
 
 function normalizeNotificationOptions(messageOrOptions) {
+  var options;
+  var click;
+  var actions;
+
   if (typeof messageOrOptions === "string") {
     return {
       title: "Notificacao",
@@ -37,12 +241,23 @@ function normalizeNotificationOptions(messageOrOptions) {
     };
   }
 
-  var options = messageOrOptions || {};
-  if (!options.onClick && !options.aoClicar) {
-    options.onClick = {
-      action: "open-app"
-    };
+  options = cloneSerializable(messageOrOptions || {}) || {};
+  click = messageOrOptions && (messageOrOptions.aoClicar || messageOrOptions.onClick);
+  options.onClick = normalizeNotificationClick(click);
+  options.aoClicar = options.onClick;
+  if (typeof notificationOpenValue(messageOrOptions) !== "undefined") {
+    options.open = notificationOpenValue(messageOrOptions);
+    options.abrir = options.open;
+    options.onClick.open = options.open;
+    options.aoClicar.open = options.open;
+  }
+
+  actions = normalizeNotificationActions(messageOrOptions && (messageOrOptions.acoes || messageOrOptions.actions));
+  if (Array.isArray(actions)) {
+    options.acoes = actions;
+    options.actions = actions;
   }
+
   return options;
 }
 
@@ -154,17 +369,98 @@ function normalizeEventType(type) {
 }
 
 function emitNotificationClick(detail) {
+  var notification = detail || null;
   initialNotification = detail || null;
 
   notificationListeners.slice().forEach(function (listener) {
     try {
-      listener(initialNotification);
+      listener(notification);
     } catch (error) {
-      setTimeout(function () {
-        throw error;
-      }, 0);
+      asyncThrow(error);
     }
   });
+
+  executeNotificationClickAction(notification);
+}
+
+function notificationActionFromDetail(detail) {
+  var action;
+
+  if (!detail || typeof detail !== "object") {
+    return null;
+  }
+
+  action = detail.action || detail.acao;
+  if (action && typeof action === "object") {
+    if (action.callbackId || action.functionName || action.funcao || action.fn || action.nomeFuncao) {
+      return action;
+    }
+    if (action.aoClicar || action.onClick) {
+      return action.aoClicar || action.onClick;
+    }
+  }
+
+  return detail.aoClicar || detail.onClick || null;
+}
+
+function notificationActionArgs(action, detail) {
+  var args = action && (
+    action.argumentos ||
+    action.args ||
+    action.parametros ||
+    action.params ||
+    action.parameters
+  );
+
+  if (typeof args === "undefined") {
+    return action && (action.passarEvento === false || action.passEvent === false) ? [] : [detail];
+  }
+
+  return Array.isArray(args) ? args : [args];
+}
+
+function handleActionResult(result) {
+  if (result && typeof result.then === "function") {
+    result.catch(asyncThrow);
+  }
+}
+
+function executeNotificationClickAction(detail) {
+  var action = notificationActionFromDetail(detail);
+  var callbackId = action && (action.callbackId || action.idCallback || action.callback);
+  var functionName;
+  var handler;
+  var args;
+
+  if (!action || typeof action !== "object") {
+    return;
+  }
+  if (detail && detail.__html2apkActionHandled) {
+    return;
+  }
+
+  if (callbackId && notificationActionCallbacks[callbackId]) {
+    detail.__html2apkActionHandled = true;
+    handleActionResult(notificationActionCallbacks[callbackId](detail));
+    return;
+  }
+
+  functionName = action.funcao || action.functionName || action.function || action.fn || action.nomeFuncao;
+  if (!functionName) {
+    return;
+  }
+
+  handler = api && api[functionName];
+  if (typeof handler !== "function" && typeof window !== "undefined") {
+    handler = window[functionName];
+  }
+  if (typeof handler !== "function") {
+    return;
+  }
+
+  args = notificationActionArgs(action, detail);
+  detail.__html2apkActionHandled = true;
+  handleActionResult(handler.apply(typeof window === "undefined" ? null : window, args));
 }
 
 function emitEvent(type, detail) {