html2apk 0.9.0 → 12.0.0

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

@@ -7,6 +7,9 @@ var notificationListeners = [];
 var eventListeners = {};
 var initialNotification = null;
 var initialLink = null;
+var initialShare = null;
+var bluetoothServerStartPromise = null;
+var wifiServerStartPromise = null;
 var scheduledNotificationCounter = 0;
 var notificationActionCounter = 0;
 var notificationActionCallbacks = {};
@@ -23,6 +26,33 @@ var eventAliases = {
   "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"
 };
@@ -605,16 +635,20 @@ function applyBase64DownloadSource(normalized, value) {
   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);
@@ -641,16 +675,20 @@ function downloadBase64Options(nameOrOptions, base64, options) {
   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;
@@ -665,6 +703,115 @@ function downloadLocalFileOptions(fileOrOptions, nameOrOptions) {
   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;
@@ -709,6 +856,61 @@ function wallpaperOptions(sourceOrOptions, options) {
   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)) {
@@ -830,6 +1032,14 @@ var api = {
   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)]);
   },
@@ -890,6 +1100,87 @@ var api = {
   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 || "")]);
   },
@@ -964,14 +1255,14 @@ var api = {
   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)]);
@@ -982,6 +1273,12 @@ var api = {
   abrirConfiguracaoPapelParede: function () {
     return call("openWallpaperSettings");
   },
+  capturarTela: function (options) {
+    return call("captureScreen", [options || {}]);
+  },
+  tirarPrint: function (options) {
+    return call("captureScreen", [options || {}]);
+  },
   infoDispositivo: function () {
     return call("deviceInfo");
   },
@@ -1000,6 +1297,18 @@ var api = {
   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");
   },
@@ -1018,9 +1327,47 @@ var api = {
   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)]);
   },
@@ -1063,12 +1410,24 @@ var api = {
   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;
@@ -1081,6 +1440,12 @@ var api = {
       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);
@@ -1099,12 +1464,67 @@ var api = {
     }
     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");
@@ -1137,6 +1557,7 @@ Object.assign(api, {
   cancelNotification: api.cancelarNotificacao,
   cancelNotificationLoop: api.cancelarLoopNotificacoes,
   vibrate: api.vibrar,
+  loading: api.aguardar,
   manterTelaLigada: api.manterTelaAcordada,
   keepScreenAwake: api.manterTelaAcordada,
   keepScreenOn: api.manterTelaAcordada,
@@ -1163,6 +1584,46 @@ Object.assign(api, {
   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.abrirUrlExterno,
   openOutsideApp: api.abrirForaDoApp,
@@ -1206,19 +1667,32 @@ Object.assign(api, {
   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,
@@ -1238,15 +1712,51 @@ Object.assign(api, {
   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
 });
 
@@ -1348,6 +1858,12 @@ if (typeof window !== "undefined") {
         emitEvent("link:aberto", link);
       }
     });
+    api.obterCompartilhamentoInicial().then(function (share) {
+      if (share) {
+        initialShare = share;
+        emitEvent("compartilhamento:recebido", share);
+      }
+    });
   }, false);
 }