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

ynf-fw-mtl-api

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

/**
 * 打开文件, 6.3.1版本统一openInOtherApp逻辑
 * @param {string} filePath 文件的本地地址（通过下载文件获取的本地路径）
 * @param {string} fileType 文件格式jpeg，txt，pdf等
 * @param {string} fileName 文件名
 * @param {string} openInOtherApp 是否调用其他应用打开 1 使用【该参数仅对iOS生效，android本身该功能就是用系统应用打开，无需解析】
 */
export function openLocalFile(param = {}) {
    let openInOtherApp = param?.openInOtherApp || '0'
    if (openInOtherApp === '1' || openInOtherApp === 1 || openInOtherApp === true) {
        const sharedModule = window.api?.require('shareAction');
        if (sharedModule) {
            sharedModule.shareFile({
                text: param?.fileName || "来自友空间分享的文件",
                path: param?.filePath,
                iPad: param?.iPad,
                success: param?.success,
                fail: param?.fail
            });
            return
        }
    }
    let obj = api.require('mtlOpenFile');
    if (!obj) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('openDocument', param);
            return;
        }
        invokeFail(param, {msg:'module mtlOpenFile not added'});
        return;
    }

    requestPermission({
        list:['storage-r'],
        success:function(){
            obj.openLocalFile(param, function(ret, err){
                if (ret && ret.status) {
                    invokeSuccess(param, ret);
                } else {
                    invokeFail(param, err || ret);
                }
            });
        },
        fail:param.fail
    });  
}

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

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

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

    let {success, fail} = param;
    param.success = function(res) {
        let localIds = [];
        res.localfiles.forEach(function(item){
            localIds.push(item.filePath);
        });
        uploadFile({
            type:'file',
            files:localIds,
            success:function(data) {
                invokeSuccess({success:success}, {files:data.files});
            },
            fail:function(err) {
                invokeFail({fail:fail}, err);
            }
        });
    };
    param.fail = function(err) {
        invokeFail({fail:fail}, err);
    }
    chooseLocalFiles(param);
}

export function moveFileToDisk(param = {}) {
    let filePath = param.filePath;
    let newDirName = 'box://mtlFileFolder';
    let newPath = '';
    let fileName = '';
    if (filePath) {
        let fileNameArr = filePath.split('/');
        if (fileNameArr && fileNameArr.length > 0) {
            fileName = fileNameArr[fileNameArr.length - 1];
        }
        newPath = newDirName + '/' + fileName;
    }
    let fs = api.require("fs");
    fs && fs.copyTo({
        oldPath: filePath,
        newPath: newDirName
    }, function(ret, err) {
        if (ret && ret.status) {
            invokeSuccess(param, {filePath: newPath});
        } else {
            invokeFail(param, err);
        }
    });
}

export function writeLog(param) {
    if (!param) return;
    let {data, tag='writeLog'} = param;
    if (data) {
        api.writeLog && api.writeLog({
            tag,
            data
        });
        invokeSuccess(param, {});
    } else {
        invokeFail(param, {message:'param error'});
    }
}

const mtlLogPath = 'fs://mtl-js/'
export function writeLocationLog(param = {}) {
    const dateTime = new Date();
    const date = dateTime.toLocaleDateString()
    const time = dateTime.toLocaleTimeString()
    const milliseconds = dateTime.getMilliseconds()
    const { parameterDic, fileName = 'log', showDate = true } = param
    const filePath = `${mtlLogPath}${fileName}.txt`
    api.writeFile({
        path: filePath,
        data: showDate ? `${date} ${time}:${milliseconds}  ${parameterDic}\n` : `${parameterDic}\n`,
        append: true
    }, function(ret, err) {
        if (ret) {
            invokeSuccess(param, ret);
            // 删除超过7M的文件内容
            var fs = api.require("fs");
            if (fs) {
                fs.getAttribute({path: filePath}, function(ret, err){
                    if (ret && ret.status) {
                        const size = ret.attribute && ret.attribute.size
                        const sizePoor = Number(size) - 1024 * 1024 * 2
                        if (sizePoor > 0) {
                            fs.writeByLength({
                                path: filePath, 
                                content: '\n',
                                place:{strategy: sizePoor}})
                        }
                    } else {
                        console.log('getAttribute error: ', err)
                    }
                })                
            }
        } else {
            invokeFail(param, err);
        }
    });
}

export function readLocationLog(param = {}) {
    const { fileName = 'log' } = param
    const filePath = `${mtlLogPath}${fileName}.txt`
    api.readFile({path: filePath}, function(ret, err){
        if (ret && ret.status) {
            invokeSuccess(param, ret)
        } else {
            invokeFail(param, err)
        }
    })
}

export function isFileExist(param = {}) {
    if (param?.filePath && param?.fileName) {
        invokeFail(param, { msg: 'filePath or fileName is empty!' });
        return;
    }

    var fs = api.require('fs');
    if (!fs) {
        if (canExecUpesnBridge()) {
            execUpesnBridgeify('isFileExist', param);
            return;
        }
        invokeFail(param, {msg:'module fs not added'});
        return;
    }

    let filePath = param?.filePath
    if (!filePath) {
        filePath = `cache://${param?.fileName}.${param?.fileType}`
    }
    fs.exist({
        path: filePath
    }, function(ret, err) {
        if (ret.exist) {
            invokeSuccess(param, {...ret, isExist: ret.exist});
        } else {
            invokeFail(param, err);
        }
    });
}

export function chooseFile(param = {}) {
    execUpesnBridge({method: 'chooseFile', ...param})
}

export function selectFiles(param = {}) {
    execUpesnBridge({method: 'selectFiles', ...param})
}

export function getLocalImgSrc(param = {}) {
    const { localId } = param
    if (localId != undefined || localId != null) {
      let data = {
        imgSrc: localId
      };
      invokeSuccess(param, data)
    } else {
      let err = {
        message: "not found src"
      };
      invokeFail(param, err);
    }
}

export function previewDoc(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('previewDoc', param);
        return;
    }
    const { downloadUrl, fileId } = param
    if (fileId) {
        loadFileSercice(param)
    } else if (downloadUrl) {
        mtl.navigateTo({canShowMIMEType: false, ...param, url: downloadUrl})
    } else {
        let err = {
            message: "fileId、downloadUrl is null"
        };
        invokeFail(param, err);
    }
}

export function previewFile(param = {}) {
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('previewFile', param);
        return;
    }
    const { fid } = param
    if (fid) {
        if (!(fid.startsWith('http'))) {
            loadFileSercice({...param, fileId: fid})
        } else {
            mtl.navigateTo({canShowMIMEType: false, ...param, url: fid})
        }
    } else {
        let err = {
            message: "fid is null"
        };
        invokeFail(param, err);
    }
}

export function wpsPreview(param = {}) {
    if (param?.isPremises) {
        mtl.navigateTo({canShowMIMEType: false, ...param, url: param?.fileUrl})
        return
    }

    if (canExecUpesnBridge()) {
        execUpesnBridgeify('wpsPreview', param);
        return;
    }
    const { fileUrl, fileId } = param
    if (fileId) {
        loadFileSercice(param)
    } else if (fileUrl) {
        mtl.navigateTo({canShowMIMEType: false, ...param, url: fileUrl})
    } else {
        let err = {
            message: "fileId、fileUrl is null"
        };
        invokeFail(param, err);
    }
}

function loadFileSercice(param = {}) {
    if (!window.YYCooperationBridge) {
        let domain = param?.domain || param?.url
        window.mtl && window.mtl.loadMtlCDNJs({
            url: domain || '/iuap-apcom-file/ucf-wh/fileservice/app/fileservice-app.min.js',
            type: 'all',
            success:function(res) {
                previewUrl(param)
            },
            fail: function(err){
                invokeFail(param, err);
            }
        })    
    } else {
        previewUrl(param)
    }
}

function previewUrl(param) {
    const { fileId, serviceCode, extraParams = {} } = param
    extraParams.authId = serviceCode
    window.YYCooperationBridge && window.YYCooperationBridge.ready(() => {
        window.YYCooperationBridge.YYGetPreviewUrlById({ ...param, fileId: fileId, extraParams }).then(res=>{
            if (typeof res === 'string') {
                window.mtl.navigateTo({
                    canShowMIMEType: false,  
                    url:res,
                    ...param
                });
            } else if (typeof res === 'object') {
                invokeFail(param, err);
            }
        }).catch(err=>{
            invokeFail(param, err);
        });
    });
}

/**
 * 保存文件流到手机本地
 * @param {object} param 
 */ 
export function saveFilesToLocal(param = {}) {
    // 透传给移动端
    if (canExecUpesnBridge()) {
        execUpesnBridgeify('saveFilesToLocal', param);
        return;
    }
    // 私有版无函数实现
    invokeFail(param, {
        code: "-10001",
        msg: "The current platform doesn't support this api"
    });
}

/**
 * 文件服务 - 预览, 6.2.13版本新增
 * @param {string} fileUrl 文件路径
 * @param {string} fileId 文件ID
 * @param {string} domain 域名.'https://bip-pre.yonyoucloud.com', 不带'/'
 */
export function previewFileService(param = {}) {
    const { fileUrl, fileId } = param

    // 如果 fileId 存在则优先处理
    if (fileId) {
        // 文件服务预览
        loadFileSercice(param)
        return
    } 
    
    // 如果只传了 fileUrl, 则直接跳转处理
    if (fileUrl) {
        mtl.navigateTo({
            canShowMIMEType: false, 
            url: fileUrl,
            ...param, 
        })
    } else {
        let err = {
            message: "fileId、fileUrl is null"
        };
        invokeFail(param, err);
    }
}