@eohjsc/react-native-smart-city 0.3.38 → 0.3.39

package/package.json

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

package/src/commons/AlertAction/index.js

@@ -39,7 +39,11 @@ const AlertAction = ({
       <Animated.View style={[styles.popoverStyle, animatedStyle]}>
         <View style={styles.modalWrapper}>
           <View style={styles.modalHeader}>
-            <Text semibold style={styles.modalHeaderText}>
+            <Text
+              semibold
+              style={styles.modalHeaderText}
+              accessibilityLabel={`${accessibilityLabelPrefix}_TITLE`}
+            >
               {title}
             </Text>
           </View>

package/src/commons/Device/ItemDevice.js

@@ -11,9 +11,11 @@ import { useNavigation } from '@react-navigation/native';
 import { useTranslations } from '../../hooks/Common/useTranslations';
 import ItemQuickAction from '../../commons/Action/ItemQuickAction';
 import Text from '../../commons/Text';
-import { isDeviceConnected as isBluetoothDeviceConnected } from '../../iot/RemoteControl/Bluetooth';
-import { useSCContextSelector } from '../../context';
-import { useHomeAssistantDeviceConnected } from '../../hooks/Common';
+import {
+  useHomeAssistantDeviceConnected,
+  useBluetoothDeviceConnected,
+  useEoHBackendDeviceConnected,
+} from '../../hooks/IoT';
 
 import { Colors } from '../../configs';
 import {
@@ -27,20 +29,20 @@ const ItemDevice = memo(
   ({ svgMain, description, title, sensor, unit, station, wrapStyle }) => {
     const t = useTranslations();
     const navigation = useNavigation();
-    const isBluetoothEnabled = useSCContextSelector(
-      (state) => state.app.isBluetoothEnabled
-    );
-    const isNetworkConnected = useSCContextSelector(
-      (state) => state.app.isNetworkConnected
-    );
-    const statuses = useSCContextSelector(
-      (state) => state.iot.internet.statuses
-    );
+
+    const {
+      isConnected: isEoHBackendConnected,
+      isFetchingStatus: isFetchingStatusFromEoHBackend,
+    } = useEoHBackendDeviceConnected(sensor);
+
     const {
       isConnected: isHomeAssistantConnected,
       isConnecting: isHomeAssistantConnecting,
     } = useHomeAssistantDeviceConnected(sensor);
 
+    const { isConnected: isBluetoothConnected } =
+      useBluetoothDeviceConnected(sensor);
+
     const goToSensorDisplay = useCallback(() => {
       navigation.navigate(Routes.DeviceDetail, {
         unitData: unit,
@@ -50,30 +52,15 @@ const ItemDevice = memo(
       });
     }, [navigation, sensor, station, title, unit]);
 
-    const isConnectedViaInternet =
-      isNetworkConnected &&
-      !!sensor &&
-      sensor.id in statuses &&
-      statuses[sensor.id]?.isConnected;
-
-    const isFetchingStatus =
-      isNetworkConnected && !!sensor && !(sensor.id in statuses);
-
-    const isConnectedViaBLE =
-      isBluetoothEnabled &&
-      isBluetoothDeviceConnected(
-        sensor?.remote_control_options?.bluetooth?.address
-      );
-
     const borderColor = (() => {
       if (!!sensor && sensor?.is_managed_by_backend) {
         if (sensor?.device_type === DEVICE_TYPE.LG_THINQ) {
           return Colors.Gray4;
         }
-        if (isConnectedViaBLE) {
+        if (isBluetoothConnected) {
           return Colors.Gray4;
         }
-        if (isFetchingStatus || isConnectedViaInternet) {
+        if (isFetchingStatusFromEoHBackend || isEoHBackendConnected) {
           return Colors.Gray4;
         }
         return Colors.Red6;
@@ -92,13 +79,13 @@ const ItemDevice = memo(
         if (sensor?.device_type === DEVICE_TYPE.LG_THINQ) {
           return t('connected');
         }
-        if (isConnectedViaBLE) {
+        if (isBluetoothConnected) {
           return t('connected');
         }
-        if (isFetchingStatus) {
+        if (isFetchingStatusFromEoHBackend) {
           return '';
         }
-        if (isConnectedViaInternet) {
+        if (isEoHBackendConnected) {
           return t('connected');
         }
         return t('disconnected');
@@ -120,10 +107,10 @@ const ItemDevice = memo(
         if (sensor?.device_type === DEVICE_TYPE.LG_THINQ) {
           return true;
         }
-        if (isConnectedViaBLE) {
+        if (isBluetoothConnected) {
           return true;
         }
-        if (isFetchingStatus) {
+        if (isFetchingStatusFromEoHBackend) {
           return false;
         }
         return true;

package/src/commons/Form/TextInput.js

@@ -29,6 +29,7 @@ const _TextInput = ({
   accessibilityLabel,
   selection,
   onSelectionChange,
+  accessibilityLabelError,
 }) => {
   const errorStyle = !!errorText && styles.errorWrap;
   return (
@@ -70,7 +71,14 @@ const _TextInput = ({
         onSelectionChange={onSelectionChange}
       />
       {extraText && extraText}
-      {!!errorText && <Text style={styles.errorText}>{errorText}</Text>}
+      {!!errorText && (
+        <Text
+          accessibilityLabel={accessibilityLabelError}
+          style={styles.errorText}
+        >
+          {errorText}
+        </Text>
+      )}
     </View>
   );
 };

package/src/commons/WrapParallaxScrollView/index.js

@@ -37,7 +37,12 @@ const WrapParallaxScrollView = ({
           hideRightPlus={hideRightPlus}
           idButtonMore={idButtonMore}
         />
-        <Text numberOfLines={1} semibold style={styles.nameUnit}>
+        <Text
+          numberOfLines={1}
+          semibold
+          style={styles.nameUnit}
+          accessibilityLabel={AccessibilityLabel.HEADER_UNIT_BUTTON_TEXT}
+        >
           {title}
         </Text>
         {contentBackground}

package/src/configs/AccessibilityLabel.js

@@ -43,6 +43,8 @@ export default {
 
   // ConfirmUnitDeletion
   CONFIRM_UNIT_DELETION_BUTTON: 'CONFIRM_UNIT_DELETION_BUTTON',
+  CONFIRM_UNIT_DELETION_CONFIRM_FIELD: 'CONFIRM_UNIT_DELETION_CONFIRM_FIELD',
+  CONFIRM_UNIT_DELETION_CONFIRM_ERROR: 'CONFIRM_UNIT_DELETION_CONFIRM_ERROR',
 
   //member list
   SHARING_MEMBER: 'SHARING_MEMBER',
@@ -252,6 +254,8 @@ export default {
   EMERGENCY_BUTTON: 'EMERGENCY_BUTTON',
 
   // ADD SUB UNIT
+  ADD_SUB_UNIT_SCREEN: 'ADD_SUB_UNIT_SCREEN',
+  ADD_SUB_UNIT_NAME_FIELD: 'ADD_SUB_UNIT_NAME_FIELD',
   ADD_SUB_UNIT_BUTTON_CHOOSE_PHOTO: 'ADD_SUB_UNIT_BUTTON_CHOOSE_PHOTO',
   ADD_SUB_UNIT_BUTTON_CHOOSE_LOCATION: 'ADD_SUB_UNIT_BUTTON_CHOOSE_LOCATION',
 
@@ -440,6 +444,7 @@ export default {
 
   // Header Unit
   HEADER_UNIT_BUTTON_BACK: 'HEADER_UNIT_BUTTON_BACK',
+  HEADER_UNIT_BUTTON_TEXT: 'HEADER_UNIT_BUTTON_TEXT',
   HEADER_UNIT_BUTTON_ADD: 'HEADER_UNIT_BUTTON_ADD',
   HEADER_UNIT_BUTTON_MORE: 'HEADER_UNIT_BUTTON_MORE',
 

package/src/context/actionType.ts

@@ -17,6 +17,7 @@ export const Action = {
   SET_STARRED_SCRIPTS: 'SET_STARRED_SCRIPTS',
   STAR_SCRIPTS: 'STAR_SCRIPTS',
   UNSTAR_SCRIPTS: 'UNSTAR_SCRIPTS',
+  SET_BLUETOOTH_CONNECTED_DEVICE: 'SET_BLUETOOTH_CONNECTED_DEVICE',
   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',
@@ -95,6 +96,9 @@ export type AppType = {
 };
 
 export type IoTType = {
+  bluetooth: {
+    connectedDevices: {};
+  };
   homeassistant: {
     connections: {};
   };

package/src/context/mockStore.ts

@@ -41,6 +41,9 @@ export const mockDataStore: ContextData = {
     isLockWhenPickColor: false,
   },
   iot: {
+    bluetooth: {
+      connectedDevices: {},
+    },
     homeassistant: {
       connections: {},
     },

package/src/context/reducer.ts

@@ -68,6 +68,9 @@ export const initialState = {
     isLockWhenPickColor: false,
   },
   iot: {
+    bluetooth: {
+      connectedDevices: {},
+    },
     homeassistant: {
       connections: {},
     },
@@ -291,6 +294,20 @@ export const reducer = (currentState: ContextData, action: Action) => {
         },
       };
 
+    case Action.SET_BLUETOOTH_CONNECTED_DEVICE:
+      return {
+        ...currentState,
+        iot: {
+          ...currentState.iot,
+          bluetooth: {
+            ...currentState.iot.bluetooth,
+            connectedDevices: {
+              ...currentState.iot.bluetooth.connectedDevices,
+              [payload.name]: payload.device,
+            },
+          },
+        },
+      };
     case Action.SET_HOME_ASSISTANT_CONNECTIONS:
       return {
         ...currentState,

package/src/hooks/Common/index.js

@@ -5,7 +5,6 @@ import useKeyboardShow from './useKeyboardShow';
 import usePopover from './usePopover';
 import useTitleHeader from './useTitleHeader';
 import useDevicesStatus from './useDevicesStatus';
-import useHomeAssistantDeviceConnected from './useHomeAssistantDeviceConnected';
 import { useBlockBackAndroid } from './useBlockBackAndroid';
 import { useIsOwnerOfUnit } from './useIsOwnerOfUnit';
 import { useStatusBar } from './useStatusBar';
@@ -23,5 +22,4 @@ export {
   useStatusBar,
   useGetIdUser,
   useDevicesStatus,
-  useHomeAssistantDeviceConnected,
 };

package/src/hooks/Common/useDevicesStatus.js

@@ -1,6 +1,5 @@
-import { useCallback, useContext } from 'react';
-import { InteractionManager } from 'react-native';
-import { useFocusEffect } from '@react-navigation/native';
+import { useCallback, useContext, useEffect } from 'react';
+import { useIsFocused } from '@react-navigation/native';
 import { SCContext, useSCContextSelector } from '../../context';
 import { axiosGet } from '../../utils/Apis/axios';
 import { API } from '../../configs';
@@ -13,8 +12,13 @@ const useDevicesStatus = (unit, devices) => {
   const isNetworkConnected = useSCContextSelector(
     (state) => state.app.isNetworkConnected
   );
+  const isFocused = useIsFocused();
 
   const getDevicesStatus = useCallback(async (_unit, _devices) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = 0;
+    }
     const params = new URLSearchParams();
     _devices.forEach((device) => {
       params.append('sensors', device.id);
@@ -30,32 +34,26 @@ const useDevicesStatus = (unit, devices) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  useFocusEffect(
-    useCallback(() => {
-      const task = InteractionManager.runAfterInteractions(() => {
-        if (!devices?.length || !isNetworkConnected) {
-          return;
-        }
+  useEffect(() => {
+    if (!isFocused) {
+      return;
+    }
+    if (!devices?.length || !isNetworkConnected) {
+      return;
+    }
 
-        const managedDevices = devices.filter(
-          (device) => device?.is_managed_by_backend
-        );
-        if (!managedDevices.length) {
-          return;
-        }
-        timeoutId = setTimeout(
-          () => getDevicesStatus(unit, managedDevices),
-          200
-        );
-      });
-
-      return () => {
-        clearTimeout(timeoutId);
-        task.cancel();
-      };
-      // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [unit, devices, isNetworkConnected])
-  );
+    const managedDevices = devices.filter(
+      (device) => device?.is_managed_by_backend
+    );
+    if (!managedDevices.length) {
+      return;
+    }
+    getDevicesStatus(unit, devices);
+    return () => {
+      clearTimeout(timeoutId);
+      timeoutId = 0;
+    };
+  }, [getDevicesStatus, unit, devices, isNetworkConnected, isFocused]);
 };
 
 export default useDevicesStatus;

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

@@ -88,6 +88,8 @@ describe('Test useRemoteControl', () => {
   });
 
   it('test send remote command via bluetooth failed then send via internet', async () => {
+    action.command_prefer_over_bluetooth = true;
+    action.command_prefer_over_internet = true;
     const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
       wrapper,
     });
@@ -156,6 +158,7 @@ describe('Test useRemoteControl', () => {
       data,
       'internet'
     );
+    expect(sendCommandOverInternet).toBeCalledTimes(1);
     expect(sendCommandOverBluetooth).not.toBeCalled();
     expect(sendCommandOverHomeAssistant).not.toBeCalled();
     expect(sendCommandOverLGThinq).not.toBeCalled();

package/src/hooks/IoT/index.js

@@ -1,13 +1,21 @@
+import useBluetoothConnection from './useBluetoothConnection';
 import useHomeAssistantConnection from './useHomeAssistantConnection';
 import useRemoteControl from './useRemoteControl';
 import useValueEvaluations from './useValueEvaluation';
 import useWatchConfigs from './useWatchConfigs';
 import useUnwatchLGDeviceConfigControl from './useUnwatchLGDeviceConfigControl';
+import useHomeAssistantDeviceConnected from './useHomeAssistantDeviceConnected';
+import useBluetoothDeviceConnected from './useBluetoothDeviceConnected';
+import useEoHBackendDeviceConnected from './useEoHBackendDeviceConnected';
 
 export {
+  useBluetoothConnection,
   useHomeAssistantConnection,
   useRemoteControl,
   useValueEvaluations,
   useWatchConfigs,
   useUnwatchLGDeviceConfigControl,
+  useHomeAssistantDeviceConnected,
+  useBluetoothDeviceConnected,
+  useEoHBackendDeviceConnected,
 };

package/src/hooks/IoT/useBluetoothConnection.js

@@ -0,0 +1,27 @@
+import { useContext, useCallback } from 'react';
+import { SCContext } from '../../context';
+import { Action } from '../../context/actionType';
+import { scanBluetoothDevices } from '../../iot/RemoteControl/Bluetooth';
+
+const useBluetoothConnection = () => {
+  const { setAction } = useContext(SCContext);
+
+  const onDeviceFound = useCallback(async (name, device) => {
+    setAction(Action.SET_BLUETOOTH_CONNECTED_DEVICE, { name, device });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const bluetoothScanDevices = useCallback(
+    (addresses) => {
+      scanBluetoothDevices(addresses, onDeviceFound);
+    },
+    [onDeviceFound]
+  );
+
+  return {
+    onDeviceFound,
+    bluetoothScanDevices,
+  };
+};
+
+export default useBluetoothConnection;

package/src/hooks/IoT/useBluetoothDeviceConnected.js

@@ -0,0 +1,18 @@
+import { useSCContextSelector } from '../../context';
+
+const useBluetoothDeviceConnected = (device) => {
+  const connectedDevices = useSCContextSelector(
+    (state) => state.iot.bluetooth.connectedDevices
+  );
+  const isBluetoothEnabled = useSCContextSelector((state) => {
+    return state.app.isBluetoothEnabled;
+  });
+
+  const isConnected =
+    isBluetoothEnabled &&
+    !!connectedDevices[device?.remote_control_options?.bluetooth?.address];
+
+  return { isConnected };
+};
+
+export default useBluetoothDeviceConnected;

package/src/hooks/IoT/useEoHBackendDeviceConnected.js

@@ -0,0 +1,21 @@
+import { useSCContextSelector } from '../../context';
+
+const useEoHBackendDeviceConnected = (device) => {
+  const isNetworkConnected = useSCContextSelector(
+    (state) => state.app.isNetworkConnected
+  );
+  const statuses = useSCContextSelector((state) => state.iot.internet.statuses);
+
+  const isConnected =
+    isNetworkConnected &&
+    !!device &&
+    device.id in statuses &&
+    statuses[device.id]?.isConnected;
+
+  const isFetchingStatus =
+    isNetworkConnected && !!device && !(device.id in statuses);
+
+  return { isConnected, isFetchingStatus };
+};
+
+export default useEoHBackendDeviceConnected;

package/src/hooks/IoT/useRemoteControl.js

@@ -15,7 +15,7 @@ const useRemoteControl = () => {
   );
 
   const sendRemoteCommand = useCallback(
-    async (sensor, action, data, userId) => {
+    async (device, action, data, userId) => {
       // No action, raise not authorized
       let result = false;
       if (!action) {
@@ -27,39 +27,28 @@ const useRemoteControl = () => {
 
       if (action.command_prefer_over_bluetooth) {
         try {
-          result = await sendCommandOverBluetooth(sensor, action, data, userId);
+          result = await sendCommandOverBluetooth(device, action, data, userId);
         } catch (err) {
-          result = false;
-          if (err === SEND_COMMAND_OVER_BLUETOOTH_FAIL) {
-            result = await sendCommandOverInternet(
-              sensor,
-              action,
-              data,
-              'bluetooth'
-            );
-          } else {
+          if (err !== SEND_COMMAND_OVER_BLUETOOTH_FAIL) {
             throw err;
           }
+          result = false;
         }
       }
 
-      if (
-        (action.command_prefer_over_internet ||
-          action.command_prefer_over_bluetooth) &&
-        !result
-      ) {
+      if (action.command_prefer_over_internet && !result) {
         result = await sendCommandOverInternet(
-          sensor,
+          device,
           action,
           data,
-          'internet'
+          action.command_prefer_over_bluetooth ? 'bluetooth' : 'internet'
         );
       }
 
       if (action.command_prefer_over_googlehome && !result) {
         result = await sendCommandOverHomeAssistant(
           homeAssistantConnections,
-          sensor,
+          device,
           action,
           data
         );

package/src/iot/RemoteControl/Bluetooth.js

@@ -22,24 +22,17 @@ export const clearFoundDevices = () => {
   }
 };
 
-bleManager.onStateChange((state) => {
-  if (state === 'PoweredOn') {
-    ToastBottomHelper.success(t('text_ble_is_powered_on'));
-    realScanBluetoothDevices();
-  }
-}, true);
-
-export const scanBluetoothDevices = (names) => {
+export const scanBluetoothDevices = (names, onDeviceFound) => {
   names.map((name) => {
     if (bluetoothDevices[name]) {
       return;
     }
     needToScanDevices.push(name);
   });
-  realScanBluetoothDevices();
+  realScanBluetoothDevices(onDeviceFound);
 };
 
-const realScanBluetoothDevices = () => {
+export const realScanBluetoothDevices = (onDeviceFound) => {
   if (!needToScanDevices.length) {
     return;
   }
@@ -67,9 +60,9 @@ const realScanBluetoothDevices = () => {
     const index = needToScanDevices.indexOf(name);
     needToScanDevices.splice(index, 1);
 
-    ToastBottomHelper.success(t(`Found bluetooth ${name} for remote control`));
-
     bluetoothDevices[name] = device;
+    onDeviceFound && onDeviceFound(name, device);
+
     if (!needToScanDevices.length) {
       try {
         bleManager.stopDeviceScan();

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

@@ -1,6 +1,4 @@
 import { BleManager } from 'react-native-ble-plx';
-import Toast from 'react-native-toast-message';
-import { getTranslate } from '../../../utils/I18n';
 import '../Bluetooth';
 import {
   scanBluetoothDevices,
@@ -12,11 +10,13 @@ import {
 
 const bleManager = new BleManager();
 
+const mockOnDeviceFound = jest.fn();
+
 describe('Test IOT Bluetooth', () => {
   beforeEach(() => {
+    mockOnDeviceFound.mockClear();
     bleManager.startDeviceScan.mockClear();
     bleManager.stopDeviceScan.mockClear();
-    Toast.show.mockClear();
     clearNeedToScanDevices();
     clearFoundDevices();
   });
@@ -26,53 +26,14 @@ describe('Test IOT Bluetooth', () => {
     clearNeedToScanDevices();
   });
 
-  it('When bluetooth is powered on, user get notification', async () => {
-    const onStateChangeFn = bleManager.onStateChangeFn;
-    onStateChangeFn('PoweredOn');
-    expect(Toast.show).toBeCalledWith({
-      type: 'success',
-      position: 'bottom',
-      text1: getTranslate('en', 'text_ble_is_powered_on'),
-      visibilityTime: 1000,
-    });
-  });
-
-  it('When bluetooth is powered on but Toast not ready, user does not get notification', async () => {
-    const onStateChangeFn = bleManager.onStateChangeFn;
-    Toast._ref = null;
-
-    onStateChangeFn('PoweredOn');
-    expect(Toast.show).toBeCalled();
-
-    Toast._ref = true;
-  });
-
-  it('When bluetooth is powered off, user does not get notification', async () => {
-    const onStateChangeFn = bleManager.onStateChangeFn;
-    onStateChangeFn('PoweredOff');
-    expect(Toast.show).not.toBeCalled();
-  });
-
-  it('Scan bluetooth device will init hardware scan', async () => {
-    scanBluetoothDevices(['123456']);
+  test('Scan bluetooth device will init hardware scan', async () => {
+    scanBluetoothDevices(['123456'], mockOnDeviceFound);
     expect(bleManager.startDeviceScan).toBeCalled();
   });
 
-  it('When power on, hardware will continue look for bluetooth', async () => {
-    scanBluetoothDevices(['123456']);
-    expect(bleManager.startDeviceScan).toBeCalledTimes(1);
-    bleManager.onStateChangeFn('PoweredOn');
-    expect(bleManager.startDeviceScan).toBeCalledTimes(2);
-  });
-
-  it('When power on, if not looking for bluetooth then hardware will not scan', async () => {
-    bleManager.onStateChangeFn('PoweredOn');
-    expect(bleManager.startDeviceScan).not.toBeCalled();
-  });
-
-  it('When look for bluetooth name, hardware will auto stop after period of time', async () => {
+  test('When look for bluetooth name, hardware will auto stop after period of time', async () => {
     jest.useFakeTimers();
-    scanBluetoothDevices(['123456']);
+    scanBluetoothDevices(['123456'], mockOnDeviceFound);
     jest.runAllTimers();
     expect(bleManager.stopDeviceScan).toBeCalled();
   });
@@ -87,13 +48,8 @@ describe('Test IOT Bluetooth', () => {
       }
     );
 
-    scanBluetoothDevices([device.localName]);
-    expect(Toast.show).toBeCalledWith({
-      type: 'success',
-      position: 'bottom',
-      text1: 'Found bluetooth 123456 for remote control',
-      visibilityTime: 1000,
-    });
+    scanBluetoothDevices([device.localName], mockOnDeviceFound);
+    expect(mockOnDeviceFound).toBeCalledWith(device.localName, device);
   });
 
   it('When search bluetooth has error then program does nothing', async () => {
@@ -107,8 +63,8 @@ describe('Test IOT Bluetooth', () => {
       }
     );
 
-    scanBluetoothDevices([device.name]);
-    expect(Toast.show).not.toBeCalled();
+    scanBluetoothDevices([device.name], mockOnDeviceFound);
+    expect(mockOnDeviceFound).not.toBeCalled();
   });
 
   it('When search bluetooth but found another device then program does nothing', async () => {
@@ -122,8 +78,8 @@ describe('Test IOT Bluetooth', () => {
       }
     );
 
-    scanBluetoothDevices([device.name + 'x']);
-    expect(Toast.show).not.toBeCalled();
+    scanBluetoothDevices([device.name + 'x'], mockOnDeviceFound);
+    expect(mockOnDeviceFound).not.toBeCalled();
   });
 
   it('When not found all bluetooth then hardware will continue scan', async () => {
@@ -135,7 +91,7 @@ describe('Test IOT Bluetooth', () => {
         listener(null, device);
       }
     );
-    scanBluetoothDevices([device.name, device.name + 'x']);
+    scanBluetoothDevices([device.name, device.name + 'x'], mockOnDeviceFound);
     expect(bleManager.stopDeviceScan).not.toBeCalled();
   });
 
@@ -148,7 +104,7 @@ describe('Test IOT Bluetooth', () => {
         listener(null, device);
       }
     );
-    scanBluetoothDevices([device.name]);
+    scanBluetoothDevices([device.name], mockOnDeviceFound);
     expect(bleManager.stopDeviceScan).toBeCalled();
   });
 
@@ -161,12 +117,12 @@ describe('Test IOT Bluetooth', () => {
         listener(null, device);
       }
     );
-    scanBluetoothDevices([device.name]);
+    scanBluetoothDevices([device.name], mockOnDeviceFound);
     expect(bleManager.startDeviceScan).toBeCalled();
 
     bleManager.startDeviceScan.mockClear();
 
-    scanBluetoothDevices([device.name]);
+    scanBluetoothDevices([device.name], mockOnDeviceFound);
     expect(bleManager.startDeviceScan).not.toBeCalled();
   });
 
@@ -203,7 +159,7 @@ describe('Test IOT Bluetooth', () => {
         listener(null, device);
       }
     );
-    scanBluetoothDevices([device.name]);
+    scanBluetoothDevices([device.name], mockOnDeviceFound);
 
     await sendCommandBluetoothFail({
       remote_control_options: {
@@ -230,7 +186,7 @@ describe('Test IOT Bluetooth', () => {
         listener(null, device);
       }
     );
-    scanBluetoothDevices([device.name]);
+    scanBluetoothDevices([device.name], mockOnDeviceFound);
 
     await sendCommandOverBluetooth(
       {

package/src/navigations/UnitStack.js

@@ -59,6 +59,9 @@ import { axiosGet } from '../utils/Apis/axios';
 import { API } from '../configs';
 import SideMenuDetail from '../screens/SideMenuDetail';
 import { styles } from './UnitStackStyles';
+import { useBluetoothConnection } from '../hooks/IoT';
+import { realScanBluetoothDevices } from '../iot/RemoteControl/Bluetooth';
+import { ToastBottomHelper } from '../utils/Utils';
 
 const Stack = createStackNavigator();
 
@@ -78,9 +81,16 @@ export const UnitStack = memo((props) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
+  const { onDeviceFound } = useBluetoothConnection();
+
   useEffect(() => {
     const subscription = bleManager.onStateChange((state) => {
-      setAction(Action.SET_BLUETOOTH_STATE, state === 'PoweredOn');
+      const connected = state === 'PoweredOn';
+      setAction(Action.SET_BLUETOOTH_STATE, connected);
+      if (connected) {
+        ToastBottomHelper.success(t('text_ble_is_powered_on'));
+        realScanBluetoothDevices(onDeviceFound);
+      }
     }, true);
 
     return () => subscription.remove();

package/src/screens/AddLocationMaps/index.js

@@ -287,6 +287,7 @@ const AddLocationMaps = memo(() => {
         rightTitle={t('done')}
         onRightClick={onDone}
         rightDisabled={!input}
+        accessibilityLabelPrefix={'LOCATION_'}
       />
       {loading && <FullLoading />}
     </View>

package/src/screens/AddNewGateway/RenameNewDevices.js

@@ -106,13 +106,13 @@ const RenameNewDevices = memo(({ route }) => {
                   onChange={updateItemName('sensor', sensor_index)}
                 />
               </View>
-              {sensor.end_devices?.length &&
-                sensor.end_devices.map((end_device, end_device_index) => (
-                  <View style={styles.device} key={`${end_device.id}`}>
+              {(sensor?.end_devices || []).map(
+                (end_device, end_device_index) => (
+                  <View style={styles.device} key={`${end_device?.id}`}>
                     <AddDeviceIcon width={43} height={43} />
                     <_TextInput
-                      accessibilityLabel={`${renameLabel}-end_device-${end_device.id}`}
-                      value={end_device.name}
+                      accessibilityLabel={`${renameLabel}-end_device-${end_device?.id}`}
+                      value={end_device?.name}
                       textInputStyle={styles.textItem}
                       onChange={updateItemName(
                         'end_device',
@@ -121,7 +121,8 @@ const RenameNewDevices = memo(({ route }) => {
                       )}
                     />
                   </View>
-                ))}
+                )
+              )}
             </>
           ))}
       </View>

package/src/screens/AddNewGateway/ScanGatewayQR.js

@@ -22,18 +22,14 @@ const ScanGatewayQR = memo(({ route }) => {
         setLoading(false);
         return;
       }
-      const devicePrefixName = data?.imei?.split('-')[0];
-
-      // todo Bang change QR format
-      if (['LITE'].indexOf(devicePrefixName) === -1) {
+      if (!data?.prefix || !data?.org_slug) {
         setIsInvalidQrCode(true);
         setLoading(false);
         return;
       }
       navigate(Routes.ConnectingWifiGuide, {
         unitId,
-        stationId: stationId,
-        prefix: devicePrefixName,
+        stationId,
         qrData: data,
       });
       setLoading(true);

package/src/screens/AddNewGateway/__test__/ScanGatewayQR.test.js

@@ -65,7 +65,7 @@ describe('test scan gateway device QR', () => {
   });
 
   it('on scan correct QR code', async () => {
-    await scanQRCode({ imei: 'LITE-xxx' }, jest.fn());
+    await scanQRCode({ org_slug: 'eoh', prefix: 'lite' }, jest.fn());
     expect(mockedNavigate).toHaveBeenCalled();
     expect(mockedNavigate.mock.calls[0][0]).toEqual(Routes.ConnectingWifiGuide);
   });

package/src/screens/ConfirmUnitDeletion/index.js

@@ -49,11 +49,16 @@ const ConfirmUnitDeletion = ({ route }) => {
         {t('enter_yes_to_perform')}
       </Text>
       <_TextInput
-        placeholder={t('text_password')}
         onChange={onChangePassword}
         errorText={errorText}
         wrapStyle={styles.noMarginTop}
         textInputStyle={styles.textInput}
+        accessibilityLabel={
+          AccessibilityLabel.CONFIRM_UNIT_DELETION_CONFIRM_FIELD
+        }
+        accessibilityLabelError={
+          AccessibilityLabel.CONFIRM_UNIT_DELETION_CONFIRM_ERROR
+        }
       />
       <View style={styles.buttonWrap}>
         <Button

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

@@ -226,6 +226,7 @@ describe('test DeviceDetail', () => {
     await act(async () => {
       tree = await create(wrapComponent(store, account, route));
     });
+
     const instance = tree.root;
     const sensorDisplayItem = instance.findAll(
       (el) =>

package/src/screens/Device/detail.js

@@ -7,59 +7,57 @@ import React, {
   useContext,
 } from 'react';
 import { View, TouchableOpacity, Platform } from 'react-native';
-import { useTranslations } from '../../hooks/Common/useTranslations';
-import moment from 'moment';
-import { get } from 'lodash';
+import { useNavigation } from '@react-navigation/native';
 import { useSelector } from 'react-redux';
 import { IconFill, IconOutline } from '@ant-design/icons-react-native';
 import { Icon } from '@ant-design/react-native';
-import Routes from '../../utils/Route';
+import moment from 'moment';
+import { get } from 'lodash';
+
+import { SCContext } from '../../context';
+import { Action } from '../../context/actionType';
+import { useSCContextSelector } from '../../context';
+import { useTranslations } from '../../hooks/Common/useTranslations';
 import { useCountUp } from './hooks/useCountUp';
-import { getData as getLocalData } from '../../utils/Storage';
-import { API, Colors } from '../../configs';
-import { axiosGet } from '../../utils/Apis/axios';
-import {
-  isDeviceConnected,
-  scanBluetoothDevices,
-} from '../../iot/RemoteControl/Bluetooth';
-import WrapHeaderScrollable from '../../commons/Sharing/WrapHeaderScrollable';
-import { getActionComponent } from '../../commons/ActionGroup';
-import { AlertSendConfirm } from '../../commons/EmergencyButton/AlertSendConfirm';
-import { AlertSent } from '../../commons/EmergencyButton/AlertSent';
 import {
   useAlertResolveEmergency,
   useEmergencyButton,
 } from './hooks/useEmergencyButton';
 import { useFavoriteDevice } from './hooks/useFavoriteDevice';
-import BottomButtonView from '../../commons/BottomButtonView';
-import Text from '../../commons/Text';
-import { AlertAction, ButtonPopup, MenuActionMore } from '../../commons';
-import { DEVICE_TYPE, AccessibilityLabel } from '../../configs/Constants';
-import { SCContext } from '../../context';
-import { Action } from '../../context/actionType';
-
 import { usePopover } from '../../hooks/Common';
 import { useConfigGlobalState } from '../../iot/states';
-import { useNavigation } from '@react-navigation/native';
-import styles from './styles';
-import {
-  useIsOwnerOfUnit,
-  useBoolean,
-  useHomeAssistantDeviceConnected,
-} from '../../hooks/Common';
+import { useIsOwnerOfUnit, useBoolean } from '../../hooks/Common';
 import {
+  useBluetoothConnection,
   useHomeAssistantConnection,
   useValueEvaluations,
+  useBluetoothDeviceConnected,
+  useHomeAssistantDeviceConnected,
+  useEoHBackendDeviceConnected,
 } from '../../hooks/IoT';
-import { SensorDisplayItem } from './components/SensorDisplayItem';
-import { useSCContextSelector } from '../../context';
-import { EmergencyCountdown } from './components/EmergencyCountdown';
-import { SensorConnectStatusViewHeader } from './components/SensorConnectStatusViewHeader';
 import { useDisconnectedDevice } from './hooks/useDisconnectedDevice';
 import { useEvaluateValue } from './hooks/useEvaluateValue';
 import { useDeviceWatchConfigControl } from './hooks/useDeviceWatchConfigControl';
+
+import WrapHeaderScrollable from '../../commons/Sharing/WrapHeaderScrollable';
+import { getActionComponent } from '../../commons/ActionGroup';
+import { AlertSendConfirm } from '../../commons/EmergencyButton/AlertSendConfirm';
+import { AlertSent } from '../../commons/EmergencyButton/AlertSent';
+import BottomButtonView from '../../commons/BottomButtonView';
+import Text from '../../commons/Text';
+import { AlertAction, ButtonPopup, MenuActionMore } from '../../commons';
+import { SensorDisplayItem } from './components/SensorDisplayItem';
+import { EmergencyCountdown } from './components/EmergencyCountdown';
+import { SensorConnectStatusViewHeader } from './components/SensorConnectStatusViewHeader';
 import { Card } from '../../commons/CardShadow';
 import PreventAccess from '../../commons/PreventAccess';
+
+import styles from './styles';
+import Routes from '../../utils/Route';
+import { getData as getLocalData } from '../../utils/Storage';
+import { API, Colors } from '../../configs';
+import { DEVICE_TYPE, AccessibilityLabel } from '../../configs/Constants';
+import { axiosGet } from '../../utils/Apis/axios';
 import { notImplemented } from '../../utils/Utils';
 
 const DeviceDetail = ({ route }) => {
@@ -102,20 +100,17 @@ const DeviceDetail = ({ route }) => {
   const isNetworkConnected = useSCContextSelector(
     (state) => state.app.isNetworkConnected
   );
-  const isBluetoothEnabled = useSCContextSelector((state) => {
-    return state.app.isBluetoothEnabled;
-  });
+
+  const { isConnected: isEoHBackendConnected } =
+    useEoHBackendDeviceConnected(sensor);
+
   const {
     isConnected: isHomeAssistantConnected,
     isConnecting: isHomeAssistantConnecting,
   } = useHomeAssistantDeviceConnected(sensor);
 
-  const isDeviceConnectedViaBle = useMemo(
-    () =>
-      isBluetoothEnabled &&
-      isDeviceConnected(sensor?.remote_control_options?.bluetooth?.address),
-    [sensor, isBluetoothEnabled]
-  );
+  const { isConnected: isBluetoothConnected } =
+    useBluetoothDeviceConnected(sensor);
 
   const isDeviceHasBle = useMemo(() => {
     const action = display.items.filter((item) => item.type === 'action');
@@ -183,6 +178,8 @@ const DeviceDetail = ({ route }) => {
 
   const { connectHomeAssistant } = useHomeAssistantConnection();
 
+  const { bluetoothScanDevices } = useBluetoothConnection();
+
   useEffect(() => {
     if (
       unit.remote_control_options &&
@@ -196,6 +193,14 @@ const DeviceDetail = ({ route }) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [unit, isNetworkConnected]);
 
+  useEffect(() => {
+    if (controlOptions?.bluetooth) {
+      const bluetooth = controlOptions.bluetooth;
+      bluetoothScanDevices([bluetooth.address]);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [controlOptions, unit]);
+
   const fetchSensorDetail = useCallback(async () => {
     const { success, data, resp_status } = await axiosGet(
       API.DEVICE.SENSOR_DETAIL(sensorId || sensor?.id)
@@ -424,16 +429,9 @@ const DeviceDetail = ({ route }) => {
 
   const { countUpStr } = useCountUp(lastEvent.reportedAt);
 
-  useEffect(() => {
-    if (controlOptions?.bluetooth) {
-      const bluetooth = controlOptions.bluetooth;
-      scanBluetoothDevices([bluetooth.address]);
-    }
-  }, [controlOptions, unit]);
-
   useEffect(() => {
     fetchDataDeviceDetail();
-  }, [sensor, fetchDataDeviceDetail]);
+  }, [sensor, isNetworkConnected, fetchDataDeviceDetail]);
 
   const onRefresh = useCallback(() => {
     fetchSensorDetail();
@@ -542,6 +540,7 @@ const DeviceDetail = ({ route }) => {
       });
     };
     if (
+      isNetworkConnected &&
       sensor?.is_managed_by_backend &&
       sensor?.device_type !== DEVICE_TYPE.LG_THINQ
     ) {
@@ -553,7 +552,7 @@ const DeviceDetail = ({ route }) => {
         setLoading((preState) => ({ ...preState, isConnected: false }));
     }
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [sensor, display]);
+  }, [sensor, display, isNetworkConnected]);
 
   const isShowEmergencyResolve =
     display.items.filter(
@@ -573,6 +572,7 @@ const DeviceDetail = ({ route }) => {
       params: { unitId: unit?.id, group },
     });
   }, [navigation, unit?.group, unit?.id]);
+
   const isHaveColorSliderTemplate = useMemo(() => {
     let isFlag = false;
     display?.items.some((item) => {
@@ -592,14 +592,8 @@ const DeviceDetail = ({ route }) => {
     return (
       <SensorConnectStatusViewHeader
         sensor={sensor}
-        connectedViaNetwork={
-          isNetworkConnected && displayValuesData.isConnected
-        }
-        connectedViaBle={
-          (!isNetworkConnected ||
-            (isNetworkConnected && !displayValuesData.isConnected)) &&
-          isDeviceConnectedViaBle
-        }
+        connectedViaNetwork={isEoHBackendConnected}
+        connectedViaBle={isBluetoothConnected}
         connectedViaHomeAssistant={isHomeAssistantConnected}
         isHomeAssistantConnecting={isHomeAssistantConnecting}
         lastUpdated={displayValuesData.lastUpdated}

package/src/screens/SubUnit/AddSubUnit.js

@@ -164,7 +164,10 @@ const AddSubUnit = ({ route }) => {
   }, [navigate]);
 
   return (
-    <SafeAreaView style={styles.wrap}>
+    <SafeAreaView
+      style={styles.wrap}
+      accessibilityLabel={AccessibilityLabel.ADD_SUB_UNIT_SCREEN}
+    >
       <TouchableWithoutFeedback onPress={Keyboard.dismiss} accessible={false}>
         <View style={styles.commonWrap}>
           <View style={styles.commonWrap}>
@@ -186,6 +189,7 @@ const AddSubUnit = ({ route }) => {
                 selectionColor={Colors.Primary}
                 value={roomName}
                 maxLength={50}
+                accessibilityLabel={AccessibilityLabel.ADD_SUB_UNIT_NAME_FIELD}
               />
 
               {isAddUnit && (

package/src/screens/Unit/MoreMenu.js

@@ -28,19 +28,19 @@ const MoreMenu = memo(
 
     const listMenuItem = useMemo(() => {
       const RouteManageUnit = {
-        id: 1,
+        id: 'mange-unit',
         route: Routes.ManageUnit,
         text: t('manage_unit'),
         data: { unitId: unit.id, unit },
       };
       const RouteUnitMemberList = {
-        id: 2,
+        id: 'unit-member',
         route: Routes.UnitMemberList,
         text: t('members'),
         data: { unitId: unit.id, unit },
       };
       const ListSmartAccount = {
-        id: 3,
+        id: 'smart-account',
         route: Routes.ListSmartAccount,
         text: t('smart_account'),
         data: { unitId: unit.id, unit },

package/src/screens/Unit/SelectAddress.js

@@ -257,6 +257,7 @@ const SelectAddress = memo(({ route }) => {
         onPressSecondary={goBack}
         typeMain="primaryText"
         typeSecondary="primaryText"
+        accessibilityLabelPrefix="LOCATION"
       />
       {loading && <FullLoading />}
     </View>

package/src/screens/Unit/components/MyUnitDevice/index.js

@@ -1,7 +1,7 @@
 import React, { useState, useCallback } from 'react';
 import { StyleSheet, View, TouchableOpacity } from 'react-native';
 import { useNavigation } from '@react-navigation/native';
-import { useHomeAssistantDeviceConnected } from '../../../../hooks/Common';
+import { useHomeAssistantDeviceConnected } from '../../../../hooks/IoT';
 
 import ItemQuickAction from '../../../../commons/Action/ItemQuickAction';
 import Text from '../../../../commons/Text';

package/src/screens/Unit/hook/useUnitConnectRemoteDevices.js

@@ -1,8 +1,8 @@
 import { useEffect, useCallback, useContext } from 'react';
 import { SCContext } from '../../../context';
 import { Action } from '../../../context/actionType';
-import { scanBluetoothDevices } from '../../../iot/RemoteControl/Bluetooth';
 import { lgThinqConnect } from '../../../iot/RemoteControl/LG';
+import { useBluetoothConnection } from '../../../hooks/IoT';
 import { useHomeAssistantConnection } from '../../../hooks/IoT';
 import { useSCContextSelector } from '../../../context';
 
@@ -10,6 +10,9 @@ export const useUnitConnectRemoteDevices = (unit) => {
   const isNetworkConnected = useSCContextSelector(
     (state) => state.app.isNetworkConnected
   );
+  const isBluetoothEnabled = useSCContextSelector((state) => {
+    return state.app.isBluetoothEnabled;
+  });
   const lqthinqUnitConnected = useSCContextSelector(
     (state) => state.iot.lgthinq.unitConnected
   );
@@ -17,6 +20,8 @@ export const useUnitConnectRemoteDevices = (unit) => {
 
   const { connectHomeAssistant } = useHomeAssistantConnection();
 
+  const { bluetoothScanDevices } = useBluetoothConnection();
+
   let lgThinqConnected = false;
 
   const onLgThinqConnected = useCallback(() => {
@@ -37,16 +42,14 @@ export const useUnitConnectRemoteDevices = (unit) => {
   );
 
   useEffect(() => {
-    if (unit?.remote_control_options?.bluetooth) {
-      scanBluetoothDevices(unit.remote_control_options.bluetooth);
+    if (unit?.remote_control_options?.bluetooth && isBluetoothEnabled) {
+      bluetoothScanDevices(unit.remote_control_options.bluetooth);
     }
-  }, [unit]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [unit, isBluetoothEnabled]);
 
   useEffect(() => {
-    if (
-      unit?.remote_control_options?.googlehome?.length &&
-      isNetworkConnected
-    ) {
+    if (unit?.remote_control_options?.googlehome && isNetworkConnected) {
       (async () => {
         await connectHomeAssistant(unit.remote_control_options.googlehome);
       })();

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

@@ -30,7 +30,7 @@ jest.mock('@react-navigation/native', () => {
     useNavigation: () => ({
       navigate: mockedNavigate,
     }),
-    useFocusEffect: jest.fn(),
+    useIsFocused: () => true,
   };
 });
 

package/src/screens/UnitSummary/components/RunningDevices/__test__/index.test.js

@@ -19,7 +19,7 @@ jest.mock('@react-navigation/native', () => {
     useNavigation: () => ({
       navigate: mockedNavigate,
     }),
-    useFocusEffect: jest.fn(),
+    useIsFocused: () => true,
   };
 });
 

package/src/screens/UnitSummary/components/RunningDevices/index.js

@@ -1,27 +1,13 @@
-import React, { memo, useEffect } from 'react';
+import React, { memo } from 'react';
 import { StyleSheet, View } from 'react-native';
 import ItemDevice from '../../../../commons/Device/ItemDevice';
-import { scanBluetoothDevices } from '../../../../iot/RemoteControl/Bluetooth';
-import { useHomeAssistantConnection } from '../../../../hooks/IoT';
 import { useDevicesStatus } from '../../../../hooks/Common';
+import { useUnitConnectRemoteDevices } from '../../../Unit/hook/useUnitConnectRemoteDevices';
 
 const RunningDevices = memo(({ unit, summaryDetail }) => {
   const { devices } = summaryDetail;
 
-  const { connectHomeAssistant } = useHomeAssistantConnection();
-
-  useEffect(() => {
-    if (unit.remote_control_options) {
-      if (unit.remote_control_options.bluetooth) {
-        scanBluetoothDevices(unit.remote_control_options.bluetooth);
-      }
-      if (unit.remote_control_options.googlehome) {
-        (async () =>
-          await connectHomeAssistant(unit.remote_control_options.googlehome))();
-      }
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [unit]);
+  useUnitConnectRemoteDevices(unit);
 
   useDevicesStatus(unit, devices);