react-native-mparticle 2.7.12 → 2.8.0

package/android/src/oldarch/java/com/mparticle/react/NativeMParticleSpec.kt

@@ -0,0 +1,153 @@
+package com.mparticle.react
+
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+
+abstract class NativeMParticleSpec(
+    reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext) {
+    companion object {
+        private const val MODULE_NAME = "RNMParticle"
+    }
+
+    override fun getName(): String = MODULE_NAME
+
+    abstract fun upload()
+
+    abstract fun setUploadInterval(uploadInterval: Double)
+
+    abstract fun logEvent(
+        eventName: String,
+        eventType: Double,
+        attributes: ReadableMap?,
+    )
+
+    abstract fun logMPEvent(event: ReadableMap?)
+
+    abstract fun logCommerceEvent(commerceEvent: ReadableMap?)
+
+    abstract fun logScreenEvent(
+        screenName: String,
+        attributes: ReadableMap?,
+        shouldUploadEvent: Boolean,
+    )
+
+    abstract fun setATTStatus(status: Double)
+
+    abstract fun setATTStatusWithCustomTimestamp(
+        status: Double,
+        timestamp: Double,
+    )
+
+    abstract fun setOptOut(optOut: Boolean)
+
+    abstract fun getOptOut(callback: Callback)
+
+    abstract fun addGDPRConsentState(
+        consent: ReadableMap?,
+        purpose: String,
+    )
+
+    abstract fun removeGDPRConsentStateWithPurpose(purpose: String)
+
+    abstract fun setCCPAConsentState(consent: ReadableMap?)
+
+    abstract fun removeCCPAConsentState()
+
+    abstract fun isKitActive(
+        kitId: Double,
+        callback: Callback,
+    )
+
+    abstract fun getAttributions(callback: Callback)
+
+    abstract fun logPushRegistration(
+        token: String?,
+        senderId: String?,
+    )
+
+    abstract fun getSession(callback: Callback)
+
+    abstract fun setLocation(
+        latitude: Double,
+        longitude: Double,
+    )
+
+    abstract fun setUserAttribute(
+        mpid: String,
+        key: String,
+        value: String,
+    )
+
+    abstract fun setUserAttributeArray(
+        mpid: String,
+        key: String,
+        value: ReadableArray?,
+    )
+
+    abstract fun getUserAttributes(
+        mpid: String,
+        callback: Callback,
+    )
+
+    abstract fun setUserTag(
+        mpid: String,
+        tag: String,
+    )
+
+    abstract fun incrementUserAttribute(
+        mpid: String,
+        key: String,
+        value: Double,
+    )
+
+    abstract fun removeUserAttribute(
+        mpid: String,
+        key: String,
+    )
+
+    abstract fun getUserIdentities(
+        mpid: String,
+        callback: Callback,
+    )
+
+    abstract fun getFirstSeen(
+        mpid: String,
+        callback: Callback,
+    )
+
+    abstract fun getLastSeen(
+        mpid: String,
+        callback: Callback,
+    )
+
+    abstract fun getCurrentUserWithCompletion(callback: Callback)
+
+    abstract fun identify(
+        identityRequest: ReadableMap?,
+        callback: Callback,
+    )
+
+    abstract fun login(
+        identityRequest: ReadableMap?,
+        callback: Callback,
+    )
+
+    abstract fun logout(
+        identityRequest: ReadableMap?,
+        callback: Callback,
+    )
+
+    abstract fun modify(
+        identityRequest: ReadableMap?,
+        callback: Callback,
+    )
+
+    abstract fun aliasUsers(
+        aliasRequest: ReadableMap?,
+        callback: Callback,
+    )
+}

package/android/src/oldarch/java/com/mparticle/react/rokt/MPRoktModule.kt

@@ -0,0 +1,79 @@
+package com.mparticle.react.rokt
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.uimanager.NativeViewHierarchyManager
+import com.facebook.react.uimanager.UIManagerModule
+import com.mparticle.MParticle
+import com.mparticle.internal.Logger
+import com.mparticle.react.NativeMPRoktSpec
+import com.mparticle.rokt.RoktEmbeddedView
+import java.lang.ref.WeakReference
+
+class MPRoktModule(
+    private val reactContext: ReactApplicationContext,
+) : NativeMPRoktSpec(reactContext) {
+    private val impl = MPRoktModuleImpl(reactContext)
+
+    override fun getName(): String = impl.getName()
+
+    @ReactMethod
+    override fun selectPlacements(
+        identifier: String,
+        attributes: ReadableMap?,
+        placeholders: ReadableMap?,
+        roktConfig: ReadableMap?,
+        fontFilesMap: ReadableMap?,
+    ) {
+        if (identifier.isBlank()) {
+            Logger.warning("selectPlacements failed. identifier cannot be empty")
+            return
+        }
+        val uiManager = reactContext.getNativeModule(UIManagerModule::class.java)
+        MParticle.getInstance()?.Rokt()?.events(identifier)?.let {
+            impl.startRoktEventListener(it, reactContext.currentActivity, identifier)
+        }
+
+        val config = roktConfig?.let { impl.buildRoktConfig(it) }
+        uiManager?.addUIBlock { nativeViewHierarchyManager ->
+            MParticle.getInstance()?.Rokt()?.selectPlacements(
+                identifier = identifier,
+                attributes = impl.readableMapToMapOfStrings(attributes),
+                callbacks = impl.createRoktCallback(),
+                embeddedViews = safeUnwrapPlaceholders(placeholders, nativeViewHierarchyManager),
+                fontTypefaces = null, // TODO
+                config = config,
+            )
+        }
+    }
+
+    @ReactMethod
+    override fun purchaseFinalized(
+        placementId: String,
+        catalogItemId: String,
+        success: Boolean,
+    ) {
+        impl.purchaseFinalized(placementId, catalogItemId, success)
+    }
+
+    private fun safeUnwrapPlaceholders(
+        placeholders: ReadableMap?,
+        nativeViewHierarchyManager: NativeViewHierarchyManager,
+    ): Map<String, WeakReference<RoktEmbeddedView>> {
+        val placeholderMap: MutableMap<String, WeakReference<RoktEmbeddedView>> = HashMap()
+
+        if (placeholders != null) {
+            placeholderMap.putAll(
+                placeholders
+                    .toHashMap()
+                    .filterValues { value -> value is Double }
+                    .mapValues { pair -> (pair.value as Double).toInt() }
+                    .mapValues { pair -> nativeViewHierarchyManager.resolveView(pair.value) as? RoktEmbeddedView }
+                    .filterValues { value -> value != null }
+                    .mapValues { WeakReference(it.value as RoktEmbeddedView) },
+            )
+        }
+        return placeholderMap
+    }
+}

package/android/src/oldarch/java/com/mparticle/react/rokt/RoktLayoutViewManager.kt

@@ -0,0 +1,34 @@
+package com.mparticle.react.rokt
+
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.mparticle.rokt.RoktEmbeddedView
+
+class RoktLayoutViewManager : ViewGroupManager<RoktEmbeddedView>() {
+    private val impl = RoktLayoutViewManagerImpl()
+
+    override fun getName(): String = impl.getName()
+
+    override fun createViewInstance(reactContext: ThemedReactContext): RoktEmbeddedView = impl.createViewInstance(reactContext)
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any>? =
+        MapBuilder
+            .builder<String, Any>()
+            .put(
+                RoktLayoutViewManagerImpl.EVENT_HEIGHT_CHANGED,
+                MapBuilder.of("registrationName", RoktLayoutViewManagerImpl.EVENT_HEIGHT_CHANGED),
+            ).put(
+                RoktLayoutViewManagerImpl.EVENT_MARGIN_CHANGED,
+                MapBuilder.of("registrationName", RoktLayoutViewManagerImpl.EVENT_MARGIN_CHANGED),
+            ).build()
+
+    override fun needsCustomLayoutForChildren(): Boolean = false
+
+    fun setPlaceholderName(
+        view: RoktEmbeddedView?,
+        value: String?,
+    ) {
+        impl.setPlaceholderName(view, value)
+    }
+}

package/ios/RNMParticle/RNMPRokt.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNMParticle/RNMParticle.h>
+#import <React/RCTBridge.h>
+
+@interface RNMPRokt : NSObject<NativeMPRoktSpec>
+@property (nonatomic, weak, nullable) RCTBridge *bridge;
+#else
+
+#import <React/RCTBridgeModule.h>
+@interface RNMPRokt : NSObject <RCTBridgeModule>
+#endif
+
+@end

package/ios/RNMParticle/RNMPRokt.mm

@@ -0,0 +1,247 @@
+#import "RNMPRokt.h"
+#if defined(__has_include) && __has_include(<mParticle_Apple_SDK/mParticle.h>)
+    #import <mParticle_Apple_SDK/mParticle.h>
+    #import <mParticle_Apple_SDK/MPRokt.h>
+#elif defined(__has_include) && __has_include(<mParticle_Apple_SDK_NoLocation/mParticle.h>)
+    #import <mParticle_Apple_SDK_NoLocation/mParticle.h>
+#else
+    #import <mParticle_Apple_SDK/Include/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>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTBridge.h>
+#import "RoktEventManager.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RoktNativeLayoutComponentView.h"
+#import <RNMParticle/RNMParticle.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+@interface RNMPRokt ()
+
+@property (nonatomic, nullable) RoktEventManager *eventManager;
+
+@end
+
+@implementation RNMPRokt
+
+@synthesize bridge = _bridge;
+
+RCT_EXTERN void RCTRegisterModule(Class);
+
++ (NSString *)moduleName {
+    return @"RNMPRokt";
+}
+
++ (void)load {
+    RCTRegisterModule(self);
+}
+
+- (dispatch_queue_t)methodQueue
+{
+    return self.bridge.uiManager.methodQueue;
+}
+
+- (void)setMethodQueue:(dispatch_queue_t)methodQueue
+{
+    // No-op setter to satisfy TurboModule requirements
+    // We always return the UI manager's method queue
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+// New Architecture Implementation
+- (void)selectPlacements:(NSString *)identifer
+              attributes:(NSDictionary *)attributes
+            placeholders:(NSDictionary *)placeholders
+               roktConfig:(JS::NativeMPRokt::RoktConfigType &)roktConfig
+            fontFilesMap:(NSDictionary *)fontFilesMap
+{
+    NSMutableDictionary *finalAttributes = [self convertToMutableDictionaryOfStrings:attributes];
+
+    // Convert JS struct to NSDictionary for internal use
+    NSMutableDictionary *roktConfigDict = [[NSMutableDictionary alloc] init];
+    if (&roktConfig != nullptr && roktConfig.cacheConfig().has_value()) {
+        NSMutableDictionary *cacheConfigDict = [[NSMutableDictionary alloc] init];
+        auto cacheConfig = roktConfig.cacheConfig().value();
+        if (cacheConfig.cacheDurationInSeconds().has_value()) {
+            cacheConfigDict[@"cacheDurationInSeconds"] = @(cacheConfig.cacheDurationInSeconds().value());
+        }
+        if (cacheConfig.cacheAttributes()) {
+            cacheConfigDict[@"cacheAttributes"] = cacheConfig.cacheAttributes();
+        }
+        roktConfigDict[@"cacheConfig"] = cacheConfigDict;
+    }
+
+    MPRoktConfig *config = [self buildRoktConfigFromDict:roktConfigDict];
+#else
+// Old Architecture Implementation
+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];
+#endif
+
+    [MParticle _setWrapperSdk_internal:MPWrapperSdkReactNative version:@""];
+    // Create callback implementation
+    MPRoktEventCallback *callbacks = [[MPRoktEventCallback alloc] init];
+
+    __weak __typeof__(self) weakSelf = self;
+
+    callbacks.onLoad = ^{
+        [self.eventManager onRoktCallbackReceived:@"onLoad"];
+    };
+
+    callbacks.onUnLoad = ^{
+        [self.eventManager onRoktCallbackReceived:@"onUnLoad"];
+        RCTLogInfo(@"unloaded");
+    };
+
+    callbacks.onShouldShowLoadingIndicator = ^{
+        [self.eventManager onRoktCallbackReceived:@"onShouldShowLoadingIndicator"];
+    };
+
+    callbacks.onShouldHideLoadingIndicator = ^{
+        [self.eventManager onRoktCallbackReceived:@"onShouldHideLoadingIndicator"];
+    };
+
+    callbacks.onEmbeddedSizeChange = ^(NSString *placementId, CGFloat height) {
+        [self.eventManager onWidgetHeightChanges:height placement:placementId];
+    };
+
+    [self.bridge.uiManager addUIBlock:^(RCTUIManager *uiManager, NSDictionary<NSNumber *,UIView *> *viewRegistry) {
+        NSMutableDictionary *nativePlaceholders = [self getNativePlaceholders:placeholders viewRegistry:viewRegistry];
+
+        [self subscribeViewEvents:identifer];
+
+        [[[MParticle sharedInstance] rokt] selectPlacements:identifer
+                                                 attributes:finalAttributes
+                                              embeddedViews:nativePlaceholders
+                                                     config:config
+                                                  callbacks:callbacks];
+    }];
+}
+
+RCT_EXPORT_METHOD(purchaseFinalized : (NSString *)placementId catalogItemId : (
+    NSString *)catalogItemId success : (BOOL)success) {
+    [[[MParticle sharedInstance] rokt] purchaseFinalized:placementId
+                                           catalogItemId:catalogItemId
+                                                 success:success];
+}
+
+- (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;
+}
+
+- (void)subscribeViewEvents:(NSString* _Nonnull) viewName
+{
+    if (self.eventManager == nil) {
+        self.eventManager = [RoktEventManager allocWithZone: nil];
+    }
+    [[[MParticle sharedInstance] rokt] events:viewName onEvent:^(MPRoktEvent * _Nonnull roktEvent) {
+            [self.eventManager onRoktEvents:roktEvent viewName:viewName];
+        }];
+}
+
+- (NSMutableDictionary *)getNativePlaceholders:(NSDictionary *)placeholders viewRegistry:(NSDictionary<NSNumber *, UIView *> *)viewRegistry
+{
+    NSMutableDictionary *nativePlaceholders = [[NSMutableDictionary alloc]initWithCapacity:placeholders.count];
+
+    for(id key in placeholders){
+#ifdef RCT_NEW_ARCH_ENABLED
+        RoktNativeLayoutComponentView *wrapperView = (RoktNativeLayoutComponentView *)viewRegistry[[placeholders objectForKey:key]];
+        if (!wrapperView || ![wrapperView isKindOfClass:[RoktNativeLayoutComponentView class]]) {
+            RCTLogError(@"Cannot find RoktNativeWidgetComponentView with tag #%@", key);
+            continue;
+        }
+        nativePlaceholders[key] = wrapperView.roktEmbeddedView;
+#else
+        MPRoktEmbeddedView *view = viewRegistry[[placeholders objectForKey:key]];
+        if (!view || ![view isKindOfClass:[MPRoktEmbeddedView class]]) {
+            RCTLogError(@"Cannot find RoktEmbeddedView with tag #%@", key);
+            continue;
+        }
+
+        nativePlaceholders[key] = view;
+#endif // RCT_NEW_ARCH_ENABLED
+    }
+
+    return nativePlaceholders;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
+    self.bridge = params.instance.bridge;
+    return std::make_shared<facebook::react::NativeMPRoktSpecJSI>(params);
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end

package/ios/RNMParticle/RNMParticle.h

@@ -1,6 +1,11 @@
 #import <Foundation/Foundation.h>
-#import <React/RCTBridge.h>
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNMParticle/RNMParticle.h>
+@interface RNMParticle : NSObject <NativeMParticleSpec>
+#else
+#import <React/RCTBridgeModule.h>
 @interface RNMParticle : NSObject <RCTBridgeModule>
+#endif
 
 @end