html2apk 0.8.0 → 0.11.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 = {};
@@ -21,6 +24,35 @@ var eventAliases = {
   "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"
 };
@@ -537,6 +569,440 @@ function openInAppUrl(url, options) {
   });
 }
 
+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
+      };
+    });
+}
+
 var api = {
   notificar: function (messageOrOptions) {
     return call("notify", [normalizeNotificationOptions(messageOrOptions)]);
@@ -566,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)]);
   },
@@ -590,6 +1064,15 @@ var api = {
   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");
   },
@@ -617,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 || "")]);
   },
@@ -659,8 +1223,61 @@ var api = {
   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");
@@ -680,12 +1297,57 @@ 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");
   },
   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 || []]);
   },
@@ -710,12 +1372,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;
@@ -728,6 +1402,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);
@@ -746,12 +1426,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");
@@ -784,6 +1519,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,
@@ -793,6 +1529,11 @@ Object.assign(api, {
   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,
@@ -805,6 +1546,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,
@@ -819,14 +1600,66 @@ Object.assign(api, {
   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,
@@ -836,15 +1669,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
 });
 
@@ -881,6 +1750,9 @@ if (typeof window !== "undefined") {
   window.escolherVideo = api.escolherVideo;
   window.escolherPasta = api.escolherPasta;
   window.salvarArquivo = api.salvarArquivo;
+  window.definirPapelParede = api.definirPapelParede;
+  window.infoPapelParede = api.infoPapelParede;
+  window.abrirConfiguracaoPapelParede = api.abrirConfiguracaoPapelParede;
   window.infoDispositivo = api.infoDispositivo;
   window.infoRede = api.infoRede;
   window.infoBateria = api.infoBateria;
@@ -943,6 +1815,12 @@ if (typeof window !== "undefined") {
         emitEvent("link:aberto", link);
       }
     });
+    api.obterCompartilhamentoInicial().then(function (share) {
+      if (share) {
+        initialShare = share;
+        emitEvent("compartilhamento:recebido", share);
+      }
+    });
   }, false);
 }