ipanel-rnapp-ajb-base 1.0.0

package/app/hooks/useAddress2.js

@@ -0,0 +1,587 @@
+import {useCallback, useEffect, useMemo, useState} from 'react';
+
+import {
+  getAddressRooms,
+  getAddrInfo,
+  getDeviceList,
+  getRoomDeviceStatuses,
+  getSceneModes,
+  getDeviceGroupList,
+} from '../api';
+
+import storage from '../storage';
+import eventBus, {EVENTS} from '../eventBus';
+import {uniqBy} from 'lodash';
+
+let roomDeviceChange = false;
+let roomDeviceStatusChange = false;
+let roomGroupChange = false;
+let roomSceneChange = false;
+
+const Hook = () => {
+  const [addressList, setAddressList] = useState([]);
+  const [activeAddr, setActiveAddr] = useState({});
+  const [roomDeviceMap, setRoomDeviceMap] = useState({});
+  // 每个房间的设备状态映射
+  const [addressRoomMap, setAddressRoomMap] = useState({});
+  const [roomsDeviceStatusMap, setRoomsDeviceStatusMap] = useState({});
+  const [roomGroupMap, setRoomGroupMap] = useState({});
+  const [roomSceneMap, setRoomSceneMap] = useState({});
+  const [roomList, setRoomList] = useState([]);
+
+  // 从本地存储中更新到当前组件内存
+  async function updateAddrFromStorage() {
+    // todo 数据超时更新
+    const addrList = await storage.get('addressList');
+    const addr = await storage.get('activeAddr');
+    setAddressList(addrList || []);
+    setActiveAddr(addr || {});
+  }
+
+  const updateAddrList = async addrList => {
+    await storage.set('addressList', addrList);
+    setAddressList(addrList);
+
+    const oldActiveAddr = await storage.get('activeAddr');
+    const newActiveAddr = addrList.find(
+      addr => oldActiveAddr && addr.address_id === oldActiveAddr.address_id,
+    );
+
+    if (newActiveAddr) {
+      updateActiveAddr(newActiveAddr);
+      return newActiveAddr;
+    } else {
+      const defaultAddr = addrList[0] ? addrList[0] : {};
+      eventBus.emit(EVENTS.FAMILY.CHANGE, defaultAddr);
+      updateActiveAddr(defaultAddr);
+      return defaultAddr;
+    }
+  };
+
+  const updateActiveAddr = addr => {
+    setActiveAddr(addr);
+    storage.set('activeAddr', addr);
+  };
+
+  const mapModel = (brand, model) => {
+    /* 兼容存量 start */
+    if (brand === 'SQ' && model === 'Flight') {
+      return 'FLI17131';
+    }
+    if (brand === 'YGZM' && model === 'Tlight') {
+      return 'DLI19121';
+    }
+    if (brand === 'YHWL' && model === 'Tlight') {
+      return 'DLIIP121';
+    }
+    if (brand === 'YHWL' && model === 'SIL500B1') {
+      return 'SLIIP121';
+    }
+    if (brand === 'dooya' && model === 'ELCEC001') {
+      return 'ELC22011';
+    }
+    if (brand === 'YHWL' && model === 'Dlight') {
+      return 'DLIIP121';
+    }
+    if (brand === 'merach' && model === 'IRMIR101') {
+      return 'IRM24101';
+    }
+    if (brand === 'merach' && model === 'ISR12071') {
+      return 'ISR24101';
+    }
+    /* 兼容存量 end */
+
+    return model;
+  };
+
+  const mapAddrList = addrList => {
+    addrList.forEach(address => {
+      const roomlist = address.room_list || [];
+      roomlist.forEach(room => {
+        const deviceList = room.device_list || [];
+        deviceList.forEach(device => {
+          device.extend.model = mapModel(
+            device.extend?.brand,
+            device.extend?.model,
+          );
+        });
+      });
+    });
+  };
+
+  // 从网络更新到本地存储和内存
+  const updateAddrFromNetwork = useCallback(async () => {
+    try {
+      const res = await getAddrInfo({detail: false});
+      const addrList = res?.result?.address_list || [];
+      mapAddrList(addrList);
+      const newActiveAddr = await updateAddrList(addrList);
+      return {
+        addrList,
+        newActiveAddr,
+      };
+    } catch (e) {
+      console.log('房间数据拉取失败');
+      throw e;
+    }
+  }, []);
+
+  useEffect(() => {
+    // updateAddrFromStorage();
+
+    // 监听用户家庭切换事件
+    eventBus.on(EVENTS.FAMILY.CHANGE, updateActiveAddr);
+
+    return () => {
+      eventBus.off(EVENTS.FAMILY.CHANGE, updateActiveAddr);
+    };
+  }, []);
+
+  const getRoomList = useCallback(async address_id => {
+    const res = await getAddressRooms({
+      address_id,
+    }).catch(err => {});
+    if (res.code === 0) {
+      return res.result.room_list || [];
+    }
+    return [];
+  }, []);
+
+  const getRoomDeviceList = useCallback(async room_id => {
+    const res = await getDeviceList({
+      room_id,
+    }).catch(err => {
+      console.log(err, 'getDeviceList');
+    });
+    if (res?.code === 0) {
+      return res.result || [];
+    }
+    return [];
+  }, []);
+
+  /**
+   * 更新房间设备
+   * @param room_id
+   * @param force
+   * @returns {Promise<boolean|*[]>}
+   */
+  const updateRoomDevice = async (room_id, force) => {
+    if (roomDeviceMap[room_id] && !force) {
+      return false;
+    }
+    console.log('刷新设备');
+    roomDeviceChange = true;
+    const res = await getDeviceList({
+      room_id,
+    }).catch(err => {
+      console.log(err, 'getDeviceList');
+    });
+    if (res?.code === 0) {
+      return res.result || [];
+    }
+    return [];
+  };
+
+  /**
+   * 更新房间设备状态
+   * @param room_id
+   * @param force
+   * @returns {Promise<{}|boolean|*>}
+   */
+  const updateDeviceStatuses = async (room_id, force) => {
+    if (roomsDeviceStatusMap[room_id] && !force) {
+      return false;
+    }
+    console.log('刷新房间设备状态');
+    roomDeviceStatusChange = true;
+    const res = await getRoomDeviceStatuses({room_id}).catch(err => {
+      console.log(err, 'getRoomDeviceStatuses');
+    });
+    if (res?.code === 0) {
+      return res.result;
+    } else {
+      return {};
+    }
+  };
+
+  /**
+   * 更新房间设备分组
+   * @param room_id
+   * @param force
+   * @returns {Promise<(*&{extend: *&{model: string|*}, on: boolean, status: {color: number, bright: number}})[]|boolean|*[]>}
+   */
+  const updateDeviceGroup = async (room_id, force) => {
+    if (room_id === 'all') {
+      return;
+    }
+    if (roomGroupMap[room_id] && !force) {
+      return false;
+    }
+    console.log('刷新房间分组');
+    roomGroupChange = true;
+    const res = await getDeviceGroupList({
+      room_id,
+    });
+    if (res.code === 0) {
+      const data = (res.result || []).map(item => {
+        return {
+          ...item,
+          extend: {
+            ...item.extend,
+            model: mapModel(item.extend?.brand, item.extend?.model),
+          },
+          on: false,
+          status: {
+            bright: 50,
+            color: 50,
+          },
+        };
+      });
+      return data;
+    } else {
+      return [];
+    }
+  };
+
+  /**
+   * 更新房间场景
+   * @param room_id
+   * @param force
+   * @returns {Promise<boolean|*[]>}
+   */
+  const updateRoomScene = async (room_id, force) => {
+    if (room_id === 'all') {
+      return;
+    }
+    if (roomSceneMap[room_id] && !force) {
+      return false;
+    }
+    console.log('刷新房间场景');
+    roomSceneChange = true;
+    const res = await getSceneModes({
+      userbins_id: 1,
+      room_id,
+    });
+    if (res.code === 0) {
+      const data = res.result || [];
+      if (data.length % 2 !== 0) {
+        data.push(null);
+      }
+      return data;
+    } else {
+      return [];
+    }
+  };
+
+  /**
+   *
+   * @param refreshAddress
+   * @param addressId
+   * @param refreshRoom 是否刷新房间列表
+   * @param roomId 当前房间
+   * @param force 是否强制刷新房间数据
+   * @param refreshDevice 是否刷新房间设备
+   * @param refreshDeviceStatus
+   * @param refreshDeviceGroup
+   * @param refreshDeviceScene
+   * @param rooms 需要刷新数据的房间id列表
+   * @returns {Promise<void>}
+   */
+  const updateDataFromNetwork = async ({
+    refreshAddress,
+    refreshRoom,
+    roomId,
+    force,
+    refreshDevice,
+    refreshDeviceStatus,
+    refreshDeviceGroup,
+    refreshDeviceScene,
+    rooms = [],
+    defaultData,
+  }) => {
+    let queryRooms = uniqBy([...rooms], 'room_id');
+    roomDeviceChange = false;
+    roomDeviceStatusChange = false;
+    roomGroupChange = false;
+    roomSceneChange = false;
+
+    // 获取家庭列表和选中家庭
+    const oldActiveAddr = await storage.get('activeAddr');
+    let actualActiveAddr = oldActiveAddr || {}; // 实际选中家庭
+    let addrList = [];
+    if (refreshAddress) {
+      const addrInfoRes = await getAddrInfo({detail: false}).catch(err => {
+        console.log(err, 'getAddrInfo');
+      });
+      addrList = addrInfoRes?.result?.address_list || [];
+      await storage.set('addressList', addrList);
+      const newActiveAddr = addrList.find(
+        addr => oldActiveAddr && addr.address_id === oldActiveAddr.address_id,
+      );
+      if (newActiveAddr) {
+        actualActiveAddr = newActiveAddr;
+      } else if (addrList.length > 0) {
+        actualActiveAddr = addrList[0];
+      }
+      await storage.set('activeAddr', actualActiveAddr || {});
+    }
+
+    // 获取家庭下房间列表
+    let actualActiveRoomIndex;
+    let newAddressRoomMap = {};
+    let roomlist = [];
+    if (refreshRoom && actualActiveAddr) {
+      const room_list = await getRoomList(actualActiveAddr.address_id);
+      if (room_list.length > 0) {
+        roomlist.unshift({room_name: '全屋', room_id: 'all'});
+        roomlist = [{room_name: '全屋', room_id: 'all'}, ...room_list];
+      }
+      const oldAddressRoomMap = global.base.addressRoomMap;
+      newAddressRoomMap = oldAddressRoomMap || {};
+      console.log(room_list, 'updateDataFromNetwork');
+      newAddressRoomMap[actualActiveAddr.address_id] = room_list;
+      global.base.addressRoomMap = newAddressRoomMap;
+      const newActiveRoomIndex = roomlist.findIndex(
+        room => room.room_id === roomId,
+      );
+      if (newActiveRoomIndex === -1) {
+        actualActiveRoomIndex = 1;
+      } else {
+        actualActiveRoomIndex = newActiveRoomIndex;
+      }
+
+      if (
+        actualActiveRoomIndex !== 0 &&
+        queryRooms.findIndex(
+          room => room.room_id === roomlist[actualActiveRoomIndex].room_id,
+        ) === -1
+      ) {
+        queryRooms.push(roomlist[actualActiveRoomIndex]);
+      }
+
+      if (roomId === 'all') {
+        queryRooms = [...roomlist.slice(1)];
+      }
+    }
+
+    // 获取房间设备
+    let newRoomDeviceMap = {};
+    if (refreshDevice) {
+      const allRoomDeviceList = await Promise.all(
+        queryRooms.map(room => {
+          return updateRoomDevice(room.room_id, force).catch(err => {});
+        }),
+      );
+      const oldRoomDeviceMap = global.base.roomDeviceMap;
+      newRoomDeviceMap = oldRoomDeviceMap || {};
+      queryRooms.forEach((room, index) => {
+        if (allRoomDeviceList[index]) {
+          newRoomDeviceMap[room.room_id] = allRoomDeviceList[index];
+        }
+      });
+      global.base.roomDeviceMap = newRoomDeviceMap;
+    }
+
+    // 获取房间设备状态
+    let newRoomDeviceStatusMap = {};
+    if (refreshDeviceStatus) {
+      const allRoomDeviceStatus = await Promise.all(
+        queryRooms.map(room => {
+          return updateDeviceStatuses(room.room_id, force).catch(err => {});
+        }),
+      );
+      const oldRoomDeviceStatusMap = global.base.roomDeviceStatusMap;
+      newRoomDeviceStatusMap = oldRoomDeviceStatusMap || {};
+      queryRooms.forEach((room, index) => {
+        if (allRoomDeviceStatus[index]) {
+          newRoomDeviceStatusMap[room.room_id] = allRoomDeviceStatus[index];
+        }
+      });
+      global.base.roomDeviceStatusMap = newRoomDeviceStatusMap;
+    }
+
+    // 获取房间设备分组
+    let newRoomDeviceGroupMap = {};
+    if (refreshDeviceGroup) {
+      const allRoomDeviceGroup = await Promise.all(
+        queryRooms.map(room => {
+          return updateDeviceGroup(room.room_id, force).catch(err => {});
+        }),
+      );
+
+      const oldRoomDeviceGroupMap = global.base.roomDeviceGroupMap;
+      newRoomDeviceGroupMap = oldRoomDeviceGroupMap || {};
+      queryRooms.forEach((room, index) => {
+        if (allRoomDeviceGroup[index]) {
+          newRoomDeviceGroupMap[room.room_id] = allRoomDeviceGroup[index];
+        }
+      });
+      global.base.roomDeviceGroupMap = newRoomDeviceGroupMap;
+    }
+
+    // 获取房间设备场景
+    let newRoomDeviceSceneMap = {};
+    if (refreshDeviceScene) {
+      const allRoomDeviceScene = await Promise.all(
+        queryRooms.map(room => {
+          return updateRoomScene(room.room_id, force).catch(err => {});
+        }),
+      );
+      const oldRoomDeviceSceneMap = global.base.roomDeviceSceneMap;
+      newRoomDeviceSceneMap = oldRoomDeviceSceneMap || {};
+      queryRooms.forEach((room, index) => {
+        if (allRoomDeviceScene[index]) {
+          newRoomDeviceSceneMap[room.room_id] = allRoomDeviceScene[index];
+        }
+      });
+      global.base.roomDeviceSceneMap = newRoomDeviceSceneMap;
+    }
+
+    if (refreshAddress) {
+      setAddressList(addrList);
+      if (actualActiveAddr.address_id !== activeAddr.address_id) {
+        eventBus.emit(EVENTS.FAMILY.CHANGE, actualActiveAddr);
+      }
+    }
+
+    if (refreshRoom && actualActiveAddr) {
+      setAddressRoomMap({
+        ...newAddressRoomMap,
+      });
+      setRoomList(roomlist);
+    }
+
+    if (roomDeviceChange || defaultData?.roomDeviceMap) {
+      setRoomDeviceMap({
+        ...defaultData?.roomDeviceMap,
+        ...newRoomDeviceMap,
+      });
+    }
+
+    if (roomDeviceStatusChange) {
+      setRoomsDeviceStatusMap({
+        ...newRoomDeviceStatusMap,
+      });
+    }
+
+    if (roomGroupChange) {
+      setRoomGroupMap({
+        ...newRoomDeviceGroupMap,
+      });
+    }
+
+    if (roomSceneChange) {
+      setRoomSceneMap({
+        ...newRoomDeviceSceneMap,
+      });
+    }
+
+    // return {
+    //   roomList,
+    //   roomIndex: actualActiveRoomIndex,
+    // };
+  };
+
+  const updateRoomDataFromStorage = async ({
+    refreshAddress,
+    refreshRoom,
+    refreshDevice,
+    refreshDeviceStatus,
+    refreshDeviceGroup,
+    refreshDeviceScene,
+  }) => {
+    const addrList = await storage.get('addressList');
+    const addr = await storage.get('activeAddr');
+    const newAddressRoomMap = global.base.addressRoomMap;
+    const newRoomDeviceMap = global.base.roomDeviceMap;
+    const newRoomDeviceStatusMap = global.base.roomDeviceStatusMap;
+    const newRoomDeviceGroupMap = global.base.roomDeviceGroupMap;
+    const newRoomDeviceSceneMap = global.base.roomDeviceSceneMap;
+    if (refreshAddress) {
+      setAddressList(addrList || []);
+      setActiveAddr(addr || {});
+    }
+    if (refreshRoom) {
+      setAddressRoomMap(newAddressRoomMap || {});
+      if (newAddressRoomMap && addr) {
+        const room_list = newAddressRoomMap[addr.address_id] || [];
+        console.log(room_list, 'room_list');
+        setRoomList(
+          room_list.length > 0
+            ? [{room_name: '全屋', room_id: 'all'}].concat(room_list)
+            : [],
+        );
+      }
+    }
+    if (refreshDevice) {
+      setRoomDeviceMap(newRoomDeviceMap || {});
+    }
+    if (refreshDeviceStatus) {
+      setRoomsDeviceStatusMap(newRoomDeviceStatusMap || {});
+    }
+    if (refreshDeviceGroup) {
+      setRoomGroupMap(newRoomDeviceGroupMap || {});
+    }
+    if (refreshDeviceScene) {
+      setRoomSceneMap(newRoomDeviceSceneMap || {});
+    }
+  };
+
+  const currentRoomList = useMemo(() => {
+    return roomList.slice(1);
+  }, [roomList]);
+
+  // 更新所有家庭
+  const updateAllRoomFromNetwork = async () => {
+    const res = await getAddrInfo().catch(err => {});
+    const addrList = res?.result?.address_list || [];
+    const newAddressRoomMap = {};
+    const newRoomDeviceMap = {};
+    addrList.forEach(addr => {
+      const room_list = addr.room_list || [];
+      newAddressRoomMap[addr.address_id] = room_list.map(room => {
+        newRoomDeviceMap[room.room_id] = room.device_list || [];
+        return {
+          ...room,
+          device_list: undefined,
+        };
+      });
+    });
+    const newAddrList = addrList.map(addr => {
+      return {
+        ...addr,
+        room_list: undefined,
+      };
+    });
+    await storage.set('addressList', newAddrList);
+    global.base.addressRoomMap = newAddressRoomMap;
+    global.base.roomDeviceMap = newRoomDeviceMap;
+    setAddressList(newAddrList);
+    setAddressRoomMap(newAddressRoomMap);
+    setRoomDeviceMap(newRoomDeviceMap);
+  };
+
+  return {
+    addressList,
+    activeAddr,
+    setActiveAddr,
+    updateAllRoomFromNetwork,
+    updateDataFromNetwork,
+    updateRoomDataFromStorage,
+    updateAddrFromNetwork,
+    updateAddrFromStorage,
+    getRoomList,
+    getRoomDeviceList,
+    roomList,
+    currentRoomList,
+    addressRoomMap,
+    roomDeviceMap,
+    roomsDeviceStatusMap,
+    setRoomsDeviceStatusMap,
+    roomGroupMap,
+    setRoomGroupMap,
+    roomSceneMap,
+  };
+};
+
+export default Hook;

package/app/hooks/useDebounceFn.js

@@ -0,0 +1,6 @@
+import {useCallback} from 'react';
+import {debounce} from 'lodash';
+
+export default (fn, wait = 500) => {
+  return useCallback(debounce(fn, wait), []);
+};

package/app/hooks/useDynamicPackages.js

@@ -0,0 +1,22 @@
+import React, {useState, useCallback} from 'react';
+
+const useDynamicPackages = () => {
+  const [DynamicStackScreens, setDynamicScreens] = useState({});
+
+  const initEvent = useCallback(() => {
+    const addDynamicScreens = screens => {
+      setDynamicScreens({
+        ...DynamicStackScreens,
+        ...screens,
+      });
+    };
+    global.base.eventBus.removeAllListeners('addDynamicScreens');
+    global.base.eventBus.addListener('addDynamicScreens', addDynamicScreens);
+  }, [DynamicStackScreens]);
+
+  initEvent();
+
+  return {DynamicStackScreens};
+};
+
+export default useDynamicPackages;

package/app/hooks/useKeyboard.js

@@ -0,0 +1,25 @@
+import {useEffect, useState} from 'react';
+import {Keyboard} from 'react-native';
+
+export default () => {
+  const [keyboardShow, setKeyboardShow] = useState(false);
+
+  useEffect(() => {
+    const keyboardDidShow = Keyboard.addListener('keyboardDidShow', () => {
+      console.log('keyboardWillShow');
+      setKeyboardShow(true);
+    });
+    const keyboardDidHide = Keyboard.addListener('keyboardDidHide', () => {
+      console.log('keyboardDidHide');
+      setKeyboardShow(false);
+    });
+
+    return () => {
+      keyboardDidShow.remove();
+      keyboardDidHide.remove();
+    };
+  }, []);
+  return {
+    keyboardShow,
+  };
+};

package/app/hooks/useLatest.js

@@ -0,0 +1,10 @@
+import {useRef} from 'react';
+
+function useLatest(value) {
+  const ref = useRef(value);
+  ref.current = value;
+
+  return ref;
+}
+
+export default useLatest;