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

package/README.md

@@ -36,6 +36,30 @@ const config : AttentiveConfiguration = {
 }
 ```
 
+### Debugging Features
+
+The SDK includes debugging helpers to show what data is being sent and received. Enable debugging by setting `enableDebugger: true`:
+
+```typescript
+const config : AttentiveConfiguration = {
+  attentiveDomain: 'YOUR_ATTENTIVE_DOMAIN',
+  mode: Mode.Debug,
+  enableDebugger: true, // Shows debug overlays for events and creatives
+}
+```
+
+When enabled, debug overlays will automatically appear when:
+- Creatives are triggered
+- Events are recorded (product views, purchases, etc.)
+
+You can also manually invoke the debug helper:
+
+```typescript
+Attentive.invokeAttentiveDebugHelper();
+```
+
+See [DEBUGGING.md](./DEBUGGING.md) for detailed information about debugging features.
+
 ### Initialize the SDK
 
 ```typescript

package/android/build.gradle

@@ -6,6 +6,7 @@ buildscript {
 
   dependencies {
     classpath "com.android.tools.build:gradle:7.3.1"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.10"
   }
 }
 
@@ -14,6 +15,7 @@ def isNewArchitectureEnabled() {
 }
 
 apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
 
 
 def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
@@ -81,6 +83,7 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation 'com.attentive:attentive-android-sdk:1.0.1'
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.10"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/java/com/attentivereactnativesdk/AttentiveReactNativeSdkModule.java

@@ -33,6 +33,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import com.attentivereactnativesdk.debug.AttentiveDebugHelper;
 
 @ReactModule(name = AttentiveReactNativeSdkModule.NAME)
 public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
@@ -41,9 +42,11 @@ public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
 
   private AttentiveConfig attentiveConfig;
   private Creative creative;
+  private AttentiveDebugHelper debugHelper;
 
   public AttentiveReactNativeSdkModule(ReactApplicationContext reactContext) {
     super(reactContext);
+    this.debugHelper = new AttentiveDebugHelper(reactContext);
   }
 
   @Override
@@ -62,6 +65,11 @@ public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
     final String domain = config.getString("attentiveDomain");
     final Boolean skipFatigue = config.hasKey("skipFatigueOnCreatives") ?
       config.getBoolean("skipFatigueOnCreatives") : false;
+    
+    // Initialize debug helper
+    final Boolean enableDebuggerFromConfig = config.hasKey("enableDebugger") ?
+      config.getBoolean("enableDebugger") : false;
+    debugHelper.initialize(enableDebuggerFromConfig);
 
     attentiveConfig = new AttentiveConfig.Builder()
         .context(this.getReactApplicationContext())
@@ -89,6 +97,12 @@ public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
         UiThreadUtil.runOnUiThread(() -> {
           creative = new Creative(attentiveConfig, rootView);
           creative.trigger(null, creativeId);
+          if (debugHelper.isDebuggingEnabled()) {
+            Map<String, Object> debugData = new HashMap<>();
+            debugData.put("type", "trigger");
+            debugData.put("creativeId", creativeId != null ? creativeId : "default");
+            debugHelper.showDebugInfo("Creative Triggered", debugData);
+          }
         });
       } else {
         Log.w(TAG, "Could not trigger the Attentive Creative because the current Activity was null");
@@ -159,6 +173,14 @@ public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
     ProductViewEvent productViewEvent = new ProductViewEvent.Builder(items).deeplink(deeplink).build();
 
     AttentiveEventTracker.getInstance().recordEvent(productViewEvent);
+
+    if (debugHelper.isDebuggingEnabled()) {
+      Map<String, Object> debugData = new HashMap<>();
+      debugData.put("items_count", String.valueOf(items.size()));
+      debugData.put("deeplink", deeplink);
+      debugData.put("payload", productViewAttrs.toHashMap());
+      debugHelper.showDebugInfo("Product View Event", debugData);
+    }
   }
 
   @ReactMethod
@@ -170,6 +192,14 @@ public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
     PurchaseEvent purchaseEvent = new PurchaseEvent.Builder(items, order).build();
 
     AttentiveEventTracker.getInstance().recordEvent(purchaseEvent);
+
+    if (debugHelper.isDebuggingEnabled()) {
+      Map<String, Object> debugData = new HashMap<>();
+      debugData.put("items_count", String.valueOf(items.size()));
+      debugData.put("order_id", order.getOrderId());
+      debugData.put("payload", purchaseAttrs.toHashMap());
+      debugHelper.showDebugInfo("Purchase Event", debugData);
+    }
   }
 
   @ReactMethod
@@ -181,6 +211,14 @@ public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
     AddToCartEvent addToCartEvent = new AddToCartEvent.Builder(items).deeplink(deeplink).build();
 
     AttentiveEventTracker.getInstance().recordEvent(addToCartEvent);
+
+    if (debugHelper.isDebuggingEnabled()) {
+      Map<String, Object> debugData = new HashMap<>();
+      debugData.put("items_count", String.valueOf(items.size()));
+      debugData.put("deeplink", deeplink);
+      debugData.put("payload", addToCartAttrs.toHashMap());
+      debugHelper.showDebugInfo("Add To Cart Event", debugData);
+    }
   }
 
   @ReactMethod
@@ -194,8 +232,32 @@ public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
     CustomEvent customEvent = new CustomEvent.Builder(customEventAttrs.getString("type"), properties).build();
 
     AttentiveEventTracker.getInstance().recordEvent(customEvent);
+
+    if (debugHelper.isDebuggingEnabled()) {
+      Map<String, Object> debugData = new HashMap<>();
+      debugData.put("event_type", customEventAttrs.getString("type"));
+      debugData.put("properties_count", String.valueOf(properties.size()));
+      debugData.put("payload", customEventAttrs.toHashMap());
+      debugHelper.showDebugInfo("Custom Event", debugData);
+    }
   }
 
+  @ReactMethod
+  public void invokeAttentiveDebugHelper() {
+    debugHelper.invokeDebugHelper();
+  }
+
+  @ReactMethod
+  public void exportDebugLogs(com.facebook.react.bridge.Promise promise) {
+    try {
+      String exportContent = debugHelper.exportDebugLogs();
+      promise.resolve(exportContent);
+    } catch (Exception e) {
+      promise.reject("EXPORT_ERROR", "Failed to export debug logs: " + e.getMessage(), e);
+    }
+  }
+
+
   private Map<String, String> convertToStringMap(Map<String, Object> inputMap) {
     Map<String, String> outputMap = new HashMap<>();
     for (Map.Entry<String, Object> entry : inputMap.entrySet()) {
@@ -244,4 +306,5 @@ public class AttentiveReactNativeSdkModule extends ReactContextBaseJavaModule {
 
     return items;
   }
+
 }

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

@@ -0,0 +1,422 @@
+package com.attentivereactnativesdk.debug
+
+import android.app.Activity
+import android.content.Intent
+import android.graphics.Color
+import android.graphics.Typeface
+import android.graphics.drawable.GradientDrawable
+import android.util.DisplayMetrics
+import android.util.Log
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.ScrollView
+import android.widget.TextView
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UiThreadUtil
+import org.json.JSONObject
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * Kotlin-based debug helper for the Attentive React Native SDK.
+ * 
+ * This class provides comprehensive debugging capabilities including:
+ * - Session history tracking
+ * - Debug overlay with tabbed interface
+ * - Export and share functionality
+ * - Real-time debug information display
+ */
+class AttentiveDebugHelper(private val reactContext: ReactApplicationContext) {
+    
+    companion object {
+        private const val TAG = "AttentiveDebugHelper"
+    }
+
+    private val debugHistory = mutableListOf<DebugEvent>()
+    var isDebuggingEnabled = false
+        private set
+
+    /**
+     * Initializes debugging based on configuration and build type.
+     * 
+     * @param enableDebuggerFromConfig Whether debugging is enabled in configuration
+     */
+    fun initialize(enableDebuggerFromConfig: Boolean) {
+        val isDebugBuild = (reactContext.applicationInfo.flags and 
+            android.content.pm.ApplicationInfo.FLAG_DEBUGGABLE) != 0
+        isDebuggingEnabled = enableDebuggerFromConfig && isDebugBuild
+        
+        Log.i(TAG, "Debug initialization - enableDebuggerFromConfig: $enableDebuggerFromConfig, " +
+                "isDebugBuild: $isDebugBuild, debuggingEnabled: $isDebuggingEnabled")
+    }
+
+    /**
+     * Shows debug information by adding to history and displaying the debug dialog.
+     * 
+     * @param event The event name/type
+     * @param data The event data
+     */
+    fun showDebugInfo(event: String, data: Map<String, Any?>) {
+        if (!isDebuggingEnabled) return
+        
+        Log.i(TAG, "showDebugInfo called for event: $event, data: $data")
+
+        // Add to debug history
+        val debugEvent = DebugEvent(event, data)
+        debugHistory.add(debugEvent)
+
+        val currentActivity = reactContext.currentActivity
+        if (currentActivity != null) {
+            Log.i(TAG, "Current activity found, showing debug dialog on UI thread")
+            UiThreadUtil.runOnUiThread {
+                showDebugDialog(currentActivity, event, data)
+            }
+        } else {
+            Log.w(TAG, "Current activity is null, cannot show debug dialog")
+        }
+    }
+
+    /**
+     * Manually invokes the debug helper overlay.
+     * Shows existing debug session data without adding to history.
+     */
+    fun invokeDebugHelper() {
+        if (!isDebuggingEnabled) return
+        
+        val currentActivity = reactContext.currentActivity
+        if (currentActivity != null) {
+            UiThreadUtil.runOnUiThread {
+                val debugData = mapOf(
+                    "action" to "manual_debug_call",
+                    "session_events" to debugHistory.size.toString()
+                )
+                showDebugDialog(currentActivity, "Manual Debug View", debugData)
+            }
+        }
+    }
+
+    /**
+     * Exports the current debug session logs as a formatted string.
+     * @return A comprehensive formatted string containing all debug events in the current session
+     */
+    fun exportDebugLogs(): String {
+        if (!isDebuggingEnabled) {
+            return "Debug logging is not enabled. Please enable debugging to export logs."
+        }
+
+        if (debugHistory.isEmpty()) {
+            return "No debug events recorded in this session."
+        }
+
+        val formatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
+        val exportDate = formatter.format(Date())
+
+        return buildString {
+            appendLine("Attentive React Native SDK - Debug Session Export")
+            appendLine("Generated: $exportDate")
+            appendLine("Total Events: ${debugHistory.size}")
+            appendLine()
+            appendLine("=".repeat(60))
+            appendLine()
+
+            // Add all events in chronological order (oldest first for better readability)
+            debugHistory.forEachIndexed { index, event ->
+                appendLine("Event #${index + 1}")
+                append(event.formatForExport())
+                appendLine()
+            }
+
+            appendLine("=".repeat(60))
+            append("End of Debug Session Export")
+        }
+    }
+
+    /**
+     * Shares debug logs using the Android share intent.
+     * @param context The current activity context
+     * @param content The content to share
+     */
+    private fun shareDebugLogs(context: Activity, content: String) {
+        val shareIntent = Intent().apply {
+            action = Intent.ACTION_SEND
+            type = "text/plain"
+            putExtra(Intent.EXTRA_TEXT, content)
+            putExtra(Intent.EXTRA_SUBJECT, "Attentive React Native SDK - Debug Session Export")
+        }
+
+        val chooser = Intent.createChooser(shareIntent, "Share Debug Logs")
+        if (shareIntent.resolveActivity(context.packageManager) != null) {
+            context.startActivity(chooser)
+        }
+    }
+
+    /**
+     * Creates and displays the comprehensive debug overlay with tabbed interface.
+     * Features:
+     * - Current event details
+     * - Session history with chronological listing
+     * - Export/share functionality
+     * - Material Design styling with rounded corners and proper spacing
+     */
+    private fun showDebugDialog(activity: Activity, currentEvent: String, currentData: Map<String, Any?>) {
+        Log.i(TAG, "showDebugDialog called for event: $currentEvent")
+
+        // Get the root view of the current activity to add our overlay directly
+        val rootView = activity.window.decorView.rootView as ViewGroup
+        Log.i(TAG, "Root view obtained: $rootView")
+
+        // Create custom view for tabbed interface - this will be added directly to the activity
+        val mainLayout = LinearLayout(activity).apply {
+            orientation = LinearLayout.VERTICAL
+            setPadding(32, 32, 32, 32)
+            setBackgroundColor(Color.TRANSPARENT) // Completely transparent background
+            layoutParams = FrameLayout.LayoutParams(
+                FrameLayout.LayoutParams.MATCH_PARENT,
+                FrameLayout.LayoutParams.MATCH_PARENT
+            )
+        }
+
+        // Create content container that will be positioned at bottom
+        val contentContainer = LinearLayout(activity).apply {
+            orientation = LinearLayout.VERTICAL
+            setBackgroundColor(0xFFFFFFFF.toInt())
+            setPadding(24, 24, 24, 24)
+
+            // Round corners with discrete outline border
+            val background = GradientDrawable().apply {
+                setColor(0xFFFFFFFF.toInt()) // White background
+                cornerRadius = 24f // Rounded corners
+                setStroke(2, 0xFFE0E0E0.toInt()) // Discrete light gray border (2dp width)
+            }
+            setBackground(background)
+        }
+
+        // Header with title, share button, and close button
+        val headerLayout = LinearLayout(activity).apply {
+            orientation = LinearLayout.HORIZONTAL
+            gravity = Gravity.CENTER_VERTICAL
+        }
+
+        val titleText = TextView(activity).apply {
+            text = "🐛 Attentive Debug Session"
+            textSize = 18f
+            typeface = Typeface.DEFAULT_BOLD
+            setTextColor(Color.BLACK)
+            layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f)
+        }
+        headerLayout.addView(titleText)
+
+        // Share button - Material Design share icon, circular
+        val shareButton = createCircularButton(activity, "↗", 0xFF1976D2.toInt(), 0xFFF0F0F0.toInt()).apply {
+            layoutParams = LinearLayout.LayoutParams(72, 72).apply {
+                setMargins(0, 0, 20, 0)
+            }
+        }
+        headerLayout.addView(shareButton)
+
+        // Close button - circular with prominent X and destructive styling
+        val closeButton = createCircularButton(activity, "×", 0xFFD32F2F.toInt(), 0xFFFFF0F0.toInt()).apply {
+            textSize = 32f
+            layoutParams = LinearLayout.LayoutParams(72, 72)
+        }
+        headerLayout.addView(closeButton)
+
+        contentContainer.addView(headerLayout)
+
+        // Tab buttons
+        val tabLayout = LinearLayout(activity).apply {
+            orientation = LinearLayout.HORIZONTAL
+            setPadding(0, 20, 0, 0)
+        }
+
+        val currentTab = Button(activity).apply {
+            text = "Current Event"
+            setTextColor(Color.BLACK)
+            layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f)
+        }
+
+        val historyTab = Button(activity).apply {
+            text = "History (${debugHistory.size})"
+            setTextColor(Color.BLACK)
+            layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.WRAP_CONTENT, 1f)
+        }
+
+        tabLayout.addView(currentTab)
+        tabLayout.addView(historyTab)
+        contentContainer.addView(tabLayout)
+
+        // Content area
+        val contentScroll = ScrollView(activity)
+        val contentText = TextView(activity).apply {
+            typeface = Typeface.MONOSPACE
+            textSize = 12f
+            setTextColor(0xFF333333.toInt()) // Dark gray text for better readability
+            setPadding(0, 20, 0, 0)
+        }
+        contentScroll.addView(contentText)
+
+        // Make content area larger to fill most of the screen
+        contentScroll.layoutParams = LinearLayout.LayoutParams(
+            LinearLayout.LayoutParams.MATCH_PARENT, 0, 1f
+        )
+        contentContainer.addView(contentScroll)
+
+        // Position content container at bottom with minimum height (55% of screen - slightly shorter)
+        val displayMetrics = DisplayMetrics()
+        activity.windowManager.defaultDisplay.getMetrics(displayMetrics)
+        val screenHeight = displayMetrics.heightPixels
+        val minHeight = (screenHeight * 0.55).toInt() // 55% of screen height - slightly shorter
+
+        contentContainer.apply {
+            minimumHeight = minHeight
+            layoutParams = LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT,
+                LinearLayout.LayoutParams.WRAP_CONTENT
+            ).apply {
+                gravity = Gravity.BOTTOM
+            }
+        }
+
+        Log.i(TAG, "Debug overlay minimum height set to: ${minHeight}px (55% of ${screenHeight}px)")
+
+        // Add spacer to push content to bottom
+        val spacer = View(activity).apply {
+            layoutParams = LinearLayout.LayoutParams(
+                LinearLayout.LayoutParams.MATCH_PARENT, 0, 1f
+            )
+        }
+        mainLayout.addView(spacer)
+        mainLayout.addView(contentContainer)
+
+        // Set initial content to current event
+        updateCurrentEventContent(contentText, currentEvent, currentData)
+
+        // Tab click listeners
+        currentTab.setOnClickListener {
+            updateCurrentEventContent(contentText, currentEvent, currentData)
+            currentTab.isEnabled = false
+            historyTab.isEnabled = true
+        }
+
+        historyTab.setOnClickListener {
+            updateHistoryContent(contentText)
+            currentTab.isEnabled = true
+            historyTab.isEnabled = false
+        }
+
+        // Set initial tab state
+        currentTab.isEnabled = false
+        historyTab.isEnabled = true
+
+        // Setup share button to export and share debug logs
+        shareButton.setOnClickListener {
+            val exportContent = exportDebugLogs()
+            shareDebugLogs(activity, exportContent)
+        }
+
+        // Setup close button to remove the overlay from the root view
+        closeButton.setOnClickListener {
+            rootView.removeView(mainLayout)
+        }
+
+        // Add the overlay directly to the activity's root view
+        rootView.addView(mainLayout)
+        Log.i(TAG, "Debug overlay added to root view successfully")
+
+        // Note: No auto-dismiss to match iOS behavior - overlay stays until user closes it
+    }
+
+    /**
+     * Creates a circular button with specified text, colors, and styling.
+     */
+    private fun createCircularButton(activity: Activity, text: String, textColor: Int, backgroundColor: Int): Button {
+        return Button(activity).apply {
+            this.text = text
+            textSize = 28f
+            setTextColor(textColor)
+            setBackgroundColor(backgroundColor)
+            typeface = Typeface.DEFAULT_BOLD
+            gravity = Gravity.CENTER
+            includeFontPadding = false
+            minWidth = 0
+            minHeight = 0
+            minimumWidth = 0
+            minimumHeight = 0
+            textAlignment = View.TEXT_ALIGNMENT_CENTER
+            setSingleLine(true)
+            setLines(1)
+            setPadding(0, -20, 0, 8)
+
+            val drawable = GradientDrawable().apply {
+                shape = GradientDrawable.OVAL
+                setColor(backgroundColor)
+                setStroke(3, textColor)
+            }
+            background = drawable
+        }
+    }
+
+    /**
+     * Updates the content text view with current event information.
+     */
+    private fun updateCurrentEventContent(contentText: TextView, event: String, data: Map<String, Any?>) {
+        val content = buildString {
+            appendLine("Event: $event")
+            appendLine()
+
+            try {
+                val jsonObject = JSONObject(data)
+                append(jsonObject.toString(2))
+            } catch (e: Exception) {
+                append("Data: $data")
+            }
+        }
+
+        contentText.text = content
+    }
+
+    /**
+     * Updates the content text view with session history information.
+     */
+    private fun updateHistoryContent(contentText: TextView) {
+        if (debugHistory.isEmpty()) {
+            contentText.text = "No events recorded in this session yet."
+            return
+        }
+
+        val content = buildString {
+            appendLine("Session History (${debugHistory.size} events):")
+            appendLine()
+
+            // Show events in reverse order (newest first)
+            debugHistory.asReversed().forEach { event ->
+                appendLine("───────────────────────────────")
+                appendLine("[${event.getFormattedTime()}] ${event.eventType}")
+
+                // Add summary
+                val summary = event.getSummary()
+                if (summary.isNotEmpty()) {
+                    appendLine("Summary: $summary")
+                }
+
+                appendLine()
+                appendLine("Payload:")
+                try {
+                    val jsonObject = JSONObject(event.data)
+                    appendLine(jsonObject.toString(2))
+                } catch (e: Exception) {
+                    appendLine(event.data.toString())
+                }
+                appendLine()
+                appendLine()
+            }
+        }
+
+        contentText.text = content
+    }
+}

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

@@ -0,0 +1,76 @@
+package com.attentivereactnativesdk.debug
+
+import org.json.JSONObject
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+/**
+ * Data class representing a debug event with timestamp and formatting capabilities.
+ * 
+ * @param eventType The type/name of the event
+ * @param data The event data as a map
+ */
+data class DebugEvent(
+    val eventType: String,
+    val data: Map<String, Any?>
+) {
+    val timestamp: Long = System.currentTimeMillis()
+
+    /**
+     * Returns formatted time string for display.
+     */
+    fun getFormattedTime(): String {
+        val formatter = SimpleDateFormat("HH:mm:ss", Locale.getDefault())
+        return formatter.format(Date(timestamp))
+    }
+
+    /**
+     * Generates a summary string with key information from the event data.
+     */
+    fun getSummary(): String {
+        val summaryParts = mutableListOf<String>()
+
+        data["items_count"]?.let { summaryParts.add("Items: $it") }
+        data["order_id"]?.let { summaryParts.add("Order: $it") }
+        data["creativeId"]?.let { summaryParts.add("Creative: $it") }
+        data["event_type"]?.let { summaryParts.add("Type: $it") }
+
+        // Always show payload size info
+        summaryParts.add("Payload: ${data.size} fields")
+
+        return summaryParts.joinToString(" • ")
+    }
+
+    /**
+     * Formats the debug event as a human-readable string for export.
+     * @return A formatted string containing timestamp, event type, and data
+     */
+    fun formatForExport(): String {
+        val formatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.getDefault())
+        val timeString = formatter.format(Date(timestamp))
+
+        return buildString {
+            appendLine("[$timeString] $eventType")
+
+            // Add summary information if available
+            val summary = getSummary()
+            if (summary.isNotEmpty()) {
+                appendLine("Summary: $summary")
+            }
+
+            appendLine("Data:")
+
+            // Format data as JSON for better readability
+            try {
+                val jsonObject = JSONObject(data)
+                appendLine(jsonObject.toString(2))
+            } catch (e: Exception) {
+                appendLine(data.toString())
+            }
+
+            appendLine("=".repeat(50))
+        }
+    }
+
+}

package/attentive-react-native-sdk.podspec

@@ -11,13 +11,12 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => "11.0" }
+  s.platforms    = { :ios => "14.0" }
   s.source       = { :git => "https://github.com/attentive-mobile/attentive-react-native-sdk.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency 'attentive-ios-sdk', '1.0.0'
-  s.ios.deployment_target = '14.0'
   s.swift_versions = ['5']
   s.dependency "React-Core"