@eohjsc/react-native-smart-city 0.3.5 → 0.3.6

package/package.json

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

package/src/commons/ActionGroup/NumberUpDownActionTemplate.js

@@ -32,7 +32,7 @@ const NumberUpDownActionTemplate = ({ actionGroup, doAction, sensor }) => {
     if (
       !!config &&
       sensor?.is_managed_by_backend &&
-      sensor.device_type !== 'GOOGLE_HOME'
+      sensor.device_type !== DEVICE_TYPE.GOOGLE_HOME
     ) {
       watchMultiConfigs([config]);
     }
@@ -53,12 +53,16 @@ const NumberUpDownActionTemplate = ({ actionGroup, doAction, sensor }) => {
 
   const doActionAndWatchConfig = useCallback(
     async (actionData, actionValue, actionName) => {
-      const data = { temperature: actionValue };
-      if (allow_config_store_value && config) {
-        data.config_id = config;
-        data.value = actionValue;
+      let data = actionValue;
+      if (sensor.device_type !== DEVICE_TYPE.GOOGLE_HOME) {
+        data = { temperature: actionValue };
+        if (allow_config_store_value && config) {
+          data.config_id = config;
+          data.value = actionValue;
+        }
+        data = JSON.stringify(data);
       }
-      await doAction(actionData, JSON.stringify(data), actionName);
+      await doAction(actionData, data, actionName);
       if (!sensor?.is_managed_by_backend) {
         return;
       }
@@ -67,7 +71,7 @@ const NumberUpDownActionTemplate = ({ actionGroup, doAction, sensor }) => {
       }
 
       config &&
-        sensor.device_type !== 'GOOGLE_HOME' &&
+        sensor.device_type !== DEVICE_TYPE.GOOGLE_HOME &&
         watchMultiConfigs([config]);
     },
     [

package/src/commons/ActionGroup/OptionsDropdownActionTemplate.js

@@ -9,7 +9,7 @@ import { useDropdownAction } from './hooks/useDropdownAction';
 import { useConfigGlobalState } from '../../iot/states';
 import styles from './OptionsDropdownActionTemplateStyle';
 import { watchMultiConfigs } from '../../iot/Monitor';
-import { TESTID } from '../../configs/Constants';
+import { DEVICE_TYPE, TESTID } from '../../configs/Constants';
 import IconComponent from '../../commons/IconComponent';
 import { useTranslations } from '../../hooks/Common/useTranslations';
 import SvgDoorState from '../../../assets/images/Device/door-state.svg';
@@ -61,14 +61,16 @@ const OptionsDropdownActionTemplate = ({ actionGroup, doAction, sensor }) => {
     const value = getOptionValue(newOption);
     let actionName = `${sensor?.name} ${title?.toLowerCase()} ${value}`;
     actionName = actionName.replace(/\s+/g, ' ').trim();
-    doAction(
-      action_data,
-      JSON.stringify({ level: value, key_code: newOption?.value_int }),
-      actionName
-    );
+
+    let data = JSON.stringify({ level: value, key_code: newOption?.value_int });
+    if (sensor.device_type === DEVICE_TYPE.GOOGLE_HOME) {
+      data = value;
+    }
+
+    doAction(action_data, data, actionName);
     if (sensor?.is_managed_by_backend) {
       configuration.config &&
-        sensor.device_type !== 'GOOGLE_HOME' &&
+        sensor.device_type !== DEVICE_TYPE.GOOGLE_HOME &&
         watchMultiConfigs([configuration.config]);
     }
     hideAlertAction();

package/src/commons/ActionGroup/__test__/NumberUpDownTemplate.test.js

@@ -328,4 +328,44 @@ describe('Test NumberUpDownActionTemplate', () => {
     const text = instance.findAllByType(ActivityIndicator);
     expect(text).toHaveLength(1);
   });
+  test('action up sensor device type is GOOGLE_HOME', async () => {
+    const mockDoAction = jest.fn();
+    await act(async () => {
+      wrapper = await create(
+        <NumberUpDownActionTemplate
+          actionGroup={actionGroup}
+          doAction={mockDoAction}
+          sensor={{
+            is_managed_by_backend: true,
+            device_type: DEVICE_TYPE.GOOGLE_HOME,
+            name: 'Device',
+          }}
+        />
+      );
+    });
+    const instance = wrapper.root;
+    const touchs = instance.find(
+      (el) =>
+        el.props.testID === TESTID.NUMBER_ACTION_UP &&
+        el.type === TouchableOpacity
+    );
+
+    await act(async () => {
+      await touchs.props.onPress();
+    });
+    expect(mockDoAction).toBeCalledWith(
+      {
+        color: '#00979D',
+        command_prefer_over_bluetooth: true,
+        command_prefer_over_googlehome: false,
+        command_prefer_over_internet: false,
+        googlehome_actions: [],
+        icon: 'caret-up',
+        id: 20,
+        key: '5ed1d4dc-a905-47cd-b0c9-f979644bd21a',
+      },
+      26,
+      'Device temp up'
+    );
+  });
 });

package/src/commons/ActionGroup/__test__/OptionsDropdownTemplate.test.js

@@ -5,7 +5,7 @@ import { act, create } from 'react-test-renderer';
 import Text from '../../../commons/Text';
 import { watchMultiConfigs } from '../../../iot/Monitor';
 import { AlertAction, RadioCircle } from '../../../commons';
-import { TESTID } from '../../../configs/Constants';
+import { DEVICE_TYPE, TESTID } from '../../../configs/Constants';
 import { getTranslate } from '../../../utils/I18n';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
@@ -246,4 +246,60 @@ describe('Test OptionsDropdownActionTemplate', () => {
       getTranslate('en', 'not_available')
     );
   });
+  test('doAction sensor device type is GOOGLE_HOME', async () => {
+    actionGroup.configuration.options[0].value_text = 'level-1';
+    sensor.device_type = DEVICE_TYPE.GOOGLE_HOME;
+    const mockDoAction = jest.fn();
+    await act(async () => {
+      wrapper = await create(wrapComponent(actionGroup, mockDoAction, sensor));
+    });
+    const instance = wrapper.root;
+
+    const touchs = instance.findAllByType(TouchableOpacity);
+    expect(touchs).toHaveLength(5);
+    const showListOption = touchs[0];
+
+    const texts = instance.findAllByType(Text);
+    expect(texts[1].props.children).toEqual('Level2');
+
+    const radioCircles = instance.findAllByType(RadioCircle);
+    expect(radioCircles[0].props.active).toBeFalsy();
+    expect(radioCircles[1].props.active).toBeTruthy();
+
+    const listChoosingOption = instance.findAll(
+      (el) =>
+        el.props.testID === TESTID.OPTIONS_DROPDOWN_ACTION_CHOOSING_ITEM &&
+        el.type === TouchableOpacity
+    );
+    expect(listChoosingOption).toHaveLength(2);
+
+    const alertAction = instance.findByType(AlertAction);
+    expect(alertAction.props.visible).toBeFalsy();
+
+    // show option
+    await act(async () => {
+      await showListOption.props.onPress();
+    });
+    expect(alertAction.props.visible).toBeTruthy();
+
+    // Choosed Level1 option
+    await act(async () => {
+      await listChoosingOption[0].props.onPress();
+    });
+
+    expect(radioCircles[0].props.active).toBeTruthy();
+    expect(radioCircles[1].props.active).toBeFalsy();
+
+    // doAction then update selectedOption
+    await act(async () => {
+      await alertAction.props.rightButtonClick();
+    });
+    expect(alertAction.props.visible).toBeFalsy();
+
+    expect(mockDoAction).toHaveBeenCalledWith(
+      action_data,
+      'level-1',
+      'Sensor name fan speed level-1'
+    ); // doAction with text instead of int
+  });
 });

package/src/commons/ConnectingProcess/index.js

@@ -81,8 +81,8 @@ const ConnectingProcess = ({ route }) => {
           }
         );
         if (success) {
-          setSensor({ name: gateway?.model });
-          setNewName(gateway?.model);
+          setSensor(data);
+          setNewName(data?.name || gateway?.model);
         } else {
           ToastBottomHelper.error(JSON.stringify(data));
           goBack();

package/src/configs/Constants.js

@@ -75,6 +75,7 @@ export const DEVICE_TYPE = {
   LG_THINQ: 'LG_THINQ',
   HANET: 'HANET',
   ZIGBEE: 'ZIGBEE',
+  GOOGLE_HOME: 'GOOGLE_HOME',
 };
 
 const marginItem = 12;

package/src/screens/AddNewGateway/PlugAndPlay/GatewayWifiList.js

@@ -28,8 +28,6 @@ import WifiManager from 'react-native-wifi-reborn';
 import { useNavigation } from '@react-navigation/native';
 import { TESTID } from '../../../configs/Constants';
 
-const isIos = Platform.OS === 'ios';
-
 const GatewayWifiList = memo(({ route }) => {
   const {
     list_wifi,
@@ -72,41 +70,46 @@ const GatewayWifiList = memo(({ route }) => {
       if (Object.prototype.hasOwnProperty.call(data, 'gateway')) {
         const checkWifiInterval = setInterval(() => {
           // eslint-disable-next-line promise/prefer-await-to-then
-          WifiManager.getCurrentWifiSSID().then((ssid) => {
-            if (ssid !== wifi_ssid) {
-              const IsRobot = devicePrefixName === 'ROBOT';
-              if (IsRobot) {
-                setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
-                navigate(Routes.AddDeviceStack, {
-                  screen: Routes.AddCommonSelectSubUnit,
-                  params: {
-                    scan_sensor_data: scan_sensor_data,
-                    addType: 'AddDeviceNewFlow',
-                    gateway: data?.gateway,
-                    unit_id: unit_id,
-                    devicePrefixName: devicePrefixName,
-                    wifi_ssid: wifi_ssid,
-                    wifi_pass: wifi_pass,
-                  },
-                });
-                clearInterval(checkWifiInterval);
-              } else {
-                setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
-                navigate(Routes.AddDeviceStack, {
-                  screen: Routes.ConnectingProcess,
-                  params: {
-                    unit_id: unit_id,
-                    unit_name: unit_name,
-                    scan_sensor_data: scan_sensor_data,
-                    gateway: data?.gateway,
-                    devicePrefixName: devicePrefixName,
-                    chip_id: chip_id,
-                  },
-                });
-                clearInterval(checkWifiInterval);
+          WifiManager.getCurrentWifiSSID().then(
+            (ssid) => {
+              if (ssid !== wifi_ssid) {
+                const IsRobot = devicePrefixName === 'ROBOT';
+                if (IsRobot) {
+                  setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+                  navigate(Routes.AddDeviceStack, {
+                    screen: Routes.AddCommonSelectSubUnit,
+                    params: {
+                      scan_sensor_data: scan_sensor_data,
+                      addType: 'AddDeviceNewFlow',
+                      gateway: data?.gateway,
+                      unit_id: unit_id,
+                      devicePrefixName: devicePrefixName,
+                      wifi_ssid: wifi_ssid,
+                      wifi_pass: wifi_pass,
+                    },
+                  });
+                  clearInterval(checkWifiInterval);
+                } else {
+                  setAction(Action.IS_CONNECT_WIFI_GATEWAY, false);
+                  navigate(Routes.AddDeviceStack, {
+                    screen: Routes.ConnectingProcess,
+                    params: {
+                      unit_id: unit_id,
+                      unit_name: unit_name,
+                      scan_sensor_data: scan_sensor_data,
+                      gateway: data?.gateway,
+                      devicePrefixName: devicePrefixName,
+                      chip_id: chip_id,
+                    },
+                  });
+                  clearInterval(checkWifiInterval);
+                }
               }
+            },
+            () => {
+              ToastBottomHelper.error('Cannot get current SSID!');
             }
-          });
+          );
         }, 3000);
       }
     },
@@ -151,7 +154,7 @@ const GatewayWifiList = memo(({ route }) => {
 
   const connectWifi = useCallback(async () => {
     if (!isConnectWifiGateway) {
-      if (isIos) {
+      if (Platform.OS === 'ios') {
         sendConnect(0);
         setAction(Action.IS_CONNECT_WIFI_GATEWAY, true);
         setIsSendWifi(true);

package/src/screens/AddNewGateway/PlugAndPlay/__test__/GatewayWifiList.test.js

@@ -1,25 +1,32 @@
 import React from 'react';
 import { act, create } from 'react-test-renderer';
 import GatewayWifiList from '../GatewayWifiList';
-import { Text, ScrollView, TouchableOpacity } from 'react-native';
+import { Text, ScrollView, TouchableOpacity, Platform } from 'react-native';
 import { getTranslate } from '../../../../utils/I18n';
 import { SCProvider } from '../../../../context';
 import { mockSCStore } from '../../../../context/mockStore';
 import TextInputPassword from '../../../../commons/Form/TextInputPassword';
 import { TESTID } from '../../../../configs/Constants';
+import WifiManager from 'react-native-wifi-reborn';
+import { useNavigation } from '@react-navigation/native';
+import Routes from '../../../../utils/Route';
 
-const wrapComponent = (route) => (
-  <SCProvider initState={mockSCStore({})}>
+const wrapComponent = (route, state = {}) => (
+  <SCProvider initState={{ ...mockSCStore({}), ...state }}>
     <GatewayWifiList route={route} />
   </SCProvider>
 );
 
 describe('Test GatewayWifiList', () => {
   let tree;
+  const socket = {
+    on: jest.fn(),
+    send: jest.fn(),
+  };
   let route = {
     params: {
       list_wifi: [{ ssid: 'eoh@io' }, { ssid: 'eoh@ras.io' }],
-      socket: { send: jest.fn() },
+      socket: socket,
     },
   };
 
@@ -33,6 +40,7 @@ describe('Test GatewayWifiList', () => {
     expect(texts[1].props.children).toEqual(getTranslate('en', 'set_network'));
     expect(texts[3].props.children).toEqual('eoh@io');
   });
+
   test('onPress wifi', async () => {
     await act(async () => {
       tree = await create(wrapComponent(route));
@@ -46,6 +54,7 @@ describe('Test GatewayWifiList', () => {
       await touchableOpacity[1].props.onPress();
     });
   });
+
   test('onChange TextInputPassword', async () => {
     await act(async () => {
       tree = await create(wrapComponent(route));
@@ -60,15 +69,60 @@ describe('Test GatewayWifiList', () => {
     const ButtonPopup = instance.find(
       (el) => el.props.testID === TESTID.GATEWAY_WIFI_LIST.BUTTON_POPUP
     );
-    await act(() => {
-      ButtonPopup.props.onPressMain();
+    await act(async () => {
+      await ButtonPopup.props.onPressMain();
     });
-    await act(() => {
-      ButtonPopup.props.onPressSecondary();
+    await act(async () => {
+      await ButtonPopup.props.onPressSecondary();
     });
-    await act(() => {
-      ButtonPopup.props.onClose();
+    await act(async () => {
+      await ButtonPopup.props.onClose();
     });
     expect(ButtonPopup).toBeDefined();
   });
+
+  test('on device is connected to wifi and mobile re-connect to internet', async () => {
+    jest.useFakeTimers();
+    Platform.OS = 'android';
+
+    await act(async () => {
+      tree = await create(wrapComponent(route, {}));
+    });
+
+    const instance = tree.root;
+    const ButtonPopup = instance.find(
+      (el) => el.props.testID === TESTID.GATEWAY_WIFI_LIST.BUTTON_POPUP
+    );
+    await act(async () => {
+      await ButtonPopup.props.onPressMain();
+    });
+    expect(socket.on).toBeCalled();
+    expect(socket.send).toBeCalled();
+
+    const mockWifiThen = jest.fn();
+    WifiManager.getCurrentWifiSSID.mockImplementation(() => ({
+      then: mockWifiThen,
+    }));
+
+    // receive message
+    await act(async () => {
+      await socket.on.mock.calls[0][1](
+        JSON.stringify({
+          gateway: true,
+        })
+      );
+    });
+    jest.runOnlyPendingTimers();
+
+    expect(WifiManager.getCurrentWifiSSID).toBeCalled();
+    expect(mockWifiThen).toBeCalled();
+
+    // get ssid success
+    act(() => {
+      mockWifiThen.mock.calls[0][0]('new-ssid');
+    });
+    const { navigate } = useNavigation();
+    expect(navigate).toBeCalled();
+    expect(navigate.mock.calls[0][0]).toEqual(Routes.AddDeviceStack);
+  });
 });