@situm/react-native 3.0.10 → 3.1.0

package/src/wayfinding/hooks/index.ts

@@ -1,480 +1,250 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { useContext, useEffect, useRef, useState } from "react";
+import { useContext, useState } from "react";
 
 import SitumPlugin from "../../sdk";
 import {
   type Building,
-  type DirectionPoint,
-  type LocationRequestOptions,
+  type Error,
+  type Location,
   type LocationStatus,
-  type Poi,
-  type Position,
-  type SDKError,
-  type SDKNavigation,
+  type NavigationProgress,
 } from "../../sdk/types";
 import {
   LocationStatusName,
   NavigationStatus,
   NavigationUpdateType,
 } from "../../sdk/types/constants";
-import { requestPermission } from "../../utils/requestPermission";
 import {
   resetLocation,
-  selectBuildings,
-  selectCurrentBuilding,
-  selectDestinationPoiID,
   selectDirections,
   selectError,
-  selectIsSDKInitialized as selectIsSdkInitialized,
   selectLocation,
   selectLocationStatus,
   selectNavigation,
-  selectPois,
-  selectUser,
-  setAuth,
-  setBuildings,
-  setCurrentBuilding,
-  setDestinationPoiID,
   setDirections,
   setError,
   setLocation,
   setLocationStatus,
   setNavigation,
-  setPois,
-  setSdkInitialized,
-  type State,
   UseSitumContext,
 } from "../store/index";
 import { useDispatch, useSelector } from "../store/utils";
+import {
+  createDirectionsMessage,
+  createDirectionsRequest,
+  createNavigationRequest,
+} from "../utils/mapper";
 
-const defaultNavigationOptions = {
+const defaultNavigationRequest = {
   distanceToGoalThreshold: 4,
   outsideRouteThreshold: 5,
 };
 
-// Hook to define references that point to functions
-// used on listeners. These references are updated whenever
-// one of the dependencies on the array change
-export const useCallbackRef = <T>(fn: T, deps: any[]) => {
-  const fnRef = useRef(fn);
-
-  useEffect(() => {
-    fnRef.current = fn;
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, deps);
-
-  return fnRef;
-};
-
 export const useSitumInternal = () => {
   const dispatch = useDispatch();
-  const isSdkInitialized = useSelector(selectIsSdkInitialized);
-  const user = useSelector(selectUser);
+
   const location = useSelector(selectLocation);
   const locationStatus = useSelector(selectLocationStatus);
-  const buildings = useSelector(selectBuildings);
-  const currentBuilding = useSelector(selectCurrentBuilding);
-  const pois = useSelector(selectPois);
+
   const directions = useSelector(selectDirections);
   const navigation = useSelector(selectNavigation);
   const error = useSelector(selectError);
-  const destinationPoiID = useSelector(selectDestinationPoiID);
 
   const [lockDirections, setLockDirections] = useState<boolean>(false);
 
-  const initSitumSdk = async ({
-    email,
-    apiKey,
-    startPositions = true,
-    fetchCartography = true,
-    useRemoteConfig = true,
-  }: {
-    email?: string;
-    apiKey?: string;
-    startPositions?: boolean;
-    fetchCartography?: boolean;
-    useRemoteConfig?: boolean;
-  }) =>
-    // TODO fix this async/await
-    // eslint-disable-next-line no-async-promise-executor
-    new Promise<void>(async (resolve, reject) => {
-      if (!isSdkInitialized) {
-        SitumPlugin.initSitumSDK();
-        setSdkInitialized(true);
-      }
-
-      if (email && apiKey) {
-        dispatch(setAuth({ email, apiKey }));
-      } else {
-        email = user.email;
-        apiKey = user.apiKey;
-      }
-
-      SitumPlugin.setApiKey(email, apiKey, (response: any) => {
-        if (response && Boolean(response.success) === true) {
-          console.debug("Situm > hook > Successful authentication.");
-        } else {
-          reject("Situm > hook > Failure while authenticating.");
-        }
-      });
-
-      useRemoteConfig &&
-        SitumPlugin.setUseRemoteConfig(`${useRemoteConfig}`, () => {
-          console.debug("Situm > hook > Using remote config");
-        });
-
-      startPositions &&
-        (await requestPermission()
-          .then(() => {
-            startPositioning();
-          })
-          .catch((e: string) => {
-            console.error(e);
-            reject(e);
-          }));
-
-      fetchCartography &&
-        (await initializeBuildings().catch((e: string) => {
-          console.error(e);
-          reject(e);
-        }));
-
-      resolve();
-    });
+  const init = () => {
+    console.debug("Situm > hook > Initializing -> Registering callbacks");
+    registerCallbacks();
+  };
 
-  // Cartography
-  const initializeBuildings = async () =>
-    new Promise<Building[]>((resolve, reject) => {
-      console.debug("Situm > hook > Retrieving buildings from Situm API");
-
-      SitumPlugin.fetchBuildings(
-        (buildingArray: Building[]) => {
-          dispatch(setBuildings(buildingArray));
-          console.debug("Situm > hook > Successfully retrieved buildings.");
-          resolve(buildingArray);
-        },
-        (_error: string) => {
-          console.error(
-            `Situm > hook > Could not retrieve buildings: ${_error}`
-          );
-          reject(`Situm > hook> Could not retrieve buildings: ${_error}`);
-          dispatch(setError({ message: _error, code: 3011 } as SDKError));
-        }
+  function registerCallbacks() {
+    SitumPlugin.onLocationUpdate((loc: Location) => {
+      dispatch(
+        setLocation({
+          ...loc,
+        })
       );
     });
 
-  const initializeBuildingById = async (buildingId: string) => {
-    if (!buildings || buildings.length === 0) return;
-    const newBuilding = buildings.find(
-      (b: Building) => b.buildingIdentifier === buildingId
-    );
-    if (newBuilding) {
-      dispatch(setCurrentBuilding(newBuilding));
-      initializeBuildingPois(newBuilding);
-    } else {
-      console.warn(`Situm > hook > No building found for id ${buildingId}`);
-    }
-  };
-
-  const initializeBuilding = async (b: Building) => {
-    dispatch(setCurrentBuilding(b));
-    initializeBuildingPois(b);
-  };
-
-  const initializeBuildingPois = (b: Building) => {
-    SitumPlugin.fetchBuildingInfo(
-      b,
-      (buildingInfo: any) => {
+    SitumPlugin.onLocationStatus((status: LocationStatus) => {
+      if (status.statusName in LocationStatusName) {
         console.debug(
-          "Situm > hook > Successfully retrieved pois of the selected building. "
-        );
-
-        // Please, do not change the next line. iOS sends data as indoorPois and Android sends it as indoorPOIs
-        const buildingPois =
-          buildingInfo?.indoorPOIs || buildingInfo?.indoorPois || [];
-        dispatch(setPois(buildingPois));
-      },
-      (err: string) => {
-        console.error(
-          `Situm > hook > Could not initialize building pois: ${error}`
+          `Situm > hook > Positioning state updated ${status.statusName}`
         );
-        dispatch(setError({ message: err, code: 3021 } as SDKError));
+        dispatch(setLocationStatus(status.statusName as LocationStatusName));
       }
-    );
-  };
+    });
 
-  const startPositioning = () => {
-    console.debug("Situm > hook > Starting positioning...");
+    SitumPlugin.onLocationError((err: Error) => {
+      console.error(`Situm > hook > Error while positioning: ${err}}`);
+      //@ts-ignore
+      dispatch(setError({ message: err, code: 3001 } as SDKError));
+    });
 
-    if (location.status !== LocationStatusName.STOPPED) {
-      console.debug("Situm > hook > Positioning has already started");
-      return;
-    }
+    SitumPlugin.onLocationStopped(() => {
+      console.debug("Situm > hook > Stopped positioning");
+      dispatch(resetLocation());
+    });
 
-    // Declare the locationOptions (empty = default parameters)
-    const locationOptions = {
-      useDeadReckoning: false,
-    } as LocationRequestOptions;
-    // Start positioning
-    SitumPlugin.startPositioning(
-      (newLocation: State["location"]) => {
-        dispatch(
-          setLocation({
-            ...newLocation,
-          })
-        );
-      },
-      (status: LocationStatus) => {
-        if (status.statusName in LocationStatusName) {
-          console.debug(
-            `Situm > hook > Positioning state updated ${status.statusName}`
-          );
-          dispatch(setLocationStatus(status.statusName as LocationStatusName));
-        }
-      },
-      (err: string) => {
-        console.error(`Situm > hook > Error while positioning: ${err}}`);
-        //@ts-ignore
-        dispatch(setError({ message: err, code: 3001 } as SDKError));
-      },
-      locationOptions
-    );
-    console.debug(`Situm > hook > Successfully started positioning`);
-  };
+    SitumPlugin.onNavigationProgress((progress: NavigationProgress) => {
+      console.debug("Situm > hook > NavigationProgress");
+
+      dispatch(
+        setNavigation({
+          currentIndication: progress?.currentIndication,
+          routeStep: progress?.routeStep,
+          distanceToGoal: progress?.distanceToGoal,
+          points: progress?.points,
+          type: NavigationUpdateType.PROGRESS,
+          segments: progress?.segments,
+          status: NavigationStatus.UPDATE,
+        })
+      );
+    });
 
-  const stopPositioning = async () => {
-    console.debug(`Situm > hook > Stopping positioning…`);
+    SitumPlugin.onNavigationOutOfRoute(() => {
+      dispatch(
+        setNavigation({
+          type: NavigationUpdateType.OUT_OF_ROUTE,
+          status: NavigationStatus.UPDATE,
+        })
+      );
 
-    SitumPlugin.stopPositioning((success: boolean) => {
-      if (success) {
-        dispatch(resetLocation());
-        console.debug("Situm > hook > Successfully stopped positioning");
-      } else {
-        console.error("Situm > hook > Could not stop positioning");
-      }
+      console.debug("Situm > hook > NavigationOutOfRoute");
     });
-  };
 
-  // Routes
-  const requestDirections = async (
-    building: Building,
-    from: Position,
-    to: Position,
-    directionsOptions?: any
-  ): Promise<State["directions"]> => {
-    console.debug("Situm > hook > Requesting directions");
-
-    const fromPoint = {
-      floorIdentifier: from.floorIdentifier,
-      buildingIdentifier: from.buildingIdentifier,
-      coordinate: from.coordinate,
-    } as DirectionPoint;
-    const toPoint = {
-      floorIdentifier: to.floorIdentifier,
-      buildingIdentifier: to.buildingIdentifier,
-      coordinate: to.coordinate,
-    } as DirectionPoint;
-
-    return new Promise((resolve, reject) => {
-      SitumPlugin.requestDirections(
-        [building, fromPoint, toPoint, directionsOptions],
-        (newDirections: State["directions"]) => {
-          console.debug("Situm > hook > Successfully computed route");
-          resolve(newDirections);
-        },
-        (err: string) => {
-          console.debug(`Situm > hook > Could not compute route: ${err}`);
-          dispatch(setError({ message: err, code: 3041 } as SDKError));
-          reject(err);
-        }
+    SitumPlugin.onNavigationFinished(() => {
+      dispatch(
+        setNavigation({
+          type: NavigationUpdateType.FINISHED,
+          status: NavigationStatus.UPDATE,
+        })
       );
+      console.debug("Situm > hook > NavigationFinished");
     });
-  };
 
-  const calculateRoute = async ({
-    originId,
-    destinationId,
-    directionsOptions,
-    updateRoute = true,
-  }: {
-    originId: number;
-    destinationId: number;
-    directionsOptions?: any;
-    updateRoute?: boolean;
-  }) => {
-    const poiOrigin = pois.find(
-      (p: Poi) => p.identifier === originId?.toString()
-    );
-    const poiDestination = pois.find(
-      (p: Poi) => p.identifier === destinationId?.toString()
+    SitumPlugin.onNavigationError((progress: NavigationProgress) => {
+      console.debug("Situm > hook > NavigationProgress: ", progress);
+    });
+  }
+
+  const calculateRoute = async (payload: any, updateRoute = true) => {
+    console.debug("Situm > hook > calculating route");
+
+    const { to, from, minimizeFloorChanges, accessibilityMode, bearingFrom } =
+      createDirectionsRequest(payload.directionsRequest);
+    const { originIdentifier, destinationIdentifier, buildingIdentifier } =
+      createDirectionsMessage(payload);
+
+    const _buildings = await SitumPlugin.fetchBuildings();
+    const _building = _buildings.find(
+      (b: Building) => b.buildingIdentifier === buildingIdentifier
     );
 
-    if (!poiDestination || (!poiOrigin && originId !== -1) || lockDirections) {
+    if (!to || !from || lockDirections) {
       console.debug(
-        `Situm > hook > Could not compute route for origin: ${originId} or destination: ${destinationId} (lockDirections: ${lockDirections})`
+        `Situm > hook > Could not compute route (to: ${to}, from: ${from}, lockDirections: ${lockDirections})`
       );
       return;
     }
 
-    const from =
-      originId === -1 && location
-        ? location.position
-        : {
-            buildingIdentifier: poiOrigin.buildingIdentifier,
-            floorIdentifier: poiOrigin.floorIdentifier,
-            cartesianCoordinate: poiOrigin.cartesianCoordinate,
-            coordinate: poiOrigin.coordinate,
-          };
-
-    const to = {
-      buildingIdentifier: poiDestination.buildingIdentifier,
-      floorIdentifier: poiDestination.floorIdentifier,
-      cartesianCoordinate: poiDestination.cartesianCoordinate,
-      coordinate: poiDestination.coordinate,
-    };
-
     // iOS workaround -> does not allow for several direction petitions
     setLockDirections(true);
-    return requestDirections(currentBuilding, from, to, directionsOptions)
-      .then((newDirections: State["directions"]) => {
-        const extendedRoute = {
-          ...newDirections,
-          originId,
-          destinationId,
-          type: directionsOptions?.accessibilityMode,
+    return await SitumPlugin.requestDirections(_building, from, to, {
+      minimizeFloorChanges,
+      accessibilityMode,
+      bearingFrom,
+    })
+      .then((_directions) => {
+        const newRoute = {
+          ..._directions,
+          originIdentifier,
+          destinationIdentifier,
+          type: accessibilityMode,
         };
-        updateRoute && dispatch(setDirections(extendedRoute));
-        return extendedRoute;
+        if (updateRoute) {
+          dispatch(setDirections(newRoute));
+        }
+        return newRoute;
       })
-      .catch((e: string) => {
+      .catch((e) => {
+        console.error(`Situm > hook > Could not compute route: ${e}`);
         dispatch(setDirections({ error: JSON.stringify(e) }));
       })
-      .finally(() => setLockDirections(false));
+      .finally(() => {
+        setLockDirections(false);
+      });
   };
 
   // Navigation
-  // TODO: this function is async and we use a callback, why not use a promise?
-  const startNavigation = async ({
-    callback,
-    destinationId,
-    directionsOptions,
-    navigationOptions,
-    originId,
-  }: {
-    callback?: (status: string, navigation?: SDKNavigation) => void;
-    destinationId: number;
-    directionsOptions?: any;
-    navigationOptions?: any;
-    originId: number;
-    updateRoute?: boolean;
-  }) => {
-    navigation?.status !== NavigationStatus.STOP && stopNavigation();
-    calculateRoute({
-      originId,
-      destinationId,
-      directionsOptions,
-      updateRoute: false,
-    }).then((r) => {
-      if (originId !== -1 || !location || !r) {
-        callback && callback("error");
-        return;
-      }
-      dispatch(
-        setNavigation({
-          status: NavigationStatus.START,
-          ...r,
-        })
-      );
-      callback && callback("success", r);
-      SitumPlugin.requestNavigationUpdates(
-        (update: SDKNavigation) => {
-          const newNavType =
-            (update.type &&
-              update.type in NavigationUpdateType &&
-              NavigationUpdateType[
-                update.type as unknown as keyof typeof NavigationUpdateType
-              ]) ||
-            NavigationUpdateType.progress;
-          dispatch(
-            setNavigation({
-              currentIndication: update?.currentIndication,
-              routeStep: update?.routeStep,
-              distanceToGoal: update?.distanceToGoal,
-              points: update?.points,
-              type: newNavType,
-              segments: update?.segments,
-              status: NavigationStatus.UPDATE,
-            })
+  const startNavigation = (payload: any) => {
+    console.debug("Situm > hook > request to start navigation");
+    // TODO: we should delegate this to the sdk plugin
+    if (!navigation || navigation?.status !== NavigationStatus.STOP) {
+      stopNavigation();
+    }
+
+    calculateRoute(payload, false)
+      .then((r) => {
+        if (!r) {
+          console.debug(`Situm > hook > No route was computed`);
+          return;
+        }
+        dispatch(
+          setNavigation({
+            status: NavigationStatus.START,
+            type: NavigationUpdateType.PROGRESS,
+            ...r,
+          })
+        );
+        try {
+          const navigationRequest = createNavigationRequest(
+            payload.navigationRequest
           );
-        },
-        (err: string) => {
-          console.error(`Situm > hook >Could not update navigation: ${err}`);
-          callback && callback("error");
-          dispatch(setError({ message: err, code: 3051 } as SDKError));
-          stopNavigationRef.current();
-        },
-        { ...defaultNavigationOptions, ...navigationOptions }
-      );
-    });
+          SitumPlugin.requestNavigationUpdates({
+            ...defaultNavigationRequest,
+            ...navigationRequest,
+          });
+        } catch (e) {
+          console.error(`Situm > hook > Could not update navigation ${e}`);
+          dispatch(setError({ message: "error", code: 3051 } as Error));
+          stopNavigation();
+        }
+      })
+      .catch((e) => {
+        console.error(
+          `Situm > hook > Could not compute route for navigation ${e}`
+        );
+      });
   };
 
-  const stopNavigation = (): void => {
+  const stopNavigation = () => {
     console.debug("Situm > hook > Stopping navigation");
-    if (!navigation || navigation.status === NavigationStatus.STOP) {
+    // TODO: we should delegate this to the sdk plugin
+    if (!navigation || navigation?.status === NavigationStatus.STOP) {
       return;
     }
-    SitumPlugin.removeNavigationUpdates((response: any) => {
-      if (response && response.success) {
-        console.debug("Situm > hook > Successfully removed navigation updates");
-      } else {
-        console.error("Situm > hook > Could not remove navigation updates");
-      }
-    });
-    dispatch(setNavigation({ status: NavigationStatus.STOP }));
-    dispatch(setDestinationPoiID(undefined));
-  };
-  const stopNavigationRef = useCallbackRef(stopNavigation, [navigation]);
-
-  useEffect(() => {
-    if (
-      !navigation ||
-      navigation.status === NavigationStatus.STOP ||
-      !location
-    ) {
-      return;
+
+    try {
+      SitumPlugin.removeNavigationUpdates();
+      console.debug("Situm > hook > Successfully removed navigation updates");
+      dispatch(setNavigation({ status: NavigationStatus.STOP }));
+    } catch (e) {
+      console.error(`Situm > hook > Could not remove navigation updates ${e}`);
     }
-    SitumPlugin.updateNavigationWithLocation(
-      location,
-      (info: any) => {
-        console.debug(info);
-      },
-      (e: string) => {
-        console.error(`Situm > hook > Error on navigation update ${e}`);
-      }
-    );
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [location]);
+  };
 
   return {
     // States
-    user,
     location,
     locationStatus,
-    currentBuilding,
-    buildings,
-    pois,
+
     directions,
     navigation,
     error,
-    destinationPoiID,
 
     // Functions
-    initSitumSdk,
-    initializeBuildings,
-    initializeBuilding,
-    initializeBuildingById,
-    startPositioning,
-    stopPositioning,
+    init,
     calculateRoute,
     startNavigation,
     stopNavigation,