a-tuoheng-device/src/main/java/com/ruoyi/device/service/impl/TuohengService.java

package com.ruoyi.device.service.impl;

import com.ruoyi.device.domain.api.IDockAircraftDomain;
import com.ruoyi.device.domain.api.IDockDomain;
import com.ruoyi.device.domain.api.IAircraftDomain;
import com.ruoyi.device.domain.api.IDeviceDomain;
import com.ruoyi.device.domain.model.DockAircraft;
import com.ruoyi.device.domain.impl.tuohengmqtt.callback.IAirportOsdCallback;
import com.ruoyi.device.domain.impl.tuohengmqtt.callback.IAirportStateCallback;
import com.ruoyi.device.domain.impl.tuohengmqtt.callback.IEventsCallback;
import com.ruoyi.device.domain.impl.tuohengmqtt.callback.IDroneOsdCallback;
import com.ruoyi.device.domain.impl.tuohengmqtt.callback.IRequestsCallback;
import com.ruoyi.device.domain.impl.tuohengmqtt.callback.IServicesReplyCallback;
import com.ruoyi.device.domain.impl.tuohengmqtt.config.TuohengMqttClientConfig;
import com.ruoyi.device.domain.impl.tuohengmqtt.handler.TuohengMqttMessageHandler;
import com.ruoyi.device.domain.impl.tuohengmqtt.manager.TuohengMqttClientManager;
import com.ruoyi.device.domain.impl.tuohengmqtt.model.AirportOsdData;
import com.ruoyi.device.domain.impl.tuohengmqtt.model.AirportStateData;
import com.ruoyi.device.domain.impl.tuohengmqtt.model.DroneOsdData;
import com.ruoyi.device.domain.impl.tuohengmqtt.model.EventsData;
import com.ruoyi.device.domain.model.Aircraft;
import com.ruoyi.device.domain.model.Device;
import com.ruoyi.device.domain.model.Dock;
import com.ruoyi.device.service.config.TuohengMqttProperties;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
@Slf4j
public class TuohengService {

    @Autowired
    private TuohengMqttClientManager clientManager;

    @Autowired
    private TuohengMqttProperties mqttProperties;

    @Autowired
    private IDockAircraftDomain dockAircraftDomain;

    @Autowired
    private IDockDomain dockDomain;

    @Autowired
    private IAircraftDomain aircraftDomain;

    @Autowired
    private IDeviceDomain deviceDomain;

    private final ObjectMapper objectMapper = new ObjectMapper();

    @EventListener(ApplicationReadyEvent.class)
    public void onApplicationReady() {
        TuohengMqttClientConfig config = TuohengMqttClientConfig.builder()
                .host(mqttProperties.getHost())
                .port(mqttProperties.getPort())
                .clientId(mqttProperties.getClientId())
                .username(mqttProperties.getUsername())
                .password(mqttProperties.getPassword())
                .connectionTimeout(mqttProperties.getConnectionTimeout())
                .keepAliveInterval(mqttProperties.getKeepAliveInterval())
                .autoReconnect(mqttProperties.getAutoReconnect())
                .cleanSession(mqttProperties.getCleanSession())
                .useSharedSubscription(true)
                .sharedGroupName("tuoheng-group")
                .build();

        clientManager.initClient(config);

        TuohengMqttMessageHandler handler = clientManager.getHandler();

        Map<String, String> mapping = loadAirportDroneMapping();
        handler.setAirportDroneMapping(mapping);

        handler.registerAirportOsdCallback(new IAirportOsdCallback() {
            @Override
            public void onAirportOsdData(String airportSn, AirportOsdData data) {
                log.info("========== 收到机场OSD数据 ==========");
                log.info("机场SN: {}", airportSn);
                try {
                    log.info("数据内容: {}", objectMapper.writeValueAsString(data));
                } catch (Exception e) {
                    log.error("序列化数据失败", e);
                }
                log.info("=====================================");
            }
        });

        handler.registerDroneOsdCallback(new IDroneOsdCallback() {
            @Override
            public void onDroneOsdData(String droneSn, String airportSn, DroneOsdData data) {
                log.info("========== 收到无人机OSD数据 ==========");
                log.info("无人机SN: {}, 机场SN: {}", droneSn, airportSn);
                try {
                    log.info("数据内容: {}", objectMapper.writeValueAsString(data));
                } catch (Exception e) {
                    log.error("序列化数据失败", e);
                }
                log.info("=====================================");
            }
        });

        handler.registerAirportStateCallback(new IAirportStateCallback() {
            @Override
            public void onAirportStateData(String airportSn, String droneSn, AirportStateData data) {
                log.info("========== 收到机场State数据 ==========");
                log.info("机场SN: {}, 无人机SN: {}", airportSn, droneSn);
                try {
                    log.info("数据内容: {}", objectMapper.writeValueAsString(data));
                } catch (Exception e) {
                    log.error("序列化数据失败", e);
                }
                log.info("=====================================");
            }
        });

        handler.registerEventsCallback(new IEventsCallback() {
            @Override
            public void onEventsData(String airportSn, EventsData data) {
                log.info("========== 收到Events数据 ==========");
                log.info("机场SN: {}", airportSn);
                try {
                    log.info("数据内容: {}", objectMapper.writeValueAsString(data));
                } catch (Exception e) {
                    log.error("序列化数据失败", e);
                }
                log.info("=====================================");
            }
        });

        handler.registerServicesReplyCallback(new IServicesReplyCallback() {
            @Override
            public void onServicesReplyData(String airportSn, Map<String, Object> data) {
                log.info("========== 收到ServicesReply数据 ==========");
                log.info("机场SN: {}", airportSn);
                try {
                    log.info("数据内容: {}", objectMapper.writeValueAsString(data));
                } catch (Exception e) {
                    log.error("序列化数据失败", e);
                }
                log.info("=====================================");
            }
        });

        handler.registerRequestsCallback(new IRequestsCallback() {
            @Override
            public void onRequestsData(String airportSn, String method, Map<String, Object> data) {
                log.info("========== 收到Requests数据 ==========");
                log.info("机场SN: {}, Method: {}", airportSn, method);
                try {
                    log.info("数据内容: {}", objectMapper.writeValueAsString(data));
                } catch (Exception e) {
                    log.error("序列化数据失败", e);
                }
                log.info("=====================================");
            }
        });

        log.info("TuohengService 初始化完成，已注册所有回调");
    }

    private Map<String, String> loadAirportDroneMapping() {
        Map<String, String> mapping = new HashMap<>();

        try {
            List<DockAircraft> dockAircraftList = dockAircraftDomain.selectDockAircraftList(new DockAircraft());

            for (DockAircraft dockAircraft : dockAircraftList) {
                Dock dock = dockDomain.selectDockByDockId(dockAircraft.getDockId());
                Aircraft aircraft = aircraftDomain.selectAircraftByAircraftId(dockAircraft.getAircraftId());

                if (dock != null && aircraft != null) {
                    Device dockDevice = deviceDomain.selectDeviceByDeviceId(dock.getDeviceId());
                    Device aircraftDevice = deviceDomain.selectDeviceByDeviceId(aircraft.getDeviceId());

                    if (dockDevice != null && aircraftDevice != null) {
                        String airportSn = dockDevice.getDeviceSn();
                        String droneSn = aircraftDevice.getDeviceSn();
                        if (airportSn != null && droneSn != null) {
                            mapping.put(airportSn, droneSn);
                            log.info("加载机场-无人机映射: {} -> {}", airportSn, droneSn);
                        }
                    }
                }
            }

            log.info("从数据库加载机场-无人机映射完成，共 {} 条记录", mapping.size());
        } catch (Exception e) {
            log.error("从数据库加载机场-无人机映射失败", e);
        }

        return mapping;
    }
}