@attentive-mobile/attentive-react-native-sdk 1.0.5 → 2.0.0-beta.1

package/README.md

@@ -3,6 +3,12 @@
 # Attentive React Native SDK
 The Attentive React Native SDK provides the functionality to render Attentive creative units and collect Attentive events in React Native mobile applications.
 
+## Package Manager
+
+This project uses **npm** as the preferred package manager for consistency and alignment with modern React Native best practices. While this library will work with any package manager (npm, yarn, or pnpm), the development scripts are configured to use npm.
+
+**Note on package managers:** Modern npm (v7+) has significantly improved performance and features, making it the recommended choice for React Native projects. Both npm and yarn work well with React Native, but this project standardizes on npm for development workflows.
+
 ## Installation
 
 Run `npm install @attentive-mobile/attentive-react-native-sdk` from your app's root directory.
@@ -162,3 +168,123 @@ Attentive.identify({phone: '+15556667777'};)
 //   email: 'theusersemail@gmail.com'
 //   phone: '+15556667777'
 ```
+
+### Push Notifications (iOS Only)
+
+The SDK supports push notification integration for iOS. Android support is planned for a future release.
+
+#### Request Push Permission
+
+```typescript
+import { registerForPushNotifications } from 'attentive-react-native-sdk';
+
+// Request permission to send push notifications
+// This will show the iOS system permission dialog
+registerForPushNotifications();
+```
+
+#### Register Device Token
+
+When your app receives a device token from APNs, register it with the Attentive backend:
+
+```typescript
+import { registerDeviceToken } from 'attentive-react-native-sdk';
+
+// In your AppDelegate or push notification handler:
+// Convert the device token Data to a hex string and pass the authorization status
+registerDeviceToken(hexEncodedToken, 'authorized');
+```
+
+The `authorizationStatus` parameter should be one of:
+- `'authorized'` - User has granted permission
+- `'denied'` - User has denied permission
+- `'notDetermined'` - User hasn't been asked yet
+- `'provisional'` - Provisional authorization (quiet notifications)
+- `'ephemeral'` - App Clip notifications
+
+#### Handle Push Notification Opens
+
+When a user taps on a push notification, track the event:
+
+```typescript
+import { handlePushOpened } from 'attentive-react-native-sdk';
+import type { ApplicationState, PushAuthorizationStatus } from 'attentive-react-native-sdk';
+
+// In your notification handler:
+handlePushOpened(
+  notificationPayload,    // The notification's userInfo/data
+  'background',           // App state: 'active', 'inactive', or 'background'
+  'authorized'            // Current authorization status
+);
+```
+
+#### Handle Foreground Notifications
+
+When a notification arrives while the app is in the foreground:
+
+```typescript
+import { handleForegroundNotification } from 'attentive-react-native-sdk';
+
+// In your foreground notification handler:
+handleForegroundNotification(notificationPayload);
+```
+
+#### iOS AppDelegate Integration
+
+For proper push notification integration, your iOS AppDelegate needs to:
+
+1. Request notification permissions via the SDK
+2. Implement `application:didRegisterForRemoteNotificationsWithDeviceToken:` to register the token
+3. Implement `UNUserNotificationCenterDelegate` methods to handle notification events
+
+##### Callback-Based Registration (Recommended)
+
+For more control over the registration flow, you can use the callback-based registration directly in your AppDelegate:
+
+```swift
+// In AppDelegate.swift
+import UserNotifications
+import attentive_react_native_sdk
+
+func application(
+    _ application: UIApplication,
+    didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
+) {
+    UNUserNotificationCenter.current().getNotificationSettings { settings in
+        let authStatus = settings.authorizationStatus
+        
+        // Get SDK instance with proper type
+        guard let attentiveSdk = AttentiveSDKManager.shared.sdk as? ATTNNativeSDK else {
+            print("[Attentive] SDK not initialized")
+            return
+        }
+        
+        // Register device token with callback
+        attentiveSdk.registerDeviceToken(
+            deviceToken,
+            authorizationStatus: authStatus,
+            callback: { data, url, response, error in
+                DispatchQueue.main.async {
+                    // Handle registration result
+                    if let error = error {
+                        print("[Attentive] Registration failed: \(error.localizedDescription)")
+                    }
+                    
+                    // Trigger regular open event after registration
+                    attentiveSdk.handleRegularOpen(authorizationStatus: authStatus)
+                }
+            }
+        )
+    }
+}
+```
+
+**Documentation:**
+- [Push Token Registration Guide](./PUSH_TOKEN_REGISTRATION_GUIDE.md) - Detailed guide for callback-based registration
+- [AppDelegate Callback Example](./APPDELEGATE_CALLBACK_EXAMPLE.md) - Complete AppDelegate implementation
+- [Push Notifications Setup](./PUSH_NOTIFICATIONS_SETUP.md) - General push notification setup
+- [iOS Native SDK documentation](https://github.com/attentive-mobile/attentive-ios-sdk) - Native SDK reference
+
+#### Android Support
+
+Android push notification support is not yet implemented. The push notification methods will be no-ops on Android. FCM (Firebase Cloud Messaging) integration is planned for a future release.

package/android/build.gradle

@@ -84,6 +84,7 @@ dependencies {
   implementation "com.facebook.react:react-native:+"
   implementation 'com.attentive:attentive-android-sdk:1.0.1'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.10"
+  implementation(platform("org.jetbrains.kotlin:kotlin-bom:1.9.10"))
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/kotlin/com/attentivereactnativesdk/AttentiveReactNativeSdkModule.kt

@@ -0,0 +1,384 @@
+package com.attentivereactnativesdk
+
+import android.app.Activity
+import android.util.Log
+import android.view.ViewGroup
+import androidx.annotation.NonNull
+import androidx.annotation.Nullable
+import com.attentive.androidsdk.AttentiveConfig
+import com.attentive.androidsdk.AttentiveEventTracker
+import com.attentive.androidsdk.UserIdentifiers
+import com.attentive.androidsdk.creatives.Creative
+import com.attentive.androidsdk.events.AddToCartEvent
+import com.attentive.androidsdk.events.CustomEvent
+import com.attentive.androidsdk.events.Item
+import com.attentive.androidsdk.events.Order
+import com.attentive.androidsdk.events.Price
+import com.attentive.androidsdk.events.ProductViewEvent
+import com.attentive.androidsdk.events.PurchaseEvent
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.bridge.Promise
+import com.attentivereactnativesdk.debug.AttentiveDebugHelper
+import java.math.BigDecimal
+import java.security.InvalidParameterException
+import java.util.Currency
+import java.util.Locale
+
+class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
+    NativeAttentiveReactNativeSdkSpec(reactContext) {
+
+    companion object {
+        const val NAME = "AttentiveReactNativeSdk"
+        private const val TAG = NAME
+    }
+
+    private var attentiveConfig: AttentiveConfig? = null
+    private var creative: Creative? = null
+    private val debugHelper: AttentiveDebugHelper
+
+    init {
+        debugHelper = AttentiveDebugHelper(reactContext)
+    }
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    override fun initialize(
+        attentiveDomain: String,
+        mode: String,
+        skipFatigueOnCreatives: Boolean,
+        enableDebugger: Boolean
+    ) {
+        // Initialize debug helper
+        debugHelper.initialize(enableDebugger)
+
+        attentiveConfig = AttentiveConfig.Builder()
+            .context(reactApplicationContext)
+            .domain(attentiveDomain)
+            .mode(AttentiveConfig.Mode.valueOf(mode.uppercase(Locale.ROOT)))
+            .skipFatigueOnCreatives(skipFatigueOnCreatives)
+            .build()
+        AttentiveEventTracker.getInstance().initialize(attentiveConfig)
+    }
+
+    override fun triggerCreative(creativeId: String?) {
+        Log.i(TAG, "Native Attentive module was called to trigger the creative.")
+        try {
+            val currentActivity: Activity? = reactApplicationContext.currentActivity
+            if (currentActivity != null) {
+                val rootView =
+                    currentActivity.window.decorView.rootView as ViewGroup
+                // The following calls edit the view hierarchy so they must run on the UI thread
+                UiThreadUtil.runOnUiThread {
+                    creative = Creative(attentiveConfig, rootView)
+                    creative?.trigger(null, creativeId)
+                    if (debugHelper.isDebuggingEnabled()) {
+                        val debugData = mutableMapOf<String, Any>()
+                        debugData["type"] = "trigger"
+                        debugData["creativeId"] = creativeId ?: "default"
+                        debugHelper.showDebugInfo("Creative Triggered", debugData)
+                    }
+                }
+            } else {
+                Log.w(TAG, "Could not trigger the Attentive Creative because the current Activity was null")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception when triggering the creative: $e")
+        }
+    }
+
+    override fun destroyCreative() {
+        val creativeToDestroy = creative
+        if (creativeToDestroy != null) {
+            UiThreadUtil.runOnUiThread {
+                creativeToDestroy.destroy()
+                creative = null
+            }
+        }
+    }
+
+    override fun updateDomain(domain: String) {
+        attentiveConfig?.changeDomain(domain)
+    }
+
+    override fun clearUser() {
+        attentiveConfig?.clearUser()
+    }
+
+    override fun identify(
+        phone: String?,
+        email: String?,
+        klaviyoId: String?,
+        shopifyId: String?,
+        clientUserId: String?,
+        customIdentifiers: ReadableMap?
+    ) {
+        val idsBuilder = UserIdentifiers.Builder()
+        if (!phone.isNullOrEmpty()) {
+            idsBuilder.withPhone(phone)
+        }
+        if (!email.isNullOrEmpty()) {
+            idsBuilder.withEmail(email)
+        }
+        if (!klaviyoId.isNullOrEmpty()) {
+            idsBuilder.withKlaviyoId(klaviyoId)
+        }
+        if (!shopifyId.isNullOrEmpty()) {
+            idsBuilder.withShopifyId(shopifyId)
+        }
+        if (!clientUserId.isNullOrEmpty()) {
+            idsBuilder.withClientUserId(clientUserId)
+        }
+        if (customIdentifiers != null) {
+            val customIds = mutableMapOf<String, String>()
+            val rawCustomIds = customIdentifiers.toHashMap()
+            for ((key, value) in rawCustomIds) {
+                if (value is String) {
+                    customIds[key] = value
+                }
+            }
+            idsBuilder.withCustomIdentifiers(customIds)
+        }
+
+        attentiveConfig?.identify(idsBuilder.build())
+    }
+
+    override fun recordProductViewEvent(items: ReadableArray, deeplink: String?) {
+        Log.i(TAG, "Sending product viewed event")
+
+        val itemsList = buildItems(items)
+        val productViewEvent = ProductViewEvent.Builder(itemsList).deeplink(deeplink).build()
+
+        AttentiveEventTracker.getInstance().recordEvent(productViewEvent)
+
+        if (debugHelper.isDebuggingEnabled()) {
+            val debugData = mutableMapOf<String, Any>()
+            debugData["items_count"] = itemsList.size.toString()
+            debugData["deeplink"] = deeplink ?: ""
+            debugHelper.showDebugInfo("Product View Event", debugData)
+        }
+    }
+
+    override fun recordPurchaseEvent(
+        items: ReadableArray,
+        orderId: String,
+        cartId: String?,
+        cartCoupon: String?
+    ) {
+        Log.i(TAG, "Sending purchase event")
+        val order = Order.Builder(orderId).build()
+
+        val itemsList = buildItems(items)
+        val purchaseEvent = PurchaseEvent.Builder(itemsList, order).build()
+
+        AttentiveEventTracker.getInstance().recordEvent(purchaseEvent)
+
+        if (debugHelper.isDebuggingEnabled()) {
+            val debugData = mutableMapOf<String, Any>()
+            debugData["items_count"] = itemsList.size.toString()
+            debugData["order_id"] = orderId
+            if (cartId != null) debugData["cart_id"] = cartId
+            if (cartCoupon != null) debugData["cart_coupon"] = cartCoupon
+            debugHelper.showDebugInfo("Purchase Event", debugData)
+        }
+    }
+
+    override fun recordAddToCartEvent(items: ReadableArray, deeplink: String?) {
+        Log.i(TAG, "Sending add to cart event")
+
+        val itemsList = buildItems(items)
+        val addToCartEvent = AddToCartEvent.Builder(itemsList).deeplink(deeplink).build()
+
+        AttentiveEventTracker.getInstance().recordEvent(addToCartEvent)
+
+        if (debugHelper.isDebuggingEnabled()) {
+            val debugData = mutableMapOf<String, Any>()
+            debugData["items_count"] = itemsList.size.toString()
+            debugData["deeplink"] = deeplink ?: ""
+            debugHelper.showDebugInfo("Add To Cart Event", debugData)
+        }
+    }
+
+    override fun recordCustomEvent(type: String, properties: ReadableMap?) {
+        Log.i(TAG, "Sending custom event")
+        if (properties == null) {
+            throw IllegalArgumentException("The CustomEvent 'properties' field cannot be null.")
+        }
+        val propertiesMap = convertToStringMap(properties.toHashMap())
+        val customEvent = CustomEvent.Builder(type, propertiesMap).build()
+
+        AttentiveEventTracker.getInstance().recordEvent(customEvent)
+
+        if (debugHelper.isDebuggingEnabled()) {
+            val debugData = mutableMapOf<String, Any>()
+            debugData["event_type"] = type
+            debugData["properties_count"] = propertiesMap.size.toString()
+            debugHelper.showDebugInfo("Custom Event", debugData)
+        }
+    }
+
+    override fun invokeAttentiveDebugHelper() {
+        debugHelper.invokeDebugHelper()
+    }
+
+    override fun exportDebugLogs(promise: Promise) {
+        try {
+            val exportContent = debugHelper.exportDebugLogs()
+            promise.resolve(exportContent)
+        } catch (e: Exception) {
+            promise.reject("EXPORT_ERROR", "Failed to export debug logs: " + e.message, e)
+        }
+    }
+
+    // ==========================================================================
+    // MARK: - Push Notification Methods (Android Implementation - TODO)
+    // ==========================================================================
+    //
+    // These methods are stubs for Android push notification support.
+    // Android push notifications typically use Firebase Cloud Messaging (FCM)
+    // and require different handling than iOS APNs.
+    //
+    // TODO: Implement Android push notification support
+    // - Integrate with Firebase Cloud Messaging (FCM)
+    // - Register FCM token with Attentive backend
+    // - Handle push notification opens and foreground notifications
+    // - Consider using the attentive-android-sdk's push notification features if available
+    //
+    // Reference: The iOS implementation uses:
+    // - registerForPushNotifications() - Request permission
+    // - registerDeviceToken() - Send token to backend
+    // - handlePushOpened() - Track push open events
+    // - handleForegroundNotification() - Handle foreground push display
+    // ==========================================================================
+
+    /**
+     * Request push notification permission from the user.
+     *
+     * TODO: Implement for Android
+     * - For Android 13+ (API 33+), request POST_NOTIFICATIONS permission
+     * - For older versions, permissions are granted at install time
+     * - Initialize FCM and get the registration token
+     */
+    override fun registerForPushNotifications() {
+        Log.i(TAG, "[TODO] registerForPushNotifications called - Android implementation pending")
+        // TODO: Implement Android push notification registration
+        // 1. Check/request POST_NOTIFICATIONS permission (Android 13+)
+        // 2. Initialize Firebase Cloud Messaging
+        // 3. Get FCM registration token
+        // 4. Register token with Attentive backend
+    }
+
+    /**
+     * Register the device token with the Attentive backend.
+     *
+     * TODO: Implement for Android
+     * - Android uses FCM tokens instead of APNs tokens
+     * - Token format and registration endpoint may differ
+     *
+     * @param token The FCM registration token
+     * @param authorizationStatus Push authorization status (may not apply to Android)
+     */
+    override fun registerDeviceToken(token: String, authorizationStatus: String) {
+        Log.i(TAG, "[TODO] registerDeviceToken called - Android implementation pending")
+        Log.d(TAG, "Token: ${token.take(16)}..., Status: $authorizationStatus")
+        // TODO: Implement Android device token registration
+        // 1. Send FCM token to Attentive backend
+        // 2. Handle token refresh via FirebaseMessagingService.onNewToken()
+    }
+
+    /**
+     * Handle when a push notification is opened by the user.
+     *
+     * TODO: Implement for Android
+     * - Track push open events with Attentive
+     * - Handle deep linking if present in payload
+     *
+     * @param userInfo The notification payload (from FCM RemoteMessage data)
+     * @param applicationState App state when notification was opened
+     * @param authorizationStatus Push authorization status
+     */
+    override fun handlePushOpened(
+        userInfo: ReadableMap,
+        applicationState: String,
+        authorizationStatus: String
+    ) {
+        Log.i(TAG, "[TODO] handlePushOpened called - Android implementation pending")
+        Log.d(TAG, "App state: $applicationState, Auth status: $authorizationStatus")
+        // TODO: Implement Android push open tracking
+        // 1. Parse notification payload
+        // 2. Send push open event to Attentive backend
+        // 3. Handle any deep links in the payload
+    }
+
+    /**
+     * Handle when a push notification arrives while the app is in foreground.
+     *
+     * TODO: Implement for Android
+     * - Android handles foreground notifications differently than iOS
+     * - By default, FCM data messages don't show UI in foreground
+     * - Need to create NotificationCompat.Builder to show notification
+     *
+     * @param userInfo The notification payload
+     */
+    override fun handleForegroundNotification(userInfo: ReadableMap) {
+        Log.i(TAG, "[TODO] handleForegroundNotification called - Android implementation pending")
+        // TODO: Implement Android foreground notification handling
+        // 1. Create notification channel (required for Android 8+)
+        // 2. Build and display notification using NotificationCompat
+        // 3. Track foreground notification event with Attentive
+    }
+
+    private fun convertToStringMap(inputMap: Map<String, Any?>): Map<String, String> {
+        val outputMap = mutableMapOf<String, String>()
+        for ((key, value) in inputMap) {
+            if (value == null) {
+                throw InvalidParameterException("The key '$key' has a null value.")
+            }
+            if (value is String) {
+                outputMap[key] = value
+            }
+        }
+        return outputMap
+    }
+
+    private fun buildItems(rawItems: ReadableArray): List<Item> {
+        Log.i(TAG, "buildItems method called with rawItems: $rawItems")
+        val items = mutableListOf<Item>()
+        for (i in 0 until rawItems.size()) {
+            val rawItem = rawItems.getMap(i) ?: continue
+
+            // Price and currency are now flattened, not nested
+            val priceValue = rawItem.getString("price")
+            val currencyCode = rawItem.getString("currency")
+            val price = Price.Builder(BigDecimal(priceValue), Currency.getInstance(currencyCode)).build()
+
+            val builder = Item.Builder(rawItem.getString("productId"), rawItem.getString("productVariantId"), price)
+
+            if (rawItem.hasKey("productImage")) {
+                builder.productImage(rawItem.getString("productImage"))
+            }
+
+            if (rawItem.hasKey("name")) {
+                builder.name(rawItem.getString("name"))
+            }
+
+            if (rawItem.hasKey("quantity")) {
+                builder.quantity(rawItem.getInt("quantity"))
+            }
+
+            if (rawItem.hasKey("category")) {
+                builder.category(rawItem.getString("category"))
+            }
+
+            val item = builder.build()
+            items.add(item)
+        }
+
+        return items
+    }
+}

package/android/src/main/kotlin/com/attentivereactnativesdk/AttentiveReactNativeSdkPackage.kt

@@ -0,0 +1,36 @@
+package com.attentivereactnativesdk
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class AttentiveReactNativeSdkPackage : TurboReactPackage() {
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == AttentiveReactNativeSdkModule.NAME) {
+            AttentiveReactNativeSdkModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            val moduleInfos = mutableMapOf<String, ReactModuleInfo>()
+            val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+            moduleInfos[AttentiveReactNativeSdkModule.NAME] = ReactModuleInfo(
+                AttentiveReactNativeSdkModule.NAME,
+                AttentiveReactNativeSdkModule.NAME,
+                false, // canOverrideExistingModule
+                false, // needsEagerInit
+                true, // hasConstants
+                false, // isCxxModule
+                isTurboModule // isTurboModule
+            )
+            moduleInfos
+        }
+    }
+}
+

package/android/src/main/kotlin/com/attentivereactnativesdk/debug/AttentiveDebugHelper.kt

@@ -38,8 +38,13 @@ class AttentiveDebugHelper(private val reactContext: ReactApplicationContext) {
     }
 
     private val debugHistory = mutableListOf<DebugEvent>()
-    var isDebuggingEnabled = false
-        private set
+    private var isDebuggingEnabled = false
+    
+    /**
+     * Returns whether debugging is currently enabled.
+     * Provides explicit getter method for Java interop.
+     */
+    fun isDebuggingEnabled(): Boolean = isDebuggingEnabled
 
     /**
      * Initializes debugging based on configuration and build type.
@@ -52,7 +57,7 @@ class AttentiveDebugHelper(private val reactContext: ReactApplicationContext) {
         isDebuggingEnabled = enableDebuggerFromConfig && isDebugBuild
         
         Log.i(TAG, "Debug initialization - enableDebuggerFromConfig: $enableDebuggerFromConfig, " +
-                "isDebugBuild: $isDebugBuild, debuggingEnabled: $isDebuggingEnabled")
+                "isDebugBuild: $isDebugBuild, debuggingEnabled: ${isDebuggingEnabled()}")
     }
 
     /**
@@ -62,7 +67,7 @@ class AttentiveDebugHelper(private val reactContext: ReactApplicationContext) {
      * @param data The event data
      */
     fun showDebugInfo(event: String, data: Map<String, Any?>) {
-        if (!isDebuggingEnabled) return
+        if (!isDebuggingEnabled()) return
         
         Log.i(TAG, "showDebugInfo called for event: $event, data: $data")
 
@@ -86,17 +91,28 @@ class AttentiveDebugHelper(private val reactContext: ReactApplicationContext) {
      * Shows existing debug session data without adding to history.
      */
     fun invokeDebugHelper() {
-        if (!isDebuggingEnabled) return
+        Log.i(TAG, "invokeDebugHelper called - isDebuggingEnabled: ${isDebuggingEnabled()}")
+        
+        if (!isDebuggingEnabled()) {
+            Log.w(TAG, "Debug helper not invoked because debugging is not enabled")
+            return
+        }
         
         val currentActivity = reactContext.currentActivity
+        Log.i(TAG, "Current activity: $currentActivity")
+        
         if (currentActivity != null) {
+            Log.i(TAG, "Activity is available, running on UI thread")
             UiThreadUtil.runOnUiThread {
                 val debugData = mapOf(
                     "action" to "manual_debug_call",
                     "session_events" to debugHistory.size.toString()
                 )
+                Log.i(TAG, "About to show debug dialog")
                 showDebugDialog(currentActivity, "Manual Debug View", debugData)
             }
+        } else {
+            Log.w(TAG, "Current activity is null, cannot show debug dialog")
         }
     }
 
@@ -105,7 +121,7 @@ class AttentiveDebugHelper(private val reactContext: ReactApplicationContext) {
      * @return A comprehensive formatted string containing all debug events in the current session
      */
     fun exportDebugLogs(): String {
-        if (!isDebuggingEnabled) {
+        if (!isDebuggingEnabled()) {
             return "Debug logging is not enabled. Please enable debugging to export logs."
         }
 

package/attentive-react-native-sdk.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
-  s.dependency 'attentive-ios-sdk', '1.0.0'
+  s.dependency 'attentive-ios-sdk', '2.0.8'
   s.swift_versions = ['5']
   s.dependency "React-Core"
 
@@ -24,9 +24,9 @@ Pod::Spec.new do |s|
   if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
     s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
     s.pod_target_xcconfig    = {
-        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/Headers/Public/React-NativeModulesApple\" \"$(PODS_ROOT)/Headers/Private/React-NativeModulesApple\" \"$(PODS_ROOT)/Headers/Private/React-Codegen/react/renderer/components\" \"${PODS_CONFIGURATION_BUILD_DIR}/React-Codegen/React_Codegen.framework/Headers\"",
         "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
-        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++20"
     }
     s.dependency "React-Codegen"
     s.dependency "RCT-Folly"

package/ios/AttentiveReactNativeSdk.h

@@ -6,7 +6,7 @@
 //
 
 #ifdef RCT_NEW_ARCH_ENABLED
-#import "RNAttentiveReactNativeSdkSpec.h"
+#import "AttentiveReactNativeSdkSpec.h"
 
 @interface AttentiveReactNativeSdk : NSObject <NativeAttentiveReactNativeSdkSpec>
 #else