@jolibox/implement 1.1.4-beta.10

package/src/native/api/lifecycle.ts

@@ -0,0 +1,76 @@
+import { BaseError, createCommands, wrapUserFunction, hostEmitter } from '@jolibox/common';
+import { createAPI, createSyncAPI, registerCanIUse, t } from './base';
+import { reportError } from '@/common/report/errors/report';
+import { applyNative, onNative } from '../bootstrap/bridge';
+import { nativeTaskEmitter } from '../report';
+
+const EXIT_GAME = 'exitGame';
+const ON_READY = 'onReady';
+const ON_SHOW = 'onJoliboxShow';
+const ON_HIDE = 'onJoliboxHide';
+
+const commands = createCommands();
+
+const safeCallbackWrapper = wrapUserFunction(reportError as (err: Error | BaseError) => void);
+const exitGame = createAPI(EXIT_GAME, {
+  paramsSchema: t.tuple(t.function()),
+  implement: async (onBeforeExit: () => void) => {
+    const safeCallback = safeCallbackWrapper(onBeforeExit);
+    // 集中上报
+    safeCallback.call(this);
+    await applyNative('exitAppAsync');
+  }
+});
+
+const onShow = createSyncAPI(ON_SHOW, {
+  paramsSchema: t.tuple(t.function()),
+  implement(callback) {
+    const safeCallback = safeCallbackWrapper(callback);
+    onNative('onJoliboxEnterForeground', () => {
+      safeCallback.call(this);
+      nativeTaskEmitter.emit('visible', true);
+    });
+  }
+});
+
+const onHide = createSyncAPI(ON_HIDE, {
+  paramsSchema: t.tuple(t.function()),
+  implement(callback) {
+    const safeCallback = safeCallbackWrapper(callback);
+    onNative('onJoliboxEnterBackground', () => {
+      safeCallback.call(this);
+      nativeTaskEmitter.emit('visible', false);
+    });
+  }
+});
+
+const onReadyHandler = createSyncAPI(ON_READY, {
+  paramsSchema: t.tuple(t.function()),
+  implement(callback) {
+    const safeCallback = safeCallbackWrapper(callback);
+    hostEmitter.on('LifecycleEvent.onReady', (info) => {
+      safeCallback(info);
+    });
+  }
+});
+
+commands.registerCommand('LifecycleSDK.exit', exitGame);
+commands.registerCommand('LifecycleSDK.onReady', onReadyHandler);
+commands.registerCommand('LifecycleSDK.onJoliboxShow', onShow);
+commands.registerCommand('LifecycleSDK.onJoliboxHide', onHide);
+
+registerCanIUse('lifeCycle.exit', {
+  version: '1.0.0' // mock
+});
+
+registerCanIUse('lifeCycle.onReady', {
+  version: '1.0.0' // mock
+});
+
+registerCanIUse('lifeCycle.onJoliboxShow', {
+  version: '1.0.0' // mock
+});
+
+registerCanIUse('lifeCycle.onJoliboxHide', {
+  version: '1.0.0' // mock
+});

package/src/native/api/login.ts

@@ -0,0 +1,73 @@
+import { context } from '@/common/context';
+import { applyNative, invokeNative, onNative } from '../bootstrap/bridge';
+import { createAPI, t, registerCanIUse } from './base';
+import { APIError, createCommands, Deferred, hostEmitter } from '@jolibox/common';
+import { createAPIError } from '@/common/report/errors';
+
+registerCanIUse('login', {
+  version: '1.0.0',
+  properties: {
+    force: '1.0.0'
+  },
+  success: {
+    errMsg: '1.0.0',
+    code: '1.0.0',
+    token: '1.0.0',
+    isLogin: '1.0.0'
+  }
+});
+registerCanIUse('checkSession', {
+  version: '1.0.0',
+  success: {
+    errMsg: '1.0.0'
+  }
+});
+
+const login = createAPI('login', {
+  async implement() {
+    const {
+      data: { isLogin }
+    } = await applyNative('checkLoginAsync');
+    if (isLogin) {
+      return { isLogin: true, token: context.hostUserInfo?.token };
+    }
+    onNative('onLoginStateChange', ({ isLogin, token, uuid }) => {
+      if (uuid == loginUUID) {
+        resolve({ isLogin, token });
+      }
+    });
+    const res = invokeNative('loginSync');
+
+    const {
+      data: { uuid: loginUUID }
+    } = res;
+    if (!loginUUID) {
+      throw createAPIError({
+        code: -1,
+        msg: 'login failed'
+      });
+    }
+    const { promise, resolve } = new Deferred<{ isLogin: boolean; token?: string }>();
+
+    const loginRes = await promise;
+    context.onEnvConfigChanged({ hostUserInfo: loginRes });
+    hostEmitter.emit('onLoginComplete', loginRes);
+
+    return loginRes;
+  }
+});
+
+const checkSession = createAPI('checkSession', {
+  async implement() {
+    const {
+      data: { isLogin }
+    } = await applyNative('checkLoginAsync');
+    return {
+      isLogin
+    };
+  }
+});
+
+const commands = createCommands();
+commands.registerCommand('API.login', login);
+commands.registerCommand('API.checkSession', checkSession);

package/src/native/api/request.ts

@@ -0,0 +1,154 @@
+import { createAPIError } from '@/common/report/errors';
+import { createFetch } from '../network/create-fetch';
+import { createAPI, registerCanIUse, t } from './base';
+import { dirtyURL, normalizeHeader, normalizeMethod, normalizeTimeout } from '../network/utils';
+import { BaseError, createCommands, Deferred, wrapUserFunction } from '@jolibox/common';
+import { AnyFunction, ResponseType } from '@jolibox/types';
+import { reportError } from '@/common/report/errors/report';
+import { FetchOptions } from '../network/types';
+
+const LIMIT = 15;
+
+const publicFetch = createFetch('createRequestTaskSync', 'operateRequestTaskSync', {
+  type: 'public'
+});
+
+/** current active count */
+let activeCount = 0;
+
+const deferQueue: AnyFunction[] = [];
+
+const safeCallbackWrapper = wrapUserFunction(reportError as (err: Error | BaseError) => void);
+
+const remove = <T>(array: T[], predicate: (item: T) => boolean) => {
+  const removedElements = array.filter(predicate);
+
+  const remainingElements = array.filter((item) => !predicate(item));
+  array.length = 0;
+  array.push(...remainingElements);
+
+  return removedElements;
+};
+
+const request = (_params: unknown) => {
+  const deferred = new Deferred<{
+    code: ResponseType;
+    data?: string | JSON | ArrayBuffer | undefined;
+    message: string;
+  }>();
+
+  let teardown = () => {
+    // noop
+  };
+
+  const _request = createAPI('request', {
+    paramsSchema: t.tuple(
+      t.object({
+        url: t.string(),
+        method: t.string(),
+        header: t.object(),
+        data: t.object().optional(),
+        query: t.object().optional(),
+        dataType: t.string().default('json'),
+        responseType: t.string().default('text'),
+        enableCache: t.boolean().default(false),
+        appendHostCookie: t.boolean().default(true),
+        timeout: t.number().default(30000),
+        success: t.function(),
+        fail: t.function()
+      })
+    ),
+    implement(params) {
+      const action = async () => {
+        const failCallback = safeCallbackWrapper(params.fail);
+        try {
+          activeCount += 1;
+
+          // 在 action 执行前, 如果用户就调用了 abort 的话就会命中该逻辑
+          if (deferred.state !== 'pending') {
+            return;
+          }
+          const { data, dataType, responseType, enableCache, appendHostCookie } = params;
+
+          const header = normalizeHeader(params.header);
+          const method = normalizeMethod(params.method);
+          const timeout = normalizeTimeout(params.timeout);
+          const url = dirtyURL(params.url, method, data);
+          const successCallback = safeCallbackWrapper(params.success);
+
+          const _params = Object.assign({}, params, {
+            method,
+            header,
+            data: method === 'GET' || method === 'HEAD' ? undefined : data, // GET HEAD 请求不需要 data 参数
+            enableCache,
+            query: params.query ?? ({} as Record<string, string>),
+            dataType,
+            responseType,
+            appendHostCookie
+          }) as FetchOptions;
+
+          if (timeout) _params['timeout'] = timeout;
+
+          const task = publicFetch<string | ArrayBuffer | JSON>(url, _params);
+
+          {
+            const { response } = await task;
+            const { code, data, message } = response;
+
+            deferred.resolve({
+              code: (code ?? 'SUCCESS') as ResponseType,
+              data,
+              message: message ?? 'request:ok'
+            });
+
+            successCallback({
+              code: 'SUCCESS',
+              message: 'request:ok',
+              data
+            });
+          }
+        } catch (err) {
+          deferred.reject(err as Error);
+          failCallback({
+            code: 'FAILURE',
+            message: 'httpRequst: failed'
+          });
+        } finally {
+          activeCount -= 1;
+          deferQueue.shift()?.();
+        }
+      };
+
+      if (activeCount >= LIMIT) {
+        teardown = () => {
+          remove(deferQueue, (i) => i === action);
+        };
+        deferQueue.push(action);
+      } else {
+        void action();
+      }
+
+      return deferred.promise;
+    }
+  });
+
+  _request(_params);
+
+  return {
+    /**
+     *  1. requesting...
+     *  2. not in deferred
+     */
+    abort() {
+      deferred.reject(createAPIError({ code: -1, msg: 'request:fail abort' }));
+      teardown();
+    }
+  };
+};
+
+const commands = createCommands();
+
+commands.registerCommand('HttpSDK.request', request);
+registerCanIUse('request', {
+  version: '1.0.0'
+});

package/src/native/api/storage.ts

@@ -0,0 +1,287 @@
+import { createAPI, createSyncAPI, registerCanIUse, t } from './base';
+import { applyNative, invokeNative } from '../bootstrap/bridge';
+import { createCommands } from '@jolibox/common';
+import { innerFetch as fetch } from '../network';
+import { context } from '@/common/context';
+import { API_CODE, StandardResponse, StorageResponse } from '@jolibox/types';
+
+const commands = createCommands();
+
+const getStorage = createAPI('getLocalStorage', {
+  paramsSchema: t.tuple(t.string()),
+  async implement(key) {
+    const { response } = await fetch<
+      StorageResponse<{
+        key: string;
+        value: string | null;
+      }>
+    >(`/api/games/user-storage/${context.mpId}`, {
+      method: 'GET',
+      responseType: 'json',
+      appendHostCookie: true,
+      query: {
+        key
+      }
+    });
+    const {
+      data: { code, message, data: originData }
+    } = await response;
+
+    if (code === 'SUCCESS') {
+      return {
+        code: code as API_CODE,
+        message,
+        data: originData?.value
+      };
+    }
+
+    try {
+      const {
+        data: { data, dataType }
+      } = await applyNative('getLocalStorageAsync', { key });
+      const parsedData = parse(data, dataType);
+      return {
+        code,
+        message: `${message}. fallback to native`,
+        data: parsedData
+      };
+    } catch (error) {
+      return {
+        code: 'INTERNAL_ERROR',
+        message: '[Jolibox SDK] get local storage failed',
+        data: null
+      };
+    }
+  }
+});
+
+commands.registerCommand('StorageSDK.getItem', getStorage);
+
+registerCanIUse('storage.getItem', {
+  version: '1.0.0',
+  properties: {
+    key: '1.0.0',
+    value: '1.0.0'
+  }
+});
+
+const setStorage = createAPI('setStorage', {
+  paramsSchema: t.tuple(t.string(), t.or(t.string(), t.boolean(), t.number())),
+  async implement(key, value) {
+    const gameId = context.mpId;
+    const valueToStore = typeof value == 'string' ? value : String(value);
+    const { response } = await fetch<StorageResponse<void>>(`/api/games/user-storage/${gameId}`, {
+      method: 'POST',
+      responseType: 'json',
+      appendHostCookie: true,
+      data: {
+        key,
+        value: valueToStore
+      }
+    });
+
+    const {
+      data: { code, message }
+    } = response;
+    const dataType = getType(value);
+    const data = stringify(value, dataType);
+    // 同步备份
+    await applyNative('setLocalStorageAsync', {
+      key,
+      data,
+      dataType
+    });
+
+    if (code == 'SUCCESS') {
+      return {
+        code,
+        message
+      };
+    } else {
+      return {
+        code,
+        message: `${message}. fallback to native`
+      } as StandardResponse<void>;
+    }
+  }
+});
+
+commands.registerCommand('StorageSDK.setItem', setStorage);
+
+registerCanIUse('storage.setItem', {
+  version: '1.0.0',
+  properties: {
+    key: '1.0.0',
+    value: '1.0.0'
+  }
+});
+
+/**
+ * 移除指定key
+ */
+export const removeStorage = createAPI('removeStorage', {
+  paramsSchema: t.tuple(t.string()),
+  async implement(key) {
+    const gameId = context.mpId;
+    const { response } = await fetch<StorageResponse<void>>(`/api/games/user-storage/${gameId}/remove`, {
+      method: 'POST',
+      responseType: 'json',
+      appendHostCookie: true,
+      data: {
+        key
+      }
+    });
+
+    const {
+      data: { code, message }
+    } = response;
+    await applyNative('removeLocalStorageAsync', { key });
+    if (code === 'SUCCESS') {
+      return {
+        code,
+        message
+      };
+    } else {
+      return {
+        code,
+        message: '[Jolibox SDK] remove item succ'
+      } as StandardResponse<void>;
+    }
+  }
+});
+
+commands.registerCommand('StorageSDK.removeItem', removeStorage);
+
+registerCanIUse('storage.removeItem', {
+  version: '1.0.0',
+  properties: {
+    key: '1.0.0'
+  }
+});
+
+/**
+ * 清理本地数据缓存
+ */
+const clearStorage = createAPI('clearStorage', {
+  async implement() {
+    const gameId = context.mpId;
+    const { response } = await fetch<StorageResponse<void>>(`/api/games/user-storage/${gameId}/clear`, {
+      method: 'POST',
+      appendHostCookie: true
+    });
+    applyNative('clearLocalStorageAsync');
+    const {
+      data: { code, message }
+    } = response;
+    if (code === 'SUCCESS') {
+      return {
+        code,
+        message
+      };
+    }
+
+    return {
+      code,
+      message: `${message}.fallback to native`
+    } as StandardResponse<void>;
+  }
+});
+
+commands.registerCommand('StorageSDK.clear', clearStorage);
+
+registerCanIUse('storage.clear', {
+  version: '1.0.0'
+});
+
+/**
+ * 异步获取当前storage的相关信息
+ */
+export const getStorageInfo = createAPI('getStorageInfo', {
+  async implement() {
+    const { data } = await applyNative('getStorageInfoAsync');
+    return data;
+  }
+});
+
+registerCanIUse('getStorageInfo', {
+  version: '1.0.0',
+  success: {
+    keys: '1.0.0', // string[] 本地数据缓存中的所有键名列表，如本地数据则返回空数组
+    currentSize: '1.0.0', // number 当前占用的空间大小，以 KB 为单位
+    limitSize: '1.0.0' // number 存储空间上限，以 KB 为单位，一般来说会返回 10240
+  }
+});
+
+/**
+ * 同步获取当前storage的相关信息
+ */
+export const getStorageInfoSync = createSyncAPI('getStorageInfoSync', {
+  implement() {
+    return invokeNative('getStorageInfoSync');
+  }
+});
+
+const DATA_TYPE = [
+  'string',
+  'number',
+  'boolean',
+  'object',
+  '' // 表示不支持的类型
+] as const;
+
+type DataType = typeof DATA_TYPE[number];
+
+function getType(data: unknown): DataType {
+  const type = Object.prototype.toString
+    .call(data)
+    .split(' ')[1]
+    .split(']')[0]
+    .toLocaleLowerCase() as DataType;
+
+  if (DATA_TYPE.includes(type)) {
+    return type;
+  }
+  return '';
+}
+
+/**
+ * 解析数据
+ */
+function parse(str: string, type: string) {
+  try {
+    switch (type) {
+      case 'string':
+        return str;
+      case 'object':
+        return JSON.parse(str);
+      case 'number':
+        return parseFloat(str);
+      case 'boolean':
+        return str === 'true';
+      default:
+        return '';
+    }
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * 序列化数据
+ */
+function stringify(data: unknown, type: DataType) {
+  try {
+    switch (type) {
+      case 'string':
+      case 'number':
+      case 'boolean':
+        return `${data}`;
+      case 'object':
+        return JSON.stringify(data);
+      default:
+        return '';
+    }
+  } catch {
+    return '';
+  }
+}