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

package/src/navigations/SmartIrStack.js

@@ -0,0 +1,31 @@
+import { createStackNavigator } from '@react-navigation/stack';
+import React, { memo } from 'react';
+
+import SelectDeviceType from '../screens/SmartIr/components/SelectDeviceType';
+import SelectBrand from '../screens/SmartIr/components/SelectBrand';
+import GroupButtonByType from '../screens/SmartIr/components/GroupButtonByType/GroupButtonByType';
+import Route from '../utils/Route';
+import { screenOptions } from './utils';
+
+const Stack = createStackNavigator();
+
+export const SmartIrStack = memo(() => {
+  return (
+    <Stack.Navigator
+      screenOptions={{
+        ...screenOptions,
+        headerShown: false,
+      }}
+    >
+      <Stack.Screen
+        name={Route.SelectDeviceType}
+        component={SelectDeviceType}
+      />
+      <Stack.Screen name={Route.SelectBrand} component={SelectBrand} />
+      <Stack.Screen
+        name={Route.GroupButtonByType}
+        component={GroupButtonByType}
+      />
+    </Stack.Navigator>
+  );
+});

package/src/navigations/SmartLockStack.js

@@ -0,0 +1,51 @@
+import { createStackNavigator } from '@react-navigation/stack';
+import React, { memo } from 'react';
+
+import Route from '../utils/Route';
+import { screenOptions } from './utils';
+import SetupGeneratePasscode from '../commons/ActionGroup/OnOffSmartLock/SetupGeneratePasscode/index';
+import AutoLock from '../commons/ActionGroup/OnOffSmartLock/AutoLock/index';
+import PasscodeList from '../commons/ActionGroup/OnOffSmartLock/PasscodeList/index';
+import ItemPasscode from '../commons/ActionGroup/OnOffSmartLock/PasscodeList/ItemPasscode';
+
+const Stack = createStackNavigator();
+
+export const SmartLockStack = memo(() => {
+  return (
+    <Stack.Navigator
+      screenOptions={{
+        ...screenOptions,
+        headerShown: false,
+      }}
+    >
+      <Stack.Screen
+        name={Route.SetupGeneratePasscode}
+        component={SetupGeneratePasscode}
+        options={{
+          headerShown: false,
+        }}
+      />
+      <Stack.Screen
+        name={Route.AutoLock}
+        component={AutoLock}
+        options={{
+          headerShown: false,
+        }}
+      />
+      <Stack.Screen
+        name={Route.PasscodeList}
+        component={PasscodeList}
+        options={{
+          headerShown: false,
+        }}
+      />
+      <Stack.Screen
+        name={Route.ItemPasscode}
+        component={ItemPasscode}
+        options={{
+          headerShown: false,
+        }}
+      />
+    </Stack.Navigator>
+  );
+});

package/src/navigations/UnitStack.js

@@ -117,12 +117,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>
@@ -323,7 +327,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/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,9 @@ import Routes from '../../../utils/Route';
 import { SCContext } from '../../../context';
 import { Action } from '../../../context/actionType';
 
+const isIos = Platform.OS === 'ios';
+const isAndroid = Platform.OS === 'android';
+
 const ConnectWifiWarning = memo(({ route }) => {
   const {
     wifi_ssid,
@@ -60,74 +63,93 @@ const ConnectWifiWarning = memo(({ route }) => {
   }, [t]);
 
   useEffect(() => {
-    Platform.OS === 'android' && getPermissionWifiAndroid();
+    isAndroid && getPermissionWifiAndroid();
   }, [getPermissionWifiAndroid]);
 
-  const handleSend = () => {
+  const handleSend = async () => {
     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) => {
+    await socket.bind(54321);
+    let intervalSend = null;
+    if (isIos) {
+      intervalSend = setInterval(() => {
+        socket.send(
+          JSON.stringify({ type: 'scan', data: { wifi: '' } }),
+          undefined,
+          undefined,
+          54321,
+          '192.168.27.1',
+          undefined
+        );
+      }, 1000);
+    } else {
+      await socket.once('listening', async () => {
+        await socket.send(
+          JSON.stringify({ type: 'scan', data: { wifi: '' } }),
+          undefined,
+          undefined,
+          54321,
+          '192.168.27.1',
+          undefined
+        );
+      });
+    }
+
+    await socket.on('message', (msg, rinfo) => {
+      isIos && 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,
         });
       }
-    });
-    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);
+      if (isIos) {
+        if (data.hasOwnProperty('gateway')) {
+          const checkWifiInterval = setInterval(() => {
+            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: { ...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);
+                }
               }
-            }
-          });
-        }, 3000);
+            });
+          }, 3000);
+        }
       }
     });
     socket.on('error', () => {

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,136 @@ const GatewayWifiList = memo(({ route }) => {
 
   const onPasswordChange = useCallback(
     (password) => {
-      setPassword(password.toString());
+      setPassword(password?.toString());
     },
     [setPassword]
   );
+
+  const sendConnect = useCallback(
+    (i) => {
+      setTimeout(() => {
+        i++;
+        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);
+    },
+    [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(1);
+        setAction(Action.IS_CONNECT_WIFI_GATEWAY, true);
+        setIsSendWifi(true);
+      } else {
+        await socket.send(
+          JSON.stringify({
+            type: 'connect',
+            data: { wifi: { ssid: selectedWifi, pass: password } },
+          }),
+          undefined,
+          undefined,
+          54321,
+          '192.168.27.1',
+          undefined
+        );
+        await socket.on('message', (msg, rinfo) => {
+          const data = JSON.parse(msg.toString());
+          if (data.hasOwnProperty('gateway')) {
+            const checkWifiInterval = setInterval(() => {
+              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);
+          }
+        });
+        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]);
+  }, [
+    chip_id,
+    devicePrefixName,
+    goBack,
+    isConnectWifiGateway,
+    navigate,
+    password,
+    scan_sensor_data,
+    selectedWifi,
+    sendConnect,
+    setAction,
+    socket,
+    t,
+    unit_id,
+    unit_name,
+    wifi_pass,
+    wifi_ssid,
+  ]);
+
   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 +233,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 +284,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,58 @@
+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-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/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}
+          />
+        );
       }
     }
   }