781 lines
19 KiB
JavaScript
781 lines
19 KiB
JavaScript
import { inRuntime, bridgeAsync } from "../bridge";
|
||
import {
|
||
isSupportWebScan,
|
||
startScanForWeb,
|
||
stopScanForWeb,
|
||
isSupportImageScan,
|
||
startScanForImage,
|
||
unlockScanBeep,
|
||
playScanBeep,
|
||
isWebScanImageFallbackEnabled,
|
||
canUseWebCameraScan,
|
||
shouldSkipWebCameraProbe,
|
||
cleanupWebScanResiduals,
|
||
detectImageFileForScan
|
||
} from "../web";
|
||
import { isSupportWxScan, startScanForWx, isWxEnv } from "../wx";
|
||
import { startScanner, stopScanner } from "../scanner";
|
||
import { getConfig } from "../config";
|
||
import { toAny } from "../../utils/toany";
|
||
import { printDebug, printWarn } from "../../utils/logger";
|
||
import { forwardEmbedScanResultIfNeeded, forwardEmbedScanErrorIfNeeded } from "../embedScanBridge";
|
||
|
||
let _scan_status = "ready";
|
||
let _scan_status_listener = null;
|
||
let _scan_listener_list = [];
|
||
let _scan_error_listener_list = [];
|
||
let _scan_resolve = null;
|
||
let _scan_closing = false;
|
||
let _scan_next_start_time = 0;
|
||
let _embed_scan_host_enabled = false;
|
||
|
||
const SCAN_RESTART_DELAY = 500;
|
||
const BRIDGE_SCAN_TIMEOUT = 5000;
|
||
const SCAN_SESSION_TIMEOUT = 90000;
|
||
|
||
function getScanRestartDelay() {
|
||
return toAny(getConfig("scanRestartDelay"), SCAN_RESTART_DELAY);
|
||
}
|
||
|
||
function getBridgeScanTimeout() {
|
||
const timeout = getConfig("bridgeScanTimeout");
|
||
return typeof timeout === "number" && timeout > 0 ? timeout : BRIDGE_SCAN_TIMEOUT;
|
||
}
|
||
|
||
function getScanSessionTimeout() {
|
||
const timeout = getConfig("scanSessionTimeout");
|
||
return typeof timeout === "number" && timeout > 0 ? timeout : SCAN_SESSION_TIMEOUT;
|
||
}
|
||
|
||
function withScanSessionTimeout(scanPromise) {
|
||
return Promise.race([
|
||
scanPromise,
|
||
new Promise(resolve => {
|
||
setTimeout(() => {
|
||
printWarn("scan session timeout");
|
||
resolve({ cancel: 1, scanTimeout: true });
|
||
}, getScanSessionTimeout());
|
||
})
|
||
]);
|
||
}
|
||
|
||
function __fallbackScanAfterBridgeFailure(err) {
|
||
if (!isScanning()) {
|
||
throw err;
|
||
}
|
||
printWarn("bridge scan unavailable, fallback:", err);
|
||
return __startNonBridgeScan(err);
|
||
}
|
||
|
||
function __fallbackScanAfterWxFailure(err) {
|
||
if (!isScanning()) {
|
||
throw err;
|
||
}
|
||
printWarn("wx scan unavailable, fallback to web/image scan:", err);
|
||
return __startNonBridgeScan(err);
|
||
}
|
||
|
||
function __startNonBridgeScan(err) {
|
||
if (isSupportWebScan()) {
|
||
return __startWebScan();
|
||
}
|
||
if (isSupportImageScan()) {
|
||
return __startImageScan();
|
||
}
|
||
throw err;
|
||
}
|
||
|
||
function parseBarcodeString(input) {
|
||
// 标准化的类型映射表：将各种变体映射到统一标识
|
||
// 这样即使传入 EAN_13、EAN-13、EAN13 都能匹配成功
|
||
const normalizedTypeMap = {
|
||
// EAN 系列
|
||
"ean13": true, "ean-13": true, "ean_13": true,
|
||
"ean8": true, "ean-8": true, "ean_8": true,
|
||
// UPC 系列
|
||
"upca": true, "upc-a": true, "upc_a": true,
|
||
"upce": true, "upc-e": true, "upc_e": true,
|
||
// CODE 系列
|
||
"code128": true, "code-128": true, "code_128": true,
|
||
"code39": true, "code-39": true, "code_39": true,
|
||
"code93": true, "code-93": true, "code_93": true,
|
||
// 其他常见类型
|
||
"itf": true, "itf14": true, "itf-14": true, "itf_14": true,
|
||
"codabar": true,
|
||
"pdf417": true, "pdf-417": true, "pdf_417": true,
|
||
"qrcode": true, "qr-code": true, "qr_code": true,
|
||
"datamatrix": true, "data-matrix": true, "data_matrix": true,
|
||
"aztec": true
|
||
};
|
||
// 健壮性检查
|
||
if (typeof input !== 'string') {
|
||
return input;
|
||
}
|
||
// 按第一个逗号分割
|
||
const commaIndex = input.indexOf(',');
|
||
if (commaIndex === -1) {
|
||
return input;
|
||
}
|
||
const possibleType = input.substring(0, commaIndex).trim();
|
||
const value = input.substring(commaIndex + 1).trim();
|
||
// 类型或值为空，返回原值
|
||
if (possibleType === "" || value === "") {
|
||
return input;
|
||
}
|
||
// 标准化类型（转小写，便于匹配）
|
||
const normalizedType = possibleType.toLowerCase();
|
||
// 检查是否为已知的条形码类型（支持多种分隔符变体）
|
||
const isKnownType = normalizedTypeMap.hasOwnProperty(normalizedType);
|
||
|
||
if (isKnownType) {
|
||
return value;
|
||
} else {
|
||
return input;
|
||
}
|
||
}
|
||
|
||
function __checkScanner() {
|
||
if (_scan_listener_list.length > 0 || _embed_scan_host_enabled) {
|
||
startScanner((result) => {
|
||
result = parseBarcodeString(result);
|
||
__scannerResult(result, { source: "scanner", skipBeep: true });
|
||
});
|
||
} else {
|
||
stopScanner();
|
||
}
|
||
}
|
||
|
||
function __match(result, match) {
|
||
let reg = null;
|
||
if (!!match && typeof match === "string") {
|
||
reg = new RegExp(match);
|
||
}
|
||
if (!!reg) {
|
||
return reg.test(result);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
function __shouldSkipBeep(meta) {
|
||
if (meta && meta.skipBeep) {
|
||
return true;
|
||
}
|
||
const source = meta && meta.source;
|
||
return source === "scanner" || source === "bridge" || source === "wx";
|
||
}
|
||
|
||
function __result(result, meta) {
|
||
result = parseBarcodeString(result);
|
||
forwardEmbedScanResultIfNeeded(result, meta);
|
||
let matched = false;
|
||
for (let i = 0; i < _scan_listener_list.length; i++) {
|
||
const item = _scan_listener_list[i];
|
||
if (item.listener && __match(result, item.match)) {
|
||
matched = true;
|
||
item.listener({ result, key: item.key });
|
||
break;
|
||
}
|
||
}
|
||
if (matched) {
|
||
if (!__shouldSkipBeep(meta)) {
|
||
playScanBeep();
|
||
}
|
||
_scan_next_start_time = Date.now() + getScanRestartDelay();
|
||
}
|
||
return matched;
|
||
}
|
||
|
||
function normalizeScanError(raw) {
|
||
if (typeof raw === "string") {
|
||
return raw;
|
||
}
|
||
if (raw && raw.error != null && raw.error !== "") {
|
||
return String(raw.error);
|
||
}
|
||
if (raw && raw.message) {
|
||
return String(raw.message);
|
||
}
|
||
if (raw == null || raw === "") {
|
||
return "";
|
||
}
|
||
return String(raw);
|
||
}
|
||
|
||
function __scanError(raw, meta) {
|
||
const error = normalizeScanError(raw);
|
||
if (!error) {
|
||
return false;
|
||
}
|
||
forwardEmbedScanErrorIfNeeded(error);
|
||
let matched = false;
|
||
for (let i = 0; i < _scan_error_listener_list.length; i++) {
|
||
const item = _scan_error_listener_list[i];
|
||
if (item.listener && __match(error, item.match)) {
|
||
matched = true;
|
||
item.listener(Object.assign({
|
||
error,
|
||
key: item.key
|
||
}, meta || {}));
|
||
break;
|
||
}
|
||
}
|
||
return matched;
|
||
}
|
||
|
||
function __notifyImageScanFailure(raw, meta) {
|
||
if (raw && raw.cancel) {
|
||
return false;
|
||
}
|
||
const error = normalizeScanError(raw);
|
||
const notified = __scanError(raw, Object.assign({ source: "image" }, meta || {}));
|
||
if (!notified && error) {
|
||
printWarn("image scan failed:", error);
|
||
}
|
||
return notified;
|
||
}
|
||
|
||
function __notifyWebScanFailure(raw, meta) {
|
||
if (raw && raw.cancel) {
|
||
return false;
|
||
}
|
||
const payload = raw && raw.error != null ? raw.error : raw;
|
||
const error = normalizeScanError(payload);
|
||
const notified = __scanError(payload, Object.assign({ source: "web" }, meta || {}));
|
||
if (!notified && error) {
|
||
printWarn("web scan failed:", error);
|
||
}
|
||
return notified;
|
||
}
|
||
|
||
function __hasMatchedListener(result) {
|
||
for (let i = 0; i < _scan_listener_list.length; i++) {
|
||
const item = _scan_listener_list[i];
|
||
if (item.listener && __match(result, item.match)) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
function __scanning() {
|
||
if (_scan_status !== "scanning") {
|
||
_scan_status = "scanning";
|
||
if (_scan_status_listener) {
|
||
_scan_status_listener({ status: "scanning" });
|
||
}
|
||
}
|
||
}
|
||
|
||
function __closed() {
|
||
if (_scan_status !== "ready") {
|
||
_scan_status = "ready";
|
||
if (_scan_status_listener) {
|
||
_scan_status_listener({ status: "ready" });
|
||
}
|
||
}
|
||
}
|
||
|
||
function __finishScan() {
|
||
const resolve = _scan_resolve;
|
||
_scan_resolve = null;
|
||
__closed();
|
||
return resolve;
|
||
}
|
||
|
||
function __stopCurrentScan() {
|
||
if (inRuntime()) {
|
||
return bridgeAsync("stopScan").catch(() => {
|
||
// no thing
|
||
});
|
||
} else if (isSupportWebScan()) {
|
||
return stopScanForWeb().catch(() => {
|
||
// no thing
|
||
});
|
||
}
|
||
return Promise.resolve();
|
||
}
|
||
|
||
/**
|
||
* 父页通过 postMessage 将识别结果投递到嵌入 iframe 时调用（与本地扫码枪/监听同一链路）。
|
||
* @returns {boolean} 是否有监听消费了该结果
|
||
*/
|
||
export function dispatchEmbedScanResult(raw, meta) {
|
||
const result =
|
||
typeof raw === "string" ? parseBarcodeString(raw) : raw;
|
||
return __scannerResult(result, meta);
|
||
}
|
||
|
||
/**
|
||
* 父页通过 postMessage 将识别错误投递到嵌入 iframe 时调用。
|
||
* @returns {boolean} 是否有监听消费了该错误
|
||
*/
|
||
export function dispatchEmbedScanError(raw) {
|
||
const error = normalizeScanError(raw);
|
||
return __scanError(error, { source: "image" });
|
||
}
|
||
|
||
/**
|
||
* 嵌入 iframe 已消费扫码结果时通知父页结束当前识别（关闭摄像头/UI 等）。
|
||
*/
|
||
export function acknowledgeEmbedScanConsumed(raw) {
|
||
const result =
|
||
typeof raw === "string" ? parseBarcodeString(raw) : raw;
|
||
if (!isScanning()) {
|
||
return;
|
||
}
|
||
const resolve = __finishScan();
|
||
_scan_closing = true;
|
||
_scan_next_start_time = Date.now() + getScanRestartDelay();
|
||
__stopCurrentScan().then(() => {
|
||
setTimeout(() => {
|
||
_scan_closing = false;
|
||
}, 0);
|
||
});
|
||
resolve && resolve({ result });
|
||
}
|
||
|
||
function __scannerResult(result, meta) {
|
||
if (!__hasMatchedListener(result)) {
|
||
return __result(result, meta);
|
||
}
|
||
if (isScanning()) {
|
||
const resolve = __finishScan();
|
||
_scan_closing = true;
|
||
__stopCurrentScan().then(() => {
|
||
setTimeout(() => {
|
||
_scan_closing = false;
|
||
}, 0);
|
||
});
|
||
const matched = __result(result, meta);
|
||
resolve && resolve({
|
||
result
|
||
});
|
||
return matched;
|
||
}
|
||
return __result(result, meta);
|
||
}
|
||
|
||
function __startBridgeScan() {
|
||
return bridgeAsync("startScan", {
|
||
closeable: true
|
||
}, getBridgeScanTimeout()).then(resp => {
|
||
if (!isScanning()) {
|
||
return resp;
|
||
}
|
||
if (!resp || !resp.result) {
|
||
return resp;
|
||
}
|
||
if (__result(resp.result, { source: "bridge" })) {
|
||
return resp;
|
||
}
|
||
if (isScanning()) {
|
||
return __startBridgeScan();
|
||
}
|
||
return resp;
|
||
}).catch(err => {
|
||
if (!isScanning()) {
|
||
throw err;
|
||
}
|
||
if (!err || !err.result) {
|
||
throw err;
|
||
}
|
||
if (__result(err.result, { source: "bridge" })) {
|
||
return err;
|
||
}
|
||
if (isScanning()) {
|
||
return __startBridgeScan();
|
||
}
|
||
return err;
|
||
});
|
||
}
|
||
|
||
function __startWxScan() {
|
||
return startScanForWx({
|
||
needResult: 1,
|
||
scanType: ["qrCode", "barCode"]
|
||
}).then(resp => {
|
||
if (!isScanning()) {
|
||
return resp;
|
||
}
|
||
if (resp && resp.error && !resp.result) {
|
||
throw resp.error;
|
||
}
|
||
if (!resp || !resp.result) {
|
||
return resp;
|
||
}
|
||
if (__result(resp.result, { source: "wx" })) {
|
||
return resp;
|
||
}
|
||
return resp;
|
||
}).catch(err => {
|
||
if (!isScanning()) {
|
||
throw err;
|
||
}
|
||
if (err && err.result) {
|
||
if (__result(err.result, { source: "wx" })) {
|
||
return err;
|
||
}
|
||
return err;
|
||
}
|
||
return __fallbackScanAfterWxFailure(err);
|
||
});
|
||
}
|
||
|
||
function __startWebScan(useImageScan = false) {
|
||
return startScanForWeb(__result, __scanError).then(resp => {
|
||
if (!isScanning()) {
|
||
return resp;
|
||
}
|
||
if (!resp || !resp.result) {
|
||
if (resp && resp.success === false) {
|
||
__notifyWebScanFailure(resp);
|
||
}
|
||
return resp;
|
||
}
|
||
__result(resp.result);
|
||
return resp;
|
||
}).catch(err => {
|
||
if (!isScanning()) {
|
||
return err;
|
||
}
|
||
if (err && err.cancel) {
|
||
return err;
|
||
}
|
||
if (err && err.scanTimeout) {
|
||
return err;
|
||
}
|
||
if (err && err.imageFallbackUsed) {
|
||
__notifyWebScanFailure(err);
|
||
return err;
|
||
}
|
||
if (isWebScanImageFallbackEnabled() && useImageScan) {
|
||
return __startImageScan();
|
||
}
|
||
__notifyWebScanFailure(err);
|
||
printWarn("web scan failed:", err);
|
||
return err;
|
||
});
|
||
}
|
||
|
||
function __startImageScan() {
|
||
return startScanForImage().then(resp => {
|
||
if (!isScanning()) {
|
||
return resp;
|
||
}
|
||
if (resp && resp.cancel) {
|
||
return resp;
|
||
}
|
||
if (!resp || !resp.result) {
|
||
__notifyImageScanFailure(resp);
|
||
return resp;
|
||
}
|
||
__result(resp.result);
|
||
return resp;
|
||
}).catch(err => {
|
||
if (!isScanning()) {
|
||
return err;
|
||
}
|
||
if (err && err.cancel) {
|
||
return err;
|
||
}
|
||
if (err && err.result) {
|
||
__result(err.result);
|
||
return err;
|
||
}
|
||
__notifyImageScanFailure(err);
|
||
return err;
|
||
});
|
||
}
|
||
|
||
export function isScanning() {
|
||
return _scan_status === "scanning";
|
||
}
|
||
|
||
export function setEmbedScanHostEnabled(enabled) {
|
||
const nextEnabled = enabled !== false;
|
||
if (_embed_scan_host_enabled === nextEnabled) {
|
||
return;
|
||
}
|
||
_embed_scan_host_enabled = nextEnabled;
|
||
__checkScanner();
|
||
}
|
||
|
||
export function clear() {
|
||
for (let i = 0; i < _scan_listener_list.length; i++) {
|
||
const item = _scan_listener_list[i];
|
||
item.cancel();
|
||
}
|
||
_scan_listener_list.length = 0;
|
||
for (let i = 0; i < _scan_error_listener_list.length; i++) {
|
||
const item = _scan_error_listener_list[i];
|
||
item.cancel();
|
||
}
|
||
_scan_error_listener_list.length = 0;
|
||
__checkScanner();
|
||
}
|
||
|
||
export function onScanListener(listener, key, match, level) {
|
||
if (!key || typeof key !== 'string') {
|
||
return;
|
||
}
|
||
if (typeof listener !== 'function') {
|
||
return;
|
||
}
|
||
let item = null;
|
||
for (let i = 0; i < _scan_listener_list.length; i++) {
|
||
const _i = _scan_listener_list[i];
|
||
if (_i.key === key) {
|
||
item = _i;
|
||
break;
|
||
}
|
||
}
|
||
if (item) {
|
||
item.level = level;
|
||
item.match = match;
|
||
item.listener = listener;
|
||
} else {
|
||
item = {
|
||
key,
|
||
match: match || "",
|
||
level: level || 0,
|
||
listener: listener,
|
||
cancel: () => {
|
||
const index = _scan_listener_list.indexOf(item);
|
||
if (index !== -1) {
|
||
const items = _scan_listener_list.splice(index, 1);
|
||
for (let i = 0; i < items.length; i++) {
|
||
const item = items[i];
|
||
item.listener && item.listener({ cancel: 1 });
|
||
}
|
||
}
|
||
}
|
||
};
|
||
_scan_listener_list.push(item);
|
||
}
|
||
// 根据level排序
|
||
_scan_listener_list.sort((a, b) => b.level - a.level);
|
||
__checkScanner();
|
||
return item;
|
||
}
|
||
|
||
export function offScanListener(listener) {
|
||
for (let i = 0; i < _scan_listener_list.length; i++) {
|
||
const _i = _scan_listener_list[i];
|
||
if (typeof listener === 'string') {
|
||
if (_i.key === listener) {
|
||
_i.cancel();
|
||
break;
|
||
}
|
||
} else if (_i.listener === listener) {
|
||
_i.cancel();
|
||
break;
|
||
}
|
||
}
|
||
__checkScanner();
|
||
}
|
||
|
||
function createScanErrorListenerItem(listener, key, match, level) {
|
||
const item = {
|
||
key,
|
||
match: match || "",
|
||
level: level || 0,
|
||
listener: listener,
|
||
cancel: () => {
|
||
const index = _scan_error_listener_list.indexOf(item);
|
||
if (index !== -1) {
|
||
const items = _scan_error_listener_list.splice(index, 1);
|
||
for (let i = 0; i < items.length; i++) {
|
||
const removed = items[i];
|
||
removed.listener && removed.listener({ cancel: 1, key: removed.key });
|
||
}
|
||
}
|
||
}
|
||
};
|
||
return item;
|
||
}
|
||
|
||
export function onScanErrorListener(listener, key, match, level) {
|
||
if (!key || typeof key !== 'string') {
|
||
return;
|
||
}
|
||
if (typeof listener !== 'function') {
|
||
return;
|
||
}
|
||
let item = null;
|
||
for (let i = 0; i < _scan_error_listener_list.length; i++) {
|
||
const _i = _scan_error_listener_list[i];
|
||
if (_i.key === key) {
|
||
item = _i;
|
||
break;
|
||
}
|
||
}
|
||
if (item) {
|
||
item.level = level;
|
||
item.match = match;
|
||
item.listener = listener;
|
||
} else {
|
||
item = createScanErrorListenerItem(listener, key, match, level);
|
||
_scan_error_listener_list.push(item);
|
||
}
|
||
_scan_error_listener_list.sort((a, b) => b.level - a.level);
|
||
return item;
|
||
}
|
||
|
||
export function offScanErrorListener(listener) {
|
||
for (let i = 0; i < _scan_error_listener_list.length; i++) {
|
||
const _i = _scan_error_listener_list[i];
|
||
if (typeof listener === 'string') {
|
||
if (_i.key === listener) {
|
||
_i.cancel();
|
||
break;
|
||
}
|
||
} else if (_i.listener === listener) {
|
||
_i.cancel();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
export function setStatusListener(listener) {
|
||
if (typeof listener !== 'function') {
|
||
return;
|
||
}
|
||
_scan_status_listener = listener;
|
||
}
|
||
|
||
export function getStatus() {
|
||
return _scan_status;
|
||
}
|
||
|
||
export function stopScan() {
|
||
cleanupWebScanResiduals();
|
||
if (!isScanning()) {
|
||
return;
|
||
}
|
||
const resolve = __finishScan();
|
||
_scan_closing = true;
|
||
__stopCurrentScan().then(() => {
|
||
resolve && resolve({ cancel: 1 });
|
||
_scan_closing = false;
|
||
});
|
||
}
|
||
|
||
export function startScan() {
|
||
if (isScanning() || _scan_closing || Date.now() < _scan_next_start_time) {
|
||
return;
|
||
}
|
||
unlockScanBeep();
|
||
Promise.resolve().then(() => {
|
||
__scanning();
|
||
let scannerPromise = new Promise(resolve => {
|
||
_scan_resolve = resolve;
|
||
});
|
||
let scanPromise = Promise.resolve();
|
||
if (inRuntime()) {
|
||
scanPromise = __startBridgeScan().catch(__fallbackScanAfterBridgeFailure);
|
||
} else if (isSupportWxScan()) {
|
||
scanPromise = __startWxScan();
|
||
} else if (isSupportWebScan()) {
|
||
scanPromise = __startWebScan(true);
|
||
} else if (isSupportImageScan()) {
|
||
scanPromise = __startImageScan();
|
||
} else {
|
||
printWarn("Not support scanner");
|
||
}
|
||
return withScanSessionTimeout(Promise.race([scanPromise, scannerPromise]));
|
||
}).finally(() => {
|
||
_scan_resolve = null;
|
||
__closed();
|
||
});
|
||
}
|
||
|
||
export function scanImage() {
|
||
if (!isSupportImageScan()) {
|
||
printDebug("Not support image scanner");
|
||
return;
|
||
}
|
||
if (isScanning() || _scan_closing || Date.now() < _scan_next_start_time) {
|
||
return;
|
||
}
|
||
unlockScanBeep();
|
||
__scanning();
|
||
withScanSessionTimeout(__startImageScan()).catch(err => {
|
||
if (err && err.cancel) {
|
||
return;
|
||
}
|
||
__notifyImageScanFailure(err);
|
||
}).finally(() => {
|
||
__closed();
|
||
});
|
||
}
|
||
|
||
/** 由原生/业务传入已选图片 File，避免 WebView 无法从 input.files 取文件 */
|
||
export function scanImageFromFile(file) {
|
||
if (!isSupportImageScan()) {
|
||
printDebug("Not support image scanner");
|
||
return;
|
||
}
|
||
if (isScanning() || _scan_closing || Date.now() < _scan_next_start_time) {
|
||
return;
|
||
}
|
||
unlockScanBeep();
|
||
cleanupWebScanResiduals();
|
||
__scanning();
|
||
withScanSessionTimeout(
|
||
detectImageFileForScan(file).then(resp => {
|
||
if (!isScanning()) {
|
||
return resp;
|
||
}
|
||
if (resp && resp.cancel) {
|
||
return resp;
|
||
}
|
||
if (!resp || !resp.result) {
|
||
__notifyImageScanFailure(resp);
|
||
return resp;
|
||
}
|
||
__result(resp.result);
|
||
return resp;
|
||
})
|
||
).catch(err => {
|
||
if (err && err.cancel) {
|
||
return;
|
||
}
|
||
__notifyImageScanFailure(err);
|
||
}).finally(() => {
|
||
__closed();
|
||
});
|
||
}
|
||
|
||
export const supportList = [
|
||
{
|
||
name: "bridge",
|
||
get support() {
|
||
return !!inRuntime();
|
||
}
|
||
},
|
||
{
|
||
name: "wx",
|
||
get support() {
|
||
return !!isSupportWxScan();
|
||
}
|
||
},
|
||
{
|
||
name: "web",
|
||
get support() {
|
||
if (shouldSkipWebCameraProbe()) {
|
||
return false;
|
||
}
|
||
return !!canUseWebCameraScan();
|
||
}
|
||
},
|
||
{
|
||
name: "image",
|
||
get support() {
|
||
return !!isSupportImageScan();
|
||
}
|
||
},
|
||
{
|
||
name: "scanner",
|
||
support: true
|
||
}
|
||
]; |