@jolibox/implement 1.1.56 → 1.2.0-beta.9

package/src/native/rewards/ui/payment-modal.ts

@@ -14,7 +14,12 @@ import { context } from '@/common/context';
 import { login } from '@/native/api/login';
 import { EventType } from '@jolibox/common';
 
-import { checkPaymentFrequency, updatePaymentFrequency } from '../check-frequency';
+import {
+  checkPaymentFrequency,
+  updatePaymentFrequency,
+  checkPaymentFrequencyGem,
+  updatePaymentFrequencyGem
+} from '../check-frequency';
 import { paymentHelper } from '@/native/payment';
 import { createLoading } from '@jolibox/ui';
 import { canIUseNative } from '@/native/api/base';
@@ -23,6 +28,60 @@ import { isUndefinedOrNull } from '@jolibox/common';
 import { track } from '@/native/report';
 import { updateAutoDeductConfig } from './utils';
 import { createEventPromiseHandler } from '@/common/rewards/registers/utils/event-listener';
+import { TrackEvent } from '@jolibox/types';
+
+// 货币配置映射
+interface CurrencyPaymentConfig {
+  frequencyConfigKey: keyof IUseModalFrequencyConfig['joliCoinUseAndCharge'];
+  trackEvents: {
+    modalShow: TrackEvent;
+    orderClick: TrackEvent;
+    payEnsure: TrackEvent;
+    payResult: TrackEvent;
+    adUnlock: TrackEvent;
+  };
+  frequencyChecker: (config: {
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+  }) => Promise<{ canShow: boolean; isFirst: boolean }>;
+  frequencyUpdater: () => Promise<void>;
+  apiEndpoint: string;
+  paymentType: 'JOLI_COIN_IAP' | 'JOLI_GEM_IAP';
+  apiEndpointAutoDeduct: string;
+}
+
+const CURRENCY_PAYMENT_CONFIG: Record<'JOLI_COIN' | 'JOLI_GEM', CurrencyPaymentConfig> = {
+  JOLI_COIN: {
+    frequencyConfigKey: 'charge',
+    trackEvents: {
+      modalShow: 'coinorder_show',
+      orderClick: 'coinorder_click',
+      payEnsure: 'order_pay_ensure',
+      payResult: 'order_pay_result',
+      adUnlock: 'ad_unlock_click'
+    },
+    frequencyChecker: checkPaymentFrequency,
+    frequencyUpdater: updatePaymentFrequency,
+    apiEndpoint: '/api/joli-coin/balance-detail',
+    apiEndpointAutoDeduct: '/api/joli-coin/user-config',
+    paymentType: 'JOLI_COIN_IAP'
+  },
+  JOLI_GEM: {
+    frequencyConfigKey: 'charge', // 暂时复用，可后续扩展
+    trackEvents: {
+      modalShow: 'gem_order_show',
+      orderClick: 'gem_order_click',
+      payEnsure: 'gem_pay_ensure',
+      payResult: 'gem_pay_result',
+      adUnlock: 'gem_ad_unlock_click'
+    },
+    frequencyChecker: checkPaymentFrequencyGem,
+    frequencyUpdater: updatePaymentFrequencyGem,
+    apiEndpoint: '/api/joli-gem/balance-detail',
+    apiEndpointAutoDeduct: '/api/joli-gem/user-config',
+    paymentType: 'JOLI_GEM_IAP'
+  }
+};
 
 const loading = createLoading();
 
@@ -35,32 +94,35 @@ const modalUseFrequencyConfig = createEventPromiseHandler<
  */
 rewardsEmitter.on(
   InvokePaymentEventName,
-  async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IInvokePaymentEvent) => {
+  async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM', params: IInvokePaymentEvent) => {
     try {
+      // 获取货币类型配置
+      const currencyType = params.currency;
+      const paymentConfig = CURRENCY_PAYMENT_CONFIG[currencyType];
       // TODO： temp remove it for dev
       if (!canIUseNative('requestPaymentSync:paymentBody:appStoreProductId')) {
         //TODO: show Toast
         console.info('requestPaymentSync:paymentBody:appStoreProductId not supported');
         setTimeout(() => {
-          rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
+          rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED', currency: currencyType });
         }, 0);
         return;
       }
 
       // handle showup frequecy
-      if (type === 'ADS-JOLI_COIN') {
+      if (type.includes('ADS-')) {
         await loading.show({
           duration: 3000
         });
         const config = await modalUseFrequencyConfig.getData();
-        const { canShow: canShowPaymentModal } = await checkPaymentFrequency(
-          config.joliCoinUseAndCharge.charge
+        const { canShow: canShowPaymentModal } = await paymentConfig.frequencyChecker(
+          config.joliCoinUseAndCharge[paymentConfig.frequencyConfigKey]
         );
-        console.log('use payment show by frequency', canShowPaymentModal);
+        console.log(`${currencyType} payment show by frequency`, canShowPaymentModal);
         loading.hide();
         if (!canShowPaymentModal) {
           // return by frequency control
-          rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
+          rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED', currency: currencyType });
           return;
         }
         console.log('show by frequency');
@@ -72,23 +134,25 @@ rewardsEmitter.on(
       await loading.show({
         duration: 3000
       });
-      const balenceDetails = await getBalenceDetails();
+      const balenceDetails = await getBalenceDetails(paymentConfig.apiEndpoint);
       loading.hide();
 
       if (!balenceDetails) {
-        rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
+        rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED', currency: currencyType });
         return;
       }
 
-      track('coinorder_show', {
+      track(paymentConfig.trackEvents.modalShow, {
         targetType: 'game',
-        eventType: EventType.View
+        eventType: EventType.View,
+        currency: currencyType
       });
 
       const modal = createPaymentJolicoinModal({
         data: {
-          userJolicoin: params.userJoliCoin,
-          joliCoinQuantity: params.joliCoinQuantity,
+          userCurrency: params.userCurrency,
+          quantity: params.quantity,
+          currency: currencyType,
           paymentChoices:
             balenceDetails.paymentChoices?.map((choice) => ({
               ...choice,
@@ -100,11 +164,12 @@ rewardsEmitter.on(
           confirm: {
             text: params.confirmButtonText,
             onPress: async (productId: string) => {
-              track('order_pay_ensure', {
+              track(paymentConfig.trackEvents.payEnsure, {
                 targetType: 'game',
                 eventType: EventType.Click,
                 payWay: 'app_iap',
-                coinAmount: params.joliCoinQuantity,
+                coinAmount: params.quantity,
+                currency: currencyType,
                 orderPrice:
                   balenceDetails.paymentChoices.find((choice) => choice.productId === productId)
                     ?.totalAmountStr ?? ''
@@ -118,9 +183,12 @@ rewardsEmitter.on(
                   return;
                 }
 
-                const balenceDetails = await getBalenceDetails();
-                if ((balenceDetails?.balance ?? 0) >= params.joliCoinQuantity) {
-                  rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
+                const balenceDetails = await getBalenceDetails(paymentConfig.apiEndpoint);
+                if ((balenceDetails?.balance ?? 0) >= params.quantity) {
+                  rewardsEmitter.emit(PaymentResultEventName, {
+                    paymentResult: 'SUCCESS',
+                    currency: currencyType
+                  });
                   modal.destroy();
                   return;
                 }
@@ -131,34 +199,42 @@ rewardsEmitter.on(
               )?.appStoreProductId;
 
               if (!appStoreProductId) {
-                rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
+                rewardsEmitter.emit(PaymentResultEventName, {
+                  paymentResult: 'FAILED',
+                  currency: currencyType
+                });
                 modal.destroy();
                 return;
               }
               await loading.show({
                 duration: 3000
               });
-              const { code } = await paymentHelper.invokePayment('JOLI_COIN_IAP', {
+              const { code } = await paymentHelper.invokePayment(paymentConfig.paymentType, {
                 productId,
                 appStoreProductId
               });
               loading.hide();
-              track('order_pay_result', {
+              track(paymentConfig.trackEvents.payResult, {
                 eventType: EventType.Other,
                 targetType: 'game',
                 payWay: 'app_iap',
-                coinAmount: params.joliCoinQuantity,
+                coinAmount: params.quantity,
+                currency: currencyType,
                 orderPrice:
                   balenceDetails.paymentChoices.find((choice) => choice.productId === productId)
                     ?.totalAmountStr ?? '',
                 payResult: code
               });
+              console.log('payment result', code);
               if (code !== 'SUCCESS') {
                 /** add timeout for google panel closed */
                 console.info('[JoliboxSDK] payment failed in payment.invokePaymet');
                 return;
               }
-              rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
+              rewardsEmitter.emit(PaymentResultEventName, {
+                paymentResult: 'SUCCESS',
+                currency: currencyType
+              });
               modal.destroy();
             }
           },
@@ -166,24 +242,27 @@ rewardsEmitter.on(
             text: params.cancelButtonText,
             onPress: ({ type }) => {
               rewardsEmitter.emit(PaymentResultEventName, {
-                paymentResult: (type ?? '') === 'CANCEL' ? 'CANCEL' : 'FAILED'
+                paymentResult: (type ?? '') === 'CANCEL' ? 'CANCEL' : 'FAILED',
+                currency: currencyType
               });
-              track('ad_unlock_click', {
+              track(paymentConfig.trackEvents.adUnlock, {
                 targetType: 'game',
-                eventType: EventType.Click
+                eventType: EventType.Click,
+                currency: currencyType
               });
               modal.destroy();
             }
           },
           onEnableDeductChanged: async (enabled: boolean) => {
-            await updateAutoDeductConfig(enabled);
+            await updateAutoDeductConfig(enabled, paymentConfig.apiEndpointAutoDeduct);
           }
         },
         onSelect: (productId: string) => {
-          track('coinorder_click', {
+          track(paymentConfig.trackEvents.orderClick, {
             targetType: 'game',
             eventType: EventType.Click,
-            coinAmount: params.joliCoinQuantity,
+            coinAmount: params.quantity,
+            currency: currencyType,
             orderPrice:
               balenceDetails.paymentChoices.find((choice) => choice.productId === productId)
                 ?.totalAmountStr ?? ''
@@ -191,10 +270,10 @@ rewardsEmitter.on(
         }
       });
 
-      await updatePaymentFrequency();
+      await paymentConfig.frequencyUpdater();
     } catch (error) {
       console.info('payment failed', error);
-      rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
+      rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED', currency: params.currency });
     }
   }
 );
@@ -215,7 +294,9 @@ const mergeResponseData = (
   ) as IPaymentChoice[];
 };
 
-const getBalenceDetails = async (): Promise<
+const getBalenceDetails = async (
+  apiEndpoint: string
+): Promise<
   | {
       balance: number;
       enableAutoDeduct: boolean;
@@ -229,7 +310,7 @@ const getBalenceDetails = async (): Promise<
       enableAutoDeduct: boolean;
       paymentChoices: IPaymentChoice[];
     }>
-  >('/api/joli-coin/balance-detail', {
+  >(apiEndpoint, {
     method: 'GET',
     appendHostCookie: true,
     responseType: 'json'

package/src/native/rewards/ui/unlogin-modal.ts

@@ -6,8 +6,13 @@ import {
   UseUnloginModalResultEventName
 } from '@/common/rewards/reward-emitter';
 import { createEventPromiseHandler } from '@/common/rewards/registers/utils/event-listener';
-import { checkUnloginModalFrequency, updateUnloginModalFrequency } from '../check-frequency';
-import { StandardResponse } from '@jolibox/types';
+import {
+  checkUnloginModalFrequency,
+  updateUnloginModalFrequency,
+  checkUnloginModalFrequencyGem,
+  updateUnloginModalFrequencyGem
+} from '../check-frequency';
+import { StandardResponse, TrackEvent } from '@jolibox/types';
 import { innerFetch as fetch } from '@/native/network';
 import { reportError } from '@/common/report/errors/report';
 import { EventType, InternalInvokeMethodError } from '@jolibox/common';
@@ -15,6 +20,63 @@ import { loginImplement } from '@/native/api/login';
 import { createToast, createUnloginJolicoinModal } from '@jolibox/ui';
 import { track } from '@/native/report';
 
+// 货币配置映射
+interface CurrencyUnloginConfig {
+  frequencyChecker: (config: {
+    show: boolean;
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+  }) => Promise<{ canShow: boolean; isFirst: boolean }>;
+  frequencyUpdater: () => Promise<void>;
+  trackEvents: {
+    modalExpose: TrackEvent;
+    clickConfirm: TrackEvent;
+    clickConfirmLogin: TrackEvent;
+    modalHide: TrackEvent;
+    clickClose: TrackEvent;
+    clickWatchAds: TrackEvent;
+  };
+  toastMessage: {
+    i18nKey: string;
+    usedText: string;
+  };
+}
+
+const CURRENCY_UNLOGIN_CONFIG: Record<'JOLI_COIN' | 'JOLI_GEM', CurrencyUnloginConfig> = {
+  JOLI_COIN: {
+    frequencyChecker: checkUnloginModalFrequency,
+    frequencyUpdater: updateUnloginModalFrequency,
+    trackEvents: {
+      modalExpose: 'LoginGuideModal',
+      clickConfirm: 'LoginGuideModal',
+      clickConfirmLogin: 'LoginGuideModal',
+      modalHide: 'LoginGuideModal',
+      clickClose: 'LoginGuideModal',
+      clickWatchAds: 'LoginGuideModal'
+    },
+    toastMessage: {
+      i18nKey: '{slot-i18ntran-loginGuide.rewardTips}',
+      usedText: 'Jolicoin Used'
+    }
+  },
+  JOLI_GEM: {
+    frequencyChecker: checkUnloginModalFrequencyGem,
+    frequencyUpdater: updateUnloginModalFrequencyGem,
+    trackEvents: {
+      modalExpose: 'GemLoginGuideModal', // 暂时复用，可后续扩展为 GemLoginGuideModal
+      clickConfirm: 'GemLoginGuideModal',
+      clickConfirmLogin: 'GemLoginGuideModal',
+      modalHide: 'GemLoginGuideModal',
+      clickClose: 'GemLoginGuideModal',
+      clickWatchAds: 'GemLoginGuideModal'
+    },
+    toastMessage: {
+      i18nKey: '{slot-i18ntran-loginGuide.gemRewardTips}',
+      usedText: 'Gem Used'
+    }
+  }
+};
+
 const unloginModalConfig = createEventPromiseHandler<
   IUseModalFrequencyConfig,
   typeof UseModalFrequencyEventName
@@ -22,109 +84,142 @@ const unloginModalConfig = createEventPromiseHandler<
 
 unloginModalConfig.getData();
 
-rewardsEmitter.on(InvokeUnloginModalEventName, async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params) => {
-  try {
-    if (type === 'ADS-JOLI_COIN') {
-      const config = await unloginModalConfig.getData();
-      console.log('unlogin guide config', config.loginGuide);
+rewardsEmitter.on(
+  InvokeUnloginModalEventName,
+  async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN' | 'JOLI_GEM' | 'ADS-JOLI_GEM', params) => {
+    try {
+      // 获取货币类型配置
+      const currencyType = params.currency;
+      const unloginConfig = CURRENCY_UNLOGIN_CONFIG[currencyType];
 
-      if (!config.loginGuide.show) {
-        rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'NOT_SUPPORT' });
-        return;
+      if (type.includes('ADS-')) {
+        const config = await unloginModalConfig.getData();
+        console.log(`${currencyType} unlogin guide config`, config.loginGuide);
+
+        if (!config.loginGuide.show) {
+          rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'NOT_SUPPORT' });
+          return;
+        }
+        const { canShow: canShowUseModal } = await unloginConfig.frequencyChecker(config.loginGuide);
+
+        console.log(`${currencyType} canShowUseModal`, canShowUseModal);
+        if (!canShowUseModal) {
+          rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'FAILED' });
+          return;
+        }
       }
-      const { canShow: canShowUseModal } = await checkUnloginModalFrequency(config.loginGuide);
 
-      console.log('canShowUseModal', canShowUseModal);
-      if (!canShowUseModal) {
-        rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'FAILED' });
+      const { firstLogin } = (await getRewardCoin()) ?? {};
+      if (!firstLogin?.reward) {
+        console.log('[JoliboxSDK] unlogin modal reward is empty');
+        rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'NOT_SUPPORT' });
         return;
       }
-    }
-
-    const { firstLogin } = (await getRewardCoin()) ?? {};
-    if (!firstLogin?.reward) {
-      console.log('[JoliboxSDK] unlogin modal reward is empty');
-      rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'NOT_SUPPORT' });
-      return;
-    }
 
-    track(
-      'LoginGuideModal',
-      {
-        eventType: EventType.Expose
-      },
-      EventType.Expose
-    );
-    const modal = createUnloginJolicoinModal({
-      data: {
-        rewardType: type,
-        rewardValue: firstLogin.reward.rewardValue
-      },
-      buttons: {
-        confirm: {
-          text: params.confirmButtonText,
-          onPress: async () => {
-            track('LoginGuideModal', { type: 'click_confirm', eventType: EventType.Click }, EventType.Click);
-            const { isLogin, extra, isFirstLogin } = await loginImplement({}, true);
-            if (!isLogin) {
-              console.log('login failed');
-              return;
-            }
+      // 根据货币类型上报不同的埋点
+      track(
+        unloginConfig.trackEvents.modalExpose,
+        {
+          eventType: EventType.Expose,
+          currency: currencyType
+        },
+        EventType.Expose
+      );
+      const modal = createUnloginJolicoinModal({
+        data: {
+          rewardType: type,
+          rewardValue: firstLogin.reward.rewardValue,
+          currency: params.currency
+        },
+        buttons: {
+          confirm: {
+            text: params.confirmButtonText,
+            onPress: async () => {
+              // 根据货币类型上报不同的埋点
+              track(
+                unloginConfig.trackEvents.clickConfirm,
+                { type: 'click_confirm', eventType: EventType.Click, currency: currencyType },
+                EventType.Click
+              );
+              const { isLogin, extra, isFirstLogin } = await loginImplement({}, true);
+              if (!isLogin) {
+                console.log('login failed');
+                return;
+              }
 
-            track(
-              'LoginGuideModal',
-              { type: 'click_confirm_login', isFirstLogin, eventType: EventType.Click },
-              EventType.Click
-            );
-            if (isFirstLogin && extra?.firstLogin?.reward) {
-              const { rewardValue } = extra.firstLogin.reward;
-              createToast(`{slot-i18ntran-loginGuide.rewardTips}`, {
-                i18nParams: {
-                  text: 'Jolicoin Used',
-                  coin: rewardValue
+              track(
+                unloginConfig.trackEvents.clickConfirmLogin,
+                {
+                  type: 'click_confirm_login',
+                  isFirstLogin,
+                  eventType: EventType.Click,
+                  currency: currencyType
                 },
-                position: 'top',
-                duration: 3000
-              });
-            }
+                EventType.Click
+              );
+              if (isFirstLogin && extra?.firstLogin?.reward) {
+                const { rewardValue } = extra.firstLogin.reward;
+                createToast(unloginConfig.toastMessage.i18nKey, {
+                  i18nParams: {
+                    text: unloginConfig.toastMessage.usedText,
+                    coin: rewardValue
+                  },
+                  position: 'top',
+                  duration: 3000
+                });
+              }
 
-            rewardsEmitter.emit(UseUnloginModalResultEventName, {
-              result: 'SUCCESS',
-              rewards: {
-                jolicoin: {
+              rewardsEmitter.emit(UseUnloginModalResultEventName, {
+                result: 'SUCCESS',
+                rewards: {
                   claimedRewardValue: extra?.firstLogin?.reward?.rewardValue ?? 0,
-                  isFirstLogin: isFirstLogin ?? false
+                  isFirstLogin: isFirstLogin ?? false,
+                  currency: params.currency
                 }
-              }
-            });
-            modal.destroy();
-            return;
-          }
-        },
-        cancel: {
-          text: params.cancelButtonText,
-          onPress: ({ type }) => {
-            track('LoginGuideModal', { eventType: EventType.Hide }, EventType.Hide);
-
-            const trackType = type === 'CANCEL' ? 'click_close' : 'click_watch_ads';
-            track('LoginGuideModal', { type: trackType, eventType: EventType.Click }, EventType.Click);
-            rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'FAILED' });
-            modal.destroy();
+              });
+              modal.destroy();
+              return;
+            }
+          },
+          cancel: {
+            text: params.cancelButtonText,
+            onPress: ({ type }) => {
+              // 根据货币类型上报不同的埋点
+              track(
+                unloginConfig.trackEvents.modalHide,
+                { eventType: EventType.Hide, currency: currencyType },
+                EventType.Hide
+              );
+
+              const trackType = type === 'CANCEL' ? 'click_close' : 'click_watch_ads';
+              const trackEvent =
+                type === 'CANCEL'
+                  ? unloginConfig.trackEvents.clickClose
+                  : unloginConfig.trackEvents.clickWatchAds;
+
+              track(
+                trackEvent,
+                { type: trackType, eventType: EventType.Click, currency: currencyType },
+                EventType.Click
+              );
+              rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'FAILED' });
+              modal.destroy();
+            }
           }
         }
-      }
-    });
-    await updateUnloginModalFrequency();
-  } catch (e) {
-    reportError(new InternalInvokeMethodError(e as Error));
-    rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'FAILED' });
+      });
+      await unloginConfig.frequencyUpdater();
+    } catch (e) {
+      reportError(new InternalInvokeMethodError(e as Error));
+      rewardsEmitter.emit(UseUnloginModalResultEventName, { result: 'FAILED' });
+    }
   }
-});
+);
 
 interface IRewardCoinResponse {
   firstLogin: {
     reward: {
-      rewardType: 'JOLI_COIN';
+      rewardType: 'JOLI_COIN' | 'JOLI_GEM';
       rewardValue: number;
     };
   };