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

package/src/context/RookSyncGateProvider.tsx

@@ -7,12 +7,14 @@ import type {
 } from './RookSyncGateTypes';
 import { RookSyncGateContext } from './RookSyncGateContext';
 import RookSdk from '../NativeRookSdk';
-import { useRookAutoSync } from '../modules/hook/useRookAutoSync';
+import { RookStateManager } from '../modules/components/RookStateManager';
 
 const initialState: RookSyncGateState = {
   clientUUID: '',
   environment: 'sandbox',
-  password: '',
+  secret: '',
+  bundleId: undefined,
+  packageName: undefined,
   ready: false,
   userID: '',
   permissions: 0,
@@ -26,42 +28,38 @@ const initialState: RookSyncGateState = {
 const RookSyncGateProvider: FC<RookSyncGateProviderProps> = ({
   environment,
   clientUUID,
-  password,
+  secret,
+  bundleId,
+  packageName,
   children,
   enableLogs = false,
   enableBackgroundSync,
-  enableEventsBackgroundSync = true,
 }) => {
   const [state, dispatch] = useReducer(rookSyncGateReducer, initialState);
 
-  const { startBackgroundServices } = useRookAutoSync({
-    state,
-    enableBackground: enableBackgroundSync,
-    enableLogs,
-  });
-
   useEffect(() => {
     initModule();
-  }, [environment, clientUUID, password]);
+  }, [environment, clientUUID, secret]);
 
   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_SECRET', secret });
+    dispatch({ type: 'SET_BUNDLE_ID', bundle: bundleId });
+    dispatch({ type: 'SET_PACKAGE_NAME', package: packageName });
     dispatch({ type: 'SET_ENABLE_LOGS', enableLogs });
 
     try {
       await RookSdk.initRook({
         environment,
         clientUUID,
-        password,
+        secret,
+        bundleId,
+        packageName,
         enableLogs,
-        enableEventsBackgroundSync,
         enableBackground: enableBackgroundSync,
       });
 
-      if (enableBackgroundSync) startBackgroundServices();
-
       dispatch({ type: 'SET_READY', ready: true });
     } catch (error) {
       console.log(error);
@@ -70,6 +68,12 @@ const RookSyncGateProvider: FC<RookSyncGateProviderProps> = ({
 
   return (
     <RookSyncGateContext.Provider value={{ state, dispatch }}>
+      <RookStateManager
+        state={state}
+        enableBackground={enableBackgroundSync}
+        enableLogs={enableLogs}
+      />
+
       {children}
     </RookSyncGateContext.Provider>
   );

package/src/context/RookSyncGateReducer.ts

@@ -26,8 +26,12 @@ export const rookSyncGateReducer = (
       return { ...state, environment: action.environment };
     case 'SET_CLIENT_UUID':
       return { ...state, clientUUID: action.clientUUID };
-    case 'SET_PASSWORD':
-      return { ...state, password: action.password };
+    case 'SET_SECRET':
+      return { ...state, secret: action.secret };
+    case 'SET_BUNDLE_ID':
+      return { ...state, bundleId: action.bundle };
+    case 'SET_PACKAGE_NAME':
+      return { ...state, packageName: action.package };
     case 'SET_USER_ID':
       return { ...state, userID: action.userID };
     case 'SET_ENABLE_LOGS':

package/src/context/RookSyncGateTypes.ts

@@ -5,7 +5,9 @@ export type Environment = 'sandbox' | 'production';
 type RookSyncGateState = {
   clientUUID: string;
   environment: Environment;
-  password: string;
+  secret: string;
+  bundleId?: string;
+  packageName?: string;
   ready: boolean;
   userID: string;
   permissions: number;
@@ -15,7 +17,9 @@ type RookSyncGateState = {
 type Action =
   | { type: 'SET_CLIENT_UUID'; clientUUID: string }
   | { type: 'SET_ENABLE_LOGS'; enableLogs: boolean }
-  | { type: 'SET_PASSWORD'; password: string }
+  | { type: 'SET_SECRET'; secret: string }
+  | { type: 'SET_BUNDLE_ID'; bundle: string | undefined }
+  | { type: 'SET_PACKAGE_NAME'; package: string | undefined }
   | { type: 'SET_PERMISSIONS' }
   | { type: 'SET_READY'; ready: boolean }
   | { type: 'SET_ROOK_ENVIRONMENT'; environment: Environment }
@@ -25,7 +29,9 @@ type RookSyncGateProviderProps = {
   children: ReactNode;
   environment: Environment;
   clientUUID: string;
-  password: string;
+  secret: string;
+  bundleId?: string;
+  packageName?: string;
   enableLogs?: boolean;
   enableBackgroundSync: boolean;
   enableEventsBackgroundSync?: boolean;

package/src/hooks/useRookConfiguration.ts

@@ -1,8 +1,9 @@
-import RookSdk from '../NativeRookSdk';
+import RookSdk, { type DiagnosticState } from '../NativeRookSdk';
 
 import { useRookSyncGateContext } from '../context/RookSyncGateContext';
 import { isModuleReady } from '../utils/isModuleReady';
-import { type SDKDataSource } from '../types/SDKSources';
+import { SDKDataSource } from '../types/SDKSources';
+import { Platform } from 'react-native';
 
 /**
  * The `useRookConfiguration` hook provides various asynchronous methods for managing the configuration
@@ -72,11 +73,34 @@ export const useRookConfiguration = () => {
     return RookSdk.removeUserFromRook(sources);
   };
 
+  const getDiagnosticState = async (
+    source: SDKDataSource
+  ): Promise<DiagnosticState> => {
+    isModuleReady(ready);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      const value = await RookSdk.getHealthConnectDiagnosticState();
+      return JSON.parse(value);
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      const value = await RookSdk.getSamsungHealthDiagnosticState();
+      return JSON.parse(value);
+    }
+
+    if (Platform.OS !== 'android' && source === SDKDataSource.APPLE_HEALTH) {
+      return RookSdk.getDiagnosticState();
+    }
+
+    throw new Error('Check the datasource');
+  };
+
   return {
     ready,
     getUserID,
     updateUserID,
     removeUserFromRook,
     syncUserTimeZone,
+    getDiagnosticState,
   };
 };

package/src/hooks/useRookData.ts

@@ -1,15 +1,16 @@
-import RookSdk from '../NativeRookSdk';
+import RookSdk, { type WriteNutrition } from '../NativeRookSdk';
 import { Platform } from 'react-native';
 
 import { isModuleReady } from '../utils/isModuleReady';
-import { isValidDate } from '../utils/isValidDate';
+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 { type HeartRateData } from '../types/HeartRateEvent';
+import { parseWriteNutritionToHC } from '../types/HCMealData';
+import { parseWriteNutritionToAH } from '../types/AppleHealthNutritionEvent';
 
 type Params = {
   date: string;
@@ -101,11 +102,21 @@ export const useRookData = () => {
     return RookSdk.getAppleHealthActivityEvents(date);
   };
 
-  const getTodayHeartRate = async (
+  const writeNutritionData = async (
+    data: WriteNutrition,
     source: SDKDataSource
-  ): Promise<HeartRateData> => {
+  ): 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) {
-      return RookSdk.getTodayHeartRate() as unknown as HeartRateData;
+      const event = parseWriteNutritionToAH(data);
+      return RookSdk.writeAppleHealthMealData(event);
     }
 
     throw new Error('Please check the data source');
@@ -117,6 +128,6 @@ export const useRookData = () => {
     getPhysicalSummary,
     getBodySummary,
     getActivityEvents,
-    getTodayHeartRate,
+    writeNutritionData,
   };
 };

package/src/hooks/useRookPermissions.ts

@@ -202,6 +202,20 @@ export const useRookPermissions = () => {
     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,
@@ -217,8 +231,10 @@ export const useRookPermissions = () => {
     requestAppleHealthPermissions,
     requestHealthConnectPermissions,
     requestSamsungHealthPermissions,
+    requestAppleWriteNutritionPermission,
     samsungHealthHasPartialPermissions,
     samsungHealthHasPermissions,
     revokeHealthConnectPermissions,
+    shouldRequestAndroidBackgroundPermissions,
   };
 };

package/src/hooks/useRookSync.ts

@@ -34,7 +34,7 @@ export const useRookSync = () => {
 
   const syncWithOutParams = async (callback: Callback) => {
     if (Platform.OS === 'android') {
-      const hcResult: any = await convertToPromise([enableLogs], RookSdk.sync);
+      const hcResult: any = await convertToPromise([], RookSdk.sync);
 
       RookSdk.shSync(enableLogs, (err: RookError, result: boolean) => {
         callback({

package/src/hooks/useRookVariables.ts

@@ -1,4 +1,4 @@
-import RookSdk from '../NativeRookSdk';
+import RookSdk, { type HeartRateData } from '../NativeRookSdk';
 import { Platform } from 'react-native';
 import { isModuleReady } from '../utils/isModuleReady';
 import { useRookSyncGateContext } from '../context/RookSyncGateContext';
@@ -69,9 +69,30 @@ export const useRookVariables = () => {
     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/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/src/modules/hook/useRookAutoSync.ts

@@ -67,9 +67,11 @@ export const useRookAutoSync = ({
   }, [state, changeAppState]);
 
   const startBackgroundServices = () => {
-    const { clientUUID, password, ready } = state;
+    const { clientUUID, secret, ready } = state;
 
-    if (!ready || !clientUUID || !password) {
+    if (!enableBackground) return;
+
+    if (!ready || !clientUUID || !secret) {
       return;
     }
 
@@ -184,9 +186,9 @@ export const useRookAutoSync = ({
    * broadcast with `value` set to `false` and an error message is logged.
    */
   const startAndroidBackgroundSync = async () => {
-    const { clientUUID, password, ready } = state;
+    const { clientUUID, secret, ready } = state;
 
-    if (!ready || !clientUUID || !password) {
+    if (!ready || !clientUUID || !secret) {
       return;
     }
 

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/types/AppleHealthNutritionEvent.ts

@@ -0,0 +1,142 @@
+import type { WriteNutrition } from './WriteNutrition';
+
+/**
+ * Represents the unit of measurement for nutrition.
+ * Map these integers to your SDK's unit requirements (e.g., Grams, Calories).
+ */
+export interface NutritionInsertionEventQuantity {
+  unit: number;
+  amount: number;
+}
+
+export interface NutritionInsertionEnergyWaterDataRelated {
+  dietaryKiloCaloriesEnergyConsumed?: number;
+  dietaryMilliLiterWater?: number;
+}
+
+export interface NutritionCarbohydratesDataRelated {
+  dietaryGramCarbohydrates?: number;
+  dietaryGramFiber?: number;
+  dietaryGramSugar?: number;
+}
+
+export interface NutritionFatsDataRelated {
+  dietaryGramFatTotal?: number;
+  dietaryGramFatSaturated?: number;
+  dietaryGramFatMonounsaturated?: number;
+  dietaryGramFatPolyunsaturated?: number;
+}
+
+export interface NutritionProteinDataRelated {
+  dietaryGramProtein?: number;
+  dietaryMilliGramCholesterol?: number;
+}
+
+export interface NutritionVitaminsDataRelated {
+  dietaryMicroGramVitaminA?: number;
+  dietaryMilliGramVitaminB6?: number;
+  dietaryMicroGramVitaminB12?: number;
+  dietaryMilliGramVitaminC?: number;
+  dietaryMicroGramVitaminD?: number;
+  dietaryMilliGramVitaminE?: number;
+  dietaryMicroGramVitaminK?: number;
+  dietaryMilliGramThiamin?: number;
+  dietaryMilliGramRiboflavin?: number;
+  dietaryMilliGramNiacin?: number;
+  dietaryMilliGramPantothenicAcid?: number;
+  dietaryMicroGramFolate?: number;
+  dietaryMicroGramBiotin?: number;
+}
+
+export interface NutritionMineralDataRelated {
+  dietaryMilliGramsCalcium?: number;
+  dietaryMilliGramsChloride?: number;
+  dietaryMilliGramsChromium?: number;
+  dietaryMilliGramsCopper?: number;
+  dietaryMilliGramsIodine?: number;
+  dietaryMilliGramsIron?: number;
+  dietaryMilliGramsMagnesium?: number;
+  dietaryMilliGramsManganese?: number;
+  dietaryMilliGramsMolybdenum?: number;
+  dietaryMilliGramsPhosphorus?: number;
+  dietaryMilliGramsPotassium?: number;
+  dietaryMilliGramsSelenium?: number;
+  dietaryMilliGramsSodium?: number;
+  dietaryMilliGramsZinc?: number;
+}
+
+/**
+ * Main Interface for Apple Health Nutrition Insertion
+ */
+export interface AHNutritionInsertionEvent {
+  name: string;
+  quantity: NutritionInsertionEventQuantity;
+  /** ISO-8601 string (e.g., new Date().toISOString()) */
+  date: string;
+  energyWaterData?: NutritionInsertionEnergyWaterDataRelated;
+  carbohydratesData?: NutritionCarbohydratesDataRelated;
+  fatsData?: NutritionFatsDataRelated;
+  proteinData?: NutritionProteinDataRelated;
+  vitaminsData?: NutritionVitaminsDataRelated;
+  mineralData?: NutritionMineralDataRelated;
+}
+
+export const parseWriteNutritionToAH = (
+  data: WriteNutrition
+): AHNutritionInsertionEvent => {
+  return {
+    name: data.name,
+    date: data.date,
+    quantity: { unit: data.unit ?? 1, amount: data.amount ?? 0 },
+    energyWaterData: {
+      dietaryKiloCaloriesEnergyConsumed: data.calories,
+      dietaryMilliLiterWater: data.water,
+    },
+    carbohydratesData: {
+      dietaryGramCarbohydrates: data.totalCarbohydrates,
+      dietaryGramFiber: data.dietaryFiber,
+      dietaryGramSugar: data.sugar,
+    },
+    fatsData: {
+      dietaryGramFatTotal: data.totalFat,
+      dietaryGramFatSaturated: data.saturatedFat,
+      dietaryGramFatMonounsaturated: data.monounsaturatedFat,
+      dietaryGramFatPolyunsaturated: data.polyunsaturatedFat,
+    },
+    proteinData: {
+      dietaryGramProtein: data.protein,
+      dietaryMilliGramCholesterol: data.cholesterol,
+    },
+    vitaminsData: {
+      dietaryMicroGramVitaminA: data.vitaminA,
+      dietaryMilliGramVitaminB6: data.vitaminB6,
+      dietaryMicroGramVitaminB12: data.vitaminB12,
+      dietaryMilliGramVitaminC: data.vitaminC,
+      dietaryMicroGramVitaminD: data.vitaminD,
+      dietaryMilliGramVitaminE: data.vitaminE,
+      dietaryMicroGramVitaminK: data.vitaminK,
+      dietaryMilliGramThiamin: data.thiamin,
+      dietaryMilliGramRiboflavin: data.riboflavin,
+      dietaryMilliGramNiacin: data.niacin,
+      dietaryMilliGramPantothenicAcid: data.pantothenicAcid,
+      dietaryMicroGramFolate: data.folate,
+      dietaryMicroGramBiotin: data.biotin,
+    },
+    mineralData: {
+      dietaryMilliGramsCalcium: data.calcium,
+      dietaryMilliGramsChloride: data.chloride,
+      dietaryMilliGramsChromium: data.chromium,
+      dietaryMilliGramsCopper: data.copper,
+      dietaryMilliGramsIodine: data.iodine,
+      dietaryMilliGramsIron: data.iron,
+      dietaryMilliGramsMagnesium: data.magnesium,
+      dietaryMilliGramsManganese: data.manganese,
+      dietaryMilliGramsMolybdenum: data.molybdenum,
+      dietaryMilliGramsPhosphorus: data.phosphorus,
+      dietaryMilliGramsPotassium: data.potassium,
+      dietaryMilliGramsSelenium: data.selenium,
+      dietaryMilliGramsSodium: data.sodium,
+      dietaryMilliGramsZinc: data.zinc,
+    },
+  };
+};