@ccos/ccsdk-lite 1.0.0

package/dist/bundle.js

@@ -0,0 +1,1006 @@
+/**
+ * 简易实现的事件触发器
+ * 仅框架内部使用
+ * 未传入name时默认会有自增id作为name
+ * 主要为 定时器 bridge 等服务
+ */
+class Bus {
+    constructor() {
+        this._busId = 0;
+        this._pool = {};
+    }
+    register(callback, name) {
+        let busName = name ? name.toString() : (++this._busId).toString();
+        if (!this._pool[busName])
+            this._pool[busName] = [];
+        this._pool[busName].push(callback);
+        return busName;
+    }
+    fire(name, ...args) {
+        if (!name)
+            return;
+        const callbacks = this._pool[name];
+        if (!callbacks || !callbacks.length)
+            return;
+        return callbacks.map((callback) => callback(...args));
+    }
+    has(name, callback) {
+        if (!name || !this._pool[name])
+            return false;
+        if (!callback)
+            return true;
+        const callbacks = this._pool[name];
+        const index = callbacks.indexOf(callback);
+        return index > -1;
+    }
+    remove(name, callback) {
+        if (!name || !this._pool[name])
+            return;
+        if (!callback) {
+            delete this._pool[name];
+            return;
+        }
+        const callbacks = this._pool[name];
+        const index = callbacks.indexOf(callback);
+        if (index > -1)
+            callbacks.splice(index, 1);
+    }
+    clear() {
+        this._busId = 0;
+        this._pool = {};
+    }
+}
+const bus = new Bus();
+
+let actionList = []; // 这里保存, 未注册命令处理函数之前，APP发过来的命令
+function defaultAppCmd(cmd, payload) {
+    console.log('default appCmd ' + cmd);
+    actionList.push({ cmd, payload }); // 有可能APP发过来的命令比较早，而页面的一些初始化还没有做完，这时把命令先存起来，放到 actionList 中
+}
+let appCmdProcessor = defaultAppCmd; // APP 发过来的命令，JS的执行函数
+function onCommandFromApp(cmd, payload) {
+    appCmdProcessor(cmd, payload);
+}
+function setAppCommandCallback(cb) {
+    appCmdProcessor = cb;
+    //
+    const workList = actionList;
+    actionList = [];
+    // 如果 actionList 中有初始化之前来的命令，则执行这些命令
+    for (const action of workList) {
+        console.log('ahead cmd = ' + action.cmd);
+        cb(action.cmd, action.payload);
+    }
+}
+function unsetAppCommandCallback() {
+    appCmdProcessor = defaultAppCmd;
+    actionList = [];
+}
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+let persistentCallbackId = []; // 持久化 callback-id 列表
+function nativeCall(funcName, callbackId, params) {
+    if (window['_CooPark']) {
+        var object1 = {
+            func: funcName,
+            id: callbackId,
+            params: params || {}
+        };
+        window['_CooPark'].exec(JSON.stringify(object1));
+    }
+}
+function nativeRequest(funcName, params, persistent, persistentIdName, persistentCallback) {
+    if (!persistent) {
+        return new Promise((resolve) => {
+            let callbackId = bus.register((res) => {
+                resolve(res);
+            });
+            nativeCall(funcName, callbackId, params);
+        });
+    }
+    // 以下是持久化调用处理
+    let index = persistentCallbackId.indexOf(persistentIdName);
+    if (index < 0) {
+        persistentCallbackId.push(persistentIdName);
+    }
+    bus.remove(persistentIdName);
+    bus.register(persistentCallback, persistentIdName); // 这里注册一个持久化的回调，通常应用于 native 会持续回调的情况
+    return new Promise((resolve) => {
+        let callbackId = bus.register((res) => {
+            resolve(res);
+        });
+        nativeCall(funcName, callbackId, params);
+    });
+}
+//
+function callNative(funcName, params) {
+    return nativeRequest(funcName, params, false);
+}
+// 带有持久性回调的调用
+function callWithPersistentCallBack(funcName, params, persistentIdName, callback) {
+    return nativeRequest(funcName, params, true, persistentIdName, callback);
+}
+// 注销一个持久的回调函数
+function deletePersistentCallBack(persistentIdName) {
+    bus.remove(persistentIdName);
+    let index = persistentCallbackId.indexOf(persistentIdName);
+    if (index < 0) {
+        return;
+    }
+    persistentCallbackId.splice(index, 1); // 从persistentCallbackId中删除name
+}
+function callbackFromNative(callbackId, data) {
+    let payload = '';
+    if (typeof data == 'string') {
+        try {
+            payload = JSON.parse(data);
+        }
+        catch (e) {
+            payload = data;
+        }
+    }
+    else {
+        payload = data;
+    }
+    bus.fire(callbackId, payload);
+    // 判断，如果不是持久的回调函数，则调用完毕之后删除该回调
+    let index = persistentCallbackId.indexOf(callbackId);
+    if (index < 0) {
+        bus.remove(callbackId);
+    }
+}
+
+const moduleName$6 = 'network';
+function getFuncName$6(name) {
+    return moduleName$6 + '_' + name;
+}
+function paramToUrl(params) {
+    if (!params)
+        return '';
+    if (typeof params == 'object') {
+        let strArr = [];
+        let counter = 0;
+        let keys = Object.keys(params);
+        keys.sort();
+        for (const key of keys) {
+            const value = params[key];
+            if (counter != 0) {
+                strArr.push('&');
+            }
+            strArr.push(encodeURIComponent(key));
+            strArr.push('=');
+            if (typeof value == 'object') {
+                strArr.push(encodeURIComponent(JSON.stringify(value)));
+            }
+            else {
+                strArr.push(encodeURIComponent(value.toString()));
+            }
+            counter++;
+        }
+        return strArr.join('');
+    }
+    return params.toString();
+}
+// 简单的 HTTP 请求
+function simpleHttpRequest(params) {
+    return callNative(getFuncName$6('simpleHttpRequest'), params);
+}
+function httpGet(url, urlParam, header, base64) {
+    const paramString = paramToUrl(urlParam);
+    let newUrl;
+    if (paramString) {
+        if (url.indexOf('?') >= 0) {
+            newUrl = url + '&' + paramString;
+        }
+        else {
+            newUrl = url + '?' + paramString;
+        }
+    }
+    else {
+        newUrl = url;
+    }
+    //
+    let obj = {
+        url: newUrl,
+        method: 'GET'
+    };
+    if (header) {
+        obj.header = JSON.stringify(header);
+    }
+    if (base64) {
+        obj.base64Flag = true;
+    }
+    return simpleHttpRequest(obj);
+}
+function httpPost(url, body, header, postJson, base64, postType) {
+    let obj = {
+        url: url,
+        method: 'POST'
+    };
+    // POST 的内容
+    if (body) {
+        if (typeof body == 'object') {
+            if (postJson) {
+                obj.body = JSON.stringify(body);
+            }
+            else {
+                obj.body = paramToUrl(body);
+            }
+        }
+        else {
+            obj.body = body.toString();
+        }
+    }
+    //
+    if (header) {
+        obj.header = JSON.stringify(header);
+    }
+    //
+    if (base64) {
+        obj.base64Flag = true;
+    }
+    //
+    if (postJson) {
+        obj.postType = 'application/json';
+    }
+    else {
+        if (postType) {
+            obj.postType = postType;
+        }
+        else {
+            obj.postType = 'application/x-www-form-urlencoded';
+        }
+    }
+    return simpleHttpRequest(obj);
+}
+function httpSseGet(url, urlParam, header, base64) {
+    const paramString = paramToUrl(urlParam);
+    let newUrl;
+    if (paramString) {
+        if (url.indexOf('?') >= 0) {
+            newUrl = url + '&' + paramString;
+        }
+        else {
+            newUrl = url + '?' + paramString;
+        }
+    }
+    else {
+        newUrl = url;
+    }
+    //
+    let obj = {
+        url: newUrl,
+        method: 'GET'
+    };
+    if (header) {
+        obj.header = JSON.stringify(header);
+    }
+    if (base64) {
+        obj.base64Flag = true;
+    }
+    return readSse(obj);
+}
+// 获取网络的基本信息
+function getNetworkInfo() {
+    return callNative(getFuncName$6('getNetworkInfo'), null);
+}
+// 获取合规化后的域名
+function getDomainName(domain) {
+    return callNative(getFuncName$6('getDomainName'), { domain });
+}
+// 获取基本 Header 信息
+function getCommonHeader() {
+    return callNative(getFuncName$6('getCommonHeader'), null);
+}
+// 读取SSE流
+function readSse(params) {
+    return callNative(getFuncName$6('readSse'), params);
+}
+// 下载一个文件到设备本地
+// url : 需要下载的链接
+// tempFlag: 是否存放到临时目录中
+// method: 请求方法，可以为 GET 或 POST
+// header: JSON格式的字符串，指明该请求需要提交的Header
+// postType: 如果为 POST 请求，指明 POST 数据的格式
+// body: 如果为 POST 请求，这里放入 POST 的内容
+// 返回：
+//     返回下载到的文件名路径
+function downloadToFile(url, tempFlag = true, method = 'GET', header = '', postType = '', body = '') {
+    return callNative(getFuncName$6('downloadToFile'), {
+        url,
+        tempFlag,
+        method,
+        header,
+        postType,
+        body
+    });
+}
+var network = {
+    simpleHttpRequest,
+    httpGet,
+    httpPost,
+    httpSseGet,
+    getNetworkInfo,
+    getDomainName,
+    getCommonHeader,
+    downloadToFile
+};
+
+const moduleName$5 = 'app';
+const localBroadcastHookCallbackId = 'localBroadcastHookCallbackId';
+const globalBroadcastHookCallbackId = 'globalBroadcastHookCallbackId';
+const localBroadcastActionMap = new Map();
+const globalBroadcastActionMap = new Map();
+function getFuncName$5(name) {
+    return moduleName$5 + '_' + name;
+}
+function startActivity(params) {
+    return callNative(getFuncName$5('startActivity'), params);
+}
+function startService(params) {
+    return callNative(getFuncName$5('startService'), params);
+}
+function sendBroadcast(params) {
+    return callNative(getFuncName$5('sendBroadcast'), params);
+}
+function sendLocalBroadcast(params) {
+    return callNative(getFuncName$5('sendLocalBroadcast'), params);
+}
+function startBackEndAction(action) {
+    return callNative(getFuncName$5('startBackEndAction'), action);
+}
+function exitPage() {
+    callNative(getFuncName$5('exitPage'), null);
+}
+function moveTaskToBack() {
+    return callNative(getFuncName$5('moveTaskToBack'), null);
+}
+function getUserInfo() {
+    return callNative(getFuncName$5('getUserInfo'), null);
+}
+function setUserLogout() {
+    return callNative(getFuncName$5('setUserLogout'), null);
+}
+function getAppList() {
+    return callNative(getFuncName$5('getAppList'), null);
+}
+function getAppInfo(params) {
+    return callNative(getFuncName$5('getAppInfo'), params);
+}
+function processLocalBroadcast(payload) {
+    if (payload.hasOwnProperty('action')) {
+        const action = payload['action'];
+        if (localBroadcastActionMap.has(action)) {
+            const func = localBroadcastActionMap.get(action);
+            if (func) {
+                func(payload);
+            }
+        }
+    }
+}
+function processGlobalBroadcast(payload) {
+    if (payload.hasOwnProperty('action')) {
+        const action = payload['action'];
+        if (globalBroadcastActionMap.has(action)) {
+            const func = globalBroadcastActionMap.get(action);
+            if (func) {
+                func(payload);
+            }
+        }
+    }
+}
+function addLocalBroadcastHook(action, callback) {
+    localBroadcastActionMap.set(action, callback); // action 如存在会更新
+    //
+    return callWithPersistentCallBack(getFuncName$5('addLocalBroadcastHook'), { callbackId: localBroadcastHookCallbackId, action }, localBroadcastHookCallbackId, processLocalBroadcast);
+}
+function deleteLocalBroadcastHook(action) {
+    localBroadcastActionMap.delete(action);
+    return callNative(getFuncName$5('deleteLocalBroadcastHook'), { action });
+}
+function addBroadcastHook(action, callback) {
+    globalBroadcastActionMap.set(action, callback); // action 如存在会更新
+    //
+    return callWithPersistentCallBack(getFuncName$5('addBroadcastHook'), { callbackId: globalBroadcastHookCallbackId, action }, globalBroadcastHookCallbackId, processGlobalBroadcast);
+}
+function deleteBroadcastHook(action) {
+    globalBroadcastActionMap.delete(action);
+    return callNative(getFuncName$5('deleteBroadcastHook'), { action });
+}
+function playAudio(source, loop = false, fromAssets = false) {
+    return callNative(getFuncName$5('playAudio'), { source, loop, fromAssets });
+}
+function stopAudio() {
+    return callNative(getFuncName$5('stopAudio'), null);
+}
+function appPrivateMethod(method, params) {
+    let str = '';
+    if (params) {
+        if (typeof params == 'object') {
+            str = JSON.stringify(params);
+        }
+        else {
+            str = String(params);
+        }
+    }
+    return callNative(getFuncName$5('appPrivateMethod'), { method, params: str });
+}
+var app = {
+    startActivity,
+    startService,
+    sendBroadcast,
+    sendLocalBroadcast,
+    startBackEndAction,
+    exitPage,
+    moveTaskToBack,
+    getUserInfo,
+    setUserLogout,
+    getAppList,
+    getAppInfo,
+    addLocalBroadcastHook,
+    deleteLocalBroadcastHook,
+    addBroadcastHook,
+    deleteBroadcastHook,
+    playAudio,
+    stopAudio,
+    appPrivateMethod
+};
+
+const moduleName$4 = 'system';
+const lifeCycleHookCallbackId = 'lifeCycleHookCallback';
+function getFuncName$4(name) {
+    return moduleName$4 + '_' + name;
+}
+// 获取SDK的版本信息
+function getSdkVersion() {
+    return callNative(getFuncName$4('getSdkVersion'), null);
+}
+// 添加 Activity 的生命周期的回调钩子
+function addLifeCycleHook(callback) {
+    return callWithPersistentCallBack(getFuncName$4('addLifeCycleHook'), { callbackId: lifeCycleHookCallbackId }, lifeCycleHookCallbackId, callback);
+}
+// 删除生命周期的回调钩子
+function deleteLifeCycleHook() {
+    deletePersistentCallBack(lifeCycleHookCallbackId);
+    return callNative(getFuncName$4('deleteLifeCycleHook'), null);
+}
+// 声明本页面接收并处理系统级的按键（如：返回、HOME、MENU 键）
+function enableSystemKey(params) {
+    return callNative(getFuncName$4('enableSystemKey'), params);
+}
+// 获取设备信息
+function getDeviceInfo() {
+    return callNative(getFuncName$4('getDeviceInfo'), null);
+}
+// 获取 android property 的值
+function getProperty(key) {
+    return callNative(getFuncName$4('getProperty'), { key });
+}
+// 获取当前设备所处的位置信息
+function getLocation() {
+    return callNative(getFuncName$4('getLocation'), null);
+}
+var system = {
+    getSdkVersion,
+    addLifeCycleHook,
+    deleteLifeCycleHook,
+    enableSystemKey,
+    getDeviceInfo,
+    getProperty,
+    getLocation
+};
+
+const moduleName$3 = 'storage';
+function getFuncName$3(name) {
+    return moduleName$3 + '_' + name;
+}
+function setKey(key, value) {
+    return callNative(getFuncName$3('setKey'), { key, value });
+}
+function getKey(key) {
+    return callNative(getFuncName$3('getKey'), { key });
+}
+function deleteKey(key) {
+    return callNative(getFuncName$3('deleteKey'), { key });
+}
+function clearAllKeys() {
+    return callNative(getFuncName$3('clearAllKeys'), null);
+}
+var storage = {
+    setKey,
+    getKey,
+    deleteKey,
+    clearAllKeys
+};
+
+const moduleName$2 = 'androidView';
+function getFuncName$2(name) {
+    return moduleName$2 + '_' + name;
+}
+const playerListenerCallbackId = 'playerListenerCallbackId';
+// 播放PAG动画
+// repeat: 循环次数 -1 表示无限
+//
+function startPagAni(params) {
+    return callNative(getFuncName$2('startPagAni'), params);
+}
+// 停止PAG动画，并消失
+function stopPagAni() {
+    return callNative(getFuncName$2('stopPagAni'), null);
+}
+// 播报 TTS 文本语音
+function sendTts(text, ttsId) {
+    return callNative(getFuncName$2('sendTts'), { text, id: ttsId });
+}
+// 停止播报 TTS
+function stopTts() {
+    return callNative(getFuncName$2('stopTts'), null);
+}
+// 流式播报 TTS
+function sendStreamTts(text, ttsId, isFirst, isEnd) {
+    return callNative(getFuncName$2('sendStreamTts'), { text, id: ttsId, isFirst, isEnd });
+}
+// 播放器，播放新的URL
+function playerPlayNewUrl(url) {
+    return callNative(getFuncName$2('playerPlayNewUrl'), { url });
+}
+// 播放器，停止播放
+function playerStop() {
+    return callNative(getFuncName$2('playerStop'), null);
+}
+// 播放器，暂停播放
+function playerPause() {
+    return callNative(getFuncName$2('playerPause'), null);
+}
+// 播放器，启动播放或者从暂停恢复播放
+function playerStart() {
+    return callNative(getFuncName$2('playerStart'), null);
+}
+// 播放器，seek
+function playerSeekTo(position) {
+    return callNative(getFuncName$2('playerSeekTo'), { position: Math.floor(position) });
+}
+// 播放器，是否准备好
+function playerHasPrepared() {
+    return callNative(getFuncName$2('playerHasPrepared'), null);
+}
+// 播放器，是否正在播放中
+function playerIsPlaying() {
+    return callNative(getFuncName$2('playerIsPlaying'), null);
+}
+// 播放器，获取总时长
+function playerGetDuration() {
+    return callNative(getFuncName$2('playerGetDuration'), null);
+}
+// 播放器，获取当前进度值
+function playerGetCurrentPosition() {
+    return callNative(getFuncName$2('playerGetCurrentPosition'), null);
+}
+// 播放器，获取播放状态，返回的value为字符串来标识播放状态
+// 例如：Idle, Initialized, Preparing, Prepared, Started, Paused, Stopped, Completed, Error, End
+function playerGetPlayerState() {
+    return callNative(getFuncName$2('playerGetPlayerState'), null);
+}
+// 播放器，播放新的本地文件路径
+function playerPlayNewFile(path) {
+    return callNative(getFuncName$2('playerPlayNewFile'), { path });
+}
+// 播放器，设置单片循环模式
+// isLooping: 是否循环播放
+// silentLoop - 静默循环，默认关闭, 开启之后，部分依靠onCompletion重新播放来实现循环播放的方案下：
+//              会无感知重播，即重播时，不会调idle/ preparing/ prepared等开始播放之前的状态）
+function playerSetLooping(isLooping, silentLoop = false) {
+    return callNative(getFuncName$2('playerSetLooping'), { isLooping, silentLoop });
+}
+// 播放器，设置自动屏保锁，即：开始或恢复播放->锁屏保，停止或暂停播放->释放屏保锁 默认关闭
+function playerSetAutoWakeLock(autoWakeLock) {
+    return callNative(getFuncName$2('playerSetAutoWakeLock'), { autoWakeLock });
+}
+// 播放器，重新播放
+function playerRePlay() {
+    return callNative(getFuncName$2('playerRePlay'), null);
+}
+// 播放器，设置是否自动播放，即 play ready 后音视频自动播放 默认开启
+function playerSetPlayWhenReady(playWhenReady = true) {
+    return callNative(getFuncName$2('playerSetPlayWhenReady'), { playWhenReady });
+}
+// 获取当前设置的播放内核， 有可能会返回 DefaultPlayer
+// 值： DefaultPlayer, MediaPlayer, SocPlayer, ExoPlayer
+function playerGetPlayerCore() {
+    return callNative(getFuncName$2('playerGetPlayerCore'), null);
+}
+// 获取实际的播放内核， 部分内核如：最佳内核，实际上是在各个内核中进行选择，不会返回 DefaultPlayer
+// 值： MediaPlayer, SocPlayer, ExoPlayer
+function playerGetRealPlayerCore() {
+    return callNative(getFuncName$2('playerGetRealPlayerCore'), null);
+}
+// 设置视频播放器的事件回调
+// 注意： 使用此回调的话，不用时记得使用 playerDeleteListener 注销事件回调
+function playerSetListener(callback) {
+    return callWithPersistentCallBack(getFuncName$2('playerSetListener'), { callbackId: playerListenerCallbackId }, playerListenerCallbackId, callback);
+}
+// 注销视频播放器的事件回调
+function playerDeleteListener() {
+    deletePersistentCallBack(playerListenerCallbackId);
+    return callNative(getFuncName$2('playerDeleteListener'), null);
+}
+// 设置视频播放窗口的位置与宽高
+function setVideoLayout(width, height, x, y) {
+    return callNative(getFuncName$2('setVideoLayout'), { x: Number(x), y: Number(y), w: Number(width), h: Number(height) });
+}
+// 设置视频窗口是否显示
+function setVideoVisible(show) {
+    return callNative(getFuncName$2('setVideoVisible'), { visible: show });
+}
+// 设置背景
+// needUpdateColor : 是否更新颜色
+// color : 颜色值，例如 0xFFFF0000表示红色，格式为 ARGB
+// needUpdateImage : 是否更新背景图
+// imageUrl: 背景图的URL
+function setBackground(needUpdateColor, color, needUpdateImage, imageUrl) {
+    return callNative(getFuncName$2('setBackground'), { updateColorFlag: needUpdateColor, updateImageFlag: needUpdateImage, color: Math.floor(color), imageUrl });
+}
+// 清除背景
+function clearBackground() {
+    return callNative(getFuncName$2('clearBackground'), null);
+}
+// 显示语音文本提示条， tips文本中如果带 # 字符，会把 # 字符显示成麦克风图标 
+function showVoiceTipsBar(tips = '') {
+    return callNative(getFuncName$2('showVoiceTipsBar'), { tips });
+}
+// 隐藏语音文本提示条
+function hideVoiceTipsBar() {
+    return callNative(getFuncName$2('hideVoiceTipsBar'), null);
+}
+var androidView = {
+    startPagAni,
+    stopPagAni,
+    sendTts,
+    stopTts,
+    sendStreamTts,
+    playerPlayNewUrl,
+    playerStop,
+    playerPause,
+    playerStart,
+    playerSeekTo,
+    playerHasPrepared,
+    playerIsPlaying,
+    playerGetDuration,
+    playerGetCurrentPosition,
+    playerGetPlayerState,
+    playerPlayNewFile,
+    playerSetLooping,
+    playerSetAutoWakeLock,
+    playerRePlay,
+    playerSetPlayWhenReady,
+    playerGetPlayerCore,
+    playerGetRealPlayerCore,
+    playerSetListener,
+    playerDeleteListener,
+    setVideoLayout,
+    setVideoVisible,
+    setBackground,
+    clearBackground,
+    showVoiceTipsBar,
+    hideVoiceTipsBar,
+};
+
+const moduleName$1 = 'audio';
+function getFuncName$1(name) {
+    return moduleName$1 + '_' + name;
+}
+const audioPlayerListenerCallbackId = 'audioPlayerListenerCallbackId';
+// 播放器，播放新的URL或者本地文件系统的路径
+function playNew(path) {
+    return callNative(getFuncName$1('playNew'), { path });
+}
+// 播放器，停止播放
+function stop() {
+    return callNative(getFuncName$1('stop'), null);
+}
+// 播放器，是否正在播放中
+function isPlaying() {
+    return callNative(getFuncName$1('isPlaying'), null);
+}
+// 播放器，是否准备好
+function hasPrepared() {
+    return callNative(getFuncName$1('hasPrepared'), null);
+}
+// 播放器，获取总时长
+function getDuration() {
+    return callNative(getFuncName$1('getDuration'), null);
+}
+// 播放器，获取当前进度值
+function getCurrentPosition() {
+    return callNative(getFuncName$1('getCurrentPosition'), null);
+}
+// 播放器，获取播放状态，返回的value为字符串来标识播放状态
+// 例如：Idle, Initialized, Preparing, Prepared, Started, Paused, Stopped, Completed, Error, End
+function getPlayerState() {
+    return callNative(getFuncName$1('getPlayerState'), null);
+}
+// 播放器，暂停播放
+function pause() {
+    return callNative(getFuncName$1('pause'), null);
+}
+// 播放器，启动播放或者从暂停恢复播放
+function start() {
+    return callNative(getFuncName$1('start'), null);
+}
+// 播放器，重新播放
+function rePlay() {
+    return callNative(getFuncName$1('rePlay'), null);
+}
+// 播放器，seek
+function seekTo(position) {
+    return callNative(getFuncName$1('seekTo'), { position: Math.floor(position) });
+}
+// 播放器，设置单片循环模式
+// isLooping: 是否循环播放
+// silentLoop - 静默循环，默认关闭, 开启之后，部分依靠onCompletion重新播放来实现循环播放的方案下：
+//              会无感知重播，即重播时，不会调idle/ preparing/ prepared等开始播放之前的状态）
+function setLooping(isLooping, silentLoop = false) {
+    return callNative(getFuncName$1('setLooping'), { isLooping, silentLoop });
+}
+// 设置音量
+function setVolume(volume) {
+    return callNative(getFuncName$1('setVolume'), { volume });
+}
+// 设置视频播放器的事件回调
+// 注意： 使用此回调的话，不用时记得使用 deleteListener 注销事件回调
+function setListener(callback) {
+    return callWithPersistentCallBack(getFuncName$1('setListener'), { callbackId: audioPlayerListenerCallbackId }, audioPlayerListenerCallbackId, callback);
+}
+// 注销视频播放器的事件回调
+function deleteListener() {
+    deletePersistentCallBack(audioPlayerListenerCallbackId);
+    return callNative(getFuncName$1('deleteListener'), null);
+}
+var audio = {
+    playNew,
+    stop,
+    isPlaying,
+    hasPrepared,
+    getDuration,
+    getCurrentPosition,
+    getPlayerState,
+    pause,
+    start,
+    rePlay,
+    seekTo,
+    setLooping,
+    setVolume,
+    setListener,
+    deleteListener
+};
+
+const moduleName = 'file';
+function getFuncName(name) {
+    return moduleName + '_' + name;
+}
+// 读取文件并返回文件的所有内容
+// 参数:
+//    path: 读取文件的路径
+//    base64Flag: 是否以base64编码方式返回, 如果读取文件文件，则应该设置 base64Flag = false，如果读取二进制文件，则应该设置 base64Flag = true
+function readAllContent(path, base64Flag = false) {
+    return callNative(getFuncName('readAllContent'), { path, base64Flag });
+}
+// 将内容全部写入文件
+// 参数:
+//    path: 写入文件的路径
+//    content: 写入的内容，字符串，如果要写入二进制，应该先编码成 base64 字符串再传入
+//    base64Flag: 是否以base64编码方式传输content, 如果写文件文件，则应该设置 base64Flag = false，如果写入二进制文件，则应该设置 base64Flag = true
+function writeAllContent(path, content, base64Flag = false) {
+    return callNative(getFuncName('writeAllContent'), { path, content, base64Flag });
+}
+// 获取应用基本目录的全路径名
+function getBaseDir() {
+    return callNative(getFuncName('getBaseDir'), null);
+}
+// 获取 Cache 目录的全路径名
+function getCacheDir() {
+    return callNative(getFuncName('getCacheDir'), null);
+}
+// 构建一个临时文件名，返回该文件的绝对路径的全文件路径名
+// 参数：
+//    fileName: 指定临时文件的基本名，如果不指定，会默认随机生成一个文件名
+function makeCacheFile(fileName = '') {
+    return callNative(getFuncName('makeCacheFile'), { fileName });
+}
+// 构建一个正常文件名，返回该文件的绝对路径的全文件路径名
+// 参数：
+//    fileName: 指定文件的基本名，如果不指定，会默认随机生成一个文件名
+function makeNormalFile(fileName = '') {
+    return callNative(getFuncName('makeNormalFile'), { fileName });
+}
+// 检测一个文件或者目录是否存在
+// 参数：
+//    path: 指定路径
+function exists(path) {
+    return callNative(getFuncName('exists'), { path });
+}
+// 检测一个路径是否为一个普通文件
+// 参数：
+//    path: 指定路径
+function isFile(path) {
+    return callNative(getFuncName('isFile'), { path });
+}
+// 检测一个路径是否为一个目录
+// 参数：
+//    path: 指定路径
+function isDirectory(path) {
+    return callNative(getFuncName('isDirectory'), { path });
+}
+// 检测一个路径表示的文件或目录 是否是隐藏的
+// 参数：
+//    path: 指定路径
+function isHidden(path) {
+    return callNative(getFuncName('isHidden'), { path });
+}
+// 检测一个路径表示的文件或目录 是否可读
+// 参数：
+//    path: 指定路径
+function canRead(path) {
+    return callNative(getFuncName('canRead'), { path });
+}
+// 检测一个路径表示的文件或目录 是否可写
+// 参数：
+//    path: 指定路径
+function canWrite(path) {
+    return callNative(getFuncName('canWrite'), { path });
+}
+// 检测一个路径表示的文件或目录 是否可执行
+// 参数：
+//    path: 指定路径
+function canExecute(path) {
+    return callNative(getFuncName('canExecute'), { path });
+}
+// 检测一个路径表示的文件或目录 的最后修改的时间，返回时间戳(1970年开始的秒数)
+// 参数：
+//    path: 指定路径
+function lastModified(path) {
+    return callNative(getFuncName('lastModified'), { path });
+}
+// 删除文件
+// 参数：
+//    path: 指定路径
+function deleteIt(path) {
+    return callNative(getFuncName('delete'), { path });
+}
+// 新建目录
+// 参数：
+//    path: 指定路径
+function mkdir(path) {
+    return callNative(getFuncName('mkdir'), { path });
+}
+// 新建目录 (如果父目录补存在则一并新建所有尚未存在的父目录)
+// 参数：
+//    path: 指定路径
+function mkdirs(path) {
+    return callNative(getFuncName('mkdirs'), { path });
+}
+// 改名
+// 参数：
+//    from: 指定源路径
+//    to:   指定目标路径
+function rename(from, to) {
+    return callNative(getFuncName('rename'), { from, to });
+}
+// 将相对路径的转换为全路径
+// 参数：
+//    path: 指定路径
+function getAbsolutePath(path) {
+    return callNative(getFuncName('getAbsolutePath'), { path });
+}
+// 指定路径创建新文件
+// 参数：
+//    path: 指定路径
+function createNewFile(path) {
+    return callNative(getFuncName('createNewFile'), { path });
+}
+// 设置可读属性
+// 参数：
+//    path: 指定路径
+//    value: 是否可读
+function setReadable(path, value = true) {
+    return callNative(getFuncName('setReadable'), { path, value });
+}
+// 设置可写属性
+// 参数：
+//    path: 指定路径
+//    value: 是否可写
+function setWritable(path, value = true) {
+    return callNative(getFuncName('setWritable'), { path, value });
+}
+// 设置可执行属性
+// 参数：
+//    path: 指定路径
+//    value: 是否可执行
+function setExecutable(path, value = true) {
+    return callNative(getFuncName('setExecutable'), { path, value });
+}
+// 设置文件最后修改的时间
+// 参数：
+//    path: 指定路径
+//    value: 时间戳
+function setLastModified(path, value = 0) {
+    return callNative(getFuncName('setLastModified'), { path, value });
+}
+// 读取目录，返回该目录下的文件列表
+// 参数：
+//    path: 指定路径
+function list(path) {
+    return callNative(getFuncName('list'), { path });
+}
+var file = {
+    readAllContent,
+    writeAllContent,
+    getBaseDir,
+    getCacheDir,
+    makeCacheFile,
+    makeNormalFile,
+    exists,
+    isFile,
+    isDirectory,
+    isHidden,
+    canRead,
+    canWrite,
+    canExecute,
+    lastModified,
+    deleteIt,
+    mkdir,
+    mkdirs,
+    rename,
+    getAbsolutePath,
+    createNewFile,
+    setReadable,
+    setWritable,
+    setExecutable,
+    setLastModified,
+    list
+};
+
+window['apkNativeCall'] = function apkNativeCall(str) {
+    let res = null;
+    //console.log('str1=' + str);
+    try {
+        const dec1 = atob(str);
+        //console.log('dec1=' + dec1);
+        const dec2 = decodeURIComponent(dec1);
+        //console.log('dec2=' + dec2);
+        res = JSON.parse(dec2);
+        //console.log('data type = ' + typeof(res.data));
+    }
+    catch (ex) {
+        console.error('error: ' + ex.toString());
+        return;
+    }
+    if (!res) {
+        console.error('apkNativeCall: res is empty');
+        return;
+    }
+    //
+    if (res.hasOwnProperty('cmd')) {
+        if (res['cmd'] == 'onApiCallBack') {
+            callbackFromNative(res['id'], res['data']);
+        }
+        else {
+            onCommandFromApp(res['cmd'], res['data']);
+        }
+    }
+};
+function isRunInCooPark() {
+    return window['_CooPark'] ? true : false;
+}
+var index = {
+    network,
+    app,
+    system,
+    storage,
+    androidView,
+    audio,
+    file,
+    isRunInCooPark
+};
+
+export { index as default, isRunInCooPark, setAppCommandCallback, unsetAppCommandCallback };