@eohjsc/react-native-smart-city 0.7.24 → 0.7.26

package/src/configs/AccessibilityLabel.js

@@ -40,6 +40,7 @@ export default {
   MY_UNIT_GO_TO_DETAIL: 'MY_UNIT_GO_TO_DETAIL',
   MY_UNIT_NO_UNIT: 'MY_UNIT_NO_UNIT',
   ITEM_UNIT: 'ITEM_UNIT',
+  UNIT_GO_TO_DETAIL: 'UNIT_GO_TO_DETAIL',
 
   // ConfirmUnitDeletion
   CONFIRM_UNIT_DELETION_BUTTON: 'CONFIRM_UNIT_DELETION_BUTTON',
@@ -270,6 +271,7 @@ export default {
   PARKING_SPOT_TEXT_RESULT: 'PARKING_SPOT_TEXT_RESULT',
 
   // Header Device
+  HEADER_DEVICE_BUTTON_PIN: 'HEADER_DEVICE_BUTTON_PIN',
   HEADER_DEVICE_BUTTON_STAR: 'HEADER_DEVICE_BUTTON_STAR',
   HEADER_SCRIPT_DETAIL_BUTTON_STAR: 'HEADER_SCRIPT_DETAIL_BUTTON_STAR',
   HEADER_DEVICE_BUTTON_MORE: 'HEADER_DEVICE_BUTTON_MORE',

package/src/configs/Constants.js

@@ -98,6 +98,9 @@ const marginItem = 12;
 const marginHorizontal = 16;
 const widthItem = (Constants.width - marginHorizontal * 2 - marginItem) / 2;
 const heightItem = (widthItem / 166) * 106;
+
+export const PAGE_SIZE = 10;
+
 export const DEVICE_SIZE = {
   width: widthItem,
   height: heightItem,

package/src/context/actionType.ts

@@ -12,6 +12,9 @@ export const Action = {
   SET_NETWORK_CONNECTED: 'SET_NETWORK_CONNECTED',
   CAMERA_STATUS_CHANGE: 'CAMERA_STATUS_CHANGE',
   CLOSE_ALL_CAMERA: 'CLOSE_ALL_CAMERA',
+  SET_DASHBOARD_DEVICES: 'SET_DASHBOARD_DEVICES',
+  ADD_DEVICES_TO_DASHBOARD: 'ADD_DEVICE_TO_DASHBOARD',
+  REMOVE_DEVICES_FROM_DASHBOARD: 'REMOVE_DEVICE_FROM_DASHBOARD',
   SET_FAVORITE_DEVICES: 'SET_FAVORITE_DEVICES',
   ADD_DEVICES_TO_FAVORITES: 'ADD_DEVICE_TO_FAVORITES',
   REMOVE_DEVICES_FROM_FAVORITES: 'REMOVE_DEVICE_FROM_FAVORITES',
@@ -78,6 +81,7 @@ export type ListAction = {
 }[];
 
 export type UnitType = {
+  dashboardDeviceIds: [];
   favoriteDeviceIds: [];
 };
 

package/src/context/mockStore.ts

@@ -27,6 +27,7 @@ export const mockDataStore: ContextData = {
   listAction: [],
   myUnits: [],
   unit: {
+    dashboardDeviceIds: [],
     favoriteDeviceIds: [],
   },
   automate: {
@@ -103,6 +104,10 @@ export const mockSCStore = (data: ContextData): ContextData => {
     },
     myUnits: [...mockDataStore.myUnits, ...(data?.myUnits || [])],
     unit: {
+      dashboardDeviceIds: [
+        ...mockDataStore.unit.dashboardDeviceIds,
+        ...(data?.unit?.dashboardDeviceIds || []),
+      ],
       favoriteDeviceIds: [
         ...mockDataStore.unit.favoriteDeviceIds,
         ...(data?.unit?.favoriteDeviceIds || []),

package/src/context/reducer.ts

@@ -15,7 +15,6 @@ import {
   BluetoothType,
 } from './actionType';
 import _ from 'lodash';
-import { STORAGE_KEY, removeMultiple } from '../utils/Storage.js';
 import { AppState } from 'react-native';
 
 export type ContextData = {
@@ -57,6 +56,7 @@ export const initialState = {
   percent: 0,
   myUnits: [],
   unit: {
+    dashboardDeviceIds: [],
     favoriteDeviceIds: [],
   },
   automate: {
@@ -264,6 +264,35 @@ export const reducer = (currentState: ContextData, action: Action) => {
         },
       };
 
+    case Action.SET_DASHBOARD_DEVICES:
+      return {
+        ...currentState,
+        unit: {
+          ...currentState.unit,
+          dashboardDeviceIds: payload,
+        },
+      };
+    case Action.ADD_DEVICES_TO_DASHBOARD:
+      return {
+        ...currentState,
+        unit: {
+          ...currentState.unit,
+          dashboardDeviceIds: _.uniq(
+            currentState.unit.dashboardDeviceIds.concat(payload)
+          ),
+        },
+      };
+    case Action.REMOVE_DEVICES_FROM_DASHBOARD:
+      return {
+        ...currentState,
+        unit: {
+          ...currentState.unit,
+          dashboardDeviceIds: currentState.unit.dashboardDeviceIds.filter(
+            (deviceId) => !payload.includes(deviceId)
+          ),
+        },
+      };
+
     case Action.SET_FAVORITE_DEVICES:
       return {
         ...currentState,
@@ -552,10 +581,6 @@ export const reducer = (currentState: ContextData, action: Action) => {
       };
 
     case Action.LOGOUT:
-      removeMultiple([
-        STORAGE_KEY.IS_FIRST_TIME_LOAD_MY_UNITS,
-        STORAGE_KEY.IS_FIRST_TIME_LOAD_MY_SHARE_UNIT,
-      ]);
       return {
         ...currentState,
       };

package/src/iot/mqtt.js

@@ -1,8 +1,11 @@
 import moment from 'moment';
+import { getObject, storeObject } from '../utils/Storage';
 import { updateGlobalValue } from './Monitor';
 import { Buffer } from 'buffer';
 
-const int_all = (bytes_str, config_data = null) => {
+const struct = require('python-struct');
+
+const int_all = (bytes_str) => {
   let val;
   val = Number.parseInt(bytes_str, 16);
 
@@ -13,44 +16,75 @@ const int_all = (bytes_str, config_data = null) => {
   return val;
 };
 
-const int_first4 = (bytes_str, config_data = null) => {
-  return Number.parseInt(bytes_str.slice(0, 4), 16);
+const int_first4 = (bytes_str) => {
+  return Number.parseInt(bytes_str?.slice(0, 4), 16);
 };
 
-const int_last4 = (bytes_str, config_data = null) => {
-  return Number.parseInt(bytes_str.slice(4), 16);
+const int_last4 = (bytes_str) => {
+  return Number.parseInt(bytes_str?.slice(4), 16);
 };
 
-const uint_32 = (bytes_str, config_data = null) => {
-  let bits = 32;
-  let value = Number.parseInt(bytes_str, 16);
-
-  // eslint-disable-next-line no-bitwise
-  if (value & (1 << (bits - 1))) {
-    // eslint-disable-next-line no-bitwise
-    value -= 1 << bits;
-  }
-
-  return value;
-};
-
-const float_convert = (bytes_str) => {
-  const struct = require('python-struct');
+const value_unpacked = (format, bytes_str) => {
   let value = null;
   try {
-    value = struct.unpack('>f', Buffer.from(bytes_str, 'hex'))[0];
+    value = struct.unpack(format, Buffer.from(bytes_str, 'hex'))[0];
     // eslint-disable-next-line no-empty
   } catch {}
   return value;
 };
 
-const float_cdba = (bytes_str, config_data = null) => {
-  const bytes_cdba = bytes_str?.slice(4) + bytes_str?.slice(0, 4);
-  return float_convert(bytes_cdba);
+const uint_32_abcd = (bytes_str) => {
+  return value_unpacked('>I', bytes_str?.slice(0, 8));
+};
+
+const uint_32_dcba = (bytes_str) => {
+  return value_unpacked('<I', bytes_str?.slice(0, 8));
+};
+
+const uint_32_badc = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('<I', swapped);
+};
+
+const uint_32_cdab = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('>I', swapped);
+};
+
+const int_32_abcd = (bytes_str) => {
+  return value_unpacked('>i', bytes_str?.slice(0, 8));
+};
+
+const int_32_dcba = (bytes_str) => {
+  return value_unpacked('<i', bytes_str?.slice(0, 8));
 };
 
-const float_abcd = (bytes_str, config_data = null) => {
-  return float_convert(bytes_str);
+const int_32_badc = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('<i', swapped);
+};
+
+const int_32_cdab = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('>i', swapped);
+};
+
+const float_abcd = (bytes_str) => {
+  return value_unpacked('>f', bytes_str?.slice(0, 8));
+};
+
+const float_dcba = (bytes_str) => {
+  return value_unpacked('<f', bytes_str?.slice(0, 8));
+};
+
+const float_badc = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('<f', swapped);
+};
+
+const float_cdab = (bytes_str) => {
+  const swapped = bytes_str?.slice(4, 8) + bytes_str?.slice(0, 4);
+  return value_unpacked('>f', swapped);
 };
 
 const range_value_converting = (
@@ -84,12 +118,21 @@ const convert_ai = (bytes_str, config_data = null) => {
 
 const mappingTransformer = {
   int_all: int_all,
-  int_first4: int_first4,
-  int_last4: int_last4,
-  uint_32: uint_32,
-  float_cdba: float_cdba,
   float_abcd: float_abcd,
+  float_dcba: float_dcba,
+  float_badc: float_badc,
+  float_cdab: float_cdab,
+  uint_32_abcd: uint_32_abcd,
+  uint_32_dcba: uint_32_dcba,
+  uint_32_badc: uint_32_badc,
+  uint_32_cdab: uint_32_cdab,
+  int_32_abcd: int_32_abcd,
+  int_32_dcba: int_32_dcba,
+  int_32_badc: int_32_badc,
+  int_32_cdab: int_32_cdab,
   convert_ai: convert_ai,
+  int_first4: int_first4,
+  int_last4: int_last4,
 };
 
 const extract_config_value = (register, value_bytes) => {
@@ -135,19 +178,56 @@ const get_sensor_data = (sensor, data) => {
 };
 
 const get_scale_value = (value, config) => {
-  if (!value || typeof value === 'string') {
+  if (!value) {
     return value;
   }
-  const { decimal_behind, scale } = config;
-  let scaledValue = value * (scale || 1);
+  const scale = config?.scale || 1;
+  return value * scale;
+};
+
+const get_decimal_value = (value, config) => {
+  if (config?.decimal_behind || config?.decimal_behind === 0) {
+    value = value.toFixed(config.decimal_behind);
+  }
+  return value;
+};
 
-  if (decimal_behind || decimal_behind === 0) {
-    scaledValue = scaledValue.toFixed(decimal_behind);
+const get_offset_sample_value = async (value, config) => {
+  const offset = parseFloat(config?.ai_trans_offset_value) || 0;
+  const sample = config?.ai_trans_average_sample || 1;
+  value += offset;
+  if (sample <= 1) {
+    return Number(get_decimal_value(value, config));
   }
-  return Number(scaledValue);
+
+  const cacheKey = `last_values_${config?.id}`;
+  let values = await getObject(cacheKey, []);
+
+  values = [value, ...values];
+  values = values.slice(0, sample);
+
+  value = values.reduce((a, b) => a + b) / values.length;
+  value = Number(get_decimal_value(value, config));
+
+  values[0] = value;
+  await storeObject(cacheKey, values);
+  return value;
 };
 
-const updateGlobalValueMqtt = (config, value) => {
+const check_filter = (value, config) => {
+  if (!config?.active_filter) {
+    return false;
+  }
+  if (config?.active_filter === 'zero') {
+    return !value;
+  }
+
+  const low = config?.low_level || 0;
+  const high = config?.high_level || 0;
+  return value < low || value > high;
+};
+
+const updateGlobalValueMqtt = async (config, value) => {
   if (!config?.id) {
     return;
   }
@@ -155,13 +235,20 @@ const updateGlobalValueMqtt = (config, value) => {
     return;
   }
 
-  value = get_scale_value(value, config);
-  updateGlobalValue(config.id, { value: value });
-};
+  const last_updated = moment().format('YYYY-MM-DDTHH:mm:ss.SSSSSS');
+  if (typeof value === 'string') {
+    updateGlobalValue(config.id, { value, last_updated });
+    return;
+  }
 
-const arduinoUpdateGlobalValueMqtt = (config, value, last_updated) => {
   value = get_scale_value(value, config);
-  updateGlobalValue(config.id, { value: value, last_updated: last_updated });
+  value = await get_offset_sample_value(value, config);
+
+  if (check_filter(value, config)) {
+    return;
+  }
+
+  updateGlobalValue(config.id, { value, last_updated });
 };
 
 export const handleModbusData = (chip, configById, data) => {
@@ -188,11 +275,7 @@ export const handleModbusData = (chip, configById, data) => {
 };
 
 export const handleChipData = (configById, configId, data) => {
-  arduinoUpdateGlobalValueMqtt(
-    configById[configId],
-    data?.v,
-    moment().format('YYYY-MM-DDTHH:mm:ss.SSSSSS')
-  );
+  updateGlobalValueMqtt(configById[configId], data?.v);
 };
 
 export const handleZigbeeData = (chip, configById, ieee_address, data) => {
@@ -217,6 +300,26 @@ export const handleZigbeeData = (chip, configById, ieee_address, data) => {
   }
 };
 
+export const handleThirdPartyData = (chip, configById, device_uid, data) => {
+  const third_party_gateway = chip?.third_party_gateway;
+  if (!third_party_gateway) {
+    return;
+  }
+
+  const third_party_device_by_uid = {};
+
+  third_party_gateway?.sensors?.forEach((device) => {
+    third_party_device_by_uid[device.device_uid] = device;
+  });
+
+  const device = third_party_device_by_uid[device_uid];
+  device?.configs?.forEach((config_map) => {
+    const value = data[config_map?.key];
+    const configId = config_map?.config;
+    updateGlobalValueMqtt(configById[configId], value);
+  });
+};
+
 export const handleMqttMessage = (
   topic,
   payloadData,
@@ -246,4 +349,17 @@ export const handleMqttMessage = (
     // payload: {zigbee_data: 'aaa', 'data': {state: 1, state_0: 0}}
     handleZigbeeData(chip, configById, matchZigbeeConfigValue[1], payloadData);
   }
+
+  const matchThirdPartyConfigValue = topic.match(/third_party\/(.+)\/data/);
+  if (matchThirdPartyConfigValue) {
+    // ThirdParty
+    // topic: eoh/chip/code-123/third_party/UID-123/data
+    // payload: {state: 1, temperature: 27.6}
+    handleThirdPartyData(
+      chip,
+      configById,
+      matchThirdPartyConfigValue[1],
+      payloadData
+    );
+  }
 };

package/src/navigations/UnitStack.js

@@ -60,6 +60,7 @@ import TDSGuide from '../screens/TDSGuide';
 import ChooseLocation from '../screens/Unit/ChooseLocation';
 import UnitDetail from '../screens/Unit/Detail';
 import ManageUnit from '../screens/Unit/ManageUnit';
+import GoToDetailUnit from '../screens/Unit/GoToDetailUnit';
 import SelectAddress from '../screens/Unit/SelectAddress';
 import SelectAddToFavorites from '../screens/Unit/SelectAddToFavorites';
 import ListSmartAccount from '../screens/Unit/SmartAccount';
@@ -124,6 +125,19 @@ export const UnitStack = memo((props) => {
   }, [isBluetoothEnabled, bluetoothPermGranted, onDeviceFound]);
 
   useEffect(() => {
+    const fetchDashboardDevices = async () => {
+      const id = unitId || unitData?.id;
+      if (!id) {
+        return;
+      }
+      await fetchWithCache(
+        API.UNIT.DASHBOARD_DEVICES(id),
+        {},
+        ({ success, data }) => {
+          success && setAction(Action.SET_DASHBOARD_DEVICES, data);
+        }
+      );
+    };
     const fetchFavoriteDevices = async () => {
       const id = unitId || unitData?.id;
       if (!id) {
@@ -137,6 +151,7 @@ export const UnitStack = memo((props) => {
         }
       );
     };
+    fetchDashboardDevices();
     fetchFavoriteDevices();
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
@@ -209,6 +224,13 @@ export const UnitStack = memo((props) => {
           headerShown: false,
         }}
       />
+      <Stack.Screen
+        name={Route.GoToDetailUnit}
+        component={GoToDetailUnit}
+        options={{
+          headerShown: false,
+        }}
+      />
       <Stack.Screen
         name={Route.ListSmartAccount}
         component={ListSmartAccount}

package/src/screens/Device/__test__/detail.test.js

@@ -661,6 +661,47 @@ describe('test DeviceDetail', () => {
     expect(menu.props.isVisible).toBe(true);
   });
 
+  it('Add device to Dashboard', async () => {
+    const sensor = route?.params?.sensorData;
+    mock.onPost(API.DEVICE.ADD_TO_DASHBOARD(sensor.id)).reply(200);
+
+    await act(async () => {
+      tree = await create(wrapComponent(store, account, route));
+    });
+    const instance = tree.root;
+    const buttonPin = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+        AccessibilityLabel.HEADER_DEVICE_BUTTON_PIN
+    );
+    await act(async () => {
+      await buttonPin.props.onPress();
+    });
+    const urls = mock.history.post.map(({ url }) => url);
+    expect(urls).toContain(API.DEVICE.ADD_TO_DASHBOARD(sensor.id));
+  });
+
+  it('Remove device from Dashboard', async () => {
+    const sensor = route?.params?.sensorData;
+    store.unit.dashboardDeviceIds = [sensor.id];
+    mock.onPost(API.DEVICE.REMOVE_FROM_DASHBOARD(sensor.id)).reply(200);
+
+    await act(async () => {
+      tree = await create(wrapComponent(store, account, route));
+    });
+    const instance = tree.root;
+    const buttonPin = instance.find(
+      (el) =>
+        el.props.accessibilityLabel ===
+        AccessibilityLabel.HEADER_DEVICE_BUTTON_PIN
+    );
+    await act(async () => {
+      await buttonPin.props.onPress();
+    });
+    const urls = mock.history.post.map(({ url }) => url);
+    expect(urls).toContain(API.DEVICE.REMOVE_FROM_DASHBOARD(sensor.id));
+  });
+
   it('Add device to Favourites', async () => {
     const sensor = route?.params?.sensorData;
     sensor.is_favourite = false;
@@ -733,7 +774,7 @@ describe('test DeviceDetail', () => {
     });
     const instance = tree.root;
     const menu = instance.findByType(MenuActionMore);
-    const gotoActivityLog = menu.props.listMenuItem[1];
+    const gotoActivityLog = menu.props.listMenuItem[2];
 
     await act(async () => {
       await menu.props.onItemClick(gotoActivityLog);