@sentiance-react-native/user-context 6.0.0-beta.9

package/README.md

@@ -0,0 +1,26 @@
+## Installation
+
+```bash
+npm i @sentiance-react-native/core
+
+npm i @sentiance-react-native/user-context
+```
+
+## Usage
+
+### Importing the package
+
+You can import the entire contents of the package for use under a namespace of your choosing:
+
+```javascript
+import * as SentianceUserContext from "@sentiance-react-native/user-context";
+```
+
+or you can require specific functionality using named imports:
+
+```javascript
+import {
+    getUserContext,
+    listenUserContextUpdates
+} from "@sentiance-react-native/user-context";
+```

package/android/build.gradle

@@ -0,0 +1,32 @@
+plugins {
+  id "com.android.library"
+}
+
+def coreProj
+if (findProject(':core')) {
+  coreProj = project(':core')
+} else if (findProject(':sentiance-react-native_core')) {
+  // Starting from RN 0.61, the @ sign is stripped from project names
+  coreProj = project(':sentiance-react-native_core')
+} else if (findProject(':@sentiance-react-native_core')) {
+  // On RN 0.60, the @ sign is not stripped from project names
+  coreProj = project(':@sentiance-react-native_core')
+} else {
+  throw new GradleException('Could not find the @sentiance-react-native/core package, have you installed it?')
+}
+
+apply from: "$coreProj.projectDir/package-json-reader.gradle"
+apply from: "$coreProj.projectDir/sentiance-version-finder.gradle"
+
+def corePackageJson = PackageJson.of(coreProj)
+applyAndroidVersionsFrom(corePackageJson)
+def sentianceSdkVersion = getSentianceSdkVersion()
+
+dependencies {
+  api coreProj
+
+  implementation(platform("com.sentiance:sdk-bom:${sentianceSdkVersion}"))
+  api("com.sentiance:sdk-user-context") { transitive = true }
+}
+
+applyReactNativeDependency()

package/android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.9-all.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/android/gradle.properties

@@ -0,0 +1,2 @@
+android.useAndroidX=true
+android.enableJetifier=true

package/android/gradlew

@@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"

package/android/gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest package="com.sentiance.react.bridge.usercontext">
+</manifest>

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

@@ -0,0 +1,210 @@
+package com.sentiance.react.bridge.usercontext;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.sentiance.sdk.ondevice.api.Attribute;
+import com.sentiance.sdk.ondevice.api.GeoLocation;
+import com.sentiance.sdk.ondevice.api.event.Event;
+import com.sentiance.sdk.ondevice.api.event.StationaryEvent;
+import com.sentiance.sdk.ondevice.api.event.TransportEvent;
+import com.sentiance.sdk.ondevice.api.segment.Segment;
+import com.sentiance.sdk.ondevice.api.venue.Venue;
+import com.sentiance.sdk.ondevice.api.venue.VenueCandidate;
+import com.sentiance.sdk.ondevice.api.venue.Visit;
+import com.sentiance.sdk.usercontext.api.RequestUserContextError;
+import com.sentiance.sdk.usercontext.api.RequestUserContextFailureReason;
+import com.sentiance.sdk.usercontext.api.UserContext;
+import com.sentiance.sdk.usercontext.api.UserContextUpdateCriteria;
+import com.sentiance.sdk.util.DateTime;
+
+import java.util.List;
+import java.util.Map;
+
+public class SentianceUserContextConverter {
+
+  public static WritableMap convertGeoLocation(GeoLocation location) {
+    WritableMap locationMap = Arguments.createMap();
+
+    locationMap.putString("latitude", String.valueOf(location.getLatitude()));
+    locationMap.putString("longitude", String.valueOf(location.getLongitude()));
+    locationMap.putString("accuracy", String.valueOf(location.getAccuracyInMeters()));
+
+    return locationMap;
+  }
+
+  private static WritableMap convertSegment(Segment segment) {
+    WritableMap map = Arguments.createMap();
+
+    map.putString("category", segment.getCategory().name());
+    map.putString("subcategory", segment.getSubcategory().name());
+    map.putString("type", segment.getType().name());
+    map.putInt("id", segment.getType().getUniqueId());
+    map.putString("startTime", segment.getStartTime().toString());
+    map.putString("startTimeEpoch", "" + segment.getStartTime().getEpochTime() / 1000);
+
+    DateTime endTime = segment.getEndTime();
+    if (endTime != null) {
+      map.putString("endTime", endTime.toString());
+      map.putString("endTimeEpoch", "" + segment.getEndTime().getEpochTime() / 1000);
+    }
+
+    WritableArray attributes = Arguments.createArray();
+    for (Attribute attribute : segment.getAttributes()) {
+      WritableMap a = Arguments.createMap();
+      a.putString("name", attribute.getName());
+      a.putDouble("value", attribute.getValue());
+      attributes.pushMap(a);
+    }
+    map.putArray("attributes", attributes);
+
+    return map;
+  }
+
+  private static WritableMap convertEvent(Event event) {
+    WritableMap map = Arguments.createMap();
+
+    map.putString("startTime", event.getStartTime().toString());
+    if (event.getEndTime() != null) {
+      map.putString("endTime", event.getEndTime().toString());
+
+      Long durationInSeconds = event.getDurationInSeconds();
+      if (durationInSeconds != null) {
+        map.putInt("durationInSeconds", (int) (long) durationInSeconds);
+      }
+    }
+
+    map.putString("type", event.getEventType().toString());
+
+    if (event instanceof StationaryEvent) {
+      addStationaryEventInfo(map, (StationaryEvent) event);
+    } else if (event instanceof TransportEvent) {
+      addTransportEventInfo(map, (TransportEvent) event);
+    }
+
+    return map;
+  }
+
+  public static WritableArray convertCriteriaList(List<UserContextUpdateCriteria> criteria) {
+    WritableArray array = Arguments.createArray();
+    for (UserContextUpdateCriteria criterion : criteria) {
+      array.pushString(criterion.toString());
+    }
+    return array;
+  }
+
+  public static WritableMap convertUserContext(UserContext userContext) {
+    WritableMap userContextMap = Arguments.createMap();
+
+    // Events
+    WritableArray eventArray = Arguments.createArray();
+    for (Event event : userContext.getEvents()) {
+      eventArray.pushMap(convertEvent(event));
+    }
+    userContextMap.putArray("events", eventArray);
+
+    // Segments
+    WritableArray segmentsArray = Arguments.createArray();
+    for (Segment segment : userContext.getActiveSegments()) {
+      segmentsArray.pushMap(convertSegment(segment));
+    }
+    userContextMap.putArray("activeSegments", segmentsArray);
+
+    // Last know location
+    if (userContext.getLastKnownLocation() != null) {
+      userContextMap.putMap("lastKnownLocation", convertGeoLocation(userContext.getLastKnownLocation()));
+    }
+
+    // Home
+    if (userContext.getHome() != null) {
+      userContextMap.putMap("home", convertVenue(userContext.getHome()));
+    }
+
+    // Work
+    if (userContext.getWork() != null) {
+      userContextMap.putMap("work", convertVenue(userContext.getWork()));
+    }
+
+    return userContextMap;
+  }
+
+  public static String stringifyGetUserContextError(RequestUserContextError error) {
+    RequestUserContextFailureReason reason = error.getReason();
+    String details = "";
+    switch (reason) {
+      case NO_USER:
+        details = "No Sentiance user present on the device.";
+        break;
+      case FEATURE_NOT_ENABLED:
+        details = "Feature not enabled. Contact Sentiance support to enable it.";
+        break;
+      case USER_DISABLED_REMOTELY:
+        details = "The user is disabled remotely.";
+        break;
+    }
+    return String.format("Reason: %s - %s", reason.name(), details);
+  }
+
+  private static void addStationaryEventInfo(WritableMap map, StationaryEvent event) {
+    if (event.getLocation() != null) {
+      map.putMap("location", convertGeoLocation(event.getLocation()));
+    }
+
+    map.putString("venueSignificance", event.getVenueSignificance().toString());
+
+    WritableArray venueCandidatesArray = Arguments.createArray();
+    for (VenueCandidate candidate : event.getVenueCandidates()) {
+      venueCandidatesArray.pushMap(convertVenueCandidate(candidate));
+    }
+
+    map.putArray("venueCandidates", venueCandidatesArray);
+  }
+
+  private static WritableMap convertVenueCandidate(VenueCandidate candidate) {
+    WritableMap venueCandidateMap = Arguments.createMap();
+    venueCandidateMap.putMap("venue", convertVenue(candidate.getVenue()));
+    venueCandidateMap.putDouble("likelihood", candidate.getLikelihood());
+
+    WritableArray visitsArray = Arguments.createArray();
+    for (Visit visit : candidate.getVisits()) {
+      visitsArray.pushMap(convertVisit(visit));
+    }
+    venueCandidateMap.putArray("visits", visitsArray);
+    return venueCandidateMap;
+  }
+
+  private static WritableMap convertVenue(Venue venue) {
+    WritableMap venueMap = Arguments.createMap();
+
+    if (venue.getName() != null) {
+      venueMap.putString("name", venue.getName());
+    }
+
+    venueMap.putMap("location", convertGeoLocation(venue.getLocation()));
+
+    WritableMap venueLabelsMap = Arguments.createMap();
+    for (Map.Entry<String, String> entry : venue.getLabels().entrySet()) {
+      venueLabelsMap.putString(entry.getKey(), entry.getValue());
+    }
+    venueMap.putMap("venueLabels", venueLabelsMap);
+
+    return venueMap;
+  }
+
+  private static WritableMap convertVisit(Visit visit) {
+    WritableMap visitMap = Arguments.createMap();
+    visitMap.putString("startTime", visit.getStartTime().toString());
+    visitMap.putString("startTimeEpoch", "" + visit.getStartTime().getEpochTime());
+
+    visitMap.putString("endTime", visit.getEndTime().toString());
+    visitMap.putString("endTimeEpoch", "" + visit.getEndTime().getEpochTime());
+
+    visitMap.putInt("durationInSeconds", (int) visit.getDurationInSeconds());
+
+    return visitMap;
+  }
+
+  private static void addTransportEventInfo(WritableMap map, TransportEvent event) {
+    map.putString("transportMode", event.getTransportMode().toString());
+  }
+}

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

@@ -0,0 +1,31 @@
+package com.sentiance.react.bridge.usercontext;
+
+import static com.sentiance.react.bridge.usercontext.SentianceUserContextConverter.convertCriteriaList;
+import static com.sentiance.react.bridge.usercontext.SentianceUserContextConverter.convertUserContext;
+
+import android.content.Context;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.sentiance.react.bridge.core.base.AbstractSentianceEmitter;
+import com.sentiance.sdk.usercontext.api.UserContext;
+import com.sentiance.sdk.usercontext.api.UserContextUpdateCriteria;
+
+import java.util.List;
+
+class SentianceUserContextEmitter extends AbstractSentianceEmitter {
+
+  private static final String USER_CONTEXT_EVENT = "SENTIANCE_USER_CONTEXT_UPDATE_EVENT";
+
+  public SentianceUserContextEmitter(Context context) {
+    super(context);
+  }
+
+  void sendUserContext(List<UserContextUpdateCriteria> criteria, UserContext userContext) {
+    WritableMap map = Arguments.createMap();
+    map.putMap("userContext", convertUserContext(userContext));
+    map.putArray("criteria", convertCriteriaList(criteria));
+
+    sendEvent(USER_CONTEXT_EVENT, map);
+  }
+}

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

@@ -0,0 +1,74 @@
+package com.sentiance.react.bridge.usercontext;
+
+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.sentiance.react.bridge.core.base.AbstractSentianceModule;
+import com.sentiance.react.bridge.usercontext.utils.ErrorCodes;
+import com.sentiance.sdk.usercontext.api.RequestUserContextError;
+import com.sentiance.sdk.usercontext.api.UserContext;
+import com.sentiance.sdk.usercontext.api.UserContextApi;
+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 @Nullable
+  UserContextUpdateListener mUserContextUpdateListener;
+
+  public SentianceUserContextModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    emitter = new SentianceUserContextEmitter(reactContext);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NATIVE_MODULE_NAME;
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void requestUserContext(final Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    UserContextApi.getInstance(reactContext)
+      .requestUserContext()
+      .addOnCompleteListener(pendingOperation -> {
+        if (pendingOperation.isSuccessful()) {
+          UserContext userContext = pendingOperation.getResult();
+          promise.resolve(SentianceUserContextConverter.convertUserContext(userContext));
+        } else {
+          RequestUserContextError error = pendingOperation.getError();
+          promise.reject(ErrorCodes.E_SDK_REQUEST_USER_CONTEXT_ERROR,
+            SentianceUserContextConverter.stringifyGetUserContextError(error));
+        }
+      });
+  }
+
+  @ReactMethod
+  @SuppressWarnings("unused")
+  public void listenUserContextUpdates(Promise promise) {
+    if (rejectIfNotInitialized(promise)) {
+      return;
+    }
+
+    UserContextApi userContextApi = UserContextApi.getInstance(reactContext);
+
+    if (mUserContextUpdateListener != null) {
+      userContextApi.removeUserContextUpdateListener(mUserContextUpdateListener);
+    }
+
+    mUserContextUpdateListener = emitter::sendUserContext;
+
+    userContextApi.addUserContextUpdateListener(mUserContextUpdateListener);
+    promise.resolve(true);
+  }
+}

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

@@ -0,0 +1,30 @@
+package com.sentiance.react.bridge.usercontext;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+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<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

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

@@ -0,0 +1,5 @@
+package com.sentiance.react.bridge.usercontext.utils;
+
+public class ErrorCodes {
+  public static final String E_SDK_REQUEST_USER_CONTEXT_ERROR = "E_SDK_REQUEST_USER_CONTEXT_ERROR";
+}

package/lib/index.d.ts

@@ -0,0 +1,198 @@
+declare module "sentiance-react-native-user-context" {
+  import {EmitterSubscription} from "react-native";
+
+  export type SegmentCategory = "LEISURE" | "MOBILITY" | "WORK_LIFE";
+  export type SegmentSubcategory =
+    "COMMUTE"
+    | "DRIVING"
+    | "ENTERTAINMENT"
+    | "FAMILY"
+    | "HOME"
+    | "SHOPPING"
+    | "SOCIAL"
+    | "TRANSPORT"
+    | "TRAVEL"
+    | "WELLBEING"
+    | "WINING_AND_DINING"
+    | "WORK";
+  export type SegmentType =
+    "AGGRESSIVE_DRIVER"
+    | "ANTICIPATIVE_DRIVER"
+    | "BAR_GOER"
+    | "BEAUTY_QUEEN"
+    | "BRAND_LOYAL__BAR"
+    | "BRAND_LOYAL__CAFE"
+    |
+    "BRAND_LOYAL__RESTAURANT"
+    | "BRAND_LOYAL__RETAIL"
+    | "BRAND_LOYALTY"
+    | "BRAND_LOYALTY__GAS_STATIONS"
+    |
+    "BRAND_LOYALTY__RESTAURANT_BAR"
+    | "BRAND_LOYALTY__SUPERMARKET"
+    | "CITY_DRIVER"
+    | "CITY_HOME"
+    | "CITY_WORKER"
+    |
+    "CLUBBER"
+    | "CULTURE_BUFF"
+    | "DIE_HARD_DRIVER"
+    | "DISTRACTED_DRIVER"
+    | "DO_IT_YOURSELVER"
+    | "DOG_WALKER"
+    | "EARLY_BIRD"
+    |
+    "EASY_COMMUTER"
+    | "EFFICIENT_DRIVER"
+    | "FASHIONISTA"
+    | "FOODIE"
+    | "FREQUENT_FLYER"
+    | "FULLTIME_WORKER"
+    | "GAMER"
+    |
+    "GREEN_COMMUTER"
+    | "HEALTHY_BIKER"
+    | "HEALTHY_WALKER"
+    | "HEAVY_COMMUTER"
+    | "HOME_BOUND"
+    | "HOMEBODY"
+    | "HOMEWORKER"
+    |
+    "ILLEGAL_DRIVER"
+    | "LATE_WORKER"
+    | "LEGAL_DRIVER"
+    | "LONG_COMMUTER"
+    | "MOBILITY"
+    | "MOBILITY__HIGH"
+    | "MOBILITY__LIMITED"
+    |
+    "MOBILITY__MODERATE"
+    | "MOTORWAY_DRIVER"
+    | "MUSIC_LOVER"
+    | "NATURE_LOVER"
+    | "NIGHT_OWL"
+    | "NIGHTWORKER"
+    | "NORMAL_COMMUTER"
+    |
+    "PARTTIME_WORKER"
+    | "PET_OWNER"
+    | "PHYSICAL_ACTIVITY__HIGH"
+    | "PHYSICAL_ACTIVITY__LIMITED"
+    | "PHYSICAL_ACTIVITY__MODERATE"
+    |
+    "PUBLIC_TRANSPORTS_COMMUTER"
+    | "PUBLIC_TRANSPORTS_USER"
+    | "RECENTLY_CHANGED_JOB"
+    | "RECENTLY_MOVED_HOME"
+    | "RESTO_LOVER"
+    |
+    "RESTO_LOVER__AMERICAN"
+    | "RESTO_LOVER__ASIAN"
+    | "RESTO_LOVER__BARBECUE"
+    | "RESTO_LOVER__FASTFOOD"
+    | "RESTO_LOVER__FRENCH"
+    |
+    "RESTO_LOVER__GERMAN"
+    | "RESTO_LOVER__GREEK"
+    | "RESTO_LOVER__GRILL"
+    | "RESTO_LOVER__INTERNATIONAL"
+    | "RESTO_LOVER__ITALIAN"
+    |
+    "RESTO_LOVER__MEDITERRANEAN"
+    | "RESTO_LOVER__MEXICAN"
+    | "RESTO_LOVER__SEAFOOD"
+    | "RESTO_LOVER__SNACK"
+    | "RURAL_HOME"
+    |
+    "RURAL_WORKER"
+    | "SHOPAHOLIC"
+    | "SHORT_COMMUTER"
+    | "SLEEP_DEPRIVED"
+    | "SOCIAL_ACTIVITY"
+    | "SOCIAL_ACTIVITY__HIGH"
+    |
+    "SOCIAL_ACTIVITY__LIMITED"
+    | "SOCIAL_ACTIVITY__MODERATE"
+    | "SPORTIVE"
+    | "STUDENT"
+    | "TOWN_HOME"
+    | "TOWN_WORKER"
+    |
+    "UBER_PARENT"
+    | "WORK_LIFE_BALANCE"
+    | "WORK_TRAVELLER"
+    | "WORKAHOLIC";
+
+  export interface Event {
+    startTime: string,
+    endTime: string | null,
+    durationInSeconds: number | null,
+    type: string,
+    // stationary event fields
+    location: EventLocation | null,
+    venueSignificance: string | null,
+    venueCandidates: VenueCandidate[] | null,
+    // transport event fields
+    transportMode: "UNKNOWN" | "BYCICLE" | "WALKING" | "RUNNING" | "VEHICLE" | "RAIL" | null
+  }
+
+  export interface EventLocation {
+    latitude: string,
+    longitude: string,
+    accuracy: string,
+  }
+
+  export interface VenueCandidate {
+    venue: Venue,
+    likelihood: number,
+    visits: Visit[],
+  }
+
+  export interface Venue {
+    name: string | null,
+    location: EventLocation | null,
+    venueLabels: VenueLabels,
+  }
+
+  export interface VenueLabels {
+    [label: string]: string
+  }
+
+  export interface Visit {
+    startTime: string,
+    endTime: string,
+    durationInSeconds: number,
+  }
+
+  export interface Segment {
+    category: SegmentCategory;
+    subcategory: SegmentSubcategory;
+    type: SegmentType;
+    id: number;
+    startTime: string;
+    endTime: string | null;
+    attributes: SegmentAttribute[];
+  }
+
+  export interface SegmentAttribute {
+    name: string,
+    value: number
+  }
+
+  export interface UserContext {
+    events: Event[],
+    activeSegments: Segment[],
+    lastKnownLocation: EventLocation | null;
+    home: Venue | null;
+    work: Venue | null;
+  }
+
+  export interface SentianceUserContext {
+    requestUserContext(): Promise<UserContext>;
+
+    addUserContextUpdateListener(onUserContextUpdated: (userContext: UserContext) => void): Promise<EmitterSubscription>;
+  }
+
+  const SentianceUserContext: SentianceUserContext;
+  export default SentianceUserContext;
+}

package/lib/index.js

@@ -0,0 +1,9 @@
+import userContext from './user-context';
+
+const requestUserContext = () => userContext.requestUserContext();
+const addUserContextUpdateListener = userContext._addUserContextUpdateListener;
+
+module.exports = {
+  requestUserContext,
+  addUserContextUpdateListener
+};

package/lib/user-context.js

@@ -0,0 +1,35 @@
+const {NativeModules, NativeEventEmitter, Platform} = require("react-native");
+const {varToString} = require("@sentiance-react-native/core/lib/utils")
+const {SentianceUserContext, SentianceCore} = NativeModules;
+
+const SDK_USER_CONTEXT_UPDATE_EVENT = "SENTIANCE_USER_CONTEXT_UPDATE_EVENT";
+
+var userContextModule
+if (Platform.OS === 'android') {
+  if (!SentianceUserContext) {
+    const nativeModuleName = varToString({SentianceUserContext});
+    throw `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.`;
+  }
+  userContextModule = SentianceUserContext
+} else {
+  if (!SentianceCore) {
+    const nativeModuleName = varToString({SentianceCore});
+    throw `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.`;
+  }
+  userContextModule = SentianceCore
+}
+
+const SENTIANCE_EMITTER = new NativeEventEmitter(userContextModule);
+
+const _addUserContextUpdateListener = async (onUserContextUpdated) => {
+  await userContextModule.listenUserContextUpdates();
+  return SENTIANCE_EMITTER.addListener(SDK_USER_CONTEXT_UPDATE_EVENT, (data) => {
+    onUserContextUpdated(data);
+  });
+};
+
+userContextModule._addUserContextUpdateListener = _addUserContextUpdateListener;
+
+export default userContextModule;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@sentiance-react-native/user-context",
+  "version": "6.0.0-beta.9",
+  "description": "React Native Sentiance - This module provides an easy API to add user context awareness into your apps.",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "lint": "npx eslint lib/index.d.ts"
+  },
+  "keywords": [
+    "react-native",
+    "user-context",
+    "sentiance"
+  ],
+  "peerDependencies": {
+    "@sentiance-react-native/core": "6.0.0-beta.9"
+  },
+  "author": "",
+  "license": "",
+  "homepage": "https://github.com/sentiance/react-native-sentiance/user-context#readme",
+  "repository": "github:sentiance/react-native-sentiance",
+  "publishConfig": {
+    "access": "public"
+  }
+}