html2apk 0.9.0 → 12.0.0

package/src/templates/html2apk-early-bridge.js

@@ -7,6 +7,8 @@
 
   var deviceReady = typeof document === "undefined";
   var readyCallbacks = [];
+  var bluetoothServerStartPromise = null;
+  var wifiServerStartPromise = null;
   var scheduledNotificationCounter = 0;
   var notificationActionCounter = 0;
   var notificationActionCallbacks = {};
@@ -21,6 +23,33 @@
     "battery:changed": "bateria:mudou",
     "location:changed": "localizacao:mudou",
     "biometric:failed": "biometria:falhou",
+    "share:received": "compartilhamento:recebido",
+    "sharing:received": "compartilhamento:recebido",
+    "bt:connected": "bluetooth:conectado",
+    "bluetooth:connected": "bluetooth:conectado",
+    "bt:data": "bluetooth:dados",
+    "bluetooth:data": "bluetooth:dados",
+    "bt:disconnected": "bluetooth:desconectado",
+    "bluetooth:disconnected": "bluetooth:desconectado",
+    "bt:error": "bluetooth:erro",
+    "bluetooth:error": "bluetooth:erro",
+    "wifi:connected": "wifi:conectado",
+    "wifi:data": "wifi:dados",
+    "wifi:disconnected": "wifi:desconectado",
+    "wifi:error": "wifi:erro",
+    "usb:connected": "usb:conectado",
+    "usb:disconnected": "usb:desconectado",
+    "headphone:connected": "fone:conectado",
+    "headphone:disconnected": "fone:desconectado",
+    "volume:changed": "volume:mudou",
+    "keyboard:opened": "teclado:abriu",
+    "keyboard:closed": "teclado:fechou",
+    "phone:shaken": "celular:sacudido",
+    "phone:faceDown": "celular:tela_para_baixo",
+    "proximity:near": "proximidade:perto",
+    "screenshot:taken": "print:tela",
+    "orientation:changed": "orientacao:mudou",
+    "nfc:received": "nfc:recebido",
     "notification:received": "notificacao:recebida",
     "notification:clicked": "notificacao:clicada"
   };
@@ -28,6 +57,7 @@
   var notificationListeners = [];
   var initialNotification = null;
   var initialLink = null;
+  var initialShare = null;
 
   function markReady() {
     if (deviceReady) {
@@ -474,16 +504,20 @@
     return normalized;
   }
 
-  function downloadFileOptions(urlOrOptions, nameOrOptions) {
+  function downloadFileOptions(urlOrOptions, nameOrOptions, options) {
     var normalized;
     var source;
 
     if (urlOrOptions && typeof urlOrOptions === "object" && !Array.isArray(urlOrOptions)) {
       normalized = cloneSerializable(urlOrOptions) || {};
-      return applyDownloadName(normalized, nameOrOptions);
+      applyDownloadName(normalized, nameOrOptions);
+      if (options && typeof options === "object" && !Array.isArray(options)) {
+        Object.assign(normalized, cloneSerializable(options) || {});
+      }
+      return normalized;
     }
 
-    normalized = {};
+    normalized = cloneSerializable(options || {}) || {};
     source = String(urlOrOptions || "").trim();
     if (source.indexOf("data:") === 0) {
       applyBase64DownloadSource(normalized, source);
@@ -510,16 +544,20 @@
     return applyBase64DownloadSource(normalized, base64);
   }
 
-  function downloadLocalFileOptions(fileOrOptions, nameOrOptions) {
+  function downloadLocalFileOptions(fileOrOptions, nameOrOptions, options) {
     var normalized;
     var source;
 
     if (fileOrOptions && typeof fileOrOptions === "object" && !Array.isArray(fileOrOptions)) {
       normalized = cloneSerializable(fileOrOptions) || {};
-      return applyDownloadName(normalized, nameOrOptions);
+      applyDownloadName(normalized, nameOrOptions);
+      if (options && typeof options === "object" && !Array.isArray(options)) {
+        Object.assign(normalized, cloneSerializable(options) || {});
+      }
+      return normalized;
     }
 
-    normalized = {};
+    normalized = cloneSerializable(options || {}) || {};
     source = String(fileOrOptions || "").trim();
     if (/^(content|file):\/\//.test(source)) {
       normalized.uri = source;
@@ -534,6 +572,115 @@
     return applyDownloadName(normalized, nameOrOptions);
   }
 
+  function ocrOptions(sourceOrOptions) {
+    if (sourceOrOptions && typeof sourceOrOptions === "object" && !Array.isArray(sourceOrOptions)) {
+      return cloneSerializable(sourceOrOptions) || {};
+    }
+    var source = String(sourceOrOptions || "").trim();
+    if (source.indexOf("data:") === 0) {
+      return { base64: source };
+    }
+    if (/^(content|file):\/\//.test(source)) {
+      return { uri: source, contentUri: source };
+    }
+    if (/^[A-Za-z]:[\\/]/.test(source) || source.charAt(0) === "/" || source.charAt(0) === "\\") {
+      return { path: source, caminho: source };
+    }
+    return { name: source, nome: source };
+  }
+
+  function normalizeReceivedShare(detail) {
+    var normalized = cloneSerializable(detail || {}) || {};
+    var kind = normalized.tipoConteudo || normalized.contentType || normalized.tipo || normalized.type;
+    if (kind) {
+      normalized.tipo = kind;
+      normalized.type = kind;
+    }
+    return normalized;
+  }
+
+  function bluetoothReceivedData(detail) {
+    if (!detail || typeof detail !== "object") {
+      return detail;
+    }
+    if (Object.prototype.hasOwnProperty.call(detail, "dados")) {
+      return detail.dados;
+    }
+    if (Object.prototype.hasOwnProperty.call(detail, "data")) {
+      return detail.data;
+    }
+    return detail;
+  }
+
+  function bluetoothErrorDetail(errorOrDetail) {
+    var detail = errorOrDetail && typeof errorOrDetail === "object"
+      ? cloneSerializable(errorOrDetail) || {}
+      : {};
+    var message = detail.message || detail.mensagem || detail.error || detail.erro ||
+      (errorOrDetail && (errorOrDetail.message || errorOrDetail.mensagem || errorOrDetail.error || errorOrDetail.erro)) ||
+      String(errorOrDetail || "");
+    detail.ok = false;
+    detail.message = message;
+    detail.mensagem = message;
+    detail.error = message;
+    detail.erro = message;
+    detail.timestamp = detail.timestamp || Date.now();
+    return detail;
+  }
+
+  function startBluetoothServerSilently() {
+    if (bluetoothServerStartPromise) {
+      return bluetoothServerStartPromise;
+    }
+
+    bluetoothServerStartPromise = call("startBluetoothServer").catch(function (error) {
+      bluetoothServerStartPromise = null;
+      emitEvent("bluetooth:erro", bluetoothErrorDetail(error));
+    });
+    return bluetoothServerStartPromise;
+  }
+
+  function wifiReceivedData(detail) {
+    if (!detail || typeof detail !== "object") {
+      return detail;
+    }
+    if (Object.prototype.hasOwnProperty.call(detail, "dados")) {
+      return detail.dados;
+    }
+    if (Object.prototype.hasOwnProperty.call(detail, "data")) {
+      return detail.data;
+    }
+    return detail;
+  }
+
+  function wifiErrorDetail(errorOrDetail) {
+    var detail = errorOrDetail && typeof errorOrDetail === "object"
+      ? cloneSerializable(errorOrDetail) || {}
+      : {};
+    var message = detail.message || detail.mensagem || detail.error || detail.erro ||
+      (errorOrDetail && (errorOrDetail.message || errorOrDetail.mensagem || errorOrDetail.error || errorOrDetail.erro)) ||
+      String(errorOrDetail || "");
+    detail.ok = false;
+    detail.message = message;
+    detail.mensagem = message;
+    detail.error = message;
+    detail.erro = message;
+    detail.timestamp = detail.timestamp || Date.now();
+    return detail;
+  }
+
+  function startWifiServerSilently() {
+    if (wifiServerStartPromise) {
+      return wifiServerStartPromise;
+    }
+
+    wifiServerStartPromise = call("startWifiServer").catch(function (error) {
+      wifiServerStartPromise = null;
+      emitEvent("wifi:erro", wifiErrorDetail(error));
+    });
+    return wifiServerStartPromise;
+  }
+
   function wallpaperOptions(sourceOrOptions, options) {
     var normalized;
     var source;
@@ -578,6 +725,61 @@
     return normalized;
   }
 
+  function volumeOptions(streamOrOptions, value, options) {
+    var normalized = {};
+    if (streamOrOptions && typeof streamOrOptions === "object" && !Array.isArray(streamOrOptions)) {
+      normalized = cloneSerializable(streamOrOptions) || {};
+    } else {
+      if (typeof streamOrOptions === "number") {
+        normalized.value = streamOrOptions;
+        normalized.valor = streamOrOptions;
+      } else if (typeof streamOrOptions === "string") {
+        normalized.stream = streamOrOptions;
+        normalized.tipo = streamOrOptions;
+      }
+      if (typeof value !== "undefined" && value !== null && typeof value !== "object") {
+        normalized.value = value;
+        normalized.valor = value;
+      }
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        Object.assign(normalized, cloneSerializable(value) || {});
+      }
+      if (options && typeof options === "object" && !Array.isArray(options)) {
+        Object.assign(normalized, cloneSerializable(options) || {});
+      }
+    }
+    return normalized;
+  }
+
+  function adjustVolumeOptions(streamOrOptions, amountOrOptions, options, direction) {
+    var normalized = volumeOptions(streamOrOptions);
+    if (typeof amountOrOptions === "number") {
+      normalized.amount = amountOrOptions;
+      normalized.quantidade = amountOrOptions;
+    } else if (amountOrOptions && typeof amountOrOptions === "object" && !Array.isArray(amountOrOptions)) {
+      Object.assign(normalized, cloneSerializable(amountOrOptions) || {});
+    }
+    if (options && typeof options === "object" && !Array.isArray(options)) {
+      Object.assign(normalized, cloneSerializable(options) || {});
+    }
+    normalized.direction = direction;
+    normalized.direcao = direction;
+    return normalized;
+  }
+
+  function floatingIconOptions(optionsOrOpacity) {
+    if (optionsOrOpacity && typeof optionsOrOpacity === "object" && !Array.isArray(optionsOrOpacity)) {
+      return cloneSerializable(optionsOrOpacity) || {};
+    }
+    if (typeof optionsOrOpacity === "number" || typeof optionsOrOpacity === "string") {
+      return {
+        opacity: Number(optionsOrOpacity),
+        opacidade: Number(optionsOrOpacity)
+      };
+    }
+    return {};
+  }
+
   function secureItemOptions(keyOrOptions, value, options) {
     var normalized;
     if (keyOrOptions && typeof keyOrOptions === "object" && !Array.isArray(keyOrOptions)) {
@@ -817,6 +1019,14 @@
     toast: function (message) {
       return call("toast", [String(message || "")]);
     },
+    aguardar: function (ms) {
+      var delay = Math.max(0, Math.min(Number(ms) || 0, 2147483647));
+      return new Promise(function (resolve) {
+        setTimeout(function () {
+          resolve({ ok: true, ms: delay });
+        }, delay);
+      });
+    },
     fullscreen: function (enabled) {
       return call("fullscreen", [Boolean(enabled)]);
     },
@@ -877,6 +1087,87 @@
     compartilhar: function (options) {
       return call("share", [options || {}]);
     },
+    compartilharApp: function (options) {
+      return call("shareCurrentApp", [options || {}]);
+    },
+    procurarBT: function (options) {
+      return call("scanBluetooth", [options || {}]);
+    },
+    conectarBT: function (idDispositivo) {
+      return call("connectBluetooth", [String(idDispositivo || "")]);
+    },
+    enviarBT: function (data) {
+      return call("sendBluetooth", [data]);
+    },
+    aoConectarBT: function (listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError("listener must be a function");
+      }
+      startBluetoothServerSilently();
+      return onEvent("bluetooth:conectado", listener);
+    },
+    aoReceberDadosBT: function (listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError("listener must be a function");
+      }
+      startBluetoothServerSilently();
+      return onEvent("bluetooth:dados", function (detail) {
+        listener(bluetoothReceivedData(detail));
+      });
+    },
+    aoDarErroBT: function (listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError("listener must be a function");
+      }
+      return onEvent("bluetooth:erro", function (detail) {
+        listener(bluetoothErrorDetail(detail));
+      });
+    },
+    procurarWiFi: function (options) {
+      return call("scanWifi", [options || {}]);
+    },
+    conectarWiFi: function (idDispositivo) {
+      return call("connectWifi", [String(idDispositivo || "")]);
+    },
+    enviarWiFi: function (data) {
+      return call("sendWifi", [data]);
+    },
+    aoConectarWiFi: function (listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError("listener must be a function");
+      }
+      startWifiServerSilently();
+      return onEvent("wifi:conectado", listener);
+    },
+    aoReceberDadosWiFi: function (listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError("listener must be a function");
+      }
+      startWifiServerSilently();
+      return onEvent("wifi:dados", function (detail) {
+        listener(wifiReceivedData(detail));
+      });
+    },
+    aoDarErroWiFi: function (listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError("listener must be a function");
+      }
+      return onEvent("wifi:erro", function (detail) {
+        listener(wifiErrorDetail(detail));
+      });
+    },
+    ocr: function (sourceOrOptions) {
+      return call("ocr", [ocrOptions(sourceOrOptions)]);
+    },
+    falar: function (text, options) {
+      return call("speakText", [String(text || ""), options || {}]);
+    },
+    pararFala: function () {
+      return call("stopSpeaking");
+    },
+    ouvir: function (options) {
+      return call("recognizeSpeech", [options || {}]);
+    },
     abrirUrl: function (url) {
       return call("openUrl", [String(url || "")]);
     },
@@ -945,14 +1236,14 @@
     compartilharArquivo: function (nameOrOptions, options) {
       return call("shareStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
     },
-    baixarArquivo: function (urlOrOptions, nameOrOptions) {
-      return call("downloadFile", [downloadFileOptions(urlOrOptions, nameOrOptions)]);
+    baixarArquivo: function (urlOrOptions, nameOrOptions, options) {
+      return call("downloadFile", [downloadFileOptions(urlOrOptions, nameOrOptions, options)]);
     },
     baixarBase64: function (nameOrOptions, base64, options) {
       return call("downloadFile", [downloadBase64Options(nameOrOptions, base64, options)]);
     },
-    baixarArquivoLocal: function (fileOrOptions, nameOrOptions) {
-      return call("downloadFile", [downloadLocalFileOptions(fileOrOptions, nameOrOptions)]);
+    baixarArquivoLocal: function (fileOrOptions, nameOrOptions, options) {
+      return call("downloadFile", [downloadLocalFileOptions(fileOrOptions, nameOrOptions, options)]);
     },
     definirPapelParede: function (sourceOrOptions, options) {
       return call("setWallpaper", [wallpaperOptions(sourceOrOptions, options)]);
@@ -963,6 +1254,12 @@
     abrirConfiguracaoPapelParede: function () {
       return call("openWallpaperSettings");
     },
+    capturarTela: function (options) {
+      return call("captureScreen", [options || {}]);
+    },
+    tirarPrint: function (options) {
+      return call("captureScreen", [options || {}]);
+    },
     infoDispositivo: function () {
       return call("deviceInfo");
     },
@@ -981,6 +1278,18 @@
     infoDesempenho: function () {
       return call("performanceInfo");
     },
+    volumeAtual: function () {
+      return call("getVolume");
+    },
+    definirVolume: function (streamOrOptions, value, options) {
+      return call("setVolume", [volumeOptions(streamOrOptions, value, options)]);
+    },
+    aumentarVolume: function (streamOrOptions, amountOrOptions, options) {
+      return call("adjustVolume", [adjustVolumeOptions(streamOrOptions, amountOrOptions, options, "up")]);
+    },
+    diminuirVolume: function (streamOrOptions, amountOrOptions, options) {
+      return call("adjustVolume", [adjustVolumeOptions(streamOrOptions, amountOrOptions, options, "down")]);
+    },
     appsAbertos: function () {
       return call("openAppsMemory");
     },
@@ -999,9 +1308,47 @@
     aoMudarLocalizacao: function (listener) {
       return onEvent("localizacao:mudou", listener);
     },
+    medirVelocidade: function (callback, options) {
+      var listener = function (local) {
+        if (typeof callback !== "function") return;
+        var ms = typeof local.velocidade === "number" ? local.velocidade : 0;
+        var kmh = ms * 3.6;
+        callback(kmh, local);
+      };
+      var stopEvent = api.aoMudarLocalizacao(listener);
+      return api.acompanharLocalizacao(Object.assign({ altaPrecisao: true, intervaloMs: 2000 }, options || {}))
+        .then(function (result) {
+          var watchId = result && result.watchId;
+          return function pararMedicao() {
+            stopEvent();
+            if (watchId) {
+              return api.pararLocalizacao(watchId);
+            }
+            return Promise.resolve();
+          };
+        });
+    },
     autenticarBiometria: function (options) {
       return call("authenticateBiometric", [options || {}]);
     },
+    solicitarBloqueio: function (options) {
+      return call("requestDeviceLock", [options || {}]);
+    },
+    solicitarSegundoPlano: function (options) {
+      return call("requestBackgroundExecution", [options || {}]);
+    },
+    configurarInicioAutomatico: function (enable) {
+      return call("setAutoStartOnBoot", [{ ativar: !!enable }]);
+    },
+    aoLigarDispositivo: function (callback) {
+      if (typeof callback === "function") {
+        call("getInitialLink").then(function(link) {
+          if (link === "html2apk://boot") {
+            callback();
+          }
+        });
+      }
+    },
     salvarSeguro: function (keyOrOptions, value, options) {
       return call("saveSecureItem", [secureItemOptions(keyOrOptions, value, options)]);
     },
@@ -1044,12 +1391,24 @@
     abrirConfiguracaoSobreposicao: function () {
       return call("openOverlaySettings");
     },
-    iniciarIconeFlutuante: function () {
-      return call("startFloatingIcon");
+    iniciarIconeFlutuante: function (options) {
+      return call("startFloatingIcon", [floatingIconOptions(options)]);
     },
     pararIconeFlutuante: function () {
       return call("stopFloatingIcon");
     },
+    configurarIconeFlutuante: function (options) {
+      return call("configureFloatingIcon", [floatingIconOptions(options)]);
+    },
+    definirOpacidadeIconeFlutuante: function (opacity) {
+      return call("configureFloatingIcon", [floatingIconOptions(opacity)]);
+    },
+    minimizarApp: function () {
+      return call("minimizeApp");
+    },
+    fecharApp: function () {
+      return call("closeApp");
+    },
     obterNotificacaoInicial: function () {
       return call("getInitialNotification").then(function (notification) {
         initialNotification = notification && notification.id ? notification : null;
@@ -1062,6 +1421,12 @@
         return initialLink;
       });
     },
+    obterCompartilhamentoInicial: function () {
+      return call("getInitialShare").then(function (share) {
+        initialShare = share && (share.text || share.texto || share.uri || (share.items && share.items.length)) ? normalizeReceivedShare(share) : null;
+        return initialShare;
+      });
+    },
     aoEvento: onEvent,
     aoMinimizar: function (listener) {
       return onEvent("app:background", listener);
@@ -1077,12 +1442,67 @@
       }
       return onEvent("link:aberto", listener);
     },
+    aoReceberCompartilhamento: function (listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError("listener must be a function");
+      }
+      if (initialShare) {
+        setTimeout(function () {
+          listener(normalizeReceivedShare(initialShare));
+        }, 0);
+      }
+      return onEvent("compartilhamento:recebido", function (detail) {
+        listener(normalizeReceivedShare(detail));
+      });
+    },
     aoMudarRede: function (listener) {
       return onEvent("rede:mudou", listener);
     },
     aoMudarBateria: function (listener) {
       return onEvent("bateria:mudou", listener);
     },
+    aoConectarUSB: function (listener) {
+      return onEvent("usb:conectado", listener);
+    },
+    aoDesconectarUSB: function (listener) {
+      return onEvent("usb:desconectado", listener);
+    },
+    aoConectarFone: function (listener) {
+      return onEvent("fone:conectado", listener);
+    },
+    aoDesconectarFone: function (listener) {
+      return onEvent("fone:desconectado", listener);
+    },
+    aoMudarVolume: function (listener) {
+      return onEvent("volume:mudou", listener);
+    },
+    aoAbrirTeclado: function (listener) {
+      return onEvent("teclado:abriu", listener);
+    },
+    aoFecharTeclado: function (listener) {
+      return onEvent("teclado:fechou", listener);
+    },
+    aoSacudirCelular: function (listener) {
+      return onEvent("celular:sacudido", listener);
+    },
+    aoVirarCelularParaBaixo: function (listener) {
+      return onEvent("celular:tela_para_baixo", listener);
+    },
+    aoAproximarObjeto: function (listener) {
+      return onEvent("proximidade:perto", listener);
+    },
+    aoTirarPrint: function (listener) {
+      return onEvent("print:tela", listener);
+    },
+    aoMudarOrientacao: function (listener) {
+      return onEvent("orientacao:mudou", listener);
+    },
+    aoNFC: function (listener) {
+      return onEvent("nfc:recebido", listener);
+    },
+    aoReceberNotificacao: function (listener) {
+      return onEvent("notificacao:recebida", listener);
+    },
     aoClicarNotificacao: function (listener) {
       if (typeof listener !== "function") {
         throw new TypeError("listener must be a function");
@@ -1107,6 +1527,7 @@
     cancelNotification: api.cancelarNotificacao,
     cancelNotificationLoop: api.cancelarLoopNotificacoes,
     vibrate: api.vibrar,
+    loading: api.aguardar,
     manterTelaLigada: api.manterTelaAcordada,
     keepScreenAwake: api.manterTelaAcordada,
     keepScreenOn: api.manterTelaAcordada,
@@ -1133,6 +1554,46 @@
     readText: api.lerTextoCopiado,
     shareText: api.compartilharTexto,
     share: api.compartilhar,
+    shareApp: api.compartilharApp,
+    share_me: api.compartilharApp,
+    scanBluetooth: api.procurarBT,
+    procurarBluetooth: api.procurarBT,
+    buscarBT: api.procurarBT,
+    connectBluetooth: api.conectarBT,
+    conectarBluetooth: api.conectarBT,
+    sendBluetooth: api.enviarBT,
+    onBluetoothConnect: api.aoConectarBT,
+    onBluetoothConnected: api.aoConectarBT,
+    onBluetoothData: api.aoReceberDadosBT,
+    onBTData: api.aoReceberDadosBT,
+    onBluetoothError: api.aoDarErroBT,
+    onBTError: api.aoDarErroBT,
+    scanWiFi: api.procurarWiFi,
+    scanWifi: api.procurarWiFi,
+    procurarWifi: api.procurarWiFi,
+    connectWiFi: api.conectarWiFi,
+    connectWifi: api.conectarWiFi,
+    conectarWifi: api.conectarWiFi,
+    sendWiFi: api.enviarWiFi,
+    sendWifi: api.enviarWiFi,
+    enviarWifi: api.enviarWiFi,
+    onWiFiConnect: api.aoConectarWiFi,
+    onWifiConnect: api.aoConectarWiFi,
+    onWiFiConnected: api.aoConectarWiFi,
+    onWifiConnected: api.aoConectarWiFi,
+    onWiFiData: api.aoReceberDadosWiFi,
+    onWifiData: api.aoReceberDadosWiFi,
+    onWiFiError: api.aoDarErroWiFi,
+    onWifiError: api.aoDarErroWiFi,
+    recognizeText: api.ocr,
+    textFromImage: api.ocr,
+    speak: api.falar,
+    textToSpeech: api.falar,
+    stopSpeaking: api.pararFala,
+    stopSpeech: api.pararFala,
+    listen: api.ouvir,
+    recognizeSpeech: api.ouvir,
+    speechToText: api.ouvir,
     openUrl: api.abrirUrl,
     openExternalUrl: api.abrirUrl,
     abrirUrlExterno: api.abrirUrl,
@@ -1178,19 +1639,32 @@
     wallpaper: api.definirPapelParede,
     wallpaperInfo: api.infoPapelParede,
     openWallpaperSettings: api.abrirConfiguracaoPapelParede,
+    captureScreen: api.capturarTela,
+    takeScreenshot: api.capturarTela,
+    screenshot: api.capturarTela,
     deviceInfo: api.infoDispositivo,
     networkInfo: api.infoRede,
     batteryInfo: api.infoBateria,
     memoryInfo: api.infoMemoria,
     storageInfo: api.infoArmazenamento,
     performanceInfo: api.infoDesempenho,
+    currentVolume: api.volumeAtual,
+    getVolume: api.volumeAtual,
+    setVolume: api.definirVolume,
+    increaseVolume: api.aumentarVolume,
+    decreaseVolume: api.diminuirVolume,
     openAppsMemory: api.appsAbertos,
     openAppsInfo: api.infoAppsAbertos,
     getLocation: api.obterLocalizacao,
     watchLocation: api.acompanharLocalizacao,
     stopLocationWatch: api.pararLocalizacao,
     onLocationChange: api.aoMudarLocalizacao,
+    measureSpeed: api.medirVelocidade,
     authenticateBiometric: api.autenticarBiometria,
+    requestDeviceLock: api.solicitarBloqueio,
+    requestBackgroundExecution: api.solicitarSegundoPlano,
+    setAutoStartOnBoot: api.configurarInicioAutomatico,
+    onDeviceBoot: api.aoLigarDispositivo,
     saveSecure: api.salvarSeguro,
     secureSet: api.salvarSeguro,
     readSecure: api.lerSeguro,
@@ -1210,15 +1684,51 @@
     requestOverlayPermission: api.solicitarPermissaoSobreposicao,
     openOverlaySettings: api.abrirConfiguracaoSobreposicao,
     startFloatingIcon: api.iniciarIconeFlutuante,
+    configureFloatingIcon: api.configurarIconeFlutuante,
+    setFloatingIconOpacity: api.definirOpacidadeIconeFlutuante,
     stopFloatingIcon: api.pararIconeFlutuante,
+    minimizeApp: api.minimizarApp,
+    closeApp: api.fecharApp,
+    exitApp: api.fecharApp,
     getInitialNotification: api.obterNotificacaoInicial,
     getInitialLink: api.obterLinkInicial,
+    getInitialShare: api.obterCompartilhamentoInicial,
+    onShareReceived: api.aoReceberCompartilhamento,
+    onReceiveShare: api.aoReceberCompartilhamento,
     onEvent: api.aoEvento,
     onMinimize: api.aoMinimizar,
     onAppResume: api.aoVoltarParaApp,
     onOpenLink: api.aoAbrirLink,
     onNetworkChange: api.aoMudarRede,
     onBatteryChange: api.aoMudarBateria,
+    onUSBConnect: api.aoConectarUSB,
+    onUsbConnect: api.aoConectarUSB,
+    onUSBDisconnect: api.aoDesconectarUSB,
+    onUsbDisconnect: api.aoDesconectarUSB,
+    onHeadphoneConnect: api.aoConectarFone,
+    onHeadphoneConnected: api.aoConectarFone,
+    onHeadphoneDisconnect: api.aoDesconectarFone,
+    onHeadphoneDisconnected: api.aoDesconectarFone,
+    onVolumeChange: api.aoMudarVolume,
+    onKeyboardOpen: api.aoAbrirTeclado,
+    onKeyboardOpened: api.aoAbrirTeclado,
+    onKeyboardClose: api.aoFecharTeclado,
+    onKeyboardClosed: api.aoFecharTeclado,
+    onPhoneShake: api.aoSacudirCelular,
+    onShake: api.aoSacudirCelular,
+    onPhoneFaceDown: api.aoVirarCelularParaBaixo,
+    onFaceDown: api.aoVirarCelularParaBaixo,
+    onProximityNear: api.aoAproximarObjeto,
+    onObjectNear: api.aoAproximarObjeto,
+    onScreenshot: api.aoTirarPrint,
+    onScreenshotTaken: api.aoTirarPrint,
+    onOrientationChange: api.aoMudarOrientacao,
+    onNFC: api.aoNFC,
+    onNfc: api.aoNFC,
+    onNFCReceived: api.aoNFC,
+    onNfcReceived: api.aoNFC,
+    onNotificationReceived: api.aoReceberNotificacao,
+    onReceiveNotification: api.aoReceberNotificacao,
     onNotificationClick: api.aoClicarNotificacao
   });
 
@@ -1257,6 +1767,12 @@
           emitEvent("link:aberto", link);
         }
       });
+      api.obterCompartilhamentoInicial().then(function (share) {
+        if (share) {
+          initialShare = share;
+          emitEvent("compartilhamento:recebido", share);
+        }
+      });
     }, false);
   }
 })();