@jolibox/implement 1.1.4-beta.4

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.game_id}`, {
+      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.game_id;
+    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.game_id;
+    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.game_id;
+    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 '';
+  }
+}

package/src/native/api/task.ts

@@ -0,0 +1,267 @@
+import { createCommands } from '@jolibox/common';
+
+import { createAPI, registerCanIUse, t } from './base';
+import { taskTracker } from '../report';
+
+const commands = createCommands();
+
+const onLevelFinished = createAPI('levelFinished', {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      result: t.boolean(),
+      duration: t.number()
+    })
+  ),
+  implement: async (levelId, parmas) => {
+    const { result, duration } = parmas;
+    const tasks = [];
+    tasks.push(
+      taskTracker.reportToNative({
+        event: 'LEVEL_FINISHED',
+        params: {
+          levelId,
+          result,
+          duration
+        }
+      })
+    );
+
+    tasks.push(
+      taskTracker.reporter({
+        event: 'COMPLETE_QUEST'
+      })
+    );
+    await Promise.all(tasks);
+  }
+});
+
+const onTaskFinished = createAPI('taskFinished', {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      duration: t.number()
+    })
+  ),
+  implement: async (taskId, params) => {
+    const { duration } = params;
+    return await taskTracker.reportToNative({
+      event: 'TASK_FINISHED',
+      params: {
+        duration,
+        taskId
+      }
+    });
+  }
+});
+
+const onLevelUpgrade = createAPI('levelUpgrade', {
+  paramsSchema: t.tuple(t.string(), t.string()),
+  implement: async (levelId, name) => {
+    const tasks = [];
+    tasks.push(
+      taskTracker.reporter({
+        event: 'COMPLETE_QUEST'
+      })
+    );
+    tasks.push(
+      taskTracker.reportToNative({
+        event: 'LEVEL_UPGRADE',
+        params: {
+          name,
+          levelId
+        }
+      })
+    );
+    await Promise.all(tasks);
+  }
+});
+
+const onHistoryUserLevel = createAPI('onHistoryUserLevel', {
+  paramsSchema: t.tuple(t.number()),
+  implement: async (level) => {
+    return await taskTracker.reportToNative({
+      event: 'HISTORY_USER_LEVEL',
+      params: {
+        level
+      }
+    });
+  }
+});
+
+const onHistoryUserScore = createAPI('onHistoryUserScore', {
+  paramsSchema: t.tuple(t.number()),
+  implement: async (score) => {
+    return await taskTracker.reportToNative({
+      event: 'HISTORY_USER_SCORE',
+      params: {
+        score
+      }
+    });
+  }
+});
+
+const onTaskEvent = createAPI('taskEvent', {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      tools: t
+        .array(
+          t.object({
+            id: t.string(),
+            name: t.string(),
+            count: t.number(),
+            description: t.string().optional(),
+            price: t
+              .object({
+                amount: t.number(),
+                unit: t.string()
+              })
+              .optional()
+          })
+        )
+        .optional(),
+      awards: t
+        .array(
+          t.object({
+            id: t.string(),
+            name: t.string()
+          })
+        )
+        .optional()
+    })
+  ),
+  implement: async (taskId, params) => {
+    const tasks = [];
+    tasks.push(
+      taskTracker.reportToNative({
+        event: 'TASK_EVENT',
+        params: {
+          taskId,
+          ...params
+        }
+      })
+    );
+    // 使用了道具，上报任务
+    if (params.tools?.length ?? 0 > 0) {
+      tasks.push(
+        taskTracker.reporter({
+          event: 'USE_GAME_ITEM'
+        })
+      );
+    }
+    await Promise.all(tasks);
+  }
+});
+
+const onTaskPayment = createAPI('taskPayment', {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      id: t.string(),
+      amount: t.number(),
+      unit: t.string()
+    })
+  ),
+  implement: async (taskId, params) => {
+    const tasks = [];
+    tasks.push(
+      taskTracker.reportToNative({
+        event: 'TASK_PAYMENT',
+        params: {
+          taskId,
+          params
+        }
+      })
+    );
+    tasks.push(
+      taskTracker.reporter({
+        event: 'IN_GAME_PURCHASES'
+      })
+    );
+    await Promise.all(tasks);
+  }
+});
+
+commands.registerCommand('TaskTrackerSDK.levelFinished', onLevelFinished);
+commands.registerCommand('TaskTrackerSDK.taskFinished', onTaskFinished);
+commands.registerCommand('TaskTrackerSDK.levelUpgrade', onLevelUpgrade);
+commands.registerCommand('TaskTrackerSDK.historyUserLevel', onHistoryUserLevel);
+commands.registerCommand('TaskTrackerSDK.historyUserScore', onHistoryUserScore);
+commands.registerCommand('TaskTrackerSDK.taskEvent', onTaskEvent);
+commands.registerCommand('TaskTrackerSDK.taskPayment', onTaskPayment);
+
+registerCanIUse('TaskTrackerSDK.onLevelFinished', {
+  version: '1.0.0',
+  properties: {
+    levelId: '1.0.0',
+    params: {
+      result: '1.0.0',
+      duration: '1.0.0'
+    }
+  }
+});
+
+registerCanIUse('TaskTrackerSDK.onTaskFinished', {
+  version: '1.0.0',
+  properties: {
+    taskId: '1.0.0',
+    duration: '1.0.0'
+  }
+});
+
+registerCanIUse('TaskTrackerSDK.onLevelUpgrade', {
+  version: '1.0.0',
+  properties: {
+    levelId: '1.0.0',
+    name: '1.0.0'
+  }
+});
+
+registerCanIUse('TaskTrackerSDK.onHistoryUserLevel', {
+  version: '1.0.0',
+  properties: {
+    level: '1.0.0'
+  }
+});
+
+registerCanIUse('TaskTrackerSDK.onHistoryUserScore', {
+  version: '1.0.0',
+  properties: {
+    score: '1.0.0'
+  }
+});
+
+registerCanIUse('TaskTrackerSDK.onTaskEvent', {
+  version: '1.0.0',
+  properties: {
+    taskId: '1.0.0',
+    params: {
+      tools: {
+        id: '1.0.0',
+        name: '1.0.0',
+        count: '1.0.0',
+        description: '1.0.0',
+        price: {
+          amount: '1.0.0',
+          unit: '1.0.0'
+        }
+      },
+      awards: {
+        id: '1.0.0',
+        name: '1.0.0'
+      }
+    }
+  }
+});
+
+registerCanIUse('TaskTrackerSDK.onTaskPayment', {
+  version: '1.0.0',
+  properties: {
+    taskId: '1.0.0',
+    params: {
+      amount: '1.0.0',
+      unit: '1.0.0'
+    }
+  }
+});

package/src/native/bootstrap/bridge.ts

@@ -0,0 +1,59 @@
+import { createBridge, On } from '../js-bridge';
+
+import { joliboxJSCore, initMessagePort } from '../js-core';
+
+import { formatErrorCode } from '../../common/report/errors';
+import { AnyFunction } from '@jolibox/types';
+import { InternalJSCoreNotFoundError } from '@jolibox/common';
+
+declare const globalThis: {
+  joliboxJSBridge?: {
+    callHandler: AnyFunction;
+    invokeHandler: AnyFunction;
+    subscribeHandler: AnyFunction;
+  };
+};
+
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+const jsCore = joliboxJSCore!;
+
+if (!jsCore) {
+  throw new InternalJSCoreNotFoundError('No joliboxJScore is found, native bridge not found.');
+}
+
+initMessagePort();
+
+const core: jsb.JSCore = {
+  ...jsCore
+  // publish(event: string, params: Record<string, unknown>, webviewIds: number[]) {
+  //   if (messagePort) {
+  //     messagePort.publish(event, params);
+  //     return;
+  //   }
+  //   jsCore.publish(event, params, webviewIds);
+  // }
+};
+
+const bridge = createBridge(core);
+
+const { invokeHandler } = bridge;
+
+export const { applyNative, invokeNative, onNative, offNative, subscribeHandler } = bridge;
+
+export const onNativeWithError: On = (event, handler) => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  onNative(event as keyof jsb.service.NativeEventMap, (...rest: any) => {
+    if (rest[0]?.errorCode) {
+      rest[0].errorCode = formatErrorCode(event, rest[0].errorCode);
+    }
+    handler(...rest);
+  });
+};
+
+globalThis.joliboxJSBridge = {
+  callHandler: invokeHandler,
+  invokeHandler,
+  subscribeHandler
+};
+
+export { RuntimeLoader } from '../js-core';

package/src/native/bootstrap/index.ts

@@ -0,0 +1,58 @@
+import { onNative, RuntimeLoader } from './bridge';
+import { joliboxJSCore } from '../js-core';
+import { HostUserInfo } from '@/common/context/types';
+import { context } from '@/common/context';
+import { hostEmitter } from '@jolibox/common';
+import { taskTracker, track } from '../report';
+
+RuntimeLoader.onReady(() => {
+  // TODO: merge some env config
+});
+
+RuntimeLoader.doExit(() => {
+  //埋点上报
+  track('onBeforeExit', {
+    timestamp: Date.now()
+  });
+  return false; // 默认不打断退出
+});
+
+/**
+ * The DOMContentLoaded event might be triggered very early,
+ * so the global loaded listener should be executed during the bootstrap process.
+ */
+function addWebviewReadyListener() {
+  hostEmitter.on('onDocumentReady', () => {
+    joliboxJSCore?.onDocumentReady(window.location.href);
+    track('onDocumentReady', {
+      start_timestamp,
+      timestamp: Date.now()
+    });
+  });
+}
+
+function addGameServiceReadyListener() {
+  onNative('onJoliboxServiceReady', ({ runtimeInfo, loadDuration }) => {
+    runtimeInfo && context.onEnvConfigChanged({ hostUserInfo: runtimeInfo });
+    hostEmitter.emit('LifecycleEvent.onReady', {
+      ...(context.hostUserInfo ? context.hostUserInfo : { isLogin: false })
+    });
+    track('joliboxServiceReady', {
+      start_timestamp,
+      timestamp: Date.now()
+    });
+
+    // 任务上报
+    taskTracker.start(loadDuration);
+  });
+
+  onNative('onBeforeExit', ({ uuid }) => {
+    joliboxJSCore?.doExit(uuid);
+  });
+}
+let start_timestamp: number;
+export function config(): void {
+  start_timestamp = Date.now();
+  addGameServiceReadyListener();
+  addWebviewReadyListener();
+}

package/src/native/js-bridge/const.ts

@@ -0,0 +1,11 @@
+export const CUSTOM_EVENT_PREFIX = 'custom_event_';
+
+export const HOST_EVENT_PREFIX = 'host_event_';
+
+//TODO: add buffer supported method
+export const BUFFER_METHODS: string[] = [];
+
+// TODO: add method cannot invoke background
+export const BACKGROUND_FORBIDDEN_METHODS: string[] = [];
+
+export const SYNC_METHODS: string[] = ['env', 'createRequestTask', 'login'];

package/src/native/js-bridge/index.ts

@@ -0,0 +1,2 @@
+export { createBridge } from './js-bridge';
+export * from './types';