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

package/src/hooks/useRookData.ts

@@ -0,0 +1,133 @@
+import RookSdk, { type WriteNutrition } from '../NativeRookSdk';
+import { Platform } from 'react-native';
+
+import { isModuleReady } from '../utils/isModuleReady';
+import { isValidDate, isValidZonedDateTime } 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 { parseWriteNutritionToHC } from '../types/HCMealData';
+import { parseWriteNutritionToAH } from '../types/AppleHealthNutritionEvent';
+
+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 writeNutritionData = async (
+    data: WriteNutrition,
+    source: SDKDataSource
+  ): Promise<boolean> => {
+    isModuleReady(ready);
+    isValidZonedDateTime(data.date);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      const event = parseWriteNutritionToHC(data);
+      return RookSdk.writeHealthConnectMealData(event);
+    }
+
+    if (Platform.OS !== 'android' && source === SDKDataSource.APPLE_HEALTH) {
+      const event = parseWriteNutritionToAH(data);
+      return RookSdk.writeAppleHealthMealData(event);
+    }
+
+    throw new Error('Please check the data source');
+  };
+
+  return {
+    ready,
+    getSleepSummary,
+    getPhysicalSummary,
+    getBodySummary,
+    getActivityEvents,
+    writeNutritionData,
+  };
+};

package/src/hooks/useRookHealthConnect.ts

@@ -0,0 +1,59 @@
+import RookSdk from '../NativeRookSdk';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import isRunningOnAndroid from '../utils/isRunningOnAndroid';
+
+export const useRookHealthConnect = () => {
+  const {
+    state: { ready, enableLogs },
+  } = useRookSyncGateContext();
+
+  /**
+   * Schedules the background synchronization of health data using Rook.
+   *
+   * This function enables automatic background data synchronization with Rook.
+   * It ensures that health data is periodically fetched and sent to Rook’s API
+   * based on the defined configuration.
+   *
+   * If the scheduling is successful, the promise resolves with true.
+   * If an error occurs, the promise rejects with an error message.
+   *
+   * @param promise A React Native promise that resolves when the sync is scheduled successfully or rejects with an error.
+   */
+  const scheduleBackgroundSync = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+    return RookSdk.scheduleBackgroundSync(enableLogs);
+  };
+
+  /**
+   * Cancels the scheduled background synchronization of health data.
+   *
+   * This function stops the automatic background sync previously scheduled using Rook.
+   * It ensures that no further health data is fetched and sent until scheduled again.
+   *
+   * If the cancellation is successful, the promise resolves with true.
+   * If an error occurs, the promise rejects with an error message.
+   *
+   * @param promise A React Native promise that resolves when the sync is canceled successfully or rejects with an error.
+   */
+  const cancelBackgroundSync = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+    return RookSdk.cancelBackgroundSync();
+  };
+
+  const isBackgroundSyncEnabled = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.isBackgroundSyncEnabled();
+  };
+
+  return {
+    ready,
+    scheduleBackgroundSync,
+    cancelBackgroundSync,
+    isBackgroundSyncEnabled,
+  };
+};

package/src/hooks/useRookPermissions.ts

@@ -0,0 +1,240 @@
+import RookSdk from '../NativeRookSdk';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import isRunningOnAndroid from '../utils/isRunningOnAndroid';
+import { isRunningOniOS } from '../utils/isRunningOniOS';
+import { SamsungHealthPermission } from '../types/SamsungHealthPermissions';
+import { AppleHealthPermission } from '../types/AppleHealthPermissions';
+import type {
+  BackgroundStatus,
+  PermissionStatus,
+} from '../types/PermissionsType';
+
+export type RequestStatusPermissions = 'REQUEST_SENT' | 'ALREADY_GRANTED';
+type CheckAvailabilityResponse =
+  | 'INSTALLED'
+  | 'NOT_INSTALLED'
+  | 'DISABLED'
+  | 'NOT_READY'
+  | 'OUTDATED'
+  | 'NOT_SUPPORTED';
+
+/**
+ * The `useRookPermissions` hook manages permissions for accessing Apple Health and Health Connect data,
+ * including requesting various types of permissions and checking their status.
+ * @returns The `useRookPermissions` hook is being returned, which provides various functions related
+ * to requesting and checking permissions for Apple Health. The hook returns an object containing the
+ * following properties and functions:
+ */
+export const useRookPermissions = () => {
+  const {
+    state: { ready },
+    dispatch,
+  } = useRookSyncGateContext();
+
+  /**
+   * The function `checkAvailability` checks the availability of the health services
+   * @returns The function `checkAvailability` returns a Promise that resolves to a
+   * `CheckAvailabilityResponse` | 'INSTALLED' | 'NOT_INSTALLED' | 'NOT_SUPPORTED';
+   */
+  const checkHealthConnectAvailability =
+    (): Promise<CheckAvailabilityResponse> => {
+      isModuleReady(ready);
+      isRunningOnAndroid();
+
+      return RookSdk.checkHealthConnectAvailability();
+    };
+
+  const checkSamsungAvailability = (): Promise<CheckAvailabilityResponse> => {
+    isModuleReady(ready);
+    isRunningOnAndroid();
+
+    return RookSdk.checkSamsungAvailability();
+  };
+
+  /**
+   * The function `healthConnectHasPermissions` checks if the app has permissions for health connect data
+   * access.
+   * @returns The function `healthConnectHasPermissions` is returning a boolean`.
+   */
+  const healthConnectHasPermissions = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.healthConnectHasPermissions();
+  };
+
+  /**
+   * The function `healthConnectHasPermissions` checks if the app has at least one permission for health connect data
+   * access.
+   * @returns The function `healthConnectHasPermissions` is returning a boolean`.
+   */
+  const healthConnectHasPartialPermissions = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.healthConnectHasPartialPermissions();
+  };
+
+  /**
+   * The function `appleHealthHasPermissions` checks if the app has permissions for apple health data
+   * access.
+   * @returns The function `healthConnectHasPermissions` is returning a boolean`.
+   */
+  const appleHealthHasPermissions = (
+    param: AppleHealthPermission
+  ): Promise<PermissionStatus> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.appleHealthHasPermissions(param);
+  };
+
+  const samsungHealthHasPermissions = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.samsungHealthHasPermissions();
+  };
+
+  const samsungHealthHasPartialPermissions = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.samsungHealthHasPartialPermissions();
+  };
+
+  /**
+   * The function `requestAllHealthConnectPermissions` requests all permissions for health connect
+   */
+  const requestHealthConnectPermissions =
+    async (): Promise<RequestStatusPermissions> => {
+      isRunningOnAndroid();
+      isModuleReady(ready);
+
+      return RookSdk.requestHealthConnectPermissions();
+    };
+
+  const requestAppleHealthPermissions = async (
+    permissions?: AppleHealthPermission[]
+  ): Promise<boolean> => {
+    isModuleReady(ready);
+    isRunningOniOS();
+
+    const bridge = permissions || Object.values(AppleHealthPermission);
+    const result = await RookSdk.requestAppleHealthPermissions(bridge);
+
+    dispatch({ type: 'SET_PERMISSIONS' });
+
+    return result;
+  };
+
+  const requestSamsungHealthPermissions = async (
+    permissions?: SamsungHealthPermission[]
+  ): Promise<RequestStatusPermissions> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    const bridge = permissions || Object.values(SamsungHealthPermission);
+    const result = await RookSdk.requestSamsungHealthPermissions(bridge);
+
+    return result;
+  };
+
+  /**
+   * The function `openAppleHealthSettings` opens the apple health settings
+   */
+  const openAppleHealthSettings = async (): Promise<void> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.openAppleHealthSettings();
+  };
+
+  /**
+   * The function `openHealthConnectSettings` opens the health connect settings
+   */
+  const openHealthConnectSettings = async (): Promise<void> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.openHealthConnectSettings();
+  };
+
+  /**
+   * The function `requestAndroidBackgroundPermissions` requests background permissions for an Android
+   * in other to extract data from Health Connect
+   * @returns The `requestBackgroundPermissions` function is being returned as a Promise<void>.
+   */
+  const requestAndroidBackgroundPermissions =
+    (): Promise<RequestStatusPermissions> => {
+      isRunningOnAndroid();
+      isModuleReady(ready);
+
+      return RookSdk.requestAndroidBackgroundPermissions();
+    };
+
+  /**
+   * The function `hasAndroidBackgroundPermissions` checks if the app has background permissions on an
+   * Android device.
+   * @returns The function `hasBackgroundPermissions()` is returning a boolean indicating the status of
+   * the permissions.
+   */
+  const androidHasBackgroundPermissions = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.androidHasBackgroundPermissions();
+  };
+
+  const checkHealthConnectBackgroundReadStatus =
+    (): Promise<BackgroundStatus> => {
+      isRunningOnAndroid();
+      isModuleReady(ready);
+
+      return RookSdk.checkHealthConnectBackgroundReadStatus();
+    };
+
+  const revokeHealthConnectPermissions = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.revokeHealthConnectPermissions();
+  };
+
+  const requestAppleWriteNutritionPermission = async (): Promise<void> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.requestAppleWriteNutritionPermission();
+  };
+
+  const shouldRequestAndroidBackgroundPermissions = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.shouldRequestAndroidBackgroundPermissions();
+  };
+
+  return {
+    ready,
+    androidHasBackgroundPermissions,
+    appleHealthHasPermissions,
+    checkHealthConnectAvailability,
+    checkHealthConnectBackgroundReadStatus,
+    checkSamsungAvailability,
+    healthConnectHasPartialPermissions,
+    healthConnectHasPermissions,
+    openAppleHealthSettings,
+    openHealthConnectSettings,
+    requestAndroidBackgroundPermissions,
+    requestAppleHealthPermissions,
+    requestHealthConnectPermissions,
+    requestSamsungHealthPermissions,
+    requestAppleWriteNutritionPermission,
+    samsungHealthHasPartialPermissions,
+    samsungHealthHasPermissions,
+    revokeHealthConnectPermissions,
+    shouldRequestAndroidBackgroundPermissions,
+  };
+};

package/src/hooks/useRookSamsungHealth.ts

@@ -0,0 +1,37 @@
+import RookSdk from '../NativeRookSdk';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import isRunningOnAndroid from '../utils/isRunningOnAndroid';
+
+export const useRookSamsungHealth = () => {
+  const {
+    state: { ready },
+  } = useRookSyncGateContext();
+
+  const enableSamsungSync = async (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.enableSamsungSync();
+  };
+
+  const isSamsungSyncEnabled = async (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.isSamsungSyncEnabled();
+  };
+
+  const disableSamsungSync = async (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.disableSamsungSync();
+  };
+  return {
+    ready,
+    enableSamsungSync,
+    disableSamsungSync,
+    isSamsungSyncEnabled,
+  };
+};

package/src/hooks/useRookSync.ts

@@ -0,0 +1,157 @@
+import RookSdk from '../NativeRookSdk';
+import { Platform } from 'react-native';
+
+import { isModuleReady } from '../utils/isModuleReady';
+import { isValidDate } from '../utils/isValidDate';
+import type {
+  Callback,
+  SyncEventParams,
+  SyncParams,
+  RookError,
+} from '../types/SyncTypes';
+import { SDKDataSource } from '../types/SDKSources';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+
+export const useRookSync = () => {
+  const {
+    state: { ready, enableLogs },
+  } = useRookSyncGateContext();
+
+  const createResultPayload = (result: any) => {
+    if (!result) {
+      return undefined;
+    }
+    return { status: result.result, error: result.error };
+  };
+
+  const convertToPromise = (params: any[], toPromise: Function) => {
+    return new Promise((resolve) => {
+      toPromise(...params, (error: Error, result: boolean) => {
+        resolve({ error, result });
+      });
+    });
+  };
+
+  const syncWithOutParams = async (callback: Callback) => {
+    if (Platform.OS === 'android') {
+      const hcResult: any = await convertToPromise([], RookSdk.sync);
+
+      RookSdk.shSync(enableLogs, (err: RookError, result: boolean) => {
+        callback({
+          healthConnect: {
+            status: hcResult.result,
+            error: hcResult.error,
+          },
+          samsungHealth: {
+            status: result,
+            error: err,
+          },
+        });
+      });
+
+      return;
+    }
+
+    RookSdk.sync((error: RookError, result: boolean) => {
+      callback({
+        appleHealth: {
+          status: result,
+          error,
+        },
+      });
+    });
+  };
+
+  const syncWithParams = async (params: SyncParams, callback: Callback) => {
+    isValidDate(params.date);
+
+    const promisesToRun = [];
+    const { sources, summary, date } = params;
+    const isAndroid = Platform.OS === 'android';
+
+    const args = [date];
+    let bridgeMethod: Function = RookSdk.syncByDate;
+    let shBridgeMethod: Function = RookSdk.shSyncByDate;
+
+    if (summary) {
+      args.unshift(summary);
+      bridgeMethod = RookSdk.syncByDefinition;
+      shBridgeMethod = RookSdk.shSyncByDefinition;
+    }
+
+    const shouldSyncSO =
+      sources.includes(SDKDataSource.APPLE_HEALTH) ||
+      sources.includes(SDKDataSource.HEALTH_CONNECT);
+
+    const shouldSyncSH =
+      sources.includes(SDKDataSource.SAMSUNG_HEALTH) && isAndroid;
+
+    if (shouldSyncSO) {
+      promisesToRun.push(convertToPromise(args, bridgeMethod));
+    }
+
+    if (shouldSyncSH) {
+      promisesToRun.push(convertToPromise(args, shBridgeMethod));
+    }
+
+    const results = await Promise.all(promisesToRun);
+    const SOResult = shouldSyncSO ? results.shift() : null;
+    const shResult = shouldSyncSH ? results.shift() : null;
+
+    callback({
+      appleHealth: !isAndroid ? createResultPayload(SOResult) : undefined,
+      healthConnect: isAndroid ? createResultPayload(SOResult) : undefined,
+      samsungHealth: createResultPayload(shResult),
+    });
+  };
+
+  const sync = (callback: Callback, params?: SyncParams): void => {
+    isModuleReady(ready);
+
+    if (!params) {
+      syncWithOutParams(callback);
+      return;
+    }
+
+    if (params && params.summary && !params.date) {
+      throw new Error('Date is missing');
+    }
+
+    syncWithParams(params, callback);
+  };
+
+  const syncEvents = async (params: SyncEventParams): Promise<boolean> => {
+    isModuleReady(ready);
+
+    const { date, event, sources } = params;
+    const isAndroid = Platform.OS === 'android';
+
+    const promisesToRun = [];
+    const parsedEvent = isAndroid ? event : event.toLowerCase();
+
+    const shouldSyncSO =
+      sources.includes(SDKDataSource.APPLE_HEALTH) ||
+      sources.includes(SDKDataSource.HEALTH_CONNECT);
+
+    const shouldSyncSH =
+      sources.includes(SDKDataSource.SAMSUNG_HEALTH) && isAndroid;
+
+    if (shouldSyncSO) {
+      if (['hydration', 'nutrition'].includes(params.event) && !isAndroid)
+        throw new Error(`${params.event} is not available on iOS`);
+
+      promisesToRun.push(RookSdk.syncEvent(date, parsedEvent));
+    }
+
+    if (shouldSyncSH) promisesToRun.push(RookSdk.shSyncEvent(date, event));
+
+    await Promise.all(promisesToRun);
+
+    return true;
+  };
+
+  return {
+    sync,
+    syncEvents,
+  };
+};