Implement Rokt integration in React Native SDK

- Added Rokt module for placement selection in both Android and iOS.
- Updated TypeScript definitions and JavaScript interface for Rokt functionality.
- Modified sample app to demonstrate Rokt placement selection.
- Updated build configurations and dependencies for compatibility with new features.

Author: thomson-t

.gitignore

@@ -79,3 +79,6 @@ build
 .gradle
 local.properties
 package-lock.json
+
+# TypeScript build output
+lib/

.npmignore

@@ -52,5 +52,17 @@ yarn-error.log*
 *.dylib
 *.dll
 
-# Add this line to your .npmignore file
-package-lock.json
+# Development files
+package-lock.json
+yarn.lock
+tsconfig.json
+release.sh
+
+# TypeScript source files (compiled to lib/)
+js/
+
+# Development and test files
+**/*.test.ts
+**/*.test.tsx
+**/*.spec.ts
+**/*.spec.tsx

android/build.gradle

@@ -1,10 +1,12 @@
 buildscript {
+    ext.kotlin_version = "1.8.21"
     repositories {
         mavenCentral()
         google()
     }
     dependencies {
         classpath 'com.android.tools.build:gradle:8.1.4'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }
 
@@ -36,6 +38,7 @@ def supportsNamespace() {
 
 // apply plugin: 'org.jlleitschuh.gradle.ktlint'
 apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
 
 android {
     if (supportsNamespace()) {

android/src/main/java/com/mparticle/react/MParticlePackage.java

@@ -5,6 +5,7 @@
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
+import com.mparticle.react.rokt.MPRoktModule;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -17,6 +18,7 @@ public List<NativeModule> createNativeModules(
         List<NativeModule> modules = new ArrayList<>();
 
         modules.add(new MParticleModule(reactContext));
+        modules.add(new MPRoktModule(reactContext));
 
         return modules;
     }

android/src/main/java/com/mparticle/react/rokt/MPRoktModule.kt

@@ -0,0 +1,79 @@
+package com.mparticle.react.rokt
+
+import com.facebook.common.logging.FLog
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.util.RCTLog
+import com.mparticle.MParticle
+import com.mparticle.internal.KitManager
+import com.mparticle.rokt.CacheConfig
+import com.mparticle.rokt.RoktConfig
+
+class MPRoktModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "MPRokt"
+
+    @ReactMethod
+    fun selectPlacements(
+        identifier: String,
+        attributes: ReadableMap?,
+        placeholders: ReadableMap?,
+        roktConfig: ReadableMap?,
+        fontFilesMap: ReadableMap?,
+    ) {
+        val finalAttributes = readableMapToMapOfStrings(attributes)
+        val config = buildRoktConfig(roktConfig)
+        MParticle.getInstance()?.Rokt()?.selectPlacements(
+            identifier = identifier,
+            attributes = finalAttributes,
+            callbacks = null,
+            embeddedViews = null, /*TODO*/
+            fontTypefaces = null /*TODO*/,
+            config = config,
+        )
+    }
+
+    private fun readableMapToMapOfStrings(attributes: ReadableMap?): Map<String, String> =
+        attributes?.toHashMap()?.filter { it.value is String }?.mapValues { it.value as String }
+            ?: emptyMap()
+
+    private fun String.toColorMode(): RoktConfig.ColorMode = when (this) {
+        "dark" -> RoktConfig.ColorMode.DARK
+        "light" -> RoktConfig.ColorMode.LIGHT
+        else -> RoktConfig.ColorMode.SYSTEM
+    }
+
+    private fun buildRoktConfig(roktConfig: ReadableMap?): RoktConfig {
+        val builder = RoktConfig.Builder()
+        val configMap: Map<String, String> = readableMapToMapOfStrings(roktConfig)
+        configMap["colorMode"]?.let {
+            builder.colorMode(it.toColorMode())
+        }
+        roktConfig?.getMap("cacheConfig")?.let {
+            builder.cacheConfig(buildCacheConfig(it))
+        }
+        return builder.build()
+    }
+
+    private fun buildCacheConfig(cacheConfigMap: ReadableMap?): CacheConfig {
+        val cacheDurationInSeconds =
+            if (cacheConfigMap?.hasKey("cacheDurationInSeconds") == true) {
+                cacheConfigMap.getDouble("cacheDurationInSeconds").toLong()
+            } else {
+                0L
+            }
+        val cacheAttributes =
+            if (cacheConfigMap?.hasKey("cacheAttributes") == true) {
+                cacheConfigMap.getMap("cacheAttributes")?.toHashMap()?.mapValues { it.value as String }
+            } else {
+                null
+            }
+        return CacheConfig(
+            cacheDurationInSeconds = cacheDurationInSeconds,
+            cacheAttributes = cacheAttributes,
+        )
+    }
+}

ios/RNMParticle/RNMPRokt.h

@@ -0,0 +1,6 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTBridge.h>
+
+@interface RNMPRokt : NSObject <RCTBridgeModule>
+
+@end

ios/RNMParticle/RNMPRokt.m

@@ -0,0 +1,102 @@
+#import "RNMPRokt.h"
+#if defined(__has_include) && __has_include(<mParticle_Apple_SDK/mParticle.h>)
+    #import <mParticle_Apple_SDK/mParticle.h>
+#elif defined(__has_include) && __has_include(<mParticle_Apple_SDK_NoLocation/mParticle.h>)
+    #import <mParticle_Apple_SDK_NoLocation/mParticle.h>
+#else
+    #import "mParticle.h"
+#endif
+#if defined(__has_include) && __has_include(<mParticle_Apple_SDK/mParticle_Apple_SDK-Swift.h>)
+    #import <mParticle_Apple_SDK/mParticle_Apple_SDK-Swift.h>
+#elif defined(__has_include) && __has_include(<mParticle_Apple_SDK_NoLocation/mParticle_Apple_SDK-Swift.h>)
+    #import <mParticle_Apple_SDK_NoLocation/mParticle_Apple_SDK-Swift.h>
+#else
+    #import "mParticle_Apple_SDK-Swift.h"
+#endif
+#import <React/RCTConvert.h>
+
+@implementation RNMPRokt
+
+RCT_EXTERN void RCTRegisterModule(Class);
+
++ (NSString *)moduleName {
+    return @"MPRokt";
+}
+
++ (void)load {
+    RCTRegisterModule(self);
+}
+
+RCT_EXPORT_METHOD(selectPlacements:(NSString *) identifer attributes:(NSDictionary *)attributes placeholders:(NSDictionary * _Nullable)placeholders roktConfig:(NSDictionary * _Nullable)roktConfig fontFilesMap:(NSDictionary * _Nullable)fontFilesMap)
+{
+    NSMutableDictionary *finalAttributes = [self convertToMutableDictionaryOfStrings:attributes];
+    MPRoktConfig *config = [self buildRoktConfigFromDict:roktConfig];
+    // TODO: Add placeholders and fontFilesMap
+    [[[MParticle sharedInstance] rokt] selectPlacements:identifer attributes:finalAttributes];
+}
+
+- (NSMutableDictionary*)convertToMutableDictionaryOfStrings:(NSDictionary*)attributes
+{
+    NSMutableDictionary *finalAttributes = [attributes mutableCopy];
+    NSArray *keysForNullValues = [finalAttributes allKeysForObject:[NSNull null]];
+    [finalAttributes removeObjectsForKeys:keysForNullValues];
+    
+    NSSet *keys = [finalAttributes keysOfEntriesPassingTest:^BOOL(id key, id obj, BOOL *stop) {
+        return ![obj isKindOfClass:[NSString class]];
+    }];
+    
+    [finalAttributes removeObjectsForKeys:[keys allObjects]];
+    return finalAttributes;
+    
+}
+
+- (MPColorMode)stringToColorMode:(NSString*)colorString
+{
+    if ([colorString isEqualToString:@"light"]) {
+        return MPColorModeLight;
+    }
+    else if ([colorString isEqualToString:@"dark"]) {
+        return MPColorModeDark;
+    }
+    else {
+        return MPColorModeSystem;
+    }
+}
+
+- (MPRoktConfig *)buildRoktConfigFromDict:(NSDictionary<NSString *, id> *)configMap {
+    MPRoktConfig *config = [[MPRoktConfig alloc] init];
+    BOOL isConfigEmpty = YES;
+
+    NSString *colorModeString = configMap[@"colorMode"];
+    if (colorModeString && [colorModeString isKindOfClass:[NSString class]]) {
+        if (@available(iOS 12.0, *)) {
+            isConfigEmpty = NO;
+            if ([colorModeString isEqualToString:@"dark"]) {
+                if (@available(iOS 13.0, *)) {
+                    config.colorMode = MPColorModeDark;
+                }
+            } else if ([colorModeString isEqualToString:@"light"]) {
+                config.colorMode = MPColorModeLight;
+            } else {
+                // default: "system"
+                config.colorMode = MPColorModeSystem;
+            }
+        }
+    }
+
+    NSDictionary *cacheConfigMap = configMap[@"cacheConfig"];
+    if (cacheConfigMap && [cacheConfigMap isKindOfClass:[NSDictionary class]]) {
+        isConfigEmpty = NO;
+        NSNumber *cacheDuration = cacheConfigMap[@"cacheDurationInSeconds"];
+        if (!cacheDuration) {
+            cacheDuration = @0;
+        }
+        NSDictionary<NSString *, NSString *> *cacheAttributes = cacheConfigMap[@"cacheAttributes"];
+        config.cacheAttributes = cacheAttributes;
+        config.cacheDuration = cacheDuration;
+    }
+
+    return isConfigEmpty ? nil : config;
+}
+
+@end