@eohjsc/react-native-smart-city 0.3.0 → 0.3.1

package/src/iot/RemoteControl/GoogleHome.js

@@ -5,8 +5,6 @@ import { ToastBottomHelper } from '../../utils/Utils';
 import { API } from '../../configs';
 import { axiosPost } from '../../utils/Apis/axios';
 
-let connections = {};
-
 let configMaps = {};
 
 let attributeMaps = {};
@@ -89,14 +87,14 @@ async function fetchConnectionEntities(connection) {
     const entity = states[i];
     const entityId = entity.entity_id;
 
-    if (configMaps.hasOwnProperty(entityId)) {
+    if (Object.prototype.hasOwnProperty.call(configMaps, entityId)) {
       const [configId, type] = configMaps[entityId];
       const typeConverter = valueTypes[type] || keepValue;
 
       configValues[configId] = typeConverter(entity.state, entityId);
     }
 
-    if (attributeMaps.hasOwnProperty(entityId)) {
+    if (Object.prototype.hasOwnProperty.call(attributeMaps, entityId)) {
       const entityAttributeMaps = attributeMaps[entityId];
       for (const [attributeName, attributeMap] of Object.entries(
         entityAttributeMaps
@@ -118,14 +116,21 @@ async function fetchConnectionEntities(connection) {
   setConfigGlobalState('configValues', { ...configValues });
 }
 
-export const googleHomeConnect = async (options) => {
-  let isConnected = true;
+export const googleHomeConnect = async (
+  oldConnections,
+  options,
+  onEstablished,
+  onDisconnected,
+  onReconnected
+) => {
+  let connections = {};
+
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
 
-    if (option.chip_id in connections) {
-      // skip connected
-      return isConnected;
+    if (option.chip_id in oldConnections && !!oldConnections[option.chip_id]) {
+      connections[option.chip_id] = oldConnections[option.chip_id];
+      continue;
     }
     connections[option.chip_id] = 0; // connecting
 
@@ -152,43 +157,45 @@ export const googleHomeConnect = async (options) => {
       }
     });
 
-    let auth = new Auth(option.auth);
-    const connection = await createConnection({ auth });
-    await connection.subscribeEvents(stateChangeCallback, 'state_changed');
-
-    connection.addEventListener('disconnected', () => {
-      ToastBottomHelper.error(t('command_googlehome_lost'));
-      isConnected = false;
-    });
-
-    connection.addEventListener('ready', async (conn, eventData) => {
-      await fetchConnectionEntities(conn);
-      ToastBottomHelper.success(t('command_googlehome_ready'));
-      isConnected = true;
-    });
-
-    connections[option.chip_id] = connection;
-    await fetchConnectionEntities(connection);
-    isConnected = true;
+    try {
+      let auth = new Auth(option.auth);
+      const connection = await createConnection({ auth });
+      await connection.subscribeEvents(stateChangeCallback, 'state_changed');
+
+      connection.addEventListener('disconnected', async () => {
+        await onDisconnected(option);
+        ToastBottomHelper.error(t('command_googlehome_lost'));
+      });
+
+      connection.addEventListener('ready', async (conn, eventData) => {
+        await fetchConnectionEntities(conn);
+        await onReconnected(option, conn);
+        ToastBottomHelper.success(t('command_googlehome_ready'));
+      });
+
+      connections[option.chip_id] = connection;
+      await fetchConnectionEntities(connection);
+    } catch (err) {
+      connections[option.chip_id] = 0;
+    }
   }
-  return isConnected;
+  await onEstablished(connections, options);
+  return connections;
 };
 
-export const googleHomeDisconnect = async (options) => {
+export const googleHomeDisconnect = async (connections, options) => {
   for (let i = 0; i < options.length; i++) {
     const option = options[i];
-
-    if (!(option.chip_id in connections)) {
-      return;
+    if (option.chip_id in connections) {
+      if (connections[option.chip_id]) {
+        await connections[option.chip_id].close();
+      }
     }
-
-    await connections[option.chip_id].close();
-    delete connections[option.chip_id];
   }
 };
 
-function getSensorConnection(sensor) {
-  return connections[sensor.chip_id];
+function getDeviceConnection(connections, device) {
+  return connections[device.chip_id];
 }
 
 function getServiceName(message) {
@@ -209,10 +216,20 @@ async function sendCommandSingleAction(connection, ghAction, data) {
     message.service_data[name] = data;
   }
 
-  await connection.sendMessagePromise(message);
+  try {
+    await connection.sendMessagePromise(message);
+    return true;
+  } catch (err) {
+    ToastBottomHelper.error(t('command_send_fail_googlehome'));
+  }
 }
 
-export async function sendCommandOverGoogleHome(sensor, action, data) {
+export async function sendCommandOverGoogleHome(
+  connections,
+  device,
+  action,
+  data
+) {
   if (
     !(action.googlehome_actions && action.googlehome_actions.length) &&
     !action.googlehome_action
@@ -220,30 +237,39 @@ export async function sendCommandOverGoogleHome(sensor, action, data) {
     return;
   }
 
-  const connection = getSensorConnection(sensor);
+  const connection = getDeviceConnection(connections, device);
   if (!connection) {
     ToastBottomHelper.error(t('command_send_fail_googlehome'));
     return;
   }
 
+  let triggerSuccess;
+
   if (action.googlehome_actions) {
     for (let i = 0; i < action.googlehome_actions.length; i++) {
-      await sendCommandSingleAction(
+      triggerSuccess = await sendCommandSingleAction(
         connection,
         action.googlehome_actions[i],
         data
       );
     }
   } else if (action.googlehome_action) {
-    await sendCommandSingleAction(connection, action.googlehome_action, data);
+    triggerSuccess = await sendCommandSingleAction(
+      connection,
+      action.googlehome_action,
+      data
+    );
   }
 
-  const { success } = await axiosPost(API.SENSOR.ACTIVITY_LOG(), {
-    action_id: action.id,
-    message: 'Trigger by user action with google home',
-  });
-  if (success) {
-    ToastBottomHelper.success(t('command_send_success_googlehome'));
+  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;
   }
-  return success;
+  return false;
 }

package/src/iot/RemoteControl/Internet.js

@@ -17,7 +17,7 @@ export const sendCommandOverInternet = async (
     }
   }
   ToastBottomHelper.success(t('Sending command via internet'));
-  const { success } = await axiosPost(API.SENSOR.QUICK_ACTION(sensor.id), {
+  const { success } = await axiosPost(API.DEVICE.TRIGGER_ACTION(sensor.id), {
     key: action.key,
     data,
     source,

package/src/iot/RemoteControl/__test__/GoogleHome.test.js

@@ -27,6 +27,10 @@ const connection = {
   close: jest.fn(),
 };
 
+const mockEstablished = jest.fn();
+const mockDisconnected = jest.fn();
+const mockReconnected = jest.fn();
+
 getStates.mockImplementation(() => []);
 createConnection.mockImplementation(() => connection);
 
@@ -82,7 +86,6 @@ describe('Remote Control Google Home', () => {
   };
 
   beforeEach(async () => {
-    await googleHomeDisconnect(options);
     connection.sendMessagePromise.mockClear();
     createConnection.mockClear();
     getStates.mockClear();
@@ -108,7 +111,13 @@ describe('Remote Control Google Home', () => {
     let configValues = getConfigGlobalState('configValues');
     expect(configValues).toEqual({});
 
-    await googleHomeConnect(options);
+    await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
     expect(createConnection).toBeCalledTimes(1);
     expect(getStates).toBeCalledTimes(1);
 
@@ -144,15 +153,33 @@ describe('Remote Control Google Home', () => {
       }
     });
 
-    await googleHomeConnect(options);
+    await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
 
     configValues = getConfigGlobalState('configValues');
     expect(configValues).toEqual({ 1: true });
   });
 
   it('Connect to same google home will be skipped', async () => {
-    await googleHomeConnect(options);
-    await googleHomeConnect(options);
+    const connections = await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
+    await googleHomeConnect(
+      connections,
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
     expect(createConnection).toBeCalledTimes(1);
     expect(getStates).toBeCalledTimes(1);
   });
@@ -163,7 +190,13 @@ describe('Remote Control Google Home', () => {
         listener();
       }
     });
-    await googleHomeConnect(options);
+    await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
     expect(createConnection).toBeCalledTimes(1);
     expect(getStates).toBeCalledTimes(2);
   });
@@ -174,7 +207,13 @@ describe('Remote Control Google Home', () => {
         listener();
       }
     });
-    await googleHomeConnect(options);
+    await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
     expect(Toast.show).toBeCalledWith({
       type: 'error',
       position: 'bottom',
@@ -184,9 +223,15 @@ describe('Remote Control Google Home', () => {
   });
 
   it('Send command over google home will send message to chip', async () => {
-    mock.onPost(API.SENSOR.ACTIVITY_LOG()).reply(200);
-    await googleHomeConnect(options);
-    await sendCommandOverGoogleHome(sensor, action);
+    mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
+    const connections = await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
+    await sendCommandOverGoogleHome(connections, sensor, action);
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_actions[0].message
     );
@@ -203,9 +248,15 @@ describe('Remote Control Google Home', () => {
       },
       id: 20,
     };
-    mock.onPost(API.SENSOR.ACTIVITY_LOG()).reply(200);
-    await googleHomeConnect(options);
-    await sendCommandOverGoogleHome(sensor, action, 19);
+    mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
+    const connections = await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
+    await sendCommandOverGoogleHome(connections, sensor, action, 19);
     action.googlehome_actions[0].message.service_data.temperature = 19;
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_actions[0].message
@@ -224,9 +275,15 @@ describe('Remote Control Google Home', () => {
       },
       id: 20,
     };
-    mock.onPost(API.SENSOR.ACTIVITY_LOG()).reply(200);
-    await googleHomeConnect(options);
-    await sendCommandOverGoogleHome(sensor, action, 19);
+    mock.onPost(API.DEVICE.ACTIVITY_LOG()).reply(200);
+    const connections = await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
+    await sendCommandOverGoogleHome(connections, sensor, action, 19);
     action.googlehome_action.message.service_data.temperature = 19;
     expect(connection.sendMessagePromise).toBeCalledWith(
       action.googlehome_action.message
@@ -234,20 +291,32 @@ describe('Remote Control Google Home', () => {
   });
 
   it('Send command over google home that not connected', async () => {
-    await googleHomeConnect(options);
-    await sendCommandOverGoogleHome({ chip_id: 2 }, action);
+    await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
+    await sendCommandOverGoogleHome({}, { chip_id: 2 }, action);
     expect(connection.sendMessagePromise).not.toBeCalled();
   });
 
   it('Send command over google home that not a google home', async () => {
-    await googleHomeConnect(options);
-    await sendCommandOverGoogleHome(sensor, {});
+    await googleHomeConnect(
+      {},
+      options,
+      mockEstablished,
+      mockDisconnected,
+      mockReconnected
+    );
+    await sendCommandOverGoogleHome({}, sensor, {});
     expect(connection.sendMessagePromise).not.toBeCalled();
   });
 
   it('Disconnect a not connected gateway', async () => {
     connection.close.mockClear();
-    await googleHomeDisconnect(options);
+    await googleHomeDisconnect({}, options);
     expect(connection.close).not.toBeCalled();
   });
 });

package/src/iot/RemoteControl/__test__/Internet.test.js

@@ -12,25 +12,25 @@ describe('Test IOT Remote Control Internet', () => {
   });
 
   test('Trigger action via request POST', async () => {
-    mock.onPost(API.SENSOR.QUICK_ACTION()).reply(200);
+    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(200);
     await sendCommandOverInternet({}, {}, 'internet');
     expect(Toast.show).toBeCalledTimes(2);
   });
 
   test('Trigger action via request POST with data isInteger', async () => {
-    mock.onPost(API.SENSOR.QUICK_ACTION()).reply(200);
+    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(200);
     await sendCommandOverInternet({}, {}, 1);
     expect(Toast.show).toBeCalledTimes(2);
   });
 
   test('Trigger action via request POST with data is null', async () => {
-    mock.onPost(API.SENSOR.QUICK_ACTION()).reply(200);
+    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(200);
     await sendCommandOverInternet({}, {}, null);
     expect(Toast.show).toBeCalledTimes(2);
   });
 
   test('Trigger action fail show error', async () => {
-    mock.onPost(API.SENSOR.QUICK_ACTION()).reply(400);
+    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(400);
     await sendCommandOverInternet({}, {}, 'internet');
     expect(Toast.show).toBeCalled();
   });

package/src/iot/RemoteControl/__test__/LgThinq.test.js

@@ -86,7 +86,7 @@ describe('Remote Control LG Thinq', () => {
 
   it('Send command over lg thinq but fetch device status failed', async () => {
     mock.onGet(API.IOT.LG.DEVICE_STATUS()).reply(200, {});
-    mock.onPost(API.SENSOR.QUICK_ACTION()).reply(200, {});
+    mock.onPost(API.DEVICE.TRIGGER_ACTION()).reply(200, {});
     setConfigGlobalState('configValues', { 1: 'LOW' });
     await sendCommandOverLGThinq(sensor, action, 'AUTO');
     let configValues = getConfigGlobalState('configValues');
@@ -146,7 +146,7 @@ describe('Remote Control LG Thinq', () => {
     };
     mock.onGet(API.IOT.LG.DEVICE_STATUS(1)).reply(200, responseGet.data);
     jest.useFakeTimers();
-    mock.onPost(API.SENSOR.QUICK_ACTION(1)).reply(200);
+    mock.onPost(API.DEVICE.TRIGGER_ACTION(1)).reply(200);
     await lgThinqConnect(options);
     setConfigGlobalState('configValues', { 1: 0, 2: 0 });
     await sendCommandOverLGThinq(sensor, action, [18, 30]);
@@ -159,14 +159,14 @@ describe('Remote Control LG Thinq', () => {
 
   it('Send command over lg thinq will call sendCommandOverInternet with boolean', async () => {
     let configValues = getConfigGlobalState('configValues');
-    mock.onPost(API.SENSOR.QUICK_ACTION(1)).reply(200, {});
+    mock.onPost(API.DEVICE.TRIGGER_ACTION(1)).reply(200, {});
     await sendCommandOverLGThinq(sensor, action, true);
     expect(configValues).toEqual({});
   });
 
   it('Send command over lg thinq will call sendCommandOverInternet with number', async () => {
     let configValues = getConfigGlobalState('configValues');
-    mock.onPost(API.SENSOR.QUICK_ACTION(1)).reply(200, {});
+    mock.onPost(API.DEVICE.TRIGGER_ACTION(1)).reply(200, {});
     await sendCommandOverLGThinq(sensor, action, 7);
     expect(configValues).toEqual({});
   });
@@ -176,7 +176,7 @@ describe('Remote Control LG Thinq', () => {
     action.lg_actions[0].message = {
       temperature: { targetTemperature: 0, locationName: 'FRIDGE', unit: 'C' },
     };
-    mock.onPost(API.SENSOR.QUICK_ACTION(1)).reply(200);
+    mock.onPost(API.DEVICE.TRIGGER_ACTION(1)).reply(200);
     await sendCommandOverLGThinq(sensor, action, 7);
     expect(configValues).toEqual({});
   });

package/src/iot/RemoteControl/index.js

@@ -1,55 +1,55 @@
-import {
-  SEND_COMMAND_OVER_BLUETOOTH_FAIL,
-  sendCommandOverBluetooth,
-} from './Bluetooth';
-import { sendCommandOverInternet } from './Internet';
-import { sendCommandOverGoogleHome } from './GoogleHome';
-import { ToastBottomHelper } from '../../utils/Utils';
-import t from '../../hooks/Common/useTranslations';
-import { sendCommandOverLGThinq } from './LG';
+// import {
+//   SEND_COMMAND_OVER_BLUETOOTH_FAIL,
+//   sendCommandOverBluetooth,
+// } from './Bluetooth';
+// import { sendCommandOverInternet } from './Internet';
+// import { sendCommandOverGoogleHome } from './GoogleHome';
+// import { ToastBottomHelper } from '../../utils/Utils';
+// import t from '../../hooks/Common/useTranslations';
+// import { sendCommandOverLGThinq } from './LG';
 
-export const sendRemoteCommand = async (
-  sensor,
-  action,
-  data,
-  userId = null,
-  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) {
-    result = await sendCommandOverInternet(sensor, action, data, 'internet');
-  }
+// export const sendRemoteCommand = async (
+//   sensor,
+//   action,
+//   data,
+//   userId = null,
+//   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) {
+//     result = await sendCommandOverInternet(sensor, action, data, 'internet');
+//   }
 
-  if (action.command_prefer_over_googlehome) {
-    result = await sendCommandOverGoogleHome(sensor, action, data);
-  }
+//   if (action.command_prefer_over_googlehome) {
+//     result = await sendCommandOverGoogleHome(sensor, action, data);
+//   }
 
-  if (action.command_prefer_over_lg) {
-    result = await sendCommandOverLGThinq(sensor, action, data);
-  }
-  return result;
-};
+//   if (action.command_prefer_over_lg) {
+//     result = await sendCommandOverLGThinq(sensor, action, data);
+//   }
+//   return result;
+// };

package/src/screens/ActivityLog/hooks/__test__/index.test.js

@@ -81,7 +81,7 @@ describe('Test useActivityLog', () => {
 
   it('Test onRefresh activity log of sensor', async () => {
     const { result } = renderHook(() => useActivityLog(props));
-    mock.onGet(API.SENSOR.ACTIVITY_LOG(1)).reply(200, {
+    mock.onGet(API.DEVICE.ACTIVITY_LOG(1)).reply(200, {
       results: actionLogData,
       count: 21,
     });
@@ -135,14 +135,14 @@ describe('Test useActivityLog', () => {
 
   it('Test onLoadMore', async () => {
     const { result } = renderHook(() => useActivityLog(props));
-    mock.onGet(API.SENSOR.ACTIVITY_LOG(1)).reply(200, {
+    mock.onGet(API.DEVICE.ACTIVITY_LOG(1)).reply(200, {
       results: actionLogData,
       count: 21,
     });
     await act(async () => {
       await result.current.onLoadMore();
     });
-    mock.onGet(API.SENSOR.ACTIVITY_LOG(2)).reply(200, {
+    mock.onGet(API.DEVICE.ACTIVITY_LOG(2)).reply(200, {
       results: actionLogData,
       count: 21,
     });

package/src/screens/ActivityLog/hooks/index.js

@@ -9,7 +9,7 @@ import { getDataForList, getEmergencyEventDataForList } from '../utils';
 
 const apiMaps = {
   ['action']: {
-    url: () => API.SENSOR.ACTIVITY_LOG(),
+    url: () => API.DEVICE.ACTIVITY_LOG(),
     params: (id) => ({ id: id }),
     standardizeData: getDataForList,
     memberUrl: (id) => API.SHARE.UNITS_MEMBERS(id),

package/src/screens/AddLocationMaps/index.js

@@ -45,9 +45,9 @@ const AddLocationMaps = memo(() => {
     goBack();
   }, [goBack]);
 
-  const onTextInput = useCallback(async (input) => {
-    setInput(input);
-    if (!input) {
+  const onTextInput = useCallback(async (newValue) => {
+    setInput(newValue);
+    if (!newValue) {
       setSearchData([]);
       setSearchedLocation(null);
       return;
@@ -55,7 +55,7 @@ const AddLocationMaps = memo(() => {
     try {
       const config = {
         params: {
-          input: input,
+          input: newValue,
           key: SCConfig.GOOGLE_MAP_API_KEY,
           sessiontoken: 123456324,
           strictBounds: false,
@@ -70,6 +70,7 @@ const AddLocationMaps = memo(() => {
       if (success) {
         setSearchData(data.predictions);
       }
+      // eslint-disable-next-line no-empty
     } catch (error) {}
   }, []);