@eohjsc/react-native-smart-city 0.3.48 → 0.3.49

package/src/configs/Constants.js

@@ -84,6 +84,12 @@ export const DEVICE_TYPE = {
   WIFI_DEVICE: 'WIFI_DEVICE',
   MODBUS: 'MODBUS',
 };
+export const PERMISSION_TYPE = {
+  ACTION: 'ACTION',
+  CONFIG: 'CONFIG',
+  CONFIG_WRITE: 'CONFIG_WRITE',
+  CONFIG_READ: 'CONFIG_READ',
+};
 
 const marginItem = 12;
 const marginHorizontal = 16;

package/src/configs/Images.js

@@ -24,4 +24,5 @@ export default {
   removeCircle: require('../Images/DevMode/remove_circle.png'),
   dienquang: require('../Images/SmartAccount/DienQuang.png'),
   lg: require('../Images/SmartAccount/LG.png'),
+  inforCode: require('../Images/DevMode/inforCode.png'),
 };

package/src/context/actionType.ts

@@ -18,6 +18,8 @@ export const Action = {
   STAR_SCRIPTS: 'STAR_SCRIPTS',
   UNSTAR_SCRIPTS: 'UNSTAR_SCRIPTS',
   SET_BLUETOOTH_CONNECTED_DEVICE: 'SET_BLUETOOTH_CONNECTED_DEVICE',
+  SET_BLUETOOTH_PERM_REQUESTED: 'SET_BLUETOOTH_PERM_REQUESTED',
+  SET_BLUETOOTH_PERM_GRANTED: 'SET_BLUETOOTH_PERM_GRANTED',
   SET_HOME_ASSISTANT_CONNECTIONS: 'SET_HOME_ASSISTANT_CONNECTIONS',
   CHANGE_HOME_ASSISTANT_CONN_STATE: 'CHANGE_HOME_ASSISTANT_CONN_STATE',
   SET_LG_THINQ_CONNECTED: 'SET_LG_THINQ_CONNECTED',
@@ -87,7 +89,6 @@ export type AppType = {
   isFirstOpenCamera: boolean;
   isLavidaSource: boolean;
   isConnectWifiGateway: boolean;
-  isBluetoothEnabled: boolean;
   isNetworkConnected: boolean;
   camera_opened: any[];
   notificationData: any;
@@ -115,3 +116,9 @@ export type DevModeType = {
   isEditingTemplate: boolean;
   isInEditTemplateScreen: boolean;
 };
+
+export type BluetoothType = {
+  isEnabled: boolean;
+  permissionsGranted: boolean;
+  permissionsRequested: boolean;
+};

package/src/context/mockStore.ts

@@ -35,7 +35,6 @@ export const mockDataStore: ContextData = {
     isFirstOpenCamera: true,
     isLavidaSource: false,
     isConnectWifiGateway: false,
-    isBluetoothEnabled: true,
     isNetworkConnected: true,
     camera_opened: [],
     isLockWhenPickColor: false,
@@ -61,6 +60,11 @@ export const mockDataStore: ContextData = {
     isEditingTemplate: false,
     isInEditTemplateScreen: false,
   },
+  bluetooth: {
+    isEnabled: true,
+    permissionsGranted: false,
+    permissionsRequested: false,
+  },
 };
 
 export const mockSCStore = (data: ContextData): ContextData => {
@@ -86,7 +90,6 @@ export const mockSCStore = (data: ContextData): ContextData => {
     app: {
       isFirstOpenCamera: true,
       isConnectWifiGateway: false,
-      isBluetoothEnabled: true,
       isNetworkConnected: true,
       isLockWhenPickColor: false,
     },
@@ -122,5 +125,8 @@ export const mockSCStore = (data: ContextData): ContextData => {
       isEditingTemplate: false,
       isInEditTemplateScreen: false,
     },
+    bluetooth: {
+      ...mockDataStore.bluetooth,
+    },
   };
 };

package/src/context/reducer.ts

@@ -12,6 +12,7 @@ import {
   AppType,
   IoTType,
   DevModeType,
+  BluetoothType,
 } from './actionType';
 import { uniq, reduce } from 'lodash';
 
@@ -28,6 +29,7 @@ export type ContextData = {
   valueEvaluations: {};
   fetchedValueEvaluationUnits: Array<number>;
   devMode: DevModeType;
+  bluetooth: BluetoothType;
   percent: number;
 };
 
@@ -60,7 +62,6 @@ export const initialState = {
     isFirstOpenCamera: true,
     isLavidaSource: false,
     isConnectWifiGateway: false,
-    isBluetoothEnabled: false,
     isNetworkConnected: false,
     camera_opened: [],
     notificationData: null,
@@ -88,6 +89,11 @@ export const initialState = {
     isEditingTemplate: false,
     isInEditTemplateScreen: false,
   },
+  bluetooth: {
+    isEnabled: false,
+    permissionsGranted: false,
+    permissionsRequested: false,
+  },
 };
 
 export const reducer = (currentState: ContextData, action: Action) => {
@@ -187,9 +193,9 @@ export const reducer = (currentState: ContextData, action: Action) => {
     case Action.SET_BLUETOOTH_STATE: {
       return {
         ...currentState,
-        app: {
-          ...currentState.app,
-          isBluetoothEnabled: payload,
+        bluetooth: {
+          ...currentState.bluetooth,
+          isEnabled: payload,
         },
       };
     }
@@ -308,6 +314,23 @@ export const reducer = (currentState: ContextData, action: Action) => {
           },
         },
       };
+    case Action.SET_BLUETOOTH_PERM_REQUESTED:
+      return {
+        ...currentState,
+        bluetooth: {
+          ...currentState.bluetooth,
+          permissionsRequested: true,
+        },
+      };
+    case Action.SET_BLUETOOTH_PERM_GRANTED:
+      return {
+        ...currentState,
+        bluetooth: {
+          ...currentState.bluetooth,
+          permissionsGranted: payload,
+        },
+      };
+
     case Action.SET_HOME_ASSISTANT_CONNECTIONS:
       return {
         ...currentState,

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

@@ -0,0 +1,46 @@
+import React from 'react';
+import { renderHook } from '@testing-library/react-hooks';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import { useWatchConfigs } from '../index';
+import { watchMultiConfigs, unwatchMultiConfigs } from '../../../iot/Monitor';
+
+const mockedSetAction = jest.fn();
+
+const wrapper = ({ children }) => <SCProvider>{children}</SCProvider>;
+
+jest.mock('react', () => {
+  return {
+    ...jest.requireActual('react'),
+    useCallback: (func) => func(),
+    useContext: () => ({
+      stateData: mockSCStore({}),
+      setAction: mockedSetAction,
+    }),
+  };
+});
+
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useFocusEffect: (func) => func(),
+  };
+});
+
+jest.mock('../../../iot/Monitor');
+
+describe('Test useWatchConfigs', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    watchMultiConfigs.mockClear();
+    unwatchMultiConfigs.mockClear();
+  });
+
+  it('test unitId null', async () => {
+    renderHook(() => useWatchConfigs([1]), {
+      wrapper,
+    });
+    expect(watchMultiConfigs).toBeCalledWith([1]);
+    expect(unwatchMultiConfigs).toBeCalledWith([1]);
+  });
+});

package/src/hooks/IoT/useBluetoothConnection.js

@@ -1,10 +1,32 @@
-import { useContext, useCallback } from 'react';
-import { SCContext } from '../../context';
+import { useContext, useCallback, useRef, useEffect } from 'react';
+import { AppState, Platform } from 'react-native';
+import { SCContext, useSCContextSelector } from '../../context';
 import { Action } from '../../context/actionType';
 import { scanBluetoothDevices } from '../../iot/RemoteControl/Bluetooth';
+import Permissions from 'react-native-permissions';
+import { OpenSetting } from '../../utils/Permission/common';
+import { useTranslations } from '../Common/useTranslations';
+
+const permissions = [
+  'android.permission.BLUETOOTH_CONNECT',
+  'android.permission.BLUETOOTH_SCAN',
+  'android.permission.BLUETOOTH_ADVERTISE',
+];
 
 const useBluetoothConnection = () => {
+  const t = useTranslations();
+  const appState = useRef(AppState.currentState);
+
   const { setAction } = useContext(SCContext);
+  const isEnabled = useSCContextSelector((state) => state.bluetooth.isEnabled);
+  const permissionsRequested = useSCContextSelector(
+    (state) => state.bluetooth.permissionsRequested
+  );
+  const permissionsGranted =
+    Platform.OS === 'ios'
+      ? true
+      : // eslint-disable-next-line react-hooks/rules-of-hooks
+        useSCContextSelector((state) => state.bluetooth.permissionsGranted);
 
   const onDeviceFound = useCallback(async (name, device) => {
     setAction(Action.SET_BLUETOOTH_CONNECTED_DEVICE, { name, device });
@@ -13,12 +35,64 @@ const useBluetoothConnection = () => {
 
   const bluetoothScanDevices = useCallback(
     (addresses) => {
-      scanBluetoothDevices(addresses, onDeviceFound);
+      permissionsGranted && scanBluetoothDevices(addresses, onDeviceFound);
     },
-    [onDeviceFound]
+    [permissionsGranted, onDeviceFound]
   );
 
+  useEffect(() => {
+    const subscription = AppState.addEventListener(
+      'change',
+      async (nextAppState) => {
+        if (
+          appState.current.match(/inactive|background/) &&
+          nextAppState === 'active'
+        ) {
+          const results = await Permissions.checkMultiple(permissions);
+          const granted = Object.values(results).every((result) =>
+            [
+              Permissions.RESULTS.GRANTED,
+              Permissions.RESULTS.UNAVAILABLE,
+            ].includes(result)
+          );
+          setAction(Action.SET_BLUETOOTH_PERM_GRANTED, granted);
+        }
+        appState.current = nextAppState;
+      }
+    );
+
+    return () => {
+      subscription?.remove();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const requestPerm = useCallback(async () => {
+    let results = await Permissions.requestMultiple(permissions);
+    const blocked = Object.values(results).some(
+      (result) => result === Permissions.RESULTS.BLOCKED
+    );
+    if (blocked) {
+      OpenSetting(
+        t('bluetooth_rationale_title'),
+        t('bluetooth_rationale_message')
+      );
+    }
+    const granted = Object.values(results).every((result) =>
+      [Permissions.RESULTS.GRANTED, Permissions.RESULTS.UNAVAILABLE].includes(
+        result
+      )
+    );
+    setAction(Action.SET_BLUETOOTH_PERM_GRANTED, granted);
+    setAction(Action.SET_BLUETOOTH_PERM_REQUESTED);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
   return {
+    isEnabled,
+    permissionsRequested,
+    permissionsGranted,
+    requestPerm,
     onDeviceFound,
     bluetoothScanDevices,
   };

package/src/hooks/IoT/useBluetoothDeviceConnected.js

@@ -5,7 +5,7 @@ const useBluetoothDeviceConnected = (device) => {
     (state) => state.iot.bluetooth.connectedDevices
   );
   const isBluetoothEnabled = useSCContextSelector((state) => {
-    return state.app.isBluetoothEnabled;
+    return state.bluetooth.isEnabled;
   });
 
   const isConnected =

package/src/iot/RemoteControl/Bluetooth.js

@@ -4,23 +4,11 @@ import t from '../../hooks/Common/useTranslations';
 import base64 from 'react-native-base64';
 import { BleManager } from 'react-native-ble-plx';
 import { ToastBottomHelper } from '../../utils/Utils';
-import { PermissionsAndroid } from 'react-native';
 
 const bluetoothDevices = {};
 const needToScanDevices = [];
 const bleManager = new BleManager();
 
-export const requestBluetoothPermissions = async () => {
-  const results = await PermissionsAndroid.requestMultiple([
-    'android.permission.BLUETOOTH_CONNECT',
-    'android.permission.BLUETOOTH_SCAN',
-    'android.permission.BLUETOOTH_ADVERTISE',
-  ]);
-  return Object.values(results).every(
-    (result) => result === PermissionsAndroid.RESULTS.GRANTED
-  );
-};
-
 export const SEND_COMMAND_OVER_BLUETOOTH_FAIL =
   'SEND_COMMAND_OVER_BLUETOOTH_FAIL';
 
@@ -45,10 +33,6 @@ export const scanBluetoothDevices = async (names, onDeviceFound) => {
 };
 
 export const realScanBluetoothDevices = async (onDeviceFound) => {
-  const permissionsGranted = await requestBluetoothPermissions();
-  if (!permissionsGranted) {
-    return;
-  }
   if (!needToScanDevices.length) {
     return;
   }

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

@@ -12,20 +12,6 @@ const bleManager = new BleManager();
 
 const mockOnDeviceFound = jest.fn();
 
-const mockRequestMultiplePerms = jest.fn();
-
-jest.mock(
-  'react-native/Libraries/PermissionsAndroid/PermissionsAndroid',
-  () => {
-    return {
-      ...jest.requireActual(
-        'react-native/Libraries/PermissionsAndroid/PermissionsAndroid'
-      ),
-      requestMultiple: mockRequestMultiplePerms,
-    };
-  }
-);
-
 describe('Test IOT Bluetooth', () => {
   beforeEach(() => {
     mockOnDeviceFound.mockClear();
@@ -33,9 +19,6 @@ describe('Test IOT Bluetooth', () => {
     bleManager.stopDeviceScan.mockClear();
     clearNeedToScanDevices();
     clearFoundDevices();
-    mockRequestMultiplePerms.mockImplementation(async (perms) =>
-      perms.map(() => 'granted')
-    );
   });
 
   afterEach(() => {
@@ -48,14 +31,6 @@ describe('Test IOT Bluetooth', () => {
     expect(bleManager.startDeviceScan).toBeCalled();
   });
 
-  test('Scan bluetooth device not scan without permissions', async () => {
-    mockRequestMultiplePerms.mockImplementation(async (perms) =>
-      perms.map(() => 'denied')
-    );
-    await scanBluetoothDevices(['123456'], mockOnDeviceFound);
-    expect(bleManager.startDeviceScan).not.toBeCalled();
-  });
-
   test('When look for bluetooth name, hardware will auto stop after period of time', async () => {
     jest.useFakeTimers();
     await scanBluetoothDevices(['123456'], mockOnDeviceFound);

package/src/navigations/Main.js

@@ -27,6 +27,15 @@ import TemplateDetail from '../screens/Template/detail';
 import Information from '../screens/Template/Information';
 import GatewayList from '../screens/Template/GatewayList';
 import EditTemplate from '../screens/Template/EditTemplate';
+import GatewayDetail from '../screens/Gateway/GatewayDetail';
+import GatewayInfo from '../screens/Gateway/GatewayInfo';
+import GatewayConnectionMethods from '../screens/Gateway/GatewayConnectionMethods';
+import DeviceZigbeeDetail from '../screens/Gateway/DeviceZigbeeDetail';
+import DeviceGatewayInfo from '../screens/Gateway/DeviceGatewayInfo';
+import DetailConfigActionZigbee from '../screens/Gateway/DetailConfigActionZigbee';
+import DeviceModbusDetail from '../screens/Gateway/DeviceModbusDetail';
+import DetailConfigActionModbus from '../screens/Gateway/DetailConfigActionModbus';
+import DetailChildConfigActionModbus from '../screens/Gateway/DetailConfigActionModbus';
 
 const Tab = createBottomTabNavigator();
 const Drawer = createDrawerNavigator();
@@ -132,6 +141,36 @@ const DevModeStack = () => {
     >
       <Stack.Screen component={DrawerScreen} name={Routes.DrawerScreen} />
       <Stack.Screen component={TemplateDetail} name={Routes.TemplateDetail} />
+      <Stack.Screen component={GatewayDetail} name={Routes.GatewayDetail} />
+      <Stack.Screen component={GatewayInfo} name={Routes.GatewayInfo} />
+      <Stack.Screen
+        component={DeviceGatewayInfo}
+        name={Routes.DeviceGatewayInfo}
+      />
+      <Stack.Screen
+        component={GatewayConnectionMethods}
+        name={Routes.GatewayConnectionMethods}
+      />
+      <Stack.Screen
+        component={DeviceZigbeeDetail}
+        name={Routes.DeviceZigbeeDetail}
+      />
+      <Stack.Screen
+        component={DeviceModbusDetail}
+        name={Routes.DeviceModbusDetail}
+      />
+      <Stack.Screen
+        component={DetailConfigActionZigbee}
+        name={Routes.DetailConfigActionZigbee}
+      />
+      <Stack.Screen
+        component={DetailConfigActionModbus}
+        name={Routes.DetailConfigActionModbus}
+      />
+      <Stack.Screen
+        component={DetailChildConfigActionModbus}
+        name={Routes.DetailChildConfigActionModbus}
+      />
       <Stack.Screen component={Information} name={Routes.Information} />
       <Stack.Screen component={GatewayList} name={Routes.GatewayList} />
       <Stack.Screen component={EditTemplate} name={Routes.EditTemplate} />

package/src/navigations/UnitStack.js

@@ -82,22 +82,35 @@ export const UnitStack = memo((props) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  const { onDeviceFound } = useBluetoothConnection();
+  const {
+    isEnabled: isBluetoothEnabled,
+    permissionsRequested: bluetoothPermRequested,
+    permissionsGranted: bluetoothPermGranted,
+    requestPerm: requestBluetoothPerm,
+    onDeviceFound,
+  } = useBluetoothConnection();
+
+  useEffect(() => {
+    !bluetoothPermRequested && requestBluetoothPerm();
+  }, [bluetoothPermRequested, requestBluetoothPerm]);
 
   useEffect(() => {
     const subscription = bleManager.onStateChange((state) => {
       const connected = state === 'PoweredOn';
       setAction(Action.SET_BLUETOOTH_STATE, connected);
-      if (connected) {
-        ToastBottomHelper.success(t('text_ble_is_powered_on'));
-        realScanBluetoothDevices(onDeviceFound);
-      }
+      connected && ToastBottomHelper.success(t('text_ble_is_powered_on'));
     }, true);
 
     return () => subscription.remove();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  useEffect(() => {
+    isBluetoothEnabled &&
+      bluetoothPermGranted &&
+      realScanBluetoothDevices(onDeviceFound);
+  }, [isBluetoothEnabled, bluetoothPermGranted, onDeviceFound]);
+
   useEffect(() => {
     const fetchFavoriteDevices = async () => {
       const id = unitId || unitData?.id;

package/src/screens/ActivityLog/__test__/FilterPopup.test.js

@@ -17,13 +17,6 @@ const wrapComponent = (props) => (
   </SCProvider>
 );
 
-jest.mock('react', () => {
-  return {
-    ...jest.requireActual('react'),
-    memo: (x) => x,
-  };
-});
-
 it('test FilterPopup', async () => {
   Date.now = jest.fn(() => new Date('2021-09-09T10:00:00.000Z'));
   const mockOnHide = jest.fn();

package/src/screens/ActivityLog/__test__/ItemLog.test.js

@@ -12,13 +12,6 @@ const wrapComponent = (props) => (
   </SCProvider>
 );
 
-jest.mock('react', () => {
-  return {
-    ...jest.requireActual('react'),
-    memo: (x) => x,
-  };
-});
-
 it('test ItemLog smart assistant', async () => {
   let tree;
   let props = {

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

@@ -25,13 +25,6 @@ jest.mock('react-redux', () => {
   };
 });
 
-jest.mock('react', () => {
-  return {
-    ...jest.requireActual('react'),
-    memo: (x) => x,
-  };
-});
-
 const mock = new MockAdapter(api.axiosInstance);
 
 const wrapComponent = (route) => (

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

@@ -37,13 +37,6 @@ jest.mock('@react-navigation/native', () => {
   };
 });
 
-jest.mock('react', () => {
-  return {
-    ...jest.requireActual('react'),
-    memo: (x) => x,
-  };
-});
-
 jest.mock('react-native-maps', () => {
   const { forwardRef } = require('react');
   const { View } = require('react-native');

package/src/screens/AddNewAction/SelectAction.js

@@ -252,6 +252,7 @@ const SelectAction = memo(({ route }) => {
       case 'three_button_action_template':
       case 'OnOffSimpleActionTemplate':
       case 'curtain_action_template':
+      case 'OnOffSmartLockActionTemplate':
         index = newActions.findIndex((item) => {
           return (
             item.template === 'on_off_button_action_template' ||
@@ -264,13 +265,15 @@ const SelectAction = memo(({ route }) => {
         });
         break;
 
-      case 'OptionsDropdownActionTemplate':
-      case 'NumberUpDownActionTemplate':
       case 'StatesGridActionTemplate':
         index = newActions.findIndex(
           (item) => item.template === action.template
         );
         break;
+      case 'OptionsDropdownActionTemplate':
+      case 'NumberUpDownActionTemplate':
+        index = newActions.findIndex((item) => item.action === action.action);
+        break;
     }
 
     if (index < 0) {
@@ -438,13 +441,13 @@ const SelectAction = memo(({ route }) => {
 });
 
 const RenderActionItem = ({ device, data, onSelectAction }) => {
-  if (!data) {
+  if (!data.length) {
     return null;
   }
   const actionTemplate = [];
-  let optionsDropdownActionTemplate = {};
-  let numberUpDownActionTemplate = {};
-  let statesGridActionTemplate = {};
+  const optionsDropdownActionTemplates = [];
+  const numberUpDownActionTemplates = [];
+  const statesGridActionTemplates = [];
 
   data.forEach((item) => {
     switch (item.template) {
@@ -457,13 +460,13 @@ const RenderActionItem = ({ device, data, onSelectAction }) => {
         actionTemplate.push(item);
         break;
       case 'OptionsDropdownActionTemplate':
-        optionsDropdownActionTemplate = { ...item };
+        optionsDropdownActionTemplates.push(item);
         break;
       case 'NumberUpDownActionTemplate':
-        numberUpDownActionTemplate = { ...item };
+        numberUpDownActionTemplates.push(item);
         break;
       case 'StatesGridActionTemplate':
-        statesGridActionTemplate = { ...item };
+        statesGridActionTemplates.push(item);
         break;
     }
   });
@@ -481,27 +484,28 @@ const RenderActionItem = ({ device, data, onSelectAction }) => {
           onSelectAction={handleOnSelectAction}
         />
       )}
-      {Object.keys(numberUpDownActionTemplate).length > 0 && (
+      {numberUpDownActionTemplates.map((item) => (
         <NumberUpDownActionTemplate
           device={device}
-          data={numberUpDownActionTemplate}
+          data={item}
           onSelectAction={handleOnSelectAction}
         />
-      )}
-      {Object.keys(optionsDropdownActionTemplate).length > 0 && (
+      ))}
+
+      {optionsDropdownActionTemplates.map((item) => (
         <OptionsDropdownActionTemplate
           device={device}
-          data={optionsDropdownActionTemplate}
+          data={item}
           onSelectAction={handleOnSelectAction}
         />
-      )}
-      {Object.keys(statesGridActionTemplate).length > 0 && (
+      ))}
+      {statesGridActionTemplates.map((item) => (
         <StatesGridActionTemplate
           device={device}
-          data={statesGridActionTemplate}
+          data={item}
           onSelectAction={handleOnSelectAction}
         />
-      )}
+      ))}
     </>
   );
 };