@eohjsc/react-native-smart-city 0.3.53 → 0.3.54

package/src/configs/API.js

@@ -210,7 +210,7 @@ const API = {
   DEV_MODE: {
     GET_TEMPLATES: '/property_manager/iot_dashboard/dev_mode/templates/',
     GET_WIDGETS: (templateId) =>
-      `/property_manager/iot_dashboard/dev_mode/templates/${templateId}/list_widgets/`,
+      `/property_manager/iot_dashboard/dev_mode/templates/${templateId}/widgets/`,
     GATEWAY: {
       LIST: () => '/chip_manager/developer_mode_chips/',
       DETAIL: (id) => `/chip_manager/developer_mode_chips/${id}/`,

package/src/configs/AccessibilityLabel.js

@@ -664,6 +664,6 @@ export default {
   //ButtonWrapper
   BUTTON_WRAPPER: 'BUTTON_WRAPPER',
   //devmod
-  TAB_PANE_CT_FLATLIST: 'TAB_PANE_CT_FLATLIST',
+  TAB_PANE_CT_SCROLLVIEW: 'TAB_PANE_CT_SCROLLVIEW',
   ROW_ITEM_DEVMOD: 'ROW_ITEM_DEVMOD',
 };

package/src/configs/Colors.js

@@ -84,6 +84,8 @@ export const Colors = {
   Orange7: '#FAAD14',
 
   //Red
+  Red11: '#FFADA6',
+  Red10: '#B20000',
   Red9: '#A8071A',
   Red8: '#CF1322',
   Red7: '#FA541C',

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

@@ -7,14 +7,12 @@ import {
 } from '../../../iot/RemoteControl/Bluetooth';
 import { sendCommandOverHomeAssistant } from '../../../iot/RemoteControl/HomeAssistant';
 import { sendCommandOverInternet } from '../../../iot/RemoteControl/Internet';
-import { sendCommandOverLGThinq } from '../../../iot/RemoteControl/LG';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 
 jest.mock('../../../iot/RemoteControl/Bluetooth');
 jest.mock('../../../iot/RemoteControl/HomeAssistant');
 jest.mock('../../../iot/RemoteControl/Internet');
-jest.mock('../../../iot/RemoteControl/LG');
 
 const mockedSetAction = jest.fn();
 
@@ -34,7 +32,6 @@ describe('Test useRemoteControl', () => {
     sendCommandOverBluetooth.mockClear();
     sendCommandOverHomeAssistant.mockClear();
     sendCommandOverInternet.mockClear();
-    sendCommandOverLGThinq.mockClear();
 
     sensor = {
       id: 1,
@@ -59,11 +56,10 @@ describe('Test useRemoteControl', () => {
       wrapper,
     });
     await act(async () => {
-      sendRemoteCommand.current(sensor, action, data, userId);
+      await sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverInternet).not.toBeCalled();
     expect(sendCommandOverHomeAssistant).not.toBeCalled();
-    expect(sendCommandOverLGThinq).not.toBeCalled();
     expect(sendCommandOverBluetooth).not.toBeCalled();
   });
 
@@ -74,7 +70,7 @@ describe('Test useRemoteControl', () => {
 
     sendCommandOverBluetooth.mockImplementation(async () => true);
     await act(async () => {
-      sendRemoteCommand.current(sensor, action, data, userId);
+      await sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverBluetooth).toBeCalledWith(
       sensor,
@@ -84,7 +80,6 @@ describe('Test useRemoteControl', () => {
     );
     expect(sendCommandOverInternet).not.toBeCalled();
     expect(sendCommandOverHomeAssistant).not.toBeCalled();
-    expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
   it('test send remote command via bluetooth failed then send via internet', async () => {
@@ -99,7 +94,7 @@ describe('Test useRemoteControl', () => {
     });
     sendCommandOverInternet.mockImplementation(async () => true);
     await act(async () => {
-      sendRemoteCommand.current(sensor, action, data, userId);
+      await sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverBluetooth).toBeCalledWith(
       sensor,
@@ -115,7 +110,6 @@ describe('Test useRemoteControl', () => {
     );
     expect(sendCommandOverInternet).toBeCalledTimes(1);
     expect(sendCommandOverHomeAssistant).not.toBeCalled();
-    expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
   it('test send remote command via bluetooth failed throw unhandled error', async () => {
@@ -128,7 +122,11 @@ describe('Test useRemoteControl', () => {
     });
     sendCommandOverInternet.mockImplementation(async () => true);
     await act(async () => {
-      sendRemoteCommand.current(sensor, action, data, userId);
+      try {
+        await sendRemoteCommand.current(sensor, action, data, userId);
+      } catch (err) {
+        expect(err).toBe('ANOTHER_ERROR');
+      }
     });
     expect(sendCommandOverBluetooth).toBeCalledWith(
       sensor,
@@ -138,7 +136,6 @@ describe('Test useRemoteControl', () => {
     );
     expect(sendCommandOverInternet).not.toBeCalled();
     expect(sendCommandOverHomeAssistant).not.toBeCalled();
-    expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
   it('test send remote command via internet', async () => {
@@ -150,7 +147,7 @@ describe('Test useRemoteControl', () => {
 
     sendCommandOverInternet.mockImplementation(async () => true);
     await act(async () => {
-      sendRemoteCommand.current(sensor, action, data, userId);
+      await sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverInternet).toBeCalledWith(
       sensor,
@@ -161,7 +158,6 @@ describe('Test useRemoteControl', () => {
     expect(sendCommandOverInternet).toBeCalledTimes(1);
     expect(sendCommandOverBluetooth).not.toBeCalled();
     expect(sendCommandOverHomeAssistant).not.toBeCalled();
-    expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
   it('test send remote command via homeassistant', async () => {
@@ -173,7 +169,7 @@ describe('Test useRemoteControl', () => {
 
     sendCommandOverHomeAssistant.mockImplementation(async () => true);
     await act(async () => {
-      sendRemoteCommand.current(sensor, action, data, userId);
+      await sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverHomeAssistant).toBeCalledWith(
       {},
@@ -183,22 +179,27 @@ describe('Test useRemoteControl', () => {
     );
     expect(sendCommandOverBluetooth).not.toBeCalled();
     expect(sendCommandOverInternet).not.toBeCalled();
-    expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
-  it('test send remote command via lg', async () => {
+  it('test send remote command action not prefer anything, trigger via internet', async () => {
     action.command_prefer_over_bluetooth = false;
-    action.command_prefer_over_lg = true;
+    action.command_prefer_over_googlehome = false;
+    action.command_prefer_over_internet = false;
     const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
       wrapper,
     });
 
-    sendCommandOverLGThinq.mockImplementation(async () => true);
+    sendCommandOverInternet.mockImplementation(async () => true);
     await act(async () => {
-      sendRemoteCommand.current(sensor, action, data, userId);
+      await sendRemoteCommand.current(sensor, action, data, userId);
     });
-    expect(sendCommandOverBluetooth).not.toBeCalled();
+    expect(sendCommandOverInternet).toBeCalledWith(
+      sensor,
+      action,
+      data,
+      'internet'
+    );
     expect(sendCommandOverHomeAssistant).not.toBeCalled();
-    expect(sendCommandOverInternet).not.toBeCalled();
+    expect(sendCommandOverBluetooth).not.toBeCalled();
   });
 });

package/src/hooks/IoT/useRemoteControl.js

@@ -27,9 +27,8 @@ const useRemoteControl = () => {
 
       if (action.command_prefer_over_bluetooth) {
         try {
-          result = await sendCommandOverBluetooth(device, action, data, userId);
+          return await sendCommandOverBluetooth(device, action, data, userId);
         } catch (err) {
-          result = false;
           if (err === SEND_COMMAND_OVER_BLUETOOTH_FAIL) {
             result = await sendCommandOverInternet(
               device,
@@ -37,14 +36,15 @@ const useRemoteControl = () => {
               data,
               'bluetooth'
             );
+            return result;
           } else {
             throw err;
           }
         }
       }
 
-      if (action.command_prefer_over_internet && !result) {
-        result = await sendCommandOverInternet(
+      if (action.command_prefer_over_internet) {
+        return await sendCommandOverInternet(
           device,
           action,
           data,
@@ -52,15 +52,16 @@ const useRemoteControl = () => {
         );
       }
 
-      if (action.command_prefer_over_googlehome && !result) {
-        result = await sendCommandOverHomeAssistant(
+      if (action.command_prefer_over_googlehome) {
+        return await sendCommandOverHomeAssistant(
           homeAssistantConnections,
           device,
           action,
           data
         );
       }
-      return result;
+
+      return await sendCommandOverInternet(device, action, data, 'internet');
     },
     [homeAssistantConnections]
   );

package/src/iot/RemoteControl/Bluetooth.js

@@ -85,7 +85,7 @@ export const sendCommandOverBluetooth = async (
   data,
   userID
 ) => {
-  const bluetooth = sensor.remote_control_options.bluetooth;
+  const bluetooth = sensor?.remote_control_options?.bluetooth;
   let device = null;
   if (bluetooth) {
     device = getDeviceByName(bluetooth.address);

package/src/navigations/Main.js

@@ -36,6 +36,7 @@ import DetailConfigActionZigbee from '../screens/Gateway/DetailConfigActionZigbe
 import DeviceModbusDetail from '../screens/Gateway/DeviceModbusDetail';
 import DetailConfigActionModbus from '../screens/Gateway/DetailConfigActionModbus';
 import DetailChildConfigActionModbus from '../screens/Gateway/DetailConfigActionModbus';
+import { useBlockBackAndroid } from '../hooks/Common';
 
 const Tab = createBottomTabNavigator();
 const Drawer = createDrawerNavigator();
@@ -53,7 +54,7 @@ const MainDevMode = () => {
     () => [
       {
         name: Routes.TemplateStack,
-        tabBarLabel: t('templates'),
+        tabBarLabel: t('dashboard'),
         component: TemplateStack,
       },
       {
@@ -120,6 +121,7 @@ const MainDevMode = () => {
 };
 
 const DrawerScreen = () => {
+  useBlockBackAndroid();
   return (
     <Drawer.Navigator
       backBehavior="none"

package/src/screens/AddNewGateway/ConnectingModbusDevice.js

@@ -22,32 +22,21 @@ const ConnectingModbusDevice = ({ route }) => {
 
   const { goBack } = useNavigation();
 
-  const addingModbusDeviceFail = useCallback(async (message, channelName) => {
-    const channel = getPusher().subscribe(channelName);
-    channel.bind('change_modbus_address_completed', (messageRes) => {
-      setIsChangeAddressSuccess(messageRes.success);
-    });
-  }, []);
-
   const onReady = useCallback(
     async (channelName) => {
       setChannelNameTemp(channelName);
-      const { success, problem, data } = await axiosPost(
-        API.CHIP.SCAN_SENSOR(chipId),
-        {
-          imei: qrData.imei,
-          unit: unitId,
-          station: subUnit?.id,
-          channel_name: channelName,
-        }
-      );
+      const { success, data } = await axiosPost(API.CHIP.SCAN_SENSOR(chipId), {
+        imei: qrData.imei,
+        unit: unitId,
+        station: subUnit?.id,
+        channel_name: channelName,
+      });
       if (!success) {
-        addingModbusDeviceFail(JSON.stringify(problem || data), channelName);
         return;
       }
       setSensorId(data.id);
     },
-    [chipId, addingModbusDeviceFail, qrData, subUnit, unitId]
+    [chipId, qrData, subUnit, unitId]
   );
 
   useEffect(() => {
@@ -63,12 +52,20 @@ const ConnectingModbusDevice = ({ route }) => {
     }
   }, [isRecallChipScan, channelNameTemp, onReady]);
 
+  useEffect(() => {
+    if (channelNameTemp) {
+      const channel = getPusher().subscribe(channelNameTemp);
+      channel.bind('change_modbus_address_completed', (messageRes) => {
+        setIsChangeAddressSuccess(messageRes.success);
+      });
+    }
+  }, [channelNameTemp, setIsChangeAddressSuccess]);
+
   return (
     <ConnectingDevice
       title={t('connect_device')}
       initState={t('connecting_to_gateway')}
       onReady={onReady}
-      fail={addingModbusDeviceFail}
       unitId={unitId}
       subUnit={subUnit}
       chipId={chipId}

package/src/screens/AddNewGateway/ConnectingWifiGuide.js

@@ -1,12 +1,13 @@
-import React, { useCallback, useEffect, useState } from 'react';
-import WifiManager from 'react-native-wifi-reborn';
-import { ActivityIndicator, Alert, Platform, View } from 'react-native';
-import { useNavigation } from '@react-navigation/native';
+import React, { useCallback, useEffect, useState, useMemo } from 'react';
+import { Alert, Platform, View } from 'react-native';
+import { useNavigation, useIsFocused } from '@react-navigation/native';
 import _ from 'lodash';
 import dgram from 'react-native-udp';
+import LottieView from 'lottie-react-native';
+import WifiManager from 'react-native-wifi-reborn';
 
-import { ToastBottomHelper } from '../../utils/Utils';
 import { useTranslations } from '../../hooks/Common/useTranslations';
+import { ToastBottomHelper } from '../../utils/Utils';
 import { HeaderCustom } from '../../commons/Header';
 import Text from '../../commons/Text';
 import Routes from '../../utils/Route';
@@ -14,31 +15,81 @@ import InteractSmartphoneIcon from '../../../assets/images/AddNewDevice/interact
 import styles from './ConnectingWifiGuideStyles';
 import BottomButtonView from '../../commons/BottomButtonView';
 import AccessibilityLabel from '../../configs/AccessibilityLabel';
+import LoadingCircle from '../../Images/Common/loading-circle.json';
+import FullLoading from '../../commons/FullLoading';
+import { useWifiManage } from './hooks/useWifiManage';
 
 let intervalSend = null;
 let socket;
-
 const ConnectingWifiGuide = ({ route }) => {
   const t = useTranslations();
-  const { qrData, unitId, subUnit, addDeviceType } = route?.params || {};
+  const {
+    qrData,
+    unitId,
+    subUnit,
+    addDeviceType,
+    stationId,
+    isBackFromOtherScreen,
+  } = route?.params || {};
   const { navigate, goBack } = useNavigation();
+  const isFocused = useIsFocused();
+  const { getCurrentWifiSSID, disconnectWifi } = useWifiManage();
+
   const [wifiList, setWifiList] = useState([]);
   const [currentState, setCurrentState] = useState(0);
+  const [isDisabled, setIsDisabled] = useState(false);
+  const [isPressButton, setIsPressButton] = useState(false);
 
-  const connectToDeviceWifi = useCallback(async () => {
-    const prefix = `${qrData.org_slug}.${qrData.prefix}`;
-    const wifiPrefix = `${prefix.toLowerCase()}.`;
-    const buttons = [
+  const buttons = useMemo(
+    () => [
       {
         text: t('cancel'),
-        onPress: goBack,
+        onPress: () => {
+          socket?.close();
+          socket = null;
+          setIsDisabled(false);
+          goBack();
+        },
       },
       {
         text: t('retry'),
         onPress: connectToDeviceWifi,
       },
-    ];
+    ],
+    [connectToDeviceWifi, goBack, t]
+  );
+
+  const connectWifiSsid = useCallback(
+    async (wifiSsid = '', passWifi = 'Eoh@2021', isWep = false) => {
+      try {
+        if (Platform.OS === 'ios') {
+          await WifiManager.connectToProtectedSSIDPrefix(
+            wifiSsid,
+            passWifi,
+            isWep
+          );
+        } else {
+          await WifiManager.connectToProtectedSSID(wifiSsid, passWifi, isWep);
+        }
+        setIsDisabled(false);
+        setCurrentState(1);
+      } catch (e) {
+        Alert.alert(
+          t('cannot_connect_to_device_wifi'),
+          t('try_to_turn_on_device_or_try_again'),
+          buttons
+        );
+        return;
+      }
+    },
+    [buttons, t]
+  );
 
+  const connectToDeviceWifi = useCallback(async () => {
+    setIsDisabled(true);
+    setIsPressButton(true);
+    const prefix = `${qrData.org_slug}.${qrData.prefix}`;
+    const wifiPrefix = `${prefix.toLowerCase()}.`;
     if (Platform.OS === 'android') {
       let phoneWifiList;
       try {
@@ -50,8 +101,8 @@ const ConnectingWifiGuide = ({ route }) => {
       const wifi = _.find(phoneWifiList, function (x) {
         return x.SSID.indexOf(wifiPrefix) === 0;
       });
-
       if (!wifi) {
+        phoneWifiList = null;
         Alert.alert(
           t('fail_to_discover_device_wifi'),
           t('try_to_turn_on_device_or_try_again'),
@@ -59,83 +110,78 @@ const ConnectingWifiGuide = ({ route }) => {
         );
         return;
       }
-
-      try {
-        await WifiManager.connectToProtectedSSID(wifi.SSID, 'Eoh@2021', false);
-        setCurrentState(1);
-      } catch (e) {
-        Alert.alert(
-          t('cannot_connect_to_device_wifi'),
-          t('try_to_turn_on_device_or_try_again'),
-          buttons
-        );
-        return;
-      }
+      await connectWifiSsid(wifi.SSID);
     } else {
-      try {
-        await WifiManager.connectToProtectedSSIDPrefix(
-          wifiPrefix,
-          'Eoh@2021',
-          false
-        );
-        setCurrentState(1);
-      } catch (e) {
-        Alert.alert(
-          t('cannot_connect_to_device_wifi'),
-          t('try_turn_on_device_or_try_again'),
-          buttons
-        );
-        return;
-      }
+      await connectWifiSsid(wifiPrefix);
     }
 
-    if (!socket) {
-      socket = dgram.createSocket({ type: 'udp4' });
-      socket.bind(54321);
+    if (intervalSend) {
+      clearInterval(intervalSend);
     }
-
-    socket.on('message', (msg, rinfo) => {
-      const data = JSON.parse(msg.toString());
-      if (Object.prototype.hasOwnProperty.call(data, 'wifi')) {
-        setWifiList(data.wifi);
-        setCurrentState(0);
-        clearInterval(intervalSend);
-        socket?.close();
-        socket = null;
+    try {
+      if (!socket) {
+        socket = dgram.createSocket({ type: 'udp4' });
+        socket.bind(54321);
       }
-    });
 
-    socket.on('error', () => {
-      ToastBottomHelper.error(t('fail_trigger_scan_wifi_on_device'));
-    });
+      socket.on('message', (msg, rinfo) => {
+        const data = JSON.parse(msg.toString());
+        if (Object.prototype.hasOwnProperty.call(data, 'wifi')) {
+          setWifiList(data.wifi);
+        }
+      });
 
-    if (intervalSend) {
-      clearInterval(intervalSend);
-    }
+      socket.on('error', () => {
+        ToastBottomHelper.error(t('fail_trigger_scan_wifi_on_device'));
+      });
+
+      intervalSend = setInterval(() => {
+        socket?.send(
+          JSON.stringify({ type: 'scan', data: { wifi: '' } }),
+          undefined,
+          undefined,
+          54321,
+          '192.168.27.1',
+          undefined
+        );
+      }, 5000); // workaround, todo Bang continue research
+      // eslint-disable-next-line no-empty
+    } catch (error) {}
+    setIsPressButton(false);
+  }, [buttons, connectWifiSsid, qrData?.org_slug, qrData?.prefix, t]);
 
-    intervalSend = setInterval(() => {
-      socket.send(
-        JSON.stringify({ type: 'scan', data: { wifi: '' } }),
-        undefined,
-        undefined,
-        54321,
-        '192.168.27.1',
-        undefined
-      );
-    }, 5000); // workaround, todo Bang continue research
-  }, [goBack, qrData, t]);
+  useEffect(() => {
+    if (isFocused) {
+      if (isBackFromOtherScreen) {
+        const currentConnectingWifi = getCurrentWifiSSID();
+        disconnectWifi(currentConnectingWifi);
+      }
+    }
+    return () => {
+      if (socket) {
+        socket?.close();
+        socket = null;
+      }
+      setIsDisabled(false);
+    };
+  }, [isFocused, isBackFromOtherScreen, getCurrentWifiSSID, disconnectWifi]);
 
   useEffect(() => {
-    if (wifiList.length) {
+    if (wifiList.length > 0) {
+      setCurrentState(0);
+      clearInterval(intervalSend);
+      socket?.close();
+      socket = null;
       navigate(Routes.ShareWifiPassword, {
         unitId,
         subUnit,
         wifiList,
         qrData: qrData,
         addDeviceType,
+        stationId,
       });
     }
-  }, [addDeviceType, navigate, qrData, subUnit, unitId, wifiList]);
+  }, [addDeviceType, navigate, qrData, stationId, subUnit, unitId, wifiList]);
 
   return (
     <View style={styles.container}>
@@ -156,16 +202,34 @@ const ConnectingWifiGuide = ({ route }) => {
               style={styles.bottomButtonView}
               mainTitle={t('ok')}
               onPressMain={connectToDeviceWifi}
-              typeMain={'primary'}
+              typeMain={isDisabled && isPressButton ? 'disabled' : 'primary'}
               accessibilityLabelPrefix={
                 AccessibilityLabel.PREFIX.BUTTON_CONNECT_WIFI
               }
             />
           </>
         ) : (
-          <ActivityIndicator size="large" />
+          <LottieView
+            source={LoadingCircle}
+            autoPlay
+            loop
+            style={styles.loading}
+          />
         )}
       </View>
+      {isDisabled && isPressButton && (
+        <FullLoading
+          styleBackground={styles.backgroundLoading}
+          customIcon={
+            <LottieView
+              source={LoadingCircle}
+              autoPlay
+              loop
+              style={styles.loading}
+            />
+          }
+        />
+      )}
     </View>
   );
 };

package/src/screens/AddNewGateway/ConnectingWifiGuideStyles.js

@@ -1,4 +1,3 @@
-import { Platform } from 'react-native';
 import { Dimensions, StyleSheet } from 'react-native';
 import { getBottomSpace } from 'react-native-iphone-x-helper';
 import { Colors } from '../../configs';
@@ -58,11 +57,13 @@ export default StyleSheet.create({
     lineHeight: 24,
   },
   bottomButtonView: {
-    marginBottom:
-      getBottomSpace() +
-      Platform.select({
-        android: 10,
-        ios: -10,
-      }),
+    marginBottom: getBottomSpace(),
+  },
+  loading: {
+    width: 40,
+    height: 40,
+  },
+  backgroundLoading: {
+    backgroundColor: Colors.Gray21,
   },
 });