html2apk 0.2.0 → 0.3.0

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

@@ -21,21 +21,33 @@ public class NotificationReceiver extends BroadcastReceiver {
 
     @Override
     public void onReceive(Context context, Intent intent) {
+        JSONObject options = parseOptions(intent);
+        int id = intent.getIntExtra(EXTRA_NOTIFICATION_ID, Html2ApkBridge.notificationId(options));
+
         if (Build.VERSION.SDK_INT >= 33 && context.checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS) != PackageManager.PERMISSION_GRANTED) {
+            if (Html2ApkBridge.repeatInterval(options) > 0) {
+                Html2ApkBridge.rescheduleRepeatingNotification(context, id, options, Html2ApkBridge.canScheduleExactAlarms(context));
+            } else {
+                NotificationStore.remove(context, id);
+            }
             return;
         }
 
-        JSONObject options = parseOptions(intent);
-        int id = intent.getIntExtra(EXTRA_NOTIFICATION_ID, Html2ApkBridge.notificationId(options));
+        JSONObject displayOptions;
+        try {
+            displayOptions = Html2ApkBridge.notificationDisplayOptions(options);
+        } catch (Exception error) {
+            displayOptions = options;
+        }
         NotificationStore.remove(context, id);
 
         Html2ApkBridge.ensureNotificationChannel(context);
 
-        String title = Html2ApkBridge.title(options);
-        String text = Html2ApkBridge.text(options);
+        String title = Html2ApkBridge.title(displayOptions);
+        String text = Html2ApkBridge.text(displayOptions);
         JSONObject detail;
         try {
-            detail = Html2ApkBridge.detailPayload(options);
+            detail = Html2ApkBridge.detailPayload(displayOptions);
         } catch (Exception error) {
             detail = new JSONObject();
         }
@@ -49,7 +61,9 @@ public class NotificationReceiver extends BroadcastReceiver {
             .setContentIntent(Html2ApkBridge.createContentIntent(context, id, detail))
             .setPriority(NotificationCompat.PRIORITY_DEFAULT);
 
+        Html2ApkBridge.addNotificationActions(builder, context, id, displayOptions);
         NotificationManagerCompat.from(context).notify(id, builder.build());
+        Html2ApkBridge.rescheduleRepeatingNotification(context, id, options, Html2ApkBridge.canScheduleExactAlarms(context));
     }
 
     static void schedule(Context context, int id, long when, JSONObject options, boolean exactAllowed) {

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

@@ -63,7 +63,19 @@ public final class NotificationStore {
                 int id = item.optInt("id");
                 long when = item.optLong("when");
                 JSONObject options = item.optJSONObject("options");
-                if (options == null || when <= now) {
+                if (options == null) {
+                    continue;
+                }
+
+                if (when <= now && Html2ApkBridge.repeatInterval(options) > 0) {
+                    when = Html2ApkBridge.nextRepeatTime(options, now);
+                    options = Html2ApkBridge.nextRepeatOptions(options, when);
+                    options.put("id", id);
+                    item.put("when", when);
+                    item.put("options", options);
+                }
+
+                if (when <= now) {
                     continue;
                 }
 

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

@@ -3,7 +3,22 @@
 var exec = require("cordova/exec");
 
 var notificationListeners = [];
+var eventListeners = {};
 var initialNotification = null;
+var initialLink = null;
+var scheduledNotificationCounter = 0;
+var eventAliases = {
+  "app:ready": "app:pronto",
+  "app:paused": "app:pausado",
+  "app:closed": "app:fechado",
+  "app:resumed": "app:voltou",
+  "back:button": "botao:voltar",
+  "link:opened": "link:aberto",
+  "network:changed": "rede:mudou",
+  "battery:changed": "bateria:mudou",
+  "notification:received": "notificacao:recebida",
+  "notification:clicked": "notificacao:clicada"
+};
 
 function call(action, args) {
   return new Promise(function (resolve, reject) {
@@ -31,6 +46,113 @@ function normalizeNotificationOptions(messageOrOptions) {
   return options;
 }
 
+function normalizeScheduledNotificationOptions(options) {
+  var normalized = normalizeNotificationOptions(options || {});
+  if (!normalized.id) {
+    scheduledNotificationCounter = (scheduledNotificationCounter + 1) % 100000;
+    normalized.id = Math.floor(Date.now() % 0x0fffffff) + scheduledNotificationCounter;
+  }
+  return normalized;
+}
+
+function parseIntervalMs(value) {
+  var text;
+  var match;
+  var amount;
+  var unit;
+
+  if (typeof value === "number" && isFinite(value)) {
+    return Math.max(0, Math.round(value));
+  }
+
+  if (value && typeof value === "object") {
+    return parseIntervalMs(value.intervalo || value.interval || value.aCada || value.every || value.ms);
+  }
+
+  text = String(value || "").trim().toLowerCase();
+  match = text.match(/^(\d+(?:\.\d+)?)\s*(ms|s|seg|m|min|h|hr|d|dia|dias)?$/);
+  if (!match) {
+    return 0;
+  }
+
+  amount = Number(match[1]);
+  unit = match[2] || "ms";
+  if (unit === "s" || unit === "seg") {
+    return Math.round(amount * 1000);
+  }
+  if (unit === "m" || unit === "min") {
+    return Math.round(amount * 60 * 1000);
+  }
+  if (unit === "h" || unit === "hr") {
+    return Math.round(amount * 60 * 60 * 1000);
+  }
+  if (unit === "d" || unit === "dia" || unit === "dias") {
+    return Math.round(amount * 24 * 60 * 60 * 1000);
+  }
+  return Math.round(amount);
+}
+
+function scheduleNotification(options) {
+  return call("scheduleNotification", [normalizeScheduledNotificationOptions(options || {})]);
+}
+
+function scheduleNotifications(items) {
+  var list = Array.isArray(items) ? items : [];
+  return Promise.all(list.map(function (item) {
+    return scheduleNotification(item);
+  }));
+}
+
+function normalizeNotificationLoop(options) {
+  var source = options || {};
+  var notifications = source.notificacoes || source.notifications || source.items || [];
+  var interval = parseIntervalMs(source.intervalo || source.interval || source.aCada || source.every || source.repeat || source.repetir);
+  var normalized;
+
+  if (!interval) {
+    return Promise.reject(new Error("Notification loop interval is required."));
+  }
+  if (!Array.isArray(notifications) || notifications.length === 0) {
+    return Promise.reject(new Error("Notification loop requires at least one notification."));
+  }
+
+  normalized = normalizeScheduledNotificationOptions(Object.assign({}, source));
+  normalized.intervalo = interval;
+  normalized.interval = interval;
+  normalized.repeat = true;
+  normalized.repetir = true;
+  normalized.notificacoes = notifications.map(function (item) {
+    return normalizeNotificationOptions(Object.assign({}, item || {}));
+  });
+  normalized.notifications = normalized.notificacoes;
+  normalized.loopIndex = Number(source.loopIndex || source.indiceLoop || 0) || 0;
+  normalized.indiceLoop = normalized.loopIndex;
+  normalized.quando = normalized.quando || normalized.when || (Date.now() + interval);
+  normalized.when = normalized.when || normalized.quando;
+  return normalized;
+}
+
+function scheduleNotificationLoop(options) {
+  var normalized = normalizeNotificationLoop(options);
+  if (normalized && typeof normalized.then === "function") {
+    return normalized;
+  }
+
+  return scheduleNotification(normalized);
+}
+
+function notificationId(input) {
+  if (input && typeof input === "object") {
+    return input.id || input.notificationId || input.notificacaoId;
+  }
+  return input;
+}
+
+function normalizeEventType(type) {
+  var eventType = String(type || "");
+  return eventAliases[eventType] || eventType;
+}
+
 function emitNotificationClick(detail) {
   initialNotification = detail || null;
 
@@ -45,12 +167,102 @@ function emitNotificationClick(detail) {
   });
 }
 
+function emitEvent(type, detail) {
+  var eventType = normalizeEventType(type || (detail && detail.type));
+  if (!eventType) {
+    return;
+  }
+
+  var payload = detail || {};
+  payload.type = payload.type || eventType;
+  payload.tipo = payload.tipo || eventType;
+  payload.timestamp = payload.timestamp || Date.now();
+
+  (eventListeners[eventType] || []).slice().forEach(function (listener) {
+    try {
+      listener(payload);
+    } catch (error) {
+      setTimeout(function () {
+        throw error;
+      }, 0);
+    }
+  });
+}
+
+function onEvent(type, listener) {
+  if (typeof listener !== "function") {
+    throw new TypeError("listener must be a function");
+  }
+
+  var eventType = normalizeEventType(type);
+  eventListeners[eventType] = eventListeners[eventType] || [];
+  eventListeners[eventType].push(listener);
+
+  return function unsubscribe() {
+    eventListeners[eventType] = (eventListeners[eventType] || []).filter(function (item) {
+      return item !== listener;
+    });
+  };
+}
+
+function firstOrNull(result) {
+  return Array.isArray(result) && result.length ? result[0] : null;
+}
+
+function openInAppUrl(url, options) {
+  var target = String(url || "").trim();
+  if (!target) {
+    return Promise.reject(new Error("URL is required."));
+  }
+  if (typeof window === "undefined" || !window.location) {
+    return Promise.reject(new Error("window.location is unavailable."));
+  }
+
+  return new Promise(function (resolve) {
+    var replace = Boolean(options && (options.replace || options.substituir));
+    resolve({
+      url: target,
+      target: "app",
+      alvo: "app",
+      opened: true,
+      aberto: true,
+      replace: replace,
+      substituir: replace
+    });
+
+    setTimeout(function () {
+      if (replace) {
+        window.location.replace(target);
+        return;
+      }
+
+      window.location.assign(target);
+    }, 0);
+  });
+}
+
 var api = {
   notificar: function (messageOrOptions) {
     return call("notify", [normalizeNotificationOptions(messageOrOptions)]);
   },
   agendarNotificacao: function (options) {
-    return call("scheduleNotification", [normalizeNotificationOptions(options || {})]);
+    if (Array.isArray(options)) {
+      return scheduleNotifications(options);
+    }
+
+    return scheduleNotification(options);
+  },
+  agendarNotificacoes: function (items) {
+    return scheduleNotifications(items);
+  },
+  agendarLoopNotificacoes: function (options) {
+    return scheduleNotificationLoop(options);
+  },
+  cancelarNotificacao: function (id) {
+    return call("cancelNotification", [notificationId(id)]);
+  },
+  cancelarLoopNotificacoes: function (id) {
+    return call("cancelNotification", [notificationId(id)]);
   },
   vibrar: function (ms) {
     return call("vibrate", [Number(ms) || 200]);
@@ -67,15 +279,120 @@ var api = {
   brilhoTela: function (value) {
     return call("setScreenBrightness", [Number(value)]);
   },
+  definirCorTema: function (optionsOrColor) {
+    return call("setSystemBarsColor", [optionsOrColor || "#126fff"]);
+  },
+  definirCorBarrasSistema: function (optionsOrColor) {
+    return call("setSystemBarsColor", [optionsOrColor || "#126fff"]);
+  },
+  lanterna: function (enabled) {
+    return call("flashlight", [Boolean(enabled)]);
+  },
+  alternarLanterna: function () {
+    return call("toggleFlashlight");
+  },
+  statusLanterna: function () {
+    return call("flashlightStatus");
+  },
+  solicitarPermissaoCamera: function () {
+    return call("requestCameraPermission");
+  },
+  solicitarPermissaoMicrofone: function () {
+    return call("requestMicrophonePermission");
+  },
+  statusMicrofone: function () {
+    return call("microphoneStatus");
+  },
+  ouvirMic: function () {
+    return call("startMic");
+  },
+  pararMic: function () {
+    return call("stopMic");
+  },
   copiarTexto: function (text) {
     return call("copyText", [String(text || "")]);
   },
+  lerTextoCopiado: function () {
+    return call("readText");
+  },
   compartilharTexto: function (text) {
     return call("shareText", [String(text || "")]);
   },
+  compartilhar: function (options) {
+    return call("share", [options || {}]);
+  },
   abrirUrl: function (url) {
     return call("openUrl", [String(url || "")]);
   },
+  abrirUrlExterno: function (url) {
+    return call("openUrl", [String(url || "")]);
+  },
+  abrirForaDoApp: function (url) {
+    return call("openUrl", [String(url || "")]);
+  },
+  abrirNoApp: function (url, options) {
+    return openInAppUrl(url, options || {});
+  },
+  discar: function (phone) {
+    return call("dial", [String(phone || "")]);
+  },
+  abrirMapa: function (query) {
+    return call("openMap", [String(query || "")]);
+  },
+  abrirWhatsapp: function (phone, message) {
+    return call("openWhatsapp", [String(phone || ""), String(message || "")]);
+  },
+  escolherArquivo: function (options) {
+    return call("pickFile", [options || {}]).then(firstOrNull);
+  },
+  escolherArquivos: function (options) {
+    var nextOptions = options || {};
+    nextOptions.multiplo = nextOptions.multiplo !== false;
+    nextOptions.multiple = nextOptions.multiple !== false;
+    return call("pickFile", [nextOptions]);
+  },
+  escolherImagem: function (options) {
+    return call("pickFile", [Object.assign({ tipo: "image", kind: "image" }, options || {})]).then(firstOrNull);
+  },
+  escolherImagens: function (options) {
+    return call("pickFile", [Object.assign({ tipo: "image", kind: "image", multiplo: true, multiple: true }, options || {})]);
+  },
+  escolherVideo: function (options) {
+    return call("pickFile", [Object.assign({ tipo: "video", kind: "video" }, options || {})]).then(firstOrNull);
+  },
+  escolherPasta: function () {
+    return call("pickFolder");
+  },
+  salvarArquivo: function (options) {
+    return call("saveFile", [options || {}]);
+  },
+  infoDispositivo: function () {
+    return call("deviceInfo");
+  },
+  infoRede: function () {
+    return call("networkInfo");
+  },
+  infoBateria: function () {
+    return call("batteryInfo");
+  },
+  infoMemoria: function () {
+    return call("memoryInfo");
+  },
+  infoArmazenamento: function () {
+    return call("storageInfo");
+  },
+  infoDesempenho: function () {
+    return call("performanceInfo");
+  },
+  appsAbertos: function () {
+    return call("openAppsMemory");
+  },
+  infoAppsAbertos: function () {
+    return call("openAppsMemory");
+  },
+  statusPermissoes: function (permissions) {
+    return call("permissionStatus", [permissions || []]);
+  },
   solicitarPermissaoNotificacoes: function () {
     return call("requestNotificationPermission");
   },
@@ -109,6 +426,36 @@ var api = {
       return initialNotification;
     });
   },
+  obterLinkInicial: function () {
+    return call("getInitialLink").then(function (link) {
+      initialLink = link && link.url ? link : null;
+      return initialLink;
+    });
+  },
+  aoEvento: onEvent,
+  aoMinimizar: function (listener) {
+    return onEvent("app:background", listener);
+  },
+  aoVoltarParaApp: function (listener) {
+    return onEvent("app:voltou", listener);
+  },
+  aoAbrirLink: function (listener) {
+    if (typeof listener !== "function") {
+      throw new TypeError("listener must be a function");
+    }
+    if (initialLink) {
+      setTimeout(function () {
+        listener(initialLink);
+      }, 0);
+    }
+    return onEvent("link:aberto", listener);
+  },
+  aoMudarRede: function (listener) {
+    return onEvent("rede:mudou", listener);
+  },
+  aoMudarBateria: function (listener) {
+    return onEvent("bateria:mudou", listener);
+  },
   aoClicarNotificacao: function (listener) {
     if (typeof listener !== "function") {
       throw new TypeError("listener must be a function");
@@ -127,9 +474,84 @@ var api = {
   },
   __emitNotificationClick: function (detail) {
     emitNotificationClick(detail);
+  },
+  __emitEvent: function (type, detail) {
+    emitEvent(type, detail);
   }
 };
 
+Object.assign(api, {
+  notify: api.notificar,
+  scheduleNotification: api.agendarNotificacao,
+  scheduleNotifications: api.agendarNotificacoes,
+  scheduleNotificationLoop: api.agendarLoopNotificacoes,
+  cancelNotification: api.cancelarNotificacao,
+  cancelNotificationLoop: api.cancelarLoopNotificacoes,
+  vibrate: api.vibrar,
+  manterTelaLigada: api.manterTelaAcordada,
+  keepScreenAwake: api.manterTelaAcordada,
+  keepScreenOn: api.manterTelaAcordada,
+  setScreenBrightness: api.brilhoTela,
+  setThemeColor: api.definirCorTema,
+  setSystemBarsColor: api.definirCorBarrasSistema,
+  flashlight: api.lanterna,
+  toggleFlashlight: api.alternarLanterna,
+  flashlightStatus: api.statusLanterna,
+  requestCameraPermission: api.solicitarPermissaoCamera,
+  requestMicrophonePermission: api.solicitarPermissaoMicrofone,
+  microphoneStatus: api.statusMicrofone,
+  listenMic: api.ouvirMic,
+  startMic: api.ouvirMic,
+  startMicRecording: api.ouvirMic,
+  stopMic: api.pararMic,
+  stopMicRecording: api.pararMic,
+  copyText: api.copiarTexto,
+  readText: api.lerTextoCopiado,
+  shareText: api.compartilharTexto,
+  share: api.compartilhar,
+  openUrl: api.abrirUrl,
+  openExternalUrl: api.abrirUrlExterno,
+  openOutsideApp: api.abrirForaDoApp,
+  openInApp: api.abrirNoApp,
+  dial: api.discar,
+  openMap: api.abrirMapa,
+  openWhatsapp: api.abrirWhatsapp,
+  pickFile: api.escolherArquivo,
+  pickFiles: api.escolherArquivos,
+  pickImage: api.escolherImagem,
+  pickImages: api.escolherImagens,
+  pickVideo: api.escolherVideo,
+  pickFolder: api.escolherPasta,
+  saveFile: api.salvarArquivo,
+  deviceInfo: api.infoDispositivo,
+  networkInfo: api.infoRede,
+  batteryInfo: api.infoBateria,
+  memoryInfo: api.infoMemoria,
+  storageInfo: api.infoArmazenamento,
+  performanceInfo: api.infoDesempenho,
+  openAppsMemory: api.appsAbertos,
+  openAppsInfo: api.infoAppsAbertos,
+  permissionStatus: api.statusPermissoes,
+  requestNotificationPermission: api.solicitarPermissaoNotificacoes,
+  notificationPermissionStatus: api.statusPermissaoNotificacoes,
+  canScheduleExactAlarms: api.podeAgendarNotificacaoExata,
+  openExactAlarmSettings: api.abrirConfiguracaoAlarmeExato,
+  overlayPermissionStatus: api.statusPermissaoSobreposicao,
+  requestOverlayPermission: api.solicitarPermissaoSobreposicao,
+  openOverlaySettings: api.abrirConfiguracaoSobreposicao,
+  startFloatingIcon: api.iniciarIconeFlutuante,
+  stopFloatingIcon: api.pararIconeFlutuante,
+  getInitialNotification: api.obterNotificacaoInicial,
+  getInitialLink: api.obterLinkInicial,
+  onEvent: api.aoEvento,
+  onMinimize: api.aoMinimizar,
+  onAppResume: api.aoVoltarParaApp,
+  onOpenLink: api.aoAbrirLink,
+  onNetworkChange: api.aoMudarRede,
+  onBatteryChange: api.aoMudarBateria,
+  onNotificationClick: api.aoClicarNotificacao
+});
+
 if (typeof window !== "undefined") {
   window.notificar = api.notificar;
   window.agendarNotificacao = api.agendarNotificacao;
@@ -137,10 +559,41 @@ if (typeof window !== "undefined") {
   window.toast = api.toast;
   window.fullscreen = api.fullscreen;
   window.manterTelaAcordada = api.manterTelaAcordada;
+  window.manterTelaLigada = api.manterTelaAcordada;
   window.brilhoTela = api.brilhoTela;
+  window.lanterna = api.lanterna;
+  window.alternarLanterna = api.alternarLanterna;
+  window.statusLanterna = api.statusLanterna;
+  window.solicitarPermissaoCamera = api.solicitarPermissaoCamera;
+  window.solicitarPermissaoMicrofone = api.solicitarPermissaoMicrofone;
+  window.statusMicrofone = api.statusMicrofone;
+  window.ouvirMic = api.ouvirMic;
+  window.pararMic = api.pararMic;
   window.copiarTexto = api.copiarTexto;
+  window.lerTextoCopiado = api.lerTextoCopiado;
+  window.compartilhar = api.compartilhar;
   window.compartilharTexto = api.compartilharTexto;
   window.abrirUrl = api.abrirUrl;
+  window.abrirUrlExterno = api.abrirUrlExterno;
+  window.abrirWhatsapp = api.abrirWhatsapp;
+  window.discar = api.discar;
+  window.abrirMapa = api.abrirMapa;
+  window.escolherArquivo = api.escolherArquivo;
+  window.escolherArquivos = api.escolherArquivos;
+  window.escolherImagem = api.escolherImagem;
+  window.escolherImagens = api.escolherImagens;
+  window.escolherVideo = api.escolherVideo;
+  window.escolherPasta = api.escolherPasta;
+  window.salvarArquivo = api.salvarArquivo;
+  window.infoDispositivo = api.infoDispositivo;
+  window.infoRede = api.infoRede;
+  window.infoBateria = api.infoBateria;
+  window.infoMemoria = api.infoMemoria;
+  window.infoArmazenamento = api.infoArmazenamento;
+  window.infoDesempenho = api.infoDesempenho;
+  window.appsAbertos = api.appsAbertos;
+  window.infoAppsAbertos = api.infoAppsAbertos;
+  window.statusPermissoes = api.statusPermissoes;
   window.solicitarPermissaoNotificacoes = api.solicitarPermissaoNotificacoes;
   window.statusPermissaoNotificacoes = api.statusPermissaoNotificacoes;
   window.podeAgendarNotificacaoExata = api.podeAgendarNotificacaoExata;
@@ -151,16 +604,47 @@ if (typeof window !== "undefined") {
   window.iniciarIconeFlutuante = api.iniciarIconeFlutuante;
   window.pararIconeFlutuante = api.pararIconeFlutuante;
   window.obterNotificacaoInicial = api.obterNotificacaoInicial;
+  window.obterLinkInicial = api.obterLinkInicial;
+  window.aoEvento = api.aoEvento;
+  window.aoMinimizar = api.aoMinimizar;
+  window.aoVoltarParaApp = api.aoVoltarParaApp;
+  window.aoAbrirLink = api.aoAbrirLink;
+  window.aoMudarRede = api.aoMudarRede;
+  window.aoMudarBateria = api.aoMudarBateria;
   window.aoClicarNotificacao = api.aoClicarNotificacao;
 
+  Object.keys(api).forEach(function (key) {
+    if (key.indexOf("__") === 0) {
+      return;
+    }
+
+    window[key] = api[key];
+  });
+
   window.addEventListener("html2apk:notification", function (event) {
     emitNotificationClick(event.detail);
   });
 
+  window.addEventListener("html2apk:event", function (event) {
+    emitEvent(event.detail && event.detail.type, event.detail);
+  });
+
+  document.addEventListener("backbutton", function () {
+    emitEvent("botao:voltar", { type: "botao:voltar", timestamp: Date.now() });
+  }, false);
+
   document.addEventListener("deviceready", function () {
+    emitEvent("app:pronto", { type: "app:pronto", timestamp: Date.now() });
     api.obterNotificacaoInicial().then(function (notification) {
       if (notification) {
         emitNotificationClick(notification);
+        emitEvent("notificacao:clicada", notification);
+      }
+    });
+    api.obterLinkInicial().then(function (link) {
+      if (link) {
+        initialLink = link;
+        emitEvent("link:aberto", link);
       }
     });
   }, false);