@jolibox/implement 1.2.7 → 1.2.9-beta.9

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

@@ -0,0 +1,81 @@
+import { checkSubscriptionFrequency, updateSubscriptionFrequency } from '../check-frequency';
+import {
+  IUseModalFrequencyConfig,
+  rewardsEmitter,
+  UseModalFrequencyEventName,
+  InvokeSubscriptionEventName,
+  UseSubscriptionResultEventName
+} from '@/common/rewards/reward-emitter';
+import { createEventPromiseHandler } from '@/common/rewards/registers/utils/event-listener';
+import { canIUseNative } from '@/native/api/base';
+import { subscriptionService } from '@/native/subscription';
+import { createLoading } from '@jolibox/ui';
+
+interface CurrencyModalConfig {
+  frequencyConfigKey: keyof IUseModalFrequencyConfig['joliCoinUseAndCharge'];
+  frequencyChecker: (config: {
+    dailyMaxPopUps?: number;
+    minInterval?: number;
+  }) => Promise<{ canShow: boolean; isFirst: boolean }>;
+  frequencyUpdater: () => Promise<void>;
+}
+
+const SUBSCRIPTION_MODAL_CONFIG: Record<'SUBSCRIPTION', CurrencyModalConfig> = {
+  SUBSCRIPTION: {
+    frequencyConfigKey: 'joinMember',
+    frequencyChecker: checkSubscriptionFrequency,
+    frequencyUpdater: updateSubscriptionFrequency
+  }
+};
+
+const loading = createLoading();
+
+const modalUseFrequencyConfig = createEventPromiseHandler<
+  IUseModalFrequencyConfig,
+  typeof UseModalFrequencyEventName
+>(rewardsEmitter, UseModalFrequencyEventName);
+
+modalUseFrequencyConfig.getData();
+/**
+ * confirm currency modal - 支持 jolicoin 和 gem
+ */
+rewardsEmitter.on(InvokeSubscriptionEventName, async (type: 'SUBSCRIPTION') => {
+  // 获取货币类型配置
+  const modalConfig = SUBSCRIPTION_MODAL_CONFIG['SUBSCRIPTION'];
+
+  if (!canIUseNative('invokeSubscriptionPanelSync')) {
+    //TODO: show Toast
+    console.info('invokeSubscriptionPanelSync not supported');
+    setTimeout(() => {
+      rewardsEmitter.emit(UseSubscriptionResultEventName, { result: 'FAILED' });
+    }, 0);
+    return;
+  }
+
+  await loading.show({
+    duration: 3000
+  });
+  const config = await modalUseFrequencyConfig.getData();
+  const { canShow: canShowUseModal, isFirst: isFirstUseModal } = await modalConfig.frequencyChecker(
+    config.joliCoinUseAndCharge[modalConfig.frequencyConfigKey]
+  );
+
+  loading.hide();
+
+  // If not used directly, then check frequency control.
+  if (!canShowUseModal) {
+    // return by frequency control
+    rewardsEmitter.emit(UseSubscriptionResultEventName, { result: 'FAILED' });
+    return;
+  }
+
+  const { data, code } = await subscriptionService.invokeSubscriptionPanel();
+  if (code == 'SUCCESS' && data?.subPlanId) {
+    rewardsEmitter.emit(UseSubscriptionResultEventName, { result: 'SUCCESS' });
+  } else {
+    rewardsEmitter.emit(UseSubscriptionResultEventName, { result: 'FAILED' });
+  }
+
+  // 根据货币类型更新使用频次
+  await modalConfig.frequencyUpdater();
+});

package/src/native/subscription/index.ts

@@ -0,0 +1,12 @@
+export * from './subscription-service';
+export * from './type';
+
+// Export subscription helper
+import { subscriptionHelper } from './subscription-helper';
+import { createSubAppSubscriptionHandler } from './registers/sub-app';
+import { createSubscriptionService } from './subscription-service';
+
+export const subscriptionService = createSubscriptionService();
+
+// Register sub-app subscription handler
+subscriptionHelper.registerSubscriptionHandler('SUB_APP', createSubAppSubscriptionHandler());

package/src/native/subscription/registers/base.ts

@@ -0,0 +1,88 @@
+import { StandardResponse } from '@jolibox/types';
+import type { IPlaceSubscriptionOrderResponse } from './type';
+import { SubscriptionErrorCodeMap } from './type';
+import { UserPaymentError, InternalPaymentError } from '@jolibox/common';
+import { context } from '@/common/context';
+import { innerFetch as fetch } from '@/native/network';
+
+type SubscriptionStatus = 'INIT' | 'PENDING' | 'SUCCESS' | 'FAILED';
+
+const createSubscriptionErrorFactory = () => {
+  const [createSubscriptionError, createSubscriptionInternalError] = [
+    UserPaymentError,
+    InternalPaymentError
+  ].map((ctor) => {
+    return (errMsg: string, errNo: number, extra?: Record<string, unknown>) => {
+      return new ctor(errMsg, errNo, extra);
+    };
+  });
+  return {
+    createSubscriptionError,
+    createSubscriptionInternalError
+  };
+};
+
+const { createSubscriptionError, createSubscriptionInternalError } = createSubscriptionErrorFactory();
+export { createSubscriptionError, createSubscriptionInternalError };
+
+const CALLBACK_HOST = context.testMode ? 'https://stg-game.jolibox.com' : 'https://game.jolibox.com';
+
+export abstract class BaseSubscriptionRegister<
+  T extends Record<string, any>,
+  E extends Record<string, any>,
+  R = void
+> {
+  private _orderId: string | null = null;
+  private _orderStatus: SubscriptionStatus = 'INIT';
+
+  startSubscription = async (params: T): Promise<StandardResponse<R>> => {
+    if (this._orderId) {
+      await this.cancelOrder(this.orderId as string);
+    }
+
+    const { code, message } = await this.placeOrder(params);
+    if (code !== 'SUCCESS') {
+      throw createSubscriptionError(message, SubscriptionErrorCodeMap.PlaceOrderFailed);
+    }
+
+    // invoke subscription flow
+    return await this.subscribe(params);
+  };
+
+  protected generateCallbackUrl = () => {
+    // Set subscription callback parameters
+    const originalSearch = new URLSearchParams('');
+    originalSearch.set('utm_source', context.deviceInfo.platform);
+    originalSearch.set(
+      'joliSource',
+      context.encodeJoliSourceQuery({
+        ...this.generateSubscriptionContext()
+      })
+    );
+    return `${CALLBACK_HOST}/subscription/callback?${originalSearch.toString()}`;
+  };
+
+  protected setOrderId(orderId: string) {
+    this._orderId = orderId;
+  }
+
+  protected setOrderStatus(status: SubscriptionStatus) {
+    this._orderStatus = status;
+  }
+
+  protected createSubscriptionError = createSubscriptionError;
+  protected createSubscriptionInternalError = createSubscriptionInternalError;
+
+  abstract placeOrder(params: T): Promise<StandardResponse<IPlaceSubscriptionOrderResponse<E>>>;
+  abstract cancelOrder(orderId: string): Promise<StandardResponse<void>>;
+  abstract generateSubscriptionContext(): Record<string, any>;
+  abstract subscribe(params: T): Promise<StandardResponse<R>>;
+
+  get orderId(): string | null {
+    return this._orderId;
+  }
+
+  get status(): SubscriptionStatus {
+    return this._orderStatus;
+  }
+}

package/src/native/subscription/registers/sub-app.ts

@@ -0,0 +1,258 @@
+import { StandardResponse } from '@jolibox/types';
+import { context } from '@/common/context';
+import { innerFetch as fetch } from '@/native/network';
+import { BaseSubscriptionRegister } from './base';
+import type { IPlaceSubscriptionOrderResponse } from './type';
+import { PaymentErrorCodeMap } from '@/native/payment/registers/type';
+import { createPaymentInternalError } from '@/native/payment/registers/base';
+import { ResponseType } from '@jolibox/types';
+import { Deferred } from '@jolibox/common';
+import { invokeNative, onNative } from '@jolibox/native-bridge';
+import { isNumber } from '@jolibox/common';
+import { SubscriptionErrorCodeMap } from './type';
+
+export interface IPlaceOrderSubAppParams {
+  basePlanId: string;
+  appStoreProductId: string;
+  productId: string;
+}
+
+export interface ISubAppProductInfo {
+  subPlanId: string;
+}
+
+export interface ISubAppSubscriptionContext {
+  gameId: string;
+  productId: string;
+  planId: string;
+}
+
+/** global subscription  */
+
+onNative('onGlobalSubscriptionStateChange', (data) => {
+  const { status, orderResponse } = data;
+  console.log('[onGlobalSubscriptionStateChange] data', data);
+  if (status === 'SUCCESS' && (orderResponse?.subPlanId || orderResponse?.tickedId)) {
+    // user must be logined
+    context.onEnvConfigChanged({
+      hostUserInfo: {
+        isLogin: true,
+        isSubUser: true
+      }
+    });
+  }
+});
+
+const pendingSubscriptions = new Map<string, Deferred<StandardResponse<{ subPlanId: string }>>>();
+
+onNative('onSubscritptionStateChange', (data) => {
+  const { subUUID, status, orderResponse } = data;
+
+  console.log('[onSubscritptionStateChange] data', data);
+  const deferred = pendingSubscriptions.get(subUUID);
+  if (!deferred) {
+    return;
+  }
+
+  if (status === 'SUCCESS') {
+    deferred.resolve({
+      code: 'SUCCESS' as ResponseType,
+      message: 'jolicoin payment success',
+      data: { subPlanId: orderResponse?.subPlanId ?? orderResponse.tickedId }
+    });
+  } else {
+    if (status === 'FAILED') {
+      if (isNumber(orderResponse?.errNo) && orderResponse?.errNo !== 0) {
+        throw createPaymentInternalError(
+          `subscription failed: ${orderResponse?.errMsg}`,
+          SubscriptionErrorCodeMap.SubscriptionFailed
+        );
+      }
+    }
+    deferred.resolve({
+      code: status as ResponseType,
+      message: orderResponse?.errMsg ?? 'UNKNOWN_ERROR'
+    });
+  }
+
+  // Clean up map
+  pendingSubscriptions.delete(subUUID);
+});
+
+const internalSubscribe = async (params: {
+  appStoreProductId: string;
+  basePlanId: string;
+  productId: string;
+  appAccountToken?: string;
+}) => {
+  const deferred = new Deferred<StandardResponse<{ subPlanId: string }>>();
+  let targetOrderUUID: string | undefined;
+
+  try {
+    console.log('[internalSubscribe] requestSubscriptionSync params', params);
+    const response = invokeNative('requestSubscriptionSync', {
+      params: {
+        basePlanId: params.basePlanId,
+        appStoreProductId: params.appStoreProductId,
+        productId: params.productId
+      },
+      ...(params.appAccountToken
+        ? {
+            paymentBody: {
+              appAccountToken: params.appAccountToken,
+              appStoreProductId: params.appStoreProductId
+            }
+          }
+        : {})
+    });
+    targetOrderUUID = response.data?.subUUID;
+
+    if (!targetOrderUUID) {
+      throw createPaymentInternalError(
+        'subUUID is null',
+        PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+      );
+    }
+
+    pendingSubscriptions.set(targetOrderUUID, deferred);
+  } catch (e) {
+    throw createPaymentInternalError(
+      JSON.stringify(e) ?? 'jolicoin payment failed',
+      PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+    );
+  }
+
+  return deferred.promise;
+};
+
+// Android 实现 - 不需要 placeOrder
+class SubAppAndroidSubscriptionRegister extends BaseSubscriptionRegister<
+  IPlaceOrderSubAppParams,
+  ISubAppProductInfo,
+  { subPlanId: string }
+> {
+  constructor(private readonly productId: string, private readonly planId: string) {
+    super();
+  }
+
+  async placeOrder(
+    _params: IPlaceOrderSubAppParams
+  ): Promise<StandardResponse<IPlaceSubscriptionOrderResponse<ISubAppProductInfo>>> {
+    // Android 不需要实际下单，直接返回成功
+    return {
+      code: 'SUCCESS',
+      message: 'Android subscription order placed locally'
+    };
+  }
+
+  cancelOrder(_orderId: string): Promise<StandardResponse<void>> {
+    // Android 本地取消
+    return Promise.resolve({
+      code: 'SUCCESS',
+      message: 'Android order cancelled locally',
+      data: undefined
+    });
+  }
+
+  generateSubscriptionContext(): ISubAppSubscriptionContext {
+    return {
+      gameId: context.mpId,
+      productId: this.productId,
+      planId: this.planId
+    };
+  }
+
+  async subscribe(params: IPlaceOrderSubAppParams): Promise<StandardResponse<{ subPlanId: string }>> {
+    const response = await internalSubscribe(params);
+    return response;
+  }
+}
+
+// iOS 实现 - 需要 placeOrder
+class SubAppIOSSubscriptionRegister extends BaseSubscriptionRegister<
+  IPlaceOrderSubAppParams,
+  ISubAppProductInfo,
+  { subPlanId: string }
+> {
+  private subscriptionToken: string | undefined;
+
+  constructor(private readonly productId: string, private readonly planId: string) {
+    super();
+  }
+
+  async placeOrder(
+    params: IPlaceOrderSubAppParams
+  ): Promise<StandardResponse<IPlaceSubscriptionOrderResponse<ISubAppProductInfo>>> {
+    console.log('----start place order for iOS subscription----');
+
+    const env = invokeNative('envSync');
+    const accountToken = env?.data?.hostUserInfo?.appAccountToken;
+    if (!accountToken) {
+      throw createPaymentInternalError(
+        'appAccountToken is null',
+        PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+      );
+    }
+    this.subscriptionToken = accountToken;
+    return {
+      code: 'SUCCESS' as ResponseType,
+      message: 'placeorder sub-app success in native'
+    };
+  }
+
+  async cancelOrder(orderId: string): Promise<StandardResponse<void>> {
+    // Android 本地取消
+    return Promise.resolve({
+      code: 'SUCCESS',
+      message: 'Android order cancelled locally',
+      data: undefined
+    });
+  }
+
+  generateSubscriptionContext(): ISubAppSubscriptionContext {
+    return {
+      gameId: context.mpId,
+      productId: this.productId,
+      planId: this.planId
+    };
+  }
+
+  async subscribe(params: IPlaceOrderSubAppParams): Promise<StandardResponse<{ subPlanId: string }>> {
+    return await internalSubscribe({ ...params, appAccountToken: this.subscriptionToken });
+  }
+}
+
+const SubAppSubscriptionRegisterMap = {
+  android: SubAppAndroidSubscriptionRegister,
+  ios: SubAppIOSSubscriptionRegister
+} as const;
+
+type SubAppSubscriptionRegister = SubAppAndroidSubscriptionRegister | SubAppIOSSubscriptionRegister;
+
+export function createSubAppSubscriptionHandler() {
+  const productSubscriptionMap = new Map<string, SubAppSubscriptionRegister>();
+
+  return async (params: { productId: string; appStoreProductId: string; planId: string }) => {
+    console.log('[SubAppSubscriptionHandler] createSubAppSubscriptionHandler params', params);
+    const { productId, planId } = params;
+    const cacheKey = `${productId}_${planId}`;
+
+    let instance = productSubscriptionMap.get(cacheKey);
+    if (!instance) {
+      console.log('[SubAppSubscriptionHandler] createSubAppSubscriptionHandler instance not found', cacheKey);
+      const Register =
+        SubAppSubscriptionRegisterMap[context.platform as keyof typeof SubAppSubscriptionRegisterMap];
+      if (!Register) {
+        throw new Error(`Platform ${context.platform} not supported for sub-app subscription`);
+      }
+      instance = new Register(productId, planId);
+      productSubscriptionMap.set(cacheKey, instance);
+    }
+
+    return instance.startSubscription({
+      basePlanId: planId,
+      appStoreProductId: params.appStoreProductId,
+      productId
+    });
+  };
+}

package/src/native/subscription/registers/type.ts

@@ -0,0 +1,13 @@
+import { StandardResponse } from '@jolibox/types';
+
+export interface IPlaceSubscriptionOrderResponse<T = any> {
+  orderId: string;
+  productInfo: T;
+}
+
+export const SubscriptionErrorCodeMap = {
+  PlaceOrderFailed: 1001,
+  CancelOrderFailed: 1002,
+  SubscriptionFailed: 1003,
+  InvalidPlan: 1004
+} as const;

package/src/native/subscription/subscription-helper.ts

@@ -0,0 +1,53 @@
+export type SubscriptionType = 'SUB_APP'; // 目前支持sub-app平台
+
+import { StandardResponse } from '@jolibox/types';
+import { reportError } from '@/common/report/errors/report';
+import { BaseError } from '@jolibox/common';
+
+export type SubscriptionResult<T> = StandardResponse<T>;
+
+export interface SubscriptionHandlerMap {
+  SUB_APP: (params: {
+    productId: string;
+    appStoreProductId: string;
+    planId: string;
+  }) => Promise<SubscriptionResult<{ subPlanId: string }>>; // sub-app subscription
+}
+
+export type SubscriptionHandler<T extends SubscriptionType> = SubscriptionHandlerMap[T];
+
+export function createSubscriptionHelper() {
+  const subscriptionHandlers = new Map<SubscriptionType, SubscriptionHandler<any>>();
+
+  return {
+    registerSubscriptionHandler<T extends SubscriptionType>(type: T, handler: SubscriptionHandler<T>) {
+      subscriptionHandlers.set(type, handler);
+    },
+    async invokeSubscription<T extends SubscriptionType>(
+      type: T,
+      ...args: Parameters<SubscriptionHandler<T>>
+    ) {
+      const subscriptionHandler = subscriptionHandlers.get(type);
+      if (!subscriptionHandler) {
+        return {
+          code: 'FAILED',
+          message: `[joliboxSDK]: ${type} subscription not supported in this platform`
+        };
+      }
+      try {
+        const result = await subscriptionHandler(...args);
+        return result;
+      } catch (e) {
+        reportError(e as BaseError);
+        return {
+          code: 'FAILED',
+          message: `[joliboxSDK]: subscription error ${e}`
+        };
+      }
+    }
+  };
+}
+
+export type SubscriptionHelper = ReturnType<typeof createSubscriptionHelper>;
+
+export const subscriptionHelper = createSubscriptionHelper();