@eohjsc/react-native-smart-city 0.3.7 → 0.3.10

package/src/context/reducer.ts

@@ -10,6 +10,7 @@ import {
   UnitType,
   AutomateType,
   AppType,
+  IoTType,
 } from './actionType';
 import { uniq } from 'lodash';
 
@@ -22,6 +23,7 @@ export type ContextData = {
   unit: UnitType;
   automate: AutomateType;
   app: AppType;
+  iot: IoTType;
 };
 
 export type Action = {
@@ -56,6 +58,13 @@ export const initialState = {
     isNetworkConnected: false,
     camera_opened: [],
   },
+  iot: {
+    googlehome: {
+      isFirstTimeConnect: true,
+      isConnecting: false,
+      connections: {},
+    },
+  },
 };
 
 export const reducer = (currentState: ContextData, action: Action) => {
@@ -88,6 +97,7 @@ export const reducer = (currentState: ContextData, action: Action) => {
       }
 
     case Action.LIST_ACTION:
+      // eslint-disable-next-line no-case-declarations
       let newListAction = [...currentState.listAction];
 
       if (Object.keys(payload).length === 0) {
@@ -151,7 +161,9 @@ export const reducer = (currentState: ContextData, action: Action) => {
     }
 
     case Action.CAMERA_STATUS_CHANGE:
+      // eslint-disable-next-line no-case-declarations
       const { id, status } = payload;
+      // eslint-disable-next-line no-case-declarations
       const arrCameraTemp = currentState.app.camera_opened || [];
       if (status) {
         if (arrCameraTemp.length >= 4) {
@@ -205,7 +217,7 @@ export const reducer = (currentState: ContextData, action: Action) => {
         unit: {
           ...currentState.unit,
           favoriteDeviceIds: currentState.unit.favoriteDeviceIds.filter(
-            (id) => id !== payload
+            (deviceId) => deviceId !== payload
           ),
         },
       };
@@ -234,11 +246,54 @@ export const reducer = (currentState: ContextData, action: Action) => {
         automate: {
           ...currentState.automate,
           starredScriptIds: currentState.automate.starredScriptIds.filter(
-            (id) => id !== payload
+            (scriptId) => scriptId !== payload
           ),
         },
       };
 
+    case Action.SET_GOOGLE_HOME_CONNECTIONS:
+      return {
+        ...currentState,
+        iot: {
+          ...currentState.iot,
+          googlehome: {
+            ...currentState.iot.googlehome,
+            isFirstTimeConnect: false,
+            isConnecting: false,
+            connections: payload,
+          },
+        },
+      };
+    case Action.CHANGE_GOOGLE_HOME_CONN_STATE:
+      return {
+        ...currentState,
+        iot: {
+          ...currentState.iot,
+          googlehome: {
+            ...currentState.iot.googlehome,
+            isFirstTimeConnect: false,
+            isConnecting: false,
+            connections: {
+              ...currentState.iot.googlehome.connections,
+              [payload.option.chip_id]: payload.data,
+            },
+          },
+        },
+      };
+    case Action.CONNECTING_GOOGLE_HOME:
+      return {
+        ...currentState,
+        iot: {
+          ...currentState.iot,
+          googlehome: {
+            ...currentState.iot.googlehome,
+            isConnecting: currentState.iot.googlehome.isFirstTimeConnect
+              ? true
+              : false,
+          },
+        },
+      };
+
     default:
       return currentState;
   }

package/src/hooks/Common/index.js

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

package/src/hooks/Common/useGGHomeDeviceConnected.js

@@ -0,0 +1,16 @@
+import { useSCContextSelector } from '../../context';
+
+const useGGHomeDeviceConnected = (device) => {
+  const { connections, isConnecting } = useSCContextSelector(
+    (state) => state.iot.googlehome
+  );
+
+  const isConnected =
+    !!device?.chip_id &&
+    device.chip_id in connections &&
+    !!connections[device.chip_id];
+
+  return { isConnected, isConnecting };
+};
+
+export default useGGHomeDeviceConnected;

package/src/hooks/Common/useGetIdUser.js

@@ -1,9 +1,5 @@
 import { useSCContextSelector } from '../../context';
 
 export const useGetIdUser = () => {
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  const idUser = useSCContextSelector(
-    (state) => state?.auth?.account?.user?.id
-  );
-  return idUser;
+  return useSCContextSelector((state) => state?.auth?.account?.user?.id);
 };

package/src/hooks/Common/useSensorsStatus.js

@@ -12,14 +12,14 @@ const useSensorsStatus = (unit, sensors) => {
 
   // eslint-disable-next-line react-hooks/exhaustive-deps
   const getSensorsStatus = useCallback(
-    throttle(async (unit, sensors) => {
+    throttle(async (_unit, _sensors) => {
       const params = new URLSearchParams();
-      if (sensors?.length > 0) {
-        sensors.forEach((sensor) => {
+      if (_sensors?.length > 0) {
+        _sensors.forEach((sensor) => {
           params.append('sensors', sensor.id);
         });
         const { success, data, resp_status } = await axiosGet(
-          API.UNIT.SENSORS_STATUS(unit.id),
+          API.UNIT.SENSORS_STATUS(_unit.id),
           {
             params: params,
           }

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

@@ -0,0 +1,199 @@
+import React from 'react';
+import { act, renderHook } from '@testing-library/react-hooks';
+import { createConnection, getStates } from 'home-assistant-js-websocket';
+import MockAdapter from 'axios-mock-adapter';
+import api from '../../../utils/Apis/axios';
+import { useGGHomeConnection } from '../index';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+import { Action } from '../../../context/actionType';
+import { API } from '../../../configs';
+
+const mock = new MockAdapter(api.axiosInstance);
+
+jest.mock('home-assistant-js-websocket', () => {
+  return {
+    Auth: jest.fn(),
+    createConnection: jest.fn(),
+    getStates: jest.fn(),
+  };
+});
+
+getStates.mockImplementation(() => []);
+
+const connection = {
+  subscribeEvents: jest.fn(),
+  addEventListener: jest.fn(),
+  sendMessagePromise: jest.fn(),
+  close: jest.fn(),
+};
+
+const mockedSetAction = jest.fn();
+
+const wrapper = ({ children }) => <SCProvider>{children}</SCProvider>;
+
+const mockUseContext = jest.fn().mockImplementation(() => ({
+  stateData: mockSCStore({}),
+  setAction: mockedSetAction,
+}));
+
+React.useContext = mockUseContext;
+
+describe('Test useGGHomeConnection', () => {
+  let options;
+
+  beforeEach(() => {
+    createConnection.mockClear();
+    mockedSetAction.mockClear();
+    options = [
+      {
+        auth: {},
+        chip_id: 1,
+        text_maps: {
+          here: 10,
+        },
+        config_maps: [
+          {
+            entity_id: 'group.sensor',
+            config_id: 1,
+            value_type: 'boolean',
+            attribute_maps: [
+              {
+                config_id: 2,
+                attribute_name: 'battery',
+                value_type: 'int',
+              },
+              {
+                config_id: 3,
+                attribute_name: 'name',
+                value_type: 'text',
+              },
+              {
+                config_id: 4,
+                attribute_name: 'height',
+                value_type: 'number',
+              },
+            ],
+          },
+        ],
+      },
+      {
+        auth: {},
+        chip_id: 2,
+        text_maps: {
+          here: 10,
+        },
+        config_maps: [
+          {
+            entity_id: 'group.sensor',
+            config_id: 1,
+            value_type: 'boolean',
+            attribute_maps: [
+              {
+                config_id: 2,
+                attribute_name: 'battery',
+                value_type: 'int',
+              },
+              {
+                config_id: 3,
+                attribute_name: 'name',
+                value_type: 'text',
+              },
+              {
+                config_id: 4,
+                attribute_name: 'height',
+                value_type: 'number',
+              },
+            ],
+          },
+        ],
+      },
+    ];
+  });
+
+  it('test connectGoogleHome all connected', async () => {
+    let conns = {};
+    options.forEach((option) => {
+      conns[option.chip_id] = connection;
+      createConnection.mockImplementationOnce(() => connection);
+    });
+    const { result } = renderHook(() => useGGHomeConnection(), {
+      wrapper,
+    });
+
+    await act(async () => {
+      await result.current.connectGoogleHome(options);
+    });
+    expect(mockedSetAction).toBeCalledWith(
+      Action.SET_GOOGLE_HOME_CONNECTIONS,
+      conns
+    );
+  });
+
+  it('test connectGoogleHome have chip disconnected', async () => {
+    let conns = {};
+    conns[options[0].chip_id] = connection;
+    conns[options[1].chip_id] = 0;
+    createConnection.mockImplementationOnce(() => connection);
+    createConnection.mockImplementationOnce(async () => {
+      throw new Error();
+    });
+    const { result } = renderHook(() => useGGHomeConnection(), {
+      wrapper,
+    });
+
+    await act(async () => {
+      await result.current.connectGoogleHome(options);
+    });
+    expect(mockedSetAction).toBeCalledWith(
+      Action.SET_GOOGLE_HOME_CONNECTIONS,
+      conns
+    );
+  });
+
+  it('test connectGooleHome all chip disconnected', async () => {
+    let conns = {};
+    options.forEach((option) => {
+      conns[option.chip_id] = 0;
+      createConnection.mockImplementationOnce(async () => {
+        throw new Error();
+      });
+    });
+    const { result } = renderHook(() => useGGHomeConnection(), {
+      wrapper,
+    });
+
+    mock.onPost(API.GOOGLE_HOME.CHECK_SEND_EMAIL()).reply(200);
+    await act(async () => {
+      await result.current.connectGoogleHome(options);
+    });
+    expect(mockedSetAction).toBeCalledTimes(3);
+    expect(mockedSetAction).toBeCalledWith(Action.CONNECTING_GOOGLE_HOME);
+    expect(mockedSetAction).toBeCalledWith(
+      Action.SET_GOOGLE_HOME_CONNECTIONS,
+      conns
+    );
+    expect(mockedSetAction).toBeCalledWith(Action.LIST_DEVICE_TYPES, {
+      chipId: options[0].chip_id,
+      sentEmail: true,
+    });
+  });
+
+  it('test disconnectGoogleHome', async () => {
+    let conns = {};
+    conns[options[0].chip_id] = connection;
+    conns[options[1].chip_id] = 0;
+
+    const { result } = renderHook(() => useGGHomeConnection(), {
+      wrapper,
+    });
+
+    await act(async () => {
+      await result.current.disconnectGoogleHome(conns, options);
+    });
+    expect(mockedSetAction).toBeCalledWith(
+      Action.SET_GOOGLE_HOME_CONNECTIONS,
+      {}
+    );
+  });
+});

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

@@ -0,0 +1,198 @@
+import React from 'react';
+import { act, renderHook } from '@testing-library/react-hooks';
+import { useRemoteControl } from '../index';
+import {
+  sendCommandOverBluetooth,
+  SEND_COMMAND_OVER_BLUETOOTH_FAIL,
+} from '../../../iot/RemoteControl/Bluetooth';
+import { sendCommandOverGoogleHome } from '../../../iot/RemoteControl/GoogleHome';
+import { sendCommandOverInternet } from '../../../iot/RemoteControl/Internet';
+import { sendCommandOverLGThinq } from '../../../iot/RemoteControl/LG';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+
+jest.mock('../../../iot/RemoteControl/Bluetooth');
+jest.mock('../../../iot/RemoteControl/GoogleHome');
+jest.mock('../../../iot/RemoteControl/Internet');
+jest.mock('../../../iot/RemoteControl/LG');
+
+const mockedSetAction = jest.fn();
+
+const wrapper = ({ children }) => <SCProvider>{children}</SCProvider>;
+
+const mockUseContext = jest.fn().mockImplementation(() => ({
+  stateData: mockSCStore({}),
+  setAction: mockedSetAction,
+}));
+
+React.useContext = mockUseContext;
+
+describe('Test useRemoteControl', () => {
+  let sensor, action, data, userId, actionName;
+
+  beforeEach(() => {
+    sendCommandOverBluetooth.mockClear();
+    sendCommandOverGoogleHome.mockClear();
+    sendCommandOverInternet.mockClear();
+    sendCommandOverLGThinq.mockClear();
+
+    sensor = {
+      id: 1,
+    };
+    action = {
+      color: '#00979D',
+      command_prefer_over_bluetooth: true,
+      command_prefer_over_googlehome: false,
+      command_prefer_over_internet: false,
+      googlehome_actions: [],
+      icon: 'caret-up',
+      id: 1,
+      key: '2b949045-8e03-4c07-a855-7794ade2e69c',
+    };
+    data = null;
+    userId = 1;
+    actionName = 'action name';
+  });
+
+  it('test send remote command action null', async () => {
+    action = null;
+    const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
+      wrapper,
+    });
+    act(() => {
+      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+    });
+    expect(sendCommandOverInternet).not.toBeCalled();
+    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverLGThinq).not.toBeCalled();
+    expect(sendCommandOverBluetooth).not.toBeCalled();
+  });
+
+  it('test send remote command via bluetooth success', async () => {
+    const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
+      wrapper,
+    });
+
+    sendCommandOverBluetooth.mockImplementation(async () => true);
+    act(() => {
+      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+    });
+    expect(sendCommandOverBluetooth).toBeCalledWith(
+      sensor,
+      action,
+      data,
+      userId
+    );
+    expect(sendCommandOverInternet).not.toBeCalled();
+    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverLGThinq).not.toBeCalled();
+  });
+
+  it('test send remote command via bluetooth failed then send via internet', async () => {
+    const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
+      wrapper,
+    });
+
+    sendCommandOverBluetooth.mockImplementation(() => {
+      throw SEND_COMMAND_OVER_BLUETOOTH_FAIL;
+    });
+    sendCommandOverInternet.mockImplementation(async () => true);
+    act(() => {
+      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+    });
+    expect(sendCommandOverBluetooth).toBeCalledWith(
+      sensor,
+      action,
+      data,
+      userId
+    );
+    expect(sendCommandOverInternet).toBeCalledWith(
+      sensor,
+      action,
+      data,
+      'bluetooth',
+      actionName
+    );
+    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverLGThinq).not.toBeCalled();
+  });
+
+  it('test send remote command via bluetooth failed throw unhandled error', async () => {
+    const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
+      wrapper,
+    });
+
+    sendCommandOverBluetooth.mockImplementation(() => {
+      throw 'ANOTHER_ERROR';
+    });
+    sendCommandOverInternet.mockImplementation(async () => true);
+    act(() => {
+      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+    });
+    expect(sendCommandOverBluetooth).toBeCalledWith(
+      sensor,
+      action,
+      data,
+      userId
+    );
+    expect(sendCommandOverInternet).not.toBeCalled();
+    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverLGThinq).not.toBeCalled();
+  });
+
+  it('test send remote command via internet', async () => {
+    action.command_prefer_over_bluetooth = false;
+    action.command_prefer_over_internet = true;
+    const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
+      wrapper,
+    });
+
+    sendCommandOverInternet.mockImplementation(async () => true);
+    act(() => {
+      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+    });
+    expect(sendCommandOverInternet).toBeCalledWith(
+      sensor,
+      action,
+      data,
+      'internet'
+    );
+    expect(sendCommandOverBluetooth).not.toBeCalled();
+    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverLGThinq).not.toBeCalled();
+  });
+
+  it('test send remote command via googlehome', async () => {
+    action.command_prefer_over_bluetooth = false;
+    action.command_prefer_over_googlehome = true;
+    const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
+      wrapper,
+    });
+
+    sendCommandOverGoogleHome.mockImplementation(async () => true);
+    act(() => {
+      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+    });
+    expect(sendCommandOverGoogleHome).toBeCalledWith({}, sensor, action, data);
+    expect(sendCommandOverBluetooth).not.toBeCalled();
+    expect(sendCommandOverInternet).not.toBeCalled();
+    expect(sendCommandOverLGThinq).not.toBeCalled();
+  });
+
+  it('test send remote command via lg', async () => {
+    action.command_prefer_over_bluetooth = false;
+    action.command_prefer_over_lg = true;
+    const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
+      wrapper,
+    });
+
+    sendCommandOverLGThinq.mockImplementation(async () => true);
+    act(() => {
+      sendRemoteCommand.current(sensor, action, data, userId, actionName);
+    });
+    expect(sendCommandOverLGThinq).toBeCalledWith(sensor, action, data);
+    expect(sendCommandOverBluetooth).not.toBeCalled();
+    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverInternet).not.toBeCalled();
+  });
+});

package/src/hooks/IoT/index.js

@@ -0,0 +1,4 @@
+import useGGHomeConnection from './useGGHomeConnection';
+import useRemoteControl from './useRemoteControl';
+
+export { useGGHomeConnection, useRemoteControl };

package/src/hooks/IoT/useGGHomeConnection.js

@@ -0,0 +1,93 @@
+import { useContext, useCallback } from 'react';
+import { SCContext, useSCContextSelector } from '../../context';
+import { Action } from '../../context/actionType';
+import {
+  googleHomeConnect,
+  googleHomeDisconnect,
+} from '../../iot/RemoteControl/GoogleHome';
+import { axiosPost } from '../../utils/Apis/axios';
+import { API } from '../../configs';
+
+const useGGHomeConnection = () => {
+  const { setAction } = useContext(SCContext);
+  const { connections } = useSCContextSelector((state) => state.iot.googlehome);
+  const { listDevice } = useSCContextSelector((state) => state);
+
+  const onEstablished = useCallback(
+    async (newConnections, options) => {
+      setAction(Action.SET_GOOGLE_HOME_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.GOOGLE_HOME.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.GOOGLE_HOME.CHECK_SEND_EMAIL(), {
+          chip_id: chipId,
+          is_connected: true,
+        });
+      }
+    },
+    [setAction, listDevice]
+  );
+
+  const onDisconnected = useCallback(
+    async (option) => {
+      setAction(Action.CHANGE_GOOGLE_HOME_CONN_STATE, { option, data: 0 });
+    },
+    [setAction]
+  );
+
+  const onReconnected = useCallback(
+    async (option, connection) => {
+      setAction(Action.CHANGE_GOOGLE_HOME_CONN_STATE, {
+        option,
+        data: connection,
+      });
+    },
+    [setAction]
+  );
+
+  const connectGoogleHome = useCallback(
+    async (options) => {
+      setAction(Action.CONNECTING_GOOGLE_HOME);
+      await googleHomeConnect(
+        connections,
+        options,
+        onEstablished,
+        onDisconnected,
+        onReconnected
+      );
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [connections, onEstablished, onDisconnected, onReconnected]
+  );
+
+  const disconnectGoogleHome = useCallback(
+    async (options) => {
+      await googleHomeDisconnect(connections, options);
+      setAction(Action.SET_GOOGLE_HOME_CONNECTIONS, {});
+    },
+    [setAction, connections]
+  );
+
+  return {
+    connectGoogleHome,
+    disconnectGoogleHome,
+  };
+};
+
+export default useGGHomeConnection;