html2apk 0.8.0 → 0.11.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 = {};
@@ -19,6 +21,35 @@
     "link:opened": "link:aberto",
     "network:changed": "rede:mudou",
     "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"
   };
@@ -26,6 +57,7 @@
   var notificationListeners = [];
   var initialNotification = null;
   var initialLink = null;
+  var initialShare = null;
 
   function markReady() {
     if (deviceReady) {
@@ -406,6 +438,440 @@
     });
   }
 
+  function hasOwn(object, key) {
+    return Object.prototype.hasOwnProperty.call(object || {}, key);
+  }
+
+  function storedFileOptions(nameOrOptions, value, options) {
+    var normalized;
+    if (nameOrOptions && typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions)) {
+      return cloneSerializable(nameOrOptions) || {};
+    }
+
+    normalized = cloneSerializable(options || {}) || {};
+    normalized.name = String(nameOrOptions || "");
+    normalized.nome = normalized.name;
+    normalized.value = cloneSerializable(value);
+    normalized.valor = normalized.value;
+    if (typeof value !== "string" && !hasOwn(normalized, "json")) {
+      normalized.json = true;
+    }
+    return normalized;
+  }
+
+  function storedFileNameOptions(nameOrOptions, options) {
+    var normalized;
+    if (nameOrOptions && typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions)) {
+      return cloneSerializable(nameOrOptions) || {};
+    }
+    normalized = cloneSerializable(options || {}) || {};
+    normalized.name = String(nameOrOptions || "");
+    normalized.nome = normalized.name;
+    return normalized;
+  }
+
+  function applyDownloadName(normalized, nameOrOptions) {
+    if (typeof nameOrOptions === "string") {
+      normalized.name = nameOrOptions;
+      normalized.nome = nameOrOptions;
+      normalized.fileName = nameOrOptions;
+      normalized.nomeArquivo = nameOrOptions;
+    } else if (nameOrOptions && typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions)) {
+      Object.assign(normalized, cloneSerializable(nameOrOptions) || {});
+    }
+    return normalized;
+  }
+
+  function applyBase64DownloadSource(normalized, value) {
+    var source = String(value || "");
+    var comma;
+    var header;
+    var mimeType;
+
+    if (source.indexOf("data:") === 0) {
+      comma = source.indexOf(",");
+      header = comma >= 0 ? source.slice(5, comma) : "";
+      mimeType = header.split(";")[0];
+      normalized.base64 = comma >= 0 ? source.slice(comma + 1) : source;
+      if (mimeType) {
+        normalized.mimeType = normalized.mimeType || mimeType;
+        normalized.tipoMime = normalized.tipoMime || mimeType;
+      }
+      return normalized;
+    }
+
+    normalized.base64 = source;
+    return normalized;
+  }
+
+  function downloadFileOptions(urlOrOptions, nameOrOptions, options) {
+    var normalized;
+    var source;
+
+    if (urlOrOptions && typeof urlOrOptions === "object" && !Array.isArray(urlOrOptions)) {
+      normalized = cloneSerializable(urlOrOptions) || {};
+      applyDownloadName(normalized, nameOrOptions);
+      if (options && typeof options === "object" && !Array.isArray(options)) {
+        Object.assign(normalized, cloneSerializable(options) || {});
+      }
+      return normalized;
+    }
+
+    normalized = cloneSerializable(options || {}) || {};
+    source = String(urlOrOptions || "").trim();
+    if (source.indexOf("data:") === 0) {
+      applyBase64DownloadSource(normalized, source);
+    } else {
+      normalized.url = source;
+    }
+    return applyDownloadName(normalized, nameOrOptions);
+  }
+
+  function downloadBase64Options(nameOrOptions, base64, options) {
+    var normalized;
+    if (nameOrOptions && typeof nameOrOptions === "object" && !Array.isArray(nameOrOptions)) {
+      normalized = cloneSerializable(nameOrOptions) || {};
+      if (typeof base64 === "string") {
+        applyBase64DownloadSource(normalized, base64);
+      } else if (base64 && typeof base64 === "object" && !Array.isArray(base64)) {
+        Object.assign(normalized, cloneSerializable(base64) || {});
+      }
+      return normalized;
+    }
+
+    normalized = cloneSerializable(options || {}) || {};
+    applyDownloadName(normalized, String(nameOrOptions || ""));
+    return applyBase64DownloadSource(normalized, base64);
+  }
+
+  function downloadLocalFileOptions(fileOrOptions, nameOrOptions, options) {
+    var normalized;
+    var source;
+
+    if (fileOrOptions && typeof fileOrOptions === "object" && !Array.isArray(fileOrOptions)) {
+      normalized = cloneSerializable(fileOrOptions) || {};
+      applyDownloadName(normalized, nameOrOptions);
+      if (options && typeof options === "object" && !Array.isArray(options)) {
+        Object.assign(normalized, cloneSerializable(options) || {});
+      }
+      return normalized;
+    }
+
+    normalized = cloneSerializable(options || {}) || {};
+    source = String(fileOrOptions || "").trim();
+    if (/^(content|file):\/\//.test(source)) {
+      normalized.uri = source;
+      normalized.contentUri = source;
+    } else if (/^[A-Za-z]:[\\/]/.test(source) || source.charAt(0) === "/" || source.charAt(0) === "\\") {
+      normalized.path = source;
+      normalized.caminho = source;
+    } else {
+      normalized.sourceName = source;
+      normalized.arquivoOrigem = source;
+    }
+    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;
+    var comma;
+    var header;
+    var mimeType;
+
+    if (sourceOrOptions && typeof sourceOrOptions === "object" && !Array.isArray(sourceOrOptions)) {
+      normalized = cloneSerializable(sourceOrOptions) || {};
+    } else {
+      normalized = cloneSerializable(options || {}) || {};
+      source = String(sourceOrOptions || "").trim();
+      if (source.indexOf("data:") === 0) {
+        comma = source.indexOf(",");
+        header = comma >= 0 ? source.slice(5, comma) : "";
+        mimeType = header.split(";")[0];
+        normalized.base64 = comma >= 0 ? source.slice(comma + 1) : source;
+        if (mimeType) {
+          normalized.mimeType = normalized.mimeType || mimeType;
+          normalized.tipoMime = normalized.tipoMime || mimeType;
+        }
+      } else if (/^(content|file):\/\//.test(source)) {
+        normalized.uri = source;
+        normalized.contentUri = source;
+      } else if (/^[A-Za-z]:[\\/]/.test(source) || source.charAt(0) === "/" || source.charAt(0) === "\\") {
+        normalized.path = source;
+        normalized.caminho = source;
+      } else {
+        normalized.name = source;
+        normalized.nome = source;
+        normalized.fileName = source;
+        normalized.nomeArquivo = source;
+      }
+    }
+
+    if (normalized.alvo && !normalized.target) {
+      normalized.target = normalized.alvo;
+    }
+    if (normalized.target && !normalized.alvo) {
+      normalized.alvo = normalized.target;
+    }
+    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)) {
+      return cloneSerializable(keyOrOptions) || {};
+    }
+    normalized = cloneSerializable(options || {}) || {};
+    normalized.key = String(keyOrOptions || "");
+    normalized.chave = normalized.key;
+    normalized.value = cloneSerializable(value);
+    normalized.valor = normalized.value;
+    if (typeof value !== "string" && !hasOwn(normalized, "json")) {
+      normalized.json = true;
+    }
+    return normalized;
+  }
+
+  function secureKeyOptions(keyOrOptions, options) {
+    var normalized;
+    if (keyOrOptions && typeof keyOrOptions === "object" && !Array.isArray(keyOrOptions)) {
+      return cloneSerializable(keyOrOptions) || {};
+    }
+    normalized = cloneSerializable(options || {}) || {};
+    normalized.key = String(keyOrOptions || "");
+    normalized.chave = normalized.key;
+    return normalized;
+  }
+
+  function unwrapStoredValue(result) {
+    if (!result || result.exists === false || result.existe === false) {
+      return null;
+    }
+    if (hasOwn(result, "value")) {
+      return result.value;
+    }
+    if (hasOwn(result, "valor")) {
+      return result.valor;
+    }
+    if (hasOwn(result, "base64")) {
+      return result.base64;
+    }
+    if (hasOwn(result, "content")) {
+      return result.content;
+    }
+    if (hasOwn(result, "conteudo")) {
+      return result.conteudo;
+    }
+    return result;
+  }
+
+  function detectQRCodeFromPhoto(photo) {
+    var source;
+    var detector;
+
+    if (!photo || !photo.base64) {
+      return null;
+    }
+    if (typeof BarcodeDetector !== "function" || typeof createImageBitmap !== "function" || typeof fetch !== "function") {
+      throw new Error("QR code scanning requires BarcodeDetector support in this Android WebView.");
+    }
+
+    detector = new BarcodeDetector({ formats: ["qr_code"] });
+    source = "data:" + (photo.mimeType || "image/jpeg") + ";base64," + photo.base64;
+    return fetch(source)
+      .then(function (response) {
+        return response.blob();
+      })
+      .then(function (blob) {
+        return createImageBitmap(blob);
+      })
+      .then(function (image) {
+        return detector.detect(image);
+      })
+      .then(function (codes) {
+        var first = codes && codes[0];
+        if (!first) {
+          return null;
+        }
+        return {
+          text: first.rawValue || "",
+          texto: first.rawValue || "",
+          rawValue: first.rawValue || "",
+          valorBruto: first.rawValue || "",
+          format: first.format || "qr_code",
+          formato: first.format || "qr_code",
+          codes: codes,
+          codigos: codes,
+          photo: photo,
+          foto: photo
+        };
+      });
+  }
+
   function normalizeEventType(type) {
     var eventType = String(type || "");
     return eventAliases[eventType] || eventType;
@@ -553,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)]);
     },
@@ -577,6 +1051,15 @@
     statusLanterna: function () {
       return call("flashlightStatus");
     },
+    tirarFoto: function (options) {
+      return call("capturePhoto", [options || {}]);
+    },
+    capturarVideo: function (options) {
+      return call("captureVideo", [options || {}]);
+    },
+    escanearQRCode: function (options) {
+      return api.tirarFoto(Object.assign({ base64: true }, options || {})).then(detectQRCodeFromPhoto);
+    },
     solicitarPermissaoCamera: function () {
       return call("requestCameraPermission");
     },
@@ -604,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 || "")]);
     },
@@ -640,8 +1204,61 @@
     escolherPasta: function () {
       return call("pickFolder");
     },
-    salvarArquivo: function (options) {
-      return call("saveFile", [options || {}]);
+    salvarArquivo: function (nameOrOptions, value, options) {
+      if (typeof nameOrOptions === "string") {
+        return call("saveStoredFile", [storedFileOptions(nameOrOptions, value, options)]);
+      }
+      return call("saveFile", [nameOrOptions || {}]);
+    },
+    lerArquivo: function (nameOrOptions, options) {
+      return call("readStoredFile", [storedFileNameOptions(nameOrOptions, options)]).then(unwrapStoredValue);
+    },
+    lerArquivoCompleto: function (nameOrOptions, options) {
+      return call("readStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    excluirArquivo: function (nameOrOptions, options) {
+      return call("deleteStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    infoArquivo: function (nameOrOptions, options) {
+      return call("storedFileInfo", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    arquivoExiste: function (nameOrOptions, options) {
+      return api.infoArquivo(nameOrOptions, options).then(function (info) {
+        return Boolean(info && (info.exists || info.existe));
+      });
+    },
+    listarArquivos: function () {
+      return call("listStoredFiles");
+    },
+    abrirArquivo: function (nameOrOptions, options) {
+      return call("openStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    compartilharArquivo: function (nameOrOptions, options) {
+      return call("shareStoredFile", [storedFileNameOptions(nameOrOptions, options)]);
+    },
+    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, options) {
+      return call("downloadFile", [downloadLocalFileOptions(fileOrOptions, nameOrOptions, options)]);
+    },
+    definirPapelParede: function (sourceOrOptions, options) {
+      return call("setWallpaper", [wallpaperOptions(sourceOrOptions, options)]);
+    },
+    infoPapelParede: function () {
+      return call("wallpaperInfo");
+    },
+    abrirConfiguracaoPapelParede: function () {
+      return call("openWallpaperSettings");
+    },
+    capturarTela: function (options) {
+      return call("captureScreen", [options || {}]);
+    },
+    tirarPrint: function (options) {
+      return call("captureScreen", [options || {}]);
     },
     infoDispositivo: function () {
       return call("deviceInfo");
@@ -661,12 +1278,57 @@
     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");
     },
     infoAppsAbertos: function () {
       return call("openAppsMemory");
     },
+    obterLocalizacao: function (options) {
+      return call("getLocation", [options || {}]);
+    },
+    acompanharLocalizacao: function (options) {
+      return call("watchLocation", [options || {}]);
+    },
+    pararLocalizacao: function (id) {
+      return call("stopLocationWatch", [id || ""]);
+    },
+    aoMudarLocalizacao: function (listener) {
+      return onEvent("localizacao:mudou", listener);
+    },
+    autenticarBiometria: function (options) {
+      return call("authenticateBiometric", [options || {}]);
+    },
+    salvarSeguro: function (keyOrOptions, value, options) {
+      return call("saveSecureItem", [secureItemOptions(keyOrOptions, value, options)]);
+    },
+    lerSeguro: function (keyOrOptions, options) {
+      return call("readSecureItem", [secureKeyOptions(keyOrOptions, options)]).then(unwrapStoredValue);
+    },
+    lerSeguroCompleto: function (keyOrOptions, options) {
+      return call("readSecureItem", [secureKeyOptions(keyOrOptions, options)]);
+    },
+    removerSeguro: function (keyOrOptions, options) {
+      return call("deleteSecureItem", [secureKeyOptions(keyOrOptions, options)]);
+    },
+    listarSeguro: function () {
+      return call("listSecureKeys");
+    },
+    limparSeguro: function () {
+      return call("clearSecureStorage");
+    },
     statusPermissoes: function (permissions) {
       return call("permissionStatus", [permissions || []]);
     },
@@ -691,12 +1353,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;
@@ -709,6 +1383,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);
@@ -724,12 +1404,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");
@@ -754,6 +1489,7 @@
     cancelNotification: api.cancelarNotificacao,
     cancelNotificationLoop: api.cancelarLoopNotificacoes,
     vibrate: api.vibrar,
+    loading: api.aguardar,
     manterTelaLigada: api.manterTelaAcordada,
     keepScreenAwake: api.manterTelaAcordada,
     keepScreenOn: api.manterTelaAcordada,
@@ -763,6 +1499,11 @@
     flashlight: api.lanterna,
     toggleFlashlight: api.alternarLanterna,
     flashlightStatus: api.statusLanterna,
+    takePhoto: api.tirarFoto,
+    capturePhoto: api.tirarFoto,
+    captureVideo: api.capturarVideo,
+    scanQRCode: api.escanearQRCode,
+    scanQrCode: api.escanearQRCode,
     requestCameraPermission: api.solicitarPermissaoCamera,
     requestMicrophonePermission: api.solicitarPermissaoMicrofone,
     microphoneStatus: api.statusMicrofone,
@@ -775,6 +1516,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,
@@ -791,14 +1572,66 @@
     pickVideo: api.escolherVideo,
     pickFolder: api.escolherPasta,
     saveFile: api.salvarArquivo,
+    readFile: api.lerArquivo,
+    readStoredFile: api.lerArquivo,
+    readStoredFileInfo: api.lerArquivoCompleto,
+    deleteFile: api.excluirArquivo,
+    removeFile: api.excluirArquivo,
+    excluirArquivoArmazenado: api.excluirArquivo,
+    removerArquivo: api.excluirArquivo,
+    apagarArquivo: api.excluirArquivo,
+    fileInfo: api.infoArquivo,
+    storedFileInfo: api.infoArquivo,
+    fileExists: api.arquivoExiste,
+    listFiles: api.listarArquivos,
+    listStoredFiles: api.listarArquivos,
+    openFile: api.abrirArquivo,
+    openStoredFile: api.abrirArquivo,
+    shareFile: api.compartilharArquivo,
+    shareStoredFile: api.compartilharArquivo,
+    downloadFile: api.baixarArquivo,
+    downloadBase64: api.baixarBase64,
+    downloadFromBase64: api.baixarBase64,
+    baixarArquivoBase64: api.baixarBase64,
+    downloadLocalFile: api.baixarArquivoLocal,
+    downloadFromFile: api.baixarArquivoLocal,
+    baixarArquivoNormal: api.baixarArquivoLocal,
+    setWallpaper: api.definirPapelParede,
+    setPhoneWallpaper: api.definirPapelParede,
+    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,
+    authenticateBiometric: api.autenticarBiometria,
+    saveSecure: api.salvarSeguro,
+    secureSet: api.salvarSeguro,
+    readSecure: api.lerSeguro,
+    secureGet: api.lerSeguro,
+    readSecureItem: api.lerSeguroCompleto,
+    deleteSecure: api.removerSeguro,
+    removeSecure: api.removerSeguro,
+    secureDelete: api.removerSeguro,
+    listSecureKeys: api.listarSeguro,
+    clearSecureStorage: api.limparSeguro,
     permissionStatus: api.statusPermissoes,
     requestNotificationPermission: api.solicitarPermissaoNotificacoes,
     notificationPermissionStatus: api.statusPermissaoNotificacoes,
@@ -808,15 +1641,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
   });
 
@@ -855,6 +1724,12 @@
           emitEvent("link:aberto", link);
         }
       });
+      api.obterCompartilhamentoInicial().then(function (share) {
+        if (share) {
+          initialShare = share;
+          emitEvent("compartilhamento:recebido", share);
+        }
+      });
     }, false);
   }
 })();