> refresh() async
```
{% endtab %}
{% tab title="React Native" %}
import {NamiEntitlementManager, NamiEntitlement} from 'react-native-nami-sdk';
NamiEntitlementManager.refresh((newEntitlements) => {
console.log('newEntitlements', newEntitlements);
});
{% endtab %}
{% tab title="Unity" %}
```c
NamiEntitlementManager.Refresh(RefreshCallback);
void RefreshCallback(List entitlements)
{
// on refresh
}
```
{% endtab %}
{% endtabs %}
# registerActiveEntitlementsHandler
Register a callback to react to a potential changes to the active entitlements for the user, whenever such state is fetched from the Nami service. This occurs during the course of the application lifecycle as well as when [refresh](/sdk-reference/namientitlementmanager/refresh) is called.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiEntitlementManager.registerActiveEntitlementsHandler { (activeEntitlements: [NamiEntitlement]) in
// respond to the current active entitlements for the user
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiEntitlementManager.registerActiveEntitlementsHandler { activeEntitlements ->
// respond to the current active entitlements for the user
}
```
{% endtab %}
{% tab title="Flutter" %}
```dart
NamiEntitlementManager.registerActiveEntitlementsHandler()
.listen((activeEntitlementHandlerData) {
});
```
{% endtab %}
{% tab title="React Native" %}
```jsx
import {NamiEntitlementManager, NamiEntitlement} from 'react-native-nami-sdk';
const subscriptionRemover =
NamiEntitlementManager.registerActiveEntitlementsHandler(
(activeEntitlements) => {
console.log('activeEntitlements', activeEntitlements);
setEntitlements(activeEntitlements);
},
);
return () => {
subscriptionRemover();
};
```
{% endtab %}
{% tab title="Unity" %}
```c
NamiEntitlementManager.RegisterActiveEntitlementsHandler(activeEntitlementsCallback);
```
{% endtab %}
{% endtabs %}
**Returns**
* `activeEntitlements` - a list of the current entitlements active for the user and device.
# dismiss
Close a paywall if it is open
Use to close a Nami paywall programmatically if desired.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPaywallManager.dismiss(animated: Bool, completion: (Void)->Void)
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
```
{% endtab %}
{% tab title="Flutter" %}
```Text
// coming soon
```
{% endtab %}
{% tab title="React Native" %}
```c
// coming soon
```
{% endtab %}
{% tab title="Unity" %}
```c
NamiPaywallManager.Dismiss();
```
{% endtab %}
{% endtabs %}
**Parameters**
* `animated`: Will animate the closing of the paywall if true.
* `completion`: Code to execute after paywall closure is fully complete.
# displayedViewController
{% hint style="info" %}
Apple-only method.
{% endhint %}
```swift
NamiPaywallManager.displayedViewController()
```
Returns the last raised Nami Paywall view controller. Will be `.none` if the paywall is closed.
### Handling VC Alerts
```swift
NamiPurchaseManager.registerRestorePurchasesHandler { state, newPurchases, oldPurchases, error in
let presentAlertFromVC = NamiPaywallManager.displayedViewController()
switch state {
case .started:
print("starting restoring purchases")
case .finished:
// additionally may want to check that there are more items in
// newPurchases than oldPurchases
if oldPurchases != newPurchases {
print("Found restored purchases")
presentAlertFromVC?.dismiss(animated: false)
} else {
let alert = UIAlertController(title: "Restore Purchase", message: "No previous purchases to restore", preferredStyle: UIAlertController.Style.alert)
alert.addAction(UIAlertAction(title: "OK", style: .default, handler: nil))
presentAlertFromVC!.present(alert, animated: true, completion: nil)
}
case .error:
print("error restoring purchases")
default:
print("unknown case")
}
}
```
# registerSignInHandler
Register a sign-in provider to handle your own sign-in logic
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPaywallManager.registerSignInHandler { fromPaywallVC in
// Add code to handle sign-in logic
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiPaywallManager.registerSignInHandler { context ->
// Add code to handle sign-in logic
}
```
{% endtab %}
{% tab title="Flutter" %}
```c
// coming soon
```
{% endtab %}
{% tab title="React Native" %}
```jsx
useEffect(() => {
const subscriptionSignInRemover =
NamiPaywallManager.registerSignInHandler(() => {
console.log('sign in');
});
return () => {
subscriptionSignInRemover();
};
```
{% endtab %}
{% tab title="Unity" %}
```c
NamiPaywallManager.RegisterSignInHandler(signInCallback);
```
{% endtab %}
{% endtabs %}
**Callback**
* (Apple-native only) `fromPaywallVC` : The paywall view controller from which the sign-in control was tapped by the user
* (Android-native only) `context` : The paywall context from which the sign-in control was tapped by the user
# registerCloseHandler
If this registered, paywall `close` buttons will call back to this handler for your own custom business logic instead of using the system default, which is to just dismiss the paywall.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPaywallManager.registerCloseHandler { paywall in
if let paywallVC = paywall {
paywallVC.dismiss(animated: true)
}
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiPaywallManager.registerCloseHandler { paywall ->
Log.d(LOG_TAG, "Paywall Close requested - implement custom logic here")
paywall.finish()
}
```
{% endtab %}
{% tab title="Flutter" %}
```c
// coming soon
```
{% endtab %}
{% tab title="React Native" %}
```c
// coming soon
```
{% endtab %}
{% tab title="Unity" %}
```c
NamiPaywallManager.RegisterCloseHandler(CloseCallback);
void CloseCallback()
{
// code, e.g.
NamiPaywallManager.Dismiss();
}
```
{% endtab %}
{% endtabs %}
# registerBuySkuHandler
{% hint style="info" %}
**For Paywalls-only plans**
This method is for customers who have implemented their own in-app purchases or subscription code directly with the App Store, Google Play, etc. or who are using another third-party for subscription or purchase management.
Your Nami account needs to be on a Paywalls-only plan to use this interface. Contact for details.
{% endhint %}
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPaywallManager.registerBuySkuHandler { sku in
print("Start the purchase flow for App Store product: \(sku.storeId)")
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiPaywallManager.registerBuySkuHandler { paywall, sku ->
Log.d(LOG_TAG, "Start the purchase flow for Google Play/Amazon Appstore product: $skuRefId")
}
```
{% endtab %}
{% tab title="Flutter" %}
```
// Coming soon
```
{% endtab %}
{% tab title="React Native" %}
```jsx
NamiPaywallManager.registerBuySkuHandler((sku) => {
// Start your purchase flow
console.log(
'buy sku handler - start purchase flow for sku:',
sku.skuId,
);
}
```
{% endtab %}
{% tab title="Unity" %}
```c
NamiPaywallManager.RegisterBuySkuHandler(buySkuCallback);
```
{% endtab %}
{% endtabs %}
Registering with `NamiPaywallManager.registerBuySkuHandler` will provide a callback from a Nami paywall when the user has selected a sku and asked for the purchase flow to start.
It is you're responsible to listen to this handler's callback to start the purchase with the provided sku.
Once the purchase is successful, indicate it is complete by calling [buySkuComplete](/sdk-reference/namipaywallmanager/buyskucomplete) to close the paywall.
# registerDeeplinkActionHandler
Register a handler that calls back with a when a paywall's Deeplink Button is invoked
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPaywallManager.registerDeeplinkActionHandler { destination in
// Calls back with a string value as configured in the Paywall Creator
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiPaywallManager.registerDeepLinkHandler { paywallActivity, destination ->
// Calls back with destination value for Deeplink Button configured
// in the Paywall Creator
}
```
{% endtab %}
{% tab title="React Native" %}
```typescript
import {NamiPaywallManager} from 'react-native-nami-sdk';
const subscriptionDeeplinkRemover =
NamiPaywallManager.registerDeeplinkActionHandler((destination) => {
console.log('deeplink action ', destination);
});
```
{% endtab %}
{% tab title="Roku" %}
```brightscript
' This is a condensed example.
' See the full example in the Demo app:
' https://github.com/namiml/nami-roku/blob/main/Demo/components/NamiDataSource.brs
' https://github.com/namiml/nami-roku/blob/main/Demo/components/NamiDataSource.xml
sub init()
setupLocals()
initializeNamiSDKValues()
end sub
sub setupLocals()
m.scene = m.top.getScene()
m.namiPaywallManager = m.namiManager.namiPaywallManager
end sub
sub initializeNamiSDKValues()
m.namiPaywallManager.callFunc("registerDeeplinkActionHandler", m.top)
end sub
function deeplinkActionHandlerCallback(url)
' deeplink url open process
print "NamiDataSource : deeplinkActionHandlerCallback : deeplink url : " url
end function
```
{% endtab %}
{% endtabs %}
# buySkuComplete
{% hint style="info" %}
**For Paywalls-0nly Plans**
This method is for customers who have implemented their own in-app purchases or subscription code directly with the App Store, Google Play, etc. or who are using another third-party for subscription or purchase management.
Your Nami account needs to be on a Paywalls only plan to use this interface. Contact for details.
{% endhint %}
{% tabs %}
{% tab title="Swift" %}
```swift
// StoreKit 2 Product & Transaction objects
NamiPaywallManager.buySkuComplete(sku: NamiSKU, product: Product, transaction: Transaction)
// StoreKit 1 SKProduct & SKPaymentTransaction objects
NamiPaywallManager.buySkuComplete(sku: NamiSKU, product: SKProduct, transaction: SKPaymentTransaction)
// or pass in the individual data elements used by Nami, wrapped in a `NamiPurchaseSuccess` object
let purchaseSuccess = NamiPurchaseSuccess(product: sku, transactionID: transactionId, originalTransactionID: originalTransactionId, originalPurchaseDate: originalPurchaseDate, purchaseDate: purchaseDate, expiresDate: expirationDate, price: price, currencyCode: currency, locale: locale)
NamiPaywallManager.buySkuComplete(purchaseSuccess: purchaseSuccess)
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
// paywall, and skuRefId were passed to you via NamiPurchaseManager.registerBuySkuHandler
// purchase is the purchase object from Google Play Billing
NamiPaywallManager.buySkuComplete(paywallActivity, purchase, sku)
// or provided a NamiPurchaseSuccess.Google or NamiPurchaseSuccess.Amazon object
NamiPaywallManager.buySkuComplete(paywallActivity, purchaseSuccess)
```
{% endtab %}
{% tab title="Flutter" %}
```
// Coming Soon
```
{% endtab %}
{% tab title="React Native" %}
```jsx
// Once purchase flow is complete:
if (Platform.OS === 'ios' || Platform.isTVOS) {
NamiPaywallManager.buySkuCompleteApple({
product: sku,
transactionID: '12345',
originalTransactionID: '12345',
originalPurchaseDate: 1684823428,
purchaseDate: 1684823428,
price: '120',
currencyCode: 'USD',
locale: 'US',
});
} else if (Platform.OS === 'android') {
if (Platform.constants.Manufacturer === 'Amazon') {
NamiPaywallManager.buySkuCompleteAmazon({
product: sku,
purchaseDate: 1684823428,
purchaseSource: 'CAMPAIGN',
receiptId: '12345',
localizedPrice: '120',
userId: '12345',
marketplace: '12345',
});
} else {
NamiPaywallManager.buySkuCompleteGooglePlay({
product: sku,
purchaseDate: 1684823428,
purchaseSource: 'CAMPAIGN',
purchaseToken:
'jolbnkpmojnpnjecgmphbmkc.AO-J1OznE4AIzyUvKFe1RSVkxw4KEtv0WfyL_tkzozOqnlSvIPsyQJBphCN80gwIMaex4EMII95rFCZhMCbVPZDc-y_VVhQU5Ddua1dLn8zV7ms_tdwoDmE',
orderId: 'GPA.3317-0284-9993-42221',
});
}
}
```
{% endtab %}
{% tab title="Unity" %}
```
// Coming soon
```
{% endtab %}
{% endtabs %}
Once your billing implementation has successfully processed a user's purchase, let the Nami SDK know by calling `NamiPaywallManager.buySkuComplete`. Once invoked, the paywall view will be closed.
To known when to start the purchase process, see [registerBuySkuHandler](/sdk-reference/namipaywallmanager/registerbuyskuhandler).
# NamiPurchaseSuccess
{% hint style="info" %}
**For Paywalls-0nly Plans**
This method is for customers who have implemented their own in-app purchases or subscription code directly with the App Store, Google Play, etc. or who are using another third-party for subscription or purchase management.
Your Nami account needs to be on a Paywalls only plan to use this interface. Contact for details.
{% endhint %}
{% tabs %}
{% tab title="Swift" %}
```c
@objc public class NamiPurchaseSuccess: NSObject, Codable {
let product: NamiSKU
let transactionID: String
let originalTransactionID: String
let originalPurchaseDate: Date
let expiresDate: Date?
let purchaseDate: Date
let price: Decimal
let currencyCode: String
let locale: Locale
let purchaseSource: NamiPurchaseSource
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
sealed class NamiPurchaseSuccess(
open val product: NamiSKU,
open val expiresDate: Date?,
open val purchaseDate: Date,
open val purchaseSource: NamiPurchaseSource,
open val description: String?
) {
data class GooglePlay(
override val product: NamiSKU,
override val expiresDate: Date?,
override val purchaseDate: Date,
override val purchaseSource: NamiPurchaseSource,
override val description: String?,
val orderId: String,
val purchaseToken: String,
) : NamiPurchaseSuccess(product, expiresDate, purchaseDate, purchaseSource, description)
data class Amazon(
override val product: NamiSKU,
override val expiresDate: Date?,
override val purchaseDate: Date,
override val purchaseSource: NamiPurchaseSource,
override val description: String?,
val receiptId: String,
val localizedPrice: String,
val userId: String,
val marketplace: String
) : NamiPurchaseSuccess(product, expiresDate, purchaseDate, purchaseSource, description)
}
```
{% endtab %}
{% tab title="Flutter" %}
```c
// coming soon
```
{% endtab %}
{% tab title="React Native" %}
```jsx
export type PurchaseSuccessIos = {
product: PurchaseSuccessProduct;
transactionID: string;
originalTransactionID: string;
originalPurchaseDate: number;
purchaseDate: number;
expiresDate?: number;
price: string;
currencyCode: string;
locale: string;
};
export type PurchaseSuccessGooglePlay = {
product: PurchaseSuccessProduct;
orderId: string;
purchaseDate: number;
expiresDate?: number;
purchaseToken: string;
purchaseSource: "CAMPAIGN" | "MARKETPLACE" | "UNKNOWN";
};
export type PurchaseSuccessAmazon = {
product: PurchaseSuccessProduct;
purchaseDate: number;
expiresDate?: number;
purchaseSource: "CAMPAIGN" | "MARKETPLACE" | "UNKNOWN";
receiptId: string;
localizedPrice: string;
userId: string;
marketplace: string;
};
```
{% endtab %}
{% tab title="Unity" %}
```c
// coming soon
```
{% endtab %}
{% endtabs %}
# NamiPaywallAction
{% tabs %}
{% tab title="Swift" %}
```swift
@objc public enum NamiPaywallAction : Int {
case close_paywall = 0
case restore_purchases = 1
case sign_in = 2
case buy_sku = 3
case select_sku = 4
case purchase_selected_sku = 5
case purchase_success = 6
case purchase_deferred = 7
case purchase_failed = 8
case purchase_cancelled = 9
case purchase_unknown = 10
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
enum class NamiPaywallAction {
NAMI_CLOSE_PAYWALL,
NAMI_RESTORE_PURCHASES,
NAMI_SIGN_IN,
NAMI_BUY_SKU,
NAMI_SELECT_SKU,
NAMI_PURCHASE_SELECTED_SKU,
NAMI_PURCHASE_SUCCESS,
NAMI_PURCHASE_CANCELLED,
NAMI_PURCHASE_FAILED,
NAMI_PURCHASE_PENDING,
NAMI_PURCHASE_UNKNOWN
}
```
{% endtab %}
{% tab title="Flutter" %}
```c
// coming soon
```
{% endtab %}
{% tab title="React Native" %}
```javascript
export enum NamiPaywallAction {
BUY_SKU = "BUY_SKU",
SELECT_SKU = "SELECT_SKU",
RESTORE_PURCHASES = "RESTORE_PURCHASES",
SIGN_IN = "SIGN_IN",
CLOSE_PAYWALL = "CLOSE_PAYWALL",
SHOW_PAYWALL = "SHOW_PAYWALL",
PURCHASE_SELECTED_SKU = "PURCHASE_SELECTED_SKU",
PURCHASE_SUCCESS = "PURCHASE_SUCCESS",
PURCHASE_FAILED = "PURCHASE_FAILED",
PURCHASE_CANCELLED = "PURCHASE_CANCELLED",
PURCHASE_PENDING = "PURCHASE_PENDING",
PURCHASE_UNKNOWN = "PURCHASE_UNKNOWN",
PURCHASE_DEFERRED = "PURCHASE_DEFERRED",
SHOW_PAYWALL = "SHOW_PAYWALL",
}
```
{% endtab %}
{% tab title="Unity" %}
```c
public enum NamiPaywallAction
{
ClosePaywall,
RestorePurchases,
SignIn,
BuySku,
SelectSku,
#if UNITY_IOS
PurchaseSelectedSku,
PurchaseSuccess,
PurchaseDeferred,
PurchaseFailed,
PurchaseCancelled,
PurchaseUnknown
#endif
}
```
{% endtab %}
{% endtabs %}
**Show Paywall** - the paywall is shown to the user
**Close Paywall**- the paywall is closed through the close control (if available), or by using the operating system to dismiss the view. For instance, through a hardware back button on Android or swiping the modal view away on iOS
**Restore Purchases** - the users invokes the paywall's restore purchases control
**Sign In** - the users invokes the paywall's sign in control for handling by the app developer
**Buy Sku** - the users starts the purchase flow by choosing a sku. For paywalls where product sku is a button that initiates the purchase flow.
**Select Sku** - the users selects a sku. For paywalls where the product skus are decoupled from the call to action button that initiates the purchase flow.
**Purchase Selected Sku** - the users starts the purchase flow from the selected sku. For paywalls where the product skus are decoupled from the call to action button that initiates the purchase flow.
**Purchase Success** - the purchase was successful. The paywall will be automatically closed. See `purchases` included on `paywallActionHandler` from `NamiCampaignManager.launch`
**Purchase Failed** - the purchase failed. See `purchaseError` included on `paywallActionHandler` from `NamiCampaignManager.launch`
**Purchase Cancelled** - the purchase flow was cancelled by the end user.
**Purchase Unknown** - an unknown purchase flow event was encountered
**Purchase Deferred** (Apple only) - the purchase was deferred.
**Purchase Pending** (Android only) - the purchase is pending.
# NamiSKUType
Enum defining types of SKUs
{% tabs %}
{% tab title="Swift" %}
```swift
@objc public enum NamiSKUType: Int, Codable {
case unknown = 0
case one_time_purchase
case subscription
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
@JsonClass(generateAdapter = false)
enum class NamiSKUType {
@Json(name = "one_time_purchase")
ONE_TIME_PURCHASE,
@Json(name = "subscription")
SUBSCRIPTION,
@Json(name = "unknown")
UNKNOWN
}
```
{% endtab %}
{% tab title="Flutter" %}
```dart
enum NamiPlatformType { one_time_purchase, subscription, unknown }
```
{% endtab %}
{% tab title="React Native" %}
```javascript
const NamiSKUType = {
"one_time_purchase": "one_time_purchase",
"subscription": "subscription",
"unknown": "unknown"
}
```
{% endtab %}
{% tab title="Unity" %}
```c
public enum NamiSKUType
{
Unknown,
OneTimePurchase,
Subscription
}
```
{% endtab %}
{% endtabs %}
# anySkuPurchased
Check if any of the passed in product SKU IDs have been purchased by the device.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPurchaseManager.anySkuPurchased(_ skuIds: [StoreID]) -> Bool
```
{% endtab %}
{% tab title="Kotlin" %}
```c
// coming soon
```
{% endtab %}
{% tab title="Flutter" %}
```Text
// coming soon
```
{% endtab %}
{% tab title="React Native" %}
```Text
// coming soon
```
{% endtab %}
{% tab title="Unity" %}
```Text
// coming soon
```
{% endtab %}
{% endtabs %}
**Arguments**
* (required) `skuIds`: An array of product SKU IDs to check for purchase status
**Returns**\
Boolean true if any of the product SKUs in the list have been purchased, or false otherwise.
# consumePurchasedSku
Mark a consumable IAP as processed so it can be purchased again.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPurchaseManager.consumePurchasedSku(skuId: StoreID)
```
{% endtab %}
{% tab title="Kotlin" %}
```Text
// coming soon
```
{% endtab %}
{% tab title="Flutter" %}
```Text
// coming soon
```
{% endtab %}
{% tab title="React Native" %}
```Text
// coming soon
```
{% endtab %}
{% tab title="Unity" %}
```Text
// coming soon
```
{% endtab %}
{% endtabs %}
**Parameters**
* `skuId` - the ID of the SKU to be consumed, can be a string, set in the Control Center.
# NamiPurchase
Object representing a purchase in the Nami Platform.
{% tabs %}
{% tab title="Swift" %}
```swift
public class NamiPurchase : NSObject, Codable {
public var sku : NamiSKU,
public var expires : Date?
public var entitlementsGranted: [NamiEntitlement]
public var transactionIdentifier : String?
public var transaction : SKPaymentTransaction?
public let skuId : StoreID
public var purchaseInitiatedTimestamp: Date
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
data class NamiPurchase(
val purchaseInitiatedTimestamp: Long = Date().time,
val expires: Date? = null,
val purchaseSource: NamiPurchaseSource,
val skuId: String,
val transactionIdentifier: String?,
val purchaseToken: String?
)
```
{% endtab %}
{% tab title="Flutter" %}
```dart
class NamiPurchase {
final int purchaseInitiatedTimestamp;
final DateTime? expires;
final NamiPurchaseSource purchaseSource;
final String skuId;
final String? transactionIdentifier;
final String? localizedDescription;
}
```
{% endtab %}
{% tab title="React Native" %}
```javascript
export type NamiPurchase = {
sku?: NamiSKU;
skuId: string;
transactionIdentifier?: string;
expires?: Date;
purchaseInitiatedTimestamp: Date;
purchaseSource?: "CAMPAIGN" | "MARKETPLACE" | "UNKNOWN";
};
```
{% endtab %}
{% tab title="Unity" %}
```c
public class NamiPurchase
{
public long PurchaseInitiatedTimestamp { get; private set; }
public DateTime Expires { get; private set; }
/// Android platforms only
public NamiPurchaseSource PurchaseSource { get; private set; }
public string SkuId { get; private set; }
public string TransactionIdentifier { get; private set; }
/// Android platforms only
public string PurchaseToken { get; private set; }
/// Apple platforms only
public NamiSKU Sku { get; private set; }
/// Apple platforms only
public List EntitlementsGranted { get; private set; }
/// Apple platforms only
public string Transaction { get; private set; }
}
```
{% endtab %}
{% endtabs %}
**Parameters**
Each App Platform provides data in NamiPurchase based upon what is available in the underlying store APIs.
**App Store**
* `sku` - a [NamiSKU](/sdk-reference/namipurchasemanager/namisku) object representing the in-app purchase product SKU the device purchased.
* `expires` - date the purchase expires if it is a subscription
* `entitlementGranted` - a [NamiEntitlement](/sdk-reference/namientitlementmanager/namientitlement) object for the entitlement granted by this purchase.
* `transactionIdentifier` - App Store ID for the transaction
* `transaction` - the StoreKit transaction object for the purchase
* `skuId` - the App Store reference ID of the purchased product SKU
* `purchaseInitiatedTimestamp` - The date and time when the purchase was initiated
**Google Play**
* `purchaseInitiatedTimestamp` - The date and time when the purchase was initiated
* `expires` - (bypass store only) Indicates when this purchase will cease
* `skuId` - the Google Play reference ID of the purchased product SKU
* `transactionIdentifier` - The purchase order ID record associated to this purchase
* `purchaseToken` - The purchase token associated to this purchase
# NamiPurchaseState
The different states a purchase can be in. Different platforms and frameworks may have different sets of states that they support.
{% tabs %}
{% tab title="Swift" %}
```swift
@objc public enum NamiPurchaseState: Int {
case pending
case purchased
case consumed
case resubscribed
case unsubscribed
case deferred
case failed
case cancelled
case unknown
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
enum class NamiPurchaseState {
PURCHASED,
FAILED,
CANCELLED,
PENDING,
UNKNOWN
}
```
{% endtab %}
{% tab title="Flutter" %}
```dart
enum NamiPurchaseState {
purchased,
failed,
cancelled,
pending,
unknown,
deferred,
resubscribed,
unsubscribed,
consumed
}
```
{% endtab %}
{% tab title="React Native" %}
```jsx
export enum NamiPurchaseState {
PENDING = "pending",
PURCHASED = "purchased",
CONSUMED = "consumed",
RESUBSCRIBED = "resubscribed",
UNSUBSCRIBED = "unsubscribed",
DEFERRED = "deferred",
FAILED = "failed",
CANCELLED = "cancelled",
UNKNOWN = "unknown",
}
```
{% endtab %}
{% tab title="Unity" %}
```c
public enum NamiPurchaseState
{
Pending,
Purchased,
Consumed,
Resubscribed,
Unsubscribed,
Deferred,
Failed,
Cancelled,
Unknown
}
```
{% endtab %}
{% endtabs %}
# NamiRestorePurchasesState
{% hint style="info" %}
**Apple SDK only**
This method is only available from the Nami SDK for Apple devices.
{% endhint %}
This object is specific to the Nami Apple SDK and Apple's process for restoring purchases. Each state is one that can be reacted to with .
{% tabs %}
{% tab title="Swift" %}
```swift
@objc public enum NamiRestorePurchasesState: Int {
case started
case finished
case error
}
```
{% endtab %}
{% tab title="Flutter" %}
```Text
// Coming soon
```
{% endtab %}
{% tab title="React Native" %}
```Text
// Coming soon
```
{% endtab %}
{% tab title="Unity" %}
```
// Coming soon
```
{% endtab %}
{% endtabs %}
# NamiSKU
Object that contains all the data on a in-app purchase SKU for an App Platform.
{% tabs %}
{% tab title="Swift" %}
```swift
public class NamiSKU: NSObject, Codable {
public var name : String
public var skuId : String
public var product : SKProduct?
public var type : NamiSKUType
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
data class NamiSKU internal constructor(
val name: String,
val skuId: String,
val skuDetails: SkuDetails,
val type: NamiSKUType,
)
```
{% endtab %}
{% tab title="Flutter" %}
```dart
class NamiSKU {
final String? name;
final String skuId;
final NamiSKUType type;
}
```
{% endtab %}
{% tab title="React Native" %}
```jsx
export type NamiSKU = {
name: string;
skuId: string;
product?: SKProduct;
type: NamiSKUType;
};
```
{% endtab %}
{% tab title="Unity" %}
```c
public class NamiSKU
{
public string Name { get; private set; }
public string SkuId { get; private set; }
/// GooglePlay only
public string SkuDetails { get; private set; }
/// Apple only
public string Product { get; private set; }
public NamiSKUType Type { get; private set; }
}
```
{% endtab %}
{% endtabs %}
**Parameters**
* `name` - The name of the product as set in the Nami Control Center
* `skuId` - The in-app purchase or subscription reference ID from the App Store or Google Play
* `product` - (Apple-only) additional product info from Apple StoreKit
* `skuDetails` - (Google Play-only) additional product info from Google Play Billing
* `type` - indicates subscription or one time purchase
# presentCodeRedemptionSheet
{% hint style="info" %}
**Apple Only**
This only works on Apple, for apps running iOS 14+
{% endhint %}
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPurchaseManager.presentCodeRedemptionSheet()
```
{% endtab %}
{% tab title="Flutter" %}
```dart
// Coming soon
```
{% endtab %}
{% tab title="React Native" %}
```Text
// Coming soon
```
{% endtab %}
{% tab title="Unity" %}
```Text
NamiPurchaseManager.PresentCodeRedemptionSheet();
```
{% endtab %}
{% endtabs %}
# registerPurchasesChangedHandler
Register a callback that will be made anytime there is a change to purchases made on the device. This will be triggered when a purchase process is started and may have different states based on the particular store platform.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPurchaseManager.registerPurchasesChangedHandler { (purchases, purchaseState, error) in
// process purchases data
}
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiPurchaseManager.registerPurchasesChangedHandler { purchases, purchaseState, error ->
// process purchases change
}
```
{% endtab %}
{% tab title="Flutter" %}
```dart
NamiPurchaseManager.registerPurchasesChangedHandler()
.listen((purchasesResponseHandlerData) {
// process purchases change
});
```
{% endtab %}
{% tab title="React Native" %}
```Text
// Coming soon
```
{% endtab %}
{% tab title="Unity" %}
```c
NamiPurchaseManager.RegisterPurchasesChangedHandler(purchasesChangedCallback);
```
{% endtab %}
{% endtabs %}
**Returns**
* `purchases` - a list of the current purchases
* `purchaseState` - the state of the purchase, see [NamiPurchaseState](/sdk-reference/namipurchasemanager/namipurchasestate) for all options
* `error` - information about an error if one occurred, generated by the store platform making the purchase
# registerRestorePurchasesHandler
{% hint style="info" %}
**Apple Only**
This method is only available from the Nami SDK for Apple devices, or cross-platform SDKs being used on Apple devices.
{% endhint %}
For recommendations on where to present UI elements to your customers during a restore purchases process, see our [Restoring Purchases](doc:restoring-purchases) guide.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPurchaseManager.registerRestorePurchasesHandler { state, newPurchases, oldPurchases, error in
// react to restore purchase process
}
```
{% endtab %}
{% tab title="Flutter" %}
```Text
// Coming soon
```
{% endtab %}
{% tab title="React Native" %}
```Text
// Coming soon
```
{% endtab %}
{% tab title="Unity" %}
```Text
NamiPurchaseManager.RegisterRestorePurchasesHandler(restorePurchasesCallback); // Apple only
```
{% endtab %}
{% endtabs %}
**Parameters**
Handler has the following parameters that return data:
* `state` - the [NamiRestorePurchasesState](/sdk-reference/namipurchasemanager/namirestorepurchasesstate), on React Native `stateDesc`
* `newPurchases` - a list of new purchases found that will be restored in the Restore Purchases process
* `oldPurchases` - a list of existing purchases already active on the device
* `error` - any error returned by the Restore Purchases process
# restorePurchases
Start the process to restore any purchases not currently active on the device.
{% hint style="info" %}
**Apple SDK only**
This method is only available from the Nami SDK for Apple devices, or cross-platform SDKs being used on Apple devices.
{% endhint %}
Restore replays all prior purchase transactions to determine which purchases are active. This function trigger an app store password prompt if called, so only call this at the request of the user.
Generally this is not needed if your Nami account supports purchase validation, as the receipt is checked every time the app comes to the foreground and can determine active purchases that way.
Learn more in our guide on [Restoring Purchases](doc:restoring-purchases) .
Activate the system restore purchases feature. Optionally calls back to a global `NamiRestorePurchasesStateHandler` handler with restore state if one is provided by\
`registerRestorePurchasesHandler`.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPurchaseManager.restorePurchases()
```
{% endtab %}
{% tab title="Flutter" %}
```Text
// Coming soon
```
{% endtab %}
{% tab title="React Native" %}
```Text
// Coming soon
```
{% endtab %}
{% tab title="Unity" %}
```Text
NamiPurchaseManager.RestorePurchases(); // Apple only
```
{% endtab %}
{% endtabs %}
Activate the system restore purchases feature and call back to the provided completion handler:
{% tabs %}
{% tab title="Swift" %}
```swift
NamiPurchaseManager.restorePurchases() { state, newPurchases, oldPurchases, error in
// react to restore purchase process
}
```
{% endtab %}
{% tab title="Flutter" %}
```c
// coming soon
```
{% endtab %}
{% tab title="React Native" %}
```Text
// coming soon
```
{% endtab %}
{% tab title="Unity" %}
```c
NamiPurchaseManager.RestorePurchases(restorePurchasesCallback); // Apple only
```
{% endtab %}
{% endtabs %}
**Parameters**
* `state` - of the Restore purchase process
* `newPurchases` - array of all purchases that are active after restore purchase process ran
* `oldPurchases` - array of purchases that were active before the restore purchase process started
* `error` - error returned by the restore purchase process
# skuPurchased
Check if a specific product SKU has been purchased.
{% tabs %}
{% tab title="Swift" %}
```swift
public static func skuPurchased(_ skuId: StoreId) -> Bool
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
fun isSKUIDPurchased(skuID: String): Boolean
```
{% endtab %}
{% tab title="Flutter" %}
```dart
static Future skuPurchased(String skuID)
```
{% endtab %}
{% tab title="React Native" %}
```Text
// coming soon
```
{% endtab %}
{% tab title="Unity" %}
```c
// coming soon
```
{% endtab %}
{% endtabs %}
**Parameters**
* `skuId` The id of a product SKU from the Control Center.
**Returns**\
True if the the `skuId` has been purchased, false otherwise.
# coreAction
Inform the SDK about an important action a user may take in your app.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiMLManager.coreAction(label: "Shared Item")
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiMLManager.coreAction(label: String)
```
{% endtab %}
{% tab title="Flutter" %}
```dart
NamiMLManager.coreAction(String label);
```
{% endtab %}
{% tab title="React Native" %}
```javascript
NativeModules.NamiMLManagerBridge.coreActionWithLabel("Shared Item");
```
{% endtab %}
{% endtabs %}
**Arguments**
* (required) `label`: a string label used to identify the core user action
Used to indicate when a user performed an action in your app that is important in creating customer loyalty and engagement. These may include actions like liking or sharing, for example.
# enterCoreContent
Inform the SDK when a user starts consuming content that is core to your app experience
{% tabs %}
{% tab title="Swift" %}
```swift
NamiMLManager.enterCoreContent(label: String)
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiMLManager.enterCoreContent(label: String)
```
{% endtab %}
{% tab title="Flutter" %}
```cplusplus
// Use version that takes List (see below)
```
{% endtab %}
{% tab title="React Native" %}
```javascript
NativeModules.NamiMLManagerBridge.enterCoreContentWithLabel(label: String);
```
{% endtab %}
{% endtabs %}
**Arguments**
* (required) `label`: String that describes the content being consumed. The same string must be used in both [enterCoreContent](/sdk-reference/namimlmanager/entercorecontent) and [exitCoreContent](/sdk-reference/namimlmanager/exitcorecontent) calls.
### Content with Hierarchies
If your content has a nested relationship between the tags, we provide a call that will allow you to inform Nami about that structure.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiMLManager.enterCoreContent(labels: [String])
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiMLManager.enterCoreContent(labels: List)
```
{% endtab %}
{% tab title="Flutter" %}
```dart
NamiMLManager.enterCoreContent(List labels);
```
{% endtab %}
{% tab title="React Native" %}
```javascript
NativeModules.NamiMLManagerBridge.enterCoreContent(labels: [String])
```
{% endtab %}
{% endtabs %}
**Arguments**
* `labels` a list of strings where the list is ordered by the relationship of the content, such as \["video", "basketball", "michael jordan"].
# exitCoreContent
Inform the SDK when a user has finished consuming content that is core to your app experience.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiMLManager.exitCoreContent(label: String)
```
{% endtab %}
{% tab title="Kotlin" %}
```kotlin
NamiMLManager.exitCoreContent(label: String)
```
{% endtab %}
{% tab title="Flutter" %}
```cplusplus
// Use version that takes List (see below)
```
{% endtab %}
{% tab title="React Native" %}
```javascript
NativeModules.NamiMLManagerBridge.exitCoreContentWithLabel(String);
```
{% endtab %}
{% endtabs %}
**Arguments**
* (required) `label`: String that describes the nature of the content being consumed. The same string string must be used in both [enterCoreContent](/sdk-reference/namimlmanager/entercorecontent) and [exitCoreContent](/sdk-reference/namimlmanager/exitcorecontent) calls.
{% tabs %}
{% tab title="Swift" %}
```swift
NamiMLManager.exitCoreContent(labels: [String])
```
{% endtab %}
{% tab title="Java" %}
```java
NamiMLManager.exitCoreContent(List labels);
```
{% endtab %}
{% tab title="Flutter" %}
```java
NamiMLManager.exitCoreContent(List labels);
```
{% endtab %}
{% endtabs %}
**Arguments**
* (required) `labels`: A list of strings of different labels that describe the content that was consumed. Note the exact same list must be used in both the `enterCoreContent` and `exitCoreContent` calls to work correctly.