@eohjsc/react-native-smart-city 0.3.8 → 0.3.11

package/src/hooks/IoT/useGGHomeConnection.js

@@ -0,0 +1,93 @@
+import { useContext, useCallback } from 'react';
+import { SCContext, useSCContextSelector } from '../../context';
+import { Action } from '../../context/actionType';
+import {
+  googleHomeConnect,
+  googleHomeDisconnect,
+} from '../../iot/RemoteControl/GoogleHome';
+import { axiosPost } from '../../utils/Apis/axios';
+import { API } from '../../configs';
+
+const useGGHomeConnection = () => {
+  const { setAction } = useContext(SCContext);
+  const { connections } = useSCContextSelector((state) => state.iot.googlehome);
+  const { listDevice } = useSCContextSelector((state) => state);
+
+  const onEstablished = useCallback(
+    async (newConnections, options) => {
+      setAction(Action.SET_GOOGLE_HOME_CONNECTIONS, newConnections);
+
+      const isConnected = options.some(
+        (option) => !!newConnections[option.chip_id]
+      );
+      let chipId = options[0].chip_id;
+      if (!isConnected) {
+        setAction(Action.LIST_DEVICE_TYPES, {
+          chipId: chipId,
+          sentEmail: true,
+        });
+        await axiosPost(API.GOOGLE_HOME.CHECK_SEND_EMAIL(), {
+          chip_id: chipId,
+          is_connected: false,
+        });
+      } else if (isConnected && listDevice[chipId]?.sentEmail) {
+        setAction(Action.LIST_DEVICE_TYPES, {
+          chipId: chipId,
+          sentEmail: false,
+        });
+        await axiosPost(API.GOOGLE_HOME.CHECK_SEND_EMAIL(), {
+          chip_id: chipId,
+          is_connected: true,
+        });
+      }
+    },
+    [setAction, listDevice]
+  );
+
+  const onDisconnected = useCallback(
+    async (option) => {
+      setAction(Action.CHANGE_GOOGLE_HOME_CONN_STATE, { option, data: 0 });
+    },
+    [setAction]
+  );
+
+  const onReconnected = useCallback(
+    async (option, connection) => {
+      setAction(Action.CHANGE_GOOGLE_HOME_CONN_STATE, {
+        option,
+        data: connection,
+      });
+    },
+    [setAction]
+  );
+
+  const connectGoogleHome = useCallback(
+    async (options) => {
+      setAction(Action.CONNECTING_GOOGLE_HOME);
+      await googleHomeConnect(
+        connections,
+        options,
+        onEstablished,
+        onDisconnected,
+        onReconnected
+      );
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [connections, onEstablished, onDisconnected, onReconnected]
+  );
+
+  const disconnectGoogleHome = useCallback(
+    async (options) => {
+      await googleHomeDisconnect(connections, options);
+      setAction(Action.SET_GOOGLE_HOME_CONNECTIONS, {});
+    },
+    [setAction, connections]
+  );
+
+  return {
+    connectGoogleHome,
+    disconnectGoogleHome,
+  };
+};
+
+export default useGGHomeConnection;

package/src/hooks/IoT/useRemoteControl.js

@@ -0,0 +1,79 @@
+import { useCallback } from 'react';
+import { useSCContextSelector } from '../../context';
+import { sendCommandOverGoogleHome } from '../../iot/RemoteControl/GoogleHome';
+import { sendCommandOverInternet } from '../../iot/RemoteControl/Internet';
+import { sendCommandOverLGThinq } from '../../iot/RemoteControl/LG';
+import {
+  sendCommandOverBluetooth,
+  SEND_COMMAND_OVER_BLUETOOTH_FAIL,
+} from '../../iot/RemoteControl/Bluetooth';
+import { ToastBottomHelper } from '../../utils/Utils';
+import { t } from 'i18n-js';
+
+const useRemoteControl = () => {
+  const ggHomeConnections = useSCContextSelector(
+    (state) => state.iot.googlehome.connections
+  );
+
+  const sendRemoteCommand = useCallback(
+    async (sensor, action, data, userId, actionName) => {
+      // No action, raise not authorized
+      let result = false;
+      if (!action) {
+        ToastBottomHelper.error(
+          t('your_account_has_not_been_authorized_to_control')
+        );
+        return result;
+      }
+
+      if (action.command_prefer_over_bluetooth) {
+        try {
+          result = await sendCommandOverBluetooth(sensor, action, data, userId);
+        } catch (err) {
+          if (err === SEND_COMMAND_OVER_BLUETOOTH_FAIL) {
+            result = await sendCommandOverInternet(
+              sensor,
+              action,
+              data,
+              'bluetooth',
+              actionName
+            );
+          } else {
+            throw err;
+          }
+        }
+      }
+
+      if (
+        action.command_prefer_over_internet ||
+        action.command_prefer_over_bluetooth
+      ) {
+        result = await sendCommandOverInternet(
+          sensor,
+          action,
+          data,
+          'internet'
+        );
+      }
+
+      if (action.command_prefer_over_googlehome) {
+        result = await sendCommandOverGoogleHome(
+          ggHomeConnections,
+          sensor,
+          action,
+          data
+        );
+      }
+
+      if (action.command_prefer_over_lg) {
+        result = await sendCommandOverLGThinq(sensor, action, data);
+      }
+      return result;
+    },
+    [ggHomeConnections]
+  );
+
+  return sendRemoteCommand;
+};
+
+export default useRemoteControl;

package/src/hooks/IoT/useValueEvaluation.js

@@ -0,0 +1,45 @@
+import { useCallback, useContext, useEffect } from 'react';
+import { API } from '../../configs';
+import { SCContext, useSCContextSelector } from '../../context';
+import { Action } from '../../context/actionType';
+import { axiosGet } from '../../utils/Apis/axios';
+
+const useValueEvaluations = (unitId) => {
+  const { setAction } = useContext(SCContext);
+
+  const fetchConfigValueEvaluations = useCallback(
+    async (page = 1) => {
+      if (!unitId) {
+        return;
+      }
+      const params = new URLSearchParams();
+      params.append('config__end_device__station__unit', unitId);
+      params.append('page', page);
+      const { success, data } = await axiosGet(API.VALUE_EVALUATIONS(), {
+        params,
+      });
+      if (success) {
+        setAction(Action.UPDATE_VALUE_EVALUATIONS, {
+          unitId,
+          data: data.results,
+        });
+        if (data.next) {
+          await fetchConfigValueEvaluations(page + 1);
+        }
+      }
+    },
+    [unitId, setAction]
+  );
+
+  const fetchedValueEvaluationUnits = useSCContextSelector((state) => {
+    return state.fetchedValueEvaluationUnits || [];
+  });
+
+  useEffect(() => {
+    if (!(fetchedValueEvaluationUnits.indexOf(unitId) !== -1)) {
+      fetchConfigValueEvaluations();
+    }
+  }, [unitId, fetchConfigValueEvaluations, fetchedValueEvaluationUnits]);
+};
+
+export default useValueEvaluations;

package/src/hooks/index.js

@@ -0,0 +1,4 @@
+import useInitDeepLink from './useInitDeepLink';
+import useReceiveNotifications from './useReceiveNotifications';
+
+export { useInitDeepLink, useReceiveNotifications };

package/src/hooks/useReceiveNotifications.js

@@ -1,21 +1,26 @@
 import { useEffect, useState, useCallback } from 'react';
 import OneSignal from 'react-native-onesignal';
 
-const useReceiveNotifications = () => {
+const useReceiveNotifications = (callBack) => {
   const [dataNofitication, setDataNofitication] = useState(null);
-  const [showEmergencyPopup, setShowEmergencyPopup] = useState(false);
 
   const onReceived = useCallback((data) => {
-    const { additionalData } = data.payload;
+    const { additionalData } = data;
     setDataNofitication(additionalData);
-    setShowEmergencyPopup(!!additionalData);
   }, []);
 
   useEffect(() => {
-    OneSignal.addEventListener('received', onReceived);
-  }, [onReceived]);
+    OneSignal.setNotificationWillShowInForegroundHandler(
+      (notifReceivedEvent) => {
+        let notif = notifReceivedEvent.getNotification();
+        setTimeout(() => notifReceivedEvent.complete(notif), 0);
+        onReceived(notif);
+        callBack && callBack();
+      }
+    );
+  }, [callBack, onReceived]);
 
-  return { dataNofitication, showEmergencyPopup, setShowEmergencyPopup };
+  return { dataNofitication };
 };
 
 export default useReceiveNotifications;

package/src/iot/Monitor.js

@@ -99,8 +99,9 @@ export const realWatchMultiConfigs = async (configIds) => {
     const configValues = getConfigGlobalState('configValues');
     const newConfigValues = { ...configValues, ...data };
     setConfigGlobalState('configValues', newConfigValues);
-
-    configIds.map((id) => watchConfig(id));
+    for (const configId in data) {
+      watchConfig(configId);
+    }
   }
 };
 

package/src/iot/RemoteControl/Bluetooth.js

@@ -1,4 +1,3 @@
-/* eslint-disable promise/prefer-await-to-then */
 /* eslint-disable promise/prefer-await-to-callbacks */
 import { BLE } from '../../configs';
 import t from '../../hooks/Common/useTranslations';
@@ -82,6 +81,7 @@ const realScanBluetoothDevices = () => {
   setTimeout(() => {
     try {
       bleManager.stopDeviceScan();
+      // eslint-disable-next-line no-empty
     } catch {}
   }, 15000);
 };

package/src/iot/RemoteControl/GoogleHome.js

@@ -5,8 +5,6 @@ import { ToastBottomHelper } from '../../utils/Utils';
 import { API } from '../../configs';
 import { axiosPost } from '../../utils/Apis/axios';
 
-let connections = {};
-
 let configMaps = {};
 
 let attributeMaps = {};
@@ -89,14 +87,14 @@ async function fetchConnectionEntities(connection) {
     const entity = states[i];
     const entityId = entity.entity_id;
 
-    if (configMaps.hasOwnProperty(entityId)) {
+    if (Object.prototype.hasOwnProperty.call(configMaps, entityId)) {
       const [configId, type] = configMaps[entityId];
       const typeConverter = valueTypes[type] || keepValue;
 
       configValues[configId] = typeConverter(entity.state, entityId);
     }
 
-    if (attributeMaps.hasOwnProperty(entityId)) {
+    if (Object.prototype.hasOwnProperty.call(attributeMaps, entityId)) {
       const entityAttributeMaps = attributeMaps[entityId];
       for (const [attributeName, attributeMap] of Object.entries(
         entityAttributeMaps
@@ -118,14 +116,21 @@ async function fetchConnectionEntities(connection) {
   setConfigGlobalState('configValues', { ...configValues });
 }
 
-export const googleHomeConnect = async (options) => {
-  let isConnected = true;
+export const googleHomeConnect = async (
+  oldConnections,
+  options,
+  onEstablished,
+  onDisconnected,
+  onReconnected
+) => {
+  let connections = {};
+
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
 
-    if (option.chip_id in connections) {
-      // skip connected
-      return isConnected;
+    if (option.chip_id in oldConnections && !!oldConnections[option.chip_id]) {
+      connections[option.chip_id] = oldConnections[option.chip_id];
+      continue;
     }
     connections[option.chip_id] = 0; // connecting
 
@@ -152,43 +157,45 @@ export const googleHomeConnect = async (options) => {
       }
     });
 
-    let auth = new Auth(option.auth);
-    const connection = await createConnection({ auth });
-    await connection.subscribeEvents(stateChangeCallback, 'state_changed');
-
-    connection.addEventListener('disconnected', () => {
-      ToastBottomHelper.error(t('command_googlehome_lost'));
-      isConnected = false;
-    });
-
-    connection.addEventListener('ready', async (conn, eventData) => {
-      await fetchConnectionEntities(conn);
-      ToastBottomHelper.success(t('command_googlehome_ready'));
-      isConnected = true;
-    });
-
-    connections[option.chip_id] = connection;
-    await fetchConnectionEntities(connection);
-    isConnected = true;
+    try {
+      let auth = new Auth(option.auth);
+      const connection = await createConnection({ auth });
+      await connection.subscribeEvents(stateChangeCallback, 'state_changed');
+
+      connection.addEventListener('disconnected', async () => {
+        await onDisconnected(option);
+        ToastBottomHelper.error(t('command_googlehome_lost'));
+      });
+
+      connection.addEventListener('ready', async (conn, eventData) => {
+        await fetchConnectionEntities(conn);
+        await onReconnected(option, conn);
+        ToastBottomHelper.success(t('command_googlehome_ready'));
+      });
+
+      connections[option.chip_id] = connection;
+      await fetchConnectionEntities(connection);
+    } catch (err) {
+      connections[option.chip_id] = 0;
+    }
   }
-  return isConnected;
+  await onEstablished(connections, options);
+  return connections;
 };
 
-export const googleHomeDisconnect = async (options) => {
+export const googleHomeDisconnect = async (connections, options) => {
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
-
-    if (!(option.chip_id in connections)) {
-      return;
+    if (option.chip_id in connections) {
+      if (connections[option.chip_id]) {
+        await connections[option.chip_id].close();
+      }
     }
-
-    await connections[option.chip_id].close();
-    delete connections[option.chip_id];
   }
 };
 
-function getSensorConnection(sensor) {
-  return connections[sensor.chip_id];
+function getDeviceConnection(connections, device) {
+  return connections[device.chip_id];
 }
 
 function getServiceName(message) {
@@ -209,10 +216,20 @@ async function sendCommandSingleAction(connection, ghAction, data) {
     message.service_data[name] = data;
   }
 
-  await connection.sendMessagePromise(message);
+  try {
+    await connection.sendMessagePromise(message);
+    return true;
+  } catch (err) {
+    ToastBottomHelper.error(t('command_send_fail_googlehome'));
+  }
 }
 
-export async function sendCommandOverGoogleHome(sensor, action, data) {
+export async function sendCommandOverGoogleHome(
+  connections,
+  device,
+  action,
+  data
+) {
   if (
     !(action.googlehome_actions && action.googlehome_actions.length) &&
     !action.googlehome_action
@@ -220,30 +237,39 @@ export async function sendCommandOverGoogleHome(sensor, action, data) {
     return;
   }
 
-  const connection = getSensorConnection(sensor);
+  const connection = getDeviceConnection(connections, device);
   if (!connection) {
     ToastBottomHelper.error(t('command_send_fail_googlehome'));
     return;
   }
 
+  let triggerSuccess;
+
   if (action.googlehome_actions) {
     for (let i = 0; i < action.googlehome_actions.length; i++) {
-      await sendCommandSingleAction(
+      triggerSuccess = await sendCommandSingleAction(
         connection,
         action.googlehome_actions[i],
         data
       );
     }
   } else if (action.googlehome_action) {
-    await sendCommandSingleAction(connection, action.googlehome_action, data);
+    triggerSuccess = await sendCommandSingleAction(
+      connection,
+      action.googlehome_action,
+      data
+    );
   }
 
-  const { success } = await axiosPost(API.SENSOR.ACTIVITY_LOG(), {
-    action_id: action.id,
-    message: 'Trigger by user action with google home',
-  });
-  if (success) {
-    ToastBottomHelper.success(t('command_send_success_googlehome'));
+  if (triggerSuccess) {
+    const { success } = await axiosPost(API.DEVICE.ACTIVITY_LOG(), {
+      action_id: action.id,
+      message: 'Trigger by user action with google home',
+    });
+    if (success) {
+      ToastBottomHelper.success(t('command_send_success_googlehome'));
+    }
+    return success;
   }
-  return success;
+  return false;
 }

package/src/iot/RemoteControl/Internet.js

@@ -17,7 +17,7 @@ export const sendCommandOverInternet = async (
     }
   }
   ToastBottomHelper.success(t('Sending command via internet'));
-  const { success } = await axiosPost(API.SENSOR.QUICK_ACTION(sensor.id), {
+  const { success } = await axiosPost(API.DEVICE.TRIGGER_ACTION(sensor.id), {
     key: action.key,
     data,
     source,