@eohjsc/react-native-smart-city 0.3.29 → 0.3.32

package/src/context/mockStore.ts

@@ -38,17 +38,26 @@ export const mockDataStore: ContextData = {
     isBluetoothEnabled: true,
     isNetworkConnected: true,
     camera_opened: [],
+    isLockWhenPickColor: false,
   },
   iot: {
-    googlehome: {
+    homeassistant: {
       connections: {},
     },
+    lgthinq: {
+      unitConnected: [],
+    },
     internet: {
       statuses: {},
     },
   },
   valueEvaluations: {},
   fetchedValueEvaluationUnits: [],
+  devMode: {
+    itemDraggingId: null,
+    isEditingTemplate: false,
+    isInEditTemplateScreen: false,
+  },
 };
 
 export const mockSCStore = (data: ContextData): ContextData => {
@@ -76,6 +85,7 @@ export const mockSCStore = (data: ContextData): ContextData => {
       isConnectWifiGateway: false,
       isBluetoothEnabled: true,
       isNetworkConnected: true,
+      isLockWhenPickColor: false,
     },
     unit: {
       favoriteDeviceIds: [
@@ -91,8 +101,8 @@ export const mockSCStore = (data: ContextData): ContextData => {
     },
     iot: {
       ...mockDataStore.iot,
-      googlehome: {
-        ...mockDataStore.iot.googlehome,
+      homeassistant: {
+        ...mockDataStore.iot.homeassistant,
         connections: {},
       },
       internet: {
@@ -104,5 +114,10 @@ export const mockSCStore = (data: ContextData): ContextData => {
       ...data.valueEvaluations,
     },
     fetchedValueEvaluationUnits: [],
+    devMode: {
+      itemDraggingId: null,
+      isEditingTemplate: false,
+      isInEditTemplateScreen: false,
+    },
   };
 };

package/src/context/reducer.ts

@@ -11,6 +11,7 @@ import {
   AutomateType,
   AppType,
   IoTType,
+  DevModeType,
 } from './actionType';
 import { uniq, reduce } from 'lodash';
 
@@ -26,6 +27,7 @@ export type ContextData = {
   iot: IoTType;
   valueEvaluations: {};
   fetchedValueEvaluationUnits: Array<number>;
+  devMode: DevModeType;
 };
 
 export type Action = {
@@ -61,17 +63,26 @@ export const initialState = {
     camera_opened: [],
     notificationData: null,
     popoverAnimating: false,
+    isLockWhenPickColor: false,
   },
   iot: {
-    googlehome: {
+    homeassistant: {
       connections: {},
     },
+    lgthinq: {
+      unitConnected: [],
+    },
     internet: {
       statuses: {},
     },
   },
   valueEvaluations: {},
   fetchedValueEvaluationUnits: [],
+  devMode: {
+    itemDraggingId: null,
+    isEditingTemplate: false,
+    isInEditTemplateScreen: false,
+  },
 };
 
 export const reducer = (currentState: ContextData, action: Action) => {
@@ -258,32 +269,44 @@ export const reducer = (currentState: ContextData, action: Action) => {
         },
       };
 
-    case Action.SET_GOOGLE_HOME_CONNECTIONS:
+    case Action.SET_HOME_ASSISTANT_CONNECTIONS:
       return {
         ...currentState,
         iot: {
           ...currentState.iot,
-          googlehome: {
-            ...currentState.iot.googlehome,
+          homeassistant: {
+            ...currentState.iot.homeassistant,
             connections: payload,
           },
         },
       };
-    case Action.CHANGE_GOOGLE_HOME_CONN_STATE:
+    case Action.CHANGE_HOME_ASSISTANT_CONN_STATE:
       return {
         ...currentState,
         iot: {
           ...currentState.iot,
-          googlehome: {
-            ...currentState.iot.googlehome,
+          homeassistant: {
+            ...currentState.iot.homeassistant,
             connections: {
-              ...currentState.iot.googlehome.connections,
+              ...currentState.iot.homeassistant.connections,
               [payload.option.chip_id]: payload.data,
             },
           },
         },
       };
 
+    case Action.SET_LG_THINQ_CONNECTED:
+      return {
+        ...currentState,
+        iot: {
+          ...currentState.iot,
+          lgthinq: {
+            ...currentState.iot.lgthinq,
+            unitConnected: [...currentState.iot.lgthinq.unitConnected, payload],
+          },
+        },
+      };
+
     case Action.SET_DEVICES_STATUS:
       // eslint-disable-next-line no-case-declarations
       let newStatuses = currentState.iot.internet.statuses;
@@ -317,7 +340,6 @@ export const reducer = (currentState: ContextData, action: Action) => {
         valueEvaluations: reduce(
           data,
           (dict, item) => {
-            // eslint-disable-next-line no-param-reassign
             dict[item.config] = item;
             return dict;
           },
@@ -351,6 +373,41 @@ export const reducer = (currentState: ContextData, action: Action) => {
           popoverAnimating: payload,
         },
       };
+    case Action.SET_LOCK_VIEW_PICK_COLOR:
+      return {
+        ...currentState,
+        app: {
+          ...currentState.app,
+          isLockWhenPickColor: payload,
+        },
+      };
+    // NOTE: DEV MODE
+    case Action.SET_WIDGET_DRAGGING:
+      return {
+        ...currentState,
+        devMode: {
+          ...currentState.devMode,
+          itemDraggingId: payload,
+        },
+      };
+
+    case Action.SET_IS_EDITING_TEMPLATE:
+      return {
+        ...currentState,
+        devMode: {
+          ...currentState.devMode,
+          isEditingTemplate: payload,
+        },
+      };
+
+    case Action.SET_IS_IN_EDIT_TEMPLATE_SCREEN:
+      return {
+        ...currentState,
+        devMode: {
+          ...currentState.devMode,
+          isInEditTemplateScreen: payload,
+        },
+      };
 
     default:
       return currentState;

package/src/hoc/withRemoteControl.js

@@ -1,3 +1,4 @@
+import React from 'react';
 import { useRemoteControl } from '../hooks/IoT';
 
 function withRemoteControl(Component) {

package/src/hooks/Common/index.js

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

package/src/hooks/Common/useDevicesStatus.js

@@ -27,7 +27,7 @@ const useDevicesStatus = (unit, devices) => {
     if (success) {
       setAction(Action.SET_DEVICES_STATUS, data);
     }
-    timeoutId = setTimeout(() => getDevicesStatus(_unit, _devices), 5000);
+    timeoutId = setTimeout(() => getDevicesStatus(_unit, _devices), 10000);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 

package/src/hooks/Common/{useGGHomeDeviceConnected.js → useHomeAssistantDeviceConnected.js}

@@ -1,8 +1,8 @@
 import { useSCContextSelector } from '../../context';
 
-const useGGHomeDeviceConnected = (device) => {
+const useHomeAssistantDeviceConnected = (device) => {
   const connections = useSCContextSelector(
-    (state) => state.iot.googlehome.connections
+    (state) => state.iot.homeassistant.connections
   );
   const isNetworkConnected = useSCContextSelector(
     (state) => state.app.isNetworkConnected
@@ -20,4 +20,4 @@ const useGGHomeDeviceConnected = (device) => {
   return { isConnected, isConnecting };
 };
 
-export default useGGHomeDeviceConnected;
+export default useHomeAssistantDeviceConnected;

package/src/hooks/Common/usePopover.js

@@ -1,14 +1,19 @@
-import { useCallback, useState, useRef } from 'react';
+import { useCallback, useState, useRef, useContext } from 'react';
+import { SCContext } from '../../context';
+import { Action } from '../../context/actionType';
 
 const usePopover = () => {
   const [showingPopover, setShowingPopover] = useState(false);
   const childRef = useRef(null);
+  const { setAction } = useContext(SCContext);
 
   const showPopoverWithRef = useCallback(
     (ref) => {
       childRef.current = ref.current;
       setShowingPopover(true);
+      setAction(Action.SET_POPOVER_ANIMATING, true);
     },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
     [childRef]
   );
 

package/src/hooks/IoT/__test__/{useGGHomeConnection.test.js → useHomeAssistantConnection.test.js}

@@ -3,7 +3,7 @@ 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 { useHomeAssistantConnection } from '../index';
 import { SCProvider } from '../../../context';
 import { mockSCStore } from '../../../context/mockStore';
 import { Action } from '../../../context/actionType';
@@ -39,7 +39,7 @@ const mockUseContext = jest.fn().mockImplementation(() => ({
 
 React.useContext = mockUseContext;
 
-describe('Test useGGHomeConnection', () => {
+describe('Test useHomeAssistantConnection', () => {
   let options;
 
   beforeEach(() => {
@@ -111,26 +111,26 @@ describe('Test useGGHomeConnection', () => {
     ];
   });
 
-  it('test connectGoogleHome all connected', async () => {
+  it('test connectHomeAssistant all connected', async () => {
     let conns = {};
     options.forEach((option) => {
       conns[option.chip_id] = connection;
       createConnection.mockImplementationOnce(() => connection);
     });
-    const { result } = renderHook(() => useGGHomeConnection(), {
+    const { result } = renderHook(() => useHomeAssistantConnection(), {
       wrapper,
     });
 
     await act(async () => {
-      await result.current.connectGoogleHome(options);
+      await result.current.connectHomeAssistant(options);
     });
     expect(mockedSetAction).toBeCalledWith(
-      Action.SET_GOOGLE_HOME_CONNECTIONS,
+      Action.SET_HOME_ASSISTANT_CONNECTIONS,
       conns
     );
   });
 
-  it('test connectGoogleHome have chip disconnected', async () => {
+  it('test connectHomeAssistant have chip disconnected', async () => {
     let conns = {};
     conns[options[0].chip_id] = connection;
     conns[options[1].chip_id] = 0;
@@ -138,15 +138,15 @@ describe('Test useGGHomeConnection', () => {
     createConnection.mockImplementationOnce(async () => {
       throw new Error();
     });
-    const { result } = renderHook(() => useGGHomeConnection(), {
+    const { result } = renderHook(() => useHomeAssistantConnection(), {
       wrapper,
     });
 
     await act(async () => {
-      await result.current.connectGoogleHome(options);
+      await result.current.connectHomeAssistant(options);
     });
     expect(mockedSetAction).toBeCalledWith(
-      Action.SET_GOOGLE_HOME_CONNECTIONS,
+      Action.SET_HOME_ASSISTANT_CONNECTIONS,
       conns
     );
   });
@@ -159,17 +159,17 @@ describe('Test useGGHomeConnection', () => {
         throw new Error();
       });
     });
-    const { result } = renderHook(() => useGGHomeConnection(), {
+    const { result } = renderHook(() => useHomeAssistantConnection(), {
       wrapper,
     });
 
-    mock.onPost(API.GOOGLE_HOME.CHECK_SEND_EMAIL()).reply(200);
+    mock.onPost(API.HOME_ASSISTANT.CHECK_SEND_EMAIL()).reply(200);
     await act(async () => {
-      await result.current.connectGoogleHome(options);
+      await result.current.connectHomeAssistant(options);
     });
     expect(mockedSetAction).toBeCalledTimes(2);
     expect(mockedSetAction).toBeCalledWith(
-      Action.SET_GOOGLE_HOME_CONNECTIONS,
+      Action.SET_HOME_ASSISTANT_CONNECTIONS,
       conns
     );
     expect(mockedSetAction).toBeCalledWith(Action.LIST_DEVICE_TYPES, {
@@ -178,20 +178,20 @@ describe('Test useGGHomeConnection', () => {
     });
   });
 
-  it('test disconnectGoogleHome', async () => {
+  it('test disconnectHomeAssistant', async () => {
     let conns = {};
     conns[options[0].chip_id] = connection;
     conns[options[1].chip_id] = 0;
 
-    const { result } = renderHook(() => useGGHomeConnection(), {
+    const { result } = renderHook(() => useHomeAssistantConnection(), {
       wrapper,
     });
 
     await act(async () => {
-      await result.current.disconnectGoogleHome(conns, options);
+      await result.current.disconnectHomeAssistant(conns, options);
     });
     expect(mockedSetAction).toBeCalledWith(
-      Action.SET_GOOGLE_HOME_CONNECTIONS,
+      Action.SET_HOME_ASSISTANT_CONNECTIONS,
       {}
     );
   });

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

@@ -5,14 +5,14 @@ import {
   sendCommandOverBluetooth,
   SEND_COMMAND_OVER_BLUETOOTH_FAIL,
 } from '../../../iot/RemoteControl/Bluetooth';
-import { sendCommandOverGoogleHome } from '../../../iot/RemoteControl/GoogleHome';
+import { sendCommandOverHomeAssistant } from '../../../iot/RemoteControl/HomeAssistant';
 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/HomeAssistant');
 jest.mock('../../../iot/RemoteControl/Internet');
 jest.mock('../../../iot/RemoteControl/LG');
 
@@ -32,7 +32,7 @@ describe('Test useRemoteControl', () => {
 
   beforeEach(() => {
     sendCommandOverBluetooth.mockClear();
-    sendCommandOverGoogleHome.mockClear();
+    sendCommandOverHomeAssistant.mockClear();
     sendCommandOverInternet.mockClear();
     sendCommandOverLGThinq.mockClear();
 
@@ -62,7 +62,7 @@ describe('Test useRemoteControl', () => {
       sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverInternet).not.toBeCalled();
-    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverHomeAssistant).not.toBeCalled();
     expect(sendCommandOverLGThinq).not.toBeCalled();
     expect(sendCommandOverBluetooth).not.toBeCalled();
   });
@@ -83,7 +83,7 @@ describe('Test useRemoteControl', () => {
       userId
     );
     expect(sendCommandOverInternet).not.toBeCalled();
-    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverHomeAssistant).not.toBeCalled();
     expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
@@ -112,7 +112,7 @@ describe('Test useRemoteControl', () => {
       'bluetooth'
     );
     expect(sendCommandOverInternet).toBeCalledTimes(1);
-    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverHomeAssistant).not.toBeCalled();
     expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
@@ -135,7 +135,7 @@ describe('Test useRemoteControl', () => {
       userId
     );
     expect(sendCommandOverInternet).not.toBeCalled();
-    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverHomeAssistant).not.toBeCalled();
     expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
@@ -157,22 +157,27 @@ describe('Test useRemoteControl', () => {
       'internet'
     );
     expect(sendCommandOverBluetooth).not.toBeCalled();
-    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverHomeAssistant).not.toBeCalled();
     expect(sendCommandOverLGThinq).not.toBeCalled();
   });
 
-  it('test send remote command via googlehome', async () => {
+  it('test send remote command via homeassistant', async () => {
     action.command_prefer_over_bluetooth = false;
     action.command_prefer_over_googlehome = true;
     const { result: sendRemoteCommand } = renderHook(() => useRemoteControl(), {
       wrapper,
     });
 
-    sendCommandOverGoogleHome.mockImplementation(async () => true);
+    sendCommandOverHomeAssistant.mockImplementation(async () => true);
     act(() => {
       sendRemoteCommand.current(sensor, action, data, userId);
     });
-    expect(sendCommandOverGoogleHome).toBeCalledWith({}, sensor, action, data);
+    expect(sendCommandOverHomeAssistant).toBeCalledWith(
+      {},
+      sensor,
+      action,
+      data
+    );
     expect(sendCommandOverBluetooth).not.toBeCalled();
     expect(sendCommandOverInternet).not.toBeCalled();
     expect(sendCommandOverLGThinq).not.toBeCalled();
@@ -190,7 +195,7 @@ describe('Test useRemoteControl', () => {
       sendRemoteCommand.current(sensor, action, data, userId);
     });
     expect(sendCommandOverBluetooth).not.toBeCalled();
-    expect(sendCommandOverGoogleHome).not.toBeCalled();
+    expect(sendCommandOverHomeAssistant).not.toBeCalled();
     expect(sendCommandOverInternet).not.toBeCalled();
   });
 });

package/src/hooks/IoT/index.js

@@ -1,11 +1,11 @@
-import useGGHomeConnection from './useGGHomeConnection';
+import useHomeAssistantConnection from './useHomeAssistantConnection';
 import useRemoteControl from './useRemoteControl';
 import useValueEvaluations from './useValueEvaluation';
 import useWatchConfigs from './useWatchConfigs';
 import useUnwatchLGDeviceConfigControl from './useUnwatchLGDeviceConfigControl';
 
 export {
-  useGGHomeConnection,
+  useHomeAssistantConnection,
   useRemoteControl,
   useValueEvaluations,
   useWatchConfigs,

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;