@sentiance-react-native/user-context 6.11.0-rc.1 → 6.11.0

package/android/src/main/java/com/sentiance/react/bridge/usercontext/SentianceUserContextEmitter.java

@@ -10,9 +10,9 @@ import com.sentiance.sdk.usercontext.api.UserContextUpdateCriteria;
 
 import java.util.List;
 
-class SentianceUserContextEmitter extends AbstractSentianceEmitter {
+public class SentianceUserContextEmitter extends AbstractSentianceEmitter {
 
-  private static final String USER_CONTEXT_EVENT = "SENTIANCE_USER_CONTEXT_UPDATE_EVENT";
+  static final String USER_CONTEXT_EVENT = "SENTIANCE_USER_CONTEXT_UPDATE_EVENT";
   private final SentianceUserContextConverter converter;
 
   public SentianceUserContextEmitter(Context context) {

package/android/src/main/java/com/sentiance/react/bridge/usercontext/SentianceUserContextModule.java

@@ -1,15 +1,19 @@
 package com.sentiance.react.bridge.usercontext;
 
+import static com.sentiance.react.bridge.usercontext.SentianceUserContextEmitter.USER_CONTEXT_EVENT;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
 import com.sentiance.react.bridge.core.common.SentianceSubscriptionsManager;
 import com.sentiance.react.bridge.core.common.base.AbstractSentianceModule;
 import com.sentiance.react.bridge.usercontext.utils.ErrorCodes;
 import com.sentiance.sdk.Sentiance;
+import com.sentiance.sdk.pendingoperation.PendingOperation;
 import com.sentiance.sdk.usercontext.api.RequestUserContextError;
 import com.sentiance.sdk.usercontext.api.UserContext;
 import com.sentiance.sdk.usercontext.api.UserContextApi;
@@ -17,82 +21,97 @@ import com.sentiance.sdk.usercontext.api.UserContextUpdateListener;
 
 public class SentianceUserContextModule extends AbstractSentianceModule {
 
-  private static final String NATIVE_MODULE_NAME = "SentianceUserContext";
-
-  private final SentianceUserContextEmitter emitter;
-  private final SentianceUserContextConverter converter;
-  private @Nullable
-  UserContextUpdateListener mUserContextUpdateListener;
-
-  public SentianceUserContextModule(ReactApplicationContext reactContext) {
-    super(reactContext, Sentiance.getInstance(reactContext), new SentianceSubscriptionsManager());
-    emitter = new SentianceUserContextEmitter(reactContext);
-    converter = new SentianceUserContextConverter();
-  }
-
-  @NonNull
-  @Override
-  public String getName() {
-    return NATIVE_MODULE_NAME;
-  }
-
-  @ReactMethod
-  @SuppressWarnings("unused")
-  public void requestUserContext(final Promise promise) {
-    if (rejectIfNotInitialized(promise)) {
-      return;
+    private static final String NATIVE_MODULE_NAME = "SentianceUserContext";
+    static final String JS_PAYLOAD_KEY_INCLUDE_PROVISIONAL_EVENTS = "includeProvisionalEvents";
+
+    private final SentianceUserContextEmitter mEmitter;
+    private final SentianceUserContextConverter mConverter;
+    private final UserContextApi mUserContextApi;
+
+    public SentianceUserContextModule(ReactApplicationContext reactContext,
+                                      Sentiance sentiance,
+                                      SentianceSubscriptionsManager subscriptionsManager,
+                                      SentianceUserContextEmitter emitter,
+                                      SentianceUserContextConverter converter,
+                                      UserContextApi userContextApi) {
+        super(reactContext, sentiance, subscriptionsManager);
+        mEmitter = emitter;
+        mConverter = converter;
+        mUserContextApi = userContextApi;
     }
 
-    UserContextApi.getInstance(mReactContext)
-      .requestUserContext()
-      .addOnCompleteListener(pendingOperation -> {
-        if (pendingOperation.isSuccessful()) {
-          UserContext userContext = pendingOperation.getResult();
-          promise.resolve(converter.convertUserContext(userContext));
-        } else {
-          RequestUserContextError error = pendingOperation.getError();
-          promise.reject(ErrorCodes.E_SDK_REQUEST_USER_CONTEXT_ERROR,
-            converter.stringifyGetUserContextError(error));
-        }
-      });
-  }
-
-  @ReactMethod
-  @SuppressWarnings("unused")
-  public void listenUserContextUpdates(Promise promise) {
-    if (rejectIfNotInitialized(promise)) {
-      return;
+    @Override
+    protected void addSupportedEventSubscriptions(SentianceSubscriptionsManager subscriptionsManager) {
+        mSubscriptionsManager.addSupportedSubscription(
+            USER_CONTEXT_EVENT,
+            mUserContextApi::addProvisionalAwareUserContextUpdateListener,
+            mUserContextApi::removeUserContextUpdateListener,
+            SentianceSubscriptionsManager.SubscriptionType.MULTIPLE
+        );
     }
 
-    UserContextApi userContextApi = UserContextApi.getInstance(mReactContext);
-
-    if (mUserContextUpdateListener != null) {
-      userContextApi.removeUserContextUpdateListener(mUserContextUpdateListener);
+    @NonNull
+    @Override
+    public String getName() {
+        return NATIVE_MODULE_NAME;
     }
 
-    mUserContextUpdateListener = emitter::sendUserContext;
+    @ReactMethod
+    @SuppressWarnings("unused")
+    public void requestUserContext(final boolean includeProvisionalEvents, final Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
 
-    userContextApi.addUserContextUpdateListener(mUserContextUpdateListener);
-    promise.resolve(true);
-  }
+        PendingOperation<UserContext, RequestUserContextError> userContextRequest =
+            includeProvisionalEvents ? mUserContextApi.requestUserContextIncludingProvisionalEvents()
+                : mUserContextApi.requestUserContext();
+
+        userContextRequest.addOnCompleteListener(pendingOperation -> {
+            if (pendingOperation.isSuccessful()) {
+                UserContext userContext = pendingOperation.getResult();
+                promise.resolve(mConverter.convertUserContext(userContext));
+            } else {
+                RequestUserContextError error = pendingOperation.getError();
+                promise.reject(ErrorCodes.E_SDK_REQUEST_USER_CONTEXT_ERROR,
+                    mConverter.stringifyGetUserContextError(error));
+            }
+        });
+    }
 
-  @Override
-  @ReactMethod
-  protected void addNativeListener(String eventName, int subscriptionId, Promise promise) {
+    @Override
+    @ReactMethod
+    protected void addNativeListener(String eventName, int subscriptionId, @Nullable ReadableMap payload, Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
 
-  }
+        switch (eventName) {
+            case USER_CONTEXT_EVENT:
+                mSubscriptionsManager.addSubscription(eventName, subscriptionId, (UserContextUpdateListener) mEmitter::sendUserContext);
+                break;
+        }
+        promise.resolve(null);
+    }
 
-  @Override
-  @ReactMethod
-  protected void removeNativeListener(String eventName, int subscriptionId, Promise promise) {
+    @Override
+    @ReactMethod
+    protected void removeNativeListener(String eventName, int subscriptionId, Promise promise) {
+        if (rejectIfNotInitialized(promise)) {
+            return;
+        }
 
-  }
+        mSubscriptionsManager.removeSubscription(subscriptionId, eventName);
+        promise.resolve(null);
+    }
 
-  @Override
-  @ReactMethod
-  protected void addListener(String eventName) {}
+    @Override
+    @ReactMethod
+    protected void addListener(String eventName) {
+    }
 
-  @Override
-  @ReactMethod
-  public void removeListeners(Integer count) {}
+    @Override
+    @ReactMethod
+    public void removeListeners(Integer count) {
+    }
 }

package/android/src/main/java/com/sentiance/react/bridge/usercontext/SentianceUserContextPackage.java

@@ -6,6 +6,9 @@ import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
+import com.sentiance.react.bridge.core.common.SentianceSubscriptionsManager;
+import com.sentiance.sdk.Sentiance;
+import com.sentiance.sdk.usercontext.api.UserContextApi;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -13,18 +16,25 @@ import java.util.List;
 
 public class SentianceUserContextPackage implements ReactPackage {
 
-  @NonNull
-  @Override
-  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
-    List<NativeModule> modules = new ArrayList<>();
-    SentianceUserContextModule module = new SentianceUserContextModule(reactContext);
-    modules.add(module);
-    return modules;
-  }
+	@NonNull
+	@Override
+	public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+		List<NativeModule> modules = new ArrayList<>();
+		SentianceUserContextModule module = new SentianceUserContextModule(
+			reactContext,
+			Sentiance.getInstance(reactContext),
+			new SentianceSubscriptionsManager(),
+			new SentianceUserContextEmitter(reactContext),
+			new SentianceUserContextConverter(),
+			UserContextApi.getInstance(reactContext)
+		);
+		modules.add(module);
+		return modules;
+	}
 
-  @NonNull
-  @Override
-  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
-    return Collections.emptyList();
-  }
+	@NonNull
+	@Override
+	public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+		return Collections.emptyList();
+	}
 }

package/lib/index.d.ts

@@ -193,6 +193,22 @@ declare module "@sentiance-react-native/user-context" {
     endTimeEpoch: number | null; // in milliseconds
     durationInSeconds: number | null;
     type: string;
+    /**
+     * Indicates whether the event is provisional.
+     *
+     * <p>A provisional event is identified based on real-time detections, but may change in the near future
+     * as more data is collected and processed, to filter out unwanted artifacts.
+     * For example, a provisional car transport may get identified, followed by a provisional bus transport.
+     * After the full trip is complete, these provisional events may get merged into a single final car event.</p>
+     *
+     * <p>Final events are generated independently of the provisional events, and have unique event IDs. They are
+     * not linked to the provisional events they may resemble, replace, or overlap with.</p>
+     *
+     * <p>Currently, provisional events apply only to 'transport' types, as the SDK tries to determine the mode of
+     * transport in (near) real time. When the full trip is complete (e.g. the user becomes stationary),
+     * the collected data is reprocessed to produce a more accurate and cleaned up list of transport events.</p>
+     */
+    isProvisional: boolean;
     // stationary event fields
     location: GeoLocation | null;
     venue: Venue | null;
@@ -260,10 +276,11 @@ declare module "@sentiance-react-native/user-context" {
   }
 
   export interface SentianceUserContext {
-    requestUserContext(): Promise<UserContext>;
+    requestUserContext(includeProvisionalEvents?: boolean): Promise<UserContext>;
 
     addUserContextUpdateListener(
-      onUserContextUpdated: (userContextUpdate: UserContextUpdate) => void
+      onUserContextUpdated: (userContextUpdate: UserContextUpdate) => void,
+      includeProvisionalEvents?: boolean
     ): Promise<EmitterSubscription>;
   }
 

package/lib/index.js

@@ -1,9 +1,16 @@
-const userContext = require('./user-context');
+const userContext = require("./user-context");
 
-const requestUserContext = () => userContext.requestUserContext();
-const addUserContextUpdateListener = userContext._addUserContextUpdateListener;
+const requestUserContext = (includeProvisionalEvents) => {
+  // See: https://github.com/facebook/react-native/issues/24250
+  return userContext.requestUserContext(!!includeProvisionalEvents);
+};
+const addUserContextUpdateListener = (listener, includeProvisionalEvents) =>
+  userContext._addUserContextUpdateListener(listener, !!includeProvisionalEvents);
 
 module.exports = {
   requestUserContext,
   addUserContextUpdateListener
 };
+module.exports.events = {
+  USER_CONTEXT_UPDATE_EVENT: userContext.events.USER_CONTEXT_UPDATE_EVENT
+};

package/lib/user-context.js

@@ -1,40 +1,61 @@
-const {NativeModules, NativeEventEmitter, Platform} = require("react-native");
-const {varToString} = require("@sentiance-react-native/core/lib/utils")
-const {SentianceUserContext, SentianceCore} = NativeModules;
+const { NativeModules, Platform } = require("react-native");
+const { varToString } = require("@sentiance-react-native/core/lib/generated/utils");
+const SentianceEventEmitter = require("@sentiance-react-native/core/lib/generated/sentiance-event-emitter").default;
+const { SentianceUserContext, SentianceCore } = NativeModules;
 
+const allUserContextCriteria = ["CURRENT_EVENT", "ACTIVE_SEGMENTS", "VISITED_VENUES"];
 const SDK_USER_CONTEXT_UPDATE_EVENT = "SENTIANCE_USER_CONTEXT_UPDATE_EVENT";
 
 let didLocateNativeModule = true;
 let userContextModule = {};
-if (Platform.OS === 'android') {
+if (Platform.OS === "android") {
   if (!SentianceUserContext) {
     didLocateNativeModule = false;
-    const nativeModuleName = varToString({SentianceUserContext});
+    const nativeModuleName = varToString({ SentianceUserContext });
     console.error(`Could not locate the native ${nativeModuleName} module.
     Make sure that your native code is properly linked, and that the module name you specified is correct.`);
   } else {
-    userContextModule = SentianceUserContext
+    userContextModule = SentianceUserContext;
   }
 } else {
   if (!SentianceCore) {
     didLocateNativeModule = false;
-    const nativeModuleName = varToString({SentianceCore});
+    const nativeModuleName = varToString({ SentianceCore });
     console.error(`Could not locate the native ${nativeModuleName} module.
     Make sure that your native code is properly linked, and that the module name you specified is correct.`);
   } else {
-    userContextModule = SentianceCore
+    userContextModule = SentianceCore;
   }
 }
 
 if (didLocateNativeModule) {
-  const SENTIANCE_EMITTER = new NativeEventEmitter(userContextModule);
+  const emitter = new SentianceEventEmitter(userContextModule);
 
-  userContextModule._addUserContextUpdateListener = async (onUserContextUpdated) => {
-    await userContextModule.listenUserContextUpdates();
-    return SENTIANCE_EMITTER.addListener(SDK_USER_CONTEXT_UPDATE_EVENT, (data) => {
-      onUserContextUpdated(data);
-    });
+  userContextModule._addUserContextUpdateListener = async (onUserContextUpdated, includeProvisionalEvents) => {
+    const payload = {
+      includeProvisionalEvents: true
+    };
+    return emitter.addListener(
+      SDK_USER_CONTEXT_UPDATE_EVENT,
+      async function(update) {
+        if (includeProvisionalEvents) {
+          // If the JS listener is interested in provisional events, we deliver the update as is
+          onUserContextUpdated(update);
+        } else {
+          // Otherwise, we query for a fresh user context without provisional events
+          const userContext = await userContextModule.requestUserContext(false);
+          onUserContextUpdated({
+            userContext,
+            criteria: allUserContextCriteria
+          });
+        }
+      },
+      payload
+    );
   };
 }
 
 module.exports = userContextModule;
+module.exports.events = {
+  USER_CONTEXT_UPDATE_EVENT: SDK_USER_CONTEXT_UPDATE_EVENT
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentiance-react-native/user-context",
-  "version": "6.11.0-rc.1",
+  "version": "6.11.0",
   "description": "The Sentiance User Context library",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -14,7 +14,7 @@
     "sentiance"
   ],
   "peerDependencies": {
-    "@sentiance-react-native/core": "6.11.0-rc.1"
+    "@sentiance-react-native/core": "6.11.0"
   },
   "author": "",
   "license": "",