和客户同步1.0版本

puzhibing

2026-04-10 ed838e62602c0a63a64ff4bd144a0d16cc9a7cf8

 xp-robotaxi-automatic-pilot-boot/src/main/java/com/xiaopeng/automaticPilot/service/KafkaConsumerService.java

@@ -8,6 +8,7 @@
import com.xiaopeng.api.dto.automaticPilot.MqttPublishDto;
import com.xiaopeng.api.dto.automaticPilot.PushOrderDto;
import com.xiaopeng.api.dto.automaticPilot.VehicleEventDTO;
import com.xiaopeng.api.dto.map.HistoryPointDto;
import com.xiaopeng.api.dto.map.OrderRouteAndFareDto;
import com.xiaopeng.api.dto.operation.CruisePointDto;
import com.xiaopeng.api.dto.operation.LonLatDto;
@@ -117,10 +118,16 @@
    @Value("${robotaxi.appId:xp_robotaxi_api}")
    private String appid;

    @Value("${automatic.content.waittime:20000}")
    private Long waittime;

    @Resource
    private XpTaskClient xpTaskClient;
    @Resource
    private VehicleBuriedPointClient vehicleBuriedPointClient;

    @Value("${xpu.res.ping.enable: true}")
    private boolean xpuResPingEnable;

    @Resource
    private XpTestOrderClient testOrderClient;
@@ -199,7 +206,7 @@
            switch (cmd) {
                case SYSTEM_STATUS_XPU:
                    log.info("XPU发布系统运行状态 (XPU→云端)：{}", message);
                    systemStatusXpu(msgContent);
                    systemStatusXpu(cmd, msgContent);
                    systemStatusXpuAndReassign(msgContent);
                    break;
                case XPU_NAVIGATION_REQUEST:
@@ -223,7 +230,7 @@
                    break;
                case ORDER_STATE_UPDATE_EVENT:
                    log.info("订单状态变化(XPU→云端)(XPU→座舱)：{}", message);
                    orderStateUpdateEvent(msgContent);
                    orderStateUpdateEvent(cmd, msgContent);
                    break;
                case POINT_ARRIVAL_STATUS_EVENT:
                    log.info("到达目标点状态(XPU→云端)(XPU→座舱)：{}", message);
@@ -253,6 +260,12 @@
                case ORDER_STATE_UPDATE_TO_CDU_EVENT:
                    log.info("更新订单状态到CDU (XPU→云端)：{}", message);
                    break;
                case ORDER_NEAR_DESTINATION_EVENT:
                    log.info("车辆即将到达订单终点 (XPU→云端)：{}", message);
//                    if(orderId.contains("XU")){
//                        buildPushOrderStatus(orderId, OrderStatusEnum.COMPLETED, sequence);
//                    }
                    break;
                default:
                    log.info("消息不在处理范围内，忽略：{}", message);
            }
@@ -271,7 +284,12 @@
                RtTaskListResponse response = msgContent.getRtTaskListResponse();
                try {
                    log.info("云端下发订单操作的响应消息 (XPU→云端)：{}", jsonPrinter.print(response));
                    Object sequence = redisService.getCacheObject("CREATE_ORDER:" + response.getResults().getOrderId());
                    RtTaskResult rtTaskResult = response.getResults(0);
                    if (rtTaskResult.getStatus() != TaskResultStatus.ACCEPTED) {
                        log.error("订单操作失败，orderId {} taskId {} 错误码 {}", rtTaskResult.getOrderId(), rtTaskResult.getTaskId(), rtTaskResult.getStatus());
                        return;
                    }
                    Object sequence = redisService.getCacheObject("CREATE_ORDER:" + response.getResults(0).getOrderId());
                    if(sequence!=null){
                        JSONObject jsonObject = JSON.parseObject(sequence.toString());
                        String orderId = jsonObject.getString("orderId");
@@ -288,7 +306,7 @@
                        dto.setXpVehicleVin(vin);
                        dto.setOrderType(orderType);
                        xpOrderClient.popOrder(dto);
                        log.info("订单状态更新：{}", response.getResults().getOrderId());
                        log.info("订单状态更新：{}", response.getResults(0).getOrderId());
                    }
                } catch (InvalidProtocolBufferException e) {
                    log.error("Failed to print RtTaskListResponse: {}", response, e);
@@ -308,7 +326,7 @@
     *
     * @param msgContent
     */
    public void systemStatusXpu(MsgContent msgContent) {
    public void systemStatusXpu(RTCmdType cmd, MsgContent msgContent) {
        //开始处理消息对应的业务逻辑
        SystemRuntimeStatus systemRuntimeStatus = msgContent.getSystemRuntimeStatus();
        //获取实时位置
@@ -322,10 +340,16 @@
        VehicleStaticInfo staticInfo = systemRuntimeStatus.getVehicleStatus().getStaticInfo();
        String xpuId = staticInfo.getXpuId();
        XpVehicle xpVehicle = xpVehicleClient.findByVehicleXpuId(xpuId).getData();
        if(null == xpVehicle){
            log.info("XPUID查询车辆无效 {}", xpuId);
            return;
        }
        String vin = xpVehicle.getVehicleVin();
        //先响应消息
        long sequence = msgContent.getHeader().getSequence();
        responseMessage(sequence, vin);
        if (xpuResPingEnable) {
            responseMessage(cmd, sequence, vin);
        }
        //保存车辆实时位置到redis
        if(0 != longitude && 0 != latitude){
            redisTemplate.opsForGeo().add("vehiclePosition:" + vin, new Point(longitude, latitude), vin);
@@ -350,6 +374,27 @@
        }
        //保存车辆实时信息到mongodb
        if(0 != longitude && 0 != latitude){
            //缓存车辆历史定位，用户辅助获取导航抓路用
            List<Object> cacheList = redisService.getCacheList("VEHICLE_HISTORY_POINT_LIST:" + xpVehicle.getId());
            List<HistoryPointDto> history = new ArrayList<>();
            if(cacheList!=null && !cacheList.isEmpty()){
                for (Object cache : cacheList) {
                    HistoryPointDto historyPointDto = JSON.parseObject(cache.toString(), HistoryPointDto.class);
                    history.add(historyPointDto);
                }
            }
            if(history.size() >= 10){
                history.subList(history.size() - 10, history.size());
            }
            HistoryPointDto historyPointDto = new HistoryPointDto();
            historyPointDto.setLocation(longitude + "," + latitude);
            historyPointDto.setLocateTime(System.currentTimeMillis() + "");
            historyPointDto.setAccuracy(naviPose.getPosAcc());
            historyPointDto.setDirection(course);
            historyPointDto.setSpeed(dynamicStatus.getSpeed());
            history.add(historyPointDto);
            redisService.setCacheList("VEHICLE_HISTORY_POINT_LIST:" + xpVehicle.getId(), history);

            VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(vin)), VehiclePosition.class);
            if (null == vehiclePosition) {
                vehiclePosition = new VehiclePosition();
@@ -375,36 +420,38 @@
                        .set("mileageRange", dynamicStatus.getDstBatDisp())
                        .set("hasOrder", hasOrder)
                        .set("orderId", orderId)
                        .set("totalOdometer", dynamicStatus.getTotalOdometer()
                        .set("addTime", System.currentTimeMillis()));
                        .set("totalOdometer", dynamicStatus.getTotalOdometer())
                        .set("addTime", System.currentTimeMillis());
                mongoTemplate.updateFirst(new Query(Criteria.where("vin").is(vin)), update, VehiclePosition.class);
            }
            //调用推送服务接口，给乘客推送剩余轨迹和里程时长
            if (null != orderId && !order_id.contains("XU")) {
                RtTripInfo rtTripInfo = systemRuntimeStatus.getRtTripInfo();
                RtTripInfo rtTripInfo = systemRuntimeStatus.getRunningOrderStatusInfo().getRtTripInfo();
                PushOrderRouteDTO dto = new PushOrderRouteDTO();
                dto.setOrderId(orderId);
                dto.setRouteType(1);
                dto.setLongitude(longitude);
                dto.setLatitude(latitude);
                //TODO 这两个字段现在拿不到
//            dto.setDuration(rtTripInfo.getRemaining_time());
//            dto.setDistance(rtTripInfo.getRemaining_distance().intValue());
//            dto.setDirection();
                //只有乘客订单需要推送剩余导航数据
                if(!order_id.contains("TEST")){
                    xpPushMessageClient.pushOrderRoute(dto);
                if (rtTripInfo.hasCurrentTask() && rtTripInfo.getCurrentTask().hasNaviProgressInfo()) {
                    dto.setDuration(rtTripInfo.getCurrentTask().getNaviProgressInfo().getRouteRemainTime());
                    dto.setDistance(rtTripInfo.getCurrentTask().getNaviProgressInfo().getRouteRemainDist());
                    dto.setDirection(course.intValue());
                }

                //存储历史轨迹
                OrderTrajectoryVo orderTrajectory = new OrderTrajectoryVo();
                orderTrajectory.setOrderId(orderId);
                orderTrajectory.setLocation(longitude + "," + latitude);
                orderTrajectory.setDirection(dto.getDirection());
                orderTrajectory.setSpeed(0D);
                orderTrajectory.setSpeed((double) dynamicStatus.getSpeed());
                orderTrajectory.setLocatetime(System.currentTimeMillis());
                orderTrajectory.setCreateTime(new Date());
                xpOrderClient.saveVehicleLocation(orderTrajectory);
                //只有乘客订单需要推送剩余导航数据
                if(!order_id.contains("TEST")){
                    xpPushMessageClient.pushOrderRoute(dto);//存储历史轨迹
                    xpOrderClient.saveVehicleLocation(orderTrajectory);
                }else{
                    testOrderClient.saveVehicleLocation(orderTrajectory);
                }
            }
        }
    }
@@ -425,6 +472,7 @@
        GearLevel gearLevel = systemRuntimeStatus.getVehicleStatus().getDynamicStatus().getGearLevel();
        int value = gearLevel.getNumber();
        redisService.setCacheObject(CacheConstants.GEAR_LEVEL + systemRuntimeStatus.getVehicleStatus().getStaticInfo().getXpuId(), value);
        log.info("车辆挡位：{} {}", CacheConstants.GEAR_LEVEL + systemRuntimeStatus.getVehicleStatus().getStaticInfo().getXpuId(), value);
        // 判断是否为故障状态
        XpVehicle vehicle = null;
        if (abnormalReason == AbnormalReason.FAULT) {
@@ -518,7 +566,7 @@
     */
    public void xpuNavigationRequest(MsgContent msgContent) {
        //开始处理消息对应的业务逻辑
        NavigationRequest naviRequest = msgContent.getNavigationRequset();
        NavigationRequest naviRequest = msgContent.getNavigationRequest();
        String requestId = naviRequest.getRequestId();
        String orderId = naviRequest.getOrderId();
        String taskId = naviRequest.getTaskId();
@@ -531,15 +579,15 @@
                break;
            case ROUTE_TO_PICKUP:
                log.info("驶往上车点的行程 {}", orderId);
                buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence());
                buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence(), taskId);
                break;
            case ROUTE_TO_DESTINATION:
                log.info("驶往下车点的行程 {}", orderId);
                buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence());
                buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence(), taskId);
                break;
            case ROUTE_TO_CRUISE:
                log.info("巡游阶段路线 {}", orderId);
                buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence());
                buildNaviRequest(requestId, orderId, orderPhase, msgContent.getHeader().getSequence(), taskId);
                break;
        }
    }
@@ -553,7 +601,7 @@
    public void navigationDeviationEvent(MsgContent msgContent) {
        //开始处理消息对应的业务逻辑
        NavigationDeviationEvent deviationEvent = msgContent.getNaviDeviationEvent();
        String requestId = deviationEvent.getNavigationDeviationMessage().getNaviRecalcRequestSeq() + "";
        String requestId = deviationEvent.getNavigationDeviationMessage().getRequestId() + "";
        //导航id
        String routeID = "";
        Long vehicleId = null;
@@ -568,7 +616,7 @@
        //订单类型  1：乘客订单，2=巡游订单
        LonLatDto destination = new LonLatDto();
        LonLatDto origin = new LonLatDto();

        RouteVo routeVo = null;
        if (orderId.contains("XU")) {
            orderType = OrderType.CRUISE_ORDER;

@@ -590,7 +638,7 @@
            if (200 != routeVoR.getCode()) {
                throw new RuntimeException("获取订单线路和运费失败");
            }
            RouteVo routeVo = routeVoR.getData();
            routeVo = routeVoR.getData();
            routeID = routeVo.getRouteID();


@@ -614,11 +662,12 @@
                    dto.setOrigin(origin);
                    dto.setDestination(destination);
                    dto.setRouteType(1);
                    dto.setVehicleId(testOrder.getVehicleId());
                    R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
                    if (200 != routeVoR.getCode()) {
                        throw new RuntimeException("获取订单线路和运费失败");
                    }
                    RouteVo routeVo = routeVoR.getData();
                    routeVo = routeVoR.getData();
                    routeID = routeVo.getRouteID();
                    //缓存数据，用于后续推给乘客导航线路
                    redisService.setCacheObject("TEST_ORDER_NAVIGATION_START_DATA:" + testOrder.getVehicleId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
@@ -639,7 +688,7 @@
                    if (200 != routeVoR.getCode()) {
                        throw new RuntimeException("获取订单线路和运费失败");
                    }
                    RouteVo routeVo = routeVoR.getData();
                    routeVo = routeVoR.getData();
                    routeID = routeVo.getRouteID();
                    //缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
                    redisService.setCacheObject("TEST_ORDER_NAVIGATION_END_DATA:" + testOrder.getVehicleId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
@@ -663,7 +712,7 @@
                if (200 != routeVoR.getCode()) {
                    throw new RuntimeException("获取订单线路和运费失败");
                }
                RouteVo routeVo = routeVoR.getData();
                routeVo = routeVoR.getData();
                routeID = routeVo.getRouteID();

                vehicleId = testOrder.getVehicleId();
@@ -690,11 +739,12 @@
                dto.setOrigin(origin);
                dto.setDestination(destination);
                dto.setRouteType(1);
                dto.setVehicleId(xpOrder.getVehicleId());
                R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
                if (200 != routeVoR.getCode()) {
                    throw new RuntimeException("获取订单线路和运费失败");
                }
                RouteVo routeVo = routeVoR.getData();
                routeVo = routeVoR.getData();
                routeID = routeVo.getRouteID();
                //缓存数据，用于后续推给乘客导航线路
                redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
@@ -715,7 +765,7 @@
                if (200 != routeVoR.getCode()) {
                    throw new RuntimeException("获取订单线路和运费失败");
                }
                RouteVo routeVo = routeVoR.getData();
                routeVo = routeVoR.getData();
                routeID = routeVo.getRouteID();
                //缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
                redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId(), JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
@@ -724,13 +774,28 @@
        }
        //直接响应回最新导航数据
        if(StringUtils.isNotEmpty(routeID)){
            //推送小程序新的导航数据
            if(orderType.equals(OrderType.USER_ORDER)){
                PushOrderRouteDTO dto = new PushOrderRouteDTO();
                dto.setOrderId(Long.parseLong(orderId));
                dto.setRouteType(1);
                dto.setLongitude(longitude);
                dto.setLatitude(latitude);
                if (null != routeVo) {
                    dto.setDuration(routeVo.getDuration().doubleValue());
                    dto.setDistance(routeVo.getDistance().doubleValue());
                    dto.setDirection(routeVo.getDirection().intValue());
                }
                xpPushMessageClient.pushOrderRoute(dto);
            }

            XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
            R<String> stringR = xpMapClient.queryRouted(routeID);
            if (200 != stringR.getCode()) {
                throw new RuntimeException("根据导航ID获取车端需要的导航数据失败");
            }
            //构建响应导航数据给车端
            cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
            cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId(), taskId);
        }
    }

@@ -741,7 +806,7 @@
     * @param orderId
     * @param orderPhase
     */
    public void buildNaviRequest(String requestId, String orderId, OrderPhase orderPhase, Long sequence) {
    public void buildNaviRequest(String requestId, String orderId, OrderPhase orderPhase, Long sequence, String taskId) {
        //订单类型  1：乘客订单，2=巡游订单
        LonLatDto destination = new LonLatDto();
        LonLatDto origin = new LonLatDto();
@@ -804,6 +869,7 @@
                        dto.setOrigin(origin);
                        dto.setDestination(destination);
                        dto.setRouteType(2);
                        dto.setVehicleId(testOrder.getVehicleId());
                        R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
                        if (200 != routeVoR.getCode()) {
                            throw new RuntimeException("获取订单线路和运费失败");
@@ -901,6 +967,7 @@
                    dto.setOrigin(origin);
                    dto.setDestination(destination);
                    dto.setRouteType(1);
                    dto.setVehicleId(xpOrder.getVehicleId());
                    R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
                    if (200 != routeVoR.getCode()) {
                        throw new RuntimeException("获取订单线路和运费失败");
@@ -955,7 +1022,7 @@
            }
            log.info("根据导航ID获取车端需要的导航数据 订单 {} 导航数据 {}", orderId, stringR.getData());
            //构建导航下发请求对象
            cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
            cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId(), taskId);
        }
    }

@@ -1013,12 +1080,12 @@
    /**
     * 构建响应消息
     */
    public void responseMessage(Long request_seq, String vin) {
    public void responseMessage(RTCmdType cmd, Long request_seq, String vin) {
        ResponseMessage.Builder responseMessageBuilder = ResponseMessage.newBuilder();
        responseMessageBuilder.setRequestSeq(request_seq);
        responseMessageBuilder.setCode(StatusCode.OK);
        responseMessageBuilder.setTimestamp(System.currentTimeMillis());
        xpuUtil.responseMessage(responseMessageBuilder.build(), vin);
        xpuUtil.responseMessage(cmd, responseMessageBuilder.build(), vin);

    }

@@ -1027,7 +1094,7 @@
     * 订单状态更新事件
     * @param msgContent
     */
    public void orderStateUpdateEvent(MsgContent msgContent) {
    public void orderStateUpdateEvent(RTCmdType cmd, MsgContent msgContent) {
        //先响应消息
        long sequence = msgContent.getHeader().getSequence();
        //开始处理消息对应的业务逻辑
@@ -1049,7 +1116,7 @@
                        if(orderId.contains("TEST")){
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.READY_DEPART.getCode());
                        }else{
                            buildPushOrderStatus(orderId, OrderStatusEnum.READY_DEPART, sequence);
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.READY_DEPART, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.READY_DEPART.getCode());
                        }
                    }
@@ -1064,7 +1131,7 @@
                        if(orderId.contains("TEST")){
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PICK_UP.getCode());
                        }else{
                            buildPushOrderStatus(orderId, OrderStatusEnum.PICK_UP, sequence);
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.PICK_UP, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP.getCode());
                        }
                    }
@@ -1079,18 +1146,24 @@
                        if(orderId.contains("TEST")){
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PICK_UP_GUESTS.getCode());
                        }else{
                            buildPushOrderStatus(orderId, OrderStatusEnum.PICK_UP_GUESTS, sequence);
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.PICK_UP_GUESTS, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PICK_UP_GUESTS.getCode());
                        }
                    }
                    break;
                case ORDER_PASSENGER_ONBOARD:
                    //先手动暂停触发，因为现目前车机响应状态时机不对
                    try {
                        Thread.sleep(waittime);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    //乘客已上车
                    if(!orderId.contains("XU")){
                        if(orderId.contains("TEST")){
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.PASSENGER_BOARDED.getCode());
                        }else{
                            buildPushOrderStatus(orderId, OrderStatusEnum.PASSENGER_BOARDED, sequence);
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.PASSENGER_BOARDED, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.PASSENGER_BOARDED.getCode());
                        }
                    }
@@ -1101,7 +1174,7 @@
                        if(orderId.contains("TEST")){
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.IN_SERVICE.getCode());
                        }else{
                            buildPushOrderStatus(orderId, OrderStatusEnum.IN_SERVICE, sequence);
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.IN_SERVICE, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.IN_SERVICE.getCode());
                        }
                    }
@@ -1116,7 +1189,7 @@
                        if(orderId.contains("TEST")){
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
                        }else{
                            buildPushOrderStatus(orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
                            buildPushOrderStatus(cmd, orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
                            xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
                        }
                    }
@@ -1171,7 +1244,7 @@
                            log.info("改派旧车取消回调，跳过订单取消处理，orderId: {}, taskId: {}, cancelScene: {}, context: {}",
                                    orderId, taskId, cancelContext.getString("cancelScene"), cancelContext);
                            //响应消息
                            responseMessage(sequence, cancelContext.getString("vin"));
                            responseMessage(cmd, sequence, cancelContext.getString("vin"));
                            return;
                        }
                        if(orderId.contains("TEST")){
@@ -1210,13 +1283,13 @@
                            }
                            if(xpOrder.getStatus() > 5 && xpOrder.getStatus() < 8){
                                //行程中取消订单，按照行程结束处理
                                buildPushOrderStatus(orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
                                buildPushOrderStatus(cmd, orderId, OrderStatusEnum.SEE_OFF_GUESTS, sequence);
                                xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.SEE_OFF_GUESTS.getCode());
                                redisService.setCacheObject("ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.SEE_OFF_GUESTS.getCode(), 24L, TimeUnit.HOURS);
                                redisService.setCacheObject("ORDER_STATUS:" + orderId, OrderStatusEnum.SEE_OFF_GUESTS.getCode(), 24L, TimeUnit.HOURS);
                            }else{
                                buildPushOrderStatus(orderId, OrderStatusEnum.CANCELED, sequence);
                                buildPushOrderStatus(cmd, orderId, OrderStatusEnum.CANCELED, sequence);
                                xpOrderClient.updateOrderStatus(Long.parseLong(orderId), OrderStatusEnum.CANCELED.getCode());
                                redisService.setCacheObject("ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.CANCELED.getCode(), 24L, TimeUnit.HOURS);
                                redisService.setCacheObject("ORDER_STATUS:" + orderId, OrderStatusEnum.CANCELED.getCode(), 24L, TimeUnit.HOURS);
                            }
                        }
                    }
@@ -1224,7 +1297,7 @@
                case ORDER_ARRIVED_AT_CRUISE_DESTINATION:
                    //到达巡游终点
                    if(orderId.contains("XU")){
                        buildPushOrderStatus(orderId, OrderStatusEnum.COMPLETED, sequence);
                        buildPushOrderStatus(cmd, orderId, OrderStatusEnum.COMPLETED, sequence);
                        String cruiseOrderId = orderId.substring(2);
                        XpCruiseOrder xpCruiseOrder = xpCruiseOrderClient.getCruiseOrder(Long.parseLong(cruiseOrderId)).getData();
                        if (Objects.nonNull(xpCruiseOrder)){
@@ -1263,7 +1336,7 @@
                        if(testOrder.getOrderType() == 2){
                            XpVehicle xpVehicle = xpVehicleClient.queryById(testOrder.getVehicleId()).getData();
                            //响应消息
                            responseMessage(sequence, xpVehicle.getVehicleVin());
                            responseMessage(cmd, sequence, xpVehicle.getVehicleVin());
                            //测试巡游单处理逻辑
                            testOrderClient.updateOrderStatus(Long.parseLong(orderId.substring(4)), OrderStatusEnum.COMPLETED.getCode());
                            redisService.setCacheObject("TEST_ORDER_STATUS:" + orderId.substring(4), OrderStatusEnum.COMPLETED.getCode(), 24L, TimeUnit.HOURS);
@@ -1286,7 +1359,7 @@
     * @param orderId
     * @param status
     */
    public void buildPushOrderStatus(String orderId, OrderStatusEnum status, Long sequence){
    public void buildPushOrderStatus(RTCmdType cmd, String orderId, OrderStatusEnum status, Long sequence){
        if(orderId.contains("XU")){
            //巡游单
            //到达目的地
@@ -1302,7 +1375,7 @@
                    R<XpVehicle> xpVehicleR = xpVehicleClient.queryById(vehicleId);
                    XpVehicle xpVehicle = xpVehicleR.getData();
                    //响应消息
                    responseMessage(sequence, xpVehicle.getVehicleVin());
                    responseMessage(cmd, sequence, xpVehicle.getVehicleVin());
                    // 运营中 继续执行
                    if(xpVehicle.getOperatingStatus()==1 && xpVehicle.getState()==0){
                        log.info("巡游单到达终点，继续执行下一笔巡游单");
@@ -1342,7 +1415,7 @@
            XpOrder xpOrder = xpOrderR.getData();
            XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
            //响应消息
            responseMessage(sequence, xpVehicle.getVehicleVin());
            responseMessage(cmd, sequence, xpVehicle.getVehicleVin());

            //构建推送消息
            Map<String, Object> params = new HashMap<>();
@@ -1419,13 +1492,15 @@
     * @param vin                   车辆VIN
     * @param xpuId                 XPU设备id
     */
    public void cloudPushNavigationInfo(String requestId, String routeId, String routeDataContent, String orderType, String orderId, String vin, String xpuId) {
    public void cloudPushNavigationInfo(String requestId, String routeId, String routeDataContent, String orderType, String orderId, String vin, String xpuId, String taskId) {
        //组装报文，将routeDateContent信息推送到XPU
        RestoreNavigationData.Builder navigationDataBuilder = RestoreNavigationData.newBuilder();
        navigationDataBuilder.setRouteId(routeId);
        navigationDataBuilder.setRequestId(requestId);
        navigationDataBuilder.setContent(routeDataContent);
        navigationDataBuilder.setTimestamp(System.currentTimeMillis());
        navigationDataBuilder.setOrderId(orderId);
        navigationDataBuilder.setTaskId(taskId);
        long sequence = snowflake.nextId();
        log.info("开始推送导航数据 {}", orderId);
        MqttPublishDto mqttPublishDto = xpuUtil.cloudPushNavigation(navigationDataBuilder.build(), xpuId, sequence);