expo-iap 2.0.0 → 2.2.0-rc.1

package/src/types/ExpoIapAndroid.types.ts

@@ -1,63 +1,48 @@
+import {PurchaseBase, ProductBase} from '../ExpoIap.types';
+
 type OneTimePurchaseOfferDetails = {
   priceCurrencyCode: string;
   formattedPrice: string;
   priceAmountMicros: string;
 };
 
-type SubscriptionOfferDetail = {
-  basePlanId: string;
-  offerId: string;
-  offerToken: string;
-  offerTags: string[];
-  pricingPhases: PricingPhases;
-};
-
-type PricingPhases = {
-  pricingPhaseList: PricingPhase[];
-};
-
-type PricingPhase = {
+type PricingPhaseAndroid = {
   formattedPrice: string;
   priceCurrencyCode: string;
+  // P1W, P1M, P1Y
   billingPeriod: string;
   billingCycleCount: number;
   priceAmountMicros: string;
   recurrenceMode: number;
 };
 
-export type ProductAndroid = {
-  productId: string;
-  title: string;
-  description: string;
-  productType: string;
+type PricingPhasesAndroid = {
+  pricingPhaseList: PricingPhaseAndroid[];
+};
+
+type SubscriptionOfferDetail = {
+  basePlanId: string;
+  offerId: string;
+  offerToken: string;
+  offerTags: string[];
+  pricingPhases: PricingPhasesAndroid;
+};
+
+export type ProductAndroid = ProductBase & {
   name: string;
   oneTimePurchaseOfferDetails?: OneTimePurchaseOfferDetails;
   subscriptionOfferDetails?: SubscriptionOfferDetail[];
 };
 
-type PricingPhaseAndroid = {
-  formattedPrice: string;
-  priceCurrencyCode: string;
-  // P1W, P1M, P1Y
-  billingPeriod: string;
-  billingCycleCount: number;
-  priceAmountMicros: string;
-  recurrenceMode: number;
-};
-
 type SubscriptionOfferAndroid = {
   basePlanId: string;
   offerId: string | null;
   offerToken: string;
-  pricingPhases: {pricingPhaseList: PricingPhaseAndroid[]};
+  pricingPhases: PricingPhasesAndroid;
   offerTags: string[];
 };
 
 export type SubscriptionProductAndroid = ProductAndroid & {
-  name: string;
-  title: string;
-  description: string;
-  productId: string;
   subscriptionOfferDetails: SubscriptionOfferAndroid[];
 };
 
@@ -121,3 +106,22 @@ export enum FeatureTypeAndroid {
   /** Subscriptions update/replace. */
   SUBSCRIPTIONS_UPDATE = 'SUBSCRIPTIONS_UPDATE',
 }
+
+export enum PurchaseStateAndroid {
+  UNSPECIFIED_STATE = 0,
+  PURCHASED = 1,
+  PENDING = 2,
+}
+
+export type ProductPurchaseAndroid = PurchaseBase & {
+  ids?: string[];
+  dataAndroid?: string;
+  signatureAndroid?: string;
+  autoRenewingAndroid?: boolean;
+  purchaseStateAndroid?: PurchaseStateAndroid;
+  isAcknowledgedAndroid?: boolean;
+  packageNameAndroid?: string;
+  developerPayloadAndroid?: string;
+  obfuscatedAccountIdAndroid?: string;
+  obfuscatedProfileIdAndroid?: string;
+};

package/src/types/ExpoIapIos.types.ts

@@ -1,3 +1,5 @@
+import {PurchaseBase, ProductBase} from '../ExpoIap.types';
+
 type SubscriptionIosPeriod = 'DAY' | 'WEEK' | 'MONTH' | 'YEAR' | '';
 type PaymentMode = '' | 'FREETRIAL' | 'PAYASYOUGO' | 'PAYUPFRONT';
 
@@ -18,22 +20,18 @@ type SubscriptionInfo = {
   subscriptionPeriod: SubscriptionIosPeriod;
 };
 
-export type ProductIos = {
-  currency: string;
-  description: string;
+export type ProductIos = ProductBase & {
   displayName: string;
   displayPrice: string;
-  id: string;
-  type: 'autoRenewable' | 'consumable' | 'nonConsumable' | 'nonRenewable';
+  type: 'autoRenewable' | 'consumable' | 'nonConsumable' | 'nonRenewable'; // Maps to 'type' in base Product
   isFamilyShareable: boolean;
   jsonRepresentation: string;
-  price: number;
   subscription: SubscriptionInfo;
   introductoryPriceNumberOfPeriodsIOS?: string;
   introductoryPriceSubscriptionPeriodIOS?: SubscriptionIosPeriod;
 };
 
-type Discount = {
+export type Discount = {
   identifier: string;
   type: string;
   numberOfPeriods: string;
@@ -59,22 +57,18 @@ export type PaymentDiscount = {
    * A string used to uniquely identify a discount offer for a product.
    */
   identifier: string;
-
   /**
    * A string that identifies the key used to generate the signature.
    */
   keyIdentifier: string;
-
   /**
    * A universally unique ID (UUID) value that you define.
    */
   nonce: string;
-
   /**
    * A UTF-8 string representing the properties of a specific discount offer, cryptographically signed.
    */
   signature: string;
-
   /**
    * The date and time of the signature's creation in milliseconds, formatted in Unix epoch time.
    */
@@ -83,7 +77,6 @@ export type PaymentDiscount = {
 
 export type RequestPurchaseIosProps = {
   sku: string;
-  andDangerouslyFinishTransactionAutomaticallyIOS?: boolean;
   /**
    * UUID representing user account
    */
@@ -94,34 +87,6 @@ export type RequestPurchaseIosProps = {
 
 export type RequestSubscriptionIosProps = RequestPurchaseIosProps;
 
-export type TransactionSk2 = {
-  appAccountToken: string;
-  appBundleID: string;
-  debugDescription: string;
-  deviceVerification: string;
-  deviceVerificationNonce: string;
-  expirationDate: number;
-  environment?: 'Production' | 'Sandbox' | 'Xcode'; // Could be undefined in some cases on iOS 15, but it's stable since iOS 16
-  id: number;
-  isUpgraded: boolean;
-  jsonRepresentation: string;
-  offerID: string;
-  offerType: string;
-  originalID: string;
-  originalPurchaseDate: number;
-  ownershipType: string;
-  productID: string;
-  productType: string;
-  purchaseDate: number;
-  purchasedQuantity: number;
-  revocationDate: number;
-  revocationReason: string;
-  signedDate: number;
-  subscriptionGroupID: number;
-  webOrderLineItemID: number;
-  verificationResult?: string;
-};
-
 type SubscriptionStatus =
   | 'expired'
   | 'inBillingRetryPeriod'
@@ -139,3 +104,34 @@ export type ProductStatusIos = {
   state: SubscriptionStatus;
   renewalInfo?: RenewalInfo;
 };
+
+export type ProductPurchaseIos = PurchaseBase & {
+  // iOS basic fields
+  quantityIos?: number;
+  originalTransactionDateIos?: number;
+  originalTransactionIdentifierIos?: string;
+  verificationResultIos?: string;
+  appAccountToken?: string;
+  // iOS additional fields from StoreKit 2
+  expirationDateIos?: number;
+  webOrderLineItemIdIos?: number;
+  environmentIos?: string;
+  storefrontCountryCodeIos?: string;
+  appBundleIdIos?: string;
+  productTypeIos?: string;
+  subscriptionGroupIdIos?: string;
+  isUpgradedIos?: boolean;
+  ownershipTypeIos?: string;
+  reasonIos?: string;
+  reasonStringRepresentationIos?: string;
+  transactionReasonIos?: 'PURCHASE' | 'RENEWAL' | string;
+  revocationDateIos?: number;
+  revocationReasonIos?: string;
+  offerIos?: {
+    id: string;
+    type: string;
+    paymentMode: string;
+  };
+  priceIos?: number;
+  currencyIos?: string;
+};

package/src/useIap.ts

@@ -0,0 +1,185 @@
+import {
+  endConnection,
+  initConnection,
+  purchaseErrorListener,
+  purchaseUpdatedListener,
+  transactionUpdatedIos,
+  getProducts,
+  getAvailablePurchases,
+  getPurchaseHistory,
+  getSubscriptions,
+} from './';
+import {useCallback, useEffect, useState} from 'react';
+import {
+  Product,
+  ProductPurchase,
+  Purchase,
+  PurchaseError,
+  PurchaseResult,
+  SubscriptionProduct,
+  SubscriptionPurchase,
+} from './ExpoIap.types';
+import {TransactionEvent} from './modules/ios';
+import {Subscription} from 'expo-modules-core';
+
+type IAP_STATUS = {
+  connected: boolean;
+  products: Product[];
+  promotedProductsIOS: ProductPurchase[];
+  subscriptions: SubscriptionProduct[];
+  purchaseHistories: ProductPurchase[];
+  availablePurchases: ProductPurchase[];
+  currentPurchase?: ProductPurchase;
+  currentPurchaseError?: PurchaseError;
+  finishTransaction: ({
+    purchase,
+    isConsumable,
+    developerPayloadAndroid,
+  }: {
+    purchase: Purchase;
+    isConsumable?: boolean;
+    developerPayloadAndroid?: string;
+  }) => Promise<string | boolean | PurchaseResult | void>;
+  getAvailablePurchases: () => Promise<void>;
+  getPurchaseHistories: () => Promise<void>;
+  getProducts: (skus: string[]) => Promise<void>;
+  getSubscriptions: (skus: string[]) => Promise<void>;
+};
+
+let purchaseUpdateSubscription: Subscription;
+let purchaseErrorSubscription: Subscription;
+let promotedProductsSubscription: Subscription;
+
+export function useIAP(): IAP_STATUS {
+  const [connected, setConnected] = useState<boolean>(false);
+  const [products, setProducts] = useState<Product[]>([]);
+  const [promotedProductsIOS, setPromotedProductsIOS] = useState<
+    ProductPurchase[]
+  >([]);
+  const [subscriptions, setSubscriptions] = useState<SubscriptionProduct[]>([]);
+  const [purchaseHistories, setPurchaseHistories] = useState<ProductPurchase[]>(
+    [],
+  );
+  const [availablePurchases, setAvailablePurchases] = useState<
+    ProductPurchase[]
+  >([]);
+  const [currentPurchase, setCurrentPurchase] = useState<ProductPurchase>();
+  const [currentPurchaseError, setCurrentPurchaseError] =
+    useState<PurchaseError>();
+
+  const requestProducts = useCallback(async (skus: string[]): Promise<void> => {
+    setProducts(await getProducts(skus));
+  }, []);
+
+  const requestSubscriptions = useCallback(
+    async (skus: string[]): Promise<void> => {
+      setSubscriptions(await getSubscriptions(skus));
+    },
+    [],
+  );
+
+  const requestAvailablePurchases = useCallback(async (): Promise<void> => {
+    setAvailablePurchases(await getAvailablePurchases());
+  }, []);
+
+  const requestPurchaseHistories = useCallback(async (): Promise<void> => {
+    setPurchaseHistories(await getPurchaseHistory());
+  }, []);
+
+  const finishTransaction = useCallback(
+    async ({
+      purchase,
+      isConsumable,
+      developerPayloadAndroid,
+    }: {
+      purchase: ProductPurchase;
+      isConsumable?: boolean;
+      developerPayloadAndroid?: string;
+    }): Promise<string | boolean | PurchaseResult | void> => {
+      try {
+        return await finishTransaction({
+          purchase,
+          isConsumable,
+          developerPayloadAndroid,
+        });
+      } catch (err) {
+        throw err;
+      } finally {
+        if (purchase.id === currentPurchase?.id) {
+          setCurrentPurchase(undefined);
+        }
+
+        if (purchase.id === currentPurchaseError?.productId) {  // Note that PurchaseError still uses productId
+          setCurrentPurchaseError(undefined);
+        }
+      }
+    },
+    [
+      currentPurchase?.id,
+      currentPurchaseError?.productId,
+      setCurrentPurchase,
+      setCurrentPurchaseError,
+    ],
+  );
+
+  const initIapWithSubscriptions = useCallback(async (): Promise<void> => {
+    const result = await initConnection();
+
+    setConnected(result);
+
+    if (result) {
+      purchaseUpdateSubscription = purchaseUpdatedListener(
+        async (purchase: Purchase | SubscriptionPurchase) => {
+          setCurrentPurchaseError(undefined);
+          setCurrentPurchase(purchase);
+        },
+      );
+
+      purchaseErrorSubscription = purchaseErrorListener(
+        (error: PurchaseError) => {
+          setCurrentPurchase(undefined);
+          setCurrentPurchaseError(error);
+        },
+      );
+
+      promotedProductsSubscription = transactionUpdatedIos(
+        (event: TransactionEvent) => {
+          setPromotedProductsIOS((prevProducts) =>
+            event.transaction
+              ? [...prevProducts, event.transaction]
+              : prevProducts,
+          );
+        },
+      );
+    }
+  }, []);
+
+  useEffect(() => {
+    initIapWithSubscriptions();
+
+    return (): void => {
+      if (purchaseUpdateSubscription) purchaseUpdateSubscription.remove();
+      if (purchaseErrorSubscription) purchaseErrorSubscription.remove();
+      if (promotedProductsSubscription) promotedProductsSubscription.remove();
+
+      endConnection();
+      setConnected(false);
+    };
+  }, [initIapWithSubscriptions]);
+
+  return {
+    connected,
+    products,
+    promotedProductsIOS,
+    subscriptions,
+    purchaseHistories,
+    finishTransaction,
+    availablePurchases,
+    currentPurchase,
+    currentPurchaseError,
+    getProducts: requestProducts,
+    getSubscriptions: requestSubscriptions,
+    getAvailablePurchases: requestAvailablePurchases,
+    getPurchaseHistories: requestPurchaseHistories,
+  };
+}