@eohjsc/react-native-smart-city 0.3.75 → 0.3.77

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eohjsc/react-native-smart-city",
   "title": "React Native Smart Home",
-  "version": "0.3.75",
+  "version": "0.3.77",
   "description": "TODO",
   "main": "index.js",
   "files": [

package/src/commons/Action/ItemQuickAction.js

@@ -6,89 +6,93 @@ import { useRemoteControl } from '../../hooks/IoT';
 import { useConfigGlobalState } from '../../iot/states';
 import IconComponent from '../IconComponent';
 
-const ItemQuickAction = memo(({ sensor, wrapperStyle, setStatus }) => {
-  const [isSendingCommand, setIsSendingCommand] = useState(false);
-  const [action, setAction] = useState(sensor.action);
-  // eslint-disable-next-line no-unused-vars
-  const [configValues, _] = useConfigGlobalState('configValues');
-  const [isOn, setIsOn] = useState(false);
+const ItemQuickAction = memo(
+  ({ sensor, wrapperStyle, setStatus, iconSize = 40 }) => {
+    const [isSendingCommand, setIsSendingCommand] = useState(false);
+    const [action, setAction] = useState(sensor.action);
+    // eslint-disable-next-line no-unused-vars
+    const [configValues, _] = useConfigGlobalState('configValues');
+    const [isOn, setIsOn] = useState(false);
 
-  const sendRemoteCommand = useRemoteControl();
-  const [processing, setProcessing] = useState(false);
+    const sendRemoteCommand = useRemoteControl();
+    const [processing, setProcessing] = useState(false);
 
-  useEffect(() => {
-    if (!(sensor.quick_action?.config_id in configValues)) {
-      return;
-    }
-    const configValue = configValues[sensor.quick_action.config_id];
-    setIsOn(configValue?.value);
-  }, [sensor, configValues]);
-
-  useEffect(() => {
-    if (!sensor.quick_action) {
-      return;
-    }
+    useEffect(() => {
+      if (!(sensor.quick_action?.config_id in configValues)) {
+        return;
+      }
+      const configValue = configValues[sensor.quick_action.config_id];
+      setIsOn(configValue?.value);
+    }, [sensor, configValues]);
 
-    if (isOn) {
-      setAction(sensor.quick_action.off_action);
-      setStatus && setStatus(sensor.quick_action.on_status);
-    } else {
-      setAction(sensor.quick_action.on_action);
-      setStatus && setStatus(sensor.quick_action.off_status);
-    }
-  }, [isOn, setStatus, sensor.quick_action]);
+    useEffect(() => {
+      if (!sensor.quick_action) {
+        return;
+      }
 
-  const userId = useSCContextSelector((state) => state?.auth.account.user.id);
-  const onActionPress = useCallback(async () => {
-    if (processing) {
-      return;
-    }
-    setProcessing(true);
-    let data = null;
-    if (
-      action?.allow_config_store_value_id === sensor?.quick_action?.config_id
-    ) {
-      if (action?.name?.toLowerCase().includes('off')) {
-        data = {
-          config_id: action?.allow_config_store_value_id,
-          config_value: 0,
-        };
+      if (isOn) {
+        setAction(sensor.quick_action.off_action);
+        setStatus && setStatus(sensor.quick_action.on_status);
       } else {
-        data = {
-          config_id: action?.allow_config_store_value_id,
-          config_value: 1,
-        };
+        setAction(sensor.quick_action.on_action);
+        setStatus && setStatus(sensor.quick_action.off_status);
       }
-      data = JSON.stringify(data);
-    }
-    await sendRemoteCommand(sensor, action, data, userId);
-    setIsSendingCommand(true);
+    }, [isOn, setStatus, sensor.quick_action]);
+
+    const userId = useSCContextSelector((state) => state?.auth.account.user.id);
+    const onActionPress = useCallback(async () => {
+      if (processing) {
+        return;
+      }
+      setProcessing(true);
+      let data = null;
+      if (
+        action?.allow_config_store_value_id === sensor?.quick_action?.config_id
+      ) {
+        if (action?.name?.toLowerCase().includes('off')) {
+          data = {
+            config_id: action?.allow_config_store_value_id,
+            config_value: 0,
+          };
+        } else {
+          data = {
+            config_id: action?.allow_config_store_value_id,
+            config_value: 1,
+          };
+        }
+        data = JSON.stringify(data);
+      }
+      await sendRemoteCommand(sensor, action, data, userId);
+      setIsSendingCommand(true);
 
-    if (!sensor.quick_action.will_auto_update_status) {
-      setTimeout(() => {
-        setIsOn(action.id === sensor.quick_action.on_action.id);
-      }, sensor.quick_action.interval);
+      if (!sensor.quick_action.will_auto_update_status) {
+        setTimeout(() => {
+          setIsOn(action.id === sensor.quick_action.on_action.id);
+        }, sensor.quick_action.interval);
+      }
+      setProcessing(false);
+    }, [processing, action, sensor, sendRemoteCommand, userId]);
+
+    if (!action) {
+      return <View />;
     }
-    setProcessing(false);
-  }, [processing, action, sensor, sendRemoteCommand, userId]);
 
-  if (!action) {
-    return <View />;
+    return (
+      <TouchableOpacity
+        accessibilityLabel={`${AccessibilityLabel.ITEM_QUICK_ACTION_PRESS}-${sensor?.id}`}
+        onPress={onActionPress}
+      >
+        <View style={wrapperStyle}>
+          <IconComponent
+            icon={action?.icon_kit || action?.icon || 'PoweroffOutlined'}
+            isSendingCommand={isSendingCommand}
+            iconSize={iconSize}
+            size={iconSize}
+          />
+        </View>
+      </TouchableOpacity>
+    );
   }
-
-  return (
-    <TouchableOpacity
-      accessibilityLabel={`${AccessibilityLabel.ITEM_QUICK_ACTION_PRESS}-${sensor?.id}`}
-      onPress={onActionPress}
-    >
-      <View style={wrapperStyle}>
-        <IconComponent
-          icon={action?.icon_kit || action?.icon || 'PoweroffOutlined'}
-          isSendingCommand={isSendingCommand}
-        />
-      </View>
-    </TouchableOpacity>
-  );
-});
+);
 
 export default ItemQuickAction;

package/src/hooks/IoT/useBluetoothConnection.js

@@ -1,5 +1,7 @@
-import { useContext, useCallback, useRef, useEffect } from 'react';
+import { useContext, useCallback, useRef, useEffect, useMemo } from 'react';
 import { AppState, Platform } from 'react-native';
+import { getSystemVersion } from 'react-native-device-info';
+
 import { SCContext, useSCContextSelector } from '../../context';
 import { Action } from '../../context/actionType';
 import { scanBluetoothDevices } from '../../iot/RemoteControl/Bluetooth';
@@ -8,6 +10,7 @@ import { OpenSetting } from '../../utils/Permission/common';
 import { useTranslations } from '../Common/useTranslations';
 import { SCConfig } from '../../configs';
 
+// These permissions are only for android 12
 const permissions = [
   'android.permission.BLUETOOTH_CONNECT',
   'android.permission.BLUETOOTH_SCAN',
@@ -24,11 +27,13 @@ const useBluetoothConnection = (fnCallback) => {
   const permissionsRequested = useSCContextSelector(
     (state) => state.bluetooth.permissionsRequested
   );
-  const permissionsGranted =
-    Platform.OS === 'ios'
+
+  const permissionsGranted = useMemo(() => {
+    return Platform.OS === 'ios' || parseInt(getSystemVersion(), 10) < 12
       ? true
       : // eslint-disable-next-line react-hooks/rules-of-hooks
         useSCContextSelector((state) => state.bluetooth.permissionsGranted);
+  }, []);
 
   const onDeviceFound = useCallback(async (name, device) => {
     fnCallback && fnCallback({ name, device });
@@ -38,9 +43,9 @@ const useBluetoothConnection = (fnCallback) => {
 
   const bluetoothScanDevices = useCallback(
     (addresses) => {
-      permissionsGranted && scanBluetoothDevices(addresses, onDeviceFound);
+      scanBluetoothDevices(addresses, onDeviceFound);
     },
-    [permissionsGranted, onDeviceFound]
+    [onDeviceFound]
   );
 
   useEffect(() => {

package/src/iot/RemoteControl/Bluetooth.js

@@ -1,14 +1,17 @@
 /* eslint-disable promise/prefer-await-to-callbacks */
-import { BLE } from '../../configs';
-import t from '../../hooks/Common/useTranslations';
 import base64 from 'react-native-base64';
-import { BleManager } from 'react-native-ble-plx';
+import { BleManager, ScanMode } from 'react-native-ble-plx';
 import { ToastBottomHelper } from '../../utils/Utils';
 
+import { BLE } from '../../configs';
+import t from '../../hooks/Common/useTranslations';
+
 const bluetoothDevices = {};
 const needToScanDevices = [];
 const bleManager = new BleManager();
 
+let isScanning = false;
+
 export const SEND_COMMAND_OVER_BLUETOOTH_FAIL =
   'SEND_COMMAND_OVER_BLUETOOTH_FAIL';
 
@@ -36,44 +39,52 @@ export const realScanBluetoothDevices = async (onDeviceFound) => {
   if (!needToScanDevices.length) {
     return;
   }
+  if (!isScanning) {
+    isScanning = true;
+    bleManager.startDeviceScan(
+      null,
+      { scanMode: ScanMode?.Balanced },
+      (error, device) => {
+        if (error) {
+          return;
+        }
 
-  bleManager.startDeviceScan(null, null, (error, device) => {
-    if (error) {
-      return;
-    }
-
-    let name = null;
-    if (
-      needToScanDevices.includes(device.name) &&
-      !bluetoothDevices[device.name]
-    ) {
-      name = device.name;
-    } else if (
-      needToScanDevices.includes(device.localName) &&
-      !bluetoothDevices[device.localName]
-    ) {
-      name = device.localName;
-    } else {
-      return;
-    }
+        let name = null;
+        if (
+          needToScanDevices.includes(device.name) &&
+          !bluetoothDevices[device.name]
+        ) {
+          name = device.name;
+        } else if (
+          needToScanDevices.includes(device.localName) &&
+          !bluetoothDevices[device.localName]
+        ) {
+          name = device.localName;
+        } else {
+          return;
+        }
 
-    const index = needToScanDevices.indexOf(name);
-    needToScanDevices.splice(index, 1);
+        const index = needToScanDevices.indexOf(name);
+        needToScanDevices.splice(index, 1);
 
-    bluetoothDevices[name] = device;
-    onDeviceFound && onDeviceFound(name, device);
+        bluetoothDevices[name] = device;
+        onDeviceFound && onDeviceFound(name, device);
 
-    if (!needToScanDevices.length) {
-      try {
-        bleManager.stopDeviceScan();
-        // eslint-disable-next-line no-empty
-      } catch {}
-    }
-  });
+        if (!needToScanDevices.length) {
+          try {
+            bleManager.stopDeviceScan();
+            isScanning = false;
+            // eslint-disable-next-line no-empty
+          } catch {}
+        }
+      }
+    );
+  }
 
   const to = setTimeout(() => {
     try {
       bleManager.stopDeviceScan();
+      isScanning = false;
       clearTimeout(to);
       // eslint-disable-next-line no-empty
     } catch {}

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

@@ -25,6 +25,36 @@ describe('Test IOT Bluetooth', () => {
     clearNeedToScanDevices();
   });
 
+  it('Send command over bluetooth via device success', async () => {
+    const device = {
+      name: '1234567',
+      cancelConnection: jest.fn(),
+      connect: async () => ({
+        discoverAllServicesAndCharacteristics: async () => ({
+          writeCharacteristicWithResponseForService: async () => ({}),
+          monitorCharacteristicForService: async () => ({}),
+        }),
+      }),
+    };
+    bleManager.startDeviceScan.mockImplementation(
+      (uuids, options, listener) => {
+        listener(null, device);
+      }
+    );
+    await scanBluetoothDevices([device.name], mockOnDeviceFound);
+
+    await sendCommandOverBluetooth(
+      {
+        remote_control_options: {
+          bluetooth: {
+            address: device.name,
+          },
+        },
+      },
+      {}
+    );
+  });
+
   test('Scan bluetooth device will init hardware scan', async () => {
     await scanBluetoothDevices(['123456'], mockOnDeviceFound);
     expect(bleManager.startDeviceScan).toBeCalled();
@@ -107,7 +137,7 @@ describe('Test IOT Bluetooth', () => {
       }
     );
     await scanBluetoothDevices([device.name], mockOnDeviceFound);
-    expect(bleManager.stopDeviceScan).toBeCalled();
+    expect(bleManager.stopDeviceScan).not.toBeCalled();
   });
 
   it('Scan same device again will not trigger hardware scan', async () => {
@@ -120,7 +150,7 @@ describe('Test IOT Bluetooth', () => {
       }
     );
     await scanBluetoothDevices([device.name], mockOnDeviceFound);
-    expect(bleManager.startDeviceScan).toBeCalled();
+    expect(bleManager.startDeviceScan).not.toBeCalled();
 
     bleManager.startDeviceScan.mockClear();
 
@@ -169,37 +199,7 @@ describe('Test IOT Bluetooth', () => {
           },
         },
       },
-      "Cannot read properties of null (reading 'cancelConnection')"
-    );
-  });
-
-  it('Send command over bluetooth via device success', async () => {
-    const device = {
-      name: '1234567',
-      cancelConnection: jest.fn(),
-      connect: async () => ({
-        discoverAllServicesAndCharacteristics: async () => ({
-          writeCharacteristicWithResponseForService: async () => ({}),
-          monitorCharacteristicForService: async () => ({}),
-        }),
-      }),
-    };
-    bleManager.startDeviceScan.mockImplementation(
-      (uuids, options, listener) => {
-        listener(null, device);
-      }
-    );
-    await scanBluetoothDevices([device.name], mockOnDeviceFound);
-
-    await sendCommandOverBluetooth(
-      {
-        remote_control_options: {
-          bluetooth: {
-            address: device.name,
-          },
-        },
-      },
-      {}
+      undefined
     );
   });
 });

package/src/screens/AddNewGateway/SelectDeviceSubUnit.js

@@ -26,7 +26,7 @@ const SelectDeviceSubUnit = ({ route }) => {
           });
           break;
         case DEVICE_TYPE.ZIGBEE:
-          navigation.navigate(Routes.ConnectRouterGuide, {
+          navigation.navigate(Routes.SelectZigbeeGateway, {
             unit,
             subUnit: chosenSubUnit,
           });

package/src/screens/SubUnit/AddSubUnit.js

@@ -25,7 +25,13 @@ const AddSubUnit = ({ route }) => {
   const t = useTranslations();
   const { dismissKeyboard } = useKeyboardShow();
   const { navigate, goBack, dispatch } = useNavigation();
-  const { unit, addType, isAddUnit, location = '' } = route?.params;
+  const {
+    unit,
+    addType,
+    isAddUnit,
+    location = '',
+    isInsideUnit,
+  } = route?.params;
   const [roomName, setRoomName] = useState('');
   const [wallpaper, setWallpaper] = useState('');
   const [imageUrl, setImageUrl] = useState('');
@@ -94,18 +100,25 @@ const AddSubUnit = ({ route }) => {
             });
             return;
           }
-          dispatch(
-            replace(Routes.UnitStack, {
-              screen: Routes.UnitDetail,
-              params: {
-                unitId: unit.id,
-                unitData: unit,
-                stationId: data.id,
-                isAddSubUnit: true,
-                routeName: Routes.DashboardStack,
-              },
-            })
-          );
+          const commonPrams = {
+            unitId: unit.id,
+            unitData: unit,
+            stationId: data.id,
+            isAddSubUnit: true,
+            routeName: Routes.DashboardStack,
+          };
+          if (isInsideUnit) {
+            navigate(Routes.UnitDetail, {
+              params: commonPrams,
+            });
+          } else {
+            dispatch(
+              replace(Routes.UnitStack, {
+                screen: Routes.UnitDetail,
+                params: commonPrams,
+              })
+            );
+          }
           cleanData();
         } else {
           awaitCreate.current = false;
@@ -118,12 +131,13 @@ const AddSubUnit = ({ route }) => {
     roomName,
     location,
     wallpaper,
-    navigate,
+    dispatch,
     t,
     unit,
     addType,
-    dispatch,
+    isInsideUnit,
     goBack,
+    navigate,
     route.params,
   ]);
 

package/src/screens/SubUnit/__test__/AddSubUnit.test.js

@@ -251,6 +251,48 @@ describe('Test AddSubUnit', () => {
     });
   });
 
+  it('test create sub-unit is in side Unit', async () => {
+    route.params = {
+      ...route.params,
+      isInsideUnit: true,
+    };
+    mock.onPost(API.SUB_UNIT.CREATE_SUB_UNIT(1)).reply(200, {});
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const viewButtonBottom = await makeValidateData(instance);
+    await act(async () => {
+      await viewButtonBottom.props.onRightClick();
+    });
+    expect(mockedNavigate).toHaveBeenCalledWith('UnitDetail', {
+      params: {
+        isAddSubUnit: true,
+        routeName: 'DashboardStack',
+        stationId: undefined,
+        unitData: { id: 1, name: 'Unit name' },
+        unitId: 1,
+      },
+    });
+  });
+
+  it('test create sub-unit is out side Unit', async () => {
+    route.params = {
+      ...route.params,
+      isInsideUnit: false,
+    };
+    mock.onPost(API.SUB_UNIT.CREATE_SUB_UNIT(1)).reply(200, {});
+    await act(async () => {
+      tree = await create(wrapComponent(route));
+    });
+    const instance = tree.root;
+    const viewButtonBottom = await makeValidateData(instance);
+    await act(async () => {
+      await viewButtonBottom.props.onRightClick();
+    });
+    expect(mockNavigationDispatch).toBeCalledWith(mockReplace);
+  });
+
   it('test create sub-unit type AddHassiDevice', async () => {
     route.params = {
       ...route.params,

package/src/screens/Unit/AddMenu.js

@@ -28,7 +28,10 @@ const AddMenu = memo(({ unit, afterItemClick, showAdd, setHideAdd }) => {
         route: Routes.AddSubUnitStack,
         text: t('sub_unit'),
         image: <AddSubUnitIcon width={43} height={43} />,
-        data: { screen: Routes.AddSubUnit, params: { unit } },
+        data: {
+          screen: Routes.AddSubUnit,
+          params: { unit, isInsideUnit: true },
+        },
       },
       {
         id: 'add_member',