mtl-js-sdk/lib/platforms/upesn/methods.js

ynf-fw-mtl-api

import xaxios from 'axios'
import QRious from 'qrious'
import home from './unique.js'

const DEFAULT_STORAGE_DOMAIN = "domain.default"
const baseUrl = "ht" + "tps://bip-dai" + "ly.yonyoucloud.com/iuap-yonbuilder-mobile"
const FAIL_CODE = 1
const SUCCESS_CODE = 200
const axios = xaxios?.default || xaxios

const unsupportFailRes = {
    code: FAIL_CODE,
    message: "The current platform does not support",
}

function unsupportMethod(object = {}) {
    object.fail && object.fail(unsupportFailRes)
    object.complete && object.complete(unsupportFailRes)
}

const unsupportMethods = ["openSchema", "getConfig", "getStatusBarHeight"]

const supportMethods = [
    "saveExclusiveDomain",
    "saveExclusiveUserInfo",
    "saveExclusiveYhtInfo",
    "openExclusiveApp",
    "isExclusivePreloadMDF",
    "getExclusiveAppH5LocationPath",
    "getExclusiveCode",
    "webviewLoadUrl",
    "getAppInfo",
    "switchLongPress",
    "setStatusBar",
    "afterPrivacyAgreement",
    "webViewCustomScanQRCode",
    "execPluginSyncBridge",
    "requestPermission",
]

const execBridgeMethods = [
    "commonReplyComponent",
    "addImageWaterMark",
    "continuousShooting",
    "deleteBase64Image",
    "getBase64Image",
    "saveBase64Image",
    "getVideoThumbnail",
    "bindSensor",
    "collectRev",
    "collectTmp",
    "collectVib",
    "connectBle",
    "disconnectBle",
    "getBindedSensor",
    "getConnectStatus",
    "registerConnectStatusListener",
    "searchBleClient",
    "stopCollect",
    "createShortcut",
    "vibrateLong",
    "smileDetect",
    "getWatermarkInfo",
    "getUserAgent",
    "gainUserInfo",
    "checkMirrorStatus",
    "startMirrorScreen",
    "closeMirrorScreen",
    "openCreateSpace",
    "convertMemberIDs",
    "chooseUserOrGroupFromChat",
    "operateCloudAlarm",
    "checkCloudAlarm",
    "openPluginWithParams",
    "getOffLineOutSignPhoto",
    "getHhtQrCodeInfo",
    "configAppletMenu",
    "appletFromQzId",
    "writeAnnounceReply",
    "openAnnounceReply",
    "announceDetail",
    "previewFile",
    "openDocument",
    "mapLocationExtend",
    "getSchedulesFromMobile",
    "openChatByGroupId",
    "mdfIsLoad",
    "chooseGroupContacts",
    "configSkinAndTabbar",
    "getMultiDataCenterConfig",
    "collectionData",
    "getGzipAppData",
    "reloadWorkbenchPath",
    "openSearchAppList",
    "openSignViewWithParams",
    "shareApplet",
    "getAppletShareParams",
    "config",
    "openAppSetting",
    "openCustomSetting",
    "checkBridgeNameExist",
    "appearanceMode",
    "toggleCamera",
    "onPullDownHandle",
    "stopPullDownHandle",
    "onPullUpHandle",
    "stopPullUpHandle",
    "continuousShootingLocal",
    "jumpSystemSettings",
    "isFileExist",
    "getAppInformation",
    "writeLocationLog",
    "openWindow",
    "getWechatBill",
    "openLiveFlow",
    "yonyouPay",
    "zebraPrinterList",
    "zebraPrintImage",
]

// ------------------start 未实现接口
// 录音
function startRecord(object) {
    let _obj = object || {}
    let data = Object.assign(
        {
            closeNcc: true,
            callback: "onVoiceRecordEnd",
        },
        handleResponse(_obj)
    )
    execEsnBridge("startRecord", data)
}
function stopRecord(object) {
    let _obj = object || {}
    let data = Object.assign(
        {
            closeNcc: true,
        },
        handleResponse(_obj, (res) => {
            return { localId: res.bytes }
        })
    )
    execEsnBridge("stopRecord", data)
}

function onVoiceRecordEnd(object) {
    let _obj = object || {}
    home.upesn.registerResumeCallback("onVoiceRecordEnd", function (res) {
        let { bytes } = res
        _obj.success && object.success({ localId: bytes })
    })
}

function translateVoice(object) {
    let _obj = object || {}
    let { localId, isShowProgressTips = isShowProgressTips ? isShowProgressTips : 1 } = _obj
    if (home.isEmpty("localId", localId, object)) {
        return
    }
    let data = Object.assign(
        {
            bytes: localId,
            isShowUI: isShowProgressTips === 1 ? true : false,
        },
        handleResponse(_obj, (res) => {
            return { translateResult: res.text }
        })
    )
    execEsnBridge("translateVoice", data)
}
// 语音播放
function playVoice(object) {
    let _obj = object || {}
    var bytes = ""
    if (_obj.localId) {
        bytes = _obj.localId
    }
    let closeNcc = true
    let callback = "onVoicePlayEnd"
    let data = Object.assign({ bytes, closeNcc, callback }, handleResponse(_obj))
    execEsnBridge("startPlayAudio", data)
}

function pauseVoice(object) {
    let _obj = object || {}
    let closeNcc = true
    let data = Object.assign({ closeNcc }, handleResponse(_obj))
    execEsnBridge("pausePlayAudio", data)
}

function stopVoice(object) {
    let _obj = object || {}
    let closeNcc = true
    let data = Object.assign({ closeNcc }, handleResponse(_obj))
    execEsnBridge("stopPlayAudio", data)
}

function onVoicePlayEnd(object) {
    let _obj = object || {}
    home.upesn.registerResumeCallback("onVoicePlayEnd", function (res) {
        _obj.success && object.success(res)
    })
}

// 语音合成
function startSpeechSyn(object) {
    let _obj = object || {}
    let { text } = _obj
    if (home.isEmpty("text", text, object)) {
        return
    }
    let data = Object.assign({ text }, handleResponse(_obj))
    execEsnBridge("startSpeechSyn", data)
}
function stopSpeechSyn(object) {
    let _obj = object || {}
    let data = handleResponse(_obj)
    execEsnBridge("stopSpeechSyn", data)
}

function scanQRCode(object) {
    let _obj = object || {}
    let { type = "1" } = _obj
    if (type === "n") {
        relayoutCustomWebview({ ..._obj, type: 0 })
    } else if (Object.prototype.hasOwnProperty.call(_obj, "scanType") && _obj.scanType === "barCode") {
        let data = Object.assign(
            { closeNcc: _obj.closeNcc },
            handleResponse(_obj, (res) => {
                return { resultStr: res.barCode }
            })
        )
        execEsnBridge("scanBarcode", data)
    } else {
        var typeNeedResult = "showWeb"
        if (Object.prototype.hasOwnProperty.call(_obj, "needResult")) {
            typeNeedResult = _obj.needResult === 1 ? "qrCode" : "showWeb"
        }
        let data = Object.assign(
            {
                closeNcc: _obj.closeNcc,
                type: typeNeedResult,
            },
            handleResponse(_obj, (res) => {
                return { resultStr: res.qrCode }
            })
        )
        execEsnBridge("QRCodeScan", data)
    }
}

function closeScanQRCode(object) {
    relayoutCustomWebview({ ...object, type: 1 })
}
// 内部调用
function relayoutCustomWebview(object) {
    // 0是默认，1全界面展示webview
    let _obj = object || {}
    let { type = 0 } = _obj
    if (type === 0) {
        home.upesn.registerCallback("scanDataCallback", function (res, responseCallback) {
            _obj.success && _obj.success({ resultStr: res })
            _obj.complete &&
                _obj.complete({
                    code: SUCCESS_CODE,
                    resultStr: res,
                })
            typeof responseCallback === "function" && responseCallback({ name: "FromJS scanDataCallback" })
        })
    }
    let data = {
        type,
        success: function () { },
        fail: function (err) {
            _obj.fail && object.fail(err)
        },
        complete: function () { },
    }
    execEsnBridge("relayoutCustomWebview", data)
}

function generateQRCode(object) {
    if (isNull(object.str)) {
        var err = "generate QRCode is null!"
        object.fail && object.fail(err)
        return
    }
    let qr = new QRious({
        value: object.str,
        size: object.size || 100,
    })
    let imgSrc = qr.toDataURL("image/jpeg")
    let res = {
        imgSrc,
        code: SUCCESS_CODE,
    }
    object.success && object.success(res)
    object.complete && object.complete(res)
}

function isNull(str) {
    if (!str) {
        return true
    }
    if (str == "") return true
    var regu = "^[ ]+$"
    var re = new RegExp(regu)
    return re.test(str)
}

function previewImage(object) {
    let _obj = object || {}
    let _index = object.urls.findIndex((item) => {
        return item == object.current
    })
    let data = {
        images: _obj.urls && object.urls,
        index: _index,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            _obj.fail && object.fail(err)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    execEsnBridge("scanUrlImages", data)
}

function openLocalFile(object) {
    let _obj = object || {}
    let data = {
        filePath: _obj.filePath,
        fileType: _obj.fileType,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            _obj.fail && object.fail(err)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
        closeNcc: _obj.closeNcc,
    }
    execEsnBridge("openLocalFile", data)
}

function getSystemInfo(object) {
    let _obj = object || {}
    let data = {
        closeNcc: true,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            _obj.fail && object.fail(err)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    execEsnBridge("getSystemInfo", data)
}

function faceRegister(object) {
    let _obj = object || {}
    let data = {
        spaceId: _obj.spaceId,
        faceGroupId: _obj.faceGroupId,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            let result = {
                code: err.errCode,
                message: err.errDescription,
            }
            _obj.fail && object.fail(result)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    // eslint-disable-next-line no-undef
    YYEsnBridge.do("faceCollect", data)
}

function faceVerify(object) {
    let _obj = object || {}
    let data = {
        spaceId: _obj.spaceId,
        faceGroupId: _obj.faceGroupId,
        needSmile: _obj.needSmile,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            let result = {
                code: err.errCode,
                message: err.errDescription,
            }
            _obj.fail && object.fail(result)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    execEsnBridge("faceDetect", data)
}

function faceCompare(object) {
    let _obj = object || {}
    let data = {
        spaceId: _obj.spaceId,
        faceGroupId: _obj.faceGroupId,
        needSmile: _obj.needSmile,
        closeNcc: true,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            let result = {
                code: err.errCode,
                message: err.errDescription,
            }
            _obj.fail && object.fail(result)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    execEsnBridge("faceCompare", data)
}

function scanInvoice(object) {
    _getOcrImageInfo(object, "invoice")
}

function recognizeInvoice(object) {
    let ocrImage = object.image
    if (ocrImage.startsWith("/9j/")) {
        openScan(object, ocrImage, "invoice")
        return
    }
    if (ocrImage.startsWith("data:image/")) {
        ocrImage = ocrImage.split(";base64,")[1]
        openScan(object, ocrImage, "invoice")
        return
    }
    _chooseOcrImage(object, "invoice")
}

function scanIDCard(object) {
    _getOcrImageInfo(object, "id")
}

function recognizeIDCard(object) {
    let ocrImage = object.image
    if (ocrImage.startsWith("/9j/")) {
        openScan(object, ocrImage, "id")
        return
    }
    if (ocrImage.startsWith("data:image/")) {
        ocrImage = ocrImage.split(";base64,")[1]
        openScan(object, ocrImage, "id")
        return
    }
    _chooseOcrImage(object, "id")
}

function _recognizeIDCard(object) {
    let { appCode, side, type, localData, url = baseUrl } = object
    let path
    if (type === "invoice") {
        path = `${url}/rest/v1/api/apilink/ocr/invoice/vat/base64`
    } else if (type === "id") {
        path = `${url}/rest/v1/api/apilink/ocr/card/id/base64`
    } else if (type === "bank") {
        path = `${url}/rest/v1/api/apilink/ocr/card/bank/base64`
    }
    let params = {
        image: localData,
        apiCode: appCode,
        isFront: side === "back" ? false : true,
    }
    axios({
        method: "post",
        url: path,
        params: null,
        data: params,
        headers: { "Content-Type": "application/json" },
    })
        .then((res) => {
            object.success && object.success(res.data)
            object.complete && object.complete(res)
        })
        .catch(function (err) {
            object.fail && object.fail(err)
            object.complete && object.complete(err)
        })
}

function scanBankCard(object) {
    _getOcrImageInfo(object, "bank")
}

function recognizeBankCard(object) {
    let ocrImage = object.image
    if (ocrImage.startsWith("/9j/")) {
        openScan(object, ocrImage, "bank")
        return
    }
    if (ocrImage.startsWith("data:image/")) {
        ocrImage = ocrImage.split(";base64,")[1]
        openScan(object, ocrImage, "bank")
        return
    }
    _chooseOcrImage(object, "bank")
}

function _getOcrImageInfo(object, type) {
    let sourceType = object.sourceType
    mtl.chooseImage({
        count: 1, // 默认9
        sizeType: ["original", "compressed"],
        sourceType: sourceType || ["album", "camera"],
        success: (res) => {
            let localIds = res.localIds
            _chooseOcrImage({ ...object, image: localIds[0] }, type)
        },
        fail: object.fail,
    })
}

function _chooseOcrImage(object, type) {
    mtl.getLocalImgData({
        localId: object.image,
        success: function (res) {
            let localData = res.localData
            if (localData.startsWith("data:image/")) {
                localData = localData.split(";base64,")[1]
            }
            openScan(object, localData, type)
        },
        fail: object.fail,
    })
}
function openScan(object, localData, type) {
    _recognizeIDCard({ ...object, localData: localData, type: type })
}

function execUpesnBridge(object) {
    execPluginBridge(object)
}

function execPluginBridge(object) {
    let _obj = object || {}
    YYEsnBridge.do(_obj.method, _obj)
}

function getLocalImgSrc(object) {
    let _obj = object || {}
    let localId = _obj.localId

    if (localId != undefined || localId != null) {
        let data = {
            imgSrc: localId,
        }
        _obj.success && object.success(data)
    } else {
        let err = {
            message: "not found src!",
        }
        _obj.fail && object.fail(err)
    }
    _obj.complete && object.complete("")
}

function isMobileNumber(phone, callback) {
    let flag = false
    let message = ""
    // let myreg = /^1[3|4|5|6|7|8]\d{9}$/;
    if (!phone) {
        flag = false
        message = "mobile number is null!"
    } else {
        flag = true
    }
    if (message) {
        callback && callback(message)
    }
    return flag
}

/**
 * 获取网络状态
 * @param {*} object
 */
function getNetworkType(object = {}) {
    let data = handleResponse(object)
    execEsnBridge("getNetType", data)
}
/**
 * 友空间未提供版本测试
 * 获取设备的唯一标识
 * @param {*} object
 */
function getMac(object) {
    getSystemInfo(
        handleResponse(object, (res) => {
            return { macAddress: res.deviceId }
        })
    )
}

function dail(object) {
    let _object = object || {}
    let number = _object.number
    if (
        isMobileNumber(number, (message) => {
            let err = {
                code: FAIL_CODE,
                message,
            }
            _object.fail && _object.fail(err)
            _object.complete && _object.complete(err)
        })
    ) {
        let data = Object.assign(
            {
                number: number,
                closeNcc: true,
            },
            handleResponse(_object)
        )
        execEsnBridge("callPhone", data)
    }
}

function voiceToText(object) {
    execEsnBridge("voiceToText", handleResponse(object))
}

function chooseImage(object) {
    let _obj = object || {}
    const { returnThumbnail = false } = _obj
    let data = Object.assign(
        {
            ..._obj,
            sourceType: _obj.sourceType || ["album", "camera"],
            count: (_obj.count && _obj.count < 10 && _obj.count > 0 && _obj.count) || 9,
        },
        handleResponse(_obj, (res) => {
            let _localIds = []
            for (let index in res.pictures) {
                let _picture = res.pictures[index]
                let _value
                if (returnThumbnail && _picture.thumbPath) {
                    _value = _picture.thumbPath
                } else {
                    _value = _picture.filePath
                }
                _localIds.push(_value)
            }
            return { localIds: _localIds }
        })
    )
    execEsnBridge("chooseImages", data)
}

function getLocalImgData(object) {
    let _obj = object || {}
    let imgData = _obj.localId
    if (home.isEmpty("localId", imgData, object)) {
        return
    }
    let data = Object.assign(
        {
            type: 1,
            level: 2,
            imgData: imgData,
        },
        handleResponse(_obj, (res) => {
            let base64str = res.base64str
            if (!base64str.startsWith("data:image/")) {
                let imgType = ""
                if (imgData.lastIndexOf(".") == -1) {
                    imgType = "jpeg"
                } else {
                    imgType = imgData.substring(imgData.lastIndexOf(".") + 1, imgData.length)
                }
                base64str = "data:image/" + imgType + ";base64," + base64str
            }
            let retData = {
                localData: base64str,
            }
            return retData
        })
    )
    execEsnBridge("compressLocalImage", data)
}

function getLocation(object) {
    let _obj = object || {}
    let data = handleResponse(_obj)
    execEsnBridge("getLocationInfo", data)
}

function openLocation(object) {
    let _obj = object || {}
    let { latitude, longitude, searchRadius } = _obj
    // if (home.isEmpty('latitude', latitude, object) || home.isEmpty('longitude', longitude, object)) {
    //   return;
    // }
    let data = Object.assign(
        {
            searchRadius: searchRadius,
            latitude: latitude,
            longitude: longitude,
        },
        handleResponse(_obj)
    )
    execEsnBridge("chooseMap", data)
}

function markAndNavigationDestination(object) {
    let _obj = object || {}
    const { latitude, longitude, navigation } = _obj
    if (home.isEmpty("latitude", latitude, object) || home.isEmpty("longitude", longitude, object)) {
        return
    }
    let data = Object.assign(
        {
            address: "",
            subAddress: "",
            latitude: latitude,
            longitude: longitude,
            userInfo: {},
            infomation: "",
            navigation: navigation,
        },
        handleResponse(_obj)
    )
    execEsnBridge("markAndNavigationDestination", data)
}

function httpRequest(object) {
    let _obj = object || {}
    const url = _obj.url
    if (url && url.substring(0, 2) === "${") {
        const key = getBracketStr(url)
        const config = mtl.getStorageSync({
            domain: "mtl",
            key: "mtlContext",
        })
        let host = ""
        if (config.host) {
            host = config.host[key]
        }
        _obj.url = url.replace(`\${${key}}`, host)
    }
    let data = Object.assign(
        {
            url: _obj.url,
            method: _obj.method,
            headers: _obj.headers,
            params: _obj.params || _obj.data,
            paramsType: _obj.paramsType,
            closeNcc: _obj.closeNcc,
        },
        handleResponse(_obj)
    )
    execEsnBridge("httpRequest", data)
}

function getBracketStr(text) {
    let result = ""
    if (!text || text === "") return result
    let regex = /\{(.+?)\}/g
    let options = text.match(regex)
    if (options && options !== "") {
        let option = options[0]
        if (option && option !== "") {
            result = option.substring(1, option.length - 1)
        }
    }
    return result
}

function getOAuthCode(obj = {}) {
    let { tenantId } = obj
    if (home.isEmpty("tenantId", tenantId, obj)) {
        return
    }
    let data = handleResponse(obj)
    execEsnBridge("getOAuthCode", data)
}

function setStorage(obj = {}) {
    let { domain: category = DEFAULT_STORAGE_DOMAIN, key, data } = obj

    if (home.isEmpty("key", key, obj)) {
        return
    }
    if (typeof key != "string") {
        if (typeof key != "string") {
            throw new TypeError("key is not a string")
        }
        return
    }
    let _data = {
        category,
        key,
        data,
        success: function () {
            obj.success && obj.success()
            obj.complete && obj.complete({ code: SUCCESS_CODE, message: "setStorage:ok!" })
        },
        fail: function (error) {
            obj.fail && obj.fail(error)
            obj.complete && obj.complete(error)
        },
    }
    execEsnBridge("setStorage", _data)
}

// function setLocalStorage(obj) {
//   let { domain = DEFAULT_STORAGE_DOMAIN, key, data } = obj;
//   let structs = localStorage.getItem(domain);
//   structs = (structs && JSON.parse(structs)) || {};
//   if (data) {
//     structs[key] = data;
//   } else {
//     delete structs[key];
//   }
//   localStorage.setItem(domain, JSON.stringify(structs));
// }

function getStorage(obj = {}) {
    let { domain: category = DEFAULT_STORAGE_DOMAIN, key } = obj
    if (home.isEmpty("key", key, obj)) {
        return
    }
    let _data = {
        category,
        key,
        success: function (res) {
            let data = res
            if (data) {
                res = { code: 0, message: "", data: { data: data } }
                obj.success && obj.success(res.data)
            } else {
                res = { code: 0, message: "not found data for key: " + key }
                obj.fail && obj.fail(res)
            }
            obj.complete && obj.complete(res)
        },
        fail: function (res) {
            obj.fail && obj.fail(res)
            obj.complete && obj.complete(res)
        },
    }
    execEsnBridge("getStorage", _data)
}

function removeStorage(obj = {}) {
    let { domain: category = DEFAULT_STORAGE_DOMAIN, key } = obj
    let data = Object.assign(
        {
            category,
            key,
        },
        handleResponse(obj)
    )
    execEsnBridge("removeStorage", data)
    removeLocalStorage(obj)
}

function clearStorage(object = {}) {
    let closeNcc = true
    let { domain: category = DEFAULT_STORAGE_DOMAIN } = object
    let data = Object.assign(
        {
            category,
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("removeCategoryStorage", data)
    clearLocalStorage(object)
}

function removeLocalStorage(obj = {}) {
    let { domain = DEFAULT_STORAGE_DOMAIN, key } = obj
    let data = null
    let structs = localStorage.getItem(domain)
    structs = (structs && JSON.parse(structs)) || {}
    if (data) {
        structs[key] = data
    } else {
        delete structs[key]
    }
    localStorage.setItem(domain, JSON.stringify(structs))
}

function clearLocalStorage(obj) {
    const domain = (obj && obj.domain) || DEFAULT_STORAGE_DOMAIN
    localStorage.removeItem(domain)
}

function changeScreenOrientation(object = {}) {
    if (Object.prototype.hasOwnProperty.call(object, "orientation")) {
        let { orientation } = object
        let data = Object.assign({ orientation: !!orientation, closeNcc: true }, handleResponse(object))
        execEsnBridge("changeScreenOrientation", data)
    } else {
        let error = {
            code: FAIL_CODE,
            message: "orientation is null",
        }
        object.fail && object.fail(error)
        object.complete && object.complete(error)
    }
}

function restoreScreenOrientation(obj = {}) {
    let data = { closeNcc: true, ...handleResponse(obj) }
    execEsnBridge("restoreScreenOrientation", data)
}

function uploadFile(object = {}) {
    let { url, filePath, header = { "content-type": "multipart/form-data" }, formData } = object
    if (home.isEmpty("url", url, object) || home.isEmpty("filePath", filePath, object)) {
        return
    }
    let data = Object.assign(
        {
            url: url,
            filePath: filePath,
            header: header,
            formData: formData,
            closeNcc: object.closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("uploadFile", data)
}

function downloadFile(object = {}) {
    let { url, fileType, header, formBody, jsonBody, autoPreview, fileName } = object
    if (home.isEmpty("url", url, object) || home.isEmpty("fileType", fileType, object)) {
        return
    }
    let data = {
        url: url,
        fileType: fileType,
        header: header,
        formBody: formBody,
        jsonBody: jsonBody,
        autoPreview: autoPreview,
        fileName: fileName,
        success: function (res) {
            object.success && object.success(res)
        },
        fail: function (err) {
            object.fail && object.fail(err)
        },
        complete: function (res) {
            object.complete && object.complete(res)
        },
        closeNcc: object.closeNcc,
    }
    execEsnBridge("downloadFile", data)
}

function isWebviewCanGoBack(object = {}) {
    let data = { closeNcc: true, ...handleResponse(object) }
    execEsnBridge("isWebviewCanGoBack", data)
}

function onWebviewGoBack(object = {}) {
    let data = { closeNcc: true, ...handleResponse(object) }
    execEsnBridge("onWebviewGoBack", data)
}

function doShare(object = {}) {
    let { imgUrl, link } = object
    let obj = { ...object }
    delete object.imgUrl
    delete object.link
    obj.imageUrl = imgUrl
    obj.pageUrl = link
    home.upesn.shareWithType({ ...obj })
}

function openShare(object = {}) {
    let { imgUrl, link } = object
    let obj = { ...object }
    delete object.imgUrl
    delete object.link
    obj.imageUrl = imgUrl
    obj.pageUrl = link
    home.upesn.showShareMenu({ ...obj })
}

function backIntercept(object) {
    let _obj = object || {}
    let callback = "backInterceptCallback"
    home.upesn.registerCallback(callback, function (res, responseCallback) {
        _obj.callback && _obj.callback(res)
        _obj.complete &&
            _obj.complete({
                code: SUCCESS_CODE,
            })
    })
    let data = {
        callback: callback,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            _obj.fail && object.fail(err)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    execEsnBridge("backIntercept", data)
}

function getAuthorizationStatus(object) {
    let closeNcc = true
    let { type = 0 } = object
    let data = Object.assign(
        {
            type,
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("getAuthorizationStatus", data)
}

function onNetworkStatusChange(object) {
    let _obj = object || {}
    let callback = "onNetworkStatusChange"
    home.upesn.registerCommonCallback(callback, function (res, responseCallback) {
        _obj.callback && _obj.callback(res)
        _obj.complete &&
            _obj.complete({
                code: SUCCESS_CODE,
            })
    })
    let data = {
        callback: callback,
        closeNcc: true,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            _obj.fail && object.fail(err)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    execEsnBridge("onNetworkStatusChange", data)
}

function watchShake(object) {
    let _obj = object || {}
    let callback = "watchShake"
    home.upesn.registerCommonCallback(callback, function (res, responseCallback) {
        _obj.callback && _obj.callback(res)
        _obj.complete &&
            _obj.complete({
                code: SUCCESS_CODE,
            })
    })
    let data = {
        callback: callback,
        closeNcc: true,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            _obj.fail && object.fail(err)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    execEsnBridge("watchShake", data)
}

function screenShot(object) {
    let { type = 0, resultType = 0 } = object
    let data = Object.assign(
        {
            type,
            resultType,
        },
        handleResponse(object)
    )
    execEsnBridge("screenShot", data)
}

function onUserCaptureScreen(object) {
    let _obj = object || {}
    let callback = "onUserCaptureScreen"
    home.upesn.registerCommonCallback(callback, function (res, responseCallback) {
        _obj.callback && _obj.callback(res)
        _obj.complete &&
            _obj.complete({
                code: SUCCESS_CODE,
            })
    })
    let data = {
        callback: callback,
        closeNcc: true,
        success: function (res) {
            _obj.success && object.success(res)
        },
        fail: function (err) {
            _obj.fail && object.fail(err)
        },
        complete: function (res) {
            _obj.complete && object.complete(res)
        },
    }
    execEsnBridge("onUserCaptureScreen", data)
}

function vibrateOnce(object) {
    let closeNcc = true
    let data = Object.assign(
        {
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("vibrateOnce", data)
}

function saveImageToPhotoAlbum(object) {
    let closeNcc = true
    const { url } = object
    let data = Object.assign(
        {
            url,
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("saveImageToPhotoAlbum", data)
}

function saveImageToLocal(object) {
    let closeNcc = true
    const { url } = object
    let data = Object.assign(
        {
            url,
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("saveImageToLocal", data)
}

function chooseVideo(object) {
    let closeNcc = true
    const { sourceType, maxDuration } = object
    let data = Object.assign(
        {
            sourceType,
            maxDuration,
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("chooseVideo", data)
}

function chooseVideoToServer(object) {
    let closeNcc = true
    const { sourceType, maxDuration } = object
    let data = Object.assign(
        {
            sourceType,
            maxDuration,
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("chooseVideoToServer", data)
}

function chooseCity(object) {
    let closeNcc = true
    const { province = "北京市" } = object
    let data = Object.assign(
        {
            province,
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("chooseCity", data)
}

function dateTimePicker(object) {
    let closeNcc = true
    const { format = "yyyy-MM-dd", currentDate } = object
    let data = Object.assign(
        {
            format,
            currentDate,
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("dateTimePicker", data)
}

function encryptData(object) {
    const { data } = object
    let params = Object.assign(
        {
            data,
        },
        handleResponse(object)
    )
    execEsnBridge("encryptData", params)
}

function decryptData(object) {
    const { data } = object
    let params = Object.assign(
        {
            data,
        },
        handleResponse(object)
    )
    execEsnBridge("decryptData", params)
}

function recordAudio(object) {
    let closeNcc = true
    let data = Object.assign(
        {
            closeNcc,
        },
        handleResponse(object)
    )
    execEsnBridge("recordAudio", data)
}

// backToHome 应用到后台
function backToHome(obj = {}) {
    let data = handleResponse(obj)
    execEsnBridge("backToHome", data)
}

// 获取原生导航信息
function getNavBarInfo(obj = {}) {
    let data = {
        success: function (res) {
            const { height } = res
            obj.success && obj.success({ ...res, isNativeNavBar: height > 0 ? true : false })
        },
        fail: function (err) {
            obj.fail && obj.fail(err)
        },
        complete: function (res) {
            obj.complete && obj.complete(res)
        },
    }
    execEsnBridge("getNavBarInfo", data)
}

//打开新页面
function navigateTo(obj = {}) {
    execNavi("navigateTo", obj)
}
//关闭当前页面
function navigateBack(obj = {}) {
    let data = Object.assign(
        {
            closeNcc: true,
            ...obj,
        },
        handleResponse(obj)
    )
    execEsnBridge("navigateBack", data)
}
//打开新页面并关闭当前页面
function redirectTo(obj = {}) {
    execNavi("redirectTo", obj)
}
//打开新页面，关闭前面所有页面
function reLaunch(obj = {}) {
    execNavi("reLaunch", obj)
}

//配置webview
function configureWebView(obj = {}) {
    execEsnBridge("configureWebView", obj)
}

/**
 * 处理导航打开页面参数
 */
function execNavi(method, obj) {
    const { url } = obj
    if (home.isEmpty("url", url, obj)) {
        return
    }
    let data = Object.assign({ closeNcc: true, ...obj }, handleResponse(obj))
    execEsnBridge(method, data)
}
function getUserInfo(obj = {}) {
    home.upesn.getUserYHTInfo({
        success: function (res) {
            obj.success && obj.success({ ...res, userId: res.yht_userid })
            obj.complete && obj.complete({ data: res, code: SUCCESS_CODE })
        },
        fail: function (err) {
            obj.fail && obj.fail(err)
            obj.complete && obj.complete(err)
        },
    })
}
// 字体
function getUserFontSize(obj = {}) {
    let closeNcc = true
    let data = Object.assign({ closeNcc }, handleResponse(obj))
    execEsnBridge("getUserFontSize", data)
}

function setUserFontSize(obj = {}) {
    const { level = 1 } = obj
    let data = Object.assign(
        {
            level,
        },
        handleResponse(obj)
    )
    execEsnBridge("setUserFontSize", data)
}

function releaseBle(obj = {}) {
    let data = handleResponse(obj)
    execEsnBridge("release", data)
}

function openScheduleDetail(obj = {}) {
    const { memberId } = obj
    let data = Object.assign(
        {
            ...obj,
            member_id: memberId,
        },
        handleResponse(obj)
    )
    execEsnBridge("openScheduleDetail", data)
}

function getClipboardData(obj = {}) {
    let data = handleResponse(obj)
    execEsnBridge("copyTextPasteboard", data)
}

function chooseFileFromLibrary(obj = {}) {
    let data = handleResponse(obj)
    execEsnBridge("chooseFileFromLibrary", data)
}

function registerLifeCycle(obj = {}) {
    let onShowStr = "onShowCallback"
    let onHideStr = "onHideCallback"
    home.upesn.registerCommonCallback(onShowStr, function (res, responseCallback) {
        obj.onShow && obj.onShow(res)
        obj.complete &&
            obj.complete({
                code: SUCCESS_CODE,
            })
    })
    home.upesn.registerCommonCallback(onHideStr, function (res, responseCallback) {
        obj.onHide && obj.onHide(res)
        obj.complete &&
            obj.complete({
                code: SUCCESS_CODE,
            })
    })
    let data = Object.assign(
        {
            onHide: onHideStr,
            onShow: onShowStr,
        },
        handleResponse(obj)
    )
    execEsnBridge("registerLifeCycle", data)
}

function onAppearanceModeChange(obj = {}) {
    let callback = "appearanceModeChangeCallback"
    home.upesn.registerCommonCallback(callback, function (res, responseCallback) {
        const modeNumber = res.mode
        obj.callback && obj.callback({ ...res, mode: modeNumber === 0 ? "light" : "dark" })
        obj.complete &&
            obj.complete({
                code: SUCCESS_CODE,
            })
    })
    let data = {
        callback: callback,
        success: function (res) {
            obj.success && obj.success(res)
        },
        fail: function (err) {
            obj.fail && obj.fail(err)
        },
        complete: function (res) {
            obj.complete && obj.complete(res)
        },
    }
    execEsnBridge("onAppearanceModeChange", data)
}

/**
 * 统一处理API的回调
 * @param {*} object
 * @param {*} callback
 */
function handleResponse(object, callback) {
    return home.handleResponse(object, callback)
}

function execEsnBridge(method, source) {
    home.execEsnBridge(method, source)
}

let exports = {
    upesn: home.upesn,
    startRecord,
    stopRecord,
    onVoiceRecordEnd,
    playVoice,
    pauseVoice,
    stopVoice,
    onVoicePlayEnd,
    previewImage,
    openLocalFile,
    getSystemInfo,
    faceRegister,
    faceVerify,
    faceCompare,
    scanInvoice,
    recognizeInvoice,
    scanIDCard,
    recognizeIDCard,
    scanBankCard,
    recognizeBankCard,
    getLocalImgSrc,
    getNetworkType,
    getMac,
    dail,
    voiceToText,
    chooseImage,
    getLocalImgData,
    getLocation,
    openLocation,
    markAndNavigationDestination,
    scanQRCode,
    closeScanQRCode,
    generateQRCode,
    request: httpRequest,
    getOAuthCode,
    setStorage,
    getStorage,
    removeStorage,
    clearStorage,
    changeScreenOrientation,
    restoreScreenOrientation,
    uploadFile,
    downloadFile,
    isWebviewCanGoBack,
    onWebviewGoBack,
    stopSpeechSyn,
    startSpeechSyn,
    translateVoice,
    doShare,
    openShare,
    backIntercept,
    execUpesnBridge,
    execPluginBridge,
    getAuthorizationStatus,
    onNetworkStatusChange,
    watchShake,
    screenShot,
    onUserCaptureScreen,
    vibrateOnce,
    saveImageToPhotoAlbum,
    saveImageToLocal,
    chooseVideo,
    chooseVideoToServer,
    chooseCity,
    dateTimePicker,
    encryptData,
    decryptData,
    recordAudio,
    backToHome,
    getNavBarInfo,
    navigateTo,
    navigateBack,
    redirectTo,
    reLaunch,
    getUserInfo,
    getUserFontSize,
    setUserFontSize,
    configureWebView,
    releaseBle,
    openScheduleDetail,
    getClipboardData,
    chooseFileFromLibrary,
    registerLifeCycle,
    onAppearanceModeChange,
    uploadImageBackBase64: home.upesn.uploadImageBackBase64,
    chooseFile: home.upesn.chooseFile,
    chooseLocalFileToServer: home.upesn.chooseLocalFileToServer,
    chooseImageToServer: home.upesn.chooseImageToServer,
    isShowTabbar: home.upesn.isShowTabbar,
    openNewWebview: home.upesn.openNewWebview,
    closeCurrentWebview: home.upesn.closeCurrentWebview,
    continuousLocationStart: home.upesn.startContinuousLocation,
    continuousLocationGet: home.upesn.getContinuousLocation,
    continuousLocationStop: home.upesn.stopContinuousLocation,
    loadImageFromLocal: home.upesn.loadImageFromLocal,
    settingNavBar: home.upesn.settingNavBar,
    showToast: home.upesn.showToast,
    showAlert: home.upesn.showAlert,
    customScanQRCode: home.upesn.customScanQRCode,
    executeDBOperate: home.upesn.executeDBOperate,
    chooseLocalFiles: home.upesn.chooseLocalFiles,
    registerCommonCallback: home.upesn.registerCommonCallback,
    mdfCustomScanQRCode: home.upesn.mdfCustomScanQRCode,
    mdfChangeCustomScanMode: home.upesn.mdfChangeCustomScanMode, //改变扫码模式   单次/连续
    mdfChangeFlashLightStatus: home.upesn.mdfChangeFlashLightStatus,
    blueToothConnectState: home.upesn.blueToothConnectState,
    blueToothConnect: home.upesn.blueToothConnect,
    blueToothPrint: home.upesn.blueToothPrint,
    blueToothDisConnect: home.upesn.blueToothDisConnect,
    blueToothScan: home.upesn.blueToothScan,
    blueToothStopScan: home.upesn.blueToothStopScan,
    rfidConnect: home.upesn.rfidConnect,
    rfidDisconnect: home.upesn.rfidDisconnect,
    setAppletCapsuleStyle: home.upesn.setAppletCapsuleStyle,
    getAppletCapsuleParams: home.upesn.getAppletCapsuleParams,
    setStatusBarStyle: home.upesn.setStatusBarStyle,
    openChatWindow: home.upesn.openChatByUserId,
    chooseContacts: home.upesn.chooseContacts,
    chooseDocFiles: home.upesn.chooseDocFiles,
    previewDoc: home.upesn.previewDoc,
    sendTodoReceipt: home.upesn.sendTodoReceipt,
    getAppInfomation: home.upesn.getAppInfomation,
    compressLocalImage: home.upesn.compressLocalImage,
    getBlueToothState: home.upesn.getBlueToothState,
    verifyLoginPassword: home.upesn.verifyLoginPassword,
    verifyGesturePassword: home.upesn.verifyGesturePassword,
    setGesturePassword: home.upesn.setGesturePassword,
    getToken: home.upesn.getToken,
    viewScheduleList: home.upesn.viewScheduleList,
    viewScheduleDetail: home.upesn.viewScheduleDetail,
    createNewSchedule: home.upesn.createNewSchedule,
    createFeedComponent: home.upesn.createFeedComponent,
    chooseDepartment: home.upesn.chooseDepartment,
    sendMiniMail: home.upesn.sendMiniMail,
    openLibraryFiles: home.upesn.openLibraryFiles,
    chooseLibraryFiles: home.upesn.chooseLibraryFiles,
    viewUserInfo: home.upesn.viewUserInfo,
    chooseInsideGroup: home.upesn.chooseInsideGroup,
    chooseAllContacts: home.upesn.chooseAllContacts,
    sendImageMessages: home.upesn.sendImageMessages,
    openAppWithParams: home.upesn.openAppWithParams,
    getAppData: home.upesn.getAppData,
    wpsPreview: home.upesn.wpsPreview,
    getUserYHTInfo: home.upesn.getUserYHTInfo,
}

unsupportMethods.forEach((pop) => {
    exports[pop] = unsupportMethod
})

supportMethods.forEach((pop) => {
    exports[pop] = home.successCallBack
})

execBridgeMethods.forEach((pop) => {
    if (!exports[pop]) {
        exports[pop] = function (param) {
            let data = Object.assign(
                {
                    ...param,
                },
                handleResponse(param)
            )
            execEsnBridge(pop, data)
        }
    }
})

export default exports