react-native-rook-sdk 4.0.0 → 5.0.0-beta.0

package/src/hooks/useRookVariables.ts

@@ -0,0 +1,98 @@
+import RookSdk, { type HeartRateData } from '../NativeRookSdk';
+import { Platform } from 'react-native';
+import { isModuleReady } from '../utils/isModuleReady';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { SDKDataSource } from '../types/SDKSources';
+
+export type Calories = {
+  active: number;
+  basal: number;
+};
+
+/**
+ * The `useRookVariables` hook returns an object with a `ready` boolean and an
+ * asynchronous function `getTodaySteps` that retrieves the number of steps taken today.
+ * @returns The `useRookVariable` hook is returning an object with two properties:
+ * 1. `ready`: This property is coming from the `useRookSyncGateContext` hook and represents the state
+ * of readiness.
+ * 2. `getTodaySteps`: This property is a function that retrieves the number of steps taken today
+ * asynchronously and returns a Promise<string> representing the number of steps taken today.
+ * 3. `getTodayCalories`: This property is a function that retrieves the number of calories burned today
+ * asynchronously and returns a Promise<string> representing the number of calories burned today.
+ */
+export const useRookVariables = () => {
+  const {
+    state: { ready },
+  } = useRookSyncGateContext();
+
+  /**
+   * The function `getTodaySteps` retrieves the number of steps taken today asynchronously.
+   * @returns The function `getTodaySteps` is returning a string representing the number of steps taken today.
+   */
+  const getTodaySteps = async (source: SDKDataSource): Promise<string> => {
+    isModuleReady(ready);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      return RookSdk.syncTodayHealthConnectStepsCount();
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      return RookSdk.syncTodaySamsungHealthStepsCount();
+    }
+
+    if (Platform.OS !== 'android' && source === SDKDataSource.APPLE_HEALTH) {
+      return RookSdk.getTodayAppleHealthSteps();
+    }
+
+    throw new Error('Invalid SDK datasource');
+  };
+
+  /**
+   * The function `syncTodayCaloriesCount` retrieves the number of calories burned today asynchronously as string
+   * @returns The function `syncTodayCaloriesCount` is returning the result of calling
+   */
+  const getTodayCalories = async (source: SDKDataSource): Promise<Calories> => {
+    isModuleReady(ready);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      return RookSdk.syncTodayCaloriesCount();
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      return RookSdk.syncSHTodayCaloriesCount();
+    }
+
+    if (Platform.OS !== 'android' && source === SDKDataSource.APPLE_HEALTH) {
+      return RookSdk.syncTodayCaloriesCount();
+    }
+
+    throw new Error('Invalid SDK datasource');
+  };
+
+  const getTodayHeartRate = async (
+    source: SDKDataSource
+  ): Promise<HeartRateData> => {
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      const result = await RookSdk.getTodayHeartRate();
+      return JSON.parse(result as unknown as string);
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await RookSdk.getSHTodayHeartRate();
+      return JSON.parse(result as unknown as string);
+    }
+
+    if (Platform.OS !== 'android' && source === SDKDataSource.APPLE_HEALTH) {
+      return RookSdk.getTodayHeartRate();
+    }
+
+    throw new Error('Please check the data source');
+  };
+
+  return {
+    ready,
+    getTodaySteps,
+    getTodayCalories,
+    getTodayHeartRate,
+  };
+};

package/src/index.tsx

@@ -0,0 +1,28 @@
+export { default as RookSdk } from './NativeRookSdk';
+
+export { default as RookSyncGate } from './context/RookSyncGateProvider';
+
+export { useRookAPISources } from './hooks/useRookAPISources';
+export { useRookAppleHealth } from './hooks/useRookAppleHealth';
+export { useRookConfiguration } from './hooks/useRookConfiguration';
+export { useRookPermissions } from './hooks/useRookPermissions';
+export { useRookData } from './hooks/useRookData';
+export { useRookAndroidBackgroundSteps } from './hooks/useRookAndroidBackgroundSteps';
+export { useRookHealthConnect } from './hooks/useRookHealthConnect';
+export { useRookSamsungHealth } from './hooks/useRookSamsungHealth';
+export { useRookVariables } from './hooks/useRookVariables';
+export { useRookSync } from './hooks/useRookSync';
+
+export { APIDataSource } from './types/DataSource';
+export { SDKDataSource } from './types/SDKSources';
+export { AppleHealthPermission } from './types/AppleHealthPermissions';
+export { type SamsungHealthPermission } from './types/SamsungHealthPermissions';
+export { type PhysicalSummary } from './types/PhysicalSummary';
+export { type BodySummary } from './types/BodySummary';
+export { type SleepSummary } from './types/SleepSummary';
+export {
+  SharedHealthEvents,
+  UniqueAppleHealthEvents,
+  UniqueSamsungHealthEvents,
+  UniqueHealthConnectEvents,
+} from './types/SyncTypes';

package/src/modules/components/RookStateManager.tsx

@@ -0,0 +1,41 @@
+/* eslint-disable react-hooks/exhaustive-deps */
+import { useEffect, useRef, type FC } from 'react';
+import { AppState, type AppStateStatus } from 'react-native';
+import type { RookSyncGateState } from '../../context/RookSyncGateTypes';
+import { useRookPermissionEmitter } from '../hook/useRookEmitter';
+import { useRookAutoSync } from '../hook/useRookAutoSync';
+
+type Props = {
+  state: RookSyncGateState;
+  enableBackground: boolean;
+  enableLogs: boolean;
+};
+
+export const RookStateManager: FC<Props> = (props) => {
+  const { checkAndroidPermissions } = useRookPermissionEmitter();
+  const { startBackgroundServices } = useRookAutoSync(props);
+  const appState = useRef(AppState.currentState);
+
+  useEffect(() => {
+    const subscription = AppState.addEventListener(
+      'change',
+      (nextAppState: AppStateStatus) => {
+        if (
+          appState.current?.match(/inactive|background/) &&
+          nextAppState === 'active'
+        ) {
+          checkAndroidPermissions();
+          startBackgroundServices();
+        }
+
+        appState.current = nextAppState;
+      }
+    );
+
+    return () => {
+      subscription.remove();
+    };
+  }, [checkAndroidPermissions]);
+
+  return <></>;
+};

package/{lib/commonjs/modules/hook/useRookAutoSync.js → src/modules/hook/useRookAutoSync.ts}

@@ -1,16 +1,17 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useRookAutoSync = void 0;
-var _react = require("react");
-var _reactNative = require("react-native");
-var _errors = require("../utils/errors");
-var _getNativeModule = _interopRequireDefault(require("../../utils/getNativeModule"));
-var _nativeModules = _interopRequireDefault(require("../../utils/nativeModules"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /* eslint-disable react-hooks/exhaustive-deps */
+import RookSdk from '../../NativeRookSdk';
+import { useEffect, useRef, useState } from 'react';
+import { AppState, Platform } from 'react-native';
+import type { RookSyncGateState } from '../../context/RookSyncGateTypes';
+import { errors } from '../utils/errors';
+import type { Message } from '../types/sendMessageBroadcast';
+import { AppleHealthPermission } from '../../types/AppleHealthPermissions';
+
+type StartBackgroundSync = {
+  state: RookSyncGateState;
+  enableBackground: boolean;
+  enableLogs: boolean;
+};
 
 const MESSAGE_TYPE = 'ROOK_BACKGROUND_ENABLED';
 
@@ -30,119 +31,149 @@ const MESSAGE_TYPE = 'ROOK_BACKGROUND_ENABLED';
  * is ready, the permissions status, and the user ID associated with the state. This state is used to
  * determine when to start the
  */
-const useRookAutoSync = ({
+export const useRookAutoSync = ({
   enableBackground,
   enableLogs,
-  state
-}) => {
-  const appState = (0, _react.useRef)(_reactNative.AppState.currentState);
-  const [changeAppState, setChangeState] = (0, _react.useState)(0);
-  (0, _react.useEffect)(() => {
+  state,
+}: StartBackgroundSync) => {
+  const appState = useRef(AppState.currentState);
+  const [changeAppState, setChangeState] = useState(0);
+
+  useEffect(() => {
     if (!enableBackground) return;
-    const subscription = _reactNative.AppState.addEventListener('change', nextAppState => {
+
+    const subscription = AppState.addEventListener('change', (nextAppState) => {
       if (
-      // Check previous state to check if he app was inactive or in background
-      // and then pass to be active
-      appState.current.match(/inactive|background/) && nextAppState === 'active') {
-        setChangeState(prev => prev + 1);
+        // Check previous state to check if he app was inactive or in background
+        // and then pass to be active
+        appState.current?.match(/inactive|background/) &&
+        nextAppState === 'active'
+      ) {
+        setChangeState((prev) => prev + 1);
       }
+
       appState.current = nextAppState;
     });
+
     return () => {
       subscription.remove();
     };
   }, []);
-  (0, _react.useEffect)(() => {
+
+  useEffect(() => {
     if (!state.ready || !enableBackground) return;
+
     startBackgroundServices();
   }, [state, changeAppState]);
+
   const startBackgroundServices = () => {
-    const {
-      clientUUID,
-      secret,
-      ready
-    } = state;
+    const { clientUUID, secret, ready } = state;
+
+    if (!enableBackground) return;
+
     if (!ready || !clientUUID || !secret) {
       return;
     }
-    if (_reactNative.Platform.OS === 'android') {
+
+    if (Platform.OS === 'android') {
       startAndroidBackgroundSync();
       return;
     }
+
     startIOSBackgroundSync();
   };
-  const isValidUser = async () => {
+
+  const isValidUser = async (): Promise<boolean> => {
     try {
-      const rookModule = (0, _getNativeModule.default)(_nativeModules.default.android.CONFIGURATION);
-      const userID = await rookModule.getUserID();
+      const userID = await RookSdk.getUserID();
+
       if (userID) return true;
-      if (enableLogs) console.error(_errors.errors.noUserIDAndroidBackground);
-      throw new Error(_errors.errors.noUserIDAndroidBackground);
+
+      if (enableLogs) console.error(errors.noUserIDAndroidBackground);
+
+      throw new Error(errors.noUserIDAndroidBackground);
     } catch (error) {
       sendMessageToBroadcast({
         type: 'ROOK_BACKGROUND_ENABLED',
-        message: 'There is not a user id',
-        value: false
+        message: (error as any).message || 'There is not a user id',
+        value: false,
       });
+
       return false;
     }
   };
-  const tryToStartBackgroundSync = async () => {
+
+  const tryToStartBackgroundSync = async (): Promise<boolean> => {
     try {
-      const rookPermissions = (0, _getNativeModule.default)(_nativeModules.default.android.PERMISSIONS);
-      const backgroundStatus = await rookPermissions.checkHealthConnectPermissionsPartially();
-      if (!backgroundStatus) throw new Error('No permission granted or not available');
-      const rookBackground = (0, _getNativeModule.default)(_nativeModules.default.android.BACKGROUND);
-      const result = await rookBackground.scheduleBackgroundSync(enableLogs);
+      const backgroundStatus =
+        await RookSdk.checkHealthConnectBackgroundReadStatus();
+
+      if (backgroundStatus !== 'PERMISSION_GRANTED')
+        throw new Error('No permission granted or not available');
+
+      const result = await RookSdk.scheduleBackgroundSync(enableLogs);
+
       return result;
     } catch (error) {
-      console.log(error);
       sendMessageToBroadcast({
         type: 'ROOK_BACKGROUND_ENABLED',
-        message: 'Health Connect background is not available on the device or the user does not grants permission',
-        value: false
+        message:
+          (error as any).message ||
+          'Health Connect background is not available on the device or the user does not grants permission',
+        value: false,
       });
+
       return false;
     }
   };
-  const tryToStartForegroundSync = async () => {
+
+  const tryToStartForegroundSync = async (): Promise<boolean> => {
     try {
-      const rookPermissionsModule = (0, _getNativeModule.default)(_nativeModules.default.android.PERMISSIONS);
-      const hasHCPermissions = await rookPermissionsModule.checkHealthConnectPermissions();
-      const hasAndroidPermissions = await rookPermissionsModule.hasAndroidBackgroundPermissions();
+      const hasHCPermissions =
+        await RookSdk.healthConnectHasPartialPermissions();
+      const hasAndroidPermissions =
+        await RookSdk.androidHasBackgroundPermissions();
+
       if (!hasHCPermissions || !hasAndroidPermissions) {
-        if (enableLogs) console.error(_errors.errors.autoStartAndroidBackgroundSync);
-        throw new Error(_errors.errors.autoStartAndroidBackgroundSync);
+        if (enableLogs) console.error(errors.autoStartAndroidBackgroundSync);
+
+        throw new Error(errors.autoStartAndroidBackgroundSync);
       }
-      const rookStepsModule = (0, _getNativeModule.default)(_nativeModules.default.android.STEPS);
-      if (_reactNative.AppState.currentState === 'active' && appState.current === 'active') {
-        await rookStepsModule.enableBackgroundAndroidSteps();
+
+      if (AppState.currentState === 'active' && appState.current === 'active') {
+        await RookSdk.enableBackgroundAndroidSteps();
+
         return true;
       }
+
       return false;
     } catch (error) {
       sendMessageToBroadcast({
         type: 'ROOK_BACKGROUND_ENABLED',
         value: false,
-        message: error.message
+        message: (error as Error).message,
       });
+
       return false;
     }
   };
-  const tryToStartSamsungHealthSync = async () => {
+
+  const tryToStartSamsungHealthSync = async (): Promise<boolean> => {
     try {
-      const rookPermissionsModule = (0, _getNativeModule.default)(_nativeModules.default.android.PERMISSIONS);
-      const isAvailable = await rookPermissionsModule.checkSamsungAvailability();
+      const isAvailable = await RookSdk.checkSamsungAvailability();
+
       if (isAvailable !== 'INSTALLED') return false;
-      const rookSyncModule = (0, _getNativeModule.default)(_nativeModules.default.android.SYNC);
-      await rookSyncModule.enableSamsungSync();
+
+      await RookSdk.enableSamsungSync();
+
       return true;
     } catch (error) {
       sendMessageToBroadcast({
         type: 'ROOK_BACKGROUND_ENABLED',
         value: false,
-        message: error.message
+        message: (error as Error).message,
       });
+
       return false;
     }
   };
@@ -155,37 +186,45 @@ const useRookAutoSync = ({
    * broadcast with `value` set to `false` and an error message is logged.
    */
   const startAndroidBackgroundSync = async () => {
-    const {
-      clientUUID,
-      secret,
-      ready
-    } = state;
+    const { clientUUID, secret, ready } = state;
+
     if (!ready || !clientUUID || !secret) {
       return;
     }
+
     try {
       const enabledSources = [];
+
       const isValid = await isValidUser();
       if (!isValid) return;
+
       const isSamsungEnabled = await tryToStartSamsungHealthSync();
       const isEnabled = await tryToStartBackgroundSync();
+
       if (isSamsungEnabled) enabledSources.push('Samsung Health');
       if (isEnabled) enabledSources.push('Health Connect');
+
       if (!isEnabled) {
         const isForegroundEnabled = await tryToStartForegroundSync();
-        if (!isForegroundEnabled && !isSamsungEnabled) throw new Error("We couldn't start background sync");
+
+        if (!isForegroundEnabled && !isSamsungEnabled)
+          throw new Error("We couldn't start background sync");
+
         if (isForegroundEnabled) enabledSources.push('Foreground Service');
       }
+
       sendMessageToBroadcast({
         type: 'ROOK_BACKGROUND_ENABLED',
         value: true,
-        message: `via: ${enabledSources.join(', ')}`
+        message: `via: ${enabledSources.join(', ')}`,
       });
+
       if (enableLogs) console.log('ROOK - Background enabled successfully');
     } catch (error) {
       sendMessageToBroadcast({
         type: 'ROOK_BACKGROUND_ENABLED',
-        value: false
+        message: (error as any).message,
+        value: false,
       });
     }
   };
@@ -199,44 +238,56 @@ const useRookAutoSync = ({
    */
   const startIOSBackgroundSync = async () => {
     try {
-      const rookPermissions = (0, _getNativeModule.default)(_nativeModules.default.ios.PERMISSIONS);
-      const rookBackground = (0, _getNativeModule.default)(_nativeModules.default.ios.BACKGROUND);
-      const rookConfigModule = (0, _getNativeModule.default)(_nativeModules.default.ios.CONFIGURATION);
-      const rookSync = (0, _getNativeModule.default)(_nativeModules.default.ios.SYNC);
-      const userID = await rookConfigModule.getUserID();
+      const userID = await RookSdk.getUserID();
+
       if (!userID) {
-        if (enableLogs) console.error(_errors.errors.noUserIDAndroidBackground);
+        if (enableLogs) console.error(errors.noUserIDAndroidBackground);
+
         sendMessageToBroadcast({
           type: MESSAGE_TYPE,
           value: false,
-          message: _errors.errors.noUserIDAndroidBackground
+          message: errors.noUserIDAndroidBackground,
         });
+
         return;
       }
-      const status = await rookPermissions.checkPermissionsStatus(null);
-      if (status === 'PERMISSION_NOT_REQUESTED') throw new Error('Permissions required');
-      await rookBackground.enableBackGroundUpdates();
-      rookSync.sync(() => {
+
+      const status = await RookSdk.appleHealthHasPermissions(
+        AppleHealthPermission.STEP_COUNT
+      );
+
+      if (status === 'PERMISSION_NOT_REQUESTED')
+        throw new Error('Permissions required');
+
+      await RookSdk.enableBackGroundUpdates();
+
+      RookSdk.sync(() => {
         sendMessageToBroadcast({
           type: MESSAGE_TYPE,
           value: true,
-          message: 'Some data has already uploaded'
+          message: 'Some data has already uploaded',
         });
       });
+
       sendMessageToBroadcast({
         type: MESSAGE_TYPE,
-        value: true
+        value: true,
       });
+
       if (enableLogs) console.log('ROOK - Background enabled successfully');
     } catch (err) {
-      const error = err;
+      const error = err as any;
+
       sendMessageToBroadcast({
         type: MESSAGE_TYPE,
         value: false,
-        message: _errors.errors.autoStartIOSBackgroundSync
+        message: errors.autoStartIOSBackgroundSync,
       });
+
       if (enableLogs) {
-        if (error.message && error.message.includes('emptyUserId')) console.error(_errors.errors.noUserIDAndroidBackground);else console.error(_errors.errors.autoStartIOSBackgroundSync);
+        if (error.message && (error.message as string).includes('emptyUserId'))
+          console.error(errors.noUserIDAndroidBackground);
+        else console.error(errors.autoStartIOSBackgroundSync);
       }
     }
   };
@@ -246,16 +297,11 @@ const useRookAutoSync = ({
    * @param {Message} message - The `message` parameter is of type `Message`, which is likely an object
    * containing information to be sent as a broadcast message.
    */
-  const sendMessageToBroadcast = message => {
-    const rookSyncModule = (0, _getNativeModule.default)(_reactNative.Platform.select({
-      android: () => _nativeModules.default.android.MAIN,
-      default: () => _nativeModules.default.ios.MAIN
-    })());
-    rookSyncModule.sendMessageToBroadcast(message).then().catch();
+  const sendMessageToBroadcast = (message: Message): void => {
+    RookSdk.sendMessage(message);
   };
+
   return {
-    startBackgroundServices
+    startBackgroundServices,
   };
 };
-exports.useRookAutoSync = useRookAutoSync;
-//# sourceMappingURL=useRookAutoSync.js.map

package/src/modules/hook/useRookEmitter.ts

@@ -0,0 +1,94 @@
+/* eslint-disable react-hooks/exhaustive-deps */
+import { useRef, useCallback } from 'react';
+import RookSdk, { type BackgroundStatus } from '../../NativeRookSdk';
+
+const PERM_KEYS = {
+  HC: 'ROOK_HEALTH_CONNECT_PERMISSIONS',
+  HC_PARTIAL: 'ROOK_HEALTH_CONNECT_PERMISSIONS_PARTIALLY_GRANTED',
+  HC_BG: 'ROOK_HEALTH_CONNECT_BACKGROUND_PERMISSIONS',
+  SAMSUNG: 'ROOK_SAMSUNG_HEALTH_PERMISSIONS',
+  SAMSUNG_PARTIAL: 'ROOK_SAMSUNG_HEALTH_PERMISSIONS_PARTIALLY_GRANTED',
+  ANDROID_BG: 'ROOK_BACKGROUND_ANDROID_PERMISSIONS',
+} as const;
+
+export const useRookPermissionEmitter = () => {
+  const emittedRef = useRef<Record<string, boolean>>({});
+
+  const evaluateAndEmit = useCallback(
+    async (key: string, checkFn: () => Promise<boolean | BackgroundStatus>) => {
+      let previuos = emittedRef.current[key] || false;
+
+      try {
+        const result = await checkFn();
+
+        const isGranted =
+          typeof result === 'string' ? result === 'PERMISSION_GRANTED' : result;
+
+        if (previuos === isGranted) return;
+
+        const success = await RookSdk.sendMessage({
+          type: key,
+          value: isGranted,
+        });
+
+        if (success) {
+          emittedRef.current[key] = true;
+        }
+      } catch (error) {
+        console.error(`Error checking/emitting ${key}:`, error);
+      }
+    },
+    []
+  );
+
+  const checkAndroidSystem = async () => {
+    await evaluateAndEmit(
+      PERM_KEYS.ANDROID_BG,
+      RookSdk.androidHasBackgroundPermissions
+    );
+  };
+
+  const checkHealthConnect = async () => {
+    await Promise.all([
+      evaluateAndEmit(PERM_KEYS.HC, RookSdk.healthConnectHasPermissions),
+      evaluateAndEmit(
+        PERM_KEYS.HC_PARTIAL,
+        RookSdk.healthConnectHasPartialPermissions
+      ),
+      evaluateAndEmit(
+        PERM_KEYS.HC_BG,
+        RookSdk.checkHealthConnectBackgroundReadStatus
+      ),
+    ]);
+  };
+
+  const checkSamsungHealth = async () => {
+    await Promise.all([
+      evaluateAndEmit(PERM_KEYS.SAMSUNG, RookSdk.samsungHealthHasPermissions),
+      evaluateAndEmit(
+        PERM_KEYS.SAMSUNG_PARTIAL,
+        RookSdk.samsungHealthHasPartialPermissions
+      ),
+    ]);
+  };
+
+  const checkAndroidPermissions = async () => {
+    try {
+      const samsungStatus = await RookSdk.checkSamsungAvailability();
+      const isSamsungAvailable = samsungStatus === 'INSTALLED';
+
+      checkAndroidSystem().then().catch(console.log);
+      checkHealthConnect().then().catch(console.log);
+
+      if (isSamsungAvailable) {
+        checkSamsungHealth().catch(console.log);
+      } else {
+        console.log(`Skipping Samsung Health checks. Status: ${samsungStatus}`);
+      }
+    } catch (error) {
+      console.error('Global Permission Check Failed', error);
+    }
+  };
+
+  return { checkAndroidPermissions };
+};

package/src/modules/types/sendMessageBroadcast.ts

@@ -0,0 +1,5 @@
+export type Message = {
+  type: string;
+  value: boolean;
+  message?: string;
+};

package/src/modules/utils/errors.ts

@@ -0,0 +1,9 @@
+export const errors = {
+  autoStartAndroidBackgroundSync:
+    'ROOK - We try to start the health connect background sync but some permissions are missing, please grant permissions on health connect and android permissions, https://docs.tryrook.io/docs/rookconnect/sdk/reactnative/fundamentals/grantpermissons/#request-permissions',
+
+  autoStartIOSBackgroundSync:
+    'ROOK -  We try to start the background sync but some error occurred please check the permissions are granted and data exists in the device, https://docs.tryrook.io/docs/rookconnect/sdk/reactnative/fundamentals/grantpermissons/#request-permissions',
+  noUserIDAndroidBackground:
+    "ROOK - We couldn't start the background sync cause there is no user registered, https://docs.tryrook.io/docs/rookconnect/sdk/reactnative/fundamentals/updateuserid/",
+};