@jolibox/implement 1.2.2 → 1.2.4

package/src/native/payment/payment-service.ts

@@ -0,0 +1,279 @@
+import { IPaymentChoice } from '@/common/rewards/reward-emitter';
+import { paymentHelper } from './index';
+import { isUndefinedOrNull } from '@jolibox/common';
+import { StandardResponse } from '@jolibox/types';
+import { applyNative } from '@jolibox/native-bridge';
+import { innerFetch as fetch } from '@/native/network';
+import type { PaymentResult } from './payment-helper';
+
+type PaymentPurchaseType = 'JOLI_COIN' | 'JOLI_GEM';
+
+const CoinFetchUrlMap: Record<PaymentPurchaseType, string> = {
+  JOLI_COIN: '/api/joli-coin/balance-detail',
+  JOLI_GEM: '/api/joli-gem/balance-detail'
+};
+
+// 缓存数据接口
+export interface CachedPaymentChoices {
+  choices: IPaymentChoice[];
+  timestamp: number;
+  expiresAt: number;
+  productIds: string[];
+}
+
+export class PaymentService {
+  private productInfoCache: Record<PaymentPurchaseType, IPaymentChoice[]> = {
+    JOLI_COIN: [],
+    JOLI_GEM: []
+  };
+
+  // 新增：paymentChoices 缓存
+  private static paymentChoicesCache = new Map<string, CachedPaymentChoices>();
+  private static readonly PAYMENT_CHOICES_CACHE_DURATION = 10 * 60 * 1000; // 10分钟缓存
+
+  async getJolicoinProductsInfo(type: PaymentPurchaseType) {
+    if (this.productInfoCache[type].length > 0) {
+      return this.productInfoCache[type];
+    }
+    const productsInfo = await PaymentService.getProductsInfo(CoinFetchUrlMap[type]);
+    this.productInfoCache[type] = productsInfo?.paymentChoices ?? [];
+    return this.productInfoCache[type];
+  }
+
+  async purchase(type: PaymentPurchaseType, productId: string) {
+    const productsInfo = await this.getJolicoinProductsInfo(type);
+    const appStoreProductId = productsInfo.find(
+      (choice) => choice.productId === productId
+    )?.appStoreProductId;
+    if (!appStoreProductId) {
+      throw new Error('appStoreProductId not found');
+    }
+
+    const result = (await paymentHelper.invokePayment(
+      type === 'JOLI_COIN' ? 'JOLI_COIN_IAP' : 'JOLI_GEM_IAP',
+      {
+        productId,
+        appStoreProductId
+      }
+    )) as PaymentResult<{ totalAmount: string }>;
+
+    return result;
+  }
+
+  private static mergeResponseData(
+    responseData: { paymentChoices: IPaymentChoice[] },
+    data: { [appStoreProductId: string]: { price: string } }
+  ) {
+    Object.keys(data).forEach((key) => {
+      const choice = responseData.paymentChoices.find((choice) => choice.appStoreProductId === key);
+      if (choice) {
+        choice.totalAmountStr = data[key].price;
+      }
+    });
+
+    responseData.paymentChoices = responseData.paymentChoices.filter(
+      (choice) => !isUndefinedOrNull(choice.totalAmountStr)
+    ) as IPaymentChoice[];
+  }
+
+  static async getProductsInfo(apiEndpoint: string): Promise<
+    | {
+        balance: number;
+        enableAutoDeduct: boolean;
+        paymentChoices: IPaymentChoice[];
+      }
+    | undefined
+  > {
+    return Promise.race([
+      this.getProductsInfoInternal(apiEndpoint),
+      new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error('[PaymentService] Request timeout after 3 seconds'));
+        }, 3000);
+      })
+    ]);
+  }
+
+  private static async getProductsInfoInternal(apiEndpoint: string): Promise<
+    | {
+        balance: number;
+        enableAutoDeduct: boolean;
+        paymentChoices: IPaymentChoice[];
+      }
+    | undefined
+  > {
+    // 首先获取服务端数据（余额等实时数据）
+    const { response } = await fetch<
+      StandardResponse<{
+        balance: number;
+        enableAutoDeduct: boolean;
+        paymentChoices: IPaymentChoice[];
+      }>
+    >(apiEndpoint, {
+      method: 'GET',
+      appendHostCookie: true,
+      responseType: 'json'
+    });
+
+    if (!response.data?.data) {
+      throw new Error('get products info failed');
+    }
+
+    const serverData = response.data.data;
+
+    // 检查 paymentChoices 缓存
+    const cachedChoices = this.getPaymentChoicesFromCache(apiEndpoint, serverData.paymentChoices);
+
+    if (cachedChoices) {
+      console.log('[PaymentService] Using cached paymentChoices');
+
+      // 使用缓存的 paymentChoices，但保持服务端的余额等实时数据
+      return {
+        balance: serverData.balance,
+        enableAutoDeduct: serverData.enableAutoDeduct,
+        paymentChoices: cachedChoices
+      };
+    }
+
+    console.log('[PaymentService] Fetching fresh paymentChoices from native');
+
+    // 缓存未命中，请求原生数据
+    const { data } = await applyNative('requestProductDetailsAsync', {
+      appStoreProductIds:
+        serverData.paymentChoices
+          ?.filter((choice) => typeof choice.appStoreProductId === 'string')
+          .map((choice) => choice.appStoreProductId as string) ?? []
+    });
+
+    if (data) {
+      this.mergeResponseData(serverData, data);
+      this.cachePaymentChoices(apiEndpoint, serverData.paymentChoices);
+    }
+
+    if (serverData.paymentChoices.length === 0) {
+      throw new Error('paymentChoices is empty');
+    }
+
+    return serverData;
+  }
+
+  // read paymentChoices from cache
+  private static getPaymentChoicesFromCache(
+    apiEndpoint: string,
+    serverChoices: IPaymentChoice[]
+  ): IPaymentChoice[] | null {
+    const cached = this.paymentChoicesCache.get(apiEndpoint);
+
+    if (!cached) {
+      return null;
+    }
+
+    if (Date.now() > cached.expiresAt) {
+      this.paymentChoicesCache.delete(apiEndpoint);
+      return null;
+    }
+
+    const serverProductIds = this.extractProductIds(serverChoices);
+    const cachedProductIds = cached.productIds;
+
+    if (!this.arraysEqual(serverProductIds, cachedProductIds)) {
+      console.log('[PaymentService] Server paymentChoices changed, invalidating cache');
+      this.paymentChoicesCache.delete(apiEndpoint);
+      return null;
+    }
+
+    const updatedChoices = this.updateChoicesWithServerData(cached.choices, serverChoices);
+
+    return updatedChoices;
+  }
+
+  private static cachePaymentChoices(apiEndpoint: string, choices: IPaymentChoice[]): void {
+    this.paymentChoicesCache.set(apiEndpoint, {
+      choices: JSON.parse(JSON.stringify(choices)), // deep copy
+      timestamp: Date.now(),
+      expiresAt: Date.now() + this.PAYMENT_CHOICES_CACHE_DURATION,
+      productIds: this.extractProductIds(choices)
+    });
+
+    console.log(`[PaymentService] Cached ${choices.length} payment choices for ${apiEndpoint}`);
+  }
+
+  private static extractProductIds(choices: IPaymentChoice[]): string[] {
+    return choices
+      .map((choice) => choice.productId)
+      .filter(Boolean)
+      .sort();
+  }
+
+  private static arraysEqual(arr1: string[], arr2: string[]): boolean {
+    if (arr1.length !== arr2.length) {
+      return false;
+    }
+
+    return arr1.every((item, index) => item === arr2[index]);
+  }
+
+  private static updateChoicesWithServerData(
+    cachedChoices: IPaymentChoice[],
+    serverChoices: IPaymentChoice[]
+  ): IPaymentChoice[] {
+    const serverChoiceMap = new Map(serverChoices.map((choice) => [choice.productId, choice]));
+
+    return cachedChoices.map((cachedChoice) => {
+      const serverChoice = serverChoiceMap.get(cachedChoice.productId);
+
+      if (serverChoice) {
+        return {
+          ...cachedChoice,
+          quantity: serverChoice.quantity
+        };
+      }
+
+      return cachedChoice;
+    });
+  }
+
+  // clear paymentChoices cache
+  public static clearPaymentChoicesCache(apiEndpoint?: string): void {
+    if (apiEndpoint) {
+      this.paymentChoicesCache.delete(apiEndpoint);
+      console.log(`[PaymentService] Cleared cache for ${apiEndpoint}`);
+    } else {
+      this.paymentChoicesCache.clear();
+      console.log('[PaymentService] Cleared all payment choices cache');
+    }
+  }
+
+  public static getPaymentChoicesCacheStats(): {
+    cacheCount: number;
+    validCount: number;
+    expiredCount: number;
+  } {
+    const now = Date.now();
+    let validCount = 0;
+    let expiredCount = 0;
+
+    for (const cached of this.paymentChoicesCache.values()) {
+      if (now > cached.expiresAt) {
+        expiredCount++;
+      } else {
+        validCount++;
+      }
+    }
+
+    return {
+      cacheCount: this.paymentChoicesCache.size,
+      validCount,
+      expiredCount
+    };
+  }
+
+  public static clearExpiredPaymentChoicesCache(): void {
+    const now = Date.now();
+    for (const [key, cached] of this.paymentChoicesCache) {
+      if (now > cached.expiresAt) {
+        this.paymentChoicesCache.delete(key);
+      }
+    }
+  }
+}

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

@@ -75,7 +75,7 @@ onNative('onPaymentStateChange', (data) => {
   pendingPayments.delete(orderUUID);
 });
 
-const payInApp = async (params: { appStoreProductId: string; appAccountToken?: string }) => {
+const purchaseGem = async (params: { appStoreProductId: string; appAccountToken?: string }) => {
   const deferred = new Deferred<StandardResponse<{ totalAmount: string }>>();
   let targetOrderUUID: string | undefined;
 
@@ -88,7 +88,7 @@ const payInApp = async (params: { appStoreProductId: string; appAccountToken?: s
     });
     targetOrderUUID = response.data?.orderUUID;
 
-    console.info('---payInApp---', response);
+    console.info('---purchaseGem---', response);
     if (!targetOrderUUID) {
       throw createPaymentInternalError(
         'orderUUID is null',
@@ -134,7 +134,7 @@ class JolicoinIAPAndroidPaymentResiter extends BasePaymentRegister<
   };
 
   pay = async (): Promise<StandardResponse<{ totalAmount: string }>> => {
-    return await payInApp({ appStoreProductId: this.appStoreProductId });
+    return await purchaseGem({ appStoreProductId: this.appStoreProductId });
   };
 }
 
@@ -180,7 +180,7 @@ class JolicoinIAPIOSPaymentResiter extends BasePaymentRegister<
   };
 
   pay = async (): Promise<StandardResponse<{ totalAmount: string }>> => {
-    return await payInApp({
+    return await purchaseGem({
       appStoreProductId: this.appStoreProductId,
       appAccountToken: this.appAccountToken
     });

package/src/native/report/index.ts

@@ -13,12 +13,15 @@ const reportNative: ReportHandler = (event, data, webviewId) => {
     : isString(_data.extra)
     ? JSON.parse(_data.extra)
     : {};
+  const { mpName, mpVersion } = context.mpInfo ?? {}; //
   const extra = {
     ...originExtra,
     mp_id: (_data.mp_id as string) ?? '',
     mp_version: (_data.mp_version as string) ?? '',
     session_id: context.sessionId,
-    user_id: context.hostUserInfo?.uid ?? ''
+    user_id: context.hostUserInfo?.uid ?? '',
+    ...(mpName ? { mp_name: mpName } : {}),
+    ...(mpVersion ? { mp_info_version: mpVersion } : {})
   };
   const eventType = (_data.eventType ?? EventType.Other) as number;
 

package/src/native/report/task-tracker.ts

@@ -1,14 +1,16 @@
 /**
  * 任务上报
  */
-
 import { context } from '@/common/context';
 import { TaskTracker, TaskPoint } from '@/common/report/task-track';
-import { EventEmitter, getApiHost } from '@jolibox/common';
+import { EventEmitter, getApiHost, isBoolean } from '@jolibox/common';
 import { innerFetch as fetch } from '../network';
 import { applyNative } from '@jolibox/native-bridge';
 import type { Track } from '.';
 import type { TrackEvent } from '@jolibox/types';
+import { getGlobalStorage, setGlobalStorage } from '../api/storage';
+
+const REPORT_FIRST_OPEN_GAME = 'REPORT_FIRST_OPEN_GAME';
 
 type NativeTaskPointEvent =
   | 'OpenGame'
@@ -52,6 +54,7 @@ export class NativeTaskTracker extends TaskTracker {
     if (extraParams) {
       Object.assign(reportBody, extraParams);
     }
+
     const reportTask =
       context.platform === 'android'
         ? fetch(`/api/base/app-event`, {
@@ -79,4 +82,18 @@ export class NativeTaskTracker extends TaskTracker {
   tracker(event: TrackEvent, info: Record<string, unknown> | null = null) {
     this.track(event, info);
   }
+
+  start(duration?: number) {
+    super.start(duration);
+    this.tryReportOpenGamePlus();
+  }
+
+  private tryReportOpenGamePlus() {
+    getGlobalStorage(REPORT_FIRST_OPEN_GAME).then((res) => {
+      if (isBoolean(res.data) && res.data) {
+        this.tracker('OpenGame_2Plus');
+      }
+      setGlobalStorage(REPORT_FIRST_OPEN_GAME, true);
+    });
+  }
 }

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

@@ -23,12 +23,12 @@ import {
 import { paymentHelper } from '@/native/payment';
 import { createLoading } from '@jolibox/ui';
 import { canIUseNative } from '@/native/api/base';
-import { applyNative } from '@jolibox/native-bridge';
-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';
+import { PaymentService } from '@/native/payment/payment-service';
 
 // 货币配置映射
 interface CurrencyPaymentConfig {
@@ -134,7 +134,7 @@ rewardsEmitter.on(
       await loading.show({
         duration: 3000
       });
-      const balenceDetails = await getBalenceDetails(paymentConfig.apiEndpoint);
+      const balenceDetails = await PaymentService.getProductsInfo(paymentConfig.apiEndpoint);
       loading.hide();
 
       if (!balenceDetails) {
@@ -183,7 +183,7 @@ rewardsEmitter.on(
                   return;
                 }
 
-                const balenceDetails = await getBalenceDetails(paymentConfig.apiEndpoint);
+                const balenceDetails = await PaymentService.getProductsInfo(paymentConfig.apiEndpoint);
                 if ((balenceDetails?.balance ?? 0) >= params.quantity) {
                   rewardsEmitter.emit(PaymentResultEventName, {
                     paymentResult: 'SUCCESS',
@@ -278,58 +278,11 @@ rewardsEmitter.on(
   }
 );
 
-const mergeResponseData = (
-  responseData: { paymentChoices: IPaymentChoice[] },
-  data: { [appStoreProductId: string]: { price: string } }
-) => {
-  Object.keys(data).forEach((key) => {
-    const choice = responseData.paymentChoices.find((choice) => choice.appStoreProductId === key);
-    if (choice) {
-      choice.totalAmountStr = data[key].price;
-    }
-  });
-
-  responseData.paymentChoices = responseData.paymentChoices.filter(
-    (choice) => !isUndefinedOrNull(choice.totalAmountStr)
-  ) as IPaymentChoice[];
-};
-
-const getBalenceDetails = async (
-  apiEndpoint: string
-): Promise<
-  | {
-      balance: number;
-      enableAutoDeduct: boolean;
-      paymentChoices: IPaymentChoice[];
-    }
-  | undefined
-> => {
-  const { response } = await fetch<
-    StandardResponse<{
-      balance: number;
-      enableAutoDeduct: boolean;
-      paymentChoices: IPaymentChoice[];
-    }>
-  >(apiEndpoint, {
-    method: 'GET',
-    appendHostCookie: true,
-    responseType: 'json'
-  });
-
-  console.info('getBalenceDetails', response);
-  const { data } = await applyNative('requestProductDetailsAsync', {
-    appStoreProductIds:
-      response.data?.data?.paymentChoices
-        ?.filter((choice) => typeof choice.appStoreProductId === 'string')
-        .map((choice) => choice.appStoreProductId as string) ?? []
-  });
+/** preload payment details */
 
-  if (response.data?.data && data) {
-    mergeResponseData(response.data?.data, data);
-  }
-  console.info('productDetails', response.data?.data);
-  if (response.data?.data?.paymentChoices.length === 0) {
-    throw new Error('paymentChoices is empty');
-  }
-  return response.data?.data;
-};
+PaymentService.getProductsInfo(CURRENCY_PAYMENT_CONFIG.JOLI_COIN.apiEndpoint).catch((e) => {
+  console.error('preload joli coin payment details failed', e);
+});
+PaymentService.getProductsInfo(CURRENCY_PAYMENT_CONFIG.JOLI_GEM.apiEndpoint).catch((e) => {
+  console.error('preload joli gem payment details failed', e);
+});