@jolibox/implement 1.1.38 → 1.1.40

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

@@ -1,24 +1,20 @@
 import { IHttpClient } from '@/common/http';
 import { context } from '@/common/context';
 import { uuidv4 } from '@jolibox/common';
-import {
-  rewardsEmitter,
-  UnlockOptionsEventName,
-  IUnlockOptionsEvent,
-  InvokePaymentEventName,
-  PaymentResultEventName,
-  IPaymentEvent,
-  IUseModalResultEvent,
-  UseModalEventName,
-  UseModalResultEventName
-} from '@/common/rewards/reward-emitter';
+import { UnlockOptionsEventName, IUnlockOptionsEvent } from '@/common/rewards/reward-emitter';
 import { IAdBreakParams } from '@/common/ads';
-import { joliCoinIsEnough } from '../index';
-import { createEventPromiseHandler, EventPromiseHandler } from '../event-listener';
-import { IJoliCoin } from '@/common/rewards/type';
+import { EventPromiseHandler } from '../event-listener';
 
-type IPaymentResult = 'SUCCESS' | 'FAILED' | 'CANCEL';
-type IUseModalResult = 'CONFIRM' | 'CANCEL' | 'FAILED';
+import {
+  createInitiateAndAwaitPayment,
+  registerUseJolicoinCommand,
+  registerUsePaymentCommand,
+  registerUseUnloginCommand,
+  createShowUnlockWithJolicoinModal,
+  createShowUnloginModal
+} from './commands';
+import { rewardsCommands } from './rewards-command';
+import { RewardsCommandType } from '@jolibox/types';
 
 interface IJolicoinUnlockRes {
   code: 'SUCCESS' | 'BALANCE_NOT_ENOUGH' | 'EPISODE_LOCK_JUMP' | 'EPISODE_UNLOCK_ALREADY';
@@ -30,61 +26,8 @@ interface IJolicoinUnlockRes {
   };
 }
 
-export const createInitiateAndAwaitPayment = (
-  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
-  buttons: {
-    confirmButtonText: string;
-    cancelButtonText: string;
-  }
-) => {
-  return async (params: { userJoliCoin: IJoliCoin; joliCoinQuantity: number }) => {
-    const paymentHandler = createEventPromiseHandler<IPaymentEvent, typeof PaymentResultEventName>(
-      rewardsEmitter,
-      PaymentResultEventName
-    );
-    rewardsEmitter.emit(InvokePaymentEventName, type, {
-      userJoliCoin: params.userJoliCoin,
-      joliCoinQuantity: params.joliCoinQuantity,
-      enableAutoDeduct: params.userJoliCoin.enableAutoDeduct,
-      confirmButtonText: buttons.confirmButtonText,
-      cancelButtonText: buttons.cancelButtonText
-    });
-
-    // Wait for payment result
-    const paymentResult = await paymentHandler.getFreshData();
-    return paymentResult.paymentResult;
-  };
-};
-
-export const createShowUnlockWithJolicoinModal = (
-  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
-  buttons: {
-    confirmButtonText: string;
-    cancelButtonText: string;
-  }
-) => {
-  return async (params: { enableAutoDeduct: boolean; userJoliCoin: IJoliCoin; joliCoinQuantity: number }) => {
-    const modalHandler = createEventPromiseHandler<IUseModalResultEvent, typeof UseModalResultEventName>(
-      rewardsEmitter,
-      UseModalResultEventName
-    );
-    rewardsEmitter.emit(UseModalEventName, type, {
-      enableAutoDeduct: params.enableAutoDeduct,
-      userJoliCoin: params.userJoliCoin,
-      joliCoinQuantity: params.joliCoinQuantity,
-      confirmButtonText: buttons.confirmButtonText,
-      cancelButtonText: buttons.cancelButtonText
-    });
-    const modalResult = await modalHandler.getFreshData();
-    return modalResult.useModalResult;
-  };
-};
-
-const checkIfCancel = (result: IPaymentResult | IUseModalResult) => {
-  return result == 'CANCEL';
-};
-
 export const createCommonJolicoinRewardHandler = (
+  type: 'JOLI_COIN' | 'ADS-JOLI_COIN',
   httpClient: IHttpClient,
   {
     handlers: {
@@ -92,7 +35,8 @@ export const createCommonJolicoinRewardHandler = (
       handleUnlockFailed,
       unlockOptionsHandler,
       initiateAndAwaitPayment,
-      showUnlockWithJolicoinModal
+      showUnlockWithJolicoinModal,
+      showUnloginModal
     }
   }: {
     handlers: {
@@ -101,43 +45,43 @@ export const createCommonJolicoinRewardHandler = (
       unlockOptionsHandler: EventPromiseHandler<IUnlockOptionsEvent, typeof UnlockOptionsEventName>;
       initiateAndAwaitPayment: ReturnType<typeof createInitiateAndAwaitPayment>;
       showUnlockWithJolicoinModal: ReturnType<typeof createShowUnlockWithJolicoinModal>;
+      showUnloginModal: ReturnType<typeof createShowUnloginModal>;
     };
   }
 ) => {
+  // register commands
+  registerUseUnloginCommand(type, {
+    httpClient: httpClient,
+    showUnloginModal: showUnloginModal
+  });
+  registerUsePaymentCommand(type, {
+    httpClient: httpClient,
+    initiateAndAwaitPayment: initiateAndAwaitPayment
+  });
+  registerUseJolicoinCommand(type, {
+    showUnlockWithJolicoinModal: showUnlockWithJolicoinModal
+  });
   return async (params: IAdBreakParams) => {
     try {
-      let shouldSkipConfirm = false;
-      const unlockOptions = await unlockOptionsHandler.getData();
-      const joliCoinQuantity =
-        unlockOptions?.options?.find((option) => option.type === 'JOLI_COIN')?.joliCoinChoices[0]
-          .joliCoinQuantity ?? 0;
-      if (!joliCoinIsEnough(unlockOptions?.options || [], unlockOptions?.userJoliCoin)) {
-        const paymentResult = await initiateAndAwaitPayment({
-          userJoliCoin: unlockOptions?.userJoliCoin,
-          joliCoinQuantity
-        });
+      let result = true;
 
-        if (paymentResult !== 'SUCCESS') {
-          handleUnlockFailed?.(params);
-          return false;
-        }
+      const commands = [
+        `Rewards.${type}.useUnloginModal`,
+        `Rewards.${type}.usePayment`,
+        `Rewards.${type}.useJolicoin`
+      ];
 
-        shouldSkipConfirm = true;
+      for (const command of commands) {
+        const commandResult = await rewardsCommands.executeCommand(command as RewardsCommandType);
+        result = result && commandResult.result !== 'FAILED';
+        if (commandResult.result !== 'CONTINUE') {
+          break;
+        }
       }
 
-      const enableAutoDeduct = !!unlockOptions?.userJoliCoin?.enableAutoDeduct;
-
-      if (!shouldSkipConfirm) {
-        const shouldUnlock = await showUnlockWithJolicoinModal({
-          enableAutoDeduct,
-          userJoliCoin: unlockOptions?.userJoliCoin,
-          joliCoinQuantity
-        });
-
-        if (shouldUnlock !== 'CONFIRM') {
-          handleUnlockFailed?.(params);
-          return false;
-        }
+      if (!result) {
+        handleUnlockFailed?.(params);
+        return false;
       }
 
       const unlockWithJolicoin = await httpClient.post<IJolicoinUnlockRes>('/api/joli-coin/unlock', {
@@ -150,6 +94,8 @@ export const createCommonJolicoinRewardHandler = (
           }
         }
       });
+
+      console.log('-----unlockWithJolicoin request result-----', unlockWithJolicoin);
       if (unlockWithJolicoin.code == 'SUCCESS') {
         params.adBreakDone?.({
           breakType: params.type,

package/src/common/rewards/registers/utils/coins/rewards-command.ts

@@ -0,0 +1,3 @@
+import { createCommands } from '@jolibox/common';
+
+export const rewardsCommands = createCommands();

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

@@ -0,0 +1,8 @@
+import { IUnlockOptionsEvent, UnlockOptionsEventName } from '../../reward-emitter';
+import { createEventPromiseHandler } from './event-listener';
+import { rewardsEmitter } from '../../reward-emitter';
+
+export const unlockOptionsHandler = createEventPromiseHandler<
+  IUnlockOptionsEvent,
+  typeof UnlockOptionsEventName
+>(rewardsEmitter, UnlockOptionsEventName);

package/src/common/rewards/registers/utils/event-listener.ts

@@ -57,6 +57,19 @@ export function createEventPromiseHandler<T, E extends string = string>(
       dataPromise = null;
       createDataPromise();
       return dataPromise!;
+    },
+
+    updateData: (newData: Partial<T>) => {
+      if (!cachedData) {
+        return;
+      }
+      cachedData = { ...cachedData, ...newData };
+      dataPromise = Promise.resolve(cachedData);
+      if (resolveData) {
+        resolveData(cachedData);
+        resolveData = null;
+      }
+      return cachedData;
     }
   };
 }

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

@@ -15,6 +15,8 @@ export const PaymentResultEventName = 'ON_PAYMENT_RESULT' as const;
 export const UseModalEventName = 'ON_USE_MODAL_EVENT' as const;
 export const UseModalResultEventName = 'ON_USE_MODAL_RESULT' as const;
 export const UseModalFrequencyEventName = 'ON_USE_MODAL_FREQUENCY' as const;
+export const UseUnloginModalResultEventName = 'ON_USE_UNLOGIN_MODAL_EVENT' as const;
+export const InvokeUnloginModalEventName = 'INVOKE_UNLOGIN_MODAL_EVENT' as const;
 
 type IPaymentResult = 'SUCCESS' | 'FAILED' | 'CANCEL';
 export interface IPaymentEvent {
@@ -47,21 +49,41 @@ export interface IUseModalEvent {
   sequenceId?: string;
 }
 
+export interface IUseUnloginModalEvent {
+  confirmButtonText: string;
+  cancelButtonText: string;
+}
+
 export interface IUseModalResultEvent {
   useModalResult: 'CONFIRM' | 'CANCEL' | 'FAILED';
 }
 
+export interface IUseUnloginModalResultEvent {
+  result: 'SUCCESS' | 'CANCEL' | 'ADS' | 'FAILED' | 'NOT_SUPPORT';
+  rewards?: {
+    jolicoin?: {
+      claimedRewardValue: number;
+      isFirstLogin: boolean;
+    };
+  };
+}
+
 export interface IUseModalFrequencyConfig {
   joliCoinUseAndCharge: {
     useJolicoin: {
-      dailyMaxPopUps: number;
-      minInterval: number;
+      dailyMaxPopUps?: number;
+      minInterval?: number;
     };
     charge: {
-      dailyMaxPopUps: number;
-      minInterval: number;
+      dailyMaxPopUps?: number;
+      minInterval?: number;
     };
   };
+  loginGuide: {
+    show: boolean;
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+  };
 }
 
 export interface RewardsEventMap extends Record<string, unknown[]> {
@@ -71,6 +93,8 @@ export interface RewardsEventMap extends Record<string, unknown[]> {
   [UseModalResultEventName]: [IUseModalResultEvent];
   [UseModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IUseModalEvent];
   [UseModalFrequencyEventName]: [IUseModalFrequencyConfig];
+  [InvokeUnloginModalEventName]: ['JOLI_COIN' | 'ADS-JOLI_COIN', IUseUnloginModalEvent];
+  [UseUnloginModalResultEventName]: [IUseUnloginModalResultEvent];
 }
 
 export const originalRewardsEmitter = new EventEmitter<RewardsEventMap>();
@@ -106,3 +130,8 @@ export const DefaltJoliCoinUseAndCharge = {
     minInterval: 8 * 60 * 60 * 1000
   }
 };
+
+export const DefaltLoginGuide = {
+  show: true,
+  minInterval: 8 * 60 * 60 * 1000
+};

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

@@ -2,7 +2,7 @@ export type RewardType = 'ADS' | 'JOLI_COIN' | 'JOLI_COIN_ONLY';
 
 import { context } from '../context';
 import type { AdsRewardsHandler } from './registers/use-ads';
-import { IUseModalFrequencyConfig, DefaltJoliCoinUseAndCharge } from './reward-emitter';
+import { IUseModalFrequencyConfig, DefaltJoliCoinUseAndCharge, DefaltLoginGuide } from './reward-emitter';
 
 export interface RewardHandlerMap {
   ADS: AdsRewardsHandler;
@@ -57,7 +57,7 @@ export function createRewardsHelper() {
           return config;
         } catch (e) {
           console.error(`getRewardOptions error:`, e);
-          return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge };
+          return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge, loginGuide: DefaltLoginGuide };
         }
       };
     },
@@ -70,7 +70,7 @@ export function createRewardsHelper() {
     },
     async getRewardFrequencyConfig(...args: unknown[]): Promise<IUseModalFrequencyConfig> {
       if (!rewardFrequencyConfigFetcher) {
-        return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge };
+        return { joliCoinUseAndCharge: DefaltJoliCoinUseAndCharge, loginGuide: DefaltLoginGuide };
       }
       return await rewardFrequencyConfigFetcher(...args);
     }

package/src/common/utils/index.ts

@@ -5,6 +5,8 @@ const JOLIBOX_CUSTOM_ADS_EVENT_TYPE = 'JOLIBOX_ADS_EVENT';
 const JOLIBOX_CUSTOM_REWARDS_EVENT_TYPE = 'JOLIBOX_CUSTOM_REWARDS_EVENT';
 const JOLIBOX_TOPUP_EVENT = 'JOLIBOX_TOPUP_EVENT';
 const JOLIBOX_JOLI_COIN_USE_EVENT = 'JOLIBOX_JOLI_COIN_USE_EVENT';
+const JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT = 'JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT'; // unlogin modal event, triggered when unlogin
+// unlogin modal result event success.
 
 interface JoliboxCustomEvent {
   [JOLIBOX_CUSTOM_ADS_EVENT_TYPE]: {
@@ -35,6 +37,10 @@ interface JoliboxCustomEvent {
     type: 'ADS-JOLI_COIN' | 'JOLI_COIN';
     sequenceId: string;
   };
+  [JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT]: {
+    sequenceId: string;
+    type: 'ADS-JOLI_COIN' | 'JOLI_COIN';
+  };
 }
 
 const notifyCustomEvent = <T extends keyof JoliboxCustomEvent>(eventName: T, data: JoliboxCustomEvent[T]) => {
@@ -58,6 +64,7 @@ const notifyCustomEvent = <T extends keyof JoliboxCustomEvent>(eventName: T, dat
 
 const ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT = 'ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT';
 const ON_JOLIBOX_JOLI_COIN_USE_RESULT = 'ON_JOLIBOX_JOLI_COIN_USE_RESULT';
+const ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT = 'ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT';
 
 interface ReceivedJoliboxCustomEvent {
   [ON_JOLIBOX_TOPUP_JOLI_COIN_RESULT]: {
@@ -73,6 +80,19 @@ interface ReceivedJoliboxCustomEvent {
     sequenceId: string;
     result: 'USE_COIN' | 'ADS' | 'CANCEL';
   };
+  [ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT]: {
+    sequenceId: string;
+    result: 'SUCCESS' | 'CANCEL' | 'ADS' | 'FAILED' | 'NOT_SUPPORT';
+    extra?: {
+      firstLogin?: {
+        reward: {
+          rewardValue: number;
+          rewardType: 'JOLI_COIN';
+        };
+      };
+    };
+    isFirstLogin?: boolean;
+  };
 }
 
 type ReceivedJoliboxCustomEventResult = keyof ReceivedJoliboxCustomEvent;

package/src/h5/bootstrap/index.ts

@@ -3,7 +3,7 @@ import { taskTracker, track } from '../report';
 import { onFCP, onLCP, onTTFB } from 'web-vitals';
 import { context } from '@/common/context';
 import { httpClientManager } from '../http';
-import { IResponse } from '@jolibox/ads';
+import { StandardResponse } from '@jolibox/types';
 import { reportError } from '@/common/report/errors/report';
 
 function trackPerformance() {
@@ -32,9 +32,27 @@ function trackPerformance() {
   });
 }
 
+async function checkSession(): Promise<boolean> {
+  const httpClient = httpClientManager.create();
+  try {
+    const response = await httpClient.get<StandardResponse<void>>('/api/users/info');
+    if (response.code !== 'SUCCESS' || !response.data) {
+      return false;
+    }
+    return true;
+  } catch (error) {
+    reportError(new InternalGlobalJSError(error as Error));
+    return false;
+  }
+}
+
 function addDomContentLoaded() {
   hostEmitter.on('onDocumentReady', async (startTime: number) => {
-    hostEmitter.emit('LifecycleEvent.onReady', { isLogin: false });
+    const isLogin = await checkSession();
+    context.onEnvConfigChanged({ hostUserInfo: { isLogin } });
+    hostEmitter.emit('LifecycleEvent.onReady', {
+      ...(context.hostUserInfo ? context.hostUserInfo : { isLogin: false })
+    });
 
     if (context.mpType === 'game') {
       taskTracker.start(Date.now() - startTime);

package/src/h5/rewards/index.ts

@@ -2,6 +2,7 @@
  * rewards event handlers
  */
 
+import { context } from '@/common/context';
 import {
   rewardsEmitter,
   UseModalEventName,
@@ -10,7 +11,9 @@ import {
   UseModalResultEventName,
   InvokePaymentEventName,
   IInvokePaymentEvent,
-  IUseModalResultEvent
+  IUseModalResultEvent,
+  UseUnloginModalResultEventName,
+  InvokeUnloginModalEventName
 } from '@/common/rewards/reward-emitter';
 import { notifyCustomEvent, onCustomEvent } from '@/common/utils';
 import { uuidv4 as v4 } from '@jolibox/common';
@@ -67,3 +70,28 @@ rewardsEmitter.on(
     });
   }
 );
+
+// unlogin modal
+onCustomEvent('ON_JOLIBOX_JOLI_UNLOGIN_MODAL_RESULT_EVENT', (data) => {
+  rewardsEmitter.emit(UseUnloginModalResultEventName, {
+    result: data.result == 'ADS' ? 'FAILED' : data.result,
+    rewards: {
+      jolicoin: {
+        claimedRewardValue: data.extra?.firstLogin?.reward?.rewardValue ?? 0,
+        isFirstLogin: data.isFirstLogin ?? false
+      }
+    }
+  });
+
+  if (data.result === 'SUCCESS') {
+    context.onEnvConfigChanged({ hostUserInfo: { isLogin: true } });
+  }
+});
+
+rewardsEmitter.on(InvokeUnloginModalEventName, async (type) => {
+  // 未登录面板
+  notifyCustomEvent('JOLIBOX_JOLI_UNLOGIN_MODAL_EVENT', {
+    sequenceId: v4(),
+    type: type
+  });
+});

package/src/native/api/ads.ts

@@ -142,18 +142,28 @@ const adConfig = createSyncAPI('adConfig', {
   }
 });
 
+let rewardLocked = false;
 const adBreak = createSyncAPI('adBreak', {
   implement: (params: IAdBreakParams) => {
     if (params.type === 'reward') {
+      if (rewardLocked) {
+        return;
+      }
+      rewardLocked = true;
       rewardsHelper.getRewardsTypes(httpClient).then((rewardsTypes) => {
-        rewardsHelper.handleReward(rewardsTypes, params).catch((e) => {
-          console.info('handleReward failed in native', e);
-          params.adBreakDone?.({
-            breakType: params.type,
-            breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
-            breakStatus: 'noAdPreloaded'
+        rewardsHelper
+          .handleReward(rewardsTypes, params)
+          .catch((e) => {
+            console.info('handleReward failed in native', e);
+            params.adBreakDone?.({
+              breakType: params.type,
+              breakFormat: params.type === 'reward' ? 'reward' : 'interstitial',
+              breakStatus: 'noAdPreloaded'
+            });
+          })
+          .finally(() => {
+            rewardLocked = false;
           });
-        });
       });
     } else {
       ads.adBreak(params);

package/src/native/api/login.ts

@@ -23,16 +23,74 @@ registerCanIUse('checkSession', {
   }
 });
 
-const loginDeferredMap = new Map<string, Deferred<{ isLogin: boolean; token?: string }>>();
+const loginDeferredMap = new Map<
+  string,
+  Deferred<{ isLogin: boolean; token?: string; isFirstLogin?: boolean; extra?: LoginExtra }>
+>();
 
-onNative('onLoginStateChange', ({ isLogin, token, uuid }) => {
+onNative('onLoginStateChange', ({ isLogin, token, uuid, isFirstLogin, extra }) => {
   const deferred = loginDeferredMap.get(uuid);
   if (deferred) {
-    deferred.resolve({ isLogin, token });
+    deferred.resolve({ isLogin, token, isFirstLogin, extra });
     loginDeferredMap.delete(uuid);
   }
 });
 
+type LoginExtra = {
+  firstLogin?: {
+    reward: {
+      rewardType: 'JOLI_COIN';
+      rewardValue: number;
+    };
+  };
+};
+
+export const loginImplement = async (
+  params: { skipLogin?: boolean; triggerFrom?: string },
+  needExtra = false
+): Promise<{
+  isLogin: boolean;
+  token?: string;
+  isFirstLogin?: boolean;
+  extra?: LoginExtra;
+}> => {
+  const {
+    data: { isLogin }
+  } = await applyNative('checkLoginAsync');
+  if (isLogin) {
+    return { isLogin: true, token: context.hostUserInfo?.token };
+  }
+
+  const { skipLogin, triggerFrom } = params ?? {};
+  const res = invokeNative('loginSync', {
+    skipLogin,
+    triggerFrom
+  });
+
+  const {
+    data: { uuid: loginUUID }
+  } = res;
+  if (!loginUUID) {
+    throw createAPIError({
+      code: -1,
+      msg: 'login failed'
+    });
+  }
+
+  const deferred = new Deferred<{
+    isLogin: boolean;
+    token?: string;
+    isFirstLogin?: boolean;
+    extra?: LoginExtra;
+  }>();
+  loginDeferredMap.set(loginUUID, deferred);
+  const loginRes = await deferred.promise;
+  context.onEnvConfigChanged({ hostUserInfo: loginRes });
+  const { extra, ...rest } = loginRes;
+  hostEmitter.emit('onLoginComplete', rest);
+  return needExtra ? loginRes : rest;
+};
+
 export const login = createAPI('login', {
   paramsSchema: t.tuple(
     t
@@ -43,35 +101,7 @@ export const login = createAPI('login', {
       .optional()
   ),
   async implement(params) {
-    const {
-      data: { isLogin }
-    } = await applyNative('checkLoginAsync');
-    if (isLogin) {
-      return { isLogin: true, token: context.hostUserInfo?.token };
-    }
-
-    const { skipLogin, triggerFrom } = params ?? {};
-    const res = invokeNative('loginSync', {
-      skipLogin,
-      triggerFrom
-    });
-
-    const {
-      data: { uuid: loginUUID }
-    } = res;
-    if (!loginUUID) {
-      throw createAPIError({
-        code: -1,
-        msg: 'login failed'
-      });
-    }
-
-    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;
+    return await loginImplement(params ?? {});
   }
 });