@eohjsc/react-native-smart-city 0.3.20 → 0.3.23

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 ? (

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

@@ -11,7 +11,6 @@ import {
   TouchableOpacity,
   ScrollView,
   ActivityIndicator,
-  Platform,
 } from 'react-native';
 import { HeaderCustom } from '../../../commons/Header';
 import { Colors } from '../../../configs';
@@ -128,11 +127,8 @@ const GatewayWifiList = memo(({ route }) => {
 
   const sendConnect = useCallback(
     (i) => {
-      setTimeout(async () => {
+      const timeoutSendConnect = setTimeout(async () => {
         i++;
-        await socket.on('message', (msg, rinfo) => {
-          handleSocketOnMsg(msg);
-        });
         socket.send(
           JSON.stringify({
             type: 'connect',
@@ -146,48 +142,32 @@ const GatewayWifiList = memo(({ route }) => {
         );
         if (i < 3) {
           sendConnect(i);
+          clearTimeout(timeoutSendConnect);
         }
       }, 1000);
     },
-    [handleSocketOnMsg, password, selectedWifi, socket]
+    [password, selectedWifi, socket]
   );
 
   const connectWifi = useCallback(async () => {
     if (!isConnectWifiGateway) {
-      if (Platform.OS === 'ios') {
-        sendConnect(0);
-        setAction(Action.IS_CONNECT_WIFI_GATEWAY, true);
-        setIsSendWifi(true);
-      } else {
-        socket.on('message', (msg, rinfo) => {
-          handleSocketOnMsg(msg);
-        });
-        socket.send(
-          JSON.stringify({
-            type: 'connect',
-            data: { wifi: { ssid: selectedWifi, pass: password } },
-          }),
-          undefined,
-          undefined,
-          54321,
-          '192.168.27.1',
-          undefined
-        );
-        socket.on('error', () => {
-          ToastBottomHelper.error(t('server_error'));
-          setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
-          goBack();
-        });
-        setAction(Action.IS_CONNECT_WIFI_GATEWAY, true);
-        setIsSendWifi(true);
-      }
+      socket.on('message', (msg, rinfo) => {
+        handleSocketOnMsg(msg);
+      });
+      socket.on('error', () => {
+        ToastBottomHelper.error(t('server_error'));
+        setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+        goBack();
+      });
+
+      sendConnect(0);
+      setAction(Action.IS_CONNECT_WIFI_GATEWAY, true);
+      setIsSendWifi(true);
     }
   }, [
     goBack,
     handleSocketOnMsg,
     isConnectWifiGateway,
-    password,
-    selectedWifi,
     sendConnect,
     setAction,
     socket,

package/src/screens/AddNewGateway/PlugAndPlay/__test__/GatewayWifiList.test.js

@@ -97,6 +97,8 @@ describe('Test GatewayWifiList', () => {
       await ButtonPopup.props.onPressMain();
     });
     expect(socket.on).toBeCalled();
+    expect(socket.on.mock.calls[0][0]).toEqual('message');
+    jest.runOnlyPendingTimers();
     expect(socket.send).toBeCalled();
 
     const mockWifiThen = jest.fn();

package/src/screens/AllCamera/__test__/index.test.js

@@ -90,7 +90,7 @@ describe('Test AllCamera screen', () => {
     });
     const instance = tree.root;
     const TouchableOpacities = instance.findAllByType(TouchableOpacity);
-    expect(TouchableOpacities).toHaveLength(11);
+    expect(TouchableOpacities).toHaveLength(9);
     const ModalFullVideos = instance.findAllByType(ModalFullVideo);
     expect(ModalFullVideos).toHaveLength(1);
     act(() => {

package/src/screens/Device/__test__/detail.test.js

@@ -12,7 +12,6 @@ import { TESTID } from '../../../configs/Constants';
 import Text from '../../../commons/Text';
 import { IconFill } from '@ant-design/icons-react-native';
 import CurrentRainSensor from '../../../commons/Device/RainningSensor/CurrentRainSensor';
-import { ConnectedViewHeader } from '../../../commons/Device';
 import { getTranslate } from '../../../utils/I18n';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
@@ -30,6 +29,7 @@ jest.mock('@react-navigation/native', () => {
     useNavigation: () => ({
       navigate: mockedNavigate,
     }),
+    useFocusEffect: jest.fn(),
   };
 });
 
@@ -609,59 +609,6 @@ describe('test DeviceDetail', () => {
     expect(sensorDisplayItem).toHaveLength(0);
   });
 
-  test('render CurrentRainSensor but is other device', async () => {
-    route.params.sensorData.is_other_device = true;
-    route.params.isGGHomeConnected = true;
-
-    const responseDisplay = {
-      status: 200,
-      data: {
-        items: [
-          {
-            id: 170,
-            order: 1,
-            template: 'value',
-            type: 'value',
-            configuration: {
-              type: 'circle',
-              configs: [
-                {
-                  id: 428,
-                  color: 'red',
-                  standard: 'Temperature',
-                  measure: '°C',
-                },
-              ],
-            },
-          },
-        ],
-      },
-    };
-
-    const responseDisplayValueV2 = {
-      status: 200,
-      data: {
-        configs: [{ id: 428 }],
-        is_connected: true,
-        last_updated: '2021-01-24T12:00:00.000Z',
-      },
-    };
-
-    mockAxios(responseDisplay, responseDisplayValueV2);
-
-    await act(async () => {
-      tree = await create(wrapComponent(store, account, route));
-    });
-
-    const instance = tree.root;
-    const sensorDisplayItem = instance.findAll(
-      (el) => el.props.testID === TESTID.SENSOR_DISPLAY_ITEM
-    );
-    expect(sensorDisplayItem).toHaveLength(1);
-    const connectedViewHeader = instance.findByType(ConnectedViewHeader);
-    expect(connectedViewHeader.props.type).toEqual('GoogleHome');
-  });
-
   test('HeaderDevice button more onClick', async () => {
     await act(async () => {
       tree = await create(wrapComponent(store, account, route));

package/src/screens/Device/components/SensorConnectStatusViewHeader.js

@@ -14,18 +14,25 @@ export const SensorConnectStatusViewHeader = ({
   showWindDirection,
   children,
 }) => {
-  const isConnecting =
-    !!sensor &&
-    sensor?.is_other_device &&
-    sensor?.device_type !== DEVICE_TYPE.LG_THINQ
-      ? isGGHomeConnecting
-      : false;
+  const isConnecting = (() => {
+    if (!!sensor && sensor?.is_managed_by_backend) {
+      return false;
+    } else {
+      if (sensor?.device_type === DEVICE_TYPE.LG_THINQ) {
+        return false;
+      } else if (sensor?.device_type === DEVICE_TYPE.GOOGLE_HOME) {
+        return isGGHomeConnecting;
+      } else {
+        return false;
+      }
+    }
+  })();
 
   if (isConnecting) {
     return <></>;
   }
 
-  if (!!sensor && !sensor?.is_other_device) {
+  if (!!sensor && sensor?.is_managed_by_backend) {
     if (connectedViaNetwork) {
       return (
         <>
@@ -55,6 +62,7 @@ export const SensorConnectStatusViewHeader = ({
       );
     }
   } else {
+    // not managed by backend
     if (sensor?.device_type === DEVICE_TYPE.LG_THINQ) {
       return (
         <>
@@ -62,7 +70,7 @@ export const SensorConnectStatusViewHeader = ({
           {children}
         </>
       );
-    } else {
+    } else if (sensor?.device_type === DEVICE_TYPE.GOOGLE_HOME) {
       if (connectedViaGGHome) {
         return (
           <>
@@ -83,6 +91,8 @@ export const SensorConnectStatusViewHeader = ({
           />
         );
       }
+    } else {
+      return <DisconnectedView sensor={sensor} />;
     }
   }
 };

package/src/screens/Device/detail.js

@@ -33,7 +33,7 @@ import { useFavoriteDevice } from './hooks/useFavoriteDevice';
 import BottomButtonView from '../../commons/BottomButtonView';
 import Text from '../../commons/Text';
 import { AlertAction, ButtonPopup, MenuActionMore } from '../../commons';
-import { TESTID } from '../../configs/Constants';
+import { DEVICE_TYPE, TESTID } from '../../configs/Constants';
 
 import { usePopover } from '../../hooks/Common';
 import { useConfigGlobalState } from '../../iot/states';
@@ -51,6 +51,7 @@ import { EmergencyCountdown } from './components/EmergencyCountdown';
 import { SensorConnectStatusViewHeader } from './components/SensorConnectStatusViewHeader';
 import { useDisconnectedDevice } from './hooks/useDisconnectedDevice';
 import { useEvaluateValue } from './hooks/useEvaluateValue';
+import { useDeviceWatchConfigControl } from './hooks/useDeviceWatchConfigControl';
 import { Card } from '../../commons/CardShadow';
 import PreventAccess from '../../commons/PreventAccess';
 import { notImplemented } from '../../utils/Utils';
@@ -122,6 +123,8 @@ const DeviceDetail = ({ route }) => {
 
   useDisconnectedDevice(sensorName, isDeviceHasBle, serverDown);
 
+  useDeviceWatchConfigControl(sensor, display);
+
   const isShowSetupEmergencyContact = useMemo(
     () =>
       display.items.filter(
@@ -148,7 +151,7 @@ const DeviceDetail = ({ route }) => {
   );
 
   const canManageSubUnit = useMemo(() => {
-    return currentUserId === unit?.user_id;
+    return Number(currentUserId) === Number(unit?.user_id);
   }, [currentUserId, unit]);
 
   const fetchUnitDetail = useCallback(async () => {
@@ -448,20 +451,24 @@ const DeviceDetail = ({ route }) => {
       if (!item.configuration) {
         return;
       }
+
       const data = item.configuration.configs.map((config) => {
-        const configValue = configValues[config.id];
+        const configValue = configValues[config.id]?.value;
         const displayValue = displayValues.find((k) => k.id === config.id);
-        if (!configValue && !displayValue) {
+        if (
+          (configValue === null || configValue === undefined) &&
+          !displayValue
+        ) {
           return;
         }
-        const value = configValue
-          ? {
-              id: config.id,
-              value: configValue,
-              evaluate: evaluateValue(config.id, configValue),
-            }
-          : displayValue;
-
+        const value =
+          configValue !== null && configValue !== undefined
+            ? {
+                id: config.id,
+                value: configValue,
+                evaluate: evaluateValue(config.id, configValue),
+              }
+            : displayValue;
         return { ...config, ...value };
       });
       return data.filter((value) => value);
@@ -513,7 +520,10 @@ const DeviceDetail = ({ route }) => {
       }
       setLoading((preState) => ({ ...preState, isConnected: false }));
     };
-    if (sensor?.is_managed_by_backend && !sensor?.is_other_device) {
+    if (
+      sensor?.is_managed_by_backend &&
+      sensor?.device_type !== DEVICE_TYPE.LG_THINQ
+    ) {
       const updateInterval = setInterval(() => fetchValues(), 5000);
       fetchValues();
       return () => clearInterval(updateInterval);
@@ -721,16 +731,19 @@ const DeviceDetail = ({ route }) => {
             isNetworkConnected !== null &&
             renderSensorConnected()}
         </View>
-        {isShowSetupEmergencyContact && canManageSubUnit && (
-          <BottomButtonView
-            style={styles.bottomButtonEmergencyContact}
-            mainIcon={<Icon name="plus" size={16} color={Colors.Primary} />}
-            mainTitle={t('setup_my_emergency_contact')}
-            onPressMain={onSetupContacts}
-            typeMain="primaryBorder"
-            semiboldMain={false}
-          />
-        )}
+        {isNetworkConnected &&
+          isConnected &&
+          isShowSetupEmergencyContact &&
+          canManageSubUnit && (
+            <BottomButtonView
+              style={styles.bottomButtonEmergencyContact}
+              mainIcon={<Icon name="plus" size={16} color={Colors.Primary} />}
+              mainTitle={t('setup_my_emergency_contact')}
+              onPressMain={onSetupContacts}
+              typeMain="primaryBorder"
+              semiboldMain={false}
+            />
+          )}
         <AlertSendConfirm
           showAlertConfirm={showAlertConfirm && !lockShowing}
           countDown={countDown}

package/src/screens/Device/hooks/__test__/useEvaluateValue.test.js

@@ -0,0 +1,102 @@
+import React from 'react';
+import { renderHook } from '@testing-library/react-hooks';
+import { useEvaluateValue } from '../useEvaluateValue';
+import { SCProvider } from '../../../../context';
+import { mockSCStore } from '../../../../context/mockStore';
+
+const wrapper =
+  (valueEvaluations) =>
+  ({ children }) =>
+    (
+      <SCProvider initState={mockSCStore({ valueEvaluations })}>
+        {children}
+      </SCProvider>
+    );
+
+const mockUseContext = jest.fn().mockImplementation(() => ({
+  stateData: mockSCStore({}),
+  setAction: jest.fn(),
+}));
+
+React.useContext = mockUseContext;
+
+describe('Test useEvaluateValue', () => {
+  let valueEvaluations = {};
+
+  beforeEach(() => {
+    valueEvaluations = {
+      [1]: {
+        template: 'range',
+        configuration: {
+          ranges: [
+            { start: 0.5, end: 1.5, evaluate: { text: 'On' } },
+            { start: -0.5, end: 0.49, evaluate: { text: 'Off' } },
+          ],
+        },
+      },
+      [2]: {
+        template: 'boolean',
+        configuration: {
+          on: {
+            value: 1,
+            evaluate: {
+              text: 'On',
+            },
+          },
+          off: {
+            value: 0,
+            evaluate: {
+              text: 'Off',
+            },
+          },
+        },
+      },
+    };
+  });
+
+  it('test value null or undefined', async () => {
+    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
+      wrapper: wrapper(valueEvaluations),
+    });
+
+    expect(evaluateValue.current(1, null).text).toBe('--');
+    expect(evaluateValue.current(1, undefined).text).toBe('--');
+  });
+
+  it('test not found ValueEvaluation', async () => {
+    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
+      wrapper: wrapper(valueEvaluations),
+    });
+
+    expect(evaluateValue.current(3, 1)).toBe(null);
+  });
+
+  it('test template not handle', async () => {
+    valueEvaluations[1].template = 'other_template';
+    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
+      wrapper: wrapper(valueEvaluations),
+    });
+
+    expect(evaluateValue.current(1, 1)).toBe(null);
+  });
+
+  it('test evaluate range', async () => {
+    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
+      wrapper: wrapper(valueEvaluations),
+    });
+
+    expect(evaluateValue.current(1, 1).text).toBe('On');
+    expect(evaluateValue.current(1, 0).text).toBe('Off');
+    expect(evaluateValue.current(1, 100).text).toBe(100);
+  });
+
+  it('test evaluate boolean', async () => {
+    const { result: evaluateValue } = renderHook(() => useEvaluateValue(), {
+      wrapper: wrapper(valueEvaluations),
+    });
+
+    expect(evaluateValue.current(2, 0).text).toBe('Off');
+    expect(evaluateValue.current(2, 1).text).toBe('On');
+    expect(evaluateValue.current(2, 2).text).toBe(2);
+  });
+});

package/src/screens/Device/hooks/useDeviceWatchConfigControl.js

@@ -0,0 +1,20 @@
+import { useMemo } from 'react';
+import { DEVICE_TYPE } from '../../../configs/Constants';
+import { getConfigControlFromDeviceDisplay } from '../utils';
+import { useWatchConfigs } from '../../../hooks/IoT';
+
+export const useDeviceWatchConfigControl = (device, display) => {
+  const configsNeedWatching = useMemo(() => {
+    if (
+      !device?.is_managed_by_backend ||
+      [DEVICE_TYPE.GOOGLE_HOME, DEVICE_TYPE.LG_THINQ].includes(
+        device?.device_type
+      )
+    ) {
+      return [];
+    }
+    return getConfigControlFromDeviceDisplay(display);
+  }, [device, display]);
+
+  useWatchConfigs(configsNeedWatching);
+};

package/src/screens/Device/utils/index.js

@@ -0,0 +1,45 @@
+export const getConfigControlFromDeviceDisplay = (deviceDisplay) => {
+  const configIds = [];
+  deviceDisplay?.items.map((item) => {
+    if (item.type !== 'action') {
+      return;
+    }
+    const actionGroup = item.configuration;
+    const { configuration } = actionGroup;
+
+    switch (actionGroup.template) {
+      case 'on_off_button_action_template':
+      case 'OnOffButtonActionTemplate':
+      case 'OnOffSimpleActionTemplate':
+      case 'OnOffSmartLockActionTemplate':
+      case 'NumberUpDownActionTemplate':
+      case 'OptionsDropdownActionTemplate':
+      case 'color_picker_template':
+      case 'slider_range_template':
+        if (configuration.config) {
+          configIds.push(configuration.config);
+        }
+        break;
+      case 'StatesGridActionTemplate':
+        configuration.options.forEach((option) => {
+          configIds.push(option.config);
+        });
+        break;
+      case 'TimerActionTemplate':
+        if (configuration.config_hour) {
+          configIds.push(configuration.config_hour);
+        }
+        if (configuration.config_minute) {
+          configIds.push(configuration.config_minute);
+        }
+        break;
+      case 'two_button_action_template':
+        configIds.push(configuration.button1.config);
+        configIds.push(configuration.button2.config);
+        break;
+      default:
+        break;
+    }
+  });
+  return configIds;
+};