Processing Purchases

import { Rovenue } from '@rovenue/react-native-sdk';

const offerings = await Rovenue.getOfferings();
// offerings.current — the default Offering (or null if none configured)
// offerings.all     — Record<string, Offering> for all named offerings

let offerings = try await Rovenue.shared.getOfferings()
// offerings.current — the default Offering? 
// offerings.all     — [String: Offering]

val offerings = Rovenue.shared.getOfferings()
// offerings.current — the default Offering?
// offerings.all     — Map<String, Offering>

import { Rovenue } from '@rovenue/react-native-sdk';

const offerings = await Rovenue.getOfferings();
const packages = offerings.current?.packages ?? [];

function Paywall() {
  return (
    <View>
      {packages.map((pkg) => (
        <TouchableOpacity key={pkg.identifier} onPress={() => handlePurchase(pkg)}>
          <Text>{pkg.product.displayName}</Text>
          <Text>{pkg.product.priceString}</Text>
        </TouchableOpacity>
      ))}
    </View>
  );
}

let offerings = try await Rovenue.shared.getOfferings()
let packages = offerings.current?.packages ?? []

for pkg in packages {
  print("\(pkg.product.displayName) — \(pkg.product.priceString ?? "?")")
}

val offerings = Rovenue.shared.getOfferings()
val packages = offerings.current?.packages ?: emptyList()

for (pkg in packages) {
  println("${pkg.product.displayName} — ${pkg.product.priceString}")
}

import { Rovenue, RovenueError } from '@rovenue/react-native-sdk';

async function handlePurchase(pkg) {
  try {
    const result = await Rovenue.purchase(pkg);

    if (result.isDeferred) {
      // Ask-to-Buy / parental controls — not an error. Wait for
      // 'ENTITLEMENTS_CHANGED' via addChangeListener before granting entitlements.
      showPendingMessage();
      return;
    }

    // result.entitlements — verified, up-to-date array
    // result.virtualCurrencies — updated balances (for currency-pack products)
    console.log('Purchase succeeded:', result.productId);
    console.log('Transaction ID:', result.storeTransactionId);

    navigateToSuccess();
  } catch (e) {
    if (!(e instanceof RovenueError)) throw e; // not an SDK error — re-throw
    switch (e.kind) {
      case 'PurchaseCanceled':
        // User dismissed the store sheet — no action needed
        break;
      case 'ProductNotAvailable':
        // Product ID not available in this store environment
        showError('This product is not available. Please try again later.');
        break;
      case 'StoreProblem':
        // Unexpected StoreKit / Play Billing error
        showError('Store error. Please try again.');
        break;
      default:
        throw e; // unexpected — re-throw
    }
  }
}

func handlePurchase(pkg: Package) async {
  do {
    let result = try await Rovenue.shared.purchase(pkg)

    if result.isDeferred {
      // Ask-to-Buy / deferred — inform the user and wait for a change event
      showPendingMessage()
      return
    }

    // result.entitlements — verified, up-to-date array
    // result.virtualCurrencies — updated balances (for currency-pack products)
    print("Purchase succeeded: \(result.productId)")
    print("Transaction ID: \(result.storeTransactionId)")

    navigateToSuccess()
  } catch let e as RovenueError {
    switch e.kind {
    case .purchaseCanceled:
      break // User dismissed the store sheet — no action needed
    case .productNotAvailable:
      showError("This product is not available. Please try again later.")
    case .storeProblem:
      showError("Store error. Please try again.")
    default:
      throw e
    }
  }
}

// `activity` is your current Activity — Play Billing requires it.
suspend fun handlePurchase(activity: Activity, pkg: Package) {
  try {
    val result = Rovenue.shared.purchase(activity, pkg)

    if (result.isDeferred) {
      // Deferred payment — inform the user and wait for a change event
      showPendingMessage()
      return
    }

    // result.entitlements — verified, up-to-date list
    // result.virtualCurrencies — updated balances (for currency-pack products)
    println("Purchase succeeded: ${result.productId}")
    println("Transaction ID: ${result.storeTransactionId}")

    navigateToSuccess()
  } catch (e: RovenueException) {
    when (e.kind) {
      ErrorKind.PURCHASE_CANCELED -> { /* User dismissed the store sheet — no action needed */ }
      ErrorKind.PRODUCT_NOT_AVAILABLE -> showError("This product is not available. Please try again later.")
      ErrorKind.STORE_PROBLEM -> showError("Store error. Please try again.")
      else -> throw e
    }
  }
}

import { Rovenue } from '@rovenue/react-native-sdk';

// Triggered by a "Restore Purchases" button
await Rovenue.restorePurchases();

// Entitlements are refreshed; read from cache
const pro = Rovenue.entitlement('pro');
console.log('pro restored:', pro?.isActive);

// Triggered by a "Restore Purchases" button
try await Rovenue.shared.restorePurchases()

// Entitlements are refreshed; read from cache
let pro = await Rovenue.shared.entitlement("pro")
print("pro restored:", pro?.isActive ?? false)

// Triggered by a "Restore Purchases" button (needs the current Activity)
Rovenue.shared.restorePurchases(activity)

// Entitlements are refreshed; read from cache
val pro = Rovenue.shared.entitlement("pro")
println("pro restored: ${pro?.isActive}")