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

ynf-fw-mtl-api

/*
 * @Author: wangyingliang@yonyou.com
 * @Date: 2023-11-15 20:56:18
 * @LastEditors: wangyingliang wangyingliang@yonyou.com
 * @LastEditTime: 2025-09-02 20:40:44
 * @FilePath: /mtl-api-project/src/platforms/tt/methods.js
 * @Description: 飞书 函数列表
 * Copyright (c) 2023 by Yonyou, All Rights Reserved.
 */
import QRious from 'qrious'
import xaxios from 'axios'
import unique from '../../common/unique.js'
import home from './unique.js'
import syncMethod from '../../common/syncMethod.js'
import h5 from '../h5/methods'
import map from '../h5/map/amapLocation.js'

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

const unsupportFailRes = {
    code: FAIL_CODE,
    message: "The current platform doesn't support",
}

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

const unsupportMethods = [
    "startSpeechSyn",
    "stopSpeechSyn",
    "showToast",
    "openShare",
    "closeScanQRCode",
    "setStatusBar",
    "registerCommonCallback",
    "getStatusBarHeight",
    "chooseVideoToServer",
    "execUpesnBridge",
    "moveFileToDisk",
    "smileDetect",
    "faceCompare",
    "faceVerify",
    "faceRegister",
]

/**
 * 处理API成功的回调
 */
function successCallBack(obj = {}) {
    obj.success && obj.success({})
    obj.complete && obj.complete({})
}

function successCallBackArray(obj = {}) {
    obj.success && obj.success([])
    obj.complete && obj.complete({})
}

const supportMethods = [
    "isExclusivePreloadMDF",
    "getExclusiveAppH5LocationPath",
    "restoreScreenOrientation",
    "changeScreenOrientation",
    "isWebviewCanGoBack",
    "onWebviewGoBack",
    "backIntercept",
    "closeScanQRCode",
    "getAppInfo",
    "chooseVideo",
    "switchLongPress",
    "setUserFontSize",
    "afterPrivacyAgreement",
    "webViewCustomScanQRCode",
    "execPluginBridge",
    "execPluginSyncBridge",
    "setCookie",
    "requestPermission",
    "chooseMap",
    "setGesturePassword",
    "verifyGesturePassword",
    "verifyLoginPassword",
    "continuousLocationStart",
    "mapLocationExtend",
    "compressLocalImage",
    "continuousShooting",
    "getVideoThumbnail",
    "chooseFile",
    "chooseFileFromLibrary",
    "commonReplyComponent",
    "searchBleClient",
    "bindSensor",
    "getBindedSensor",
    "connectBle",
    "registerConnectStatusListener",
    "collectVib",
    "collectTmp",
    "collectRev",
    "getConnectStatus",
    "stopCollect",
    "disconnectBle",
    "translateVoice",
    "encryptData",
    "decryptData",
    "viewUserInfo",
    "chooseDepartment",
    "chooseContacts",
    "chooseAllContacts",
    "chooseInsideGroup",
    "convertMemberIDs",
    "chooseUserOrGroupFromChat",
    "createFeedComponent",
    "sendImageMessages",
    "createNewSchedule",
    "viewScheduleList",
    "viewScheduleDetail",
    "getSchedulesFromMobile",
    "sendMiniMail",
    "openLibraryFiles",
    "chooseLibraryFiles",
    "getUserYHTInfo",
    "getUserAgent",
    "getUserFontSize",
    "openCreateSpace",
    "copyTextPasteboard",
    "operateCloudAlarm",
    "checkCloudAlarm",
    "continuousShootingLocal",
    "openChatByGroupId",
    "getXYVersion",
    "openXYChatView",
    "closeXYChatView",
    "mdfIsLoad",
    "chooseGroupContacts",
    "jumpSystemSettings",
    "configSkinAndTabbar",
    "getWechatBill",
    "isFileExist",
    "getAppInformation",
    "getMultiDataCenterConfig",
    "selectFiles",
    "getWatermarkInfo",
    "openLiveFlow",
    "relayoutCustomWebview",
    "writeAnnounceReply",
    "openAnnounceReply",
    "collectionData",
    "getGzipAppData",
    "configAppletMenu",
    "getHhtQrCodeInfo",
    "startMirrorScreen",
    "closeMirrorScreen",
    "checkMirrorStatus",
    "yonyouPay",
    "announceDetail",
    "writeLocationLog",
    "readLocationLog",
    "reloadWorkbenchPath",
    "openSearchAppList",
    "openSignViewWithParams",
    "shareApplet",
    "zebraPrinterList",
    "zebraPrintImage",
    "getOffLineOutSignPhoto",
    "config",
    "registerLifeCycle",
    "appletFromQzId",
    "openWindow",
    "openPluginWithParams",
    "openAppSetting",
    "openCustomSetting",
    "releaseBle",
    "vibrateLong",
    "openDocument",
    "appearanceMode",
    "onAppearanceModeChange",
    "toggleCamera",
    "onPullDownHandle",
    "stopPullDownHandle",
    "onPullUpHandle",
    "stopPullUpHandle",
    "deleteBase64Image",
    "getBase64Image",
    "saveBase64Image",
    "createShortcut",
    "openScheduleDetail",
    "executeDBOperate",
    "h5PageClose",
    "configureWebView",
]

/**
 * 处理回调返回结构
 * @param {string} code 响应code
 * @param {string} msg code 对应的说明
 */
function resultStructure(code, msg) {
    const response = {
        code: code,
        message: msg,
    }
    return response
}

/**
 * 生成二维码
 * @param {string} str 图片路径, 不支持网络
 * @param {number} size 生成图片大小，默认 100 * 100
 */
function generateQRCode(object) {
    if (unique.isEmpty("str", object?.str, object)) {
        return
    }
    let qr = new QRious({
        value: object?.str,
        size: object?.size || 100,
    })
    let imgSrc = qr.toDataURL("image/jpeg")
    let res = { imgSrc }
    object?.success && object?.success(res)
    object?.complete && object?.complete(res)
}

/**
 * 二维码扫描
 * @param {string[]} scanType 图片路径, 不支持网络
 */
function scanQRCode(object) {
    let scanType = ["barCode", "qrCode", "datamatrix", "pdf417"]
    tt.scanCode({
        scanType: object?.scanType || scanType,
        success(res) {
            console.log(JSON.stringify(res))
            let response = {
                resultStr: res.result,
            }
            object?.success && object?.success(response)
        },
        fail(res) {
            let response = resultStructure(FAIL_CODE, `scanCode fail: ${JSON.stringify(res)}`)
            object?.fail && object?.fail(response)
        },
    })
}

/**
 * 调用相机 || 相册
 * @param {number} count 最多可以选择的图片张数
 * @param {string[]} sourceType 选择图片的来源 ['album', 'camera']
 * @param {object} watermark 图片水印
 * @param {boolen} returnThumbnail 是否需要返回缩略图, 默认false
 * @param {string[]} sizeType 选择原图，或是对图片质量进行压缩。["original","compressed"]
 * @param {string} cameraDevice 使用相机拍摄的默认摄像头, front, back
 * @param {string} isSaveToAlbum 使用相机拍摄后图片是否保存到相册。"0"不存 || "1"存
 */
function chooseImage(object) {
    let watermark = object?.watermark
    let returnThumbnail = object?.returnThumbnail
    tt.chooseImage({
        count: 1,
        sourceType: object?.sourceType || ["album", "camera"], // PC端无效
        sizeType: object?.sizeType || ["original"],
        cameraDevice: object?.cameraDevice || "back",
        isSaveToAlbum: object?.isSaveToAlbum || "0",
        success(res) {
            console.log(res.tempFilePaths, res.tempFiles)

            // 转化图片地址为base64
            getLocalImgData({
                localId: res.tempFilePaths[0],
                success: (resLID) => {
                    // 获取到图片后需要判断是否需要打水印等功能.
                    if (!!!watermark && !returnThumbnail) {
                        let obj = {
                            localIds: resLID.localData,
                        }
                        object?.success && object?.success(obj)
                    } else {
                        // 走水印通用逻辑.
                        unique.selectedImages({ ...object, localIds: resLID.localData, originLOcalIds: localIds })
                    }
                },
                fail: (err) => {
                    let response = resultStructure(FAIL_CODE, `getLocalImgData fail: ${JSON.stringify(err)}`)
                    object?.fail && object?.fail(response)
                },
            })
        },
        fail(err) {
            let response = resultStructure(FAIL_CODE, `chooseImage fail: ${JSON.stringify(err)}`)
            object?.fail && object?.fail(response)
        },
    })
}

/**
 * 压缩图片
 * @param {string} url 图片路径, 不支持网络
 * @param {number} quality 图片压缩质量。取值范围 (0,100]
 */
function compressImage(object) {
    const { url } = object

    // 校验url
    if (!(url && url.length > 0)) {
        let response = resultStructure(FAIL_CODE, "url is null")
        object?.fail && object?.fail(response)
        return
    }

    if (url.indexOf("http") != -1) {
        let response = resultStructure(FAIL_CODE, "Network URL not supported")
        object?.fail && object?.fail(response)
        return
    }

    tt.compressImage({
        src: url,
        quality: object?.quality || 80,
        success: (res) => {
            console.log(res)
            object?.success && object?.success(res)
        },
        fail: (res) => {
            let response = resultStructure(FAIL_CODE, `compressImage fail: ${JSON.stringify(res)}`)
            object?.fail && object?.fail(response)
        },
    })
}

/**
 * 预览图片
 * @param {string[]} urls 图片地址列表, 支持本地和网络 url
 * @param {object} header 请求头（Header），对传入的网络 url 生效。
 * @param {string} current 默认显示的图片地址
 * @param {boolean} shouldShowSaveOption 是否显示图片存储功能
 */
function previewImage(object) {
    tt.previewImage({
        urls: object?.urls,
        header: object?.header,
        current: object?.current || false,
        shouldShowSaveOption: object?.shouldShowSaveOption || false,
        success(res) {
            console.log("previewImage sucess  res = ", res)
            object?.success && object?.success(res)
        },
        fail(res) {
            let response = resultStructure(FAIL_CODE, `previewImage fail: ${JSON.stringify(res)}`)
            object?.fail && object?.fail(response)
        },
    })
}

/**
 * 打开新窗口
 * @param {string} url
 * @param {boolean} external 是否跳转到飞书以外的应用
 */
function openNewWebview(object) {
    tt.openSchema({
        schema: object?.url,
        external: object?.external || false,
        success(res) {
            object?.success && object?.success(res)
        },
        fail(res) {
            let response = resultStructure(FAIL_CODE, `openSchema fail: ${JSON.stringify(res)}`)
            object?.fail && object?.fail(response)
        },
    })
}

/**
 * 关闭当前窗口
 */
function closeCurrentWebview(object) {
    tt.closeWindow({
        fail(res) {
            const error = {
                code: FAIL_CODE,
                message: `closeWindow fail: ${JSON.stringify(res)}`,
            }
            object?.fail && object?.fail(error)
        },
    })
}

/**
 * 存储图片到相册
 * @param {string} url 图片的路径.不支持网络url.
 */
function saveImageToPhotoAlbum(object) {
    let url = object?.url

    // 校验url
    if (!url) {
        let response = resultStructure(FAIL_CODE, "url is null")
        object?.fail && object?.fail(response)
        return
    }

    if (url.indexOf("http") !== -1) {
        let response = resultStructure(FAIL_CODE, "Network URL not supported")
        object?.fail && object?.fail(response)
        return
    }

    tt.saveVideoToPhotosAlbum({
        filePath: url, // 本地视频文件
        success(res) {
            console.log(res)
            object?.success && object?.success(res)
        },
        fail(res) {
            console.log(`saveVideoToPhotosAlbum failed`)
            const error = {
                code: FAIL_CODE,
                message: `saveVideoToPhotosAlbum fail: ${JSON.stringify(res)}`,
            }
            object?.fail && object?.fail(error)
        },
    })
}

function getLocalImgData(obj = {}) {
    var { localId } = obj
    if (localId) {
        if (localId.indexOf("\n") != -1 || localId.indexOf("\r") != -1 || localId.indexOf(" ") != -1) {
            // 包含\n,可以直接替换, 解决android机器base64编码后带有\n问题
            localId = localId.replace(/(\r\n)|(\n)|(\s)/g, "")
        }

        obj.success && obj.success({ localData: localId })
        obj.complete && obj.complete({ localData: localId })
    } else {
        obj.fail && obj.fail({
            code: FAIL_CODE,
            message: "no found localId",
        })
    }
}

/**
 * 获取tt本地文件函数
 * @param {string} localId 图片的路径
 */
function getLocalImgDatas(object) {
    if (!object?.localId) {
        const error = {
            code: FAIL_CODE,
            message: "localId is null",
        }

        object?.fail && object?.fail(error)
        object?.complete && object?.complete(error)
        return
    }

    const fileSystemManager = tt.getFileSystemManager()
    fileSystemManager.readFile({
        filePath: object?.localId,
        encoding: object?.encoding || "base64",
        position: object?.position || 0,
        success(res) {
            // 返回值
            let base64Data = res?.data
            if (base64Data.indexOf("\n") != -1 || base64Data.indexOf("\r") != -1 || base64Data.indexOf(" ") != -1) {
                // 包含\n,可以直接替换, 解决android机器base64编码后带有\n问题
                base64Data = base64Data.replace(/(\r\n)|(\n)|(\s)/g, "")
            }

            // var file = unique.base64ToFile(base64Data, object?.fileName || new Date().getTime() + '');

            let obj = {
                localData: base64Data,
                localIds: [base64Data]
            }

            object?.success && object?.success(obj)
        },
        fail(err) {
            const error = {
                code: FAIL_CODE,
                message: `readFile fail: ${JSON.stringify(err)}`,
            }
            object?.fail && object?.fail(error)
        },
    })
}

/**
 * 获取网络状况
 */
function getNetworkType(object) {
    tt && tt.getNetworkType({
        success(res) {
            object?.success && object?.success(res)
        },
        fail(err) {
            const error = {
                code: FAIL_CODE,
                message: `readFile fail: ${JSON.stringify(err)}`,
            }
            object?.fail && object?.fail(error)
        },
    })
}

function scanInvoice(object) {
    mtl.chooseImage({
        count: 1,
        sizeType: ["original", "compressed"],
        sourceType: ["album", "camera"],
        success: (res) => {
            let localIds = res.localIds
            mtl.recognizeInvoice({ ...object, image: localIds[0] })
        },
        fail: object?.fail,
    })
}

function recognizeInvoice(object) {
    let { appCode, image, url = baseUrl } = object
    new Promise((resolve, reject) => {
        if (image.startsWith("ttfile://")) {
            mtl.getLocalImgData({
                localId: image,
                success: resolve,
                fail: reject,
            })
        } else {
            resolve({ localData: image })
        }
    }).then((res) => {
        let imgBase64 = res.localData

        // 移除\n
        if (imgBase64.indexOf("\n") != -1 || imgBase64.indexOf("\r") != -1 || imgBase64.indexOf(" ") != -1) {
            // 包含\n,可以直接替换, 解决android机器base64编码后带有\n问题
            imgBase64 = imgBase64.replace(/(\r\n)|(\n)|(\s)/g, "")
        }

        let index = imgBase64.indexOf("base64,")
        if (index !== -1) {
            imgBase64 = imgBase64.substring(index + 7, imgBase64.count)
        }
        let path = `${url}/rest/v1/api/apilink/ocr/invoice/vat/base64`
        let params = {
            image: imgBase64,
            apiCode: appCode,
        }
        return axios({
            method: "post",
            url: path,
            params: null,
            data: params,
            headers: {
                "Content-Type": "application/json;charset=UTF-8",
            },
        })
    }).then((res) => {
        object?.success && object?.success(res.data)
        object?.complete && object?.complete(res)
    }).catch((err) => {
        let result = {
            code: FAIL_CODE,
            message: err.toString(),
        }
        object?.fail && object?.fail(result)
        object?.complete && object?.complete(result)
    })
}

/**
 * 获取用户信息
 * @param {function} success 成功的回调
 * @param {function} fail 失败的回调
 */
function getUserInfo(obj = {}) {
    getStorage({
        key: "USER_ID",
        success: function (res) {
            obj.success && obj.success({ userId: res.data })
            obj.complete && obj.complete({ data: res, code: 200 })
        },
        fail: function (err) {
            obj.fail && obj.fail(err)
            obj.complete && obj.complete(err)
        },
    })
}

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

function getMac(object) {
    console.log(object);
}

function getWifiInfo(object) {
    tt && tt.getWifiInfo({
        success: (res) => {
            let resData = {
                ssid: res?.SSID,
                bssid: res?.BSSID,
                ipAddress: res?.IPAddress,
                macAddress: res?.MACAddress,
                name: res?.SSID,
                mac: res?.BSSID,
            }
            object?.success && object?.success(resData)
        },
        fail: (err) => {
            object?.fail && object?.fail(err)
        },
    })
}

function recognizeIDCard(object) {
    let { appCode, side, image, url = baseUrl } = object
    new Promise((resolve, reject) => {
        if (image.startsWith("ttfile://")) {
            mtl.getLocalImgData({
                localId: image,
                success: resolve,
                fail: reject,
            })
        } else {
            resolve({ localData: image })
        }
    }).then((res) => {
        let imgBase64 = res.localData

        // 移除\n
        if (imgBase64.indexOf("\n") != -1 || imgBase64.indexOf("\r") != -1 || imgBase64.indexOf(" ") != -1) {
            // 包含\n,可以直接替换, 解决android机器base64编码后带有\n问题
            imgBase64 = imgBase64.replace(/(\r\n)|(\n)|(\s)/g, "")
        }

        let index = imgBase64.indexOf("base64,")
        if (index !== -1) {
            imgBase64 = imgBase64.substring(index + 7, imgBase64.count)
        }
        let path = `${url}/rest/v1/api/apilink/ocr/card/id/base64`
        let params = {
            image: imgBase64,
            apiCode: appCode,
            isFront: side === "back" ? false : true,
        }
        return axios({
            method: "post",
            url: path,
            params: null,
            data: params,
            headers: {
                "Content-Type": "application/json;charset=UTF-8",
            },
        })
    }).then((res) => {
        object?.success && object?.success(res.data)
        object?.complete && object?.complete(res)
    }).catch((err) => {
        let result = {
            code: FAIL_CODE,
            message: err.toString(),
        }
        object?.fail && object?.fail(result)
        object?.complete && object?.complete(result)
    })
}

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

function recognizeBankCard(object) {
    let { appCode, image, url = baseUrl } = object
    new Promise((resolve, reject) => {
        if (image.startsWith("ttfile://")) {
            mtl.getLocalImgData({
                localId: image,
                success: resolve,
                fail: reject,
            })
        } else {
            resolve({ localData: image })
        }
    }).then((res) => {
        let imgBase64 = res.localData

        // 移除\n
        if (imgBase64.indexOf("\n") != -1 || imgBase64.indexOf("\r") != -1 || imgBase64.indexOf(" ") != -1) {
            // 包含\n,可以直接替换, 解决android机器base64编码后带有\n问题
            imgBase64 = imgBase64.replace(/(\r\n)|(\n)|(\s)/g, "")
        }

        let index = imgBase64.indexOf("base64,")
        if (index !== -1) {
            imgBase64 = imgBase64.substring(index + 7, imgBase64.count)
        }
        let path = `${url}/rest/v1/api/apilink/ocr/card/bank/base64`
        let params = {
            image: imgBase64,
            apiCode: appCode,
        }
        return axios({
            method: "post",
            url: path,
            params: null,
            data: params,
            headers: {
                "Content-Type": "application/json;charset=UTF-8",
            },
        })
    }).then((res) => {
        object?.success && object?.success(res.data)
        object?.complete && object?.complete(res)
    }).catch((err) => {
        let result = {
            code: FAIL_CODE,
            message: err.toString(),
        }
        object?.fail && object?.fail(result)
        object?.complete && object?.complete(result)
    })
}

/**
 * 网络请求
 * @param {String} url 是开发者服务器接口地址
 * @param {Object} params 否请求参数
 * @param {Object} headers 否设置请求的 headers，`content-type`，默认为 `application/json`
 * @param {String} method 否默认为 GET, GET || POST
 * @param {Number} paramsType 否请求参数的类型;0 键值对,1 json格式，只支持POST请求，会在header中自动添加content-type:application/json
 */
function request(object) {
    let { url, method = "GET", headers = { "content-type": "application/json" }, params } = object
    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]
        }
        url = url.replace(`\${${key}}`, host)
    }
    let obj = {
        url,
        method,
        headers,
        params: method.toUpperCase() == "GET" ? params : {},
        data: method.toUpperCase() == "POST" ? params : {},
        timeout: object?.timeout || 0,
        responseType: "json",
        withCredentials: true,
    }
    axios(obj).then((response) => {
        let { status: code, statusText: message, data } = response
        if (code === 200) {
            object?.success && object?.success(response)
        } else {
            object?.fail && object?.fail({ code, message, data })
        }
        object?.complete && object?.complete({ code, message, data })
    }).catch((err) => {
        const result = (err.response && err.response.data) || { code: FAIL_CODE, message: err.message }
        object?.fail && object?.fail(result)
        object?.complete && object?.complete(result)
    })
}

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 setStorage(obj) {
    let { domain = DEFAULT_STORAGE_DOMAIN, key, data } = obj
    if (unique.isEmpty("key", key, obj)) {
        return
    }
    if (typeof key != "string") {
        throw new TypeError("key is not a string")
    }
    let structs = localStorage.getItem(domain)
    structs = (structs && JSON.parse(structs)) || {}
    structs[key] = data
    localStorage.setItem(domain, JSON.stringify(structs))
    obj.success && obj.success({ code: SUCCESS_CODE, message: "setStorage:ok" })
    obj.complete && obj.complete({ code: SUCCESS_CODE, message: "setStorage:ok" })
}

function getStorage(obj) {
    let res = null
    let data = null
    let { domain = DEFAULT_STORAGE_DOMAIN, key, callbackSuccess = false } = obj
    if (unique.isEmpty("key", key, obj)) {
        return
    }
    if (typeof key != "string") {
        res = {
            code: FAIL_CODE,
            message: new TypeError("key is not a string").toString(),
        }
        obj.fail && obj.fail(res)
    } else {
        let structs = localStorage.getItem(domain)
        structs = structs && JSON.parse(structs)
        data = structs && structs.hasOwnProperty(key) ? structs[key] : null
        if (typeof data === "boolean" || typeof data === "number" || !!data) {
            res = {
                code: SUCCESS_CODE,
                message: "getStorage:ok",
                data: data,
            }
            obj.success && obj.success(res)
        } else {
            res = {
                code: FAIL_CODE,
                message: new TypeError("data is null").toString(),
            }
            obj.fail && obj.fail(res)
        }
    }
    obj.complete && obj.complete(res)
    return data
}

function removeStorage(obj = {}) {
    let { domain = DEFAULT_STORAGE_DOMAIN, key } = obj
    let data = null
    if (unique.isEmpty("key", key, obj)) {
        return
    }
    if (typeof key != "string") {
        throw new TypeError("key is not a string")
    }
    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))
    obj.success && obj.success()
    obj.complete && obj.complete({ code: SUCCESS_CODE, message: "removeStorage:ok" })
}

function clearStorage(obj) {
    const domain = (obj && obj.domain) || DEFAULT_STORAGE_DOMAIN
    localStorage.removeItem(domain)
    obj.success && obj.success()
    obj.complete && obj.complete({ code: SUCCESS_CODE, message: "clearStorage:ok" })
}

function getOAuthCode(obj = {}) {
    let { url, tenantId } = obj
    if (unique.isEmpty("url", url, obj) || unique.isEmpty("tenantId", tenantId, obj)) {
        return
    }
    mtl.yht.getUCGAuthCode(obj)
}

function getLocation(obj = {}) {
    map.amapLocation(obj)
}

// 获取原生导航信息
function getNavBarInfo(obj = {}) {
    let data = { isNativeNavBar: true, height: 44 }
    obj.success && obj.success(data)
    obj.complete && obj.complete(data)
}

function convertToObject(res) {
    let dataObj = res
    if (typeof res === "string") {
        try {
            dataObj = JSON.parse(res)
        } catch (error) {
            dataObj = res
        }
    }
    return dataObj
}

function getUrlParams() {
    let res = {}
    let serach = window.location.search
    if (!serach || serach === "") {
        serach = window.location.href.split("?").pop()
    }
    let str = decodeURIComponent(serach)
    str = str.trim().replace(/^[?#&]/, "")

    if (!str) {
        return res
    }
    str.split("&").forEach((strItem) => {
        if (strItem) {
            let parts = strItem.split("=")
            let partKey = parts[0],
                partValue = parts[1] || ""
            res[partKey] = partValue
        }
    })
    return res
}

function getConfig(obj = {}) {
    const { envURL, resId, configUrl } = getUrlParams()
    if (!envURL) {
        obj.fail && obj.fail({ code: FAIL_CODE, message: "envURL is null" })
        return
    }
    const urlArray = envURL.split("rest")
    const url = configUrl || urlArray[0] + "/rest/v2/mobile/out/getConfigJson?id=" + resId
    let params = {
        url: url,
        method: "GET",
        withCredentials: true,
        responseType: "json",
        headers: {
            "content-type": "application/json",
        },
    }
    axios(params).then((response) => {
        let res = response.data && response.status && response.headers ? response.data : response
        let dataObj = convertToObject(res)
        obj.success && obj.success(dataObj)
    }).catch((err) => {
        obj.fail && obj.fail(err)
    })
}

/**
 * 打开新窗口, 默认使用H5方式.
 * @param {string} url
 * @param {boolean} external 是否跳转到飞书以外的应用
 * @param {boolean} newWindow 是否使用新窗口的方式打开
 */
function openSchema(object) {
    openNewWebview(object)
}

/**
 * 打开新窗口, 默认使用H5方式.
 * @param {string} url
 * @param {boolean} external 是否跳转到飞书以外的应用
 * @param {boolean} newWindow 是否使用新窗口的方式打开
 */
function openExclusiveApp(object = {}) {
    object.newWindow = true
    navigateTo(object)
}

/**
 * 当前页面打开 url , 默认使用H5方式.
 * @param {string} url
 * @param {boolean} external 是否跳转到飞书以外的应用
 * @param {boolean} newWindow 是否使用新窗口的方式打开
 */
function webviewLoadUrl(object = {}) {
    const { url } = object
    if (unique.isEmpty("url", url, object)) {
        const error = {
            code: FAIL_CODE,
            message: `webviewLoadUrl fail: url is empty.`,
        }
        object?.fail && object?.fail(error)
        return
    }

    if (object?.newWindow) {
        openNewWebview(object)
        return
    }

    window.location.href = url
    successCallBack(object)
}

/**
 * 打开新窗口, 默认使用H5方式.
 * @param {string} url
 * @param {boolean} external 是否跳转到飞书以外的应用
 * @param {boolean} newWindow 是否使用新窗口的方式打开
 */
function navigateTo(object) {
    if (object?.newWindow) {
        openNewWebview(object)
        return
    }
    window.location.href = object?.url
    object?.success && object?.success({ code: SUCCESS_CODE, message: "navigateTo: ok" })
}

function redirectTo({ url, parameters }) {
    location.replace(url)
}

function navigateBack() {
    history.back()
}

function reLaunch({ url }) {
    history.go(1 - history.length)
    history.replaceState({}, null, url)
}

function tt_ready(fn, obj) {
    window.h5sdk.ready(() => {
        // window.h5sdk.ready回调函数在环境准备就绪时触发
        fn(obj)
    })
}

/**
 * 拨打电话
 * @param {string} number
 * @returns
 */
function dail(object) {
    if (!object?.number) {
        object?.fail && object?.fail(resultStructure(FAIL_CODE, "number is null!"))
        return
    }
    tt.makePhoneCall({
        phoneNumber: object?.number,
        success(res) {
            console.log(JSON.stringify(res))
            object?.success && object?.success(resultStructure("200", "dail: ok"))
        },
        fail(res) {
            console.log(`makePhoneCall fail: ${JSON.stringify(res)}`)
            object?.fail && object?.fail(resultStructure(FAIL_CODE, "Call failed!"))
        },
    })
}

// 对外 api 对照关系
let exports = {
    generateQRCode,
    scanQRCode,
    saveImageToPhotoAlbum,
    chooseImage: h5.chooseImage,
    chooseImages: h5.chooseImages,
    previewImage,
    openNewWebview,
    closeCurrentWebview,
    getLocalImgData,
    scanInvoice,
    recognizeInvoice,
    scanIDCard,
    recognizeIDCard,
    scanBankCard,
    recognizeBankCard,
    request,
    setStorage,
    getStorage,
    removeStorage,
    clearStorage,
    getOAuthCode,
    webviewLoadUrl,
    getLocation,
    getNavBarInfo,
    getMac,
    getWifiInfo,
    getNetworkType,
    navigateTo,
    redirectTo,
    navigateBack,
    reLaunch,
    getUserInfo,
    getConfig,
    dail,
    getAuthCode: unique.getAuthCode,
    getAppCode: unique.getAppCode,
    canExecUpesnBridge: unique.canExecUpesnBridge,
    checkBridgeNameExist: unique.checkBridgeNameExist,
    getStorageSync: syncMethod.getStorageSync,
    getStorageParseSync: syncMethod.getStorageParseSync,
    getStorageStringifySync: syncMethod.getStorageStringifySync,
    settingNavBar: home.upesn.settingNavBar,
    voiceToText: home.upesn.voiceToText,
    getBlueToothState: home.upesn.getBlueToothState,
    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,
    getAuthorizationStatus: home.upesn.getAuthorizationStatus,
    uploadFile: home.upesn.uploadFile,
    uploadToFileService: home.upesn.uploadToFileService,
    openChatWindow: home.upesn.openChatWindow,
    chooseDocFiles: home.upesn.chooseDocFiles,
    chooseLocalFileToServer: home.upesn.chooseLocalFileToServer,
    sendTodoReceipt: home.upesn.sendTodoReceipt,
    getAppInfomation: home.upesn.getAppInfomation,
    backToHome: home.upesn.backToHome,
    chooseImageToServer: home.upesn.chooseImageToServer,
    getUserYHTInfo: home.upesn.getUserYHTInfo,
    setUserYHTInfo: home.upesn.setUserYHTInfo,
    getToken: home.upesn.getToken,
    gainUserInfo: home.upesn.gainUserInfo,
    wpsPreview: home.upesn.wpsPreview,
    previewDoc: home.upesn.previewDoc,
    previewFile: home.upesn.previewFile,
    getAppData: home.upesn.getAppData,
    chooseLocalFiles: unique.chooseLocalFiles,
    onNetworkStatusChange: unique.onNetworkStatusChange,
    openAppWithParams: unique.openAppWithParams,
    getAppletShareParams: unique.getAppletShareParams,
    getSystemInfo: unique.getSystemInfo,
    getClipboardData: unique.getClipboardData,
    setClipboardData: unique.setClipboardData,
    watchShake: unique.watchShake,
    vibrateOnce: unique.vibrateOnce,
    saveExclusiveDomain: unique.saveExclusiveDomain,
    saveExclusiveUserInfo: unique.saveExclusiveUserInfo,
    saveExclusiveYhtInfo: unique.saveExclusiveYhtInfo,
    getExclusiveCode: unique.getExclusiveCode,
    setExclusiveLanguage: unique.setExclusiveLanguage,
    addImageWaterMark: unique.addImageWaterMark,
    mtlContext: unique.mtlContext,
}

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

supportMethods.forEach((pop) => {
    if (!exports[pop]) {
        if (pop === "chooseLibraryFiles" || pop === "chooseContacts" || pop === "chooseDepartment") {
            exports[pop] = successCallBackArray
        } else {
            exports[pop] = successCallBack
        }
    }
})
export default exports