@eohjsc/react-native-smart-city 0.2.86 → 0.2.89

package/src/navigations/UnitStack.js

@@ -1,7 +1,9 @@
-import React, { memo } from 'react';
+import React, { memo, useContext, useEffect } from 'react';
 import { View, StyleSheet } from 'react-native';
 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 { get } from 'lodash';
 
 import Text from '../commons/Text';
@@ -10,6 +12,8 @@ import { Colors, Device } from '../configs';
 import Route from '../utils/Route';
 import ActivityLogScreen from '../screens/ActivityLog';
 import { screenOptions } from './utils';
+import { SCContext } from '../context';
+import { Action } from '../context/actionType';
 
 import AQIGuide from '../screens/AQIGuide';
 import DeviceDetail from '../screens/Device/detail';
@@ -45,11 +49,33 @@ import SetUpSensor from '../screens/AddNewAction/SetupSensor';
 import EditDevice from '../screens/Device/EditDevice/index';
 import EmergencySetting from '../screens/EmergencySetting';
 import ConfirmUnitDeletion from '../screens/ConfirmUnitDeletion';
+import { HanetCameraStack } from './HanetCameraStack';
 
 const Stack = createStackNavigator();
 
+const bleManager = new BleManager();
+
 export const UnitStack = memo((props) => {
   const t = useTranslations();
+  const { setAction } = useContext(SCContext);
+
+  useEffect(() => {
+    const unsubscribe = NetInfo.addEventListener((state) => {
+      setAction(Action.SET_NETWORK_CONNECTED, state.isConnected);
+    });
+    return () => unsubscribe();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  useEffect(() => {
+    const subscription = bleManager.onStateChange((state) => {
+      setAction(Action.SET_BLUETOOTH_STATE, state === 'PoweredOn');
+    }, true);
+
+    return () => subscription.remove();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   return (
     <Stack.Navigator
       screenOptions={{
@@ -117,12 +143,16 @@ export const UnitStack = memo((props) => {
         component={ChooseLocation}
         options={{
           headerShown: true,
+          headerTitleStyle: {
+            ...styles.headerLocation,
+          },
           headerTitle: () => (
-            <View style={styles.alignCenter}>
+            <View style={styles.headerLocation}>
               <Text type="H3" color={Colors.Gray9} bold>
                 {t('choose_on_map')}
               </Text>
-              <Text type="H4" color={Colors.Gray8}>
+
+              <Text type="H4" color={Colors.Gray8} style={styles.headerContent}>
                 {t('plan_and_zoom_to_adjust')}
               </Text>
             </View>
@@ -162,6 +192,13 @@ export const UnitStack = memo((props) => {
           headerShown: false,
         }}
       />
+      <Stack.Screen
+        name={Route.HanetCameraStack}
+        component={HanetCameraStack}
+        options={{
+          headerShown: false,
+        }}
+      />
       <Stack.Screen
         name={Route.UVIndexGuide}
         component={UVIndexGuide}
@@ -323,7 +360,12 @@ const styles = StyleSheet.create({
   icLeft: {
     marginLeft: Device.isIOS ? 8 : 0,
   },
-  alignCenter: {
+  headerLocation: {
     alignItems: 'center',
+    justifyContent: 'center',
+  },
+  headerContent: {
+    textAlign: 'center',
+    paddingBottom: 8,
   },
 });

package/src/screens/ActivityLog/hooks/index.js

@@ -93,9 +93,9 @@ export default ({ id, type, share, filterEnabled }) => {
         setData(api.standardizeData(results));
       } else {
         dataTemp = dataTemp.concat(results);
-        setIsCanLoadMore(page < Math.ceil(data.count / 20));
         setData(api.standardizeData(dataTemp));
       }
+      setIsCanLoadMore(page < Math.ceil(data.count / 20));
     }
     page === 1 ? setIsRefreshing(false) : setIsLoading(false);
   };

package/src/screens/AddCommon/__test__/SelectSubUnit.test.js

@@ -152,7 +152,7 @@ describe('Test SelectSubUnit container', () => {
         case 'AddVconnexDevice':
           expect(mockedNavigate).toBeCalledWith('Browser', {
             // eslint-disable-next-line max-len
-            link: 'https://partner-api-stg.vconnex.vn/oauth/authorize?client_id=&redirect_uri=&response_type=code&scope=SYNCH&scope=CONTROL&scope=QUERY&state=undefined@undefined@undefined',
+            link: 'https://partner-api.vconnex.vn/oauth/authorize?client_id=&redirect_uri=&response_type=code&scope=SYNCH&scope=CONTROL&scope=QUERY&state=undefined@undefined@undefined',
           });
           break;
         case 'AddDeviceNewFlow':

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

@@ -27,6 +27,15 @@ import Routes from '../../../utils/Route';
 import { SCContext } from '../../../context';
 import { Action } from '../../../context/actionType';
 
+const isIos = Platform.OS === 'ios';
+const isAndroid = Platform.OS === 'android';
+
+let socket = null;
+if (isIos) {
+  socket = dgram.createSocket({ type: 'udp4' });
+  socket.bind(54321);
+}
+
 const ConnectWifiWarning = memo(({ route }) => {
   const {
     wifi_ssid,
@@ -60,81 +69,79 @@ const ConnectWifiWarning = memo(({ route }) => {
   }, [t]);
 
   useEffect(() => {
-    Platform.OS === 'android' && getPermissionWifiAndroid();
+    isAndroid && getPermissionWifiAndroid();
   }, [getPermissionWifiAndroid]);
 
-  const handleSend = () => {
-    const socket = dgram.createSocket({ type: 'udp4' });
-    socket.bind(54321);
-    socket.once('listening', function () {
-      socket.send(
-        JSON.stringify({ type: 'scan', data: { wifi: '' } }),
-        undefined,
-        undefined,
-        54321,
-        '192.168.27.1',
-        undefined
-      );
-    });
-    socket.on('message', (msg, rinfo) => {
-      const data = JSON.parse(msg.toString());
-      if (data.hasOwnProperty('wifi')) {
-        navigate(Routes.GatewayWifiList, {
-          list_wifi: data.wifi,
-          unit_id: unit_id,
-          chip_id: chip_id,
-          socket: socket,
-        });
-      }
-    });
-    socket.on('message', (msg, rinfo) => {
-      const data = JSON.parse(msg.toString());
-      if (data.hasOwnProperty('gateway')) {
-        const checkWifiInterval = setInterval(() => {
-          // eslint-disable-next-line promise/prefer-await-to-then
-          WifiManager.getCurrentWifiSSID().then(async (ssid) => {
-            if (ssid !== wifi_ssid) {
-              const IsRobot = devicePrefixName === 'ROBOT';
-              if (IsRobot) {
-                setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
-                navigate(Routes.AddDeviceStack, {
-                  screen: Routes.AddCommonSelectSubUnit,
-                  params: {
-                    scan_sensor_data: { ...body },
-                    addType: 'AddDeviceNewFlow',
-                    gateway: data?.gateway,
-                    unit_id: unit_id,
-                    devicePrefixName: devicePrefixName,
-                    wifi_ssid: wifi_ssid,
-                    wifi_pass: wifi_pass,
-                  },
-                });
-                clearInterval(checkWifiInterval);
-              } else {
-                setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
-                navigate(Routes.AddDeviceStack, {
-                  screen: Routes.ConnectingProcess,
-                  params: {
-                    unit_id: unit_id,
-                    unit_name: unit_name,
-                    scan_sensor_data: { ...body },
-                    gateway: data?.gateway,
-                    devicePrefixName: devicePrefixName,
-                    chip_id: chip_id,
-                  },
-                });
-                clearInterval(checkWifiInterval);
-              }
-            }
+  const handleSend = async () => {
+    let intervalSend = null;
+    if (isIos) {
+      await socket.on('message', (msg, rinfo) => {
+        clearInterval(intervalSend);
+        const data = JSON.parse(msg.toString());
+        if (data.hasOwnProperty('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,
           });
-        }, 3000);
-      }
-    });
-    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
+        );
+      }, 1000);
+      socket.on('error', () => {
+        ToastBottomHelper.error(t('server_error'));
+        setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+        goBack();
+      });
+    } else {
+      const socket = dgram.createSocket({ type: 'udp4' });
+      await socket.bind(54321);
+      await socket.on('message', (msg, rinfo) => {
+        const data = JSON.parse(msg.toString());
+        if (data.hasOwnProperty('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,
+          });
+        }
+      });
+      await socket.once('listening', async () => {
+        await socket.send(
+          JSON.stringify({ type: 'scan', data: { wifi: '' } }),
+          undefined,
+          undefined,
+          54321,
+          '192.168.27.1',
+          undefined
+        );
+      });
+      socket.on('error', () => {
+        ToastBottomHelper.error(t('server_error'));
+        setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+        goBack();
+      });
+    }
   };
 
   const handleConnectWifiGateway = async () => {

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

@@ -11,6 +11,7 @@ import {
   TouchableOpacity,
   ScrollView,
   ActivityIndicator,
+  Platform,
 } from 'react-native';
 import { HeaderCustom } from '../../../commons/Header';
 import { Colors } from '../../../configs';
@@ -21,14 +22,31 @@ import ButtonPopup from '../../../commons/ButtonPopup';
 import TextInputPassword from '../../../commons/Form/TextInputPassword';
 import { SCContext, useSCContextSelector } from '../../../context';
 import { Action } from '../../../context/actionType';
+import { ToastBottomHelper } from '../../../utils/Utils';
+import Routes from '../../../utils/Route';
+import WifiManager from 'react-native-wifi-reborn';
+import { useNavigation } from '@react-navigation/native';
+
+const isIos = Platform.OS === 'ios';
 
 const GatewayWifiList = memo(({ route }) => {
-  const { list_wifi, socket } = route.params;
+  const {
+    list_wifi,
+    socket,
+    unit_name,
+    wifi_pass,
+    wifi_ssid,
+    scan_sensor_data,
+    unit_id,
+    chip_id,
+    devicePrefixName,
+  } = route.params;
   const t = useTranslations();
-
+  const { navigate, goBack } = useNavigation();
   const [isShowPopupPassword, setIsShowPopupPassword] = useState(false);
   const [password, setPassword] = useState('');
   const [selectedWifi, setSelectedWifi] = useState('');
+  const [isSendWifi, setIsSendWifi] = useState(false);
   const { setAction } = useContext(SCContext);
 
   const isConnectWifiGateway = useSCContextSelector(
@@ -42,31 +60,150 @@ const GatewayWifiList = memo(({ route }) => {
 
   const onPasswordChange = useCallback(
     (password) => {
-      setPassword(password.toString());
+      setPassword(password?.toString());
     },
     [setPassword]
   );
+
+  const handleSocketOnMsg = useCallback(
+    (msg) => {
+      const data = JSON.parse(msg.toString());
+      if (data.hasOwnProperty('gateway')) {
+        const checkWifiInterval = setInterval(() => {
+          // eslint-disable-next-line promise/prefer-await-to-then
+          WifiManager.getCurrentWifiSSID().then((ssid) => {
+            if (ssid !== wifi_ssid) {
+              const IsRobot = devicePrefixName === 'ROBOT';
+              if (IsRobot) {
+                setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+                navigate(Routes.AddDeviceStack, {
+                  screen: Routes.AddCommonSelectSubUnit,
+                  params: {
+                    scan_sensor_data: scan_sensor_data,
+                    addType: 'AddDeviceNewFlow',
+                    gateway: data?.gateway,
+                    unit_id: unit_id,
+                    devicePrefixName: devicePrefixName,
+                    wifi_ssid: wifi_ssid,
+                    wifi_pass: wifi_pass,
+                  },
+                });
+                clearInterval(checkWifiInterval);
+              } else {
+                setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+                navigate(Routes.AddDeviceStack, {
+                  screen: Routes.ConnectingProcess,
+                  params: {
+                    unit_id: unit_id,
+                    unit_name: unit_name,
+                    scan_sensor_data: scan_sensor_data,
+                    gateway: data?.gateway,
+                    devicePrefixName: devicePrefixName,
+                    chip_id: chip_id,
+                  },
+                });
+                clearInterval(checkWifiInterval);
+              }
+            }
+          });
+        }, 3000);
+      }
+    },
+    [
+      chip_id,
+      devicePrefixName,
+      navigate,
+      scan_sensor_data,
+      setAction,
+      unit_id,
+      unit_name,
+      wifi_pass,
+      wifi_ssid,
+    ]
+  );
+
+  const sendConnect = useCallback(
+    (i) => {
+      setTimeout(async () => {
+        i++;
+        await 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
+        );
+        if (i < 3) {
+          sendConnect(i);
+        }
+      }, 1000);
+    },
+    [handleSocketOnMsg, password, selectedWifi, socket]
+  );
+
   const connectWifi = useCallback(async () => {
     if (!isConnectWifiGateway) {
-      await socket.send(
-        JSON.stringify({
-          type: 'connect',
-          data: { wifi: { ssid: selectedWifi, pass: password } },
-        }),
-        undefined,
-        undefined,
-        54321,
-        '192.168.27.1',
-        undefined
-      );
-      setAction(Action.IS_CONNECT_WIFI_GATEWAY, true);
+      if (isIos) {
+        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);
+      }
     }
-  }, [isConnectWifiGateway, password, selectedWifi, setAction, socket]);
+  }, [
+    goBack,
+    handleSocketOnMsg,
+    isConnectWifiGateway,
+    password,
+    selectedWifi,
+    sendConnect,
+    setAction,
+    socket,
+    t,
+  ]);
+
   useEffect(() => {
     if (!isConnectWifiGateway) {
       setIsShowPopupPassword(false);
     }
   }, [isConnectWifiGateway]);
+
+  const onCloseModal = useCallback(() => {
+    if (isSendWifi) {
+      setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+      setIsShowPopupPassword(false);
+      setIsSendWifi(false);
+    }
+  }, [isSendWifi, setAction]);
+
   return (
     <View style={styles.screen}>
       <HeaderCustom title={t('connect_device')} isShowSeparator />
@@ -110,7 +247,8 @@ const GatewayWifiList = memo(({ route }) => {
         secondaryTitle={t('cancel')}
         typeSecondary={isConnectWifiGateway ? 'disabled' : 'cancel'}
         onPressSecondary={() => setIsShowPopupPassword(false)}
-        hideClose={true}
+        hideClose
+        onClose={isSendWifi ? onCloseModal : () => <></>}
       >
         <>
           <Text>{t('enter_wifi_password')}</Text>
@@ -160,16 +298,6 @@ const styles = StyleSheet.create({
     paddingVertical: 16,
     paddingLeft: 16,
   },
-  firstItem: {
-    paddingTop: 32,
-    paddingBottom: 16,
-    paddingLeft: 16,
-  },
-  lastItem: {
-    paddingBottom: 32,
-    paddingTop: 16,
-    paddingLeft: 16,
-  },
   wifiIcon: {
     paddingRight: 16,
   },

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

@@ -0,0 +1,65 @@
+import React from 'react';
+import { act, create } from 'react-test-renderer';
+
+import ConnectWifiWarning from '../ConnectWifiWarning';
+import { SCProvider } from '../../../../context';
+import { mockSCStore } from '../../../../context/mockStore';
+import { HeaderCustom } from '../../../../commons/Header';
+
+const mockedGoBack = jest.fn();
+const mockedNavigate = jest.fn();
+const mockSetState = jest.fn();
+jest.mock('react', () => {
+  return {
+    ...jest.requireActual('react'),
+    memo: (x) => x,
+    useState: jest.fn((init) => [init, mockSetState]),
+  };
+});
+jest.mock('react-native-udp', () => {
+  return {
+    createSocket: () => ({
+      bind: jest.fn(),
+    }),
+  };
+});
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      navigate: mockedNavigate,
+      goBack: mockedGoBack,
+    }),
+    useIsFocused: () => ({}),
+  };
+});
+
+const wrapComponent = (route) => (
+  <SCProvider initState={mockSCStore({})}>
+    <ConnectWifiWarning route={route} />
+  </SCProvider>
+);
+
+describe('Test ConnectWifiWarning', () => {
+  let tree;
+  let route = {
+    params: {
+      wifi_ssid: 1,
+      wifi_pass: 'abc',
+      unit_id: 1,
+      chip_id: 1,
+      devicePrefixName: 'robot',
+      body: { wifi_ssid: 1 },
+      unit_name: 'abc',
+    },
+  };
+
+  test('create ConnectWifiWarning', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const headerCustom = instance.findAllByType(HeaderCustom);
+    expect(headerCustom).toHaveLength(1);
+  });
+});

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

@@ -1,11 +1,11 @@
 import React from 'react';
 import { act, create } from 'react-test-renderer';
-
 import GatewayWifiList from '../GatewayWifiList';
-import { Text } from 'react-native';
+import { Text, ScrollView, TouchableOpacity } from 'react-native';
 import { getTranslate } from '../../../../utils/I18n';
 import { SCProvider } from '../../../../context';
 import { mockSCStore } from '../../../../context/mockStore';
+import TextInputPassword from '../../../../commons/Form/TextInputPassword';
 
 const wrapComponent = (route) => (
   <SCProvider initState={mockSCStore({})}>
@@ -32,4 +32,28 @@ describe('Test GatewayWifiList', () => {
     expect(texts[1].props.children).toEqual(getTranslate('en', 'set_network'));
     expect(texts[3].props.children).toEqual('eoh@io');
   });
+  test('onPress wifi', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const scrollView = instance.findAllByType(ScrollView);
+    expect(scrollView).toHaveLength(1);
+    const touchableOpacity = instance.findAllByType(TouchableOpacity);
+    expect(touchableOpacity).toHaveLength(6);
+    await act(async () => {
+      await touchableOpacity[1].props.onPress();
+    });
+  });
+  test('onChange TextInputPassword', async () => {
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const textInputPassword = instance.findAllByType(TextInputPassword);
+    expect(textInputPassword).toHaveLength(1);
+    await act(async () => {
+      await textInputPassword[0].props.onChange();
+    });
+  });
 });

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

@@ -43,16 +43,6 @@ jest.mock('react-redux', () => {
   };
 });
 
-jest.mock('@react-native-community/netinfo', () => {
-  return {
-    useNetInfo: () => {
-      return {
-        isConnected: true,
-      };
-    },
-  };
-});
-
 jest.mock('react', () => ({
   ...jest.requireActual('react'),
   useLayoutEffect: jest.fn(),

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

@@ -28,7 +28,12 @@ export const SensorConnectStatusViewHeader = (props) => {
         </>
       );
     } else {
-      return <DisconnectedView sensor={props.sensor} />;
+      return (
+        <DisconnectedView
+          sensor={props.sensor}
+          isDeviceHasBle={props.isDeviceHasBle}
+        />
+      );
     }
   } else {
     if (props.sensor?.device_type === DEVICE_TYPE.LG_THINQ) {
@@ -50,7 +55,13 @@ export const SensorConnectStatusViewHeader = (props) => {
           </>
         );
       } else {
-        return <DisconnectedView sensor={props.sensor} type={'GoogleHome'} />;
+        return (
+          <DisconnectedView
+            sensor={props.sensor}
+            type={'GoogleHome'}
+            isDeviceHasBle={props.isDeviceHasBle}
+          />
+        );
       }
     }
   }