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

ynf-fw-mtl-api

import {invokeCallback, invokeFail, invokeSuccess} from '../callback'
import {requestPermission} from '../permission'
import {getLanguage} from '../localization'
import {execUpesnBridgeify,canExecUpesnBridge, execUpesnBridge} from '../bridge/index'
import {saveExpandParams} from '../keys'
import {getExclusiveDomainInfo} from '../util'

export function getNetworkType(param) {
    invokeSuccess(param, {networkType:api.connectionType});
}

export function getSystemInfo(param) {
    let obj = param || {}
    if (canExecUpesnBridge()) {
        let data = {
            ...obj,
            success: function(res) {
                const { systemLanguage = navigator.language } = res
                invokeSuccess(obj, {...res, systemLanguage})
            }
        }
        execUpesnBridgeify('getSystemInfo', data);
        return;
    }

    api.getSystemInfo({
        success:function(res){
            let info = {
                brand:res.platform=='ios'?'Apple':res.brand,
                model:res.model,
                platform:res.platform=='ios'?'iOS':'Android',
                system:api.systemVersion,
                screenWidth:res.screenWidth * res.pixelRatio,
                screenHeight:res.screenHeight * res.pixelRatio,
                pixelRatio:res.pixelRatio,
                YZVersion:res.version,
                YZLanguage:getLanguage(),
                systemLanguage: res.systemLanguage || navigator.language,
                deviceId:api.deviceId
            };
            invokeSuccess(obj, info);
        },
        fail:function(err){
            invokeFail(obj, err);
        }
    });
}

export function getMac(param) {
    invokeSuccess(param, {macAddress:api.deviceId});
}

export function getWifiInfo(param = {}) {
    if (api.systemType == 'ios' && parseFloat(api.systemVersion) >= 14) {
        requestPermission({
            list:['location'],
            complete:function(){
                _getWifiInfo(param);
            }
        });
    } else {
        _getWifiInfo(param);
    }
}

function _getWifiInfo(param) {
    let obj = api.require('wifi');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridge({
                ...param,
                method:'getWifiInformation',
                success:function(res) {
                    invokeSuccess(param, {name:res.name, mac:res.macAddress});
                }
            });
            return;
        }
        invokeFail(param, {msg:'module wifi not added'});
        return;
    }
    obj.currentWifi(function(ret, err) {
        if (ret.status) {
            invokeSuccess(param, {name:ret.ssid, mac:ret.bssid});
        } else {
            invokeFail(param, err);
        }
    });
}

function mapPrivacy() {
    let obj = api.require('mtlMap');
    if (!obj) {
        return;
    }
    obj.updateLocationPrivacy && obj.updateLocationPrivacy();
    obj.updateSearchPrivacy && obj.updateSearchPrivacy();
    obj.updateMapViewPrivacy && obj.updateMapViewPrivacy();
}

export function getLocation(param={}) {
    let obj = api.require('mtlMap');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('getLocationInfo', param);
            return;
        }
        invokeFail(param, {msg:'module mtlMap not added'});
        return;
    }

    requestPermission({
        list:['location'],
        success:function(){
            mapPrivacy();
            obj.getLocation(param, function(ret, err) {
                if (ret && ret.status) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err || ret);
                }
            });      
        },
        fail:param.fail
    });  
}

export function mapLocationExtend(param={}) {
    let obj = api.require('mtlMap');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('mapLocationExtend', param);
            return;
        }
        invokeFail(param, {msg:'module mtlMap not added'});
        return;
    }
    requestPermission({
        list:['location'],
        success:function(){
            mapPrivacy();
            obj.mapLocationExtend(param, function(ret, err) {
                if (ret && ret.status) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err || ret);
                }
            });  
        },
        fail:param.fail
    });   
}

export function openLocation(param={}) {
    let obj = api.require('mtlMap');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('chooseLocation', param);
            return;
        }
        invokeFail(param, {msg:'module mtlMap not added'});
        return;
    }

    requestPermission({
        list:['location'],
        success:function(){
            mapPrivacy();
            obj.openLocation(param, function(ret, err) {
                if (ret && ret.status) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err || ret);
                }
            });  
        },
        fail:param.fail
    });   
}

export function markAndNavigationDestination(param={}) {
    let obj = api.require('mtlMap');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('markAndNavigationDestination', param);
            return;
        }
        invokeFail(param, {msg:'module mtlMap not added'});
        return;
    }

    requestPermission({
        list:['location'],
        success:function(){
            mapPrivacy();
            obj.markAndNavigationDestination(param, function(ret, err) {
                if (ret && ret.status) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err || ret);
                }
            }); 
        },
        fail:param.fail
    });      
}

export function openMapToNavi(param={}) {
    let obj = api.require('mtlMap');
    if (!obj) {
        invokeFail(param, {msg:'module mtlMap not added'});
        return;
    }
    let type = param.type;
    if (type == 1) {
        type = 'GAODE';
    } else if (type == 2) {
        type = 'BAIDU';
    } else if (type == 3) {
        type = 'TENCENT';
    }
    param.type = type;
    obj.openMapToNavi(param, function(ret, err) {
        if (ret && ret.status) {
            invokeSuccess(param, ret);
        } else {
            invokeFail(param, err || ret);
        }
    });    
}

export function continuousLocationStart(param={}) {
    let obj = api.require('mtlMap');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('startLocationUpdate', param);
            return;
        }
        invokeFail(param, {msg:'module mtlMap not added'});
        return;
    }

    requestPermission({
        list:['location'],
        success:function(){
            mapPrivacy();
            obj.continuousLocationStart(param, function(ret, err) {
                if (ret && ret.status) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err || ret);
                }
            });  
        },
        fail:param.fail
    });        
}

export function continuousLocationGet(param={}) {
    let obj = api.require('mtlMap');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('getLocationUpdateInfo', param);
            return;
        }
        invokeFail(param, {msg:'module mtlMap not added'});
        return;
    }

    requestPermission({
        list:['location'],
        success:function(){
            obj.continuousLocationGet(param, function(ret, err) {
                if (ret) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err);
                }
            });  
        },
        fail:param.fail
    });
}

export function continuousLocationStop(param={}) {
    let obj = api.require('mtlMap');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('stopLocationUpdate', param);
            return;
        }
        invokeFail(param, {msg:'module mtlMap not added'});
        return;
    }
    obj.continuousLocationStop();    
    invokeSuccess(param, {});
}

export function getAuthorizationStatus(param={}) {
    let type = param.type;
    if (typeof type == 'number') {
        let list = ['photos','camera','microphone','location','contacts'];
        let name = list[type];
        if (name) {
            let res = api.hasPermission({list:[name]});
            invokeSuccess(param, {authStatus:res[0].granted?1:0});
        } else {
            invokeFail(param, {});
        }
    } else {
        invokeFail(param, {});
    }
}

export function onNetworkStatusChange(param) {
    api.addEventListener({
        name:'online'
    }, function(ret){
        let isConnected = true;
        let networkType = ret.connectionType;
        invokeCallback(param, {isConnected, networkType});
    });
    api.addEventListener({
        name:'offline'
    }, function(ret){
        let isConnected = false;
        let networkType = api.connectionType;
        invokeCallback(param, {isConnected, networkType});
    });
}

export function watchShake(param) {
    api.addEventListener({
        name:'shake'
    }, function() {
        invokeCallback(param, {});
    });
}

export function screenShot(param={}) {
    let {type, resultType} = param;
    let p = {};
    if (type == 1) {
        p.region = 'window';
    }
    if (resultType == 0) {
        p.destinationType = 'base64';
    }
    api.screenCapture(p, function(ret){
        let base64Data = ret.base64Data;
        if (base64Data && base64Data.indexOf('data:image') == -1) {
            base64Data = 'data:image/png;base64,' + base64Data;
        }
        invokeSuccess(param, {picStr:base64Data, picPath:ret.savePath});
    });
}

export function onUserCaptureScreen(param) {
    api.addEventListener({
        name:'takescreenshot'
    }, function() {
        invokeCallback(param, {});
    });
}

export function dail(param) {
    requestPermission({
        list:['phone-call'],
        success:function(){
            api.call(param, function(ret, err) {
                invokeSuccess(param, ret, err);
            });
        },
        fail:param.fail
    });        
}

export function backIntercept(param) {
    if (canExecUpesnBridge()) {
        execUpesnBridge({...param, method:'backIntercept'});
        return;
    }
    const { isInterceptArrow = true, isInterceptSystemBack = true} = param || {}
    if (!isInterceptArrow) {
		api.addEventListener({
			name:'navbackbtn'
		}, function(){
			api.navigateBack();
		});
	}
    api.addEventListener({
        name:'keyback',
        extra:{
            slidBackIntercept: isInterceptSystemBack
        }
    }, function(ret){
        invokeCallback(param, ret);
    });
}

export function vibrateOnce(param) {
    let list = api.systemType == 'ios' ? [500] : [100, 500];
    api.notification({
        vibrate:list
    });
    invokeSuccess(param, {});
}

export function changeScreenOrientation(param={}) {
    if (canExecUpesnBridge()) {
        execUpesnBridge({...param, method: 'changeScreenOrientation'})
        return;
    }
    api.setScreenOrientation({
        orientation:param.orientation?'portrait_up':'auto_landscape'
    });
    invokeSuccess(param, {});
}

export function restoreScreenOrientation(param) {
    if (canExecUpesnBridge()) {
        execUpesnBridge({...param, method: 'restoreScreenOrientation'})
        return;
    }
    api.setScreenOrientation({
        orientation:'portrait_up'
    });
    invokeSuccess(param, {});
}

export function openSchema(param = {}) {
    let url = param.url;
    api.openApp({
        androidPkg: 'android.intent.action.VIEW',
        mimeType: 'text/html',
        uri: url,
        iosUrl: url
    });
    invokeSuccess(param, {});
}

export function openAppWithParams(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('openAppWithParams', param);
        return;
    }
    const { expandParams } = param
    getData(param, function(data){
        let params = data.ykj || {};
        params.app_type = params.appType;
        params.serviceIcon = data.serviceIcon;
        params.serviceName = data.serviceName;
        params.tenantId = data.tenantId;
        params.serviceId = data.serviceId;
        params.openAppExpandParams = expandParams;
        mtl.openExclusiveApp({
            ...params,
            success:function(openRes){
                invokeSuccess(param, openRes || {});
            },
            fail:function(openErr){
                invokeFail(param, openErr);
            },
        })
    })
}

export function getAppletShareParams(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('getAppletShareParams', param);
        return;
    }
    let data = api.getGlobalData({
        key: saveExpandParams
    });
    invokeSuccess(param, {expandParams: data || JSON.stringify({})})
}

export function setStatusBarStyle(param = {}) {
    let style;
    let fontColorMode = param.fontColorMode;
    if (typeof fontColorMode != 'undefined') {
        if (fontColorMode == 0 || fontColorMode == '0') {
            style = "dark";
        } else if (fontColorMode == 1 || fontColorMode == '1') {
            style = "light";
        }
    }
    if (style) {
        api.setStatusBarStyle({
            style: style
        });
    }
    invokeSuccess(param, {});
}

export function createShortcut(param = {}) {
    let obj = api.require('shortcutCreator');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('createShortcut', param);
            return;
        }
        invokeFail(param, {msg:'module shortcutCreator not added'});
        return;
    }
    obj.createShortcut && obj.createShortcut(param,function(res, err){
        if (res) {
            invokeSuccess(param, res);
        } else {
            invokeFail(param, err);
        }
    });
}

export function checkBridgeNameExist(param = {}) {
    let {bridgeName} = param;
    let isExist = mtl[bridgeName]?'1':'0';
    invokeSuccess(param, {isExist});
}

export function appearanceMode(param = {}) {
    let mode = api.getInterfaceStyle();
    invokeSuccess(param, {mode});
}

export function onAppearanceModeChange(param = {}) {
    api.addEventListener({
        name:'interfacestylechanged'
    }, function(ret) {
        invokeCallback(param, {mode:ret.style});
    });
    invokeSuccess(param, {});
}

export function setClipboardData(param = {}) {
    api.setClipboardData(param, function(ret, err){
        if (ret) {
            invokeSuccess(param, ret);
        } else {
            invokeFail(param, err);
        }
    })
}

export function getClipboardData(param = {}) {
    api.getClipboardData(param, function(ret, err){
        if (ret) {
            invokeSuccess(param, ret);
        } else {
            invokeFail(param, err);
        }
    })
}

export function jumpSystemSettings(param = {}) {
    api.openApp({
        uri:'app-settings:',
        iosUrl: 'app-settings:'
    })
    invokeSuccess(param, {});
}

function getUserKey({serviceCode, getUKSuccess, getUKFail}) {
    mtl.getUserYHTInfo({
        success:function(res){
            const { tenant_id='tenant', yht_userid='userid' } = res
            const key = `${tenant_id}-${yht_userid}-${serviceCode}`
            getUKSuccess && getUKSuccess(key)
        },
        fail:function(err){
            console.log('getUserYHTInfo error: ', err)
            getUKFail && getUKFail(err)
        }
    });
}

export function getAppData(param = {}) {
    if (canExecUpesnBridge()) {
        const { success } = param
        execUpesnBridgeify('getAppData', {...param, success:function(res){
            success && success({...res, packageType: res.packagetype})
        }});
        return;
    }
    const { serviceCode } = param
    getUserKey({
        serviceCode,
        getUKSuccess:function(res){
            let data = window.api?.getPrefs({
                sync: true,
                key: res
            });
            if (data) {
                invokeSuccess(param, JSON.parse(data))        
            }
        }
    });
    getData(param, function(data){
        let params = data.ykj || {}
        params.app_type = params.appType
        params.name = data.serviceName
        params.url = params.appUrl
        invokeSuccess(param, params)
        getUserKey({
            serviceCode,
            getUKSuccess:function(res){
                window.api?.setPrefs({
                    sync: false,
                    key: res,
                    value: JSON.stringify(params)
                });
            },
            getUKFail:function(err){
                console.log('getUserYHTInfo error: ', err)
            }
        });
    })
}

function getData(param, onSuccess) {
    const { serviceCode, url } = param
    let domainObj = getExclusiveDomainInfo() || {};
    let {data} = domainObj;
    let domain = null
    if (data && data.mobileAppUrl) {
        domain = data.mobileAppUrl;
    }
    const appUrl = mtl.getStorageSync({key: 'key_mobile_app_url'}) || domain || `${window.location.origin}/iuap-yonbuilder-mobile`
    let path = `${appUrl}/rest/v1/mobile/app/getServiceDetail`
    if (url) {
        path = url
    }
    mtl.request({
        url: path,
        params: { serviceCode },
        success:function(res){
            let resData = res.data
            if (resData && typeof(resData) === 'string') {
                resData = JSON.parse(resData)
            }
            if (resData && resData.success) {
                const data = resData.data || {}
                onSuccess && onSuccess(data)
            } else {
                invokeFail(param, resData);
            }
        },
        fail:function(err){
            invokeFail(param, err);
        },
    })
}