@eohjsc/react-native-smart-city 0.3.31 → 0.3.34

package/src/context/reducer.ts

@@ -28,6 +28,7 @@ export type ContextData = {
   valueEvaluations: {};
   fetchedValueEvaluationUnits: Array<number>;
   devMode: DevModeType;
+  percent: number;
 };
 
 export type Action = {
@@ -48,6 +49,7 @@ export const initialState = {
   statusBar: {} as StatusBar,
   listDevice: {} as ListDevice,
   listAction: [] as ListAction,
+  percent: 0,
   unit: {
     favoriteDeviceIds: [],
   },
@@ -66,9 +68,12 @@ export const initialState = {
     isLockWhenPickColor: false,
   },
   iot: {
-    googlehome: {
+    homeassistant: {
       connections: {},
     },
+    lgthinq: {
+      unitConnected: [],
+    },
     internet: {
       statuses: {},
     },
@@ -92,6 +97,26 @@ export const reducer = (currentState: ContextData, action: Action) => {
       return { ...currentState, statusBar: payload };
     case Action.UPDATE_LANGUAGE:
       return { ...currentState, language: payload };
+    case Action.PERCENT_LOADED:
+      // eslint-disable-next-line no-case-declarations
+      const percent =
+        currentState.percent < 0.85
+          ? currentState.percent + (Math.random() * 0.15 + 0.01)
+          : currentState.percent;
+      return {
+        ...currentState,
+        percent: percent,
+      };
+    case Action.REFRESH_PERCENT:
+      return {
+        ...currentState,
+        percent: 0,
+      };
+    case Action.PROCESS_DONE:
+      return {
+        ...currentState,
+        percent: 1,
+      };
     case Action.LIST_DEVICE_TYPES:
       if (currentState.listDevice) {
         currentState.listDevice[action.payload.chipId] = {
@@ -266,32 +291,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;

package/src/hoc/__test__/withRemoteControl.test.js

@@ -0,0 +1,24 @@
+import React from 'react';
+import renderer, { act } from 'react-test-renderer';
+import { withRemoteControl } from '../index';
+import { SCProvider } from '../../context';
+import { mockSCStore } from '../../context/mockStore';
+
+describe('Test withRemoteControl', () => {
+  let tree;
+
+  it('test send remote command action null', async () => {
+    const Component = () => <></>;
+    const WrappedComponent = withRemoteControl(Component);
+    await act(async () => {
+      tree = renderer.create(
+        <SCProvider initState={mockSCStore({})}>
+          <WrappedComponent />
+        </SCProvider>
+      );
+    });
+    const instance = tree.root;
+    const _Component = instance.findByType(Component);
+    expect(_Component.props.sendRemoteCommand).toBeDefined();
+  });
+});

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/__test__/useAndroidTranslucentStatusBar.test.js

@@ -0,0 +1,55 @@
+import React from 'react';
+import { Platform } from 'react-native';
+import { renderHook } from '@testing-library/react-hooks';
+import { useAndroidTranslucentStatusBar } from '../index';
+import { SCProvider } from '../../../context';
+import { mockSCStore } from '../../../context/mockStore';
+
+const mockedSetAction = jest.fn();
+
+const wrapper = ({ children }) => <SCProvider>{children}</SCProvider>;
+
+const mockUseContext = jest.fn().mockImplementation(() => ({
+  stateData: mockSCStore({}),
+  setAction: mockedSetAction,
+}));
+
+React.useContext = mockUseContext;
+
+const mockAddListener = jest.fn();
+jest.mock('@react-navigation/native', () => {
+  return {
+    ...jest.requireActual('@react-navigation/native'),
+    useNavigation: () => ({
+      addListener: mockAddListener,
+    }),
+  };
+});
+
+describe('test useAndroidTranslucentStatusBar', () => {
+  beforeEach(() => {
+    mockAddListener.mockClear();
+  });
+
+  test('test useAndroidTranslucentStatusBar android', () => {
+    Platform.OS = 'android';
+    renderHook(
+      () => useAndroidTranslucentStatusBar({ background: '#ffffff' }),
+      {
+        wrapper,
+      }
+    );
+    expect(mockAddListener).not.toBeCalled();
+  });
+
+  test('test useAndroidTranslucentStatusBar ios', () => {
+    Platform.OS = 'ios';
+    renderHook(
+      () => useAndroidTranslucentStatusBar({ background: '#ffffff' }),
+      {
+        wrapper,
+      }
+    );
+    expect(mockAddListener).not.toBeCalled();
+  });
+});

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

@@ -1,4 +1,5 @@
 import { useCallback, useContext } from 'react';
+import { InteractionManager } from 'react-native';
 import { useFocusEffect } from '@react-navigation/native';
 import { SCContext, useSCContextSelector } from '../../context';
 import { axiosGet } from '../../utils/Apis/axios';
@@ -24,30 +25,33 @@ const useDevicesStatus = (unit, devices) => {
         params: params,
       }
     );
-    if (success) {
-      setAction(Action.SET_DEVICES_STATUS, data);
-    }
+    success && setAction(Action.SET_DEVICES_STATUS, data);
     timeoutId = setTimeout(() => getDevicesStatus(_unit, _devices), 10000);
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
   useFocusEffect(
     useCallback(() => {
-      if (!devices?.length || !isNetworkConnected) {
-        return;
-      }
-
-      const managedDevices = devices.filter(
-        (device) => device?.is_managed_by_backend
-      );
-      if (!managedDevices.length) {
-        return;
-      }
-
-      timeoutId = setTimeout(() => getDevicesStatus(unit, managedDevices), 200);
+      const task = InteractionManager.runAfterInteractions(() => {
+        if (!devices?.length || !isNetworkConnected) {
+          return;
+        }
+
+        const managedDevices = devices.filter(
+          (device) => device?.is_managed_by_backend
+        );
+        if (!managedDevices.length) {
+          return;
+        }
+        timeoutId = setTimeout(
+          () => getDevicesStatus(unit, managedDevices),
+          200
+        );
+      });
 
       return () => {
         clearTimeout(timeoutId);
+        task.cancel();
       };
       // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [unit, devices, isNetworkConnected])

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;