@eohjsc/react-native-smart-city 0.3.22 → 0.3.25

package/src/hooks/Common/useDevicesStatus.js

@@ -0,0 +1,57 @@
+import { useCallback, useContext } from 'react';
+import { useFocusEffect } from '@react-navigation/native';
+import { SCContext, useSCContextSelector } from '../../context';
+import { axiosGet } from '../../utils/Apis/axios';
+import { API } from '../../configs';
+import { Action } from '../../context/actionType';
+
+let timeoutId;
+
+const useDevicesStatus = (unit, devices) => {
+  const { setAction } = useContext(SCContext);
+  const isNetworkConnected = useSCContextSelector(
+    (state) => state.app.isNetworkConnected
+  );
+
+  const getDevicesStatus = useCallback(async (_unit, _devices) => {
+    const params = new URLSearchParams();
+    _devices.forEach((device) => {
+      params.append('sensors', device.id);
+    });
+    const { success, data } = await axiosGet(
+      API.UNIT.SENSORS_STATUS(_unit.id),
+      {
+        params: params,
+      }
+    );
+    if (success) {
+      setAction(Action.SET_DEVICES_STATUS, data);
+    }
+    timeoutId = setTimeout(() => getDevicesStatus(_unit, _devices), 5000);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  useFocusEffect(
+    useCallback(() => {
+      if (!devices?.length || !isNetworkConnected) {
+        return;
+      }
+
+      const managedDevices = devices.filter(
+        (device) => device?.is_managed_by_backend
+      );
+      if (!managedDevices.length) {
+        return;
+      }
+
+      timeoutId = setTimeout(() => getDevicesStatus(unit, managedDevices), 200);
+
+      return () => {
+        clearTimeout(timeoutId);
+      };
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [unit, devices, isNetworkConnected])
+  );
+};
+
+export default useDevicesStatus;

package/src/hooks/Common/useGGHomeDeviceConnected.js

@@ -1,9 +1,9 @@
 import { useSCContextSelector } from '../../context';
 
 const useGGHomeDeviceConnected = (device) => {
-  const { connections, isConnecting } = useSCContextSelector(
-    (state) => state.iot.googlehome
-  );
+  const { connections } = useSCContextSelector((state) => state.iot.googlehome);
+
+  const isConnecting = !!device?.chip_id && !(device.chip_id in connections);
 
   const isConnected =
     !!device?.chip_id &&

package/src/hooks/IoT/__test__/useGGHomeConnection.test.js

@@ -167,8 +167,7 @@ describe('Test useGGHomeConnection', () => {
     await act(async () => {
       await result.current.connectGoogleHome(options);
     });
-    expect(mockedSetAction).toBeCalledTimes(3);
-    expect(mockedSetAction).toBeCalledWith(Action.CONNECTING_GOOGLE_HOME);
+    expect(mockedSetAction).toBeCalledTimes(2);
     expect(mockedSetAction).toBeCalledWith(
       Action.SET_GOOGLE_HOME_CONNECTIONS,
       conns

package/src/hooks/IoT/__test__/useRemoteControl.test.js

@@ -28,7 +28,7 @@ const mockUseContext = jest.fn().mockImplementation(() => ({
 React.useContext = mockUseContext;
 
 describe('Test useRemoteControl', () => {
-  let sensor, action, data, userId, actionName;
+  let sensor, action, data, userId;
 
   beforeEach(() => {
     sendCommandOverBluetooth.mockClear();
@@ -51,7 +51,6 @@ describe('Test useRemoteControl', () => {
     };
     data = null;
     userId = 1;
-    actionName = 'action name';
   });
 
   it('test send remote command action null', async () => {
@@ -60,7 +59,7 @@ describe('Test useRemoteControl', () => {
       wrapper,
     });
     act(() => {
-      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+      sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverInternet).not.toBeCalled();
     expect(sendCommandOverGoogleHome).not.toBeCalled();
@@ -75,7 +74,7 @@ describe('Test useRemoteControl', () => {
 
     sendCommandOverBluetooth.mockImplementation(async () => true);
     act(() => {
-      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+      sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverBluetooth).toBeCalledWith(
       sensor,
@@ -98,7 +97,7 @@ describe('Test useRemoteControl', () => {
     });
     sendCommandOverInternet.mockImplementation(async () => true);
     act(() => {
-      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+      sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverBluetooth).toBeCalledWith(
       sensor,
@@ -110,8 +109,7 @@ describe('Test useRemoteControl', () => {
       sensor,
       action,
       data,
-      'bluetooth',
-      actionName
+      'bluetooth'
     );
     expect(sendCommandOverInternet).toBeCalledTimes(1);
     expect(sendCommandOverGoogleHome).not.toBeCalled();
@@ -128,7 +126,7 @@ describe('Test useRemoteControl', () => {
     });
     sendCommandOverInternet.mockImplementation(async () => true);
     act(() => {
-      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+      sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverBluetooth).toBeCalledWith(
       sensor,
@@ -150,7 +148,7 @@ describe('Test useRemoteControl', () => {
 
     sendCommandOverInternet.mockImplementation(async () => true);
     act(() => {
-      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+      sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverInternet).toBeCalledWith(
       sensor,
@@ -172,7 +170,7 @@ describe('Test useRemoteControl', () => {
 
     sendCommandOverGoogleHome.mockImplementation(async () => true);
     act(() => {
-      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+      sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverGoogleHome).toBeCalledWith({}, sensor, action, data);
     expect(sendCommandOverBluetooth).not.toBeCalled();
@@ -189,7 +187,7 @@ describe('Test useRemoteControl', () => {
 
     sendCommandOverLGThinq.mockImplementation(async () => true);
     act(() => {
-      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+      sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverBluetooth).not.toBeCalled();
     expect(sendCommandOverGoogleHome).not.toBeCalled();

package/src/hooks/IoT/index.js

@@ -1,5 +1,13 @@
 import useGGHomeConnection from './useGGHomeConnection';
 import useRemoteControl from './useRemoteControl';
 import useValueEvaluations from './useValueEvaluation';
+import useWatchConfigs from './useWatchConfigs';
+import useUnwatchLGDeviceConfigControl from './useUnwatchLGDeviceConfigControl';
 
-export { useGGHomeConnection, useRemoteControl, useValueEvaluations };
+export {
+  useGGHomeConnection,
+  useRemoteControl,
+  useValueEvaluations,
+  useWatchConfigs,
+  useUnwatchLGDeviceConfigControl,
+};

package/src/hooks/IoT/useGGHomeConnection.js

@@ -63,7 +63,6 @@ const useGGHomeConnection = () => {
 
   const connectGoogleHome = useCallback(
     async (options) => {
-      setAction(Action.CONNECTING_GOOGLE_HOME);
       await googleHomeConnect(
         connections,
         options,

package/src/hooks/IoT/useRemoteControl.js

@@ -15,7 +15,7 @@ const useRemoteControl = () => {
   );
 
   const sendRemoteCommand = useCallback(
-    async (sensor, action, data, userId, actionName) => {
+    async (sensor, action, data, userId) => {
       // No action, raise not authorized
       let result = false;
 
@@ -36,8 +36,7 @@ const useRemoteControl = () => {
               sensor,
               action,
               data,
-              'bluetooth',
-              actionName
+              'bluetooth'
             );
           } else {
             throw err;

package/src/hooks/IoT/useUnwatchLGDeviceConfigControl.js

@@ -0,0 +1,29 @@
+import { useCallback } from 'react';
+import { useFocusEffect } from '@react-navigation/native';
+import { unwatchMultiConfigs } from '../../iot/Monitor';
+import { DEVICE_TYPE } from '../../configs/Constants';
+
+const useUnwatchLGDeviceConfigControl = (device, configs) => {
+  const unwatch = useCallback(
+    (_configs) => {
+      if (
+        device?.is_managed_by_backend &&
+        device?.device_type === DEVICE_TYPE.LG_THINQ
+      ) {
+        unwatchMultiConfigs(configs.map((config) => config));
+      }
+    },
+    [device, configs]
+  );
+
+  useFocusEffect(
+    useCallback(() => {
+      return () => {
+        unwatch();
+      };
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [])
+  );
+};
+
+export default useUnwatchLGDeviceConfigControl;

package/src/hooks/IoT/useWatchConfigs.js

@@ -0,0 +1,34 @@
+import { useCallback } from 'react';
+import { useFocusEffect } from '@react-navigation/native';
+import { useSCContextSelector } from '../../context';
+import { watchMultiConfigs, unwatchMultiConfigs } from '../../iot/Monitor';
+import { SCConfig } from '../../configs';
+
+let intervalId;
+
+const useWatchConfigs = (configIds) => {
+  const isNetworkConnected = useSCContextSelector(
+    (state) => state.app.isNetworkConnected
+  );
+
+  useFocusEffect(
+    useCallback(() => {
+      if (!configIds.length || !isNetworkConnected) {
+        return;
+      }
+
+      watchMultiConfigs(configIds);
+      clearInterval(intervalId);
+      intervalId = setInterval(() => {
+        watchMultiConfigs(configIds);
+      }, SCConfig.intervalWatchConfigTime);
+
+      return () => {
+        unwatchMultiConfigs(configIds);
+        clearInterval(intervalId);
+      };
+    }, [configIds, isNetworkConnected])
+  );
+};
+
+export default useWatchConfigs;

package/src/iot/Monitor.js

@@ -2,8 +2,10 @@ import { API } from '../configs';
 import { getConfigGlobalState, setConfigGlobalState } from './states';
 import _ from 'lodash';
 import Pusher from 'pusher-js/react-native';
+import PusherBatchAuthorizer from 'pusher-js-auth';
 import { axiosPost } from '../utils/Apis/axios';
 import { SCConfig } from '../configs';
+import api from '../utils/Apis/axios';
 
 Pusher.logToConsole = true;
 let pusher = null;
@@ -12,23 +14,14 @@ const getPusher = () => {
   if (!pusher) {
     pusher = new Pusher(SCConfig.pusherAppKey, {
       cluster: 'ap1',
-      authorizer: function (channel, option) {
-        return {
-          // eslint-disable-next-line promise/prefer-await-to-callbacks
-          authorize: async function (socketId, callback) {
-            const { success, data } = await axiosPost(
-              API.IOT.CHIP_MANAGER.PUSHER_AUTH(),
-              {
-                channel_name: channel.name,
-                socket_id: socketId,
-              }
-            );
-            if (success) {
-              // eslint-disable-next-line promise/prefer-await-to-callbacks
-              callback(null, data);
-            }
-          },
-        };
+      authorizer: PusherBatchAuthorizer,
+      authEndpoint: SCConfig.apiRoot + API.IOT.CHIP_MANAGER.PUSHER_AUTH(),
+      authDelay: 300,
+      auth: {
+        headers: {
+          Accept: 'application/json',
+          Authorization: api.headers.Authorization,
+        },
       },
     });
   }
@@ -55,7 +48,7 @@ const watchConfig = (configId) => {
     return;
   }
   watchingConfigs[configId] = 1;
-  const channel = getPusher().subscribe(`private-config-${configId}`);
+  const channel = getPusher().subscribe(`private-config_v2-${configId}`);
   channel.bind('new-value', updateGlobalValue.bind(channel, configId));
 };
 
@@ -66,7 +59,7 @@ const unwatchConfig = (configId) => {
   watchingConfigs[configId] -= 1;
   if (!watchingConfigs[configId]) {
     delete watchingConfigs[configId];
-    getPusher().unsubscribe(`private-config-${configId}`);
+    getPusher().unsubscribe(`private-config_v2-${configId}`);
     if (_.isEmpty(watchingConfigs)) {
       destroyPusher();
     }
@@ -84,7 +77,7 @@ export const watchMultiConfigs = async (configIds) => {
       waitWatchConfigIds = [];
       clearTimeout(waitWatchConfigTimerId);
       waitWatchConfigTimerId = 0;
-    }, 100);
+    }, 200);
   }
 };
 

package/src/iot/RemoteControl/GoogleHome.js

@@ -48,10 +48,9 @@ async function stateChangeCallback(event) {
     isChanged = true;
     const [configId, type] = configMaps[entityId];
     const typeConverter = valueTypes[type] || keepValue;
-    configValues[configId] = typeConverter(
-      event.data.new_state.state,
-      entityId
-    );
+    configValues[configId] = {
+      value: typeConverter(event.data.new_state.state, entityId),
+    };
   }
 
   if (entityId in attributeMaps) {
@@ -66,10 +65,9 @@ async function stateChangeCallback(event) {
 
       const [configId, type] = attributeMap;
       const typeConverter = valueTypes[type] || keepValue;
-      configValues[configId] = typeConverter(
-        entity.attributes[attributeName],
-        entityId
-      );
+      configValues[configId] = {
+        value: typeConverter(entity.attributes[attributeName], entityId),
+      };
     }
   }
 
@@ -91,7 +89,9 @@ async function fetchConnectionEntities(connection) {
       const [configId, type] = configMaps[entityId];
       const typeConverter = valueTypes[type] || keepValue;
 
-      configValues[configId] = typeConverter(entity.state, entityId);
+      configValues[configId] = {
+        value: typeConverter(entity.state, entityId),
+      };
     }
 
     if (Object.prototype.hasOwnProperty.call(attributeMaps, entityId)) {
@@ -105,10 +105,9 @@ async function fetchConnectionEntities(connection) {
 
         const [configId, type] = attributeMap;
         const typeConverter = valueTypes[type] || keepValue;
-        configValues[configId] = typeConverter(
-          entity.attributes[attributeName],
-          entityId
-        );
+        configValues[configId] = {
+          value: typeConverter(entity.attributes[attributeName], entityId),
+        };
       }
     }
   }

package/src/iot/RemoteControl/Internet.js

@@ -4,13 +4,7 @@ import { ToastBottomHelper } from '../../utils/Utils';
 import { axiosPost } from '../../utils/Apis/axios';
 import { API } from '../../configs';
 
-export const sendCommandOverInternet = async (
-  sensor,
-  action,
-  data,
-  source,
-  actionName
-) => {
+export const sendCommandOverInternet = async (sensor, action, data, source) => {
   if (data !== null) {
     if (Number.isInteger(data)) {
       data = data.toString(16).toUpperCase();
@@ -21,7 +15,6 @@ export const sendCommandOverInternet = async (
     key: action.key,
     data,
     source,
-    action_name: actionName,
   });
   if (success) {
     ToastBottomHelper.success(t('Command is sent to device via internet'));

package/src/iot/RemoteControl/LG.js

@@ -3,6 +3,7 @@ import { axiosGet } from '../../utils/Apis/axios';
 import { getConfigGlobalState, setConfigGlobalState } from '../states';
 import { sendCommandOverInternet } from './Internet';
 
+// TODO update show config name of camelCase and snakeCase
 let deviceMaps = {};
 const propertyListMaps = {
   temperature: 'targetTemperature',

package/src/iot/RemoteControl/__test__/GoogleHome.test.js

@@ -122,7 +122,12 @@ describe('Remote Control Google Home', () => {
     expect(getStates).toBeCalledTimes(1);
 
     configValues = getConfigGlobalState('configValues');
-    expect(configValues).toEqual({ 1: true, 2: 50, 3: 10, 4: 123.4 });
+    expect(configValues).toEqual({
+      1: { value: true },
+      2: { value: 50 },
+      3: { value: 10 },
+      4: { value: 123.4 },
+    });
   });
 
   it('When state change, global config value also change', async () => {
@@ -162,7 +167,7 @@ describe('Remote Control Google Home', () => {
     );
 
     configValues = getConfigGlobalState('configValues');
-    expect(configValues).toEqual({ 1: true });
+    expect(configValues).toEqual({ 1: { value: true } });
   });
 
   it('Connect to same google home will be skipped', async () => {

package/src/navigations/UnitStack.js

@@ -4,10 +4,12 @@ import { IconOutline } from '@ant-design/icons-react-native';
 import { createStackNavigator } from '@react-navigation/stack';
 import { BleManager } from 'react-native-ble-plx';
 import NetInfo from '@react-native-community/netinfo';
+import { AppState } from 'react-native';
 import { get } from 'lodash';
 
 import Text from '../commons/Text';
 import { useTranslations } from '../hooks/Common/useTranslations';
+import { unwatchAllConfigs } from '../iot/Monitor';
 import { Colors, Device } from '../configs';
 import Route from '../utils/Route';
 import ActivityLogScreen from '../screens/ActivityLog';
@@ -107,6 +109,28 @@ export const UnitStack = memo((props) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  useEffect(() => {
+    const subscription = AppState.addEventListener('change', (nextAppState) => {
+      if (nextAppState === 'background') {
+        unwatchAllConfigs();
+      }
+    });
+    return () => {
+      subscription?.remove();
+    };
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      const id = unitId || unitData?.id;
+      if (!id) {
+        return;
+      }
+      setAction(Action.NEED_UPDATE_VALUE_EVALUATIONS, id);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   return (
     <Stack.Navigator
       screenOptions={{

package/src/screens/AddNewAction/SelectAction.js

@@ -349,7 +349,7 @@ const SelectAction = memo(({ route }) => {
             <LoadingSelectAction style={styles.container} />
           ) : (
             sensorData.map((item) => {
-              const isHasValue = !!item?.value || item?.value === 0;
+              const isHasValue = !!item?.value;
               return (
                 <View style={styles.wrapItem} key={item?.id}>
                   <TitleCheckBox

package/src/screens/AddNewAction/SetupSensor.js

@@ -149,6 +149,10 @@ const SetUpSensor = () => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [minimum, maximum, value]);
 
+  useEffect(() => {
+    !isNumberValue && setValue(1);
+  }, [isNumberValue]);
+
   useEffect(() => {
     if (!isHasLimit && maximum - 150 <= value * 10) {
       setMaximum(maximum + 200);

package/src/screens/AddNewGateway/PlugAndPlay/ConnectWifiWarning.js

@@ -28,14 +28,9 @@ import { Action } from '../../../context/actionType';
 import { TESTID } from '../../../configs/Constants';
 import Connecting from '../../../commons/Connecting';
 
-const isIos = Platform.OS === 'ios';
 const isAndroid = Platform.OS === 'android';
-
-let socket = null;
-if (isIos) {
-  socket = dgram.createSocket({ type: 'udp4' });
-  socket.bind(54321);
-}
+let socket,
+  intervalSend = null;
 
 const ConnectWifiWarning = memo(({ route }) => {
   const {
@@ -83,77 +78,44 @@ const ConnectWifiWarning = memo(({ route }) => {
   }, [getPermissionWifiAndroid]);
 
   const handleSend = async () => {
-    let intervalSend = null;
-    if (isIos) {
-      await setIsPercentConnect(1);
-      await socket.on('message', (msg, rinfo) => {
-        clearInterval(intervalSend);
-        const data = JSON.parse(msg.toString());
-        if (Object.prototype.hasOwnProperty.call(data, 'wifi')) {
-          navigate(Routes.GatewayWifiList, {
-            list_wifi: data.wifi,
-            unit_id: unit_id,
-            chip_id: chip_id,
-            scan_sensor_data: { ...body },
-            wifi_ssid: wifi_ssid,
-            wifi_pass: wifi_pass,
-            unit_name: unit_name,
-            devicePrefixName: devicePrefixName,
-            socket: socket,
-          });
-        }
-      });
-      intervalSend = setInterval(() => {
-        socket.send(
-          JSON.stringify({ type: 'scan', data: { wifi: '' } }),
-          undefined,
-          undefined,
-          54321,
-          '192.168.27.1',
-          undefined
-        );
-      }, 1000);
-      socket.on('error', () => {
-        ToastBottomHelper.error(t('server_error'));
-        setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
-        goBack();
-      });
-    } else {
-      const dgSocket = dgram.createSocket({ type: 'udp4' });
-      await setIsPercentConnect(1);
-      await dgSocket.bind(54321);
-      await dgSocket.on('message', (msg, rinfo) => {
-        const data = JSON.parse(msg.toString());
-        if (Object.prototype.hasOwnProperty.call(data, 'wifi')) {
-          navigate(Routes.GatewayWifiList, {
-            list_wifi: data.wifi,
-            unit_id: unit_id,
-            chip_id: chip_id,
-            scan_sensor_data: { ...body },
-            wifi_ssid: wifi_ssid,
-            wifi_pass: wifi_pass,
-            unit_name: unit_name,
-            devicePrefixName: devicePrefixName,
-            socket: dgSocket,
-          });
-        }
-      });
-      await dgSocket.once('listening', async () => {
-        await dgSocket.send(
-          JSON.stringify({ type: 'scan', data: { wifi: '' } }),
-          undefined,
-          undefined,
-          54321,
-          '192.168.27.1',
-          undefined
-        );
-      });
-      dgSocket.on('error', () => {
-        ToastBottomHelper.error(t('server_error'));
-        setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
-        goBack();
-      });
-    }
+    socket = dgram.createSocket({ type: 'udp4' });
+    socket.bind(54321);
+    setIsPercentConnect(1);
+
+    socket.on('message', (msg, rinfo) => {
+      clearInterval(intervalSend);
+      const data = JSON.parse(msg.toString());
+      if (Object.prototype.hasOwnProperty.call(data, 'wifi')) {
+        navigate(Routes.GatewayWifiList, {
+          list_wifi: data.wifi,
+          unit_id: unit_id,
+          chip_id: chip_id,
+          scan_sensor_data: { ...body },
+          wifi_ssid: wifi_ssid,
+          wifi_pass: wifi_pass,
+          unit_name: unit_name,
+          devicePrefixName: devicePrefixName,
+          socket: socket,
+        });
+      }
+    });
+
+    socket.on('error', () => {
+      ToastBottomHelper.error(t('server_error'));
+      setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+      goBack();
+    });
+
+    intervalSend = setInterval(() => {
+      socket.send(
+        JSON.stringify({ type: 'scan', data: { wifi: '' } }),
+        undefined,
+        undefined,
+        54321,
+        '192.168.27.1',
+        undefined
+      );
+    }, 5000); // workaround, todo Bang continue research
   };
 
   const handleConnectWifiGateway = async () => {
@@ -171,6 +133,10 @@ const ConnectWifiWarning = memo(({ route }) => {
     );
   };
 
+  useEffect(() => {
+    return () => intervalSend && clearInterval(intervalSend);
+  }, []);
+
   return (
     <View style={styles.screen}>
       {!isLoading ? (