@jolibox/implement 1.1.32 → 1.1.34

package/dist/native/rewards/check-frequency.d.ts

@@ -6,7 +6,10 @@
 export declare const checkUseModalFrequency: (config: {
     dailyMaxPopUps: number;
     minInterval: number;
-}) => Promise<boolean>;
+}) => Promise<{
+    canShow: boolean;
+    isFirst: boolean;
+}>;
 export declare const updateUseModalFrequency: () => Promise<void>;
 /**
  * check can show paymentModal
@@ -14,7 +17,10 @@ export declare const updateUseModalFrequency: () => Promise<void>;
 export declare const checkPaymentFrequency: (config: {
     dailyMaxPopUps: number;
     minInterval: number;
-}) => Promise<boolean>;
+}) => Promise<{
+    canShow: boolean;
+    isFirst: boolean;
+}>;
 /**
  * update paymentFrequency
  */

package/implement.build.log

@@ -1,9 +1,9 @@
 Invoking: npm run clean && npm run build:esm && tsc 
 
-> @jolibox/implement@1.1.32 clean
+> @jolibox/implement@1.1.34 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.1.32 build:esm
+> @jolibox/implement@1.1.34 build:esm
 > BUILD_VERSION=$(node -p "require('./package.json').version")  node esbuild.config.js --format=esm
 

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@jolibox/implement",
   "description": "This project is Jolibox JS-SDk implement for Native && H5",
-  "version": "1.1.32",
+  "version": "1.1.34",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.1.32",
-    "@jolibox/types": "1.1.32",
-    "@jolibox/native-bridge": "1.1.32",
-    "@jolibox/ads": "1.1.32",
+    "@jolibox/common": "1.1.34",
+    "@jolibox/types": "1.1.34",
+    "@jolibox/native-bridge": "1.1.34",
+    "@jolibox/ads": "1.1.34",
     "localforage": "1.10.0",
     "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"

package/src/common/context/index.ts

@@ -39,7 +39,8 @@ type MPType = 'game' | 'miniApp';
 export enum SDKEnvironment {
   jolibox = 'jolibox', // 默认
   dlightek = 'dlightek', // 传音
-  funmax = 'funmax' // 小米
+  funmax = 'funmax', // 小米
+  huaweiQuick = 'huaweiQuick' // 华为快应用
 }
 
 type Viewport = {
@@ -139,6 +140,10 @@ const wrapContext = () => {
       if (hasDlightekMeta) {
         return SDKEnvironment.dlightek;
       }
+      const huaweiQuick = urlParams.get('huaweiQuick') === 'true';
+      if (huaweiQuick) {
+        return SDKEnvironment.huaweiQuick;
+      }
       return SDKEnvironment.jolibox;
     },
     get viewport(): Viewport {

package/src/common/report/track.ts

@@ -1,4 +1,4 @@
-import { debounce } from '@jolibox/common';
+import { debounce, EventType } from '@jolibox/common';
 import { ReportHandler, Track, TrackPerformance, CommonReportConfig } from './types';
 import { PerformanceType, TrackEvent } from '@jolibox/types';
 import { InternalGlobalJSError } from '@jolibox/common';
@@ -7,11 +7,13 @@ import { reportError } from './errors/report';
 // Track system event, wrap common config
 export function createTrack(reportHandler: ReportHandler, common: CommonReportConfig): Track {
   const track = (tag: TrackEvent, info: Record<string, unknown> | null, webviewId?: number): void => {
+    const { eventType, ...rest } = info ?? {};
     const data = {
       tag,
+      eventType: (eventType ?? EventType.Other) as number,
       ...common,
       extra: {
-        ...info
+        ...rest
       }
     };
     if (tag == 'globalJsError') {

package/src/common/report/types.ts

@@ -1,8 +1,8 @@
 import { PerformanceType, TrackEvent } from '@jolibox/types';
-import { EProject } from '@jolibox/common';
+import { EProject, EventType } from '@jolibox/common';
 
 export interface Track {
-  (tag: TrackEvent, info: Record<string, unknown> | null): void;
+  (tag: TrackEvent, info: Record<string, unknown> | null, eventType?: number): void;
   debounce: (tag: TrackEvent, info: Record<string, unknown>) => void;
 }
 
@@ -13,7 +13,7 @@ export interface TrackPerformance {
 
 export type ReportHandler = (
   event: string,
-  data: { tag: TrackEvent; data?: Record<string, string | number | boolean | null> },
+  data: { tag: TrackEvent; eventType?: number; data?: Record<string, string | number | boolean | null> },
   webviewId?: number
 ) => void;
 

package/src/common/rewards/registers/utils/coins/index.ts

@@ -81,9 +81,7 @@ export const createShowUnlockWithJolicoinModal = (
 };
 
 const checkIfCancel = (result: IPaymentResult | IUseModalResult) => {
-  if (result == 'CANCEL') {
-    throw new Error('CANCEL');
-  }
+  return result == 'CANCEL';
 };
 
 export const createCommonJolicoinRewardHandler = (
@@ -118,7 +116,6 @@ export const createCommonJolicoinRewardHandler = (
           userJoliCoin: unlockOptions?.userJoliCoin,
           joliCoinQuantity
         });
-        checkIfCancel(paymentResult);
 
         if (paymentResult !== 'SUCCESS') {
           handleUnlockFailed?.(params);
@@ -137,7 +134,6 @@ export const createCommonJolicoinRewardHandler = (
           joliCoinQuantity
         });
 
-        checkIfCancel(shouldUnlock);
         if (shouldUnlock !== 'CONFIRM') {
           handleUnlockFailed?.(params);
           return false;

package/src/h5/api/ads.ts

@@ -18,47 +18,26 @@ import {
 } from '@jolibox/ads';
 import { context, SDKEnvironment } from '@/common/context';
 import '../rewards';
+import DlightekAdsHandler from './platformAdsHandle/DlightekAdsHandler';
+import HuaweiQuickAdsHandler from './platformAdsHandle/HuaweiQuickAdsHandler';
 
 declare global {
   interface Window {
-    h5sdk: any;
+    // 传音sdk
+    h5sdk: JoliboxAdsForGame;
+    // 华为快应用
+    system: {
+      postMessage: (params: string) => void;
+    };
   }
 }
-
-// 统一的广告处理器接口
-interface IAdsHandler {
+export interface IAdsHandler {
   init(config?: IAdsInitParams): void;
   adConfig(params: IAdConfigParams): void;
   adBreak(params: IAdBreakParams): Promise<void> | void;
   adUnit(params: IAdUnitParams): void;
-  getAdsInstance(): JoliboxAdsForGame | any;
-}
-
-// 具体处理器实现
-class DlightekAdsHandler implements IAdsHandler {
-  constructor(private ads: any) {}
-
-  getAdsInstance(): any {
-    return this.ads;
-  }
-
-  init(_config?: IAdsInitParams): void {
-    // Dlightek 不需要初始化
-  }
-
-  adConfig(params: IAdConfigParams): void {
-    this.ads.adConfig(params);
-  }
-
-  adBreak(params: IAdBreakParams): void {
-    this.ads.adBreak(params);
-  }
-
-  adUnit(_params: IAdUnitParams): void {
-    // Dlightek 不需要 adUnit
-  }
+  getAdsInstance(): JoliboxAdsForGame;
 }
-
 class JoliboxAdsHandler implements IAdsHandler {
   constructor(private ads: JoliboxAdsForGame) {}
 
@@ -115,6 +94,10 @@ class H5AdsManager {
         this.cacheHandler = new DlightekAdsHandler(window.h5sdk);
         break;
       }
+      case SDKEnvironment.huaweiQuick: {
+        this.cacheHandler = HuaweiQuickAdsHandler.getInstance();
+        break;
+      }
       default: {
         const joliboxAds = new JoliboxAdsForGame(this.context);
         this.cacheHandler = new JoliboxAdsHandler(joliboxAds);

package/src/h5/api/platformAdsHandle/DlightekAdsHandler.ts

@@ -0,0 +1,26 @@
+import { IAdConfigParams, IAdBreakParams, JoliboxAdsForGame } from '@jolibox/ads';
+import { IAdsHandler } from '../ads';
+
+export default class DlightekAdsHandler implements IAdsHandler {
+  constructor(private ads: JoliboxAdsForGame) {}
+
+  getAdsInstance(): JoliboxAdsForGame {
+    return this.ads;
+  }
+
+  init(): void {
+    // Dlightek 不需要初始化
+  }
+
+  adConfig(params: IAdConfigParams): void {
+    this.ads.adConfig(params);
+  }
+
+  adBreak(params: IAdBreakParams): void {
+    this.ads.adBreak(params);
+  }
+
+  adUnit(): void {
+    // Dlightek 不需要 adUnit
+  }
+}

package/src/h5/api/platformAdsHandle/HuaweiQuickAdsHandler.ts

@@ -0,0 +1,268 @@
+import {
+  IAdsInitParams,
+  IAdConfigParams,
+  IAdBreakParams,
+  IAdUnitParams,
+  JoliboxAdsForGame,
+  IPlacementInfo
+} from '@jolibox/ads';
+import { IAdsHandler } from '../ads';
+
+enum HuaweiQuickAdsEventEnum {
+  INIT = 'huawei_quick_ads_init',
+  AD_CONFIG = 'huawei_quick_ads_ad_config',
+  AD_BREAK = 'huawei_quick_ads_ad_break',
+  AD_UNIT = 'huawei_quick_ads_ad_unit',
+
+  AD_OPERATION = 'huawei_quick_ads_ad_operation'
+}
+
+enum HuaweiQuickAdsOnMessageEventEnum {
+  INIT = 'huawei_quick_ads_on_message_init',
+  AD_CONFIG = 'huawei_quick_ads_on_message_ad_config',
+  AD_BREAK = 'huawei_quick_ads_on_message_ad_break',
+  AD_UNIT = 'huawei_quick_ads_on_message_ad_unit'
+}
+
+interface HuaweiQuickAdsEventMap {
+  [HuaweiQuickAdsEventEnum.INIT]: IAdsInitParams | undefined;
+  [HuaweiQuickAdsEventEnum.AD_CONFIG]: IAdConfigParams;
+  [HuaweiQuickAdsEventEnum.AD_BREAK]: IAdBreakParams;
+  [HuaweiQuickAdsEventEnum.AD_UNIT]: IAdUnitParams;
+  [HuaweiQuickAdsEventEnum.AD_OPERATION]: undefined;
+}
+
+// 通用事件接口
+interface HuaweiQuickAdsEvent<T extends HuaweiQuickAdsEventEnum> {
+  type: T;
+  data?: HuaweiQuickAdsEventMap[T];
+}
+
+interface HuaweiQuickAdsCallbackMap {
+  onReady?: () => void;
+
+  adBreakDone?: (placementInfo: IPlacementInfo) => void;
+  beforeAd?: () => void;
+  afterAd?: () => void;
+  beforeReward?: (showAdFn: () => void) => void;
+  adDismissed?: () => void;
+  adViewed?: () => void;
+
+  breakType?: string;
+  breakName?: string;
+  breakFormat?: 'interstitial' | 'reward';
+}
+
+export default class HuaweiQuickAdsHandler implements IAdsHandler {
+  private static instance: HuaweiQuickAdsHandler;
+
+  private callbacksId: number;
+  private callbackMap: Map<number, HuaweiQuickAdsCallbackMap>;
+
+  private constructor() {
+    this.callbacksId = 0;
+    this.callbackMap = new Map();
+
+    this.initOnMessage();
+  }
+
+  public static getInstance(): HuaweiQuickAdsHandler {
+    if (!HuaweiQuickAdsHandler.instance) {
+      HuaweiQuickAdsHandler.instance = new HuaweiQuickAdsHandler();
+    }
+    return HuaweiQuickAdsHandler.instance;
+  }
+
+  private initOnMessage() {
+    window.addEventListener('message', (event) => {
+      //   const { data, origin, source } = event;
+      console.log(`HuaweiQuickAdsHandler,event => ${event}`);
+      if (event.origin != window.location.origin) return;
+
+      console.log(`data => ${event.data}`);
+
+      if (event.data && event.data.type == null) {
+        const data = JSON.parse(event.data);
+
+        console.log(`HuaweiQuickAdsHandler type => ${data.type}`);
+        switch (data.type) {
+          case HuaweiQuickAdsOnMessageEventEnum.INIT:
+            console.log('HuaweiQuickAdsHandler window.addEventListener init', data);
+            break;
+          case HuaweiQuickAdsOnMessageEventEnum.AD_CONFIG:
+            {
+              const callbackId = data.callbackId;
+              if (callbackId) {
+                const callbacks = this.callbackMap.get(callbackId);
+                callbacks?.onReady?.();
+              }
+              console.log('HuaweiQuickAdsHandler window.addEventListener adConfig', data);
+            }
+            break;
+          case HuaweiQuickAdsOnMessageEventEnum.AD_BREAK:
+            {
+              const callbackId = data.callbackId;
+              if (callbackId) {
+                const callbacks = this.callbackMap.get(callbackId);
+                let adsRes:
+                  | 'notReady'
+                  | 'timeout'
+                  | 'error'
+                  | 'noAdPreloaded'
+                  | 'frequencyCapped'
+                  | 'ignored'
+                  | 'other'
+                  | 'dismissed'
+                  | 'viewed' = 'noAdPreloaded';
+                let isBreakDone = false;
+
+                switch (data.adsRes) {
+                  case 'viewed':
+                    adsRes = 'viewed';
+                    callbacks?.adViewed?.();
+                    isBreakDone = true;
+                    break;
+                  case 'dismissed':
+                    adsRes = 'dismissed';
+                    callbacks?.adDismissed?.();
+                    isBreakDone = true;
+                    break;
+                  case 'error':
+                    adsRes = 'error';
+                    isBreakDone = true;
+                    break;
+                  case 'other':
+                    adsRes = 'other';
+                    isBreakDone = true;
+                    break;
+
+                  case 'beforeReward':
+                    callbacks?.beforeReward?.(() => {
+                      //   this.sendPostMessage(HuaweiQuickAdsEventEnum.AD_OPERATION, undefined, undefined);
+                      window.system.postMessage(
+                        JSON.stringify({
+                          type: HuaweiQuickAdsEventEnum.AD_OPERATION
+                        })
+                      );
+                      console.log('HuaweiQuickAdsHandler beforeReward postMessage AD_OPERATION');
+                    });
+                    isBreakDone = false;
+                    break;
+                  case 'beforeAd':
+                    callbacks?.beforeAd?.();
+                    isBreakDone = false;
+                    break;
+                  case 'afterAd':
+                    callbacks?.afterAd?.();
+                    isBreakDone = false;
+                    break;
+                }
+
+                isBreakDone &&
+                  callbacks?.adBreakDone?.({
+                    breakType: callbacks.breakType ?? '',
+                    breakName: callbacks.breakName,
+                    breakFormat: callbacks.breakFormat ?? 'interstitial',
+                    breakStatus: adsRes
+                  });
+              }
+
+              console.log('HuaweiQuickAdsHandler window.addEventListener adBreak', data);
+            }
+            break;
+          case HuaweiQuickAdsOnMessageEventEnum.AD_UNIT:
+            console.log('HuaweiQuickAdsHandler window.addEventListener adUnit', data);
+            break;
+          default:
+            break;
+        }
+      }
+    });
+  }
+
+  getAdsInstance(): JoliboxAdsForGame {
+    return HuaweiQuickAdsHandler.getInstance() as unknown as JoliboxAdsForGame;
+  }
+
+  init(config?: IAdsInitParams): void {
+    try {
+      this.sendPostMessage(HuaweiQuickAdsEventEnum.INIT, undefined, config);
+    } catch (e) {
+      console.error('init failed', e);
+    }
+  }
+
+  adConfig(params: IAdConfigParams): void {
+    try {
+      let callbackId = undefined;
+      if (params.onReady) {
+        callbackId = ++this.callbacksId;
+        this.callbackMap.set(callbackId, { onReady: params.onReady });
+      }
+
+      this.sendPostMessage(HuaweiQuickAdsEventEnum.AD_CONFIG, callbackId, params);
+    } catch (e) {
+      console.error('adConfig failed', e);
+    }
+  }
+
+  adBreak(params: IAdBreakParams): void {
+    try {
+      const callbackId = ++this.callbacksId;
+      const callbacks: HuaweiQuickAdsCallbackMap = {};
+
+      callbacks.breakType = params.type;
+      if (params.type !== 'preroll' && params.name) callbacks.breakName = params.name;
+      callbacks.breakFormat = params.type === 'reward' ? 'reward' : 'interstitial';
+
+      if (params.adBreakDone) callbacks.adBreakDone = params.adBreakDone;
+      if (params.type !== 'preroll' && params.beforeAd) callbacks.beforeAd = params.beforeAd;
+      if (params.type !== 'preroll' && params.afterAd) callbacks.afterAd = params.afterAd;
+      if (params.type === 'reward' && params.beforeReward) callbacks.beforeReward = params.beforeReward;
+      if (params.type === 'reward' && params.adDismissed) callbacks.adDismissed = params.adDismissed;
+      if (params.type === 'reward' && params.adViewed) callbacks.adViewed = params.adViewed;
+
+      this.callbackMap.set(callbackId, callbacks);
+
+      this.sendPostMessage(HuaweiQuickAdsEventEnum.AD_BREAK, callbackId, params);
+    } catch (e) {
+      params.adBreakDone?.({
+        breakType: params.type,
+        breakName: params.type === 'preroll' ? undefined : params.name,
+        breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
+        breakStatus: 'noAdPreloaded'
+      });
+    }
+  }
+
+  adUnit(params: IAdUnitParams): void {
+    try {
+      this.sendPostMessage(HuaweiQuickAdsEventEnum.AD_UNIT, undefined, params);
+    } catch (e) {
+      console.error('adUnit failed', e);
+    }
+  }
+
+  private sendPostMessage<T extends HuaweiQuickAdsEventEnum>(
+    type: T,
+    callbackId?: number,
+    data?: HuaweiQuickAdsEventMap[T]
+  ): void {
+    try {
+      if (!window.system?.postMessage) {
+        throw new Error('window.system.postMessage is not available');
+      }
+
+      const message: HuaweiQuickAdsEvent<T> = {
+        type,
+        ...(callbackId !== undefined && { callbackId }),
+        ...(data !== undefined && { data })
+      };
+
+      window.system.postMessage(JSON.stringify(message));
+    } catch (e) {
+      console.error('sendPostMessage failed', e);
+      throw e;
+    }
+  }
+}

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

@@ -1,6 +1,7 @@
 import { createCommands } from '@jolibox/common';
 import { createSyncAPI, registerCanIUse } from './base';
 import { invokeNative } from '@jolibox/native-bridge';
+import { context } from '@/common/context';
 
 const commands = createCommands();
 
@@ -19,7 +20,11 @@ const getSystemInfoSync = createSyncAPI(API_GET_SYSTEM_SYNC, {
       language: data.deviceInfo.lang,
       brand: data.deviceInfo.brand,
       appName: data.hostInfo?.appName,
-      SDKVersion: data.sdkInfo.jssdkVersion
+      SDKVersion: data.sdkInfo.jssdkVersion,
+      viewport: {
+        statusBarHeight: context.viewport.statusBarHeight,
+        navigationBarHeight: context.viewport.navigationBarHeight
+      }
     };
   }
 });
@@ -40,5 +45,8 @@ registerCanIUse('env', {
 });
 
 registerCanIUse('getSystemInfoSync', {
-  version: '1.0.0'
+  version: '1.0.0',
+  properties: {
+    viewport: '1.0.33'
+  }
 });

package/src/native/api/login.ts

@@ -23,15 +23,38 @@ registerCanIUse('checkSession', {
   }
 });
 
+const loginDeferredMap = new Map<string, Deferred<{ isLogin: boolean; token?: string }>>();
+
+onNative('onLoginStateChange', ({ isLogin, token, uuid }) => {
+  const deferred = loginDeferredMap.get(uuid);
+  if (deferred) {
+    deferred.resolve({ isLogin, token });
+    loginDeferredMap.delete(uuid);
+  }
+});
+
 export const login = createAPI('login', {
-  async implement() {
+  paramsSchema: t.tuple(
+    t
+      .object({
+        skipLogin: t.boolean().optional(),
+        triggerFrom: t.string().optional()
+      })
+      .optional()
+  ),
+  async implement(params) {
     const {
       data: { isLogin }
     } = await applyNative('checkLoginAsync');
     if (isLogin) {
       return { isLogin: true, token: context.hostUserInfo?.token };
     }
-    const res = invokeNative('loginSync');
+
+    const { skipLogin, triggerFrom } = params ?? {};
+    const res = invokeNative('loginSync', {
+      skipLogin,
+      triggerFrom
+    });
 
     const {
       data: { uuid: loginUUID }
@@ -42,17 +65,12 @@ export const login = createAPI('login', {
         msg: 'login failed'
       });
     }
-    onNative('onLoginStateChange', ({ isLogin, token, uuid }) => {
-      if (uuid == loginUUID) {
-        resolve({ isLogin, token });
-      }
-    });
-    const { promise, resolve } = new Deferred<{ isLogin: boolean; token?: string }>();
 
-    const loginRes = await promise;
+    const deferred = new Deferred<{ isLogin: boolean; token?: string }>();
+    loginDeferredMap.set(loginUUID, deferred);
+    const loginRes = await deferred.promise;
     context.onEnvConfigChanged({ hostUserInfo: loginRes });
     hostEmitter.emit('onLoginComplete', loginRes);
-
     return loginRes;
   }
 });

package/src/native/payment/registers/jolicoin-iap.ts

@@ -58,11 +58,13 @@ onNative('onPaymentStateChange', (data) => {
         );
       }
     }
-    const failedStatus = IPaymentIAPFailedStatusMap[status] ?? 'unlockFailed';
-    createToast(`{slot-error} {slot-i18n-jolicoin.${failedStatus}}`, {
-      position: 'center',
-      duration: 3000
-    });
+    const failedStatus = IPaymentIAPFailedStatusMap[status];
+    if (failedStatus) {
+      createToast(`{slot-error} {slot-i18n-jolicoin.${failedStatus}}`, {
+        position: 'center',
+        duration: 3000
+      });
+    }
     deferred.resolve({
       code: 'FAILED' as ResponseType,
       message: 'jolicoin payment failed'

package/src/native/report/index.ts

@@ -1,5 +1,5 @@
 import './errors';
-import { createCommands, isObject, isString, EventEmitter, EProject } from '@jolibox/common';
+import { createCommands, isObject, isString, EventEmitter, EProject, EventType } from '@jolibox/common';
 export * from '../../common/report/types';
 import { createTracks, ReportHandler } from '@/common/report';
 import { context } from '@/common/context';
@@ -20,10 +20,13 @@ const reportNative: ReportHandler = (event, data, webviewId) => {
     session_id: context.sessionId,
     user_id: context.hostUserInfo?.uid ?? ''
   };
+  const eventType = (_data.eventType ?? EventType.Other) as number;
+
   invokeNative('trackAsync', {
     event: data.tag ?? event,
     data: extra,
-    webviewId
+    webviewId,
+    eventType
   });
 };