@jolibox/implement 1.1.4-beta.10

package/src/h5/api/get-system-info.ts

@@ -0,0 +1,59 @@
+import { context } from '@/common/context';
+import { createSyncAPI, registerCanIUse } from './base';
+import { createCommands } from '@jolibox/common';
+import { ISystemInfo } from '@jolibox/types';
+
+const commands = createCommands();
+
+const API_ENV = 'env';
+const API_GET_SYSTEM_SYNC = 'getSystemInfoSync';
+
+const getSystemInfo = () => {
+  let config = {
+    system: context.deviceInfo.system,
+    platform: context.deviceInfo.platform,
+    brand: context.deviceInfo.brand,
+    pixelRatio: context.deviceInfo.pixelRatio,
+    language: context.deviceInfo.lang,
+    version: context.sdkInfo.jssdkVersion,
+    appName: context.hostInfo?.appName,
+    SDKVersion: context.sdkInfo.nativeSDKVersion
+  } as ISystemInfo;
+
+  const version = context.hostInfo?.version;
+  version && (config = { ...config, version });
+
+  const appName = context.hostInfo?.appName;
+  appName && (config = { ...config, appName });
+
+  const SDKVersion = context.sdkInfo?.jssdkVersion;
+  SDKVersion && (config = { ...config, SDKVersion });
+
+  return config;
+};
+
+const getSystemInfoSync = createSyncAPI(API_GET_SYSTEM_SYNC, {
+  implement: getSystemInfo
+});
+
+const getEnv = createSyncAPI(API_ENV, {
+  implement: () => {
+    return {
+      ...context.hostInfo,
+      sdkInfo: context.sdkInfo,
+      platform: context.platform,
+      deviceInfo: context.deviceInfo
+    };
+  }
+});
+
+commands.registerCommand(`API.env`, getEnv);
+commands.registerCommand(`API.getSystemInfoSync`, getSystemInfoSync);
+
+registerCanIUse('env', {
+  version: '1.0.0'
+});
+
+registerCanIUse('getSystemInfoSync', {
+  version: '1.0.0'
+});

package/src/h5/api/index.ts

@@ -0,0 +1,4 @@
+import './get-system-info';
+import './lifecycle';
+import './storage';
+import './task';

package/src/h5/api/lifecycle.ts

@@ -0,0 +1,95 @@
+import { BaseError, createCommands, hostEmitter, wrapUserFunction } from '@jolibox/common';
+import { createSyncAPI, registerCanIUse, t } from './base';
+import { reportError } from '@/common/report/errors/report';
+import { h5TaskEmitter } from '../report';
+
+const ON_SHOW = 'onJoliboxShow';
+const ON_HIDE = 'onJoliboxHide';
+const ON_READY = 'onReady';
+
+const commands = createCommands();
+
+const safeCallbackWrapper = wrapUserFunction(reportError as (err: Error | BaseError) => void);
+
+let isPageVisible = true;
+let isPageFocused = true;
+let lastEventTime = 0;
+
+const visibleEmitter = h5TaskEmitter;
+
+// 防止交叉触发
+function handleVisibilityChange() {
+  const currentTime = Date.now();
+  if (currentTime - lastEventTime < 100) return; // 忽略100ms内的重复触发
+  lastEventTime = currentTime;
+
+  const currentState = document.visibilityState === 'visible';
+  if (currentState !== isPageVisible) {
+    isPageVisible = currentState;
+    visibleEmitter.emit('visible', isPageVisible);
+  }
+}
+
+function handleFocusBlur(eventType: string) {
+  const currentTime = Date.now();
+  if (currentTime - lastEventTime < 100) return; // 忽略100ms内的重复触发
+  lastEventTime = currentTime;
+
+  if (eventType === 'focus' && !isPageFocused) {
+    isPageFocused = true;
+  } else if (eventType === 'blur' && isPageFocused) {
+    isPageFocused = false;
+  }
+
+  visibleEmitter.emit('visible', isPageFocused);
+}
+
+document.addEventListener('visibilitychange', handleVisibilityChange);
+window.addEventListener('focus', () => handleFocusBlur('focus'));
+window.addEventListener('blur', () => handleFocusBlur('blur'));
+
+const onShow = createSyncAPI(ON_SHOW, {
+  paramsSchema: t.tuple(t.function()),
+  implement(callback) {
+    const safeCallback = safeCallbackWrapper(callback);
+    visibleEmitter.on('visible', (visible) => {
+      visible && safeCallback();
+    });
+  }
+});
+
+const onHide = createSyncAPI(ON_HIDE, {
+  paramsSchema: t.tuple(t.function()),
+  implement(callback) {
+    const safeCallback = safeCallbackWrapper(callback);
+    visibleEmitter.on('visible', (visible) => {
+      !visible && safeCallback();
+    });
+  }
+});
+
+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.onReady', onReadyHandler);
+commands.registerCommand('LifecycleSDK.onJoliboxShow', onShow);
+commands.registerCommand('LifecycleSDK.onJoliboxHide', onHide);
+
+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/h5/api/storage.ts

@@ -0,0 +1,173 @@
+import { createAPI, t, registerCanIUse } from './base';
+import { createCommands, isBoolean, isNumber, isString } from '@jolibox/common';
+import JoliboxHttpClient from '@/h5/http';
+import { context } from '@/common/context';
+import { API_CODE, StorageResponse } from '@jolibox/types';
+import localForage from 'localforage';
+
+const commands = createCommands();
+
+export class JoliboxCloudStorage {
+  private gameId: string;
+  private httpClient: JoliboxHttpClient;
+  private gameStore: LocalForage;
+  constructor() {
+    this.gameId = this.getGameId();
+    this.httpClient = new JoliboxHttpClient({
+      baseUrl: context.testMode ? 'https://stg-api.jolibox.com' : 'https://api.jolibox.com'
+    });
+    //没有game的情况使用全局空间
+    this.gameStore = localForage.createInstance({
+      name: this.gameId.length ? this.gameId : 'default'
+    });
+  }
+  /**
+   *  Cloud storage getItem api
+   */
+  private getGameId = () => context.mpId;
+  /**
+   *
+   * @param key getItem key
+   */
+  getItem = async (key: string): Promise<StorageResponse<string | null>> => {
+    const {
+      code,
+      data: originData,
+      message
+    } = await this.httpClient.get<
+      StorageResponse<{
+        key: string;
+        value: string | null;
+      }>
+    >(`/api/games/user-storage/${this.gameId}`, {
+      query: {
+        key
+      }
+    });
+    let data = originData?.value;
+    let fallbackmsg = message;
+    if (code !== 'SUCCESS') {
+      // Only when data cannot be retrieved from the cloud should it be read locally.
+      data = await this.gameStore.getItem<string>(key);
+      console.info('[SDK] cloud storage getItem failed, read from localstorage', data);
+      fallbackmsg += 'fallback to localstorage';
+    }
+    const res = {
+      code,
+      message: fallbackmsg,
+      data: data && data !== 'undefined' ? data : null
+    };
+    return res;
+  };
+
+  /**
+   * Cloud storage setItem api
+   * @param progress - The progress of the loading, should be an integer between 0 and 100
+   */
+  setItem = async (key: string, value: string | boolean | number): Promise<StorageResponse<void>> => {
+    const valueToStore = typeof value == 'string' ? value : String(value);
+    //Regardless of whether the cloud operation is successful, corresponding changes should be made locally.
+    const { code, message } = await this.httpClient.post(`/api/games/user-storage/${this.gameId}`, {
+      data: {
+        key,
+        value: valueToStore
+      }
+    });
+    await this.gameStore.setItem(key, valueToStore);
+    return {
+      code,
+      message
+    };
+  };
+
+  removeItem = async (key: string): Promise<StorageResponse<void>> => {
+    await this.gameStore.removeItem(key);
+    const { code, message } = await this.httpClient.post(`/api/games/user-storage/${this.gameId}/remove`, {
+      data: {
+        key
+      }
+    });
+    return {
+      code,
+      message
+    };
+  };
+
+  clear = async (): Promise<StorageResponse<void>> => {
+    await this.gameStore.clear();
+    const { code, message } = await this.httpClient.post(`/api/games/user-storage/${this.gameId}/clear`, {});
+    return {
+      code,
+      message
+    };
+  };
+}
+
+const storageImpl = new JoliboxCloudStorage();
+const getStorage = createAPI('getLocalStorage', {
+  paramsSchema: t.tuple(t.string()),
+  async implement(key) {
+    return await storageImpl.getItem(key);
+  }
+});
+
+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) {
+    return await storageImpl.setItem(key, value);
+  }
+});
+
+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) {
+    return await storageImpl.removeItem(key);
+  }
+});
+
+commands.registerCommand('StorageSDK.removeItem', removeStorage);
+
+registerCanIUse('storage.removeItem', {
+  version: '1.0.0',
+  properties: {
+    key: '1.0.0'
+  }
+});
+
+/**
+ * 清理本地数据缓存
+ */
+const clearStorage = createAPI('clearStorage', {
+  async implement() {
+    return await storageImpl.clear();
+  }
+});
+
+commands.registerCommand('StorageSDK.clear', clearStorage);
+
+registerCanIUse('storage.clear', {
+  version: '1.0.0'
+});

package/src/h5/api/task.ts

@@ -0,0 +1,190 @@
+import { createCommands, logger } 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;
+    logger.info(`onLevelFinished`, result, duration);
+    await Promise.all([
+      taskTracker.reporter({
+        event: 'COMPLETE_GAME_LEVEL'
+      }),
+      taskTracker.tracker('LevelFinished', {
+        levelId,
+        result,
+        duration
+      })
+    ]);
+  }
+});
+
+const onTaskFinished = createAPI('taskFinished', {
+  paramsSchema: t.tuple(
+    t.string(),
+    t.object({
+      duration: t.number()
+    })
+  ),
+  implement: async (taskId, params) => {
+    const { duration } = params;
+    await taskTracker.tracker('TaskFinished', {
+      duration,
+      taskId
+    });
+  }
+});
+
+const onLevelUpgrade = createAPI('levelUpgrade', {
+  paramsSchema: t.tuple(t.string(), t.string()),
+  implement: async (levelId, name) => {
+    return await taskTracker.tracker('LevelUpgrade', {
+      name,
+      levelId
+    });
+  }
+});
+
+const onHistoryUserLevel = createAPI('onHistoryUserLevel', {
+  paramsSchema: t.tuple(t.number()),
+  implement: async (level) => {
+    return await taskTracker.tracker('HistoryUserLevel', {
+      level
+    });
+  }
+});
+
+const onHistoryUserScore = createAPI('onHistoryUserScore', {
+  paramsSchema: t.tuple(t.number()),
+  implement: async (score) => {
+    return await taskTracker.tracker('HistoryUserScore', {
+      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) => {
+    if (params.tools?.length) {
+      await Promise.all([
+        taskTracker.reporter({
+          event: 'USE_GAME_ITEM'
+        }),
+        taskTracker.tracker('UseGameItem', {
+          taskId,
+          ...params
+        })
+      ]);
+    }
+  }
+});
+
+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/h5/bootstrap/index.ts

@@ -0,0 +1,16 @@
+import { hostEmitter } from '@jolibox/common';
+import { taskTracker } from '../report';
+
+function addDomContentLoaded() {
+  hostEmitter.on('onDocumentReady', (startTime: number) => {
+    hostEmitter.emit('LifecycleEvent.onReady', {
+      isLogin: false
+    });
+
+    taskTracker.start(Date.now() - startTime);
+  });
+}
+
+export function config(): void {
+  addDomContentLoaded();
+}