mtl-js-sdk/lib/platforms/yyzone/bridge/index.js

ynf-fw-mtl-api

import {invokeSuccess, invokeFail} from '../callback'
import {onlinePreloadMdf, offlinePreloadMdf, onlineName, offlineName} from '../keys'

export function registerCommonCallback(handleName, callback) {
    if (handleName && callback) {
        window.MTLWebViewJavascriptBridge.registerHandler(handleName, callback);
    }
}

export function registerCallback(handleName, callback) {
    if (handleName && callback) {
        window.MTLWebViewJavascriptBridge.registerHandler(handleName, function(res, responseCallback) {
            console.log(res);
            if (!!res && res !== "{}") {
                callback(JSON.parse(res).qrString, responseCallback);
            } else {
                callback(res, responseCallback);
            }
        });
    }
}

export function ready(callback) {
    if (window.api) {
        console.log('api already existed');
        typeof callback === 'function' && callback();
    } else if (!window.api && window.top !== window) {
        try {
            console.log('xxxxx window.top.api ready start');
            window.api = window.top.api		
            typeof callback === 'function' && callback();
        } catch (error) {
            console.log('window.top.api	catch')
        }	
    } else {
        console.log('api ready addEventListener start');
        document.addEventListener('apiready', function() { 
            console.log('-------- api ready!!!!! ---------');
            typeof callback === 'function' && callback();
        }, false);
    }
}

export function canExecUpesnBridge() {
    let { upesnVersion = 0, platform} = window.mtl
    if (platform == 'upesn' && upesnVersion > 0) {
        return true
    }
    return false;
}

export function execUpesnBridgeify(name, param = {}) {
    let { upesnVersion = 0, platform} = window.mtl
    if (platform == 'upesn' && upesnVersion > 0) {
        if (api[name]) {
            api[name](param);
            return true;
        }
        return false
    }
    return false;
}

export function execPluginBridge(param = {}) {
    let {method, requireName} = param;
    if (!method) {
        invokeFail(param, {message: 'lack of param'});
        return;
    }
    let m;
    if (requireName) {
        let obj = window.api.require(requireName);
        if (!obj) {
            invokeFail(param, {msg:'module ' + requireName + ' not added'});
            return;
        }
        m = obj[method];
    } else {
        if ((method === 'openWindow' || method === 'openNewWebview') && mtl && mtl[method]) {
            m = mtl[method]
        } else {
            m = window.api[method];
        }
    }
    if (method === 'mdfIsLoad') {
        mdfIsLoad()
    }
    if (!m) {
        invokeFail(param, {msg: 'method ' + method + ' not found'});
        return;
    }
    m(param, function(ret, err) {
        if (ret) {
            invokeSuccess(param, ret);
        } else {
            invokeFail(param, err);
        }
    });
}

export function execUpesnBridge(param) {
    let {method} = param;
    if (!method) {
        invokeFail(param, {message: 'lack of param'});
        return;
    }
    if (method === 'mdfIsLoad') {
        mdfIsLoad()
    }
    if (api.execUpesnBridge) {
        api.execUpesnBridge(param)
        return
    }
    execPluginBridge(param);
}

export function execPluginSyncBridge(param = {}) {
    let {method, requireName} = param;
    if (!method) {
        invokeFail(param, {message: 'lack of param'});
        return;
    }
    let m;
    if (requireName) {
        let obj = window.api.require(requireName);
        if (!obj) {
            invokeFail(param, {msg:'module ' + requireName + ' not added'});
            return;
        }
        m = obj[method];
    } else {
        param.sync = true;
        m = window.api[method];
    }
    if (!m) {
        invokeFail(param, {msg: 'method ' + method + ' not found'});
        return;
    }
    return m(param);
}

export function mdfIsLoad(param = {}) {
    console.log('-----------mdfIsLoad----------')
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('mdfIsLoad', param, false);
        return;
    }
    if (window.api.winName === onlineName || window.api.winName === offlineName) {
        if (window.location.href.includes('https')) {
            window.api.setGlobalData({
                key: onlinePreloadMdf,
                value: onlineName
            });
        } else {
            window.api.setGlobalData({
                key: offlinePreloadMdf,
                value: offlineName
            });  
        }
    }
}