@ccos/ccsdk-lite 1.0.2 → 1.0.4

package/dist/app/index.d.ts

@@ -17,7 +17,6 @@ export declare function startBackEndAction(action: object): Promise<any>;
 export declare function exitPage(): void;
 export declare function moveTaskToBack(): Promise<any>;
 export declare function getUserInfo(): Promise<any>;
-export declare function setUserLogout(): Promise<any>;
 export declare function getAppList(): Promise<any>;
 export declare function getAppInfo(params: GetAppInfoParam): Promise<any>;
 export declare function addLocalBroadcastHook(action: string, callback: Function): Promise<any>;
@@ -36,7 +35,6 @@ declare const _default: {
     exitPage: typeof exitPage;
     moveTaskToBack: typeof moveTaskToBack;
     getUserInfo: typeof getUserInfo;
-    setUserLogout: typeof setUserLogout;
     getAppList: typeof getAppList;
     getAppInfo: typeof getAppInfo;
     addLocalBroadcastHook: typeof addLocalBroadcastHook;

package/dist/bundle.js

@@ -4,70 +4,76 @@
  * 未传入name时默认会有自增id作为name
  * 主要为 定时器 bridge 等服务
  */
-class Bus {
-    constructor() {
+var Bus = /** @class */ (function () {
+    function Bus() {
         this._busId = 0;
         this._pool = {};
     }
-    register(callback, name) {
-        let busName = name ? name.toString() : (++this._busId).toString();
+    Bus.prototype.register = function (callback, name) {
+        var busName = name ? name.toString() : (++this._busId).toString();
         if (!this._pool[busName])
             this._pool[busName] = [];
         this._pool[busName].push(callback);
         return busName;
-    }
-    fire(name, ...args) {
+    };
+    Bus.prototype.fire = function (name) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
         if (!name)
             return;
-        const callbacks = this._pool[name];
+        var callbacks = this._pool[name];
         if (!callbacks || !callbacks.length)
             return;
-        return callbacks.map((callback) => callback(...args));
-    }
-    has(name, callback) {
+        return callbacks.map(function (callback) { return callback.apply(void 0, args); });
+    };
+    Bus.prototype.has = function (name, callback) {
         if (!name || !this._pool[name])
             return false;
         if (!callback)
             return true;
-        const callbacks = this._pool[name];
-        const index = callbacks.indexOf(callback);
+        var callbacks = this._pool[name];
+        var index = callbacks.indexOf(callback);
         return index > -1;
-    }
-    remove(name, callback) {
+    };
+    Bus.prototype.remove = function (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);
+        var callbacks = this._pool[name];
+        var index = callbacks.indexOf(callback);
         if (index > -1)
             callbacks.splice(index, 1);
-    }
-    clear() {
+    };
+    Bus.prototype.clear = function () {
         this._busId = 0;
         this._pool = {};
-    }
-}
-const bus = new Bus();
+    };
+    return Bus;
+}());
+var bus = new Bus();
 
-let actionList = []; // 这里保存, 未注册命令处理函数之前，APP发过来的命令
+var actionList = []; // 这里保存, 未注册命令处理函数之前，APP发过来的命令
 function defaultAppCmd(cmd, payload) {
     console.log('default appCmd ' + cmd);
-    actionList.push({ cmd, payload }); // 有可能APP发过来的命令比较早，而页面的一些初始化还没有做完，这时把命令先存起来，放到 actionList 中
+    actionList.push({ cmd: cmd, payload: payload }); // 有可能APP发过来的命令比较早，而页面的一些初始化还没有做完，这时把命令先存起来，放到 actionList 中
 }
-let appCmdProcessor = defaultAppCmd; // APP 发过来的命令，JS的执行函数
+var appCmdProcessor = defaultAppCmd; // APP 发过来的命令，JS的执行函数
 function onCommandFromApp(cmd, payload) {
     appCmdProcessor(cmd, payload);
 }
 function setAppCommandCallback(cb) {
     appCmdProcessor = cb;
     //
-    const workList = actionList;
+    var workList = actionList;
     actionList = [];
     // 如果 actionList 中有初始化之前来的命令，则执行这些命令
-    for (const action of workList) {
+    for (var _i = 0, workList_1 = workList; _i < workList_1.length; _i++) {
+        var action = workList_1[_i];
         console.log('ahead cmd = ' + action.cmd);
         cb(action.cmd, action.payload);
     }
@@ -78,7 +84,7 @@ function unsetAppCommandCallback() {
 }
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-let persistentCallbackId = []; // 持久化 callback-id 列表
+var persistentCallbackId = []; // 持久化 callback-id 列表
 function nativeCall(funcName, callbackId, params) {
     if (window['_liteNativeApi']) {
         // 运行于 android 浏览器webview 
@@ -92,22 +98,22 @@ function nativeCall(funcName, callbackId, params) {
 }
 function nativeRequest(funcName, params, persistent, persistentIdName, persistentCallback) {
     if (!persistent) {
-        return new Promise((resolve) => {
-            let callbackId = bus.register((res) => {
+        return new Promise(function (resolve) {
+            var callbackId = bus.register(function (res) {
                 resolve(res);
             });
             nativeCall(funcName, callbackId, params);
         });
     }
     // 以下是持久化调用处理
-    let index = persistentCallbackId.indexOf(persistentIdName);
+    var 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) => {
+    return new Promise(function (resolve) {
+        var callbackId = bus.register(function (res) {
             resolve(res);
         });
         nativeCall(funcName, callbackId, params);
@@ -124,14 +130,14 @@ function callWithPersistentCallBack(funcName, params, persistentIdName, callback
 // 注销一个持久的回调函数
 function deletePersistentCallBack(persistentIdName) {
     bus.remove(persistentIdName);
-    let index = persistentCallbackId.indexOf(persistentIdName);
+    var index = persistentCallbackId.indexOf(persistentIdName);
     if (index < 0) {
         return;
     }
     persistentCallbackId.splice(index, 1); // 从persistentCallbackId中删除name
 }
 function callbackFromNative(callbackId, data) {
-    let payload = '';
+    var payload = '';
     if (typeof data == 'string') {
         try {
             payload = JSON.parse(data);
@@ -145,13 +151,13 @@ function callbackFromNative(callbackId, data) {
     }
     bus.fire(callbackId, payload);
     // 判断，如果不是持久的回调函数，则调用完毕之后删除该回调
-    let index = persistentCallbackId.indexOf(callbackId);
+    var index = persistentCallbackId.indexOf(callbackId);
     if (index < 0) {
         bus.remove(callbackId);
     }
 }
 
-const moduleName$6 = 'network';
+var moduleName$6 = 'network';
 function getFuncName$6(name) {
     return moduleName$6 + '_' + name;
 }
@@ -159,12 +165,13 @@ function paramToUrl(params) {
     if (!params)
         return '';
     if (typeof params == 'object') {
-        let strArr = [];
-        let counter = 0;
-        let keys = Object.keys(params);
+        var strArr = [];
+        var counter = 0;
+        var keys = Object.keys(params);
         keys.sort();
-        for (const key of keys) {
-            const value = params[key];
+        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
+            var key = keys_1[_i];
+            var value = params[key];
             if (counter != 0) {
                 strArr.push('&');
             }
@@ -187,8 +194,8 @@ function simpleHttpRequest(params) {
     return callNative(getFuncName$6('simpleHttpRequest'), params);
 }
 function httpGet(url, urlParam, header, base64) {
-    const paramString = paramToUrl(urlParam);
-    let newUrl;
+    var paramString = paramToUrl(urlParam);
+    var newUrl;
     if (paramString) {
         if (url.indexOf('?') >= 0) {
             newUrl = url + '&' + paramString;
@@ -201,7 +208,7 @@ function httpGet(url, urlParam, header, base64) {
         newUrl = url;
     }
     //
-    let obj = {
+    var obj = {
         url: newUrl,
         method: 'GET'
     };
@@ -214,7 +221,7 @@ function httpGet(url, urlParam, header, base64) {
     return simpleHttpRequest(obj);
 }
 function httpPost(url, body, header, postJson, base64, postType) {
-    let obj = {
+    var obj = {
         url: url,
         method: 'POST'
     };
@@ -255,8 +262,8 @@ function httpPost(url, body, header, postJson, base64, postType) {
     return simpleHttpRequest(obj);
 }
 function httpSseGet(url, urlParam, header, base64) {
-    const paramString = paramToUrl(urlParam);
-    let newUrl;
+    var paramString = paramToUrl(urlParam);
+    var newUrl;
     if (paramString) {
         if (url.indexOf('?') >= 0) {
             newUrl = url + '&' + paramString;
@@ -269,7 +276,7 @@ function httpSseGet(url, urlParam, header, base64) {
         newUrl = url;
     }
     //
-    let obj = {
+    var obj = {
         url: newUrl,
         method: 'GET'
     };
@@ -287,7 +294,7 @@ function getNetworkInfo() {
 }
 // 获取合规化后的域名
 function getDomainName(domain) {
-    return callNative(getFuncName$6('getDomainName'), { domain });
+    return callNative(getFuncName$6('getDomainName'), { domain: domain });
 }
 // 获取基本 Header 信息
 function getCommonHeader() {
@@ -306,32 +313,37 @@ function readSse(params) {
 // body: 如果为 POST 请求，这里放入 POST 的内容
 // 返回：
 //     返回下载到的文件名路径
-function downloadToFile(url, tempFlag = true, method = 'GET', header = '', postType = '', body = '') {
+function downloadToFile(url, tempFlag, method, header, postType, body) {
+    if (tempFlag === void 0) { tempFlag = true; }
+    if (method === void 0) { method = 'GET'; }
+    if (header === void 0) { header = ''; }
+    if (postType === void 0) { postType = ''; }
+    if (body === void 0) { body = ''; }
     return callNative(getFuncName$6('downloadToFile'), {
-        url,
-        tempFlag,
-        method,
-        header,
-        postType,
-        body
+        url: url,
+        tempFlag: tempFlag,
+        method: method,
+        header: header,
+        postType: postType,
+        body: body
     });
 }
 var network = {
-    simpleHttpRequest,
-    httpGet,
-    httpPost,
-    httpSseGet,
-    getNetworkInfo,
-    getDomainName,
-    getCommonHeader,
-    downloadToFile
+    simpleHttpRequest: simpleHttpRequest,
+    httpGet: httpGet,
+    httpPost: httpPost,
+    httpSseGet: httpSseGet,
+    getNetworkInfo: getNetworkInfo,
+    getDomainName: getDomainName,
+    getCommonHeader: getCommonHeader,
+    downloadToFile: downloadToFile
 };
 
-const moduleName$5 = 'app';
-const localBroadcastHookCallbackId = 'localBroadcastHookCallbackId';
-const globalBroadcastHookCallbackId = 'globalBroadcastHookCallbackId';
-const localBroadcastActionMap = new Map();
-const globalBroadcastActionMap = new Map();
+var moduleName$5 = 'app';
+var localBroadcastHookCallbackId = 'localBroadcastHookCallbackId';
+var globalBroadcastHookCallbackId = 'globalBroadcastHookCallbackId';
+var localBroadcastActionMap = new Map();
+var globalBroadcastActionMap = new Map();
 function getFuncName$5(name) {
     return moduleName$5 + '_' + name;
 }
@@ -359,9 +371,6 @@ function moveTaskToBack() {
 function getUserInfo() {
     return callNative(getFuncName$5('getUserInfo'), null);
 }
-function setUserLogout() {
-    return callNative(getFuncName$5('setUserLogout'), null);
-}
 function getAppList() {
     return callNative(getFuncName$5('getAppList'), null);
 }
@@ -370,9 +379,9 @@ function getAppInfo(params) {
 }
 function processLocalBroadcast(payload) {
     if (payload.hasOwnProperty('action')) {
-        const action = payload['action'];
+        var action = payload['action'];
         if (localBroadcastActionMap.has(action)) {
-            const func = localBroadcastActionMap.get(action);
+            var func = localBroadcastActionMap.get(action);
             if (func) {
                 func(payload);
             }
@@ -381,9 +390,9 @@ function processLocalBroadcast(payload) {
 }
 function processGlobalBroadcast(payload) {
     if (payload.hasOwnProperty('action')) {
-        const action = payload['action'];
+        var action = payload['action'];
         if (globalBroadcastActionMap.has(action)) {
-            const func = globalBroadcastActionMap.get(action);
+            var func = globalBroadcastActionMap.get(action);
             if (func) {
                 func(payload);
             }
@@ -393,29 +402,31 @@ function processGlobalBroadcast(payload) {
 function addLocalBroadcastHook(action, callback) {
     localBroadcastActionMap.set(action, callback); // action 如存在会更新
     //
-    return callWithPersistentCallBack(getFuncName$5('addLocalBroadcastHook'), { callbackId: localBroadcastHookCallbackId, action }, localBroadcastHookCallbackId, processLocalBroadcast);
+    return callWithPersistentCallBack(getFuncName$5('addLocalBroadcastHook'), { callbackId: localBroadcastHookCallbackId, action: action }, localBroadcastHookCallbackId, processLocalBroadcast);
 }
 function deleteLocalBroadcastHook(action) {
     localBroadcastActionMap.delete(action);
-    return callNative(getFuncName$5('deleteLocalBroadcastHook'), { action });
+    return callNative(getFuncName$5('deleteLocalBroadcastHook'), { action: action });
 }
 function addBroadcastHook(action, callback) {
     globalBroadcastActionMap.set(action, callback); // action 如存在会更新
     //
-    return callWithPersistentCallBack(getFuncName$5('addBroadcastHook'), { callbackId: globalBroadcastHookCallbackId, action }, globalBroadcastHookCallbackId, processGlobalBroadcast);
+    return callWithPersistentCallBack(getFuncName$5('addBroadcastHook'), { callbackId: globalBroadcastHookCallbackId, action: action }, globalBroadcastHookCallbackId, processGlobalBroadcast);
 }
 function deleteBroadcastHook(action) {
     globalBroadcastActionMap.delete(action);
-    return callNative(getFuncName$5('deleteBroadcastHook'), { action });
+    return callNative(getFuncName$5('deleteBroadcastHook'), { action: action });
 }
-function playAudio(source, loop = false, fromAssets = false) {
-    return callNative(getFuncName$5('playAudio'), { source, loop, fromAssets });
+function playAudio(source, loop, fromAssets) {
+    if (loop === void 0) { loop = false; }
+    if (fromAssets === void 0) { fromAssets = false; }
+    return callNative(getFuncName$5('playAudio'), { source: source, loop: loop, fromAssets: fromAssets });
 }
 function stopAudio() {
     return callNative(getFuncName$5('stopAudio'), null);
 }
 function appPrivateMethod(method, params) {
-    let str = '';
+    var str = '';
     if (params) {
         if (typeof params == 'object') {
             str = JSON.stringify(params);
@@ -424,31 +435,30 @@ function appPrivateMethod(method, params) {
             str = String(params);
         }
     }
-    return callNative(getFuncName$5('appPrivateMethod'), { method, params: str });
+    return callNative(getFuncName$5('appPrivateMethod'), { method: method, params: str });
 }
 var app = {
-    startActivity,
-    startService,
-    sendBroadcast,
-    sendLocalBroadcast,
-    startBackEndAction,
-    exitPage,
-    moveTaskToBack,
-    getUserInfo,
-    setUserLogout,
-    getAppList,
-    getAppInfo,
-    addLocalBroadcastHook,
-    deleteLocalBroadcastHook,
-    addBroadcastHook,
-    deleteBroadcastHook,
-    playAudio,
-    stopAudio,
-    appPrivateMethod
+    startActivity: startActivity,
+    startService: startService,
+    sendBroadcast: sendBroadcast,
+    sendLocalBroadcast: sendLocalBroadcast,
+    startBackEndAction: startBackEndAction,
+    exitPage: exitPage,
+    moveTaskToBack: moveTaskToBack,
+    getUserInfo: getUserInfo,
+    getAppList: getAppList,
+    getAppInfo: getAppInfo,
+    addLocalBroadcastHook: addLocalBroadcastHook,
+    deleteLocalBroadcastHook: deleteLocalBroadcastHook,
+    addBroadcastHook: addBroadcastHook,
+    deleteBroadcastHook: deleteBroadcastHook,
+    playAudio: playAudio,
+    stopAudio: stopAudio,
+    appPrivateMethod: appPrivateMethod
 };
 
-const moduleName$4 = 'system';
-const lifeCycleHookCallbackId = 'lifeCycleHookCallback';
+var moduleName$4 = 'system';
+var lifeCycleHookCallbackId = 'lifeCycleHookCallback';
 function getFuncName$4(name) {
     return moduleName$4 + '_' + name;
 }
@@ -475,163 +485,265 @@ function getDeviceInfo() {
 }
 // 获取 android property 的值
 function getProperty(key) {
-    return callNative(getFuncName$4('getProperty'), { key });
+    return callNative(getFuncName$4('getProperty'), { key: key });
 }
 // 获取当前设备所处的位置信息
 function getLocation() {
     return callNative(getFuncName$4('getLocation'), null);
 }
+// 检查 JS-API 是否已经实现
+function checkApi(apiName) {
+    return callNative(getFuncName$4('checkApi'), { apiName: apiName });
+}
+// 获取显示屏幕信息
+function getDisplayInfo() {
+    return callNative(getFuncName$4('getDisplayInfo'), null);
+}
 var system = {
-    getSdkVersion,
-    addLifeCycleHook,
-    deleteLifeCycleHook,
-    enableSystemKey,
-    getDeviceInfo,
-    getProperty,
-    getLocation
+    getSdkVersion: getSdkVersion,
+    addLifeCycleHook: addLifeCycleHook,
+    deleteLifeCycleHook: deleteLifeCycleHook,
+    enableSystemKey: enableSystemKey,
+    getDeviceInfo: getDeviceInfo,
+    getProperty: getProperty,
+    getLocation: getLocation,
+    checkApi: checkApi,
+    getDisplayInfo: getDisplayInfo,
 };
 
-const moduleName$3 = 'storage';
+var moduleName$3 = 'storage';
 function getFuncName$3(name) {
     return moduleName$3 + '_' + name;
 }
 function setKey(key, value) {
-    return callNative(getFuncName$3('setKey'), { key, value });
+    return callNative(getFuncName$3('setKey'), { key: key, value: value });
 }
 function getKey(key) {
-    return callNative(getFuncName$3('getKey'), { key });
+    return callNative(getFuncName$3('getKey'), { key: key });
 }
 function deleteKey(key) {
-    return callNative(getFuncName$3('deleteKey'), { key });
+    return callNative(getFuncName$3('deleteKey'), { key: key });
 }
 function clearAllKeys() {
     return callNative(getFuncName$3('clearAllKeys'), null);
 }
 var storage = {
-    setKey,
-    getKey,
-    deleteKey,
-    clearAllKeys
+    setKey: setKey,
+    getKey: getKey,
+    deleteKey: deleteKey,
+    clearAllKeys: clearAllKeys
 };
 
-const moduleName$2 = 'androidView';
+var moduleName$2 = 'audio';
 function getFuncName$2(name) {
     return moduleName$2 + '_' + name;
 }
-const playerListenerCallbackId = 'playerListenerCallbackId';
+var audioPlayerListenerCallbackId = 'audioPlayerListenerCallbackId';
+// 播放器，播放新的URL或者本地文件系统的路径
+function playNew(path) {
+    return callNative(getFuncName$2('playNew'), { path: path });
+}
+// 播放器，停止播放
+function stop() {
+    return callNative(getFuncName$2('stop'), null);
+}
+// 播放器，是否正在播放中
+function isPlaying() {
+    return callNative(getFuncName$2('isPlaying'), null);
+}
+// 播放器，是否准备好
+function hasPrepared() {
+    return callNative(getFuncName$2('hasPrepared'), null);
+}
+// 播放器，获取总时长
+function getDuration() {
+    return callNative(getFuncName$2('getDuration'), null);
+}
+// 播放器，获取当前进度值
+function getCurrentPosition() {
+    return callNative(getFuncName$2('getCurrentPosition'), null);
+}
+// 播放器，获取播放状态，返回的value为字符串来标识播放状态
+// 例如：Idle, Initialized, Preparing, Prepared, Started, Paused, Stopped, Completed, Error, End
+function getPlayerState() {
+    return callNative(getFuncName$2('getPlayerState'), null);
+}
+// 播放器，暂停播放
+function pause() {
+    return callNative(getFuncName$2('pause'), null);
+}
+// 播放器，启动播放或者从暂停恢复播放
+function start() {
+    return callNative(getFuncName$2('start'), null);
+}
+// 播放器，重新播放
+function rePlay() {
+    return callNative(getFuncName$2('rePlay'), null);
+}
+// 播放器，seek
+function seekTo(position) {
+    return callNative(getFuncName$2('seekTo'), { position: Math.floor(position) });
+}
+// 播放器，设置单片循环模式
+// isLooping: 是否循环播放
+// silentLoop - 静默循环，默认关闭, 开启之后，部分依靠onCompletion重新播放来实现循环播放的方案下：
+//              会无感知重播，即重播时，不会调idle/ preparing/ prepared等开始播放之前的状态）
+function setLooping(isLooping, silentLoop) {
+    if (silentLoop === void 0) { silentLoop = false; }
+    return callNative(getFuncName$2('setLooping'), { isLooping: isLooping, silentLoop: silentLoop });
+}
+// 设置音量
+function setVolume(volume) {
+    return callNative(getFuncName$2('setVolume'), { volume: volume });
+}
+// 设置视频播放器的事件回调
+// 注意： 使用此回调的话，不用时记得使用 deleteListener 注销事件回调
+function setListener(callback) {
+    return callWithPersistentCallBack(getFuncName$2('setListener'), { callbackId: audioPlayerListenerCallbackId }, audioPlayerListenerCallbackId, callback);
+}
+// 注销视频播放器的事件回调
+function deleteListener() {
+    deletePersistentCallBack(audioPlayerListenerCallbackId);
+    return callNative(getFuncName$2('deleteListener'), null);
+}
+var audio = {
+    playNew: playNew,
+    stop: stop,
+    isPlaying: isPlaying,
+    hasPrepared: hasPrepared,
+    getDuration: getDuration,
+    getCurrentPosition: getCurrentPosition,
+    getPlayerState: getPlayerState,
+    pause: pause,
+    start: start,
+    rePlay: rePlay,
+    seekTo: seekTo,
+    setLooping: setLooping,
+    setVolume: setVolume,
+    setListener: setListener,
+    deleteListener: deleteListener
+};
+
+var moduleName$1 = 'androidView';
+function getFuncName$1(name) {
+    return moduleName$1 + '_' + name;
+}
+var playerListenerCallbackId = 'playerListenerCallbackId';
 // 播放PAG动画
 // repeat: 循环次数 -1 表示无限
 //
 function startPagAni(params) {
-    return callNative(getFuncName$2('startPagAni'), params);
+    return callNative(getFuncName$1('startPagAni'), params);
 }
 // 停止PAG动画，并消失
 function stopPagAni() {
-    return callNative(getFuncName$2('stopPagAni'), null);
+    return callNative(getFuncName$1('stopPagAni'), null);
 }
 // 播报 TTS 文本语音
 function sendTts(text, ttsId) {
-    return callNative(getFuncName$2('sendTts'), { text, id: ttsId });
+    return callNative(getFuncName$1('sendTts'), { text: text, id: ttsId });
 }
 // 停止播报 TTS
 function stopTts() {
-    return callNative(getFuncName$2('stopTts'), null);
+    return callNative(getFuncName$1('stopTts'), null);
 }
 // 流式播报 TTS
 function sendStreamTts(text, ttsId, isFirst, isEnd) {
-    return callNative(getFuncName$2('sendStreamTts'), { text, id: ttsId, isFirst, isEnd });
+    return callNative(getFuncName$1('sendStreamTts'), { text: text, id: ttsId, isFirst: isFirst, isEnd: isEnd });
 }
 // 播放器，播放新的URL
 function playerPlayNewUrl(url) {
-    return callNative(getFuncName$2('playerPlayNewUrl'), { url });
+    return callNative(getFuncName$1('playerPlayNewUrl'), { url: url });
 }
 // 播放器，停止播放
 function playerStop() {
-    return callNative(getFuncName$2('playerStop'), null);
+    return callNative(getFuncName$1('playerStop'), null);
 }
 // 播放器，暂停播放
 function playerPause() {
-    return callNative(getFuncName$2('playerPause'), null);
+    return callNative(getFuncName$1('playerPause'), null);
 }
 // 播放器，启动播放或者从暂停恢复播放
 function playerStart() {
-    return callNative(getFuncName$2('playerStart'), null);
+    return callNative(getFuncName$1('playerStart'), null);
 }
 // 播放器，seek
 function playerSeekTo(position) {
-    return callNative(getFuncName$2('playerSeekTo'), { position: Math.floor(position) });
+    return callNative(getFuncName$1('playerSeekTo'), { position: Math.floor(position) });
 }
 // 播放器，是否准备好
 function playerHasPrepared() {
-    return callNative(getFuncName$2('playerHasPrepared'), null);
+    return callNative(getFuncName$1('playerHasPrepared'), null);
 }
 // 播放器，是否正在播放中
 function playerIsPlaying() {
-    return callNative(getFuncName$2('playerIsPlaying'), null);
+    return callNative(getFuncName$1('playerIsPlaying'), null);
 }
 // 播放器，获取总时长
 function playerGetDuration() {
-    return callNative(getFuncName$2('playerGetDuration'), null);
+    return callNative(getFuncName$1('playerGetDuration'), null);
 }
 // 播放器，获取当前进度值
 function playerGetCurrentPosition() {
-    return callNative(getFuncName$2('playerGetCurrentPosition'), null);
+    return callNative(getFuncName$1('playerGetCurrentPosition'), null);
 }
 // 播放器，获取播放状态，返回的value为字符串来标识播放状态
 // 例如：Idle, Initialized, Preparing, Prepared, Started, Paused, Stopped, Completed, Error, End
 function playerGetPlayerState() {
-    return callNative(getFuncName$2('playerGetPlayerState'), null);
+    return callNative(getFuncName$1('playerGetPlayerState'), null);
 }
 // 播放器，播放新的本地文件路径
 function playerPlayNewFile(path) {
-    return callNative(getFuncName$2('playerPlayNewFile'), { path });
+    return callNative(getFuncName$1('playerPlayNewFile'), { path: path });
 }
 // 播放器，设置单片循环模式
 // isLooping: 是否循环播放
 // silentLoop - 静默循环，默认关闭, 开启之后，部分依靠onCompletion重新播放来实现循环播放的方案下：
 //              会无感知重播，即重播时，不会调idle/ preparing/ prepared等开始播放之前的状态）
-function playerSetLooping(isLooping, silentLoop = false) {
-    return callNative(getFuncName$2('playerSetLooping'), { isLooping, silentLoop });
+function playerSetLooping(isLooping, silentLoop) {
+    if (silentLoop === void 0) { silentLoop = false; }
+    return callNative(getFuncName$1('playerSetLooping'), { isLooping: isLooping, silentLoop: silentLoop });
 }
 // 播放器，设置自动屏保锁，即：开始或恢复播放->锁屏保，停止或暂停播放->释放屏保锁 默认关闭
 function playerSetAutoWakeLock(autoWakeLock) {
-    return callNative(getFuncName$2('playerSetAutoWakeLock'), { autoWakeLock });
+    return callNative(getFuncName$1('playerSetAutoWakeLock'), { autoWakeLock: autoWakeLock });
 }
 // 播放器，重新播放
 function playerRePlay() {
-    return callNative(getFuncName$2('playerRePlay'), null);
+    return callNative(getFuncName$1('playerRePlay'), null);
 }
 // 播放器，设置是否自动播放，即 play ready 后音视频自动播放 默认开启
-function playerSetPlayWhenReady(playWhenReady = true) {
-    return callNative(getFuncName$2('playerSetPlayWhenReady'), { playWhenReady });
+function playerSetPlayWhenReady(playWhenReady) {
+    if (playWhenReady === void 0) { playWhenReady = true; }
+    return callNative(getFuncName$1('playerSetPlayWhenReady'), { playWhenReady: playWhenReady });
 }
 // 获取当前设置的播放内核， 有可能会返回 DefaultPlayer
 // 值： DefaultPlayer, MediaPlayer, SocPlayer, ExoPlayer
 function playerGetPlayerCore() {
-    return callNative(getFuncName$2('playerGetPlayerCore'), null);
+    return callNative(getFuncName$1('playerGetPlayerCore'), null);
 }
 // 获取实际的播放内核， 部分内核如：最佳内核，实际上是在各个内核中进行选择，不会返回 DefaultPlayer
 // 值： MediaPlayer, SocPlayer, ExoPlayer
 function playerGetRealPlayerCore() {
-    return callNative(getFuncName$2('playerGetRealPlayerCore'), null);
+    return callNative(getFuncName$1('playerGetRealPlayerCore'), null);
 }
 // 设置视频播放器的事件回调
 // 注意： 使用此回调的话，不用时记得使用 playerDeleteListener 注销事件回调
 function playerSetListener(callback) {
-    return callWithPersistentCallBack(getFuncName$2('playerSetListener'), { callbackId: playerListenerCallbackId }, playerListenerCallbackId, callback);
+    return callWithPersistentCallBack(getFuncName$1('playerSetListener'), { callbackId: playerListenerCallbackId }, playerListenerCallbackId, callback);
 }
 // 注销视频播放器的事件回调
 function playerDeleteListener() {
     deletePersistentCallBack(playerListenerCallbackId);
-    return callNative(getFuncName$2('playerDeleteListener'), null);
+    return callNative(getFuncName$1('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) });
+    return callNative(getFuncName$1('setVideoLayout'), { x: Number(x), y: Number(y), w: Number(width), h: Number(height) });
 }
 // 设置视频窗口是否显示
 function setVideoVisible(show) {
-    return callNative(getFuncName$2('setVideoVisible'), { visible: show });
+    return callNative(getFuncName$1('setVideoVisible'), { visible: show });
 }
 // 设置背景
 // needUpdateColor : 是否更新颜色
@@ -639,143 +751,55 @@ function setVideoVisible(show) {
 // needUpdateImage : 是否更新背景图
 // imageUrl: 背景图的URL
 function setBackground(needUpdateColor, color, needUpdateImage, imageUrl) {
-    return callNative(getFuncName$2('setBackground'), { updateColorFlag: needUpdateColor, updateImageFlag: needUpdateImage, color: Math.floor(color), imageUrl });
+    return callNative(getFuncName$1('setBackground'), { updateColorFlag: needUpdateColor, updateImageFlag: needUpdateImage, color: Math.floor(color), imageUrl: imageUrl });
 }
 // 清除背景
 function clearBackground() {
-    return callNative(getFuncName$2('clearBackground'), null);
+    return callNative(getFuncName$1('clearBackground'), null);
 }
 // 显示语音文本提示条， tips文本中如果带 # 字符，会把 # 字符显示成麦克风图标 
-function showVoiceTipsBar(tips = '') {
-    return callNative(getFuncName$2('showVoiceTipsBar'), { tips });
+function showVoiceTipsBar(tips) {
+    if (tips === void 0) { tips = ''; }
+    return callNative(getFuncName$1('showVoiceTipsBar'), { tips: tips });
 }
 // 隐藏语音文本提示条
 function hideVoiceTipsBar() {
-    return callNative(getFuncName$2('hideVoiceTipsBar'), null);
+    return callNative(getFuncName$1('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
+    startPagAni: startPagAni,
+    stopPagAni: stopPagAni,
+    sendTts: sendTts,
+    stopTts: stopTts,
+    sendStreamTts: sendStreamTts,
+    playerPlayNewUrl: playerPlayNewUrl,
+    playerStop: playerStop,
+    playerPause: playerPause,
+    playerStart: playerStart,
+    playerSeekTo: playerSeekTo,
+    playerHasPrepared: playerHasPrepared,
+    playerIsPlaying: playerIsPlaying,
+    playerGetDuration: playerGetDuration,
+    playerGetCurrentPosition: playerGetCurrentPosition,
+    playerGetPlayerState: playerGetPlayerState,
+    playerPlayNewFile: playerPlayNewFile,
+    playerSetLooping: playerSetLooping,
+    playerSetAutoWakeLock: playerSetAutoWakeLock,
+    playerRePlay: playerRePlay,
+    playerSetPlayWhenReady: playerSetPlayWhenReady,
+    playerGetPlayerCore: playerGetPlayerCore,
+    playerGetRealPlayerCore: playerGetRealPlayerCore,
+    playerSetListener: playerSetListener,
+    playerDeleteListener: playerDeleteListener,
+    setVideoLayout: setVideoLayout,
+    setVideoVisible: setVideoVisible,
+    setBackground: setBackground,
+    clearBackground: clearBackground,
+    showVoiceTipsBar: showVoiceTipsBar,
+    hideVoiceTipsBar: hideVoiceTipsBar,
 };
 
-const moduleName = 'file';
+var moduleName = 'file';
 function getFuncName(name) {
     return moduleName + '_' + name;
 }
@@ -783,16 +807,18 @@ function getFuncName(name) {
 // 参数:
 //    path: 读取文件的路径
 //    base64Flag: 是否以base64编码方式返回, 如果读取文件文件，则应该设置 base64Flag = false，如果读取二进制文件，则应该设置 base64Flag = true
-function readAllContent(path, base64Flag = false) {
-    return callNative(getFuncName('readAllContent'), { path, base64Flag });
+function readAllContent(path, base64Flag) {
+    if (base64Flag === void 0) { base64Flag = false; }
+    return callNative(getFuncName('readAllContent'), { path: path, base64Flag: 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 writeAllContent(path, content, base64Flag) {
+    if (base64Flag === void 0) { base64Flag = false; }
+    return callNative(getFuncName('writeAllContent'), { path: path, content: content, base64Flag: base64Flag });
 }
 // 获取应用基本目录的全路径名
 function getBaseDir() {
@@ -805,169 +831,175 @@ function getCacheDir() {
 // 构建一个临时文件名，返回该文件的绝对路径的全文件路径名
 // 参数：
 //    fileName: 指定临时文件的基本名，如果不指定，会默认随机生成一个文件名
-function makeCacheFile(fileName = '') {
-    return callNative(getFuncName('makeCacheFile'), { fileName });
+function makeCacheFile(fileName) {
+    if (fileName === void 0) { fileName = ''; }
+    return callNative(getFuncName('makeCacheFile'), { fileName: fileName });
 }
 // 构建一个正常文件名，返回该文件的绝对路径的全文件路径名
 // 参数：
 //    fileName: 指定文件的基本名，如果不指定，会默认随机生成一个文件名
-function makeNormalFile(fileName = '') {
-    return callNative(getFuncName('makeNormalFile'), { fileName });
+function makeNormalFile(fileName) {
+    if (fileName === void 0) { fileName = ''; }
+    return callNative(getFuncName('makeNormalFile'), { fileName: fileName });
 }
 // 检测一个文件或者目录是否存在
 // 参数：
 //    path: 指定路径
 function exists(path) {
-    return callNative(getFuncName('exists'), { path });
+    return callNative(getFuncName('exists'), { path: path });
 }
 // 检测一个路径是否为一个普通文件
 // 参数：
 //    path: 指定路径
 function isFile(path) {
-    return callNative(getFuncName('isFile'), { path });
+    return callNative(getFuncName('isFile'), { path: path });
 }
 // 检测一个路径是否为一个目录
 // 参数：
 //    path: 指定路径
 function isDirectory(path) {
-    return callNative(getFuncName('isDirectory'), { path });
+    return callNative(getFuncName('isDirectory'), { path: path });
 }
 // 检测一个路径表示的文件或目录 是否是隐藏的
 // 参数：
 //    path: 指定路径
 function isHidden(path) {
-    return callNative(getFuncName('isHidden'), { path });
+    return callNative(getFuncName('isHidden'), { path: path });
 }
 // 检测一个路径表示的文件或目录 是否可读
 // 参数：
 //    path: 指定路径
 function canRead(path) {
-    return callNative(getFuncName('canRead'), { path });
+    return callNative(getFuncName('canRead'), { path: path });
 }
 // 检测一个路径表示的文件或目录 是否可写
 // 参数：
 //    path: 指定路径
 function canWrite(path) {
-    return callNative(getFuncName('canWrite'), { path });
+    return callNative(getFuncName('canWrite'), { path: path });
 }
 // 检测一个路径表示的文件或目录 是否可执行
 // 参数：
 //    path: 指定路径
 function canExecute(path) {
-    return callNative(getFuncName('canExecute'), { path });
+    return callNative(getFuncName('canExecute'), { path: path });
 }
 // 检测一个路径表示的文件或目录 的最后修改的时间，返回时间戳(1970年开始的秒数)
 // 参数：
 //    path: 指定路径
 function lastModified(path) {
-    return callNative(getFuncName('lastModified'), { path });
+    return callNative(getFuncName('lastModified'), { path: path });
 }
 // 删除文件
 // 参数：
 //    path: 指定路径
 function deleteIt(path) {
-    return callNative(getFuncName('delete'), { path });
+    return callNative(getFuncName('delete'), { path: path });
 }
 // 新建目录
 // 参数：
 //    path: 指定路径
 function mkdir(path) {
-    return callNative(getFuncName('mkdir'), { path });
+    return callNative(getFuncName('mkdir'), { path: path });
 }
 // 新建目录 (如果父目录补存在则一并新建所有尚未存在的父目录)
 // 参数：
 //    path: 指定路径
 function mkdirs(path) {
-    return callNative(getFuncName('mkdirs'), { path });
+    return callNative(getFuncName('mkdirs'), { path: path });
 }
 // 改名
 // 参数：
 //    from: 指定源路径
 //    to:   指定目标路径
 function rename(from, to) {
-    return callNative(getFuncName('rename'), { from, to });
+    return callNative(getFuncName('rename'), { from: from, to: to });
 }
 // 将相对路径的转换为全路径
 // 参数：
 //    path: 指定路径
 function getAbsolutePath(path) {
-    return callNative(getFuncName('getAbsolutePath'), { path });
+    return callNative(getFuncName('getAbsolutePath'), { path: path });
 }
 // 指定路径创建新文件
 // 参数：
 //    path: 指定路径
 function createNewFile(path) {
-    return callNative(getFuncName('createNewFile'), { path });
+    return callNative(getFuncName('createNewFile'), { path: path });
 }
 // 设置可读属性
 // 参数：
 //    path: 指定路径
 //    value: 是否可读
-function setReadable(path, value = true) {
-    return callNative(getFuncName('setReadable'), { path, value });
+function setReadable(path, value) {
+    if (value === void 0) { value = true; }
+    return callNative(getFuncName('setReadable'), { path: path, value: value });
 }
 // 设置可写属性
 // 参数：
 //    path: 指定路径
 //    value: 是否可写
-function setWritable(path, value = true) {
-    return callNative(getFuncName('setWritable'), { path, value });
+function setWritable(path, value) {
+    if (value === void 0) { value = true; }
+    return callNative(getFuncName('setWritable'), { path: path, value: value });
 }
 // 设置可执行属性
 // 参数：
 //    path: 指定路径
 //    value: 是否可执行
-function setExecutable(path, value = true) {
-    return callNative(getFuncName('setExecutable'), { path, value });
+function setExecutable(path, value) {
+    if (value === void 0) { value = true; }
+    return callNative(getFuncName('setExecutable'), { path: path, value: value });
 }
 // 设置文件最后修改的时间
 // 参数：
 //    path: 指定路径
 //    value: 时间戳
-function setLastModified(path, value = 0) {
-    return callNative(getFuncName('setLastModified'), { path, value });
+function setLastModified(path, value) {
+    if (value === void 0) { value = 0; }
+    return callNative(getFuncName('setLastModified'), { path: path, value: value });
 }
 // 读取目录，返回该目录下的文件列表
 // 参数：
 //    path: 指定路径
 function list(path) {
-    return callNative(getFuncName('list'), { path });
+    return callNative(getFuncName('list'), { path: 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
+    readAllContent: readAllContent,
+    writeAllContent: writeAllContent,
+    getBaseDir: getBaseDir,
+    getCacheDir: getCacheDir,
+    makeCacheFile: makeCacheFile,
+    makeNormalFile: makeNormalFile,
+    exists: exists,
+    isFile: isFile,
+    isDirectory: isDirectory,
+    isHidden: isHidden,
+    canRead: canRead,
+    canWrite: canWrite,
+    canExecute: canExecute,
+    lastModified: lastModified,
+    deleteIt: deleteIt,
+    mkdir: mkdir,
+    mkdirs: mkdirs,
+    rename: rename,
+    getAbsolutePath: getAbsolutePath,
+    createNewFile: createNewFile,
+    setReadable: setReadable,
+    setWritable: setWritable,
+    setExecutable: setExecutable,
+    setLastModified: setLastModified,
+    list: list
 };
 
-window['apkNativeCall'] = function apkNativeCall(str) {
-    let res = null;
+window['appNativeCall'] = function apkNativeCall(str) {
+    var res = null;
     //console.log('str1=' + str);
     try {
-        const dec1 = atob(str);
+        var dec1 = atob(str);
         //console.log('dec1=' + dec1);
-        const dec2 = decodeURIComponent(dec1);
+        var dec2 = decodeURIComponent(dec1);
         //console.log('dec2=' + dec2);
         res = JSON.parse(dec2);
         //console.log('data type = ' + typeof(res.data));
@@ -994,14 +1026,14 @@ function isRunInAppBrowser() {
     return window['_liteNativeApi'] ? true : false;
 }
 var index = {
-    network,
-    app,
-    system,
-    storage,
-    androidView,
-    audio,
-    file,
-    isRunInAppBrowser
+    network: network,
+    app: app,
+    system: system,
+    storage: storage,
+    androidView: androidView,
+    audio: audio,
+    file: file,
+    isRunInAppBrowser: isRunInAppBrowser
 };
 
 export { index as default, isRunInAppBrowser, setAppCommandCallback, unsetAppCommandCallback };

package/dist/index.d.ts

@@ -20,7 +20,6 @@ declare const _default: {
         exitPage: typeof import("./app").exitPage;
         moveTaskToBack: typeof import("./app").moveTaskToBack;
         getUserInfo: typeof import("./app").getUserInfo;
-        setUserLogout: typeof import("./app").setUserLogout;
         getAppList: typeof import("./app").getAppList;
         getAppInfo: typeof import("./app").getAppInfo;
         addLocalBroadcastHook: typeof import("./app").addLocalBroadcastHook;
@@ -39,6 +38,8 @@ declare const _default: {
         getDeviceInfo: typeof import("./system").getDeviceInfo;
         getProperty: typeof import("./system").getProperty;
         getLocation: typeof import("./system").getLocation;
+        checkApi: typeof import("./system").checkApi;
+        getDisplayInfo: typeof import("./system").getDisplayInfo;
     };
     storage: {
         setKey: typeof import("./storage").setKey;

package/dist/system/index.d.ts

@@ -8,6 +8,8 @@ export declare function enableSystemKey(params: SystemKeyParam | null): Promise<
 export declare function getDeviceInfo(): Promise<any>;
 export declare function getProperty(key: string): Promise<any>;
 export declare function getLocation(): Promise<any>;
+export declare function checkApi(apiName: string): Promise<any>;
+export declare function getDisplayInfo(): Promise<any>;
 declare const _default: {
     getSdkVersion: typeof getSdkVersion;
     addLifeCycleHook: typeof addLifeCycleHook;
@@ -16,5 +18,7 @@ declare const _default: {
     getDeviceInfo: typeof getDeviceInfo;
     getProperty: typeof getProperty;
     getLocation: typeof getLocation;
+    checkApi: typeof checkApi;
+    getDisplayInfo: typeof getDisplayInfo;
 };
 export default _default;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@ccos/ccsdk-lite",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "a jssdk for coocaa tv-system",
+  "type": "module",
   "main": "dist/bundle.js",
   "module": "dist/bundle.js",
   "types": "dist/index.d.ts",