2025年04月16日13:19:36

wjc

2025-04-16 134c23aae116f94644d8331c096ff7085e43572b

 app/src/main/java/com/hdl/photovoltaic/other/HdlDeviceLogic.java

@@ -38,6 +38,7 @@

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
@@ -91,44 +92,58 @@
     * 获取当前住宅的逆变器列表(包括从的逆变器)
     *
     * @param homeId                  电站ID
     * @param cloudInverterDeviceList 远端上的逆变器列表（并网，离网，负载中心）
     * @param cloudInverterDeviceList 元端上的逆变器列表（并网，离网，负载中心）
     */
    public List<GatewayBean> getCurrentHomeGatewayList(String homeId, List<CloudInverterDeviceBean> cloudInverterDeviceList) {
        List<GatewayBean> newList = new ArrayList<>();
        List<GatewayBean> list = HDLLinkLocalGateway.getInstance().getGatewayList();
        if (list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                GatewayBean gatewayBean = list.get(i);
                if (!getGatewaySpk().contains(gatewayBean.getGatewayType())) {
                    continue;
                }
                if (TextUtils.isEmpty(gatewayBean.getDevice_mac())
                        || TextUtils.isEmpty(gatewayBean.getSid())
                        || TextUtils.isEmpty(gatewayBean.getOid())) {
                    continue;
                }
                //用homeId筛选当前住宅的逆变器列表
                if (gatewayBean.getHomeId().equals(homeId)) {
                    newList.add(gatewayBean);
                }
            }
        }
        //追加这个条件是因为上面把HDLLinkLocalGateway.getInstance().getGatewayList()列表处理完后,接着搜索局域网又还原列表数据，导致出现旧数据；
        if (cloudInverterDeviceList != null && cloudInverterDeviceList.size() > 0) {
            List<GatewayBean> checkNewList = new ArrayList<>();
            for (int i = 0; i < cloudInverterDeviceList.size(); i++) {
                CloudInverterDeviceBean cloudInverterDevice = cloudInverterDeviceList.get(i);
                for (GatewayBean gatewayBean : newList) {
                    if (cloudInverterDevice.getOsn().equals(gatewayBean.getDevice_mac())) {
                        checkNewList.add(gatewayBean);
                        break;
        try {
            List<GatewayBean> newList = new ArrayList<>();
            //云端有设备列表，HDLLinkLocalGateway.getInstance().getGatewayList()没有，即本地没有，里面会调用refreshGatewayCacheData()方法虚拟一个逆变器实体添加本地列表里面；
            List<GatewayBean> list = HDLLinkLocalGateway.getInstance().getGatewayList();
            if (list.size() > 0) {
                for (int i = 0; i < list.size(); i++) {
                    GatewayBean gatewayBean = list.get(i);
                    if (!getGatewaySpk().contains(gatewayBean.getGatewayType())) {
                        continue;
                    }
                    if (TextUtils.isEmpty(gatewayBean.getDevice_mac())
                            || TextUtils.isEmpty(gatewayBean.getSid())
                            || TextUtils.isEmpty(gatewayBean.getOid())) {
                        continue;
                    }
                    //用homeId筛选当前住宅的逆变器列表
                    if (gatewayBean.getHomeId().equals(homeId)) {
                        newList.add(gatewayBean);
                    }
                }
            }
            newList.clear();
            newList.addAll(checkNewList);
            //有外网，以云端设备列表为准;云端没有，本地存在，则删除本地；否则，没有外网只有局域网，以本地为主,搜索多少个设备就显示多少个
            //追加这个条件是因为上面把HDLLinkLocalGateway.getInstance().getGatewayList()列表处理完后,接着搜索局域网又还原列表数据，导致出现旧数据；
            if (cloudInverterDeviceList != null && cloudInverterDeviceList.size() > 0) {
                List<GatewayBean> checkNewList = new ArrayList<>();
                for (int i = 0; i < cloudInverterDeviceList.size(); i++) {
                    CloudInverterDeviceBean cloudInverterDevice = cloudInverterDeviceList.get(i);
                    for (GatewayBean gatewayBean : newList) {
                        if (cloudInverterDevice.getOsn().equals(gatewayBean.getDevice_mac())) {
                            checkNewList.add(gatewayBean);
                            break;
                        }
                    }
                }
                newList.clear();
                newList.addAll(checkNewList);
            }
//            // 将list2的元素合并到list1的头部
//            List<GatewayBean> mockData = getGatewayDeviceListMockData(3);
//            if (mockData.size() > 0) {
//                for (GatewayBean mockDatum : mockData) {
//                    newList.add(0, mockDatum);
//                }
//            }

            return newList;
        } catch (Exception e) {
            return new ArrayList<>();
        }
        return newList;
    }


@@ -142,7 +157,7 @@
        if (newGatewayBean == null || TextUtils.isEmpty(homeId)) {
            return;
        }
        List<GatewayBean> list = getCurrentHomeGatewayList(homeId,null);
        List<GatewayBean> list = getCurrentHomeGatewayList(homeId, null);
        if (list == null || list.size() == 0) {
            return;
        }
@@ -171,7 +186,7 @@
        if (TextUtils.isEmpty(mac)) {
            return;
        }
        List<GatewayBean> list = getCurrentHomeGatewayList(homeId,null);
        List<GatewayBean> list = getCurrentHomeGatewayList(homeId, null);
        if (list == null || list.size() == 0) {
            return;
        }
@@ -198,7 +213,7 @@
        if (TextUtils.isEmpty(deviceId)) {
            return;
        }
        List<GatewayBean> list = getCurrentHomeGatewayList(homeId,null);
        List<GatewayBean> list = getCurrentHomeGatewayList(homeId, null);
        if (list == null || list.size() == 0) {
            return;
        }
@@ -386,7 +401,7 @@
                                updateOidAdd(homeId, newOidList, new CloudCallBeak<Boolean>() {
                                    @Override
                                    public void onSuccess(Boolean obj) {
                                        HdlLogLogic.print("上传oid列表到云端成功---住宅id:" + homeId + "---mac:" + gatewayBean.getDevice_mac(), true);
                                        HdlLogLogic.print("上传oid列表到云端成功(增量)---住宅id:" + homeId + "---mac:" + gatewayBean.getDevice_mac() + "---\r\n数据---" + new Gson().toJson(oidBeanList), true);
                                    }

                                    @Override
@@ -467,8 +482,16 @@
            public void onSuccess(String str) {
                if (cloudCallBeak != null) {
                    cloudCallBeak.onSuccess(true);
                    //临时的逻辑，上传oid列表到云端
                    List<GatewayBean> list = HdlDeviceLogic.getInstance().getCurrentHomeGatewayList(homeId,null);
                    List<GatewayBean> list = new ArrayList<>();
                    GatewayBean gatewayBean = new GatewayBean();
                    gatewayBean.setHomeId(homeId);
                    gatewayBean.setDevice_mac(mac);
                    gatewayBean.setSpk(spk);
                    gatewayBean.setSid(sid);
                    gatewayBean.setOid(oid);
                    gatewayBean.setDevice_name(name);
                    list.add(gatewayBean);
                    //添加设备成功后，上传oid列表到云端
                    uploadOidDataToCloud(homeId, list, true, null);
                }
            }
@@ -1100,8 +1123,8 @@
    }

    /**
     * 获取逆变器列表(整合云端和本地列表)
     * 注意:有外网，以云端设备为准,本地存在，云端没有则删除；否则，没有外网只有局域网，以本地为主,搜索多少个设备就显示多少个
     * 获取逆变器列表,整合云端逆变器列表和本地逆变器列表(设备类型有:并网逆变器，离线逆变器，负载中心设备);
     * 注意:有外网，以云端设备列表为准;云端没有，本地存在，则删除本地；否则，没有外网只有局域网，以本地为主,搜索多少个设备就显示多少个
     *
     * @param homeId        住宅id
     * @param cloudCallBeak 返回逆变器列表
@@ -1110,7 +1133,6 @@
        searchCurrentHomeGateway(homeId, new GatewayCallBack() {
            @Override
            public void onSuccess(List<GatewayBean> gatewayBeanList) {
                //局域网有2种情况(1:有局域网，有外网；2:有局域网，没有外网);
                //向云端获取逆变器列表
                getCloudInverterDeviceList(homeId, new CloudCallBeak<List<CloudInverterDeviceBean>>() {
                    @Override
@@ -1123,38 +1145,14 @@
                                    //合并负载中心设备列表，然后在一起做处理
                                    inverterDeviceList.addAll(loadCentreDeviceList);
                                }
                                List<String> removeMacList = new ArrayList<>();
                                for (int j = 0; j < HDLLinkLocalGateway.getInstance().getGatewayList().size(); j++) {
                                    GatewayBean gatewayBean = HDLLinkLocalGateway.getInstance().getGatewayList().get(j);
                                    if (queryMacInverter(inverterDeviceList, gatewayBean.getDevice_mac())) {
                                        //本地有，云端没有,删除本地；
                                        removeMacList.add(gatewayBean.getDevice_mac());
                                    }
                                }
                                for (int i = 0; i < removeMacList.size(); i++) {
                                    //删除本地的逆变器
                                    removeLocalInverter(removeMacList.get(i));
                                }
                                //情况1:有局域网，有外网；
                                //设置设备的远程信息
                                setDeviceRemoteInfo(inverterDeviceList, homeId, cloudCallBeak);
                            }

                            @Override
                            public void onFailure(HDLException e) {
                                //向云端获取负载中心设备列表失败后，仍然处理逆变器设备列表
                                List<String> removeMacList = new ArrayList<>();
                                for (int j = 0; j < HDLLinkLocalGateway.getInstance().getGatewayList().size(); j++) {
                                    GatewayBean gatewayBean = HDLLinkLocalGateway.getInstance().getGatewayList().get(j);
                                    if (queryMacInverter(inverterDeviceList, gatewayBean.getDevice_mac())) {
                                        //云端没有,本地有，删除本地；
                                        removeMacList.add(gatewayBean.getDevice_mac());
                                    }
                                }
                                for (int i = 0; i < removeMacList.size(); i++) {
                                    //删除本地的逆变器
                                    removeLocalInverter(removeMacList.get(i));
                                }
                                //情况1:有局域网，有外网；
                                //设置设备的远程信息
                                setDeviceRemoteInfo(inverterDeviceList, homeId, cloudCallBeak);
                            }
                        });
@@ -1164,7 +1162,6 @@

                    @Override
                    public void onFailure(HDLException e) {
                        ///情况2:有局域网，没有外网;
                        //本地有逆变器列表,获取云端绑定逆变器失败,默认返回本地逆变器列表;
                        //向云端获取负载中心列表
                        getLoadCentreDeviceList(homeId, new CloudCallBeak<List<CloudInverterDeviceBean>>() {
@@ -1172,27 +1169,12 @@
                            public void onSuccess(List<CloudInverterDeviceBean> loadCentreDeviceList) {
                                if (loadCentreDeviceList == null) {
                                    if (cloudCallBeak != null) {
                                        //没有数据，默认返回本地逆变器列表;
                                        cloudCallBeak.onSuccess(getCurrentHomeGatewayList(homeId, null));
                                    }
                                    return;
                                }
                                List<String> removeMacList = new ArrayList<>();
                                for (int j = 0; j < HDLLinkLocalGateway.getInstance().getGatewayList().size(); j++) {
                                    GatewayBean gatewayBean = HDLLinkLocalGateway.getInstance().getGatewayList().get(j);
                                    if (!isLoadCenterSpk(gatewayBean.getSpk())) {
                                        //不是负载中心的spk不做处理；
                                        continue;
                                    }
                                    if (queryMacInverter(loadCentreDeviceList, gatewayBean.getDevice_mac())) {
                                        //云端没有,本地有，删除本地；
                                        removeMacList.add(gatewayBean.getDevice_mac());
                                    }
                                }
                                for (int i = 0; i < removeMacList.size(); i++) {
                                    //删除本地的逆变器
                                    removeLocalInverter(removeMacList.get(i));
                                }
                                //情况1:有局域网，有外网；
                                //设置设备的远程信息
                                setDeviceRemoteInfo(loadCentreDeviceList, homeId, cloudCallBeak);
                            }

@@ -1205,16 +1187,14 @@
                            }
                        });

//                        if (cloudCallBeak != null) {
//                            cloudCallBeak.onSuccess(getCurrentHomeGatewayList(homeId));
//                        }
                    }
                });
            }

            @Override
            public void onError(HDLLinkException e) {
                //外网只有1种情况(本地搜索逆变器列表失败了)
                //外网进来先【默认】清空本地逆变器列表
                HDLLinkLocalGateway.getInstance().getGatewayList().clear();
                //向云端获取逆变器列表
                getCloudInverterDeviceList(homeId, new CloudCallBeak<List<CloudInverterDeviceBean>>() {
                    @Override
@@ -1223,30 +1203,26 @@
                        getLoadCentreDeviceList(homeId, new CloudCallBeak<List<CloudInverterDeviceBean>>() {
                            @Override
                            public void onSuccess(List<CloudInverterDeviceBean> loadCentreDeviceList) {
                                //外网进来先【默认】清空本地逆变器列表
                                HDLLinkLocalGateway.getInstance().getGatewayList().clear();

                                List<CloudInverterDeviceBean> newList = new ArrayList<>();
                                if (cloudInverterList != null) {
                                    //添加逆变器设备列表
                                    newList.addAll(cloudInverterList);
                                }
                                if (loadCentreDeviceList != null) {
                                    //添加负载中心设备列表
                                    newList.addAll(loadCentreDeviceList);
                                }
                                //逆变器列表和负载中心列表相加
                                //整合设备列表后,再一起设置设备的远程信息
                                setDeviceRemoteInfo(newList, homeId, cloudCallBeak);
                            }

                            @Override
                            public void onFailure(HDLException e) {
                                //外网进来先【默认】清空本地逆变器列表
                                //向云端获取负载中心列表失败,直接返回逆变器列表；
                                HDLLinkLocalGateway.getInstance().getGatewayList().clear();
                                //设置设备的远程信息
                                setDeviceRemoteInfo(cloudInverterList, homeId, cloudCallBeak);
                            }
                        });
//                        //外网进来先【默认】清空本地逆变器列表
//                        HDLLinkLocalGateway.getInstance().getGatewayList().clear();
//                        setDeviceRemoteInfo(list, homeId, cloudCallBeak);
                    }

                    @Override
@@ -1256,22 +1232,18 @@
                        getLoadCentreDeviceList(homeId, new CloudCallBeak<List<CloudInverterDeviceBean>>() {
                            @Override
                            public void onSuccess(List<CloudInverterDeviceBean> loadCentreDeviceList) {
                                //外网进来先【默认】清空本地逆变器列表
                                HDLLinkLocalGateway.getInstance().getGatewayList().clear();
                                //逆变器列表和负载中心列表
                                //设置设备的远程信息
                                setDeviceRemoteInfo(loadCentreDeviceList, homeId, cloudCallBeak);
                            }

                            @Override
                            public void onFailure(HDLException e) {
                                //都是获取失败的话,直接返回空列表;
                                if (cloudCallBeak != null) {
                                    cloudCallBeak.onFailure(e);
                                    cloudCallBeak.onSuccess(new ArrayList<>());
                                }
                            }
                        });
//                        if (cloudCallBeak != null) {
//                            cloudCallBeak.onFailure(e);
//                        }
                    }
                });
            }
@@ -1291,7 +1263,6 @@
            if (cloudCallBeak != null) {
                cloudCallBeak.onSuccess(getCurrentHomeGatewayList(homeId, list));
            }

            return;
        }
        AtomicInteger atomicInteger = new AtomicInteger(0);
@@ -1826,6 +1797,38 @@
    }

    /**
     * 模拟逆变器设备列表
     *
     * @param sum 模拟多少个
     * @return 返回逆变器列表
     */
    public List<GatewayBean> getGatewayDeviceListMockData(int sum) {

        try {
            List<GatewayBean> list = new ArrayList<>();
            for (int i = 0; i < sum; i++) {
                String spk = getGatewaySpk().get(i % getGatewaySpk().size());
                GatewayBean gatewayBean = new GatewayBean();
                gatewayBean.setHomeId("100000000" + i);
                gatewayBean.setDevice_mac("200000000" + i);
                gatewayBean.setSpk(spk);
                gatewayBean.setGateway_type(spk);
                gatewayBean.setMaster("true");
                gatewayBean.setSid("300000000" + i);
                gatewayBean.setOid("400000000" + i);
                gatewayBean.setGatewayId("500000000" + i);
                gatewayBean.setDevice_name("模拟-" + i + "(" + spk + ")");
                gatewayBean.setDeviceStatus(5);//默认都是离线¬
                list.add(gatewayBean);
            }
            return list;
        } catch (Exception ignored) {
            return new ArrayList<>();
        }

    }

    /**
     * 逆变器spk
     */
    public final String INVERTER_DEVICE_SPK = "energy.hdl_inverter";