@jolibox/implement 1.1.13-beta.1 → 1.1.13-beta.11

package/dist/native/api/keyboard.d.ts

@@ -1,7 +1,7 @@
 export declare const showKeyboard: (params: {
     defaultValue?: string | undefined;
-    maxLength?: unknown;
     multiple?: boolean | undefined;
+    maxLength?: unknown;
 }) => import("@jolibox/types").StandardResponse<void>;
 export declare const updateKeyboard: (params: {
     value: string;

package/implement.build.log

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

package/package.json

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

package/src/common/ads/anti-cheating.test.ts

@@ -20,7 +20,9 @@ describe('createLeadingNotifiableDebounce', () => {
   };
 
   it('should ban initial call', async () => {
-    localStorage.clear();
+    (window as any).__joliboxLocalStorage__ = window.localStorage;
+
+    (window as any).__joliboxLocalStorage__.clear();
 
     const adsAntiCheating = new AdsAntiCheating(track, http, () => true, config);
     await new Promise((resolve) => setTimeout(resolve, 10));
@@ -32,7 +34,7 @@ describe('createLeadingNotifiableDebounce', () => {
   });
 
   it('should ban continous calling', async () => {
-    localStorage.clear();
+    (window as any).__joliboxLocalStorage__.clear();
 
     const adsAntiCheating = new AdsAntiCheating(track, http, () => true, config);
     await new Promise((resolve) => setTimeout(resolve, 100));

package/src/common/ads/anti-cheating.ts

@@ -1,5 +1,7 @@
 import type { IHttpClient } from '../http';
 import type { Track } from '../report';
+import { getOriginalLocalStorage } from '@jolibox/common';
+getOriginalLocalStorage();
 
 export type AdsDisplayPermission =
   | 'BLOCK_INITIAL'
@@ -24,6 +26,12 @@ export interface IAdsAntiCheatingConfig {
   highFreqThreshold?: number; // default 2000 (2s)
 }
 
+declare global {
+  interface Window {
+    __joliboxLocalStorage__: Storage;
+  }
+}
+
 export class AdsAntiCheating {
   private checkShouldBanInitial: ReturnType<typeof createInitialStrategy>;
   private checkShouldBanHighFreq: ReturnType<typeof createHighFreqStrategy>;
@@ -177,7 +185,7 @@ const createBanForTimeStrategy = (
     _records: [] as CallAdsHistory[],
     init() {
       try {
-        const fromStorage = JSON.parse(window.localStorage.getItem(TIMESTAMP_STORAGE_KEY) ?? '[]');
+        const fromStorage = JSON.parse(window.__joliboxLocalStorage__.getItem(TIMESTAMP_STORAGE_KEY) ?? '[]');
         if (Array.isArray(fromStorage)) {
           this._records = fromStorage;
         } else {
@@ -192,7 +200,7 @@ const createBanForTimeStrategy = (
     },
     set values(value: CallAdsHistory[]) {
       try {
-        window.localStorage.setItem(TIMESTAMP_STORAGE_KEY, JSON.stringify(value));
+        window.__joliboxLocalStorage__.setItem(TIMESTAMP_STORAGE_KEY, JSON.stringify(value));
       } catch {
         // console.error('Failed to save timestamps');
         // do nothing
@@ -205,7 +213,7 @@ const createBanForTimeStrategy = (
     _record: false,
     init() {
       try {
-        const fromStorage = JSON.parse(window.localStorage.getItem(BAN_FOR_TIME_KEY) ?? 'false');
+        const fromStorage = JSON.parse(window.__joliboxLocalStorage__.getItem(BAN_FOR_TIME_KEY) ?? 'false');
         if (typeof fromStorage === 'boolean') {
           this._record = fromStorage;
         }
@@ -228,7 +236,7 @@ const createBanForTimeStrategy = (
     },
     set value(value: boolean) {
       try {
-        window.localStorage.setItem(BAN_FOR_TIME_KEY, JSON.stringify(value));
+        window.__joliboxLocalStorage__.setItem(BAN_FOR_TIME_KEY, JSON.stringify(value));
       } catch {
         // do nothing
       }

package/src/common/ads/index.ts

@@ -377,6 +377,55 @@ export class JoliboxAdsImpl {
    * @returns IAdBreakParams
    */
   private wrapAdBreakParams = (params: IAdBreakParams): IAdBreakParams => {
+    let googleHasResponse = false;
+
+    /* hook adBreakDone to track adBreakDone event -- start */
+    const originAdBreakDone = params.adBreakDone;
+    const adBreakDone = (placementInfo: IPlacementInfo) => {
+      googleHasResponse = true;
+      this.adsActionDetection.adBreakIsShowing = false;
+      this.track('CallAdBreakDone', {
+        breakType: placementInfo.breakType,
+        breakName: placementInfo.breakName ?? '',
+        breakFormat: placementInfo.breakFormat,
+        breakStatus: placementInfo.breakStatus
+      });
+      if (originAdBreakDone) {
+        originAdBreakDone(placementInfo);
+      }
+    };
+    params.adBreakDone = adBreakDone;
+    /* hook adBreakDone to track adBreakDone event -- end */
+
+    /* hook for reward -- start */
+    if (params.type === 'reward') {
+      const originBeforeReward = params.beforeReward;
+      const wrapShowAdFn = (originShowAdFn: () => void) => () => {
+        this.track('CallShowAdFn', null);
+        originShowAdFn();
+      };
+      const beforeReward = (originShowAdFn: () => void) => {
+        googleHasResponse = true;
+        if (originBeforeReward) {
+          originBeforeReward(wrapShowAdFn(originShowAdFn));
+        }
+      };
+      params.beforeReward = beforeReward;
+
+      window.setTimeout(() => {
+        if (!googleHasResponse) {
+          this.track('CallAdBreakTimeout', { type: params.type });
+          params.adBreakDone?.({
+            breakType: params.type,
+            breakName: params.name ?? '',
+            breakFormat: 'reward',
+            breakStatus: 'timeout'
+          });
+        }
+      }, 5000); // Timeout duration in milliseconds, 5 seconds
+    }
+    /* hook for reward -- end */
+
     const isPreroll = (params: IAdBreakParams): params is IPrerollParams => {
       return params.type === 'preroll';
     };
@@ -396,6 +445,7 @@ export class JoliboxAdsImpl {
       const originAfterAd = params.afterAd;
 
       const beforeAd = () => {
+        googleHasResponse = true;
         adEventEmitter.emit('isAdShowing', true);
         this.track('CallBeforeAd', {
           type: params.type,
@@ -407,6 +457,7 @@ export class JoliboxAdsImpl {
       };
 
       const afterAd = () => {
+        googleHasResponse = true;
         adEventEmitter.emit('isAdShowing', false);
         this.track('CallAfterAd', {
           type: params.type,
@@ -529,39 +580,6 @@ export class JoliboxAdsImpl {
 
     const type = params.type;
 
-    /* hook adBreakDone to track adBreakDone event -- start */
-    const originAdBreakDone = params.adBreakDone;
-    const adBreakDone = (placementInfo: IPlacementInfo) => {
-      this.adsActionDetection.adBreakIsShowing = false;
-      this.track('CallAdBreakDone', {
-        breakType: placementInfo.breakType,
-        breakName: placementInfo.breakName ?? '',
-        breakFormat: placementInfo.breakFormat,
-        breakStatus: placementInfo.breakStatus
-      });
-      if (originAdBreakDone) {
-        originAdBreakDone(placementInfo);
-      }
-    };
-    params.adBreakDone = adBreakDone;
-    /* hook adBreakDone to track adBreakDone event -- end */
-
-    /* hook beforeAd to track beforeAd event -- start */
-    if (params.type === 'reward') {
-      const originBeforeReward = params.beforeReward;
-      const wrapShowAdFn = (originShowAdFn: () => void) => () => {
-        this.track('CallShowAdFn', null);
-        originShowAdFn();
-      };
-      const beforeReward = (originShowAdFn: () => void) => {
-        if (originBeforeReward) {
-          originBeforeReward(wrapShowAdFn(originShowAdFn));
-        }
-      };
-      params.beforeReward = beforeReward;
-    }
-    /* hook beforeAd to track beforeAd event -- end */
-
     let paramsToTrack;
     switch (type) {
       case 'preroll':

package/src/common/rewards/__tests__/can-use-jolicoin.test.ts

@@ -0,0 +1,94 @@
+import { IUnlockOptionType } from '../type';
+import { canUseJolicoin } from '../registers/utils';
+
+describe('canUseJolicoin', () => {
+  it('should return true when joliCoin balance is sufficient and autoDeduct is enabled', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 100 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+
+  it('should return true when joliCoin balance is more than required', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+
+  it('should return false when joliCoin balance is insufficient', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 150 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when autoDeduct is disabled', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: false };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when there is no JOLI_COIN option', () => {
+    const unlockOptions = [
+      {
+        type: 'ADS' as IUnlockOptionType,
+        joliCoinChoices: []
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false with empty unlockOptions', () => {
+    const unlockOptions: any[] = [];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(false);
+  });
+
+  it('should return false when joliCoin is undefined', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 50 }]
+      }
+    ];
+
+    expect(canUseJolicoin(unlockOptions, undefined)).toBe(false);
+  });
+
+  it('should return true when at least one choice is valid', () => {
+    const unlockOptions = [
+      {
+        type: 'JOLI_COIN' as IUnlockOptionType,
+        joliCoinChoices: [{ joliCoinQuantity: 200 }, { joliCoinQuantity: 50 }]
+      }
+    ];
+    const joliCoin = { balance: 100, enableAutoDeduct: true };
+
+    expect(canUseJolicoin(unlockOptions, joliCoin)).toBe(true);
+  });
+});

package/src/common/rewards/fetch-reward.ts

@@ -0,0 +1,39 @@
+import { UnlockOptionsEventName, unlockOptionsEmitter } from '.';
+import { IHttpClient } from '../http';
+import { RewardsHelper, RewardType } from './reward-helper';
+import { IJolicoinRewardOption } from './type';
+
+const priority = () => {
+  return (a: RewardType, b: RewardType) => {
+    if (a === 'JOLI_COIN' && b === 'ADS') return -1;
+    if (a === 'ADS' && b === 'JOLI_COIN') return 1;
+    return 0;
+  };
+};
+
+export const createRewardFetcher = (rewardsHelper: RewardsHelper) => {
+  rewardsHelper.registerRewardsFetcher(async (httpClient: IHttpClient) => {
+    const defaultRewards: RewardType[] = ['ADS'];
+    try {
+      const res = await httpClient.post<IJolicoinRewardOption>('/api/games/unlock-options', {});
+      if (res.code !== 'SUCCESS') {
+        return defaultRewards;
+      }
+      unlockOptionsEmitter.emit(UnlockOptionsEventName, {
+        options: res.data?.unlockOptions || [],
+        userJoliCoin: res.extra?.joliCoin || {
+          balance: 0,
+          enableAutoDeduct: false
+        }
+      });
+
+      const rewardsTypes =
+        res.data?.unlockOptions?.map((option) => option.type) || Array.from(defaultRewards);
+      // Sort reward types with JOLI_COIN having higher priority than ADS
+      return rewardsTypes.sort(priority());
+    } catch (e) {
+      console.error('getRewardOptions error:', e);
+      return defaultRewards;
+    }
+  });
+};

package/src/common/rewards/index.ts

@@ -0,0 +1,20 @@
+import { createRewardsHelper } from './reward-helper';
+import { createRewardFetcher } from './fetch-reward';
+import { EventEmitter } from '@jolibox/common';
+import { IUnlockOption, IJoliCoin } from './type';
+
+export const rewardsHelper = createRewardsHelper();
+createRewardFetcher(rewardsHelper);
+
+export * from './registers/use-ads';
+export * from './registers/use-jolicoin';
+
+export interface IUnlockOptionsEvent {
+  options: IUnlockOption[];
+  userJoliCoin: IJoliCoin;
+}
+
+export const UnlockOptionsEventName = 'UNLOCK_OPTIONS_CHANGED' as const;
+export const unlockOptionsEmitter = new EventEmitter<{
+  [UnlockOptionsEventName]: [IUnlockOptionsEvent];
+}>();

package/src/common/rewards/registers/use-ads.ts

@@ -0,0 +1,9 @@
+import { JoliboxAdsImpl, IRewardParams } from '../../ads';
+
+export type AdsRewardsHandler = (params: IRewardParams) => Promise<boolean>;
+export const createAdsRewardHandler = (ads: JoliboxAdsImpl): AdsRewardsHandler => {
+  return async (params: IRewardParams) => {
+    ads.adBreak(params);
+    return true;
+  };
+};

package/src/common/rewards/registers/use-jolicoin.ts

@@ -0,0 +1,96 @@
+import { IHttpClient } from '@/common/http';
+import { context } from '@/common/context';
+import { uuidv4 } from '@jolibox/common';
+import { canUseJolicoin } from './utils';
+import { unlockOptionsEmitter, UnlockOptionsEventName, IUnlockOptionsEvent } from '..';
+import { IAdBreakParams } from '@/common/ads';
+
+interface IJolicoinUnlockRes {
+  code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
+  message: string;
+  data: {
+    transactionId: string;
+    quantity: number;
+    balance: number;
+  };
+}
+
+export type JolicoinRewardsHandler = (params: IAdBreakParams) => Promise<boolean>;
+export const createJolicoinRewardHandler = (
+  httpClient: IHttpClient,
+  {
+    onUnlockSuccess,
+    onUnlockFailed
+  }: {
+    onUnlockSuccess?: (data: { quantity: number; balance: number }) => void;
+    onUnlockFailed?: () => void;
+  }
+): JolicoinRewardsHandler => {
+  let unlockOptionsPromise: Promise<IUnlockOptionsEvent> | null = null;
+  let resolveUnlockOptions: ((value: IUnlockOptionsEvent) => void) | null = null;
+  let cachedUnlockOptions: IUnlockOptionsEvent | null = null;
+
+  const createUnlockOptionsPromise = () => {
+    if (cachedUnlockOptions) {
+      unlockOptionsPromise = Promise.resolve(cachedUnlockOptions);
+      return;
+    }
+
+    unlockOptionsPromise = new Promise<IUnlockOptionsEvent>((resolve) => {
+      resolveUnlockOptions = resolve;
+    });
+  };
+
+  createUnlockOptionsPromise();
+
+  unlockOptionsEmitter.on(UnlockOptionsEventName, (options) => {
+    cachedUnlockOptions = options;
+    if (resolveUnlockOptions) {
+      resolveUnlockOptions(options);
+      resolveUnlockOptions = null;
+    }
+  });
+
+  return async (params: IAdBreakParams) => {
+    try {
+      if (!unlockOptionsPromise) {
+        createUnlockOptionsPromise();
+      }
+      const unlockOptions = await unlockOptionsPromise!;
+      if (!canUseJolicoin(unlockOptions?.options || [], unlockOptions?.userJoliCoin)) {
+        onUnlockFailed?.();
+        return false;
+      }
+
+      const unlockWithJolicoin = await httpClient.post<IJolicoinUnlockRes>('/api/joli-coin/unlock', {
+        data: {
+          // TODO: support drama
+          type: 'GAME_REWARD',
+          reqId: `${uuidv4()}-${context.mpType}-${Date.now()}`,
+          gameInfo: {
+            gameId: context.mpId
+          }
+        }
+      });
+      if (unlockWithJolicoin.code == 'SUCCESS') {
+        onUnlockSuccess?.({
+          quantity: unlockWithJolicoin.data.quantity,
+          balance: unlockWithJolicoin.data.balance
+        });
+        params.adBreakDone?.({
+          breakType: params.type,
+          breakName: 'name' in params ? params.name ?? '' : '',
+          breakFormat: 'reward',
+          breakStatus: 'viewed'
+        });
+        return true;
+      }
+      onUnlockFailed?.();
+      return false;
+    } catch (e) {
+      console.error(`JolicoinRewardHandler error:`, e);
+      onUnlockFailed?.();
+      return false;
+    }
+  };
+};

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

@@ -0,0 +1,11 @@
+import { IJoliCoin, IUnlockOption } from '@/common/rewards/type';
+
+export const canUseJolicoin = (unlockOptions: IUnlockOption[], joliCoin?: IJoliCoin) => {
+  return unlockOptions.some(
+    (option) =>
+      option.type === 'JOLI_COIN' &&
+      option.joliCoinChoices.some(
+        (choice) => choice.joliCoinQuantity <= (joliCoin?.balance ?? 0) && !!joliCoin?.enableAutoDeduct
+      )
+  );
+};

package/src/common/rewards/reward-helper.ts

@@ -0,0 +1,56 @@
+export type RewardType = 'ADS' | 'JOLI_COIN';
+
+import { context } from '../context';
+import type { AdsRewardsHandler } from './registers/use-ads';
+
+export interface RewardHandlerMap {
+  ADS: AdsRewardsHandler;
+  JOLI_COIN: (params?: unknown) => Promise<boolean>;
+}
+
+export type RewardHandler<T extends RewardType> = RewardHandlerMap[T];
+
+const isTestMode = context.testMode;
+export function createRewardsHelper() {
+  const rewardsHandlers = new Map<RewardType, RewardHandler<any>>();
+  let rewardFetcher: ((...args: any[]) => Promise<RewardType[]>) | undefined;
+
+  return {
+    registerRewardHandler<T extends RewardType>(type: T, handler: RewardHandler<T>) {
+      rewardsHandlers.set(type, handler);
+    },
+    async handleReward<T extends RewardType>(rewardsTypes: T[], ...args: Parameters<RewardHandler<T>>) {
+      const result = await rewardsTypes.reduce(async (prevPromise, type) => {
+        const prevResult = await prevPromise;
+        if (prevResult === true) return true;
+
+        isTestMode && console.log(`handleReward ${type}`);
+        const handler = rewardsHandlers.get(type);
+        const nextResult = handler ? await handler(...args) : prevResult;
+        isTestMode && console.log(`handleReward ${type} ${nextResult}`);
+        return nextResult;
+      }, Promise.resolve(false));
+
+      return result;
+    },
+    async registerRewardsFetcher<T extends RewardType>(fetcher: (...args: any[]) => Promise<T[]>) {
+      rewardFetcher = async (...args: unknown[]) => {
+        try {
+          const rewardsTypes = await fetcher(...args);
+          return rewardsTypes;
+        } catch (e) {
+          console.error(`getRewardOptions error:`, e);
+          return ['ADS'];
+        }
+      };
+    },
+    async getRewardsTypes(...args: unknown[]): Promise<RewardType[]> {
+      if (!rewardFetcher) {
+        return ['ADS'];
+      }
+      return await rewardFetcher(...args);
+    }
+  };
+}
+
+export type RewardsHelper = ReturnType<typeof createRewardsHelper>;

package/src/common/rewards/type.ts

@@ -0,0 +1,25 @@
+export interface IJoliCoin {
+  balance: number;
+  enableAutoDeduct: boolean;
+}
+
+export type IUnlockOptionType = 'JOLI_COIN' | 'ADS';
+
+interface IJoliCoinChoice {
+  joliCoinQuantity: number;
+}
+export interface IUnlockOption {
+  type: IUnlockOptionType;
+  joliCoinChoices: IJoliCoinChoice[];
+}
+
+export interface IJolicoinRewardOption {
+  code: 'SUCCESS' | 'ERROR' | 'PARAMETER_ERROR' | 'EPISODE_LOCK_JUMP';
+  message: string;
+  data: {
+    unlockOptions?: IUnlockOption[];
+  };
+  extra: {
+    joliCoin: IJoliCoin;
+  };
+}

package/src/common/utils/index.ts

@@ -1,9 +1,16 @@
 const JOLIBOX_CUSTOM_ADS_EVENT_TYPE = 'JOLIBOX_ADS_EVENT';
+const JOLIBOX_CUSTOM_REWARDS_EVENT_TYPE = 'JOLIBOX_CUSTOM_REWARDS_EVENT';
 
 interface JoliboxCustomEvent {
   [JOLIBOX_CUSTOM_ADS_EVENT_TYPE]: {
     isAdShowing: boolean;
   };
+  [JOLIBOX_CUSTOM_REWARDS_EVENT_TYPE]: {
+    ['JOLI_COIN']?: {
+      quantity: number;
+      balance: number;
+    };
+  };
 }
 
 export const notifyCustomEvent = <T extends keyof JoliboxCustomEvent>(

package/src/h5/api/ads.ts

@@ -3,10 +3,23 @@ import { track } from '../report';
 import { createCommands } from '@jolibox/common';
 import { httpClientManager } from '../http';
 import { notifyCustomEvent } from '@/common/utils';
+import { createAdsRewardHandler, rewardsHelper, createJolicoinRewardHandler } from '@/common/rewards';
+
 const commands = createCommands();
 
 const httpClient = httpClientManager.create();
 const ads = new JoliboxAdsImpl(track, httpClient, () => httpClientManager.getNetworkStatus());
+rewardsHelper.registerRewardHandler('ADS', createAdsRewardHandler(ads));
+rewardsHelper.registerRewardHandler(
+  'JOLI_COIN',
+  createJolicoinRewardHandler(ads.httpClient, {
+    onUnlockSuccess: (params: { quantity: number; balance: number }) => {
+      notifyCustomEvent('JOLIBOX_CUSTOM_REWARDS_EVENT', {
+        JOLI_COIN: params
+      });
+    }
+  }) as unknown as (params?: unknown) => Promise<boolean>
+);
 
 adEventEmitter.on('isAdShowing', (isAdShowing) => {
   notifyCustomEvent('JOLIBOX_ADS_EVENT', { isAdShowing });
@@ -21,7 +34,13 @@ commands.registerCommand('AdsSDK.adConfig', (params) => {
 });
 
 commands.registerCommand('AdsSDK.adBreak', (params) => {
-  ads.adBreak(params);
+  if (params.type === 'reward') {
+    rewardsHelper.getRewardsTypes(ads.httpClient).then((rewardsTypes) => {
+      rewardsHelper.handleReward(rewardsTypes, params);
+    });
+  } else {
+    ads.adBreak(params);
+  }
 });
 
 commands.registerCommand('AdsSDK.adUnit', (params) => {

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

@@ -11,7 +11,7 @@ const API_GET_SYSTEM_SYNC = 'getSystemInfoSync';
 const getSystemInfo = () => {
   let config = {
     system: context.deviceInfo.system,
-    platform: context.deviceInfo.platform,
+    platform: context.deviceInfo.platform.toLowerCase(),
     brand: context.deviceInfo.brand,
     pixelRatio: context.deviceInfo.pixelRatio,
     language: context.deviceInfo.lang,

package/src/h5/http/utils/__tests__/xua.test.ts

@@ -4,7 +4,7 @@ import { isValidUUIDV4 } from '@jolibox/common';
 
 describe('xua', () => {
   it('test xua', () => {
-    // window.__JOLIBOX_LOCAL_SDK_VERSION__ = '1.0.0';
+    (window as any).__joliboxLocalStorage__ = window.localStorage;
     const xua = xUserAgent();
     const deviceInfoRegex = /.* (\(.*\) ).*/;
     const deviceInfoMatch = xua.match(deviceInfoRegex);