@sentiance-react-native/core 6.3.0-rc.2 → 6.3.0

package/android/src/main/java/com/sentiance/react/bridge/core/SentianceModule.java

@@ -563,14 +563,20 @@ public class SentianceModule extends AbstractSentianceModule {
     promise.resolve(args);
   }
 
+  @Override
   @ReactMethod
-  public void addListener(String eventName) {
-    // Set up any upstream listeners or background tasks as necessary
+  protected void addListener(String eventName, int subscriptionId, Promise promise) {
+
   }
 
+  @Override
   @ReactMethod
-  public void removeListeners(Integer count) {
-    // Remove upstream listeners, stop unnecessary background tasks
+  protected void removeListener(String eventName, int subscriptionId, Promise promise) {
+
   }
+
+  @Override
+  @ReactMethod
+  public void removeListeners(Integer count) {}
 }
 

package/android/src/main/java/com/sentiance/react/bridge/core/base/AbstractSentianceModule.java

@@ -2,9 +2,13 @@ package com.sentiance.react.bridge.core.base;
 
 import static com.sentiance.react.bridge.core.utils.ErrorCodes.E_SDK_NOT_INITIALIZED;
 
+import androidx.annotation.NonNull;
+
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.sentiance.react.bridge.core.common.SentianceSubscriptionsManager;
 import com.sentiance.sdk.InitState;
 import com.sentiance.sdk.Sentiance;
 
@@ -12,11 +16,18 @@ public abstract class AbstractSentianceModule extends ReactContextBaseJavaModule
 
   protected final ReactApplicationContext reactContext;
   protected final Sentiance sdk;
+  protected final SentianceSubscriptionsManager subscriptionsManager;
 
   public AbstractSentianceModule(ReactApplicationContext reactApplicationContext) {
     super(reactApplicationContext);
     reactContext = reactApplicationContext;
     sdk = Sentiance.getInstance(reactContext);
+    subscriptionsManager = new SentianceSubscriptionsManager();
+  }
+
+  @Override
+  public void initialize() {
+    addSupportedEventSubscriptions(subscriptionsManager);
   }
 
   protected boolean rejectIfNotInitialized(Promise promise) {
@@ -30,4 +41,22 @@ public abstract class AbstractSentianceModule extends ReactContextBaseJavaModule
   private boolean isSdkInitialized() {
     return sdk.getInitState() == InitState.INITIALIZED;
   }
+
+  protected void addSupportedEventSubscriptions(SentianceSubscriptionsManager subscriptionsManager) {
+
+  }
+
+  protected <T> void addSubscription(@NonNull String eventType, int subscriptionId, @NonNull T eventEmitterLogic) {
+    subscriptionsManager.addSubscription(eventType, subscriptionId, eventEmitterLogic);
+  }
+
+  protected <T> void removeSubscription(int subscriptionId, @NonNull String eventType) {
+    subscriptionsManager.removeSubscription(subscriptionId, eventType);
+  }
+
+  protected abstract void removeListener(String eventName, int subscriptionId, Promise promise);
+
+  protected abstract void addListener(String eventName, int subscriptionId, Promise promise);
+
+  protected abstract void removeListeners(Integer count);
 }

package/android/src/main/java/com/sentiance/react/bridge/core/common/SentianceSubscriptionsManager.java

@@ -0,0 +1,202 @@
+package com.sentiance.react.bridge.core.common;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.sentiance.react.bridge.core.utils.SingleParamRunnable;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+@SuppressWarnings("rawtypes")
+public class SentianceSubscriptionsManager {
+
+  private final List<Subscription> mSubscriptions;
+  private final Map<String, SubscriptionDefinition> mSupportedSubscriptions;
+
+  public SentianceSubscriptionsManager() {
+    mSubscriptions = new ArrayList<>();
+    mSupportedSubscriptions = new HashMap<>();
+  }
+
+  public <T> void addSupportedSubscription(String eventType, SingleParamRunnable<T> nativeSubscribeLogic,
+                                       SingleParamRunnable<T> nativeUnsubscribeLogic, SubscriptionType subscriptionType) {
+    if (mSupportedSubscriptions.containsKey(eventType)) {
+      throw new IllegalArgumentException(String.format("A subscription definition for %s has already been added.",
+                                                       eventType));
+    }
+
+    mSupportedSubscriptions.put(eventType, new SubscriptionDefinition<>(eventType, nativeSubscribeLogic,
+                                                                        nativeUnsubscribeLogic, subscriptionType));
+  }
+
+  public <T> void addSubscription(@NonNull String eventType, int subscriptionId, @NonNull T eventEmitterLogic) {
+    SubscriptionDefinition definition = mSupportedSubscriptions.get(eventType);
+    if (definition == null) {
+      return;
+    }
+
+    if (shouldSubscribeNatively(definition)) {
+      //noinspection unchecked
+      definition.nativeSubscribeLogic.run(eventEmitterLogic);
+    }
+
+    Subscription<T> subscription = new Subscription<>(subscriptionId, eventEmitterLogic, eventType);
+
+    synchronized (mSubscriptions) {
+      mSubscriptions.add(subscription);
+    }
+  }
+
+  public void removeSubscription(int subscriptionId, String eventType) {
+    SubscriptionDefinition definition = mSupportedSubscriptions.get(eventType);
+    if (definition == null) {
+      return;
+    }
+
+    Subscription subscription = getExistingSubscription(subscriptionId, eventType);
+    if (subscription != null) {
+      synchronized (mSubscriptions) {
+        mSubscriptions.remove(subscription);
+      }
+
+      if (shouldUnsubscribeNatively(definition)) {
+        //noinspection unchecked
+        definition.nativeUnsubscribeLogic.run(subscription.eventEmitterLogic);
+      }
+    }
+  }
+
+  @Nullable
+  private Subscription getExistingSubscription(int subscriptionId, String eventType) {
+    synchronized (mSubscriptions) {
+      for (Subscription subscription : mSubscriptions) {
+        if (subscription.id == subscriptionId && subscription.eventType.equals(eventType)) {
+          return subscription;
+        }
+      }
+      return null;
+    }
+  }
+
+  private boolean shouldSubscribeNatively(SubscriptionDefinition definition) {
+    return shouldInvokeNativeLogic(definition);
+  }
+
+  private boolean shouldUnsubscribeNatively(SubscriptionDefinition definition) {
+    return shouldInvokeNativeLogic(definition);
+  }
+
+  private boolean shouldInvokeNativeLogic(SubscriptionDefinition definition) {
+    if (definition.subscriptionType == SubscriptionType.MULTIPLE) {
+      return true;
+    }
+
+    return definition.subscriptionType == SubscriptionType.SINGLE && !subscriptionsExists(definition.eventType);
+  }
+
+  private boolean subscriptionsExists(String eventType) {
+    synchronized (mSubscriptions) {
+      for (Subscription sub : mSubscriptions) {
+        if (sub.eventType.equals(eventType)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+
+  private static class Subscription<T> {
+    private final int id;
+    @Nullable
+    private final T eventEmitterLogic;
+    private final String eventType;
+
+    public Subscription(int id, @Nullable T eventEmmitterLogic, String eventType) {
+      this.id = id;
+      this.eventEmitterLogic = eventEmmitterLogic;
+      this.eventType = eventType;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      Subscription<?> that = (Subscription<?>) o;
+      return id == that.id && Objects.equals(eventEmitterLogic, that.eventEmitterLogic) && Objects.equals(eventType, that.eventType);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(id, eventEmitterLogic, eventType);
+    }
+
+    @Override
+    public String toString() {
+      return "Subscription{" +
+        "id=" + id +
+        ", eventType='" + eventType + '\'' +
+        '}';
+    }
+  }
+
+  /**
+   * Outlines how the native code should react to incoming requests in order to subscribe to/unsubscribe from
+   * global events from the JS code.
+   * <br/>
+   * <p>
+   * It defines how to add a listener on the Sentiance SDK to get updates related to the provided <code>eventType</code>,
+   * and how to remove the said listener.
+   * </p>
+   *
+   * @param <T> The type of the Sentiance SDK listener to be added/removed.
+   */
+  private static class SubscriptionDefinition<T> {
+    private final String eventType;
+    /**
+     * The subscription logic to run towards the native SDK.
+     */
+    private final SingleParamRunnable<T> nativeSubscribeLogic;
+    /**
+     * The unsubscription logic to run towards the native SDK.
+     */
+    private final SingleParamRunnable<T> nativeUnsubscribeLogic;
+
+    private final SubscriptionType subscriptionType;
+
+    public SubscriptionDefinition(String eventType, SingleParamRunnable<T> nativeSubscribeLogic,
+                                  SingleParamRunnable<T> nativeUnsubscribeLogic, SubscriptionType subscriptionType) {
+      this.eventType = eventType;
+      this.nativeSubscribeLogic = nativeSubscribeLogic;
+      this.nativeUnsubscribeLogic = nativeUnsubscribeLogic;
+      this.subscriptionType = subscriptionType;
+    }
+
+    @Override
+    public String toString() {
+      return "SubscriptionDefinition{" +
+        "eventType='" + eventType + '\'' +
+        ", subscriptionType=" + subscriptionType +
+        '}';
+    }
+  }
+
+  /**
+   * Indicates whether the Sentiance SDK supports setting multiple listeners for a certain event type,
+   * or just a single listener.
+   *
+   * <pre>
+   *   {@code
+   *     someSentianceApi.setSomeEventListener(); // SINGLE
+   *     someSentianceApi.addSomeEventListener(); // MULTIPLE
+   *   }
+   * </pre>
+   */
+  public enum SubscriptionType {
+    SINGLE,
+    MULTIPLE
+  }
+}

package/android/src/main/java/com/sentiance/react/bridge/core/utils/SingleParamRunnable.java

@@ -0,0 +1,6 @@
+package com.sentiance.react.bridge.core.utils;
+
+@FunctionalInterface
+public interface SingleParamRunnable<T> {
+  void run(T t);
+}

package/ios/RNSentianceCore+Converter.h

@@ -49,5 +49,7 @@ typedef NS_ENUM(NSInteger, UIBackgroundRefreshStatus);
 - (NSString*)convertBackgroundRefreshStatus:(UIBackgroundRefreshStatus)backgroundRefreshStatus;
 - (NSSet<NSString*> *)convertIntegerTransmittableDataTypes:(NSArray<NSNumber*>*)intDataTypes;
 - (NSSet<NSNumber*> *)convertStringTransmittableDataTypes:(NSArray<NSString*>*)stringDataTypes;
+- (NSDictionary *)convertDrivingInsights:(SENTDrivingInsights *)drivingInsights;
+- (NSArray *)convertHarshDrivingEvents:(NSArray<SENTHarshDrivingEvent*> *)harshDrivingEvents;
 
 @end

package/ios/RNSentianceCore+Converter.m

@@ -241,17 +241,8 @@
 
 - (NSMutableDictionary*)convertEvent:(SENTTimelineEvent*)event {
     NSMutableDictionary *eventDict = [[NSMutableDictionary alloc] init];
-    eventDict[@"startTime"] = [event.startDate description];
-    eventDict[@"startTimeEpoch"] = @((long) (event.startDate.timeIntervalSince1970 * 1000));
-    if (event.endDate != nil) {
-        eventDict[@"endTime"] = [event.endDate description];
-        eventDict[@"endTimeEpoch"] = @((long) (event.endDate.timeIntervalSince1970 * 1000));
 
-        NSInteger durationInSeconds = event.durationInSeconds;
-        if (durationInSeconds != SENTDurationUnknown) {
-            eventDict[@"durationInSeconds"] = [NSNumber numberWithInt:(int)durationInSeconds];
-        }
-    }
+    [self _addBaseEventFields:eventDict event:event];
 
     eventDict[@"type"] = [self convertTimelineEventTypeToString:event.type];
 
@@ -265,6 +256,22 @@
     return eventDict;
 }
 
+- (NSMutableDictionary*) _addBaseEventFields:(NSMutableDictionary*) eventDict event: (SENTTimelineEvent*)event {
+    eventDict[@"id"] = [event eventId];
+    eventDict[@"startTime"] = [event.startDate description];
+    eventDict[@"startTimeEpoch"] = @((long) (event.startDate.timeIntervalSince1970 * 1000));
+    if (event.endDate != nil) {
+        eventDict[@"endTime"] = [event.endDate description];
+        eventDict[@"endTimeEpoch"] = @((long) (event.endDate.timeIntervalSince1970 * 1000));
+
+        NSInteger durationInSeconds = event.durationInSeconds;
+        if (durationInSeconds != SENTDurationUnknown) {
+            eventDict[@"durationInSeconds"] = [NSNumber numberWithInt:(int)durationInSeconds];
+        }
+    }
+    return eventDict;
+}
+
 - (nullable NSString*)convertSegmentCategoryToString:(SENTSegmentCategory)category {
     switch (category) {
         case SENTSegmentCategoryLeisure:
@@ -1114,4 +1121,35 @@
     return [typesSet copy];
 }
 
+- (NSDictionary<NSString *, NSDictionary<NSString *, NSNumber *> *> *)convertDrivingInsights:(SENTDrivingInsights *)drivingInsights {
+    NSMutableDictionary *dict = [[NSMutableDictionary alloc] init];
+    NSMutableDictionary *transportEventDict = [[NSMutableDictionary alloc] init];
+    NSMutableDictionary *safetyScoresDict = [[NSMutableDictionary alloc] init];
+
+    [self _addBaseEventFields:transportEventDict event:drivingInsights.transportEvent];
+    [self addTransportEventInfoToDict:transportEventDict event:drivingInsights.transportEvent];
+    dict[@"transportEvent"] = transportEventDict;
+
+    safetyScoresDict[@"smoothScore"] = drivingInsights.safetyScores.smoothScore;
+    dict[@"safetyScores"] = safetyScoresDict;
+
+    return dict;
+}
+
+- (NSArray<NSDictionary<NSString *, NSNumber *> *> *)convertHarshDrivingEvents:(NSArray<SENTHarshDrivingEvent*> *)harshDrivingEvents {
+    NSMutableArray <NSDictionary<NSString *, NSNumber *> *> *array = [[NSMutableArray alloc] init];
+    for (SENTHarshDrivingEvent *event in harshDrivingEvents) {
+        [array addObject:[self convertHarshDrivingEvent:event]];
+    }
+    return array;
+}
+
+- (NSDictionary<NSString *, NSNumber *> *)convertHarshDrivingEvent:(SENTHarshDrivingEvent *)harshDrivingEvent {
+    NSMutableDictionary<NSString *, NSNumber *> *dict = [[NSMutableDictionary alloc] init];
+    dict[@"time"] = [harshDrivingEvent.date description];
+    dict[@"timeEpoch"] = @((long) (harshDrivingEvent.date.timeIntervalSince1970 * 1000));
+    dict[@"magnitude"] = @(harshDrivingEvent.magnitude);
+    return dict;
+}
+
 @end

package/ios/RNSentianceCore.h

@@ -11,8 +11,9 @@ static NSString * _Nonnull const TripTimeoutEvent = @"SENTIANCE_ON_TRIP_TIMED_OU
 static NSString * _Nonnull const VehicleCrashEvent = @"SENTIANCE_VEHICLE_CRASH_EVENT";
 static NSString * _Nonnull const VehicleCrashDiagnosticEvent = @"SENTIANCE_VEHICLE_CRASH_DIAGNOSTIC_EVENT";
 static NSString * _Nonnull const UserContextUpdateEvent = @"SENTIANCE_USER_CONTEXT_UPDATE_EVENT";
+static NSString * _Nonnull const DrivingInsightsReadyEvent = @"SENTIANCE_DRIVING_INSIGHTS_READY_EVENT";
 
-@interface RNSentianceCore : RCTEventEmitter <RCTBridgeModule, SENTUserContextDelegate>
+@interface RNSentianceCore : RCTEventEmitter <RCTBridgeModule, SENTUserContextDelegate, SENTDrivingInsightsReadyDelegate>
 typedef void (^SdkStatusHandler)(SENTSDKStatus * _Nonnull status);
 - (SENTUserLinker _Nonnull ) getUserLinker;
 - (SdkStatusHandler _Nonnull) getSdkStatusUpdateHandler;

package/ios/RNSentianceCore.m

@@ -5,6 +5,7 @@
 #import "RNSentianceNativeInitialization.h"
 #import "RNSentianceCore+Converter.h"
 #import "RNSentianceErrorCodes.h"
+#import "RNSentianceSubscriptionsManager.h"
 
 #define REJECT_IF_SDK_NOT_INITIALIZED(reject) if ([self isSdkNotInitialized]) {                            \
                                                   reject(ESDKNotInitialized, @"Sdk not initialized", nil); \
@@ -15,6 +16,7 @@
 
 @property (nonatomic, strong) void (^userLinkSuccess)(void);
 @property (nonatomic, strong) void (^userLinkFailed)(void);
+@property (nonatomic, strong) RNSentianceSubscriptionsManager* subscriptionsManager;
 @property (nonatomic, strong) SENTUserLinker userLinker;
 @property (nonatomic, strong) SdkStatusHandler sdkStatusHandler;
 @property (assign) BOOL userLinkingEnabled;
@@ -33,7 +35,7 @@ RCT_EXPORT_MODULE(SentianceCore)
 
 - (NSArray<NSString *> *)supportedEvents
 {
-    return @[SdkStatusUpdateEvent, TripTimeoutEvent, UserLinkEvent, UserActivityUpdateEvent, VehicleCrashEvent, VehicleCrashDiagnosticEvent, UserLinkEvent, UserContextUpdateEvent];
+    return @[SdkStatusUpdateEvent, TripTimeoutEvent, UserLinkEvent, UserActivityUpdateEvent, VehicleCrashEvent, VehicleCrashDiagnosticEvent, UserLinkEvent, UserContextUpdateEvent, DrivingInsightsReadyEvent];
 }
 
 // Will be called when this module's first listener is added.
@@ -48,6 +50,29 @@ RCT_EXPORT_MODULE(SentianceCore)
     // Remove upstream listeners, stop unnecessary background tasks
 }
 
++ (BOOL)requiresMainQueueSetup {
+    return NO;
+}
+
+- (void)onDrivingInsightsReadyWithInsights:(SENTDrivingInsights *)insights {
+    [self sendEventWithName:DrivingInsightsReadyEvent body:[self convertDrivingInsights:insights]];
+}
+
+- (instancetype)init
+{
+    self = [super init];
+    _subscriptionsManager = [RNSentianceSubscriptionsManager new];
+    __weak typeof(self) weakSelf = self;
+
+    [_subscriptionsManager addSupportedSubscriptionForEventType:DrivingInsightsReadyEvent nativeSubscribeLogic:^{
+        [[Sentiance sharedInstance] setDrivingInsightsReadyDelegate:weakSelf];
+    } nativeUnsubscribeLogic:^{
+        [[Sentiance sharedInstance] setDrivingInsightsReadyDelegate:nil];
+    } subscriptionType:SENTSubscriptionTypeSingle];
+
+    return self;
+}
+
 - (void) initSDK:(NSString *)appId
           secret:(NSString *)secret
          baseURL:(nullable NSString *)baseURL
@@ -993,7 +1018,7 @@ RCT_EXPORT_METHOD(listenTripTimeout:(RCTPromiseResolveBlock)resolve rejecter:(RC
 RCT_EXPORT_METHOD(setTransmittableDataTypes:(NSArray *)types resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     REJECT_IF_SDK_NOT_INITIALIZED(reject);
-    
+
     NSSet *typesSet = [NSSet setWithArray:types];
     NSSet *convertedTypes = [self convertStringTransmittableDataTypes:types];
     [[Sentiance sharedInstance] setTransmittableDataTypes:convertedTypes];
@@ -1002,13 +1027,49 @@ RCT_EXPORT_METHOD(setTransmittableDataTypes:(NSArray *)types resolver:(RCTPromis
 RCT_EXPORT_METHOD(getTransmittableDataTypes:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     REJECT_IF_SDK_NOT_INITIALIZED(reject);
-    
+
     NSSet *types = [[Sentiance sharedInstance] transmittableDataTypes];
     NSSet *convertedTypes = [self convertIntegerTransmittableDataTypes:types];
     NSArray *array = [convertedTypes allObjects];
     resolve(array);
 }
 
+RCT_EXPORT_METHOD(getDrivingInsights:(NSString*)transportId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    REJECT_IF_SDK_NOT_INITIALIZED(reject);
+
+    SENTDrivingInsights *drivingInsights = [[Sentiance sharedInstance] getDrivingInsightsForTransportId:transportId];
+    if (drivingInsights == nil) {
+        resolve(nil);
+        return;
+    }
+    resolve([self convertDrivingInsights:drivingInsights]);
+}
+
+RCT_EXPORT_METHOD(getHarshDrivingEvents:(NSString*)transportId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    REJECT_IF_SDK_NOT_INITIALIZED(reject);
+
+    NSArray<SENTHarshDrivingEvent *> *harshDrivingEvents = [[Sentiance sharedInstance] getHarshDrivingEventsForTransportId:transportId];
+    resolve([self convertHarshDrivingEvents:harshDrivingEvents]);
+}
+
+RCT_EXPORT_METHOD(addNativeListener:(NSString *)eventName subscriptionId:(NSInteger)subscriptionId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    REJECT_IF_SDK_NOT_INITIALIZED(reject);
+
+    [_subscriptionsManager addSubscriptionForEventType:eventName subscriptionId:subscriptionId];
+
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(removeNativeListener:(NSString *)eventName subscriptionId:(NSInteger)subscriptionId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject) {
+    REJECT_IF_SDK_NOT_INITIALIZED(reject);
+
+    [_subscriptionsManager removeSubscriptionForId:subscriptionId eventType:eventName];
+
+    resolve(nil);
+}
+
 - (void)didUpdateUserContext:(SENTUserContext *)userContext
              forCriteriaMask:(SENTUserContextUpdateCriteria)criteriaMask {
     NSDictionary *dict = @{

package/ios/RNSentianceCore.podspec

@@ -4,7 +4,7 @@ sentiance_sdk_version = package['sdkVersions']['ios']['sentiance']
 
 Pod::Spec.new do |s|
   s.name         = "RNSentianceCore"
-  s.version      = "6.3.0-rc.2"
+  s.version      = "6.3.0"
   s.summary      = "RNSentianceCore"
   s.description  = <<-DESC
                    RNSentianceCore

package/ios/RNSentianceCore.xcodeproj/project.pbxproj

@@ -12,6 +12,9 @@
 		03AE2706282A80FE0085E48F /* RNSentianceCore.m in Sources */ = {isa = PBXBuildFile; fileRef = 03AE2701282A80FD0085E48F /* RNSentianceCore.m */; };
 		03AE2707282A80FE0085E48F /* RNSentianceCore+Converter.m in Sources */ = {isa = PBXBuildFile; fileRef = 03AE2704282A80FD0085E48F /* RNSentianceCore+Converter.m */; };
 		9AE9AE342527BDFA0070A307 /* RNSentianceNativeInitialization.m in Sources */ = {isa = PBXBuildFile; fileRef = 9AE9AE332527BDFA0070A307 /* RNSentianceNativeInitialization.m */; };
+		DE07003329DC44B900C4FA5B /* RNSentianceSubscriptionDefinition.m in Sources */ = {isa = PBXBuildFile; fileRef = DE07002D29DC44B900C4FA5B /* RNSentianceSubscriptionDefinition.m */; };
+		DE07003429DC44B900C4FA5B /* RNSentianceSubscription.m in Sources */ = {isa = PBXBuildFile; fileRef = DE07002F29DC44B900C4FA5B /* RNSentianceSubscription.m */; };
+		DE07003529DC44B900C4FA5B /* RNSentianceSubscriptionsManager.m in Sources */ = {isa = PBXBuildFile; fileRef = DE07003029DC44B900C4FA5B /* RNSentianceSubscriptionsManager.m */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -36,8 +39,15 @@
 		03AE2703282A80FD0085E48F /* RNSentianceCore+Converter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = "RNSentianceCore+Converter.h"; sourceTree = "<group>"; };
 		03AE2704282A80FD0085E48F /* RNSentianceCore+Converter.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = "RNSentianceCore+Converter.m"; sourceTree = "<group>"; };
 		134814201AA4EA6300B7C361 /* libRNSentianceCore.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRNSentianceCore.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		4C0B444329DD81A60094360E /* RNSentianceFoundation.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNSentianceFoundation.h; sourceTree = "<group>"; };
 		9AE9AE322527BDD90070A307 /* RNSentianceNativeInitialization.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNSentianceNativeInitialization.h; sourceTree = "<group>"; };
 		9AE9AE332527BDFA0070A307 /* RNSentianceNativeInitialization.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNSentianceNativeInitialization.m; sourceTree = "<group>"; };
+		DE07002D29DC44B900C4FA5B /* RNSentianceSubscriptionDefinition.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNSentianceSubscriptionDefinition.m; sourceTree = "<group>"; };
+		DE07002E29DC44B900C4FA5B /* RNSentianceSubscription.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNSentianceSubscription.h; sourceTree = "<group>"; };
+		DE07002F29DC44B900C4FA5B /* RNSentianceSubscription.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNSentianceSubscription.m; sourceTree = "<group>"; };
+		DE07003029DC44B900C4FA5B /* RNSentianceSubscriptionsManager.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RNSentianceSubscriptionsManager.m; sourceTree = "<group>"; };
+		DE07003129DC44B900C4FA5B /* RNSentianceSubscriptionsManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNSentianceSubscriptionsManager.h; sourceTree = "<group>"; };
+		DE07003229DC44B900C4FA5B /* RNSentianceSubscriptionDefinition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RNSentianceSubscriptionDefinition.h; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -62,6 +72,7 @@
 		58B511D21A9E6C8500147676 = {
 			isa = PBXGroup;
 			children = (
+				4C0B444329DD81A60094360E /* RNSentianceFoundation.h */,
 				03AE2702282A80FD0085E48F /* RNSentianceErrorCodes.h */,
 				03AE26FF282A80FD0085E48F /* RNSentianceErrorCodes.m */,
 				03AE2700282A80FD0085E48F /* RNSentianceCore.h */,
@@ -70,8 +81,14 @@
 				03AE2704282A80FD0085E48F /* RNSentianceCore+Converter.m */,
 				03AE26FD282A80E90085E48F /* RNSentianceHelper.h */,
 				03AE26FC282A80E90085E48F /* RNSentianceHelper.m */,
-				9AE9AE332527BDFA0070A307 /* RNSentianceNativeInitialization.m */,
+				DE07002E29DC44B900C4FA5B /* RNSentianceSubscription.h */,
+				DE07002F29DC44B900C4FA5B /* RNSentianceSubscription.m */,
+				DE07003229DC44B900C4FA5B /* RNSentianceSubscriptionDefinition.h */,
+				DE07002D29DC44B900C4FA5B /* RNSentianceSubscriptionDefinition.m */,
+				DE07003129DC44B900C4FA5B /* RNSentianceSubscriptionsManager.h */,
+				DE07003029DC44B900C4FA5B /* RNSentianceSubscriptionsManager.m */,
 				9AE9AE322527BDD90070A307 /* RNSentianceNativeInitialization.h */,
+				9AE9AE332527BDFA0070A307 /* RNSentianceNativeInitialization.m */,
 				134814211AA4EA7D00B7C361 /* Products */,
 			);
 			sourceTree = "<group>";
@@ -135,7 +152,10 @@
 			files = (
 				03AE2707282A80FE0085E48F /* RNSentianceCore+Converter.m in Sources */,
 				03AE26FE282A80E90085E48F /* RNSentianceHelper.m in Sources */,
+				DE07003329DC44B900C4FA5B /* RNSentianceSubscriptionDefinition.m in Sources */,
+				DE07003529DC44B900C4FA5B /* RNSentianceSubscriptionsManager.m in Sources */,
 				03AE2706282A80FE0085E48F /* RNSentianceCore.m in Sources */,
+				DE07003429DC44B900C4FA5B /* RNSentianceSubscription.m in Sources */,
 				9AE9AE342527BDFA0070A307 /* RNSentianceNativeInitialization.m in Sources */,
 				03AE2705282A80FE0085E48F /* RNSentianceErrorCodes.m in Sources */,
 			);

package/ios/RNSentianceFoundation.h

@@ -0,0 +1,11 @@
+//
+//  RNSentianceFoundation.h
+//  RNSentianceCore
+//
+//  Created by David Chelidze on 05/04/2023.
+//  Copyright © 2023 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+typedef void (^SentianceBlock)(void);

package/ios/RNSentianceSubscription.h

@@ -0,0 +1,19 @@
+//
+//  Subscription.h
+//  Pods
+//
+//  Created by Mohammed Aouf Zouag on 27/3/2023.
+//
+
+#import <Foundation/Foundation.h>
+
+
+@interface RNSentianceSubscription : NSObject
+
+@property (nonatomic, readonly) NSInteger subscriptionId;
+@property (nonatomic, strong, readonly) NSString *eventType;
+
+- (instancetype)init NS_UNAVAILABLE;
+- (instancetype)initWithEventType:(NSString*)eventType subscriptionId:(NSInteger)subscriptionId NS_DESIGNATED_INITIALIZER;
+
+@end

package/ios/RNSentianceSubscription.m

@@ -0,0 +1,30 @@
+//
+//  Subscription.m
+//  DoubleConversion
+//
+//  Created by Mohammed Aouf Zouag on 27/3/2023.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNSentianceSubscription.h"
+
+
+@interface RNSentianceSubscription ()
+
+@property (nonatomic, readwrite) NSInteger subscriptionId;
+@property (nonatomic, strong, readwrite) NSString *eventType;
+
+@end
+
+@implementation RNSentianceSubscription
+
+- (instancetype)initWithEventType:(NSString *)eventType subscriptionId:(NSInteger)subscriptionId {
+    self = [super init];
+    if (self) {
+        self.eventType = eventType;
+        self.subscriptionId = subscriptionId;
+    }
+    return self;
+}
+
+@end

package/ios/RNSentianceSubscriptionDefinition.h

@@ -0,0 +1,32 @@
+//
+//  RNSentianceSubscriptionMapping.h
+//  Pods
+//
+//  Created by Mohammed Aouf Zouag on 27/3/2023.
+//
+
+#ifndef RNSentianceSubscriptionMapping_h
+#define RNSentianceSubscriptionMapping_h
+
+#import "RNSentianceFoundation.h"
+typedef NS_ENUM(NSUInteger, SENTSubscriptionType) {
+    SENTSubscriptionTypeSingle,
+    SENTSubscriptionTypeMultiple,
+};
+
+@interface RNSentianceSubscriptionDefinition : NSObject
+
+@property (nonatomic, strong, readonly) NSString *eventType;
+@property (nonatomic, strong, readonly) SentianceBlock nativeSubscribeLogic;
+@property (nonatomic, strong, readonly) SentianceBlock nativeUnsubscribeLogic;
+@property (nonatomic, readonly) SENTSubscriptionType subscriptionType;
+
+- (instancetype)init NS_UNAVAILABLE;
+- (instancetype)initWithEventType:(NSString *)eventType
+             nativeSubscribeLogic:(SentianceBlock)nativeSubscribeLogic
+           nativeUnsubscribeLogic:(SentianceBlock)nativeUnsubscribeLogic
+                 subscriptionType:(SENTSubscriptionType)subscriptionType NS_DESIGNATED_INITIALIZER;
+
+@end
+
+#endif /* RNSentianceSubscriptionMapping_h */

package/ios/RNSentianceSubscriptionDefinition.m

@@ -0,0 +1,36 @@
+//
+//  RNSentianceSubscriptionMapping.m
+//  DoubleConversion
+//
+//  Created by Mohammed Aouf Zouag on 27/3/2023.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNSentianceSubscriptionDefinition.h"
+
+@interface RNSentianceSubscriptionDefinition ()
+
+@property (nonatomic, strong, readwrite) NSString *eventType;
+@property (nonatomic, strong, readwrite) SentianceBlock nativeSubscribeLogic;
+@property (nonatomic, strong, readwrite) SentianceBlock nativeUnsubscribeLogic;
+@property (nonatomic, readwrite) SENTSubscriptionType subscriptionType;
+
+@end
+
+@implementation RNSentianceSubscriptionDefinition
+
+- (instancetype)initWithEventType:(NSString *)eventType
+             nativeSubscribeLogic:(SentianceBlock)nativeSubscribeLogic
+           nativeUnsubscribeLogic:(SentianceBlock)nativeUnsubscribeLogic
+                 subscriptionType:(SENTSubscriptionType)subscriptionType {
+    self = [super init];
+    if (self) {
+        self.eventType = eventType;
+        self.nativeSubscribeLogic = nativeSubscribeLogic;
+        self.nativeUnsubscribeLogic = nativeUnsubscribeLogic;
+        self.subscriptionType = subscriptionType;
+    }
+    return self;
+}
+
+@end

package/ios/RNSentianceSubscriptionsManager.h

@@ -0,0 +1,26 @@
+//
+//  SentianceSubscriptionsManager.h
+//  Pods
+//
+//  Created by Mohammed Aouf Zouag on 27/3/2023.
+//
+
+#ifndef SentianceSubscriptionsManager_h
+#define SentianceSubscriptionsManager_h
+
+#import "RNSentianceFoundation.h"
+#import "RNSentianceSubscriptionDefinition.h"
+#import <SENTSDK/SENTSDK.h>
+
+@interface RNSentianceSubscriptionsManager : NSObject
+
+- (void)addSupportedSubscriptionForEventType:(NSString *)eventType
+                        nativeSubscribeLogic:(SentianceBlock)nativeSubscribeLogic
+                      nativeUnsubscribeLogic:(SentianceBlock)nativeUnsubscribeLogic
+                            subscriptionType:(SENTSubscriptionType)subscriptionType;
+- (void)addSubscriptionForEventType:(NSString *)eventType subscriptionId:(NSInteger)subscriptionId;
+- (void)removeSubscriptionForId:(NSInteger)subscriptionId eventType:(NSString *)eventType;
+
+@end
+
+#endif /* SentianceSubscriptionsManager_h */

package/ios/RNSentianceSubscriptionsManager.m

@@ -0,0 +1,117 @@
+//
+//  SentianceSubscriptionsManager.m
+//  DoubleConversion
+//
+//  Created by Mohammed Aouf Zouag on 27/3/2023.
+//
+
+#import <Foundation/Foundation.h>
+#import "RNSentianceSubscriptionsManager.h"
+#import "RNSentianceSubscriptionDefinition.h"
+#import "RNSentianceSubscription.h"
+
+@interface RNSentianceSubscriptionsManager()
+
+@property (nonatomic, strong) NSMutableArray<RNSentianceSubscription*> *subscriptions;
+@property (nonatomic, strong) NSMutableDictionary<NSString *, RNSentianceSubscriptionDefinition *> *supportedSubscriptions;
+
+@end
+
+@implementation RNSentianceSubscriptionsManager
+
+- (instancetype)init {
+    self = [super init];
+    _subscriptions = [[NSMutableArray alloc] init];
+    _supportedSubscriptions = [[NSMutableDictionary alloc] init];
+    return self;
+}
+
+- (void)addSupportedSubscriptionForEventType:(NSString *)eventType
+                        nativeSubscribeLogic:(SentianceBlock)nativeSubscribeLogic
+                      nativeUnsubscribeLogic:(SentianceBlock)nativeUnsubscribeLogic
+                            subscriptionType:(SENTSubscriptionType)subscriptionType {
+    @synchronized (_subscriptions) {
+        if (_supportedSubscriptions[eventType] == nil) {
+            RNSentianceSubscriptionDefinition *definition =
+                [[RNSentianceSubscriptionDefinition alloc]initWithEventType:eventType
+                                                             nativeSubscribeLogic:nativeSubscribeLogic
+                                                           nativeUnsubscribeLogic:nativeUnsubscribeLogic
+                                                           subscriptionType:subscriptionType];
+            _supportedSubscriptions[eventType] = definition;
+        }
+    }
+}
+
+- (void)addSubscriptionForEventType:(NSString *)eventType subscriptionId:(NSInteger)subscriptionId {
+    RNSentianceSubscriptionDefinition *definition = _supportedSubscriptions[eventType];
+    
+    if (definition != nil) {
+        if ([self _shouldSubscribeNatively:definition]) {
+            definition.nativeSubscribeLogic();
+        }
+
+        RNSentianceSubscription *subscription = [[RNSentianceSubscription alloc]initWithEventType:eventType
+                                                                                   subscriptionId:subscriptionId];
+        
+        @synchronized (_subscriptions) {
+            [_subscriptions addObject:subscription];
+        }
+    }
+}
+
+- (void)removeSubscriptionForId:(NSInteger)subscriptionId eventType:(NSString *)eventType {
+    RNSentianceSubscriptionDefinition *definition = _supportedSubscriptions[eventType];
+    
+    if (definition != nil) {
+        RNSentianceSubscription *subscription = [self _getExistingSubscriptionWithId:subscriptionId eventType:eventType];
+        if (subscription != nil) {
+            @synchronized (_subscriptions) {
+                [_subscriptions removeObject:subscription];
+            }
+            
+            if ([self _shouldUnsubscribeNatively:definition]) {
+                definition.nativeUnsubscribeLogic();
+            }
+        }
+    }
+}
+
+- (nullable RNSentianceSubscription *)_getExistingSubscriptionWithId:(NSInteger)subscriptionId eventType:(NSString *)eventType {
+    @synchronized (_subscriptions) {
+        for (RNSentianceSubscription *subscription in _subscriptions) {
+            if (subscription.subscriptionId == subscriptionId && [eventType isEqualToString:subscription.eventType]) {
+                return subscription;
+            }
+        }
+        return nil;
+    }
+}
+
+- (BOOL)_shouldSubscribeNatively:(RNSentianceSubscriptionDefinition*)definition {
+    return [self _shouldInvokeNativeLogic:definition];
+}
+
+- (BOOL)_shouldUnsubscribeNatively:(RNSentianceSubscriptionDefinition*)definition {
+    return [self _shouldInvokeNativeLogic:definition];
+}
+
+- (BOOL)_shouldInvokeNativeLogic:(RNSentianceSubscriptionDefinition*)definition {
+    if (definition.subscriptionType == SENTSubscriptionTypeMultiple) {
+        return true;
+    }
+
+    return definition.subscriptionType == SENTSubscriptionTypeSingle && [self _subscriptionExists:definition.eventType] == NO;
+}
+
+- (BOOL)_subscriptionExists:(NSString *)eventType {
+    @synchronized (_subscriptions) {
+        for (RNSentianceSubscription *subscription in _subscriptions) {
+            if ([subscription.eventType isEqualToString:eventType]) {
+                return YES;
+            }
+        }
+        return NO;
+    }
+}
+
+@end

package/lib/SentianceEventEmitter.js

@@ -0,0 +1,75 @@
+import {EmitterSubscription, NativeEventEmitter, Platform} from "react-native";
+
+class SentianceEventEmitter extends NativeEventEmitter {
+
+  constructor(nativeModule) {
+    super(nativeModule);
+
+    const bindings = this.requireNativeBindings(nativeModule);
+    this._addNativeListener = bindings.addNativeListener;
+    this._removeNativeListener = bindings.removeNativeListener;
+  }
+
+  requireNativeBindings(nativeModule) {
+    if (!nativeModule) {
+      throw new Error('Native module cannot have a null value.');
+    }
+    if (Platform.OS === 'android') {
+      return this.requireAndroidBindings(nativeModule);
+    } else {
+      return this.requireIosBindings(nativeModule);
+    }
+  }
+
+  requireAndroidBindings(nativeModule) {
+    const hasAddListener = typeof nativeModule.addListener === 'function';
+    const hasRemoveListener = typeof nativeModule.removeListener === 'function';
+
+    if (!hasAddListener) {
+      throw new Error('Native Android module does not expose an addListener function');
+    }
+    if (!hasRemoveListener) {
+      throw new Error('Native Android module does not expose a removeListener function');
+    }
+
+    return {
+      addNativeListener: nativeModule.addListener,
+      removeNativeListener: nativeModule.removeListener
+    };
+  }
+
+  requireIosBindings(nativeModule) {
+    const hasAddListener = typeof nativeModule.addNativeListener === 'function';
+    const hasRemoveListener = typeof nativeModule.removeNativeListener === 'function';
+
+    if (!hasAddListener) {
+      throw new Error('Native iOS module does not expose an addNativeListener function');
+    }
+    if (!hasRemoveListener) {
+      throw new Error('Native iOS module does not expose a removeNativeListener function');
+    }
+
+    return {
+      addNativeListener: nativeModule.addNativeListener,
+      removeNativeListener: nativeModule.removeNativeListener
+    };
+  }
+
+  async addListener(eventType, listener, context): EmitterSubscription {
+    const subscription = super.addListener(eventType, listener, context);
+    await this._addNativeListener(eventType, subscription.key);
+    return subscription;
+  }
+
+  async clearSubscription(eventType, subscription) {
+    if (super.removeSubscription != null) {
+      super.removeSubscription(subscription);
+    } else {
+      // RN 0.64+ no longer provides a removeSubscription function
+      subscription.remove();
+    }
+    await this._removeNativeListener(eventType, subscription.key);
+  }
+}
+
+module.exports = SentianceEventEmitter;

package/lib/SentianceEventListenerUtils.js

@@ -0,0 +1,12 @@
+const SentianceEventEmitter = require("@sentiance-react-native/core/lib/SentianceEventEmitter");
+
+exports.createEventListener = async (eventName: String, emitter: SentianceEventEmitter, callback: Function) => {
+  const listener = (data) => {
+    callback(data);
+  };
+  const subscription = await emitter.addListener(eventName, listener);
+  subscription.remove = async function () {
+    await emitter.clearSubscription(eventName, subscription);
+  }
+  return subscription;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentiance-react-native/core",
-  "version": "6.3.0-rc.2",
+  "version": "6.3.0",
   "description": "React Native Sentiance core library",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -29,10 +29,10 @@
       "targetSdk": 31,
       "compileSdk": 31,
       "buildTools": "30.0.3",
-      "sentiance": "6.3.0-rc1"
+      "sentiance": "6.3.+"
     },
     "ios": {
-      "sentiance": "~> 6.3.0-rc2"
+      "sentiance": "~> 6.3.0"
     }
   }
 }