Quick Start

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

Rovenue.configure({
  apiKey: 'rov_pub_your_key_here',
});

import Rovenue

Rovenue.configure(
  apiKey: "rov_pub_your_key_here"
)

import dev.rovenue.sdk.Rovenue

Rovenue.configure(
  context = this,
  apiKey = "rov_pub_your_key_here"
)

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

export function ProBadge() {
  const pro = useEntitlement('pro'); // Entitlement | null

  if (!pro?.isActive) return null;
  return <View><Text>Pro</Text></View>;
}

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

const pro = Rovenue.entitlement('pro'); // Entitlement | null
if (pro?.isActive) {
  // grant access
}

import Rovenue

// Async read — resolves from cache, never suspends on network
let pro = await Rovenue.shared.entitlement("pro")

if pro?.isActive == true {
  // grant access
}

import dev.rovenue.sdk.Rovenue

val pro = Rovenue.shared.entitlement("pro")

if (pro?.isActive == true) {
  // grant access
}

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

async function handlePurchase() {
  // 1. Fetch the current offering (cached; network-refreshed in background)
  const offerings = await Rovenue.getOfferings();
  const pkg = offerings.current?.packages[0];
  if (!pkg) return; // no products configured

  try {
    // 2. Launch native purchase sheet; resolves after server validation
    const result = await Rovenue.purchase(pkg);

    if (result.isDeferred) {
      // Ask-to-Buy / deferred payment — not an error; inform the user to wait
      return;
    }

    console.log('Entitlements:', result.entitlements);
    console.log('Virtual currencies:', result.virtualCurrencies);
  } catch (e) {
    if (e instanceof RovenueError && e.kind === 'PurchaseCanceled') {
      // User dismissed the sheet — not an error; do nothing
    } else {
      throw e;
    }
  }
}

// Restore purchases (call on a "Restore" button)
await Rovenue.restorePurchases();

import Rovenue

func handlePurchase() async {
  // 1. Fetch the current offering
  guard let offerings = try? await Rovenue.shared.getOfferings(),
        let pkg = offerings.current?.packages.first else { return }

  do {
    // 2. Launch native purchase sheet; resolves after server validation
    let result = try await Rovenue.shared.purchase(pkg)

    if result.isDeferred {
      // Ask-to-Buy / deferred — not an error; inform user
      return
    }

    print("Entitlements:", result.entitlements)
    print("Virtual currencies:", result.virtualCurrencies)
  } catch let e as RovenueError {
    switch e.kind {
    case .purchaseCanceled:
      break // User dismissed — not an error
    default:
      throw e
    }
  }
}

// Restore purchases
try? await Rovenue.shared.restorePurchases()

import android.app.Activity
import dev.rovenue.sdk.Rovenue
import dev.rovenue.sdk.RovenueException
import dev.rovenue.sdk.ErrorKind

// `activity` is your current Activity — Play Billing requires it.
suspend fun handlePurchase(activity: Activity) {
  // 1. Fetch the current offering
  val offerings = Rovenue.shared.getOfferings()
  val pkg = offerings.current?.packages?.firstOrNull() ?: return

  try {
    // 2. Launch native purchase sheet; resolves after server validation
    val result = Rovenue.shared.purchase(activity, pkg)

    if (result.isDeferred) {
      // Deferred payment — not an error; inform user
      return
    }

    println("Entitlements: ${result.entitlements}")
    println("Virtual currencies: ${result.virtualCurrencies}")
  } catch (e: RovenueException) {
    when (e.kind) {
      ErrorKind.PURCHASE_CANCELED -> { /* User dismissed — not an error */ }
      else -> throw e
    }
  }
}

// Restore purchases (also needs the current Activity)
Rovenue.shared.restorePurchases(activity)

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

// After your auth flow resolves and you have a stable user ID:
async function onLoginSuccess(userId: string) {
  Rovenue.identify(userId); // optimistic: local state updates immediately

  const user = Rovenue.currentUser();
  // user.rovenueId  → permanent install id (rov_...)
  // user.appUserId  → userId you just passed
}

// On sign-out: clear appUserId and mint a fresh rovenueId
async function onLogOut() {
  Rovenue.logOut();
}

import Rovenue

// After login:
func onLoginSuccess(userId: String) {
  Rovenue.shared.identify(appUserId: userId) // optimistic

  let user = await Rovenue.shared.currentUser()
  // user.rovenueId  → permanent install id (rov_...)
  // user.appUserId  → userId
}

// On sign-out:
func onLogOut() {
  Rovenue.shared.logOut()
}

import dev.rovenue.sdk.Rovenue

// After login:
fun onLoginSuccess(userId: String) {
  Rovenue.shared.identify(appUserId = userId) // optimistic

  val user = Rovenue.shared.currentUser()
  // user.rovenueId  → permanent install id (rov_...)
  // user.appUserId  → userId
}

// On sign-out:
fun onLogOut() {
  Rovenue.shared.logOut()
}