@eohjsc/react-native-smart-city 0.2.99 → 0.3.2

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

@@ -0,0 +1,198 @@
+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(2);
+    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,91 @@
+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) => {
+      await googleHomeConnect(
+        connections,
+        options,
+        onEstablished,
+        onDisconnected,
+        onReconnected
+      );
+    },
+    [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;

package/src/hooks/IoT/useRemoteControl.js

@@ -0,0 +1,79 @@
+import { useCallback } from 'react';
+import { useSCContextSelector } from '../../context';
+import { sendCommandOverGoogleHome } from '../../iot/RemoteControl/GoogleHome';
+import { sendCommandOverInternet } from '../../iot/RemoteControl/Internet';
+import { sendCommandOverLGThinq } from '../../iot/RemoteControl/LG';
+import {
+  sendCommandOverBluetooth,
+  SEND_COMMAND_OVER_BLUETOOTH_FAIL,
+} from '../../iot/RemoteControl/Bluetooth';
+import { ToastBottomHelper } from '../../utils/Utils';
+import { t } from 'i18n-js';
+
+const useRemoteControl = () => {
+  const ggHomeConnections = useSCContextSelector(
+    (state) => state.iot.googlehome.connections
+  );
+
+  const sendRemoteCommand = useCallback(
+    async (sensor, action, data, userId, actionName) => {
+      // No action, raise not authorized
+      let result = false;
+      if (!action) {
+        ToastBottomHelper.error(
+          t('your_account_has_not_been_authorized_to_control')
+        );
+        return result;
+      }
+
+      if (action.command_prefer_over_bluetooth) {
+        try {
+          result = await sendCommandOverBluetooth(sensor, action, data, userId);
+        } catch (err) {
+          if (err === SEND_COMMAND_OVER_BLUETOOTH_FAIL) {
+            result = await sendCommandOverInternet(
+              sensor,
+              action,
+              data,
+              'bluetooth',
+              actionName
+            );
+          } else {
+            throw err;
+          }
+        }
+      }
+
+      if (
+        action.command_prefer_over_internet ||
+        action.command_prefer_over_bluetooth
+      ) {
+        result = await sendCommandOverInternet(
+          sensor,
+          action,
+          data,
+          'internet'
+        );
+      }
+
+      if (action.command_prefer_over_googlehome) {
+        result = await sendCommandOverGoogleHome(
+          ggHomeConnections,
+          sensor,
+          action,
+          data
+        );
+      }
+
+      if (action.command_prefer_over_lg) {
+        result = await sendCommandOverLGThinq(sensor, action, data);
+      }
+      return result;
+    },
+    [ggHomeConnections]
+  );
+
+  return sendRemoteCommand;
+};
+
+export default useRemoteControl;

package/src/hooks/index.js

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

package/src/hooks/useReceiveNotifications.js

@@ -3,19 +3,23 @@ import OneSignal from 'react-native-onesignal';
 
 const useReceiveNotifications = () => {
   const [dataNofitication, setDataNofitication] = useState(null);
-  const [showEmergencyPopup, setShowEmergencyPopup] = useState(false);
 
   const onReceived = useCallback((data) => {
-    const { additionalData } = data.payload;
+    const { additionalData } = data;
     setDataNofitication(additionalData);
-    setShowEmergencyPopup(!!additionalData);
   }, []);
 
   useEffect(() => {
-    OneSignal.addEventListener('received', onReceived);
+    OneSignal.setNotificationWillShowInForegroundHandler(
+      (notifReceivedEvent) => {
+        let notif = notifReceivedEvent.getNotification();
+        setTimeout(() => notifReceivedEvent.complete(notif), 0);
+        onReceived(notif);
+      }
+    );
   }, [onReceived]);
 
-  return { dataNofitication, showEmergencyPopup, setShowEmergencyPopup };
+  return { dataNofitication };
 };
 
 export default useReceiveNotifications;

package/src/iot/Monitor.js

@@ -99,8 +99,9 @@ export const realWatchMultiConfigs = async (configIds) => {
     const configValues = getConfigGlobalState('configValues');
     const newConfigValues = { ...configValues, ...data };
     setConfigGlobalState('configValues', newConfigValues);
-
-    configIds.map((id) => watchConfig(id));
+    for (const configId in data) {
+      watchConfig(configId);
+    }
   }
 };
 

package/src/iot/RemoteControl/Bluetooth.js

@@ -1,4 +1,3 @@
-/* eslint-disable promise/prefer-await-to-then */
 /* eslint-disable promise/prefer-await-to-callbacks */
 import { BLE } from '../../configs';
 import t from '../../hooks/Common/useTranslations';
@@ -82,6 +81,7 @@ const realScanBluetoothDevices = () => {
   setTimeout(() => {
     try {
       bleManager.stopDeviceScan();
+      // eslint-disable-next-line no-empty
     } catch {}
   }, 15000);
 };