@jolibox/implement 1.1.4-beta.10

package/src/native/api/task.ts

@@ -0,0 +1,227 @@
+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.tracker('LevelFinished', {
+        levelId,
+        result,
+        duration
+      })
+    );
+
+    tasks.push(
+      taskTracker.reporter({
+        event: 'COMPLETE_GAME_LEVEL'
+      })
+    );
+    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: 'TaskFinished',
+      params: {
+        duration,
+        taskId
+      }
+    });
+  }
+});
+
+const onLevelUpgrade = createAPI('levelUpgrade', {
+  paramsSchema: t.tuple(t.string(), t.string()),
+  implement: async (levelId, name) => {
+    const tasks = [];
+    tasks.push(
+      taskTracker.reportToNative({
+        event: 'LevelUpgrade',
+        params: {
+          name,
+          levelId
+        }
+      })
+    );
+    await Promise.all(tasks);
+  }
+});
+
+const onHistoryUserLevel = createAPI('onHistoryUserLevel', {
+  paramsSchema: t.tuple(t.number()),
+  implement: async (level) => {
+    return await taskTracker.reportToNative({
+      event: 'HistoryUserLevel',
+      params: {
+        level
+      }
+    });
+  }
+});
+
+const onHistoryUserScore = createAPI('onHistoryUserScore', {
+  paramsSchema: t.tuple(t.number()),
+  implement: async (score) => {
+    return await taskTracker.reportToNative({
+      event: 'HistoryUserScore',
+      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: 'TaskEvent',
+        params: {
+          taskId,
+          ...params
+        }
+      })
+    );
+    // 使用了道具，上报任务
+    if (params.tools?.length ?? 0 > 0) {
+      tasks.push(
+        taskTracker.reporter({
+          event: 'USE_GAME_ITEM'
+        })
+      );
+      tasks.push(
+        taskTracker.reportToNative({
+          event: 'UseGameItem',
+          params: {
+            taskId,
+            ...params
+          }
+        })
+      );
+    }
+    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);
+
+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'
+      }
+    }
+  }
+});

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,59 @@
+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()
+  });
+  taskTracker.close(Date.now() - start_timestamp);
+  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';

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

@@ -0,0 +1,210 @@
+import { pack, unpack } from './utils';
+import { Deferred, isObject, isPromiseLike, InternalApplyNativeError, logger } from '@jolibox/common';
+import { formatErrorCode } from '../../common/report/errors';
+import { BACKGROUND_FORBIDDEN_METHODS, BUFFER_METHODS, SYNC_METHODS } from './const';
+import { createReportInvokeMetrics } from './report';
+import { InvokeHandler, On } from './types';
+
+import { AnyFunction } from '@jolibox/types';
+
+interface Invokes {
+  /** 暴露给宿主, 触发调用的方法 */
+  invokeHandler: InvokeHandler;
+  /** 基础库内部, 调用宿主的方法, 返回 native 返回对象 */
+  invokeNative: (method: string, args?: Record<string, unknown>, webviewId?: number) => any;
+  /** 基础库内部, 调用宿主的方法, 会根据 errMsg throwError */
+  applyNative: (method: string, args?: Record<string, unknown>, webviewId?: number) => any;
+}
+
+type Response = {
+  errMsg: string;
+  errNo?: number;
+  __timing?: {
+    receiveJSInvoke: number;
+    invokeCallback: number;
+  };
+} & Record<string, unknown>;
+
+// 后台期间积压的请求
+const asyncInvokes: {
+  method: string;
+  args?: Record<string, unknown>;
+  resolve: AnyFunction;
+}[] = [];
+
+//TODO: support arrayBuffer
+const NOT_SUPPORT_ARRAY_BUFFER = false;
+
+export function createInvoke(jsCore: jsb.JSCore, onNative: On): Invokes {
+  let resolveId = 0;
+  let IS_FOREGROUND = true;
+
+  const resolveMap = new Map<number, AnyFunction>();
+  const reportInvokeMetrics = createReportInvokeMetrics(jsCore, onNative);
+
+  onNative('onJoliboxEnterBackground', () => {
+    IS_FOREGROUND = false;
+  });
+
+  onNative('onJoliboxEnterForeground', () => {
+    IS_FOREGROUND = true;
+    // 从后台进入前台后, 处理之前在后台挤压的任务
+    asyncInvokes.forEach(async ({ method, args, resolve }) => {
+      const res = await invokeNative(method, args);
+      resolve(res);
+    });
+    // 清空积压
+    asyncInvokes.length = 0;
+  });
+
+  const invokeHandler: InvokeHandler = (resolveId, data): void => {
+    /**
+     * Android resolveId 是 `string`
+     * iOS 上待确认, IDE 上是 `number`
+     */
+    logger.info('----resolveId', resolveId, data);
+    const resolve = resolveMap.get(Number(resolveId));
+    if (!resolve) return;
+    const response = unpack(data);
+    resolve(response);
+    resolveMap.delete(Number(resolveId));
+  };
+
+  const invokeNative = (
+    method: string,
+    args?: Record<string, unknown>
+  ): Record<string, unknown> | Promise<Record<string, unknown>> => {
+    const startTime = Date.now();
+    const isForeground = `${IS_FOREGROUND}`;
+
+    resolveId += 1;
+
+    const deferred = new Deferred<Response>();
+    resolveMap.set(resolveId, deferred.resolve);
+
+    if (!IS_FOREGROUND && BACKGROUND_FORBIDDEN_METHODS.includes(method)) {
+      // `FOREGROUND_FORBIDDEN_EVENTS` all async API
+      return new Promise<Record<string, unknown>>((resolve) => {
+        asyncInvokes.push({ method, args, resolve });
+      });
+    }
+
+    const basicReportParam = {
+      method,
+      startTime,
+      args,
+      isForeground
+    };
+
+    const invokeReportParam = {
+      ...basicReportParam,
+      invokeType: 'js-bridge'
+    } as const;
+
+    const useArrayBuffer = !NOT_SUPPORT_ARRAY_BUFFER && BUFFER_METHODS.includes(method);
+
+    const payload = pack(args, useArrayBuffer);
+    const params = useArrayBuffer ? payload : JSON.stringify(payload);
+
+    /** 调用结果 */
+    let response;
+
+    if (method.endsWith('Sync') || SYNC_METHODS.includes(method)) {
+      response = jsCore.call?.(method, payload, resolveId);
+    } else {
+      if (typeof params === 'string') {
+        console.log('-----params', method, resolveId);
+        response = jsCore.invoke(method, params, resolveId);
+      } else {
+        response = jsCore.call?.(method, params, resolveId);
+      }
+    }
+
+    /**
+     * 如果 invoke 返回了结果，则为同步调用
+     * - iOS 返回 `undefined`
+     * - Android 返回空字符串 `""`
+     */
+    if (response) {
+      try {
+        if (typeof response === 'string') {
+          response = JSON.parse(response);
+        }
+        response = unpack(response);
+      } catch (error) {
+        logger.error(error);
+      }
+      resolveMap.delete(resolveId);
+      if (response.errorCode) {
+        response.errorCode = formatErrorCode(method, response.errorCode);
+      }
+      reportInvokeMetrics({ ...invokeReportParam, ...response });
+
+      return response;
+    }
+
+    if (method.endsWith('Sync')) {
+      resolveMap.delete(resolveId);
+    }
+
+    return deferred.promise.then((response) => {
+      if (response.errorCode) {
+        response.errorCode = formatErrorCode(method, response.errorCode as number | undefined);
+      }
+      reportInvokeMetrics({ ...invokeReportParam, ...response });
+      return response;
+    });
+  };
+
+  const applyNative = (method: string, arg?: Record<string, unknown>) => {
+    const res = invokeNative(method, arg);
+    if (isPromiseLike(res)) {
+      return res.then((r) =>
+        ifThrowError(
+          method,
+          r as {
+            errMsg?: string;
+            errNo?: number;
+            errorType?: string;
+            errorCode?: number;
+          }
+        )
+      );
+    }
+    return ifThrowError(method, res);
+  };
+
+  return {
+    invokeNative,
+    applyNative,
+    invokeHandler
+  };
+}
+
+export function ifThrowError(
+  method: string,
+  res: {
+    errMsg?: string;
+    errNo?: number;
+    errorType?: string;
+    errorCode?: number;
+  }
+) {
+  if (!isObject(res)) {
+    logger.warn(`[Jolibox SDK]${method} no response value`);
+    return;
+  }
+  const { errMsg, errNo, errorType, errorCode, ...data } = res;
+
+  if (errMsg && errMsg !== `${method}:ok`) {
+    throw new InternalApplyNativeError(errMsg, errNo, errorType, errorCode);
+  }
+
+  return data;
+}
+
+export class ApplyNativeError extends Error {
+  constructor(message: string, readonly errNo?: number) {
+    super(message);
+  }
+}

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

@@ -0,0 +1,23 @@
+import { createInvoke } from './invoke';
+import { createSubscribe } from './subscribe';
+import { JSBridge } from './types';
+
+/**
+ * build js-bridge
+ * @param jsCore jsCore function inject by native
+ */
+export function createBridge(jsCore: jsb.JSCore): JSBridge {
+  const { subscribeHandler, onNative, offNative } = createSubscribe(jsCore);
+
+  const { invokeNative, invokeHandler, applyNative } = createInvoke(jsCore, onNative);
+
+  return {
+    // 宿主调用
+    invokeHandler,
+    subscribeHandler,
+    applyNative,
+    invokeNative,
+    onNative,
+    offNative
+  };
+}