@eohjsc/react-native-smart-city 0.7.27 → 0.7.31

package/src/hooks/Review/useInAppReview.js

@@ -0,0 +1,70 @@
+import { useIsFocused } from '@react-navigation/native';
+import { useCallback, useEffect } from 'react';
+import InAppReview from 'react-native-in-app-review';
+
+import { getObject, storeObject } from '../../utils/Storage';
+
+const KEY_CACHE = 'in_app_review';
+
+const TRIGGER_LIMIT = 10;
+const MAX_PROMPTS = 3;
+const INTERVAL_RETRY = 3 * 24 * 3600 * 1000;
+
+const useInAppReview = (ask, onFailed) => {
+  const isFocused = useIsFocused();
+
+  const allowInAppReview = useCallback(async () => {
+    const review = await getObject(KEY_CACHE, {});
+    await storeObject(KEY_CACHE, { ...review, allow: true });
+  }, []);
+
+  const incrementReviewTrigger = useCallback(async () => {
+    const review = await getObject(KEY_CACHE, {});
+    const trigger = (review.trigger ?? 0) + 1;
+    await storeObject(KEY_CACHE, {
+      ...review,
+      allow: trigger >= TRIGGER_LIMIT,
+      trigger,
+    });
+  }, []);
+
+  const askReview = useCallback(async () => {
+    const now = Date.now();
+    const review = await getObject(KEY_CACHE, {});
+    const { allow = false, count = 0, last = 0 } = review;
+    if (!allow || count >= MAX_PROMPTS || now - last < INTERVAL_RETRY) {
+      return false;
+    }
+
+    await storeObject(KEY_CACHE, {
+      ...review,
+      count: count + 1,
+      last: now,
+    });
+
+    if (!InAppReview.isAvailable()) {
+      onFailed && onFailed();
+      return false;
+    }
+
+    try {
+      await InAppReview.RequestInAppReview();
+      return true;
+    } catch {
+      onFailed && onFailed();
+      return false;
+    }
+  }, [onFailed]);
+
+  useEffect(() => {
+    ask && isFocused && askReview();
+  }, [ask, isFocused, askReview]);
+
+  return {
+    allowInAppReview,
+    askReview,
+    incrementReviewTrigger,
+  };
+};
+
+export default useInAppReview;

package/src/hooks/useMqtt.js

@@ -1,12 +1,36 @@
 import mqtt from 'precompiled-mqtt/dist/mqtt.browser';
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useContext, useEffect, useMemo, useState } from 'react';
 
 import API from '../configs/API';
+import { SCContext } from '../context';
+import { Action } from '../context/actionType';
 import { handleMqttMessage } from '../iot/mqtt';
 import { axiosGet } from '../utils/Apis/axios';
+import { getConfigsById } from '../utils/store';
 
-const useChipJsonConfiguration = (dashboardId) => {
+export const mqttClientsPool = new Map();
+
+const useChipJsonConfiguration = ({ dashboardId, ready = true }) => {
+  const { setAction } = useContext(SCContext);
   const [chips, setChips] = useState([]);
+  const [isFetching, setIsFetching] = useState(true);
+
+  const handleUpdateConfigsById = useCallback(
+    (listChip) => {
+      const configsById = listChip.reduce((acc, chip) => {
+        chip.sensors.forEach((sensor) => {
+          sensor.configs.forEach((config) => {
+            acc[config.id] = config;
+          });
+        });
+        return acc;
+      }, {});
+      setAction(Action.UPDATE_CONFIGS_BY_ID, configsById);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+
   // get chip data
   useEffect(() => {
     const getGateways = async () => {
@@ -17,49 +41,54 @@ const useChipJsonConfiguration = (dashboardId) => {
       });
       if (success) {
         setChips(data);
+        handleUpdateConfigsById(data);
       }
+      setIsFetching(false);
     };
-    getGateways();
-  }, [dashboardId]);
+    ready && getGateways();
+  }, [dashboardId, ready, handleUpdateConfigsById]);
 
   return {
     chips,
+    isFetching,
   };
 };
 
 export const connectMqttServer = (mqttServer, code) => {
-  const { websocket_host, websocket_port } = mqttServer;
-  const client = mqtt.connect(`wss://${websocket_host}:${websocket_port}`, {
-    username: code,
-    password: code,
-  });
+  const { websocket_host, websocket_port, is_wss = true } = mqttServer;
+  const client = mqtt.connect(
+    `ws${is_wss ? 's' : ''}://${websocket_host}:${websocket_port}`,
+    {
+      username: code,
+      password: code,
+    }
+  );
   return client;
 };
 
 const connectChipMqtt = (chip) => {
-  const configById = {};
   const { code, mqtt_server } = chip;
+  let currentChip = chip;
 
   const client = connectMqttServer(mqtt_server, code);
 
-  (chip?.sensors).forEach((sensor) => {
-    (sensor?.configs).forEach((config) => {
-      configById[config.id] = config;
-    });
-  });
-
   client.on('connect', () => {
     client.subscribe(`eoh/chip/${code}/#`);
   });
   client.on('message', (topic, payload, packet) => {
     try {
+      const configsById = getConfigsById();
       const payloadObject = JSON.parse(payload.toString());
-      handleMqttMessage(topic, payloadObject, code, chip, configById);
+      handleMqttMessage(topic, payloadObject, code, currentChip, configsById);
       // eslint-disable-next-line no-empty
     } catch {}
   });
 
-  return client;
+  const updateChip = (newChip) => {
+    currentChip = newChip;
+  };
+
+  return { client, updateChip };
 };
 
 export const useConnectChipMqtt = (chips) => {
@@ -69,31 +98,53 @@ export const useConnectChipMqtt = (chips) => {
   );
 
   const mqttConfigs = useMemo(() => {
-    let configById = {};
+    let configsById = {};
 
     mqttChips.forEach((chip) => {
       chip?.sensors.forEach((sensor) => {
         sensor?.configs.forEach((config) => {
-          configById[config.id] = config;
+          configsById[config.id] = config;
         });
       });
     });
 
-    return configById;
+    return configsById;
   }, [mqttChips]);
 
-  const mqttClientsRef = useRef([]);
   useEffect(() => {
     mqttChips.forEach((chip) => {
-      const client = connectChipMqtt(chip);
-      mqttClientsRef.current.push(client);
+      let pool = mqttClientsPool.get(chip.id);
+      if (!pool) {
+        const { client, updateChip } = connectChipMqtt(chip);
+        pool = { client, updateChip, count: 0, timer: null };
+        mqttClientsPool.set(chip.id, pool);
+      } else {
+        pool.updateChip(chip);
+      }
+      if (pool.timer) {
+        clearTimeout(pool.timer);
+        pool.timer = null;
+      }
+      pool.count += 1;
     });
 
     return () => {
-      mqttClientsRef.current.forEach((client) => {
-        client && client.end();
+      mqttChips.forEach((chip) => {
+        const pool = mqttClientsPool.get(chip.id);
+        if (!pool) {
+          return;
+        }
+        pool.count -= 1;
+        if (pool.count) {
+          return;
+        }
+
+        pool.timer = setTimeout(() => {
+          const latest = mqttClientsPool.get(chip.id);
+          latest?.client?.end();
+          mqttClientsPool.delete(chip.id);
+        }, 1000);
       });
-      mqttClientsRef.current = [];
     };
   }, [mqttChips]);
 

package/src/iot/Monitor.js

@@ -1,18 +1,28 @@
-import { API } from '../configs';
-import { getConfigGlobalState, setConfigGlobalState } from './states';
 import _ from 'lodash';
 import Pusher from 'pusher-js/react-native';
 import PusherBatchAuthorizer from 'pusher-js-auth';
-import { axiosPost } from '../utils/Apis/axios';
+import { API } from '../configs';
 import { SCConfig } from '../configs';
-import api from '../utils/Apis/axios';
+import { WATCH_DATA_CHIP_TYPE } from '../configs/Constants';
+import api, { axiosPost } from '../utils/Apis/axios';
+import { getConfigsById, getSharedChipsById } from '../utils/store';
+
+import { updateGlobalValues } from './UpdateStates';
+import {
+  handleChipData,
+  handleModbusData,
+  handleZigbeeData,
+  handleThirdPartyData,
+  handleSelfSensorData,
+} from './mqtt';
 
 Pusher.logToConsole = true;
-let pusher = null;
+const pusherMap = new Map();
 
-const getPusher = () => {
-  if (!pusher) {
-    pusher = new Pusher(SCConfig.pusherAppKey, {
+const getPusher = (watch_type) => {
+  watch_type = watch_type || 'config';
+  if (!pusherMap.has(watch_type)) {
+    const pusher = new Pusher(SCConfig.pusherAppKey, {
       cluster: 'ap1',
       authorizer: PusherBatchAuthorizer,
       authEndpoint: SCConfig.apiRoot + API.IOT.CHIP_MANAGER.PUSHER_AUTH(),
@@ -22,24 +32,29 @@ const getPusher = () => {
           Accept: 'application/json',
           Authorization: api.headers.Authorization,
         },
+        params: { watch_type },
       },
     });
+    pusherMap.set(watch_type, pusher);
   }
-  return pusher;
+  return pusherMap.get(watch_type);
 };
 
-const destroyPusher = () => {
-  pusher.disconnect();
-  pusher = null;
+const destroyPusher = (watch_type) => {
+  const pusher = pusherMap.get(watch_type);
+  if (pusher) {
+    pusher.disconnect();
+    pusherMap.delete(watch_type);
+  }
 };
 
 const watchingConfigs = {};
+const CHANNEL_CONFIG = 'private-config_v2';
+
+const updateConfigValue = (configId, value) => {
+  const configsById = getConfigsById();
 
-export const updateGlobalValue = (configId, value) => {
-  const configValues = getConfigGlobalState('configValues');
-  let newConfigValues = { ...configValues };
-  newConfigValues[configId] = value;
-  setConfigGlobalState('configValues', newConfigValues);
+  handleChipData(configsById, configId, { v: value.value }, value.last_updated);
 };
 
 const watchConfig = (configId) => {
@@ -48,8 +63,10 @@ const watchConfig = (configId) => {
     return;
   }
   watchingConfigs[configId] = 1;
-  const channel = getPusher().subscribe(`private-config_v2-${configId}`);
-  channel.bind('new-value', updateGlobalValue.bind(channel, configId));
+  const channel = getPusher('config').subscribe(
+    `${CHANNEL_CONFIG}-${configId}`
+  );
+  channel.bind('new-raw', updateConfigValue.bind(channel, configId));
 };
 
 const unwatchConfig = (configId) => {
@@ -59,9 +76,9 @@ const unwatchConfig = (configId) => {
   watchingConfigs[configId] -= 1;
   if (!watchingConfigs[configId]) {
     delete watchingConfigs[configId];
-    getPusher().unsubscribe(`private-config_v2-${configId}`);
+    getPusher('config').unsubscribe(`${CHANNEL_CONFIG}-${configId}`);
     if (_.isEmpty(watchingConfigs)) {
-      destroyPusher();
+      destroyPusher('config');
     }
   }
 };
@@ -90,15 +107,15 @@ export const realWatchMultiConfigs = async (configIds) => {
     API.IOT.CHIP_MANAGER.WATCH_CONFIGS(),
     {
       configs: configIds,
+      is_raw: true,
     }
   );
   if (success) {
-    const configValues = getConfigGlobalState('configValues');
-    const newConfigValues = { ...configValues, ...data };
-    setConfigGlobalState('configValues', newConfigValues);
-    for (const configId in data) {
+    updateGlobalValues(data);
+
+    Object.keys(data).forEach((configId) => {
       watchConfig(configId);
-    }
+    });
   }
 };
 
@@ -111,3 +128,109 @@ export const unwatchAllConfigs = async () => {
     await unwatchMultiConfigs(Object.keys(watchingConfigs));
   }
 };
+
+// WATCH DATA CHIP
+const watchingDataChips = {};
+const CHANNEL_DATA_CHIP = 'private-data';
+
+const updateDataChip = (chipId, value) => {
+  const configsById = getConfigsById();
+  const chip = getSharedChipsById()[chipId];
+
+  const { type, data = {} } = value;
+
+  switch (type) {
+    case WATCH_DATA_CHIP_TYPE.MODBUS:
+      data.data &&
+        handleModbusData(chip, configsById, data.data, data.last_updated);
+      break;
+    case WATCH_DATA_CHIP_TYPE.ZIGBEE:
+      Object.keys(data).forEach((key) => {
+        handleZigbeeData(
+          chip,
+          configsById,
+          key,
+          data[key],
+          data[key].last_updated
+        );
+      });
+      break;
+    case WATCH_DATA_CHIP_TYPE.THIRD_PARTY:
+      Object.keys(data).forEach((key) => {
+        handleThirdPartyData(
+          chip,
+          configsById,
+          key,
+          data[key],
+          data[key].last_updated
+        );
+      });
+      break;
+    case WATCH_DATA_CHIP_TYPE.SELF:
+      handleSelfSensorData(chip, configsById, data, data.last_updated);
+      break;
+    /* istanbul ignore next */
+    default:
+      break;
+  }
+};
+
+const watchDataChip = async (chipId) => {
+  if (watchingDataChips[chipId]) {
+    watchingDataChips[chipId] += 1;
+    return;
+  }
+  watchingDataChips[chipId] = 1;
+  const channel = getPusher('data').subscribe(`${CHANNEL_DATA_CHIP}-${chipId}`);
+  channel.bind('new-data', updateDataChip.bind(channel, chipId));
+};
+
+export const watchMultiDataChips = async (chipIds) => {
+  const { success, data } = await axiosPost(
+    API.IOT.CHIP_MANAGER.WATCH_DATA_CHIPS(),
+    {
+      chips: chipIds,
+    }
+  );
+  if (success) {
+    Object.keys(data).forEach((chipId) => {
+      const dataChip = data[chipId];
+      updateDataChip(chipId, {
+        type: WATCH_DATA_CHIP_TYPE.MODBUS,
+        data: dataChip?.last_modbus_data,
+      });
+      updateDataChip(chipId, {
+        type: WATCH_DATA_CHIP_TYPE.ZIGBEE,
+        data: dataChip?.last_zigbee_data,
+      });
+      updateDataChip(chipId, {
+        type: WATCH_DATA_CHIP_TYPE.THIRD_PARTY,
+        data: dataChip?.last_third_party_data,
+      });
+      updateDataChip(chipId, {
+        type: WATCH_DATA_CHIP_TYPE.SELF,
+        data: dataChip?.last_self_data,
+      });
+      watchDataChip(chipId);
+    });
+  }
+};
+
+const unwatchDataChip = (chipId) => {
+  if (!watchingDataChips[chipId]) {
+    return;
+  }
+  watchingDataChips[chipId] -= 1;
+
+  if (!watchingDataChips[chipId]) {
+    delete watchingDataChips[chipId];
+    getPusher('data').unsubscribe(`${CHANNEL_DATA_CHIP}-${chipId}`);
+    if (_.isEmpty(watchingDataChips)) {
+      destroyPusher('data');
+    }
+  }
+};
+
+export const unwatchMultiDataChips = async (chipIds) => {
+  chipIds.map((chipId) => unwatchDataChip(chipId));
+};

package/src/iot/UpdateStates.js

@@ -0,0 +1,60 @@
+import moment from 'moment';
+
+import { getConfigGlobalState, setConfigGlobalState } from './states';
+
+const isNewer = (valueTime, valueMicro, currentTime, currentMicro) => {
+  if (valueTime?.isAfter(currentTime)) {
+    return true;
+  }
+  if (valueTime?.isSame(currentTime)) {
+    return valueMicro > currentMicro;
+  }
+  return false;
+};
+
+export const getLastUpdated = (time) => {
+  let last_updated_micro = 0;
+  if (!time) {
+    return { last_updated: moment(), last_updated_micro };
+  }
+  if (typeof time === 'number') {
+    const millis = time * 1000;
+    last_updated_micro = Math.round((millis - Math.floor(millis)) * 1000);
+    time = Math.floor(millis);
+  } else {
+    const [, fracRaw = ''] = time.split('.');
+    const cleanFrac = fracRaw.replace(/\D/g, '');
+    const frac = cleanFrac.slice(0, 6).padEnd(6, '0');
+    last_updated_micro = parseInt(frac.slice(3), 10);
+  }
+  return { last_updated: moment(time), last_updated_micro };
+};
+
+export const updateGlobalValues = (data) => {
+  Object.keys(data).forEach((key) => {
+    const value = data[key];
+    updateGlobalValue(key, {
+      ...value,
+      ...getLastUpdated(value.last_updated),
+    });
+  });
+};
+
+export const updateGlobalValue = (configId, value) => {
+  const configValues = getConfigGlobalState('configValues');
+  const currentValue = configValues[configId];
+  if (
+    !isNewer(
+      value.last_updated,
+      value.last_updated_micro,
+      currentValue?.last_updated || moment(0),
+      currentValue?.last_updated_micro || 0
+    )
+  ) {
+    return;
+  }
+  setConfigGlobalState('configValues', {
+    ...configValues,
+    [configId]: value,
+  });
+};