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

package/{lib/commonjs/context/RookSyncGateContext.js → src/context/RookSyncGateContext.ts}

@@ -1,17 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useRookSyncGateContext = exports.RookSyncGateContext = void 0;
-var _react = require("react");
 // RookSyncGateContext.tsx
+import { createContext, useContext, type Dispatch } from 'react';
+import type { RookSyncGateState, Action } from './RookSyncGateTypes';
 
 /* This line of code is creating a context using the `createContext` function provided by React. The
 context being created is named `RookSyncGateContext` and it is defined to hold an object with two
 properties: `state` of type `RookSyncGateState` and `dispatch` of type `Dispatch<Action>`. The
 `Dispatch` type is a generic type that represents a function to dispatch actions. */
-const RookSyncGateContext = exports.RookSyncGateContext = /*#__PURE__*/(0, _react.createContext)(undefined);
+export const RookSyncGateContext = createContext<
+  { state: RookSyncGateState; dispatch: Dispatch<Action> } | undefined
+>(undefined);
 
 /**
  * The function `useRookSyncGateContext` ensures that it is used within the `RookSyncGateProvider`
@@ -20,12 +17,12 @@ const RookSyncGateContext = exports.RookSyncGateContext = /*#__PURE__*/(0, _reac
  * `RookSyncGateContext` using the `useContext` hook. If the context is not found, it throws an error
  * indicating that `useRookSyncGateContext` should be used inside `RookSyncGateProvider`.
  */
-const useRookSyncGateContext = () => {
-  const context = (0, _react.useContext)(RookSyncGateContext);
+export const useRookSyncGateContext = () => {
+  const context = useContext(RookSyncGateContext);
   if (!context) {
-    throw new Error('useRookSyncGateContext should be used inside RookSyncGateProvider');
+    throw new Error(
+      'useRookSyncGateContext should be used inside RookSyncGateProvider'
+    );
   }
   return context;
 };
-exports.useRookSyncGateContext = useRookSyncGateContext;
-//# sourceMappingURL=RookSyncGateContext.js.map

package/src/context/RookSyncGateProvider.tsx

@@ -0,0 +1,78 @@
+/* eslint-disable react-hooks/exhaustive-deps */
+import { useReducer, type FC, useEffect } from 'react';
+import { rookSyncGateReducer } from './RookSyncGateReducer'; // Importa el reducer
+import type {
+  RookSyncGateState,
+  RookSyncGateProviderProps,
+} from './RookSyncGateTypes';
+import { RookSyncGateContext } from './RookSyncGateContext';
+import RookSdk from '../NativeRookSdk';
+import { useRookAutoSync } from '../modules/hook/useRookAutoSync';
+
+const initialState: RookSyncGateState = {
+  clientUUID: '',
+  environment: 'sandbox',
+  password: '',
+  ready: false,
+  userID: '',
+  permissions: 0,
+  enableLogs: false,
+};
+
+/*
+ * This code snippet is defining a React functional component called `RookSyncGateProvider`.
+ * this define the provider for the SDK
+ */
+const RookSyncGateProvider: FC<RookSyncGateProviderProps> = ({
+  environment,
+  clientUUID,
+  password,
+  children,
+  enableLogs = false,
+  enableBackgroundSync,
+  enableEventsBackgroundSync = true,
+}) => {
+  const [state, dispatch] = useReducer(rookSyncGateReducer, initialState);
+
+  const { startBackgroundServices } = useRookAutoSync({
+    state,
+    enableBackground: enableBackgroundSync,
+    enableLogs,
+  });
+
+  useEffect(() => {
+    initModule();
+  }, [environment, clientUUID, password]);
+
+  const initModule = async (): Promise<void> => {
+    dispatch({ type: 'SET_ROOK_ENVIRONMENT', environment });
+    dispatch({ type: 'SET_CLIENT_UUID', clientUUID });
+    dispatch({ type: 'SET_PASSWORD', password });
+    dispatch({ type: 'SET_ENABLE_LOGS', enableLogs });
+
+    try {
+      await RookSdk.initRook({
+        environment,
+        clientUUID,
+        password,
+        enableLogs,
+        enableEventsBackgroundSync,
+        enableBackground: enableBackgroundSync,
+      });
+
+      if (enableBackgroundSync) startBackgroundServices();
+
+      dispatch({ type: 'SET_READY', ready: true });
+    } catch (error) {
+      console.log(error);
+    }
+  };
+
+  return (
+    <RookSyncGateContext.Provider value={{ state, dispatch }}>
+      {children}
+    </RookSyncGateContext.Provider>
+  );
+};
+
+export default RookSyncGateProvider;

package/{lib/commonjs/context/RookSyncGateReducer.js → src/context/RookSyncGateReducer.ts}

@@ -1,9 +1,5 @@
-"use strict";
+import type { RookSyncGateState, Action } from './RookSyncGateTypes';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.rookSyncGateReducer = void 0;
 /**
  * The rookSyncGateReducer function in TypeScript handles various actions to update the state of a
  * RookSyncGate component.
@@ -19,46 +15,29 @@ exports.rookSyncGateReducer = void 0;
  * type provided. The state object is updated with the corresponding values based on the action type.
  * If the action type is not recognized, it returns the current state unchanged.
  */
-const rookSyncGateReducer = (state, action) => {
+export const rookSyncGateReducer = (
+  state: RookSyncGateState,
+  action: Action
+): RookSyncGateState => {
   switch (action.type) {
     case 'SET_READY':
-      return {
-        ...state,
-        ready: action.ready
-      };
+      return { ...state, ready: action.ready };
     case 'SET_ROOK_ENVIRONMENT':
-      return {
-        ...state,
-        environment: action.environment
-      };
+      return { ...state, environment: action.environment };
     case 'SET_CLIENT_UUID':
-      return {
-        ...state,
-        clientUUID: action.clientUUID
-      };
+      return { ...state, clientUUID: action.clientUUID };
     case 'SET_PASSWORD':
-      return {
-        ...state,
-        password: action.password
-      };
+      return { ...state, password: action.password };
     case 'SET_USER_ID':
-      return {
-        ...state,
-        userID: action.userID
-      };
+      return { ...state, userID: action.userID };
     case 'SET_ENABLE_LOGS':
-      return {
-        ...state,
-        enableLogs: action.enableLogs
-      };
+      return { ...state, enableLogs: action.enableLogs };
     case 'SET_PERMISSIONS':
       return {
         ...state,
-        permissions: state.permissions + 1
+        permissions: state.permissions + 1,
       };
     default:
       return state;
   }
 };
-exports.rookSyncGateReducer = rookSyncGateReducer;
-//# sourceMappingURL=RookSyncGateReducer.js.map

package/src/context/RookSyncGateTypes.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from 'react';
+
+export type Environment = 'sandbox' | 'production';
+
+type RookSyncGateState = {
+  clientUUID: string;
+  environment: Environment;
+  password: string;
+  ready: boolean;
+  userID: string;
+  permissions: number;
+  enableLogs: boolean;
+};
+
+type Action =
+  | { type: 'SET_CLIENT_UUID'; clientUUID: string }
+  | { type: 'SET_ENABLE_LOGS'; enableLogs: boolean }
+  | { type: 'SET_PASSWORD'; password: string }
+  | { type: 'SET_PERMISSIONS' }
+  | { type: 'SET_READY'; ready: boolean }
+  | { type: 'SET_ROOK_ENVIRONMENT'; environment: Environment }
+  | { type: 'SET_USER_ID'; userID: string };
+
+type RookSyncGateProviderProps = {
+  children: ReactNode;
+  environment: Environment;
+  clientUUID: string;
+  password: string;
+  enableLogs?: boolean;
+  enableBackgroundSync: boolean;
+  enableEventsBackgroundSync?: boolean;
+};
+
+export type { RookSyncGateState, Action, RookSyncGateProviderProps };

package/src/hooks/useRookAPISources.ts

@@ -0,0 +1,83 @@
+import RookSdk from '../NativeRookSdk';
+import { isModuleReady } from '../utils/isModuleReady';
+import { Platform } from 'react-native';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import type { APIDataSource } from '../types/DataSource';
+import type {
+  AuthorizedSource,
+  DataSourceAuthorizer,
+  DataSourceProps,
+} from '../types/AuthorizedSources';
+
+/**
+ * The `useRookDataSources` hook provides functionality to interact with data sources in Rook,
+ * including retrieving available data sources, presenting a connections page, and revoking user
+ * authorization for a specific data source.
+ * @returns An object is being returned from the `useRookDataSources` hook to allow the user to access to the sources API
+ */
+export const useRookAPISources = () => {
+  const {
+    state: { ready },
+  } = useRookSyncGateContext();
+
+  /**
+   * The function `revokeDataSource` revokes user authorization for the specified data source.
+   * @param {DataSourceType} type - The `type` parameter in the `revokeDataSource` function represents
+   * the type of data source that you want to revoke access to. It is of type `DataSourceType`.
+   * @returns A Promise<boolean> is being returned from the `revokeDataSource` function.
+   */
+  const revokeDataSource = (
+    userid: string,
+    type: APIDataSource
+  ): Promise<boolean> => {
+    isModuleReady(ready);
+
+    return RookSdk.revokeDataSource(userid, type);
+  };
+
+  /**
+   * Retrieves the authorization status for a specific data source linked to a given user.
+   *  If the user is not authorized, an authorization URL is provided to start the process.
+   *  If the user is already authorized, the response will indicate "authorized": true and no authorization URL will be
+   * returned. The redirect_url parameter can be used to specify where the user should be redirected
+   * after completing the authorization.
+   * @returns The function `getDataSourceAuthorizer` is returning a `DataSourceAuthorizer` object after
+   * parsing the response from `rookSync.current.getDataSourceAuthorizer()` as JSON.
+   */
+  const getDataSourceAuthorizer = async (
+    props: DataSourceProps
+  ): Promise<DataSourceAuthorizer> => {
+    const response = await RookSdk.getDataSourceAuthorizer(props);
+
+    if (Platform.OS === 'android')
+      return JSON.parse(response as any) as DataSourceAuthorizer;
+
+    return response;
+  };
+
+  /**
+   * The function `getAuthorizedDataSources` returns authorized data sources after checking ROOK services
+   * in case of apple health, health connect and android this only determines if the user
+   * is connected not if the user granted permissions.
+   * @returns The function `getAuthorizedDataSources` is returning a Promise that will resolve to the
+   * result of calling `rookSync.current.getAuthorizedDataSources()`.
+   */
+  const getAuthorizedDataSourcesV2 = async (
+    userid: string
+  ): Promise<AuthorizedSource[]> => {
+    isModuleReady(ready);
+
+    if (Platform.OS !== 'android')
+      return RookSdk.getAuthorizedDataSourcesV2(userid);
+
+    const response = await RookSdk.getAuthorizedDataSourcesV2(userid);
+    return JSON.parse(response as any) as AuthorizedSource[];
+  };
+
+  return {
+    ready,
+    revokeDataSource,
+    getDataSourceAuthorizer,
+    getAuthorizedDataSourcesV2,
+  };
+};

package/src/hooks/useRookAndroidBackgroundSteps.ts

@@ -0,0 +1,81 @@
+import RookSdk from '../NativeRookSdk';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import isRunningOnAndroid from '../utils/isRunningOnAndroid';
+
+/**
+ * The `useRookAndroidBackgroundSteps` function provides various methods for managing and retrieving
+ * step count data on Android devices using the Rook module.
+ * @returns The `useRookAndroidBackgroundSteps` function returns a hook with the functions that allows the user to
+ * control de steps sync
+ */
+export const useRookAndroidBackgroundSteps = () => {
+  const {
+    state: { ready },
+  } = useRookSyncGateContext();
+
+  /**
+   * The function `isStepsAvailable` checks if steps data is available.
+   * @returns The function `isStepsAvailable` is returning a promise that resolve in a boolean value.
+   */
+  const isStepsAvailable = async (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.isStepsAvailable();
+  };
+
+  /**
+   * The function `enableBackgroundAndroidSteps` starts collecting of steps during the day
+   * @returns The `enableBackgroundAndroidSteps` function is returning a Promise that resolves to a boolean
+   */
+  const enableBackgroundAndroidSteps = async (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.enableBackgroundAndroidSteps();
+  };
+
+  /**
+   * The function `disableBackgroundAndroidSteps` stops a process of collecting steps during the day
+   * @returns The function `disableBackgroundAndroidSteps` function is returning a Promise that resolves to a boolean
+   */
+  const disableBackgroundAndroidSteps = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.disableBackgroundAndroidSteps();
+  };
+
+  /**
+   * The function `isBackgroundAndroidStepsActive` checks if steps are active and returns a Promise with a boolean
+   * value.
+   * @returns The function is returning a Promise that resolves to a boolean
+   */
+  const isBackgroundAndroidStepsActive = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.isBackgroundAndroidStepsActive();
+  };
+
+  /**
+   * The function `getTodayAndroidStepsCount` retrieves the number of steps taken today asynchronously as string.
+   * @returns The function `getTodaySteps` is returning the result of calling
+   */
+  const syncTodayAndroidStepsCount = (): Promise<string> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.syncTodayAndroidStepsCount();
+  };
+
+  return {
+    ready,
+    isStepsAvailable,
+    enableBackgroundAndroidSteps,
+    disableBackgroundAndroidSteps,
+    isBackgroundAndroidStepsActive,
+    syncTodayAndroidStepsCount,
+  };
+};

package/src/hooks/useRookAppleHealth.ts

@@ -0,0 +1,55 @@
+import RookSdk from '../NativeRookSdk';
+
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import { isRunningOniOS } from '../utils/isRunningOniOS';
+
+export const useRookAppleHealth = () => {
+  const {
+    state: { ready },
+  } = useRookSyncGateContext();
+
+  /**
+   * The function `enableBackGroundUpdates` enable background updates and returns a promise
+   * indicating success.
+   * @returns The function `enableBackGroundUpdates` returns a Promise that resolves to a boolean
+   * value.
+   */
+  const enableBackGroundUpdates = (): Promise<boolean> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.enableBackGroundUpdates();
+  };
+
+  /**
+   * The function `disableBackGroundUpdates` disables background updates and returns a promise
+   * indicating success.
+   * @returns The function `disableBackGroundUpdates` returns a Promise that resolves to a boolean
+   * value.
+   */
+  const disableBackGroundUpdates = (): Promise<boolean> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.disableBackGroundUpdates();
+  };
+
+  /**
+   * This function checks if background summaries are enabled.
+   * @returns The function `isBackGroundForSummariesEnable` is returning a boolean value
+   */
+  const isBackgroundUpdatesEnabled = async (): Promise<boolean> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.isBackgroundUpdatesEnabled();
+  };
+
+  return {
+    ready,
+    enableBackGroundUpdates,
+    disableBackGroundUpdates,
+    isBackgroundUpdatesEnabled,
+  };
+};

package/src/hooks/useRookConfiguration.ts

@@ -0,0 +1,82 @@
+import RookSdk from '../NativeRookSdk';
+
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import { type SDKDataSource } from '../types/SDKSources';
+
+/**
+ * The `useRookConfiguration` hook provides various asynchronous methods for managing the configuration
+ * of the ROOK SDK
+ * @returns The `useRookConfiguration` function returns an object containing that allow the user to configure
+ * the SDK
+ */
+export const useRookConfiguration = () => {
+  const {
+    state: { ready },
+    dispatch,
+  } = useRookSyncGateContext();
+
+  /**
+   * The `getUserID` function retrieves the user ID
+   * @returns The function `getUserID` is returning a Promise that resolves to a string value.
+   */
+  const getUserID = async (): Promise<string> => {
+    isModuleReady(ready);
+
+    const result = await RookSdk.getUserID();
+
+    if (result) dispatch({ type: 'SET_USER_ID', userID: result });
+
+    return result;
+  };
+
+  /**
+   * The function `updateUserID` updates the user ID and returns a boolean indicating the success of
+   * the update.
+   * @param {string} userID - The `userID` parameter is a string that represents the user ID that needs
+   * to be updated in the system.
+   * @returns The `updateUserID` function returns a Promise that resolves to a boolean value.
+   */
+  const updateUserID = async (userID: string): Promise<boolean> => {
+    isModuleReady(ready);
+
+    const result: boolean = await RookSdk.updateUserID(userID);
+
+    dispatch({ type: 'SET_USER_ID', userID });
+
+    return result;
+  };
+
+  /**
+   * This function `syncUserTimeZone` synchronizes the user's time zone using
+   * @returns The `syncUserTimeZone` function returns a boolean value, indicating success or failure
+   */
+  const syncUserTimeZone = async (): Promise<boolean> => {
+    isModuleReady(ready);
+
+    const result: boolean = await RookSdk.syncUserTimeZone();
+    return result;
+  };
+
+  /**
+   * The function `removeUserFromRook` removes a user from a rook services,  If you delete the user from the Rook services you have to create the user again with updateUserID and request permissions.
+   * @returns The `removeUserFromRook` function is returning a boolean value.
+   */
+  const removeUserFromRook = async (
+    sources: SDKDataSource[]
+  ): Promise<boolean> => {
+    isModuleReady(ready);
+
+    dispatch({ type: 'SET_USER_ID', userID: '' });
+
+    return RookSdk.removeUserFromRook(sources);
+  };
+
+  return {
+    ready,
+    getUserID,
+    updateUserID,
+    removeUserFromRook,
+    syncUserTimeZone,
+  };
+};

package/src/hooks/useRookData.ts

@@ -0,0 +1,122 @@
+import RookSdk from '../NativeRookSdk';
+import { Platform } from 'react-native';
+
+import { isModuleReady } from '../utils/isModuleReady';
+import { isValidDate } from '../utils/isValidDate';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { SDKDataSource } from '../types/SDKSources';
+import { type SleepSummary } from '../types/SleepSummary';
+import { type PhysicalSummary } from '../types/PhysicalSummary';
+import { type BodySummary } from '../types/BodySummary';
+import { type ActivityEvent } from '../types/ActivityEvent';
+import { type HeartRateData } from '../types/HeartRateEvent';
+
+type Params = {
+  date: string;
+  source: SDKDataSource;
+};
+
+export const useRookData = () => {
+  const {
+    state: { ready },
+  } = useRookSyncGateContext();
+
+  const getSleepSummary = async ({
+    date,
+    source,
+  }: Params): Promise<SleepSummary[]> => {
+    isModuleReady(ready);
+    isValidDate(date);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await RookSdk.getSamsungSleepSummary(date);
+      return JSON.parse(result);
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      const result = await RookSdk.getHealthConnectSleepSummary(date);
+      return JSON.parse(result);
+    }
+
+    return RookSdk.getAppleHealthSleepSummary(date);
+  };
+
+  const getPhysicalSummary = async ({
+    date,
+    source,
+  }: Params): Promise<PhysicalSummary> => {
+    isModuleReady(ready);
+    isValidDate(date);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await RookSdk.getSamsungPhysicalSummary(date);
+      return JSON.parse(result);
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      const result = await RookSdk.getHealthConnectPhysicalSummary(date);
+      return JSON.parse(result);
+    }
+
+    return RookSdk.getAppleHealthPhysicalSummary(date);
+  };
+
+  const getBodySummary = async ({
+    date,
+    source,
+  }: Params): Promise<BodySummary> => {
+    isModuleReady(ready);
+    isValidDate(date);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await RookSdk.getSamsungBodySummary(date);
+      return JSON.parse(result);
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      const result = await RookSdk.getHealthConnectBodySummary(date);
+      return JSON.parse(result);
+    }
+
+    return RookSdk.getAppleHealthBodySummary(date);
+  };
+
+  const getActivityEvents = async ({
+    date,
+    source,
+  }: Params): Promise<ActivityEvent[]> => {
+    isModuleReady(ready);
+    isValidDate(date);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await RookSdk.getSamsungActivityEvents(date);
+      return JSON.parse(result);
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      const result = await RookSdk.getHealthConnectActivityEvents(date);
+      return JSON.parse(result);
+    }
+
+    return RookSdk.getAppleHealthActivityEvents(date);
+  };
+
+  const getTodayHeartRate = async (
+    source: SDKDataSource
+  ): Promise<HeartRateData> => {
+    if (Platform.OS !== 'android' && source === SDKDataSource.APPLE_HEALTH) {
+      return RookSdk.getTodayHeartRate() as unknown as HeartRateData;
+    }
+
+    throw new Error('Please check the data source');
+  };
+
+  return {
+    ready,
+    getSleepSummary,
+    getPhysicalSummary,
+    getBodySummary,
+    getActivityEvents,
+    getTodayHeartRate,
+  };
+};