react-native-iap 13.0.4 → 14.0.0-rc.2

package/android/src/main/java/com/margelo/nitro/iap/NitroIapPackage.java

@@ -0,0 +1,33 @@
+package com.margelo.nitro.iap;
+
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
+import com.margelo.nitro.core.HybridObject;
+
+import java.util.HashMap;
+import java.util.function.Supplier;
+
+public class NitroIapPackage extends TurboReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+        return new HashMap<>();
+    };
+  }
+
+  static {
+    NitroIapOnLoad.initializeNative();
+  }
+}

package/android/src/main/java/com/margelo/nitro/iap/Types.kt

@@ -0,0 +1,173 @@
+package com.margelo.nitro.iap
+
+import com.android.billingclient.api.BillingClient
+
+/**
+ * Error codes for IAP operations - centralized error code management
+ * Single source of truth for all error codes used across the module
+ */
+object IapErrorCode {
+    // Connection and initialization errors
+    const val E_NOT_PREPARED = "E_NOT_PREPARED"
+    const val E_INIT_CONNECTION = "E_INIT_CONNECTION"
+    const val E_SERVICE_DISCONNECTED = "E_SERVICE_DISCONNECTED"
+    const val E_ALREADY_PREPARED = "E_ALREADY_PREPARED"
+    const val E_CONNECTION_CLOSED = "E_CONNECTION_CLOSED"
+    
+    // Product and purchase errors
+    const val E_QUERY_PRODUCT = "E_QUERY_PRODUCT"
+    const val E_SKU_NOT_FOUND = "E_SKU_NOT_FOUND"
+    const val E_SKU_OFFER_MISMATCH = "E_SKU_OFFER_MISMATCH"
+    const val E_PURCHASE_ERROR = "E_PURCHASE_ERROR"
+    const val E_USER_CANCELLED = "E_USER_CANCELLED"
+    const val E_PENDING = "E_PENDING"
+    
+    // Service and developer errors
+    const val E_SERVICE_ERROR = "E_SERVICE_ERROR"
+    const val E_DEVELOPER_ERROR = "E_DEVELOPER_ERROR"
+    const val E_ITEM_UNAVAILABLE = "E_ITEM_UNAVAILABLE"
+    const val E_ALREADY_OWNED = "E_ALREADY_OWNED"
+    const val E_ITEM_NOT_OWNED = "E_ITEM_NOT_OWNED"
+    
+    // Network and billing errors
+    const val E_NETWORK_ERROR = "E_NETWORK_ERROR"
+    const val E_BILLING_UNAVAILABLE = "E_BILLING_UNAVAILABLE"
+    const val E_FEATURE_NOT_SUPPORTED = "E_FEATURE_NOT_SUPPORTED"
+    const val E_BILLING_RESPONSE_JSON_PARSE_ERROR = "E_BILLING_RESPONSE_JSON_PARSE_ERROR"
+    
+    // Activity and UI errors
+    const val E_ACTIVITY_UNAVAILABLE = "E_ACTIVITY_UNAVAILABLE"
+    
+    // User and remote errors
+    const val E_USER_ERROR = "E_USER_ERROR"
+    const val E_REMOTE_ERROR = "E_REMOTE_ERROR"
+    const val E_NOT_ENDED = "E_NOT_ENDED"
+    
+    // Validation errors
+    const val E_EMPTY_SKU_LIST = "E_EMPTY_SKU_LIST"
+    const val E_RECEIPT_FAILED = "E_RECEIPT_FAILED"
+    
+    // Unknown error
+    const val E_UNKNOWN = "E_UNKNOWN"
+}
+
+/**
+ * Data class for billing error information
+ */
+data class BillingErrorData(
+    val code: String,
+    val message: String
+)
+
+/**
+ * Helper object for billing response handling
+ */
+object BillingUtils {
+    
+    /**
+     * Get error data from billing response code
+     */
+    fun getBillingErrorData(responseCode: Int): BillingErrorData {
+        return when (responseCode) {
+            BillingClient.BillingResponseCode.OK -> 
+                BillingErrorData("OK", "Success")
+            
+            BillingClient.BillingResponseCode.USER_CANCELED -> 
+                BillingErrorData(IapErrorCode.E_USER_CANCELLED, "User cancelled the purchase")
+            
+            BillingClient.BillingResponseCode.SERVICE_UNAVAILABLE -> 
+                BillingErrorData(IapErrorCode.E_SERVICE_ERROR, "Network connection is down")
+            
+            BillingClient.BillingResponseCode.BILLING_UNAVAILABLE -> 
+                BillingErrorData(IapErrorCode.E_BILLING_UNAVAILABLE, "Billing API version is not supported for the type requested")
+            
+            BillingClient.BillingResponseCode.ITEM_UNAVAILABLE -> 
+                BillingErrorData(IapErrorCode.E_ITEM_UNAVAILABLE, "Requested product is not available for purchase")
+            
+            BillingClient.BillingResponseCode.DEVELOPER_ERROR -> 
+                BillingErrorData(IapErrorCode.E_DEVELOPER_ERROR, "Invalid arguments provided to the API")
+            
+            BillingClient.BillingResponseCode.ERROR -> 
+                BillingErrorData(IapErrorCode.E_UNKNOWN, "Fatal error during the API action")
+            
+            BillingClient.BillingResponseCode.ITEM_ALREADY_OWNED -> 
+                BillingErrorData(IapErrorCode.E_ALREADY_OWNED, "Failure to purchase since item is already owned")
+            
+            BillingClient.BillingResponseCode.ITEM_NOT_OWNED -> 
+                BillingErrorData(IapErrorCode.E_ITEM_NOT_OWNED, "Failure to consume since item is not owned")
+            
+            BillingClient.BillingResponseCode.SERVICE_DISCONNECTED -> 
+                BillingErrorData(IapErrorCode.E_SERVICE_DISCONNECTED, "Play Store service is not connected now")
+            
+            BillingClient.BillingResponseCode.FEATURE_NOT_SUPPORTED -> 
+                BillingErrorData(IapErrorCode.E_FEATURE_NOT_SUPPORTED, "The requested feature is not supported by Play Store on the current device")
+            
+            BillingClient.BillingResponseCode.NETWORK_ERROR -> 
+                BillingErrorData(IapErrorCode.E_NETWORK_ERROR, "A network error occurred during the operation")
+            
+            else -> 
+                BillingErrorData(IapErrorCode.E_UNKNOWN, "Unknown billing error (code: $responseCode)")
+        }
+    }
+    
+    /**
+     * Get error message for Google Play Services availability
+     */
+    fun getPlayServicesErrorMessage(resultCode: Int): String {
+        return when (resultCode) {
+            com.google.android.gms.common.ConnectionResult.SERVICE_MISSING -> 
+                "Google Play Services is missing on this device"
+            
+            com.google.android.gms.common.ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED -> 
+                "Google Play Services needs to be updated"
+            
+            com.google.android.gms.common.ConnectionResult.SERVICE_DISABLED -> 
+                "Google Play Services is disabled"
+            
+            com.google.android.gms.common.ConnectionResult.SERVICE_INVALID -> 
+                "Google Play Services is invalid"
+            
+            else -> 
+                "Google Play Services is not available (error code: $resultCode)"
+        }
+    }
+    
+    /**
+     * Create JSON error string from error data and additional info
+     */
+    fun createErrorJson(
+        code: String, 
+        message: String, 
+        responseCode: Int? = null, 
+        debugMessage: String? = null,
+        productId: String? = null,
+        additionalData: Map<String, Any> = emptyMap()
+    ): String {
+        val errorMap = mutableMapOf<String, Any>(
+            "code" to code,
+            "message" to message
+        )
+        
+        responseCode?.let { errorMap["responseCode"] = it }
+        debugMessage?.let { errorMap["debugMessage"] = it }
+        productId?.let { errorMap["productId"] = it }
+        errorMap.putAll(additionalData)
+        
+        return try {
+            // Simple JSON serialization for basic types
+            val jsonPairs = errorMap.map { (key, value) ->
+                val valueStr = when (value) {
+                    is String -> "\"${value.replace("\"", "\\\"")}\""
+                    is Number -> value.toString()
+                    is Boolean -> value.toString()
+                    else -> "\"$value\""
+                }
+                "\"$key\":$valueStr"
+            }
+            "{${jsonPairs.joinToString(",")}}"
+        } catch (e: Exception) {
+            // Fallback to simple format
+            "$code: $message"
+        }
+    }
+}

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  NitroIap
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once

package/ios/ErrorUtils.swift

@@ -0,0 +1,153 @@
+import Foundation
+import StoreKit
+
+/**
+ * Error utilities for iOS IAP operations
+ * Provides centralized error handling and JSON error formatting
+ * Matches the error codes from existing react-native-iap implementations
+ */
+struct IapErrorCode {
+    // Constants for code usage - safe pattern without force unwrapping
+    static let unknown = "E_UNKNOWN"
+    static let serviceError = "E_SERVICE_ERROR"
+    static let userCancelled = "E_USER_CANCELLED"
+    static let userError = "E_USER_ERROR"
+    static let itemUnavailable = "E_ITEM_UNAVAILABLE"
+    static let remoteError = "E_REMOTE_ERROR"
+    static let networkError = "E_NETWORK_ERROR"
+    static let receiptFailed = "E_RECEIPT_FAILED"
+    static let receiptFinishedFailed = "E_RECEIPT_FINISHED_FAILED"
+    static let notPrepared = "E_NOT_PREPARED"
+    static let notEnded = "E_NOT_ENDED"
+    static let alreadyOwned = "E_ALREADY_OWNED"
+    static let developerError = "E_DEVELOPER_ERROR"
+    static let purchaseError = "E_PURCHASE_ERROR"
+    static let syncError = "E_SYNC_ERROR"
+    static let deferredPayment = "E_DEFERRED_PAYMENT"
+    static let transactionValidationFailed = "E_TRANSACTION_VALIDATION_FAILED"
+    static let billingResponseJsonParseError = "E_BILLING_RESPONSE_JSON_PARSE_ERROR"
+    static let interrupted = "E_INTERRUPTED"
+    static let iapNotAvailable = "E_IAP_NOT_AVAILABLE"
+    static let activityUnavailable = "E_ACTIVITY_UNAVAILABLE"
+    static let alreadyPrepared = "E_ALREADY_PREPARED"
+    static let pending = "E_PENDING"
+    static let connectionClosed = "E_CONNECTION_CLOSED"
+}
+
+/**
+ * Error data structure for iOS IAP errors
+ */
+struct IapErrorData {
+    let code: String
+    let message: String
+    
+    init(code: String, message: String) {
+        self.code = code
+        self.message = message
+    }
+}
+
+/**
+ * Helper class for iOS error handling
+ */
+@available(iOS 15.0, *)
+class ErrorUtils {
+    
+    /**
+     * Get error data from StoreKit error
+     */
+    static func getStoreKitErrorData(_ error: Error) -> IapErrorData {
+        if let storeKitError = error as? StoreKitError {
+            return getStoreKitErrorData(storeKitError)
+        }
+        
+        // Handle other error types
+        if error is CancellationError {
+            return IapErrorData(code: IapErrorCode.userCancelled, message: "Purchase was cancelled")
+        }
+        
+        // Fallback for unknown errors
+        return IapErrorData(code: IapErrorCode.unknown, message: error.localizedDescription)
+    }
+    
+    /**
+     * Get error data from specific StoreKitError
+     */
+    static func getStoreKitErrorData(_ error: StoreKitError) -> IapErrorData {
+        switch error {
+        case .userCancelled:
+            return IapErrorData(code: IapErrorCode.userCancelled, message: "User cancelled the purchase")
+        case .networkError:
+            return IapErrorData(code: IapErrorCode.networkError, message: "Network error occurred during purchase")
+        case .systemError:
+            return IapErrorData(code: IapErrorCode.serviceError, message: "System error occurred")
+        case .notAvailableInStorefront:
+            return IapErrorData(code: IapErrorCode.itemUnavailable, message: "Product not available in current storefront")
+        case .notEntitled:
+            return IapErrorData(code: IapErrorCode.alreadyOwned, message: "User not entitled to this product")
+        default:
+            return IapErrorData(code: IapErrorCode.unknown, message: "Unknown StoreKit error: \\(error.localizedDescription)")
+        }
+    }
+    
+    /**
+     * Create JSON error string from error data
+     */
+    static func createErrorJson(
+        code: String,
+        message: String,
+        underlyingError: Error? = nil,
+        productId: String? = nil,
+        additionalData: [String: Any] = [:]
+    ) -> String {
+        var errorMap: [String: Any] = [
+            "code": code,
+            "message": message
+        ]
+        
+        if let error = underlyingError {
+            errorMap["underlyingError"] = error.localizedDescription
+            
+            // Add NSError specific information if available
+            if let nsError = error as NSError? {
+                errorMap["domain"] = nsError.domain
+                errorMap["errorCode"] = nsError.code
+            }
+        }
+        
+        if let productId = productId {
+            errorMap["productId"] = productId
+        }
+        
+        // Add any additional data
+        for (key, value) in additionalData {
+            errorMap[key] = value
+        }
+        
+        // Convert to JSON
+        do {
+            let jsonData = try JSONSerialization.data(withJSONObject: errorMap, options: [])
+            if let jsonString = String(data: jsonData, encoding: .utf8) {
+                return jsonString
+            }
+        } catch {
+            print("[ErrorUtils] Failed to serialize error to JSON: \\(error)")
+        }
+        
+        // Fallback to simple format
+        return "\\(code): \\(message)"
+    }
+    
+    /**
+     * Create JSON error string from Swift Error
+     */
+    static func createErrorJson(from error: Error, productId: String? = nil) -> String {
+        let errorData = getStoreKitErrorData(error)
+        return createErrorJson(
+            code: errorData.code,
+            message: errorData.message,
+            underlyingError: error,
+            productId: productId
+        )
+    }
+}