java/Robotaxi.git

package com.xiaopeng.vehicleConvoy.controller;
 
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson2.JSON;
import com.xiaopeng.api.dto.vehicleConvoy.VehicleTemperatureDto;
import com.xiaopeng.api.vo.vehicleConvoy.VehicleStateVo;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.redis.service.RedisService;
import com.xiaopeng.vehicleConvoy.model.dto.CarControlCallbackDTO;
import com.xiaopeng.vehicleConvoy.service.AsyncVehicleStateService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
 
/**
 * 控车回调接口
 */
@Slf4j
@RestController
@RequestMapping("/logan/api/v1")
public class CarControlCallbackController {
 
    @Resource
    private AsyncVehicleStateService asyncVehicleStateService;
    @Resource
    private RedisService redisService;
 
    /**
     * 车控指令执行的回调接口
     *
     * @param request 车控指令请求
     * @return 车控指令响应
     */
    @PostMapping("/vehicles/command/callback")
    public R<String> callback(@RequestBody CarControlCallbackDTO request) {
        if (request == null) {
            throw new ServiceException("请求参数缺失");
        }
        log.info("接收到回调:{}", JSONUtil.toJsonStr(request));
 
        try {
            // 处理车辆状态回调, 19指令处理回调，其他暂不处理
            if (request.getMsgRef() != null && request.getMsgContent() != null && request.getServiceType() != null && request.getServiceType() == 19) {
                // 尝试解析车辆状态数据
                VehicleTemperatureDto stateData = parseVehicleStateFromCallback(request);
                if (stateData != null) {
                    // 通知异步服务处理回调
                    asyncVehicleStateService.handleStateCallback(request.getMsgRef(), stateData);
                }
                // 尝试解析车辆空调数据
                parseAirConditioningSwitchFromCallback(request);
            }
        } catch (Exception e) {
            log.error("处理车辆状态回调异常: msgId={}", request.getMsgRef(), e);
        }
 
        return R.ok(JSONUtil.toJsonStr(request));
    }
 
    /**
     * 从回调消息中解析车辆状态数据
     */
    private VehicleTemperatureDto parseVehicleStateFromCallback(CarControlCallbackDTO callback) {
        try {
            if (callback.getMsgContent() == null) {
                return null;
            }
 
            log.debug("解析车辆状态数据: msgId={}, content={}", callback.getMsgRef(), JSON.toJSONString(callback.getMsgContent()));
 
            // 解析msgContent为Map结构
            Map<String, Object> msgContent = (Map<String, Object>) callback.getMsgContent();
 
            // 检查返回码
            Integer code = (Integer) msgContent.get("code");
            if (code == null || code != 200) {
                log.warn("车辆状态回调返回错误码: msgId={}, code={}", callback.getMsgRef(), code);
                return null;
            }
 
            // 获取instant数据
            Map<String, Object> instant = (Map<String, Object>) msgContent.get("instant");
            if (instant == null) {
                log.warn("回调数据中缺少instant字段: msgId={}", callback.getMsgRef());
                return null;
            }
 
            // 创建VehicleTemperatureDto对象
            VehicleTemperatureDto stateData = new VehicleTemperatureDto();
            Map<String, VehicleStateVo> stateMap = new HashMap<>();
 
            // 解析door信息
            Map<String, Object> door = (Map<String, Object>) instant.get("door");
            if (door != null) {
                //存入缓存用于后续使用
                redisService.setCacheObject("DOOR:" + callback.getMsgId(), JSON.toJSONString(door), 30L, TimeUnit.SECONDS);
                // 获取trunk_ajar_st_new值
                Object trunkAjarStNewObj = door.get("trunk_ajar_st_new");
                if (trunkAjarStNewObj != null) {
                    VehicleStateVo trunkState = new VehicleStateVo();
                    trunkState.setValue(trunkAjarStNewObj.toString());
                    stateMap.put("trunkAjarCloseSt", trunkState); // 保持原有的key名称兼容
 
                    // 同时添加新的key名称
                    stateMap.put("trunk_ajar_st_new", trunkState);
 
                    log.info("解析到后备箱状态: msgId={}, trunk_ajar_st_new={}", callback.getMsgRef(), trunkAjarStNewObj);
                }
            }
            // 解析hvac信息
            Map<String, Object> hvac = (Map<String, Object>) instant.get("hvac");
            if (hvac != null) {
                //存入缓存用于后续使用
                redisService.setCacheObject("HVAC:" + callback.getMsgId(), JSON.toJSONString(hvac), 30L, TimeUnit.SECONDS);
            }
            // 解析seat信息
            Map<String, Object> seat = (Map<String, Object>) instant.get("seat");
            if (seat != null) {
                //存入缓存用于后续使用
                redisService.setCacheObject("SEAT:" + callback.getMsgId(), JSON.toJSONString(seat), 30L, TimeUnit.SECONDS);
            }
            // 解析charge信息
            Map<String, Object> charge = (Map<String, Object>) instant.get("charge");
            if (charge != null) {
                //存入缓存用于后续使用
                redisService.setCacheObject("CHARGE:" + callback.getMsgId(), JSON.toJSONString(charge), 30L, TimeUnit.SECONDS);
            }
            stateData.setStateMap(stateMap);
            return stateData;
 
        } catch (Exception e) {
            log.warn("解析车辆状态数据失败: msgId={}", callback.getMsgRef(), e);
            return null;
        }
    }
 
 
    /**
     * 从回调消息中解析车辆空调状态数据
     */
    private VehicleTemperatureDto parseAirConditioningSwitchFromCallback(CarControlCallbackDTO callback) {
        try {
            if (callback.getMsgContent() == null) {
                return null;
            }
 
            log.info("解析空调状态数据: msgId={}, content={}", callback.getMsgRef(), JSON.toJSONString(callback.getMsgContent()));
 
            // 解析msgContent为Map结构
            Map<String, Object> msgContent = (Map<String, Object>) callback.getMsgContent();
 
            // 检查返回码
            Integer code = (Integer) msgContent.get("code");
            if (code == null || code != 200) {
                log.info("空调状态回调返回错误码: msgId={}, code={}", callback.getMsgRef(), code);
                return null;
            }
 
            // 获取instant数据
            Map<String, Object> instant = (Map<String, Object>) msgContent.get("instant");
            if (instant == null) {
                log.info("回调数据中缺少instant字段: msgId={}", callback.getMsgRef());
                return null;
            }
 
            // 创建VehicleTemperatureDto对象
            VehicleTemperatureDto stateData = new VehicleTemperatureDto();
            Map<String, VehicleStateVo> stateMap = new HashMap<>();
 
            // 解析hvac信息
            Map<String, Object> hvac = (Map<String, Object>) instant.get("hvac");
            if (hvac != null) {
                log.info("解析到空调: msgId={}, hvac_on={}", callback.getMsgRef(), JSON.toJSONString(hvac));
                //存入缓存用于后续使用
                redisService.setCacheObject("HVAC:" + callback.getMsgId(), JSON.toJSONString(hvac), 30L, TimeUnit.SECONDS);
            }
            stateData.setStateMap(stateMap);
            return stateData;
        } catch (Exception e) {
            log.warn("解析空调状态数据失败: msgId={}", callback.getMsgRef(), e);
            return null;
        }
    }
}