@jolibox/implement 1.1.33 → 1.1.35

package/implement.build.log

@@ -1,9 +1,9 @@
 Invoking: npm run clean && npm run build:esm && tsc 
 
-> @jolibox/implement@1.1.33 clean
+> @jolibox/implement@1.1.35 clean
 > rimraf ./dist
 
 
-> @jolibox/implement@1.1.33 build:esm
+> @jolibox/implement@1.1.35 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.33",
+  "version": "1.1.35",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "license": "MIT",
   "dependencies": {
-    "@jolibox/common": "1.1.33",
-    "@jolibox/types": "1.1.33",
-    "@jolibox/native-bridge": "1.1.33",
-    "@jolibox/ads": "1.1.33",
+    "@jolibox/common": "1.1.35",
+    "@jolibox/types": "1.1.35",
+    "@jolibox/native-bridge": "1.1.35",
+    "@jolibox/ads": "1.1.35",
     "localforage": "1.10.0",
     "@jolibox/ui": "1.0.0",
     "web-vitals": "4.2.4"

package/src/common/context/index.ts

@@ -39,7 +39,9 @@ type MPType = 'game' | 'miniApp';
 export enum SDKEnvironment {
   jolibox = 'jolibox', // 默认
   dlightek = 'dlightek', // 传音
-  funmax = 'funmax' // 小米
+  funmax = 'funmax', // 小米
+  huaweiQuick = 'huaweiQuick', // 华为快应用
+  gamedistribution = 'gamedistribution'
 }
 
 type Viewport = {
@@ -48,8 +50,7 @@ type Viewport = {
 };
 
 function hasMetaTag(name: string, content: string): boolean {
-  const metaTag = document?.head.querySelector(`meta[name="${name}"][content="${content}"]`);
-  return metaTag !== null;
+  return document?.head.querySelector(`meta[name="${name}"][content="${content}"]`) !== null;
 }
 
 const wrapContext = () => {
@@ -135,10 +136,15 @@ const wrapContext = () => {
       return env.deviceInfo.lang;
     },
     get sdkEnvironment(): SDKEnvironment {
-      const hasDlightekMeta = hasMetaTag('dlightek', 'jolibox');
-      if (hasDlightekMeta) {
+      if (hasMetaTag('dlightek', 'jolibox')) {
         return SDKEnvironment.dlightek;
       }
+      if (urlParams.get('huaweiQuick') === 'true') {
+        return SDKEnvironment.huaweiQuick;
+      }
+      if (hasMetaTag('gamedistribution', 'jolibox')) {
+        return SDKEnvironment.gamedistribution;
+      }
       return SDKEnvironment.jolibox;
     },
     get viewport(): Viewport {

package/src/h5/api/ads.ts

@@ -18,47 +18,27 @@ import {
 } from '@jolibox/ads';
 import { context, SDKEnvironment } from '@/common/context';
 import '../rewards';
+import DlightekAdsHandler from './platformAdsHandle/DlightekAdsHandler';
+import HuaweiQuickAdsHandler from './platformAdsHandle/HuaweiQuickAdsHandler';
+import GamedistributionAdsHandler from './platformAdsHandle/GamedistributionAdsHandler';
 
 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 +95,14 @@ class H5AdsManager {
         this.cacheHandler = new DlightekAdsHandler(window.h5sdk);
         break;
       }
+      case SDKEnvironment.huaweiQuick: {
+        this.cacheHandler = HuaweiQuickAdsHandler.getInstance();
+        break;
+      }
+      case SDKEnvironment.gamedistribution: {
+        this.cacheHandler = GamedistributionAdsHandler.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/GamedistributionAdsHandler.ts

@@ -0,0 +1,123 @@
+import {
+  IAdsInitParams,
+  IAdConfigParams,
+  IAdBreakParams,
+  IAdUnitParams,
+  JoliboxAdsForGame
+} from '@jolibox/ads';
+import { IAdsHandler } from '../ads';
+
+declare global {
+  interface Window {
+    // gamedistribution
+    gdsdk: {
+      preloadAd: (type: string) => Promise<void>;
+      showAd: (type: string) => Promise<{ adType: string; args: { success: boolean } }>;
+    };
+  }
+}
+
+export default class GamedistributionAdsHandler implements IAdsHandler {
+  private static instance: GamedistributionAdsHandler;
+
+  private constructor() {
+    // 不需要初始化
+  }
+
+  public static getInstance(): GamedistributionAdsHandler {
+    if (!GamedistributionAdsHandler.instance) {
+      GamedistributionAdsHandler.instance = new GamedistributionAdsHandler();
+    }
+    return GamedistributionAdsHandler.instance;
+  }
+
+  getAdsInstance(): JoliboxAdsForGame {
+    return GamedistributionAdsHandler.getInstance() as unknown as JoliboxAdsForGame;
+  }
+
+  init(): void {
+    // 不需要初始化
+  }
+
+  adConfig(params: IAdConfigParams): void {
+    if (params.onReady) params.onReady();
+  }
+
+  adBreak(params: IAdBreakParams): Promise<void> | void {
+    try {
+      if (params.type === 'reward') {
+        window.gdsdk
+          .preloadAd('rewarded')
+          .then(() => {
+            params.beforeReward?.(() => {
+              if (params.beforeAd) params.beforeAd();
+
+              window.gdsdk
+                .showAd('rewarded')
+                .then((response) => {
+                  if (response?.args?.success) {
+                    params.adViewed?.();
+                  } else {
+                    params.adDismissed?.();
+                  }
+
+                  if (params.afterAd) params.afterAd();
+
+                  params.adBreakDone?.({
+                    breakType: params.type,
+                    breakName: params.name,
+                    breakFormat: 'reward',
+                    breakStatus: response?.args?.success ? 'viewed' : 'dismissed'
+                  });
+                })
+                .catch((error) => {
+                  console.log('showReward error => ', error);
+
+                  params.adBreakDone?.({
+                    breakType: params.type,
+                    breakName: params.name,
+                    breakFormat: 'reward',
+                    breakStatus: 'noAdPreloaded'
+                  });
+                });
+            });
+          })
+          .catch((error) => {
+            console.log('preloadAd error => ', error);
+
+            params.adBreakDone?.({
+              breakType: params.type,
+              breakName: params.name,
+              breakFormat: 'reward',
+              breakStatus: 'noAdPreloaded'
+            });
+          });
+      } else {
+        if (params.type !== 'preroll' && params.beforeAd) params.beforeAd();
+        window.gdsdk.showAd('interstitial').then(() => {
+          if (params.type !== 'preroll' && params.afterAd) params.afterAd();
+
+          params.adBreakDone?.({
+            breakType: params.type,
+            breakName: params.type === 'preroll' ? undefined : params.name,
+            breakFormat: 'interstitial',
+            breakStatus: 'viewed'
+          });
+        });
+      }
+    } catch (e) {
+      console.log('adBreak error => ', e);
+
+      params.adBreakDone?.({
+        breakType: params.type,
+        breakName: params.type === 'preroll' ? undefined : params.name,
+        breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
+        breakStatus: 'error'
+      });
+    }
+  }
+
+  adUnit(): void {
+    // 不需要初始化
+  }
+}

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/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/rewards/index.ts

@@ -229,7 +229,9 @@ rewardsEmitter.on(
                     ?.totalAmountStr ?? ''
               });
               if (!context.hostUserInfo?.isLogin) {
-                const { data } = await login();
+                const { data } = await login({
+                  skipLogin: true
+                });
                 if (!data?.isLogin) {
                   console.log('login failed');
                   return;