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

ynf-fw-mtl-api

import { invokeSuccess, invokeFail } from '../callback'
import { uploadFile } from '../util'
import { requestPermission } from '../permission';
import { localizedString } from '../localization'
import { execUpesnBridgeify, canExecUpesnBridge, execUpesnBridge } from '../bridge/index'
import { saveExclusiveYhtInfoKey } from '../keys'

function _chooseImage(param = {}) {
    let list = param.sourceType[0] == 'album' ? ['photos'] : ['camera', 'storage'];
    requestPermission({
        list: list,
        success: function () {
            let obj = api.require('mtlPhotoPicker');
            obj.chooseImage(param, function (ret, err) {
                if (ret && ret.localIds) {
                    let pictures = ret.localIds;
                    let localIds = [];
                    pictures.forEach(function (item) {
                        localIds.push(item.filePath);
                    });
                    invokeSuccess(param, { localIds, pictures });
                } else {
                    invokeFail(param, err);
                }
            });
        },
        fail: function (err) {
            invokeFail(param, {
                code: '-10007',
                message: "permission denied"
            });
        }
    });
}

export function chooseImage(param = {}) {
    let obj = api.require('mtlPhotoPicker');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridge({
                method: 'chooseImages',
                ...param,
                success: function (res) {
                    let localIds = [];
                    let pictures = res.pictures;
                    pictures.forEach(item => {
                        localIds.push(item.filePath);
                    });
                    let trans = api.require('trans');
                    if (trans && trans.batchTransPath) {
                        trans.batchTransPath({
                            paths: localIds
                        }, function (ret, err) {
                            if (ret && ret.status) {
                                let transPaths = ret.paths;
                                for (let i = 0; i < pictures.length; i++) {
                                    let item = pictures[i];
                                    item.filePath = transPaths[i];
                                    // 文件名
                                    let array = item.filePath.split('/');
                                    item.fileName = array[array.length - 1];
                                    // 缩略图路径处理
                                    if (item.thumbPath && api.systemType == 'ios') {
                                        let boxDir = api.boxDir;
                                        item.thumbPath = boxDir.substring(0, boxDir.indexOf('Documents')) + 'Documents' + item.thumbPath;
                                    }
                                }
                                invokeSuccess(param, { localIds: transPaths, pictures });
                            } else {
                                invokeSuccess(param, { localIds, pictures });
                            }
                        });
                    } else {
                        invokeSuccess(param, { localIds, pictures });
                    }
                }
            });
            return;
        }
        invokeFail(param, { msg: 'module mtlPhotoPicker not added' });
        return;
    }

    let sourceType = param.sourceType || ['album', 'camera'];
    if (sourceType.length == 1 && (sourceType[0] == 'album' || sourceType[0] == 'camera')) {
        _chooseImage(param);
    } else {
        api.actionSheet({
            cancelTitle: localizedString('cancel'),
            buttons: [localizedString('album'), localizedString('camera')]
        }, function (ret, err) {
            if (ret) {
                if (ret.buttonIndex == 3) {
                    // invokeFail(param, {message:'canceled'});
                } else {
                    param.sourceType = ret.buttonIndex == 1 ? ['album'] : ['camera'];
                    _chooseImage(param);
                }
            } else {
                invokeFail(param, err);
            }
        });
    }
}

export function chooseImageToServer(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('chooseImageToServer', param);
        return;
    }

    let { success, fail } = param;
    param.success = function (res) {
        uploadFile({
            type: 'image',
            files: res.localIds,
            success: function (data) {
                invokeSuccess({ success: success }, { pictures: data.files });
            },
            fail: function (err) {
                invokeFail({ fail: fail }, err);
            }
        });
    };
    param.fail = function (err) {
        invokeFail({ fail: fail }, err);
    }
    chooseImage(param);
}

/**
 * 调用系统相机或相册, 6.2.14版本增加.
 * @param {array} sourceType 采集源（可选项）. camera 相机, album 相册, ['album', 'camera'](默认)
 * @param {int} shootMode 拍摄模式（可选项）. 0:拍照片+拍视频(默认); - 1:拍照片; - 2:拍视频
 * @param {boolean} mirror 是否关闭自拍镜像，前置摄像头拍照时生效（可选项）. (默认 false)
 * @param {int} count 最多可以选择的图片张数，仅从相册选择时有效，相机拍照只会返回一张（可选项）. (默认 9)
 * @param {int} recordSecond 拍摄视频时的视频时长（可选项）. (默认15s)
 * @param {boolean} isEditImage 拍照完成后是否显示画笔按钮，仅拍照模式下支持（可选项）. (默认 true)
 * @param {boolean} isSaveToAlbum 拍照完成后是否保存到本地相册，仅拍照模式下支持（可选项）. (默认 false)
 * @param {boolean} isSaveOriginal 拍照完成后保存相册照片是否带水印，仅拍照模式下支持（可选项）. (默认 false)
 * @param {boolean} returnThumbnail 是否需要返回缩略图，watermark生效时，此参数无效，只返回带水印的路径（可选项）. (默认 false)
 * @param {object} watermark 图片水印字符串，不传则不显示水印,仅图片支持水印设置
 */
export function chooseImages(params) {
    let sourceType = params?.sourceType
    let list = sourceType[0] == 'album' ? ['photos', 'storage'] : ['camera', 'storage'];
    // 申请权限
    requestPermission({
        list: list,
        success: function () {
            let obj = api.require('mediaCollector');
            if (!obj) {
                invokeFail(params, { msg: 'module mediaCollector not added' });
                return
            }

            if (!obj.chooseImage) {
                invokeFail(params, { msg: "Please update the 'mediaCollector' plugin!" });
                return
            }

            let p = {
                ...params
            }

            delete p.success;
            delete p.fail;
            delete p.complete;

            obj.chooseImage({
                sourceType: sourceType,
                ...p
            }, function (ret, err) {
                if (ret) {
                    invokeSuccess(params, ret);
                } else {
                    invokeFail(params, err);
                }
            });
        },
        fail: function (err) {
            invokeFail(params, {
                code: '-10007',
                message: "permission denied"
            });
        }
    });
}

export function previewImage(param = {}) {
    let yht_access_token;
    let yhtInfoStr = api.getPrefs({
        sync: true,
        key: saveExclusiveYhtInfoKey
    });
    if (yhtInfoStr) {
        let yhtInfo = JSON.parse(yhtInfoStr);
        if (yhtInfo) {
            yht_access_token = yhtInfo.yht_access_token;
        }
    }
    if (!param.yht_access_token) {
        param.yht_access_token = yht_access_token
    }
    let obj = api.require('mtlPhotoPicker');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('previewImage', param);
            return;
        }
        invokeFail(param, { msg: 'module mtlPhotoPicker not added' });
        return;
    }
    obj.previewImage(param, function (ret, err) {
        if (ret && ret.status) {
            invokeSuccess(param, ret);
        } else {
            invokeFail(param, err || ret);
        }
    });
}

export function saveImageToPhotoAlbum(param = {}) {
    requestPermission({
        list: ['photos-w'],
        success: function () {
            let base64Str = param.base64Str;
            if (base64Str) {
                var trans = api.require('trans');
                if (!trans) {
                    invokeFail(param, { msg: "module trans not added" });
                    return;
                }
                base64Str = base64Str.replace(/data:image\/\S+;base64,/g, '');
                trans.saveImage({
                    base64Str,
                    album: true,
                    imgName: param.imgName
                }, function (ret, err) {
                    if (ret && ret.status) {
                        invokeSuccess(param, ret);
                    } else {
                        invokeFail(param, err);
                    }
                });
                return;
            }
            api.saveMediaToAlbum({
                path: param.url
            }, function (ret, err) {
                if (ret && ret.status) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err);
                }
            });
        },
        fail: param.fail
    });
}

export function getLocalImgData(param = {}) {
    let path = param.localId;
    if (path) {
        if (canExecUpesnBridge()) {
            const { localId = '', type = 1, level = 2 } = param
            execUpesnBridgeify('compressLocalImage', {
                ...param, imgData: localId, type, level, success: function (res) {
                    let base64str = res.base64str;
                    if (!base64str.startsWith("data:image/")) {
                        let imgType = ''
                        if (localId.lastIndexOf(".") == -1) {
                            imgType = 'jpeg'
                        } else {
                            imgType = localId.substring(localId.lastIndexOf(".") + 1, localId.length);
                        }
                        base64str = "data:image/" + imgType + ";base64," + base64str;
                    }
                    invokeSuccess(param, { localData: base64str });
                }
            });
            return;
        }
        let obj = api.require('trans')
        if (obj) {
            obj.decodeImgToBase64({
                imgPath: path
            }, function (ret, err) {
                if (ret && ret.status) {
                    invokeSuccess(param, { localData: 'data:image/png;base64,' + ret.base64Str });
                } else {
                    invokeFail(param, err);
                }
            });
        } else {
            invokeFail(param, { msg: 'module trans not added' });
        }
    } else {
        invokeFail(param, { message: 'file does not exist' });
    }
}

export function saveImageToLocal(param = {}) {
    requestPermission({
        list: ['storage'],
        success: function () {
            api.download({
                url: param.url,
                allowResume: true
            }, function (ret, err) {
                if (ret) {
                    if (ret.state == 1) {
                        mtl.setStorage({ key: param.url, data: ret.savePath });
                        invokeSuccess(param, {});
                    } else if (ret.state == 2) {
                        invokeFail(param, err);
                    }
                } else {
                    invokeFail(param, err);
                }
            });
        },
        fail: param.fail
    });
}

export function loadImageFromLocal(param = {}) {
    requestPermission({
        list: ['storage'],
        success: function () {
            let path = mtl.getStorageSync({ key: param.url });
            if (path) {
                api.require('trans').decodeImgToBase64({
                    imgPath: path
                }, function (ret, err) {
                    if (ret && ret.status) {
                        invokeSuccess(param, { imageData: 'data:image/png;base64,' + ret.base64Str });
                    } else {
                        invokeFail(param, err);
                    }
                });
            } else {
                invokeFail(param, { message: 'file does not exist' });
            }
        },
        fail: param.fail
    });
}

export function saveBase64Image(param = {}) {
    let { name, base64str } = param;
    if (name && base64str) {
        var trans = api.require('trans');
        if (!trans) {
            if (canExecUpesnBridge()) {
                execUpesnBridgeify('saveBase64Image', param);
                return;
            }
            invokeFail(param, {
                msg: "module trans not added"
            });
            return;
        }

        trans.saveBase64Image({
            name,
            base64str
        }, function (ret, err) {
            if (ret.status) {
                invokeSuccess(param, ret);
            } else {
                invokeFail(param, err);
            }
        });
    } else {
        invokeFail(param, { message: 'param error' });
    }
}

export function getBase64Image(param = {}) {
    let { name } = param;
    if (name) {
        var trans = api.require('trans');
        if (!trans) {
            if (canExecUpesnBridge()) {
                execUpesnBridgeify('getBase64Image', param);
                return;
            }
            invokeFail(param, {
                msg: "module trans not added"
            });
            return;
        }

        trans.getBase64Image({
            name
        }, function (ret, err) {
            if (ret.status) {
                invokeSuccess(param, ret);
            } else {
                invokeFail(param, err);
            }
        });
    } else {
        invokeFail(param, { message: 'param error' });
    }
}

export function deleteBase64Image(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('deleteBase64Image', param);
        return;
    }
    let { name } = param;
    if (name) {
        var trans = api.require('trans');
        if (!trans) {
            if (canExecUpesnBridge()) {
                execUpesnBridgeify('deleteBase64Image', param);
                return;
            }
            invokeFail(param, {
                msg: "module trans not added"
            });
            return;
        }

        trans.deleteBase64Image({
            name
        }, function (ret, err) {
            if (ret.status) {
                invokeSuccess(param, ret);
            } else {
                invokeFail(param, err);
            }
        });
    } else {
        invokeFail(param, { message: 'param error' });
    }
}

export function compressLocalImage(param = {}) {
    var imageTools = api.require('imageTools');
    if (!imageTools) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('compressLocalImage', param);
            return;
        }
        invokeFail(param, { msg: 'module imageTools not added' });
        return;
    }
    let { imgData } = param;
    if (!imgData) {
        invokeFail(param, { message: 'imgData error' });
        return
    }
    imageTools.compressLocalImage(param, function (ret, err) {
        if (ret) {
            invokeSuccess(param, ret);
        } else {
            invokeFail(param, err);
        }
    });
}

export function addImageWaterMark(param = {}) {
    var imageHandle = api.require('imageHandle');
    if (!imageHandle) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('addImageWaterMark', param);
            return;
        }
        invokeFail(param, { msg: 'module imageHandle not added' });
        return;
    }
    let { image, watermark = {} } = param;
    if (image && watermark) {
        imageHandle.addImageWaterMark({
            image,
            watermark
        }, function (ret, err) {
            if (ret) {
                invokeSuccess(param, ret);
            } else {
                invokeFail(param, err);
            }
        });
    } else {
        invokeFail(param, { message: 'param error' });
    }
}

export function continuousShootingLocal(param = {}) {
    var seriesCamera = api.require('seriesCamera');
    if (!seriesCamera) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('continuousShootingLocal', {
                ...param,
                success: (res) => {
                    let pictures = res.pictures;
                    pictures.forEach(item => {
                        if (item.fileFullPath) {
                            item.filePath = item.fileFullPath;
                        }
                    });
                    invokeSuccess(param, { ...res, pictures });
                }
            });
            return;
        }
        invokeFail(param, { msg: 'module seriesCamera not added' });
        return;
    }
    const { quality, count = 9 } = param
    requestPermission({
        list: ['camera', 'photos', 'storage'],
        success: function () {
            seriesCamera.open({
                max: count,
                quality
            }, function (ret, err) {
                console.log('continuousShootingLocal--', ret)
                if (ret) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err);
                }
            });
        },
        fail: param.fail
    });
}

function _chooseVideo(param = {}) {
    let list = param.sourceType[0] == 'album' ? ['photos'] : ['camera', 'microphone', 'storage'];
    requestPermission({
        list: list,
        success: function () {
            let obj = api.require('mtlPhotoPicker');
            obj.chooseVideo(param, function (ret, err) {
                if (ret) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err);
                }
            });
        },
        fail: param.fail
    });
}

export function getVideoThumbnail(param = {}) {
    var videoScreenshots = api.require('videoScreenshots');
    if (!videoScreenshots) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('getVideoThumbnail', param);
            return;
        }
        invokeFail(param, { msg: 'module videoScreenshots not added' });
        return;
    }
    let { videoPath, thumbnailQuality } = param;
    videoScreenshots.screenshots({
        videoUrl: videoPath,
        thumbnailQuality,
    }, function (ret, err) {
        if (ret) {
            invokeSuccess(param, ret);
        } else {
            invokeFail(param, err);
        }
    });
}

export function chooseVideo(param = {}) {
    let obj = api.require('mtlPhotoPicker');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('chooseVideo', {
                ...param,
                success: function (res) {
                    invokeSuccess(param, { ...res, filePath: res.tempFilePath });
                }
            });
            return;
        }
        invokeFail(param, { msg: 'module mtlPhotoPicker not added' });
        return;
    }

    let sourceType = param.sourceType || ['album', 'camera'];
    if (sourceType.length == 1 && (sourceType[0] == 'album' || sourceType[0] == 'camera')) {
        _chooseVideo(param);
    } else {
        api.actionSheet({
            cancelTitle: localizedString('cancel'),
            buttons: [localizedString('album'), localizedString('camera')]
        }, function (ret, err) {
            if (ret) {
                if (ret.buttonIndex == 3) {
                    // invokeFail(param, {message:'canceled'});
                } else {
                    param.sourceType = ret.buttonIndex == 1 ? ['album'] : ['camera'];
                    _chooseVideo(param);
                }
            } else {
                invokeFail(param, err);
            }
        });
    }
}

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

    let { success, fail } = param;
    param.success = function (res) {
        uploadFile({
            type: 'video',
            files: [res.filePath],
            success: function (data) {
                invokeSuccess({ success: success }, data.files[0]);
            },
            fail: function (err) {
                invokeFail({ fail: fail }, err);
            }
        });
    };
    param.fail = function (err) {
        invokeFail({ fail: fail }, err);
    }
    chooseVideo(param);
}

let recordTimer = null;
let onVoiceRecordEndCallback = null;
export function startRecord(param = {}) {
    let obj = api.require('FNRecordMp3');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('startRecordMp3', {
                ...param,
                callback: onVoiceRecordEndCallback && onVoiceRecordEndCallback.success
            });
            return;
        }
        invokeFail(param, { msg: 'module FNRecordMp3 not added' });
        return;
    }

    requestPermission({
        list: ['microphone', 'storage'],
        success: function () {
            if (recordTimer != null) {
                clearTimeout(recordTimer);
                recordTimer = null;
            }
            recordTimer = setTimeout(() => {
                recordTimer = null;
                if (onVoiceRecordEndCallback) {
                    mtl.stopRecord(onVoiceRecordEndCallback);
                }
            }, 60000);

            obj.open({
                path: 'cache://record',
                fileDir: 'cache://record/'
            }, function (ret, err) {
                if (ret && ret.status) {
                    obj.start(function (ret1, err1) {
                        if (ret1 && ret1.status) {
                            invokeSuccess(param, ret);
                        } else {
                            if (recordTimer != null) {
                                clearTimeout(recordTimer);
                                recordTimer = null;
                            }
                            invokeFail(param, err1);
                        }
                    });
                } else {
                    if (recordTimer != null) {
                        clearTimeout(recordTimer);
                        recordTimer = null;
                    }
                    invokeFail(param, err);
                }
            });
        },
        fail: param.fail
    });
}

export function stopRecord(param = {}) {
    let obj = api.require('FNRecordMp3');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('stopRecordMp3', {
                ...param,
                success: function (res) {
                    invokeSuccess(param, { localId: res.bytes });
                }
            });
            return;
        }
        invokeFail(param, { msg: 'module FNRecordMp3 not added' });
        return;
    }

    if (recordTimer != null) {
        clearTimeout(recordTimer);
        recordTimer = null;
    }

    obj.stop(function (ret, err) {
        if (ret && ret.status) {
            obj.getMp3Path({
                channel: 2
            }, function (ret1, err1) {
                if (ret1 && ret1.status) {
                    api.require('trans').decodeFileToBase64({
                        filePath: ret1.path
                    }, function (ret2, err2) {
                        if (ret2 && ret2.status) {
                            invokeSuccess(param, { localId: ret2.base64Str });
                        } else {
                            invokeFail(param, err2);
                        }
                    });
                } else {
                    invokeFail(param, err1);
                }
            });
        } else {
            invokeFail(param, err);
        }
    });
}

export function onVoiceRecordEnd(param = {}) {
    onVoiceRecordEndCallback = param;
}

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

    requestPermission({
        list: ['microphone', 'storage'],
        success: function () {
            obj.recordAudio(param, function (ret, err) {
                if (ret) {
                    api.require('trans').decodeFileToBase64({
                        filePath: ret.bytes
                    }, function (ret2, err2) {
                        if (ret2 && ret2.status) {
                            invokeSuccess(param, { bytes: ret2.base64Str });
                        } else {
                            invokeFail(param, err2);
                        }
                    });
                } else {
                    invokeFail(param, err);
                }
            });
        },
        fail: param.fail
    });
}

let onVoicePlayEndCallback = null;
export function playVoice(param = {}) {
    const { url } = param
    if (url) {
        api.startPlay({
            path: url
        }, function (ret1, err1) {
            if (ret1) {
                if (onVoicePlayEndCallback) {
                    invokeSuccess(onVoicePlayEndCallback, { url });
                } else {
                    invokeSuccess(param, { url });
                }
            } else {
                invokeFail(param, err1);
            }
        });
        return
    }
    requestPermission({
        list: ['storage'],
        success: function () {
            let localId = param.localId;
            api.require('trans').saveFile({
                base64Str: localId,
                filePath: 'cache://',
                fileName: 'tmp.mp3'
            }, function (ret, err) {
                if (ret && ret.status) {
                    let filePath = 'cache://tmp.mp3';
                    api.startPlay({
                        path: filePath
                    }, function (ret1, err1) {
                        if (ret1) {
                            if (onVoicePlayEndCallback) {
                                invokeSuccess(onVoicePlayEndCallback, { localId });
                            } else {
                                invokeSuccess(param, { localId });
                            }
                            let fs = api.require('fs');
                            fs && fs.removeSync({ path: filePath });
                        } else {
                            invokeFail(param, err1);
                        }
                    });
                } else {
                    invokeFail(param, err);
                }
            });
        },
        fail: param.fail
    });
}

export function pauseVoice(param = {}) {
    api.pausePlay();
    invokeSuccess(param, {});
}

export function stopVoice(param = {}) {
    api.stopPlay();
    invokeSuccess(param, {});
}

export function onVoicePlayEnd(param = {}) {
    onVoicePlayEndCallback = param;
}

/**
 * 结束人脸验证
 * @param {Object} params 参数集合
 * @returns 无
 */
export function endLoginFaceFactorVerify(params = {}) {
    if (window.mtl.platform === 'upesn' && canExecUpesnBridge()) {
        execUpesnBridge('endLoginFaceFactorVerify', {
            ...params,
            success: function (res) {
                invokeSuccess(params);
            }
        })
        return
    }

    // 私有版中, 只发送事件并关闭窗口, 由私有版接收事件.
    window.api?.sendEvent({
        name: "endLoginFaceFactorVerify",
        extra: {
            ...params
        }
    })
    window.mtl?.closeCurrentWebview()
}