@jolibox/implement 1.1.29 → 1.1.31

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

@@ -0,0 +1,220 @@
+import { innerFetch as fetch } from '@/native/network';
+import { BasePaymentRegister, createPaymentError, createPaymentInternalError } from './base';
+import { PaymentErrorCodeMap, IPlaceOrderResponse } from './type';
+import { ResponseType, StandardResponse } from '@jolibox/types';
+import { applyNative, onNative } from '@jolibox/native-bridge';
+import { Deferred, isNumber, platform } from '@jolibox/common';
+import { context } from '@/common/context';
+import { createToast } from '@jolibox/ui';
+import { IPaymentIAPFailedStatusMap } from './const';
+
+export interface IPlaceOrderJoliCoinIAPParamas {
+  productId: string;
+  appStoreProductId: string;
+}
+
+export interface IJoliCoinProductInfo {
+  quantity: number;
+}
+
+interface IJolicoinPaymentIAPResponse {
+  totalAmount: string;
+}
+
+export interface IJolicoinPaymentIAPContext {
+  type: 'JOLI_COIN_IAP_CONTEXT';
+  state: 'TO_CHECKOUT' | 'TO_VALIDATE';
+  productId: string;
+  appStoreProductId: string;
+}
+
+const pendingPayments = new Map<string, Deferred<StandardResponse<{ totalAmount: string }>>>();
+
+onNative('onPaymentStateChange', (data) => {
+  console.info('onPaymentStateChange', data);
+  const { orderUUID, status, totalAmount, orderResponse } = data;
+
+  const deferred = pendingPayments.get(orderUUID);
+  if (!deferred) {
+    return;
+  }
+
+  if (status === 'SUCCESS') {
+    createToast(`{slot-success} {slot-i18n-jolicoin.unlockSuccess}`, {
+      position: 'center',
+      duration: 3000
+    });
+    deferred.resolve({
+      code: 'SUCCESS' as ResponseType,
+      message: 'jolicoin payment success',
+      data: { totalAmount }
+    });
+  } else {
+    if (status === 'FAILED') {
+      if (isNumber(orderResponse?.errNo) && orderResponse?.errNo !== 0) {
+        throw createPaymentInternalError(
+          `jolicoin payment failed: ${orderResponse?.errMsg}`,
+          PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+        );
+      }
+    }
+    const failedStatus = IPaymentIAPFailedStatusMap[status] ?? 'unlockFailed';
+    createToast(`{slot-error} {slot-i18n-jolicoin.${failedStatus}}`, {
+      position: 'center',
+      duration: 3000
+    });
+    deferred.resolve({
+      code: 'FAILED' as ResponseType,
+      message: 'jolicoin payment failed'
+    });
+  }
+
+  // Clean up map
+  pendingPayments.delete(orderUUID);
+});
+
+const payInApp = async (params: { appStoreProductId: string; appAccountToken?: string }) => {
+  const deferred = new Deferred<StandardResponse<{ totalAmount: string }>>();
+  let targetOrderUUID: string | undefined;
+
+  try {
+    const response = await applyNative('requestPaymentSync', {
+      paymentBody: {
+        appStoreProductId: params.appStoreProductId,
+        appAccountToken: params.appAccountToken
+      }
+    });
+    targetOrderUUID = response.data?.orderUUID;
+
+    console.info('---payInApp---', response);
+    if (!targetOrderUUID) {
+      throw createPaymentInternalError(
+        'orderUUID is null',
+        PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+      );
+    }
+
+    pendingPayments.set(targetOrderUUID, deferred);
+  } catch (e) {
+    throw createPaymentInternalError(
+      JSON.stringify(e) ?? 'jolicoin payment failed',
+      PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+    );
+  }
+
+  return deferred.promise;
+};
+
+class JolicoinIAPAndroidPaymentResiter extends BasePaymentRegister<
+  IPlaceOrderJoliCoinIAPParamas,
+  IJoliCoinProductInfo,
+  IJolicoinPaymentIAPResponse
+> {
+  constructor(readonly productId: string, readonly appStoreProductId: string) {
+    super();
+  }
+  async placeOrder(
+    params: IPlaceOrderJoliCoinIAPParamas
+  ): Promise<StandardResponse<IPlaceOrderResponse<IJoliCoinProductInfo>, unknown>> {
+    return {
+      code: 'SUCCESS' as ResponseType,
+      message: 'placeorder jolicoin success in native'
+    };
+  }
+
+  generatePaymentContext = (): IJolicoinPaymentIAPContext => {
+    return {
+      type: 'JOLI_COIN_IAP_CONTEXT',
+      state: 'TO_VALIDATE',
+      productId: this.productId,
+      appStoreProductId: this.appStoreProductId
+    };
+  };
+
+  pay = async (): Promise<StandardResponse<{ totalAmount: string }>> => {
+    return await payInApp({ appStoreProductId: this.appStoreProductId });
+  };
+}
+
+class JolicoinIAPIOSPaymentResiter extends BasePaymentRegister<
+  IPlaceOrderJoliCoinIAPParamas,
+  IJoliCoinProductInfo,
+  IJolicoinPaymentIAPResponse
+> {
+  private appAccountToken: string | undefined;
+  constructor(readonly productId: string, readonly appStoreProductId: string) {
+    super();
+  }
+  async placeOrder(
+    params: IPlaceOrderJoliCoinIAPParamas
+  ): Promise<StandardResponse<IPlaceOrderResponse<IJoliCoinProductInfo>, unknown>> {
+    console.log('----start place order for ios----');
+    const { response } = await fetch<StandardResponse<{ iapToken: string }>>('/api/orders/iap-init', {
+      method: 'GET',
+      appendHostCookie: true
+    });
+    const { data, code } = response ?? {};
+    console.log('----iap init----', data, code);
+    if (data.code !== 'SUCCESS') {
+      throw createPaymentInternalError(
+        'iap-init failed',
+        PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+      );
+    }
+    this.appAccountToken = data?.data?.iapToken;
+    return {
+      code: 'SUCCESS' as ResponseType,
+      message: 'placeorder jolicoin success in native'
+    };
+  }
+
+  generatePaymentContext = (): IJolicoinPaymentIAPContext => {
+    return {
+      type: 'JOLI_COIN_IAP_CONTEXT',
+      state: 'TO_VALIDATE',
+      productId: this.productId,
+      appStoreProductId: this.appStoreProductId
+    };
+  };
+
+  pay = async (): Promise<StandardResponse<{ totalAmount: string }>> => {
+    return await payInApp({
+      appStoreProductId: this.appStoreProductId,
+      appAccountToken: this.appAccountToken
+    });
+  };
+}
+
+const IAPPaymentRegisterMap = {
+  android: JolicoinIAPAndroidPaymentResiter,
+  ios: JolicoinIAPIOSPaymentResiter
+} as const;
+
+type JolicoinIAPPaymentResiter = JolicoinIAPAndroidPaymentResiter | JolicoinIAPIOSPaymentResiter;
+export const createJolicoinIAPPaymentHandler = () => {
+  const productPaymentMap = new Map<string, JolicoinIAPPaymentResiter>();
+  return async (params: { productId: string; appStoreProductId: string }) => {
+    const { productId, appStoreProductId } = params;
+    let instance = productPaymentMap.get(productId);
+    if (!instance) {
+      const Register = IAPPaymentRegisterMap[context.platform as keyof typeof IAPPaymentRegisterMap];
+      if (!Register) {
+        throw createPaymentInternalError(
+          'platform not supported',
+          PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed
+        );
+      }
+      instance = new Register(productId, appStoreProductId);
+      productPaymentMap.set(productId, instance);
+    }
+
+    const { code, message } = await instance.startPayment({ productId, appStoreProductId });
+    if (code !== 'SUCCESS') {
+      throw createPaymentError(message, PaymentErrorCodeMap.JolicoinPlaceOrderRequestFailed);
+    }
+    return {
+      code: 'SUCCESS' as ResponseType,
+      message: 'jolicoin payment success'
+    };
+  };
+};

package/src/native/rewards/check-frequency.ts

@@ -20,6 +20,7 @@ const parseFrequency = (data: string) => {
 export const checkUseModalFrequency = async (config: { dailyMaxPopUps: number; minInterval: number }) => {
   const { dailyMaxPopUps, minInterval } = config;
   const res = (await getGlobalStorage('joli_coin_use_modal_frequency')) as StandardResponse<string>;
+  console.log('checkUseModalFrequency', res.data);
   if (!res.data) {
     return true;
   }
@@ -53,7 +54,7 @@ export const updateUseModalFrequency = async () => {
 export const checkPaymentFrequency = async (config: { dailyMaxPopUps: number; minInterval: number }) => {
   const { dailyMaxPopUps, minInterval } = config;
   const res = (await getGlobalStorage('joli_coin_payment_frequency')) as StandardResponse<string>;
-
+  console.log('checkPaymentFrequency', res.data);
   if (!res.data) {
     return true;
   }

package/src/native/rewards/index.ts

@@ -14,7 +14,7 @@ import {
   UseModalFrequencyEventName,
   IUseModalFrequencyConfig
 } from '@/common/rewards/reward-emitter';
-import { createConfirmJolicoinModal, createPaymentJolicoinModal } from '@jolibox/ui';
+import { createConfirmJolicoinModal, createPaymentJolicoinModal, createToast } from '@jolibox/ui';
 import { innerFetch as fetch } from '../network';
 import { StandardResponse } from '@jolibox/types';
 import { context } from '@/common/context';
@@ -28,6 +28,10 @@ import {
   updatePaymentFrequency
 } from './check-frequency';
 import { paymentHelper } from '../payment';
+import { createLoading } from '@jolibox/ui';
+import { canIUseNative } from '../api/base';
+import { applyNative } from '@jolibox/native-bridge';
+import { isUndefinedOrNull } from '@jolibox/common';
 
 const modalUseFrequencyConfig = createEventPromiseHandler<
   IUseModalFrequencyConfig,
@@ -36,6 +40,8 @@ const modalUseFrequencyConfig = createEventPromiseHandler<
 
 modalUseFrequencyConfig.getData();
 
+const loading = createLoading();
+
 /**
  * update config
  */
@@ -67,9 +73,13 @@ const updateAutoDeductConfig = async (enabled: boolean): Promise<void> => {
 rewardsEmitter.on(UseModalEventName, async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IUseModalEvent) => {
   if (type === 'ADS-JOLI_COIN') {
     //TODO
-    console.log('use modal show by frequency');
+    await loading.show({
+      duration: 3000
+    });
     const config = await modalUseFrequencyConfig.getData();
     const canShowUseModal = await checkUseModalFrequency(config.joliCoinUseAndCharge.useJolicoin);
+    console.log('use modal show by frequency', canShowUseModal);
+    loading.hide();
     if (!canShowUseModal) {
       // return by frequency control
       rewardsEmitter.emit(UseModalResultEventName, { useModalResult: 'CONFIRM' });
@@ -115,11 +125,24 @@ rewardsEmitter.on(
   InvokePaymentEventName,
   async (type: 'JOLI_COIN' | 'ADS-JOLI_COIN', params: IInvokePaymentEvent) => {
     try {
+      // 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' });
+        }, 0);
+        return;
+      }
       // handle showup frequecy
       if (type === 'ADS-JOLI_COIN') {
-        //
+        await loading.show({
+          duration: 3000
+        });
         const config = await modalUseFrequencyConfig.getData();
         const canShowPaymentModal = await checkPaymentFrequency(config.joliCoinUseAndCharge.charge);
+        console.log('use payment show by frequency', canShowPaymentModal);
+        loading.hide();
         if (!canShowPaymentModal) {
           // return by frequency control
           rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
@@ -128,7 +151,15 @@ rewardsEmitter.on(
         console.log('show by frequency');
       }
 
+      /**
+       * TODO: need merge totalAmountStr from native
+       */
+      await loading.show({
+        duration: 3000
+      });
       const balenceDetails = await getBalenceDetails();
+      loading.hide();
+
       if (!balenceDetails) {
         rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
         return;
@@ -137,15 +168,17 @@ rewardsEmitter.on(
         data: {
           userJolicoin: params.userJoliCoin,
           joliCoinQuantity: params.joliCoinQuantity,
-          paymentChoices: balenceDetails.paymentChoices,
+          paymentChoices:
+            balenceDetails.paymentChoices?.map((choice) => ({
+              ...choice,
+              totalAmountStr: choice.totalAmountStr ?? ''
+            })) ?? [],
           enableAutoDeduct: balenceDetails.enableAutoDeduct
         },
         buttons: {
           confirm: {
             text: params.confirmButtonText,
             onPress: async (productId: string) => {
-              // TODO: native payment
-              // await invokeNativePayment(productId);
               if (!context.hostUserInfo?.isLogin) {
                 const { data } = await login();
                 if (!data?.isLogin) {
@@ -161,12 +194,28 @@ rewardsEmitter.on(
                 }
               }
               console.log('invokeNativePayment', productId);
-              const { code } = await paymentHelper.invokePayment('JOLI_COIN', productId);
-              if (code !== 'SUCCESS') {
+              const appStoreProductId = balenceDetails?.paymentChoices?.find(
+                (choice) => choice.productId === productId
+              )?.appStoreProductId;
+
+              if (!appStoreProductId) {
                 rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'FAILED' });
                 modal.destroy();
                 return;
               }
+              await loading.show({
+                duration: 3000
+              });
+              const { code } = await paymentHelper.invokePayment('JOLI_COIN_IAP', {
+                productId,
+                appStoreProductId
+              });
+              loading.hide();
+              if (code !== 'SUCCESS') {
+                /** add timeout for google panel closed */
+                console.info('[JoliboxSDK] payment failed in payment.invokePaymet');
+                return;
+              }
               rewardsEmitter.emit(PaymentResultEventName, { paymentResult: 'SUCCESS' });
               modal.destroy();
             }
@@ -194,6 +243,23 @@ 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[];
+  console.info('----mergeResponseData-----', responseData.paymentChoices);
+};
+
 const getBalenceDetails = async (): Promise<
   | {
       balance: number;
@@ -214,5 +280,17 @@ const getBalenceDetails = async (): Promise<
     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) ?? []
+  });
+
+  if (response.data?.data && data) {
+    mergeResponseData(response.data?.data, data);
+  }
+  console.info('productDetails', response.data?.data);
   return response.data?.data;
 };

package/src/native/ui/retention.ts

@@ -108,7 +108,7 @@ export async function openRetentionSchema() {
           break;
         case 'dismiss':
           quitResultDeffer.resolve(true);
-          modal.hide();
+          modal.destroy();
           break;
         case 'navigate':
           // TODO: 跳转游戏
@@ -121,7 +121,7 @@ export async function openRetentionSchema() {
           } else {
             quitResultDeffer.resolve(true);
           }
-          modal.hide();
+          modal.destroy();
           break;
         default:
           // 关闭弹框，留在当前游戏