@eohjsc/react-native-smart-city 0.3.30 → 0.3.33

package/src/hooks/IoT/useHomeAssistantConnection.js

@@ -0,0 +1,91 @@
+import { useContext, useCallback } from 'react';
+import { SCContext, useSCContextSelector } from '../../context';
+import { Action } from '../../context/actionType';
+import {
+  homeAssistantConnect,
+  homeAssistantDisconnect,
+} from '../../iot/RemoteControl/HomeAssistant';
+import { axiosPost } from '../../utils/Apis/axios';
+import { API } from '../../configs';
+
+const useHomeAssistantConnection = () => {
+  const { setAction } = useContext(SCContext);
+  const { connections } = useSCContextSelector(
+    (state) => state.iot.homeassistant
+  );
+  const { listDevice } = useSCContextSelector((state) => state);
+
+  const onEstablished = useCallback(
+    async (newConnections, options) => {
+      setAction(Action.SET_HOME_ASSISTANT_CONNECTIONS, newConnections);
+
+      const isConnected = options.some(
+        (option) => !!newConnections[option.chip_id]
+      );
+      let chipId = options[0].chip_id;
+      if (!isConnected) {
+        setAction(Action.LIST_DEVICE_TYPES, {
+          chipId: chipId,
+          sentEmail: true,
+        });
+        await axiosPost(API.HOME_ASSISTANT.CHECK_SEND_EMAIL(), {
+          chip_id: chipId,
+          is_connected: false,
+        });
+      } else if (isConnected && listDevice[chipId]?.sentEmail) {
+        setAction(Action.LIST_DEVICE_TYPES, {
+          chipId: chipId,
+          sentEmail: false,
+        });
+        await axiosPost(API.HOME_ASSISTANT.CHECK_SEND_EMAIL(), {
+          chip_id: chipId,
+          is_connected: true,
+        });
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [listDevice]
+  );
+
+  const onDisconnected = useCallback(async (option) => {
+    setAction(Action.CHANGE_HOME_ASSISTANT_CONN_STATE, { option, data: 0 });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const onReconnected = useCallback(async (option, connection) => {
+    setAction(Action.CHANGE_HOME_ASSISTANT_CONN_STATE, {
+      option,
+      data: connection,
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const connectHomeAssistant = useCallback(
+    async (options) => {
+      await homeAssistantConnect(
+        connections,
+        options,
+        onEstablished,
+        onDisconnected,
+        onReconnected
+      );
+    },
+    [connections, onEstablished, onDisconnected, onReconnected]
+  );
+
+  const disconnectHomeAssistant = useCallback(
+    async (options) => {
+      await homeAssistantDisconnect(connections, options);
+      setAction(Action.SET_HOME_ASSISTANT_CONNECTIONS, {});
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [connections]
+  );
+
+  return {
+    connectHomeAssistant,
+    disconnectHomeAssistant,
+  };
+};
+
+export default useHomeAssistantConnection;

package/src/hooks/IoT/useRemoteControl.js

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { useSCContextSelector } from '../../context';
-import { sendCommandOverGoogleHome } from '../../iot/RemoteControl/GoogleHome';
+import { sendCommandOverHomeAssistant } from '../../iot/RemoteControl/HomeAssistant';
 import { sendCommandOverInternet } from '../../iot/RemoteControl/Internet';
 import {
   sendCommandOverBluetooth,
@@ -10,8 +10,8 @@ import { ToastBottomHelper } from '../../utils/Utils';
 import { t } from 'i18n-js';
 
 const useRemoteControl = () => {
-  const ggHomeConnections = useSCContextSelector(
-    (state) => state.iot.googlehome.connections
+  const homeAssistantConnections = useSCContextSelector(
+    (state) => state.iot.homeassistant.connections
   );
 
   const sendRemoteCommand = useCallback(
@@ -58,8 +58,8 @@ const useRemoteControl = () => {
       }
 
       if (action.command_prefer_over_googlehome && !result) {
-        result = await sendCommandOverGoogleHome(
-          ggHomeConnections,
+        result = await sendCommandOverHomeAssistant(
+          homeAssistantConnections,
           sensor,
           action,
           data
@@ -67,7 +67,7 @@ const useRemoteControl = () => {
       }
       return result;
     },
-    [ggHomeConnections]
+    [homeAssistantConnections]
   );
 
   return sendRemoteCommand;

package/src/hooks/__test__/useInitDeepLink.test.js

@@ -0,0 +1,28 @@
+import React from 'react';
+import { renderHook } from '@testing-library/react-hooks';
+import { useInitDeepLink } from '../index';
+import { SCProvider } from '../../context';
+import { mockSCStore } from '../../context/mockStore';
+import DeepLinking from 'react-native-deep-linking';
+
+const mockedSetAction = jest.fn();
+
+const wrapper = ({ children }) => <SCProvider>{children}</SCProvider>;
+
+const mockUseContext = jest.fn().mockImplementation(() => ({
+  stateData: mockSCStore({}),
+  setAction: mockedSetAction,
+}));
+
+React.useContext = mockUseContext;
+
+jest.mock('react-native-deep-linking');
+
+describe('Test useRemoteControl', () => {
+  it('test send remote command action null', async () => {
+    renderHook(() => useInitDeepLink(), {
+      wrapper,
+    });
+    expect(DeepLinking.addScheme).toBeCalled();
+  });
+});

package/src/hooks/useReceiveNotifications.js

@@ -8,10 +8,8 @@ const useReceiveNotifications = (callBack) => {
   );
 
   useEffect(() => {
-    if (notificationData) {
-      setDataNotification(notificationData);
-      callBack && callBack();
-    }
+    notificationData && setDataNotification(notificationData);
+    notificationData && callBack && callBack();
   }, [callBack, notificationData]);
 
   return { dataNotification };

package/src/iot/RemoteControl/{GoogleHome.js → HomeAssistant.js}

@@ -115,7 +115,7 @@ async function fetchConnectionEntities(connection) {
   setConfigGlobalState('configValues', { ...configValues });
 }
 
-export const googleHomeConnect = async (
+export const homeAssistantConnect = async (
   oldConnections,
   options,
   onEstablished,
@@ -163,13 +163,13 @@ export const googleHomeConnect = async (
 
       connection.addEventListener('disconnected', async () => {
         await onDisconnected(option);
-        ToastBottomHelper.error(t('command_googlehome_lost'));
+        ToastBottomHelper.error(t('command_homeassistant_lost'));
       });
 
       connection.addEventListener('ready', async (conn, eventData) => {
         await fetchConnectionEntities(conn);
         await onReconnected(option, conn);
-        ToastBottomHelper.success(t('command_googlehome_ready'));
+        ToastBottomHelper.success(t('command_homeassistant_ready'));
       });
 
       connections[option.chip_id] = connection;
@@ -182,7 +182,7 @@ export const googleHomeConnect = async (
   return connections;
 };
 
-export const googleHomeDisconnect = async (connections, options) => {
+export const homeAssistantDisconnect = async (connections, options) => {
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
     if (option.chip_id in connections) {
@@ -219,11 +219,11 @@ async function sendCommandSingleAction(connection, ghAction, data) {
     await connection.sendMessagePromise(message);
     return true;
   } catch (err) {
-    ToastBottomHelper.error(t('command_send_fail_googlehome'));
+    ToastBottomHelper.error(t('command_send_fail_homeassistant'));
   }
 }
 
-export async function sendCommandOverGoogleHome(
+export async function sendCommandOverHomeAssistant(
   connections,
   device,
   action,
@@ -238,7 +238,7 @@ export async function sendCommandOverGoogleHome(
 
   const connection = getDeviceConnection(connections, device);
   if (!connection) {
-    ToastBottomHelper.error(t('command_send_fail_googlehome'));
+    ToastBottomHelper.error(t('command_send_fail_homeassistant'));
     return;
   }
 
@@ -260,15 +260,19 @@ export async function sendCommandOverGoogleHome(
     );
   }
 
-  if (triggerSuccess) {
-    const { success } = await axiosPost(API.DEVICE.ACTIVITY_LOG(), {
-      action_id: action.id,
-      message: 'Trigger by user action with google home',
-    });
-    if (success) {
-      ToastBottomHelper.success(t('command_send_success_googlehome'));
-    }
-    return success;
+  const { success: createLog } = await axiosPost(API.DEVICE.ACTIVITY_LOG(), {
+    action_id: action.id,
+    message: `Trigger 
+    ${triggerSuccess ? 'success' : 'fail'}
+    by user action with home assistant`,
+    action_status: triggerSuccess,
+  });
+  if (createLog && triggerSuccess) {
+    ToastBottomHelper.success(t('command_send_success_homeassistant'));
+    return true;
+  }
+  if (createLog && !triggerSuccess) {
+    ToastBottomHelper.error(t('command_send_fail_homeassistant'));
+    return false;
   }
-  return false;
 }

package/src/iot/RemoteControl/LG.js

@@ -110,7 +110,7 @@ export async function fetchDeviceStatusLG(endDevice) {
   }, 1000);
 }
 
-export const lgThinqConnect = async (options) => {
+export const lgThinqConnect = async (options, onConnected) => {
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
     for (let j = 0; j < option.lg_devices.length; j++) {
@@ -136,6 +136,7 @@ export const lgThinqConnect = async (options) => {
       await fetchDeviceStatusLG(endDevice);
     }
   }
+  onConnected && onConnected();
 };
 
 export const sendCommandOverLGThinq = async (sensor, action, data) => {

package/src/iot/RemoteControl/__test__/{GoogleHome.test.js → HomeAssistant.test.js}

@@ -2,10 +2,10 @@ import { createConnection, getStates } from 'home-assistant-js-websocket';
 import Toast from 'react-native-toast-message';
 import MockAdapter from 'axios-mock-adapter';
 import {
-  googleHomeConnect,
-  googleHomeDisconnect,
-  sendCommandOverGoogleHome,
-} from '../GoogleHome';
+  homeAssistantConnect,
+  homeAssistantDisconnect,
+  sendCommandOverHomeAssistant,
+} from '../HomeAssistant';
 import { getConfigGlobalState, setConfigGlobalState } from '../../states';
 import { API } from '../../../configs';
 import { getTranslate } from '../../../utils/I18n';
@@ -34,7 +34,7 @@ const mockReconnected = jest.fn();
 getStates.mockImplementation(() => []);
 createConnection.mockImplementation(() => connection);
 
-describe('Remote Control Google Home', () => {
+describe('Remote Control Home Assistant', () => {
   const options = [
     {
       auth: {},
@@ -92,7 +92,7 @@ describe('Remote Control Google Home', () => {
     setConfigGlobalState('configValues', {});
   });
 
-  it('Connect to google home basic will fetch entities', async () => {
+  it('Connect to Home Assistant basic will fetch entities', async () => {
     getStates.mockImplementationOnce(() => [
       {
         entity_id: 'group.sensor',
@@ -111,7 +111,7 @@ describe('Remote Control Google Home', () => {
     let configValues = getConfigGlobalState('configValues');
     expect(configValues).toEqual({});
 
-    await googleHomeConnect(
+    await homeAssistantConnect(
       {},
       options,
       mockEstablished,
@@ -158,7 +158,7 @@ describe('Remote Control Google Home', () => {
       }
     });
 
-    await googleHomeConnect(
+    await homeAssistantConnect(
       {},
       options,
       mockEstablished,
@@ -170,15 +170,15 @@ describe('Remote Control Google Home', () => {
     expect(configValues).toEqual({ 1: { value: true } });
   });
 
-  it('Connect to same google home will be skipped', async () => {
-    const connections = await googleHomeConnect(
+  it('Connect to same Home Assistant will be skipped', async () => {
+    const connections = await homeAssistantConnect(
       {},
       options,
       mockEstablished,
       mockDisconnected,
       mockReconnected
     );
-    await googleHomeConnect(
+    await homeAssistantConnect(
       connections,
       options,
       mockEstablished,
@@ -195,7 +195,7 @@ describe('Remote Control Google Home', () => {
         listener();
       }
     });
-    await googleHomeConnect(
+    await homeAssistantConnect(
       {},
       options,
       mockEstablished,
@@ -212,7 +212,7 @@ describe('Remote Control Google Home', () => {
         listener();
       }
     });
-    await googleHomeConnect(
+    await homeAssistantConnect(
       {},
       options,
       mockEstablished,
@@ -222,27 +222,27 @@ describe('Remote Control Google Home', () => {
     expect(Toast.show).toBeCalledWith({
       type: 'error',
       position: 'bottom',
-      text1: getTranslate('en', 'command_googlehome_lost'),
+      text1: getTranslate('en', 'command_homeassistant_lost'),
       visibilityTime: 1000,
     });
   });
 
-  it('Send command over google home will send message to chip', async () => {
+  it('Send command over Home Assistant will send message to chip', async () => {
     mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
-    const connections = await googleHomeConnect(
+    const connections = await homeAssistantConnect(
       {},
       options,
       mockEstablished,
       mockDisconnected,
       mockReconnected
     );
-    await sendCommandOverGoogleHome(connections, sensor, action);
+    await sendCommandOverHomeAssistant(connections, sensor, action);
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_actions[0].message
     );
   });
 
-  it('Send command over google home will send message to chip with service_data and data', async () => {
+  it('Send command over Home Assistant will send message to chip with service_data and data', async () => {
     action.googlehome_actions[0].message = {
       type: 'call_service',
       domain: 'climate',
@@ -254,21 +254,21 @@ describe('Remote Control Google Home', () => {
       id: 20,
     };
     mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
-    const connections = await googleHomeConnect(
+    const connections = await homeAssistantConnect(
       {},
       options,
       mockEstablished,
       mockDisconnected,
       mockReconnected
     );
-    await sendCommandOverGoogleHome(connections, sensor, action, 19);
+    await sendCommandOverHomeAssistant(connections, sensor, action, 19);
     action.googlehome_actions[0].message.service_data.temperature = 19;
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_actions[0].message
     );
   });
 
-  it('Send command over google home action googlehome_action one to one', async () => {
+  it('Send command over Home Assistant action googlehome_action one to one', async () => {
     action.googlehome_actions = null;
     action.googlehome_action.message = {
       type: 'call_service',
@@ -281,47 +281,47 @@ describe('Remote Control Google Home', () => {
       id: 20,
     };
     mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
-    const connections = await googleHomeConnect(
+    const connections = await homeAssistantConnect(
       {},
       options,
       mockEstablished,
       mockDisconnected,
       mockReconnected
     );
-    await sendCommandOverGoogleHome(connections, sensor, action, 19);
+    await sendCommandOverHomeAssistant(connections, sensor, action, 19);
     action.googlehome_action.message.service_data.temperature = 19;
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_action.message
     );
   });
 
-  it('Send command over google home that not connected', async () => {
-    await googleHomeConnect(
+  it('Send command over Home Assistant that not connected', async () => {
+    await homeAssistantConnect(
       {},
       options,
       mockEstablished,
       mockDisconnected,
       mockReconnected
     );
-    await sendCommandOverGoogleHome({}, { chip_id: 2 }, action);
+    await sendCommandOverHomeAssistant({}, { chip_id: 2 }, action);
     expect(connection.sendMessagePromise).not.toBeCalled();
   });
 
-  it('Send command over google home that not a google home', async () => {
-    await googleHomeConnect(
+  it('Send command over Home Assistant that not a Home Assistant', async () => {
+    await homeAssistantConnect(
       {},
       options,
       mockEstablished,
       mockDisconnected,
       mockReconnected
     );
-    await sendCommandOverGoogleHome({}, sensor, {});
+    await sendCommandOverHomeAssistant({}, sensor, {});
     expect(connection.sendMessagePromise).not.toBeCalled();
   });
 
   it('Disconnect a not connected gateway', async () => {
     connection.close.mockClear();
-    await googleHomeDisconnect({}, options);
+    await homeAssistantDisconnect({}, options);
     expect(connection.close).not.toBeCalled();
   });
 });

package/src/navigations/AddDeviceStack.js

@@ -3,12 +3,8 @@ import React, { memo } from 'react';
 
 import AddCommonSelectUnit from '../screens/AddCommon/SelectUnit';
 import AddCommonSelectSubUnit from '../screens/AddCommon/SelectSubUnit';
-import AddGatewaySelectGateway from '../screens/AddNewGateway/SelectGateway';
 import AddNewDevice from '../screens/AddNewDevice';
-import ConnectDevices from '../screens/AddNewDevice/ConnectDevices';
 import ConnectingDevices from '../screens/AddNewDevice/ConnectingDevices';
-import ConnectingProcess from '../commons/ConnectingProcess';
-import ScanSensorQR from '../screens/ScanSensorQR';
 import Route from '../utils/Route';
 import { screenOptions } from './utils';
 
@@ -30,21 +26,11 @@ export const AddDeviceStack = memo(() => {
         name={Route.AddCommonSelectSubUnit}
         component={AddCommonSelectSubUnit}
       />
-      <Stack.Screen
-        name={Route.AddGatewaySelectGateway}
-        component={AddGatewaySelectGateway}
-      />
-      <Stack.Screen
-        name={Route.ConnectingProcess}
-        component={ConnectingProcess}
-      />
       <Stack.Screen name={Route.AddNewDevice} component={AddNewDevice} />
-      <Stack.Screen name={Route.ScanSensorQR} component={ScanSensorQR} />
       <Stack.Screen
         name={Route.ConnectingDevices}
         component={ConnectingDevices}
       />
-      <Stack.Screen name={Route.ConnectDevices} component={ConnectDevices} />
     </Stack.Navigator>
   );
 });

package/src/navigations/AddGatewayStack.js

@@ -2,16 +2,22 @@ import { createStackNavigator } from '@react-navigation/stack';
 import React, { memo } from 'react';
 
 import AddNewGateway from '../screens/AddNewGateway';
-import ScanChipQR from '../screens/ScanChipQR';
 import Route from '../utils/Route';
-import ConnectedGateway from '../screens/AddNewGateway/ConnectedGateway';
-import ConnectingGateway from '../screens/AddNewGateway/ConnectingGateway';
-import SetupGatewayWifi from '../screens/AddNewGateway/SetupGatewayWifi';
-import AddCommonSelectSubUnit from '../screens/AddCommon/SelectSubUnit';
 import FirstWarning from '../screens/AddNewGateway/PlugAndPlay/FirstWarning';
-import ConnectWifiWarning from '../screens/AddNewGateway/PlugAndPlay/ConnectWifiWarning';
-import GatewayWifiList from '../screens/AddNewGateway/PlugAndPlay/GatewayWifiList';
 import { screenOptions } from './utils';
+import SelectDeviceSubUnit from '../screens/AddNewGateway/SelectDeviceSubUnit';
+import SelectDeviceType from '../screens/AddNewGateway/SelectDeviceType';
+import SelectModbusGateway from '../screens/AddNewGateway/SelectModbusGateway';
+import SelectZigbeeGateway from '../screens/AddNewGateway/SelectZigbeeGateway';
+import ConnectingZigbeeDevice from '../screens/AddNewGateway/ConnectingZigbeeDevice';
+import SelectDeviceUnit from '../screens/AddNewGateway/SelectDeviceUnit';
+import ScanModbusQR from '../screens/AddNewGateway/ScanModbusQR';
+import ConnectingModbusDevice from '../screens/AddNewGateway/ConnectingModbusDevice';
+import ScanWifiDeviceQR from '../screens/AddNewGateway/ScanWifiDeviceQR';
+import ConnectingWifiDevice from '../screens/AddNewGateway/ConnectingWifiDevice';
+import ShareWifiPassword from '../screens/AddNewGateway/ShareWifiPassword';
+import ScanGatewayQR from '../screens/AddNewGateway/ScanGatewayQR';
+import RenameNewDevices from '../screens/AddNewGateway/RenameNewDevices';
 
 const Stack = createStackNavigator();
 
@@ -23,30 +29,54 @@ export const AddGatewayStack = memo(() => {
         headerShown: false,
       }}
     >
+      <Stack.Screen name={Route.FirstWarning} component={FirstWarning} />
+      <Stack.Screen name={Route.AddNewGateway} component={AddNewGateway} />
       <Stack.Screen
-        name={Route.SetupGatewayWifi}
-        component={SetupGatewayWifi}
+        name={Route.SelectDeviceUnit}
+        component={SelectDeviceUnit}
       />
-      <Stack.Screen name={Route.AddNewGateway} component={AddNewGateway} />
       <Stack.Screen
-        name={Route.AddCommonSelectSubUnit}
-        component={AddCommonSelectSubUnit}
+        name={Route.SelectDeviceSubUnit}
+        component={SelectDeviceSubUnit}
       />
-      <Stack.Screen name={Route.ScanChipQR} component={ScanChipQR} />
       <Stack.Screen
-        name={Route.ConnectingGateway}
-        component={ConnectingGateway}
+        name={Route.SelectDeviceType}
+        component={SelectDeviceType}
       />
       <Stack.Screen
-        name={Route.ConnectedGateway}
-        component={ConnectedGateway}
+        name={Route.SelectModbusGateway}
+        component={SelectModbusGateway}
+      />
+      <Stack.Screen
+        name={Route.SelectZigbeeGateway}
+        component={SelectZigbeeGateway}
+      />
+      <Stack.Screen
+        name={Route.ConnectingZigbeeDevice}
+        component={ConnectingZigbeeDevice}
+      />
+      <Stack.Screen name={Route.ScanModbusQR} component={ScanModbusQR} />
+      <Stack.Screen
+        name={Route.ConnectingModbusDevice}
+        component={ConnectingModbusDevice}
+      />
+      <Stack.Screen
+        name={Route.ScanWifiDeviceQR}
+        component={ScanWifiDeviceQR}
+      />
+      <Stack.Screen name={Route.ScanGatewayQR} component={ScanGatewayQR} />
+      <Stack.Screen
+        name={Route.ShareWifiPassword}
+        component={ShareWifiPassword}
+      />
+      <Stack.Screen
+        name={Route.ConnectingWifiDevice}
+        component={ConnectingWifiDevice}
       />
-      <Stack.Screen name={Route.FirstWarning} component={FirstWarning} />
       <Stack.Screen
-        name={Route.ConnectWifiWarning}
-        component={ConnectWifiWarning}
+        name={Route.RenameNewDevices}
+        component={RenameNewDevices}
       />
-      <Stack.Screen name={Route.GatewayWifiList} component={GatewayWifiList} />
     </Stack.Navigator>
   );
 });