修改推送导航数据逻辑

puzhibing

2026-02-25 06006887e9625a5d8b2f348ce9aca65ee296c768

修改推送导航数据逻辑

 xp-robotaxi-api/src/main/java/com/xiaopeng/api/dto/order/PopOrderDto.java

@@ -12,6 +12,9 @@
    @ApiModelProperty(value = "订单Id")
    private Long orderId;

    @ApiModelProperty(value = "订单类型")
    private String orderType;

    @ApiModelProperty(value = "车辆Vin")
    private String xpVehicleVin;


 xp-robotaxi-api/src/main/java/com/xiaopeng/api/vo/OrderType.java

New file
@@ -0,0 +1,15 @@
package com.xiaopeng.api.vo;

/**
 * 定义订单类型
 */
public interface OrderType {
    /**
     * 巡游单
     */
    String CRUISE_ORDER = "cruise_order";
    /**
     * 乘客订单
     */
    String USER_ORDER = "user_order";
}

 xp-robotaxi-api/src/main/java/com/xiaopeng/api/vo/SystemEventType.java

New file
@@ -0,0 +1,12 @@
package com.xiaopeng.api.vo;

/**
 * 定义事件类型
 */
public interface SystemEventType {

    /**
     * 推送导航
     */
    String PUSH_NAVIGATION = "push_navigation";
}

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

@@ -4,7 +4,6 @@
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.xiaopeng.api.dto.automaticPilot.MqttPublishDto;
import com.xiaopeng.api.dto.map.OrderRouteAndFareDto;
import com.xiaopeng.api.dto.operation.LonLatDto;
import com.xiaopeng.api.dto.operation.ReassignOrderDTO;
@@ -21,6 +20,8 @@
import com.xiaopeng.api.model.order.XpCruiseOrder;
import com.xiaopeng.api.model.order.XpOrder;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.api.vo.OrderType;
import com.xiaopeng.api.vo.SystemEventType;
import com.xiaopeng.api.vo.automaticPilot.VehiclePosition;
import com.xiaopeng.api.vo.automaticPilot.proto.down.GeoPoint;
import com.xiaopeng.api.vo.automaticPilot.proto.down.ResponseMessage;
@@ -208,11 +209,17 @@
            if(code == com.xiaopeng.api.vo.automaticPilot.proto.up.StatusCode.OK){
                Object sequence = redisTemplate.opsForValue().get(requestSeq);
                if(sequence!=null){
                    String[] split = sequence.toString().split("_");
                    if(split[0].equals("pushOrder")){
                    JSONObject jsonObject = JSON.parseObject(sequence.toString());
                    String event = jsonObject.getString("event");
                    //推送导航的响应消息
                    if(SystemEventType.PUSH_NAVIGATION.equals(event)){
                        String orderId = jsonObject.getString("orderId");
                        String vin = jsonObject.getString("vin");
                        String orderType = jsonObject.getString("orderType");
                        PopOrderDto dto = new PopOrderDto();
                        dto.setOrderId(Long.valueOf(split[1]));
                        dto.setXpVehicleVin(split[2]);
                        dto.setOrderId(Long.valueOf(orderId));
                        dto.setXpVehicleVin(vin);
                        dto.setOrderType(orderType);
                        xpOrderClient.popOrder(dto);
                    }
                }
@@ -403,6 +410,10 @@
        //开始处理消息对应的业务逻辑
        NavigationDeviationEvent deviationEvent = msgContent.getContent_detail().getObject("deviationEvent", NavigationDeviationEvent.class);
        String requestId = deviationEvent.getRequest_id();
        //导航id
        String routeID = "";
        Long vehicleId = null;
        String orderType = "";
        //偏航事件类型 1：请求导航，2：取消导航
        if (deviationEvent.getEvent_type().equals(RtEventType.RT_EVENT_TYPE_REQUEST)) {
            NavigationDeviationMessage navigationDeviationMessage = deviationEvent.getNavigation_deviation_message();
@@ -414,15 +425,31 @@
            LonLatDto destination = new LonLatDto();
            LonLatDto origin = new LonLatDto();
            if (orderId.contains("XU")) {
                orderType = OrderType.CRUISE_ORDER;
                // todo 下发巡游单的导航数据
                //巡游单
                origin.setLongitude(longitude);
                origin.setLatitude(latitude);
                //先响应消息
                responseMessage(sequence, "");
                //构建导航数据给到车端
                origin.setLongitude(116.40528);
                origin.setLatitude(39.90498);
                destination.setLongitude(116.40528);
                destination.setLatitude(39.90498);
                //响应消息
                responseMessage(sequence, "");

                OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
                dto.setOrderId(Long.parseLong(orderId));
                dto.setOrigin(origin);
                dto.setDestination(destination);
                R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
                if (200 != routeVoR.getCode()) {
                    throw new RuntimeException("获取订单线路和运费失败");
                }
                RouteVo routeVo = routeVoR.getData();
                routeID = routeVo.getRouteID();


//                vehicleId = xpOrder.getVehicleId();
            } else {
                orderType = OrderType.USER_ORDER;
                //正常单
                R<XpOrder> xpOrderR = xpOrderClient.queryOrderById(Long.parseLong(orderId));
                if (200 != xpOrderR.getCode()) {
@@ -439,31 +466,50 @@
                    origin.setLatitude(latitude);
                    destination.setLongitude(xpOrder.getStartLon());
                    destination.setLatitude(xpOrder.getStartLat());

                    OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
                    dto.setOrderId(Long.parseLong(orderId));
                    dto.setOrigin(origin);
                    dto.setDestination(destination);
                    R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
                    if (200 != routeVoR.getCode()) {
                        throw new RuntimeException("获取订单线路和运费失败");
                    }
                    RouteVo routeVo = routeVoR.getData();
                    routeID = routeVo.getRouteID();
                    //缓存数据，用于后续推给乘客导航线路
                    redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), com.alibaba.fastjson.JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
                }
                //驶往下车点的行程
                if (Arrays.asList(6).contains(xpOrder.getStatus())) {
                    //查询起点到终点的线路
                    origin.setLongitude(longitude);
                    origin.setLatitude(latitude);
                    destination.setLongitude(xpOrder.getEndLon());
                    destination.setLatitude(xpOrder.getEndLat());

                    OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
                    dto.setOrderId(Long.parseLong(orderId));
                    dto.setOrigin(origin);
                    dto.setDestination(destination);
                    R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
                    if (200 != routeVoR.getCode()) {
                        throw new RuntimeException("获取订单线路和运费失败");
                    }
                    RouteVo routeVo = routeVoR.getData();
                    routeID = routeVo.getRouteID();
                    //缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
                    redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId(), com.alibaba.fastjson.JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
                }
                OrderRouteAndFareDto dto = new OrderRouteAndFareDto();
                dto.setOrderId(Long.parseLong(orderId));
                dto.setOrigin(origin);
                dto.setDestination(destination);
                R<RouteVo> routeVoR = xpMapClient.getOrderDistanceAndDuration(dto);
                if (200 != routeVoR.getCode()) {
                    throw new RuntimeException("获取订单线路和运费失败");
                }
                RouteVo routeVo = routeVoR.getData();
                R<String> stringR = xpMapClient.queryRouted(routeVo.getRouteID());
            }

            if(StringUtils.isNotEmpty(routeID)){
                XpVehicle xpVehicle = xpVehicleClient.queryById(vehicleId).getData();
                R<String> stringR = xpMapClient.queryRouted(routeID);
                if (200 != stringR.getCode()) {
                    throw new RuntimeException("根据导航ID获取车端需要的导航数据失败");
                }

                //构建导航下发请求对象
                cloudPushNavigationInfo(requestId, routeVo.getRouteID(), stringR.getData(), orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
                cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
            }
        }
    }
@@ -482,8 +528,10 @@
        //导航id
        String routeID = "";
        Long vehicleId = null;
        String orderType = "";
        if (orderId.contains("XU")) {
            // todo 下发巡游单的导航数据
            orderType = OrderType.CRUISE_ORDER;
            //巡游单
            if (orderPhase.equals(OrderPhase.ROUTE_TO_CRUISE)) {
                //先响应消息
@@ -509,17 +557,18 @@
//                vehicleId = xpOrder.getVehicleId();
            }
        } else {
            orderType = OrderType.USER_ORDER;
            //正常单
            R<XpOrder> xpOrderR = xpOrderClient.queryOrderById(Long.parseLong(orderId));
            if (200 != xpOrderR.getCode()) {
                throw new RuntimeException("订单不存在");
            }
            XpOrder xpOrder = xpOrderR.getData();
            XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
            //先响应消息
            responseMessage(sequence, xpVehicle.getVehicleVin());
            //驶往上车点的行程
            if (orderPhase.equals(OrderPhase.ROUTE_TO_PICKUP)) {
                XpVehicle xpVehicle = xpVehicleClient.queryById(xpOrder.getVehicleId()).getData();
                //先响应消息
                responseMessage(sequence, xpVehicle.getVehicleVin());
                //查询车辆位置
                VehiclePosition vehiclePosition = mongoTemplate.findOne(new Query(Criteria.where("vin").is(xpVehicle.getVehicleVin())), VehiclePosition.class);
                if (Objects.isNull(vehiclePosition)) {
@@ -541,6 +590,8 @@
                }
                RouteVo routeVo = routeVoR.getData();
                routeID = routeVo.getRouteID();
                //缓存数据，用于后续推给乘客导航线路
                redisService.setCacheObject("ORDER_NAVIGATION_START_DATA:" + xpOrder.getAppUserId(), com.alibaba.fastjson.JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
            }
            //驶往下车点的行程
            if (orderPhase.equals(OrderPhase.ROUTE_TO_DESTINATION)) {
@@ -564,7 +615,7 @@
                    RouteVo routeVo = routeVoR.getData();
                    routeID = routeVo.getRouteID();
                    //缓存导航数据，用于后面的逻辑中给乘客端推送导航数据
                    redisService.setCacheObject("ORDER_NAVIGATION_DATA:" + xpOrder.getAppUserId(), com.alibaba.fastjson.JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
                    redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + xpOrder.getAppUserId(), com.alibaba.fastjson.JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
                }else{
                    RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
                    routeID = routeVo.getRouteID();
@@ -580,7 +631,7 @@
                throw new RuntimeException("根据导航ID获取车端需要的导航数据失败");
            }
            //构建导航下发请求对象
            cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
            cloudPushNavigationInfo(requestId, routeID, stringR.getData(), orderType, orderId, xpVehicle.getVehicleVin(), xpVehicle.getXpuId());
        }
    }

@@ -832,7 +883,7 @@
     * @param vin                   车辆VIN
     * @param xpuId                 XPU设备id
     */
    public void cloudPushNavigationInfo(String requestId, String routeId, String routeDataContent, String orderId, String vin, String xpuId) {
    public void cloudPushNavigationInfo(String requestId, String routeId, String routeDataContent, String orderType, String orderId, String vin, String xpuId) {
        //组装报文，将routeDateContent信息推送到XPU
        RestoreNavigationData navigationData = new RestoreNavigationData();
        navigationData.setRoute_id(routeId);
@@ -841,7 +892,12 @@
        navigationData.setTimestamp(System.currentTimeMillis());
        long sequence = snowflake.nextId();
        // 处理数据
        redisTemplate.opsForValue().set(sequence,"pushOrder_"+orderId+"_"+vin,30, TimeUnit.MINUTES);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("event", SystemEventType.PUSH_NAVIGATION);
        jsonObject.put("orderType", orderType);
        jsonObject.put("orderId", orderId);
        jsonObject.put("vin", vin);
        redisTemplate.opsForValue().set(sequence, jsonObject.toJSONString(),30, TimeUnit.MINUTES);
        xpuUtil.cloudPushNavigation(navigationData, xpuId, sequence);
    }


 xp-robotaxi-itinerary-boot/src/main/java/com/xiaopeng/itinerary/service/impl/XpPricingServiceImpl.java

@@ -352,7 +352,7 @@
        // 进行缓存
        redisService.setCacheObject(key, voJsonStr, 5l, TimeUnit.MINUTES);
        //缓存导航数据，用于下单后推送导航给车端和乘客端
        redisService.setCacheObject("ORDER_NAVIGATION_DATA:" + userId, JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
        redisService.setCacheObject("ORDER_NAVIGATION_END_DATA:" + userId, JSON.toJSONString(routeVo), 24L, TimeUnit.HOURS);
        return routeAndFareVo;
    }


 xp-robotaxi-order-boot/src/main/java/com/xiaopeng/order/service/impl/XpOrderServiceImpl.java

@@ -5,6 +5,7 @@
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson2.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -41,8 +42,10 @@
import com.xiaopeng.api.model.order.*;
import com.xiaopeng.api.model.vehicleConvoy.XpFleet;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.api.vo.OrderType;
import com.xiaopeng.api.vo.account.UserCouponVo;
import com.xiaopeng.api.vo.automaticPilot.proto.down.cloudOrderOperation.OrderOperationType;
import com.xiaopeng.api.vo.operation.RouteVo;
import com.xiaopeng.api.vo.order.*;
import com.xiaopeng.api.vo.vehicleConvoy.AddTaxiPassengerVo;
import com.xiaopeng.api.vo.vehicleConvoy.CancelTaxiPassengerVo;
@@ -1649,46 +1652,102 @@
    @Transactional
//    @ShardingTransactionType(TransactionType.BASE)
    public void popOrder(PopOrderDto dto) {
        XpOrder order = this.getById(dto.getOrderId());
        order.setAcceptanceTime(LocalDateTime.now());
        AddTaxiPassengerVo addTaxiPassengerVo = new AddTaxiPassengerVo();
        R<XpVehicle> byVehicleVin = xpVehicleClient.findByVehicleVin(dto.getXpVehicleVin());
        XpVehicle vehicle = null;
        if (byVehicleVin.getCode() == 200) {
            vehicle = byVehicleVin.getData();
            order.setVehicleId(vehicle.getId());
            addTaxiPassengerVo.setVin(vehicle.getVehicleVin());
        String orderType = dto.getOrderType();
        Long orderId = dto.getOrderId();
        //巡游单处理逻辑
        if(OrderType.CRUISE_ORDER.equals(orderType)){
            // todo 需要处理巡游的逻辑



        }
        order.setStatus(2);
        //乘客单处理逻辑
        if(OrderType.USER_ORDER.equals(orderType)){
            XpOrder order = this.getById(orderId);
            //订单为待接单状态
            if(order.getStatus() == 1){
                AddTaxiPassengerVo addTaxiPassengerVo = new AddTaxiPassengerVo();
                order.setAcceptanceTime(LocalDateTime.now());
                R<XpVehicle> byVehicleVin = xpVehicleClient.findByVehicleVin(dto.getXpVehicleVin());
                XpVehicle vehicle = null;
                if (byVehicleVin.getCode() == 200) {
                    vehicle = byVehicleVin.getData();
                    order.setVehicleId(vehicle.getId());
                    addTaxiPassengerVo.setVin(vehicle.getVehicleVin());
                }
                order.setStatus(2);

        addTaxiPassengerVo.setUid(order.getAppUserId().toString());
        addTaxiPassengerVo.setOrderNo(order.getOrderNumber());
        // TODO appid
        addTaxiPassengerVo.setAppId("");
                // Redis弹出这个队列元素
                // value 订单Id_经纬度_状态_用户id_订单编号_距离_时间
                String popFirstElement = redisService.popFirstElement(order.getQueueName());
                XpGeoQueryEntity xpGeoQueryEntity = new XpGeoQueryEntity();
                String[] split = popFirstElement.split("_");
                xpGeoQueryEntity.setOrderId(split[0]);
                // 存mongo数据
                xpPricingClient.updateXpGeoQueryEntity(split[0]);
                this.updateById(order);

        BaseVehicleUserDto baseVehicleUserDto = userVehicleClient.addTaxiPassenger(addTaxiPassengerVo);
        if (baseVehicleUserDto.getCode() == 200) {
                // 修改车辆信息
                vehicle.setState(1);
                xpVehicleClient.updateVehicleById(vehicle);

            // Redis弹出这个队列元素
            // value 订单Id_经纬度_状态_用户id_订单编号_距离_时间
            String popFirstElement = redisService.popFirstElement(order.getQueueName());
            XpGeoQueryEntity xpGeoQueryEntity = new XpGeoQueryEntity();
            String[] split = popFirstElement.split("_");
            xpGeoQueryEntity.setOrderId(split[0]);
            // 存mongo数据
            xpPricingClient.updateXpGeoQueryEntity(split[0]);
            this.updateById(order);

            // 修改车辆信息
            vehicle.setState(1);
            xpVehicleClient.updateVehicleById(vehicle);


                //绑定用户和车辆关系
                addTaxiPassengerVo.setUid(order.getAppUserId().toString());
                addTaxiPassengerVo.setOrderNo(order.getOrderNumber());
                // TODO appid
                addTaxiPassengerVo.setAppId("");
                userVehicleClient.addTaxiPassenger(addTaxiPassengerVo);
                //推送乘客车辆到达预约点的导航数据
                sendRoute(order.getAppUserId().toString(), orderId, "ORDER_NAVIGATION_START_DATA");
            }else{
                //推送行起点到终点的驶轨迹给乘客端
                sendRoute(order.getAppUserId().toString(), orderId, "ORDER_NAVIGATION_END_DATA");
            }
        }
    }


    /**
     * 发送乘客导航路径数据
     * @param appUserId
     * @param keyStr
     */
    public void sendRoute(String appUserId, Long orderId, String keyStr){
        Object cacheObject = redisService.getCacheObject(keyStr + ":" + appUserId);
        if(null != cacheObject){
            RouteVo routeVo = JSON.parseObject(cacheObject.toString(), RouteVo.class);
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("type", "ORDER_ROUTE");
            jsonObject.put("timestamp", System.currentTimeMillis());
            JSONObject content = new JSONObject();
            content.put("orderId", orderId);
            content.put("routeType", "ORDER_NAVIGATION_START_DATA".equals(keyStr) ? 1 : 2);
            JSONObject route = new JSONObject();
            route.put("distance", routeVo.getDistance());
            route.put("duration", routeVo.getDuration());
            route.put("routeID", routeVo.getRouteID());

            List<JSONObject> collect = routeVo.getPolyline().stream().map(item->{
                JSONObject point = new JSONObject();
                point.put("latitude", item.getLatitude());
                point.put("longitude", item.getLongitude());
                return point;
            }).collect(Collectors.toList());

            route.put("polyline", collect);
            content.put("route", route);
            jsonObject.put("content", content);
            SendMessageDTO messageDTO = new SendMessageDTO();
            messageDTO.setAppUserId(appUserId);
            messageDTO.setMessage(jsonObject.toJSONString());
            xpPushMessageClient.sendRoute(messageDTO);
        }
    }




    /**
     * 获取当前用户正在执行的订单
     *
     * @param uid