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

ynf-fw-mtl-api

/*
 * @Author: wangyingliang@yonyou.com
 * @Date: 2024-10-31 09:34:14
 * @LastEditors: wangyingliang wangyingliang@yonyou.com
 * @LastEditTime: 2025-09-02 20:40:49
 * @FilePath: /mtl-api-project/src/platforms/wx/methods.js
 * @Description: 微信 || 企微函数文件
 * Copyright (c) 2024 by Yonyou, All Rights Reserved.
 */
import xaxios from 'axios'
import QRious from 'qrious'
import home from './unique.js'
import map from '../h5/map/amapLocation.js'
import unique from '../../common/unique.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",
    "openSchema",
    "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",
    "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",
    "saveImageToPhotoAlbum",
    "h5PageClose",
    "configureWebView",
]

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)
}

function getLocalImgSrc(object) {
    const { localId } = object
    mtl.getLocalImgData({
        localId,
        complete: function (res) {
            let { code, message, data } = res
            if (code === SUCCESS_CODE) {
                message = "getLocalImgSrc:ok!"
                data = { imgSrc: data.localData }
                object.success && object.success(data)
            } else {
                object.fail && object.fail({ code, message })
            }
            object.complete && object.complete({ code, message, data })
        },
    })
}

function scanInvoice(object) {
    mtl.chooseImage({
        count: 1, // 默认9
        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("wxLocalResource://") || image.startsWith("weixin://")) {
            mtl.getLocalImgData({
                localId: image,
                success: resolve,
                fail: reject,
            })
        } else {
            resolve({ localData: image })
        }
    }).then((res) => {
        let imgBase64 = res.localData
        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)
    })
}

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 recognizeIDCard(object) {
    let { appCode, side, image, url = baseUrl } = object
    new Promise((resolve, reject) => {
        if (image.startsWith("wxLocalResource://") || image.startsWith("weixin://")) {
            mtl.getLocalImgData({
                localId: image,
                success: resolve,
                fail: reject,
            })
        } else {
            resolve({ localData: image })
        }
    })
        .then((res) => {
            let imgBase64 = res.localData
            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("wxLocalResource://") || image.startsWith("weixin://")) {
            mtl.getLocalImgData({
                localId: image,
                success: resolve,
                fail: reject,
            })
        } else {
            resolve({ localData: image })
        }
    })
        .then((res) => {
            let imgBase64 = res.localData
            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)
        })
}

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 getAppCode(obj) {
    let urlSuffix = window.location.search
    if (urlSuffix) {
        let query = window.location.search.substring(1)
        let vars = query.split("&")
        let result = vars.find((element) => {
            return element.indexOf("appCode") != -1
        })
        if (result) {
            let data = {
                code: 200,
                message: "",
                data: {
                    appCode: result.substring(result.lastIndexOf("=") + 1),
                },
            }
            obj.complete && obj.complete(data)
            obj.success && obj.success(data.data)
        } else {
            let data = {
                code: -1,
                message: "appCode acquisition failed",
            }
            obj.fail && obj.fail(data)
            obj.complete && obj.complete(data)
        }
    } else {
        throw "appCode is null"
    }
}

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

function getAuthCode(obj) {
    let urlSuffix = window.location.search
    if (urlSuffix) {
        let query = window.location.search.substring(1)
        let vars = query.split("&")
        let result = vars.find((element) => {
            return element.indexOf("authCode") != -1
        })
        if (result) {
            let data = {
                code: 200,
                message: "",
                data: {
                    authCode: result.substring(result.lastIndexOf("=") + 1),
                },
            }
            obj.complete && obj.complete(data)
            obj.success && obj.success(data.data)
        } else {
            let data = {
                code: -1,
                message: "authCode acquisition failed",
            }
            obj.fail && obj.fail(data)
            obj.complete && obj.complete(data)
        }
        return
    } else {
        throw "authCode is null"
    }
}

function getMac(obj) {
    if (obj) {
        const openId = localStorage.getItem("wxOpenId")
        if (unique.isEmpty("macAddress", openId, obj)) {
            return
        }
        obj.success && obj.success({ macAddress: openId })
        obj.complete && obj.complete({ code: SUCCESS_CODE, data: { macAddress: openId } })
    } else {
        console.log("obj is null in getMac API.")
    }
}

function weChatBindByPassword(obj) {
    let path = obj.url ? obj.url : baseUrl
    obj.url = `${path}/rest/v1/mobile/user/weChatBind`
    obj.method = "POST"
    const data = {
        username: obj.username,
        password: obj.password,
        appId: obj.appId,
        openId: obj.openId,
        validateCodeType: "username",
    }
    obj.params = data
    request(obj)
}

function weChatBindByValidateCode(obj) {
    let path = obj.url ? obj.url : baseUrl
    obj.url = `${path}/rest/v1/mobile/user/weChatBind`
    obj.method = "POST"
    const data = {
        username: obj.username,
        validateCode: obj.validateCode,
        appId: obj.appId,
        openId: obj.openId,
        validateCodeType: "mobile",
    }
    obj.params = data
    request(obj)
}

function weChatUnBind(obj) {
    let path = obj.url ? obj.url : baseUrl
    obj.url = `${path}/rest/v1/mobile/user/weChatUnbind`
    obj.method = "POST"
    const data = {
        yhtToken: obj.yhtToken,
    }
    obj.params = data
    request(obj)
}

function doShare(obj) {
    const urlEncode = encodeURIComponent(obj.link)
    const title = obj.title ? obj.title : ""
    const miniPageUrl = "/pages/"
    let url = `${miniPageUrl}home/home?title=${title}&url=${urlEncode}`
    if (obj.type == 9) {
        url = `${miniPageUrl}mtlShare/mtlShare?title=${title}&url=${urlEncode}`
    }
    mtl.navigateTo({
        url: url,
        success: function (res) {
            obj.success && obj.success(res)
        },
        fail: function (err) {
            obj.fail && obj.fail(err)
        },
    })
}

function openNewWebview(obj = {}) {
    let url = ""
    if (obj?.miniPageUrl) {
        // 包含 pages/ 走原生
        const miniPageUrl = obj?.miniPageUrl || "/pages/web" + "View/webView"
        const urlEncode = encodeURIComponent(obj?.url)
        url = `${miniPageUrl}?url=${urlEncode}`
    } else {
        url = obj?.url || ""
    }
    mtl.navigateTo({
        url: url,
        success: function (res) {
            obj.success && obj.success(res)
        },
        fail: function (err) {
            obj.fail && obj.fail(err)
        },
    })
}
function closeCurrentWebview(obj = {}) {
    mtl.navigateBack(obj)
}

function openExclusiveApp(obj = {}) {
    const { appUrl } = obj
    if (unique.isEmpty("appUrl", appUrl, obj)) {
        return
    }
    const urlEncode = encodeURIComponent(appUrl)
    const miniPageUrl = "/pages/"
    let url = `${miniPageUrl}webView/webView?url=${urlEncode}`
    mtl.navigateTo({
        url: url,
        success: function (res) {
            obj.success && obj.success(res)
        },
        fail: function (err) {
            obj.fail && obj.fail(err)
        },
    })
    successCallBack(obj)
}

function webviewLoadUrl(obj = {}) {
    const { url } = obj
    if (unique.isEmpty("url", url, obj)) {
        return
    }
    window.location.href = url
    successCallBack(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 getUserInfo(obj = {}) {
    mtl.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 getConfig(obj = {}) {
    const { envURL, resId } = getUrlParams()
    if (!envURL) {
        obj.fail && obj.fail({ code: FAIL_CODE, message: "envURL is null" })
        return
    }
    const urlArray = envURL.split("rest")
    const url = 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)
        })
}

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 markAndNavigationDestination(obj = {}) {
    const { address, subAddress } = obj
    mtl.openLocation({ ...obj, name: address, address: subAddress })
}

const backIntercept = (obj = {}) => {
    mtl.onHistoryBack(obj)
}

let exports = {
    upesn: home.upesn,
    generateQRCode,
    getLocalImgSrc,
    scanInvoice,
    recognizeInvoice,
    scanIDCard,
    recognizeIDCard,
    scanBankCard,
    recognizeBankCard,
    request,
    setStorage,
    getStorage,
    removeStorage,
    clearStorage,
    getAppCode,
    getAuthCode,
    getMac,
    getOAuthCode,
    weChatBindByPassword,
    weChatBindByValidateCode,
    weChatUnBind,
    doShare,
    openNewWebview,
    closeCurrentWebview,
    openExclusiveApp,
    webviewLoadUrl,
    getLocation,
    getNavBarInfo,
    getUserInfo,
    getConfig,
    markAndNavigationDestination,
    backIntercept,
    mdfCustomScanQRCode: home.upesn.mdfCustomScanQRCode,
    mdfChangeCustomScanMode: home.upesn.mdfChangeCustomScanMode,
    mdfChangeFlashLightStatus: home.upesn.mdfChangeFlashLightStatus,
    dail: home.upesn.dail,
    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,
    downloadFile: home.upesn.downloadFile,
    uploadFile: home.upesn.uploadFile,
    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,
    checkBridgeNameExist: unique.checkBridgeNameExist,
    canExecUpesnBridge: unique.canExecUpesnBridge,
}

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