Merge branch 'dev_robotaxi-d_230912_6.1.0' into dev_robotaxi-d_230912_6.1.0_local

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/callback/ISweeperCloudTaskCallback.kt

@@ -3,13 +3,15 @@ package com.mogo.och.sweepercloud.callback
 import chassis.ChassisStatesOuterClass
 import com.mogo.och.sweepercloud.bean.SweeperRoutePlanningUpdateReqBean
 import com.mogo.och.sweepercloud.database.bean.WeltDataBean
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask
+import com.zhjt.mogo.adas.data.AiCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable.IsBootableResp
 import com.zhjt.mogo.adas.data.sweeper.common.SweeperCommon
 import com.zhjt.mogo.adas.data.sweeper.common.SweeperCommon.Code
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.ActionType
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.BigTaskActionPush
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop.StopTaskType
 
 /**
@@ -20,7 +22,7 @@ interface ISweeperCloudTaskCallback {
     /**
      * 接取云端任务/正在执行中任务信息回调
      */
-    fun onSweeperCloudTask(messageType: SweeperCloudTask.MessageType,taskInfo: SweeperTask.TaskInfo?)
+    fun onSweeperCloudTask(messageType: AiCloudTask.MessageType, taskInfo: SweeperTask.TaskInfo?)
 
     /**
      * 云端下发子任务请求pad确认
@@ -40,7 +42,7 @@ interface ISweeperCloudTaskCallback {
     /**
      * 挂起/恢复
      */
-    fun onSweeperCloudTaskSuspendResume(messageType: SweeperCloudTask.MessageType,taskId:String,subTaskId:String,code:Code)
+    fun onSweeperCloudTaskSuspendResume(messageType: AiCloudTask.MessageType,taskId:String,subTaskId:String,code:Code)
 
     /**
      * pad请求云端进入自驾
@@ -50,7 +52,13 @@ interface ISweeperCloudTaskCallback {
     /**
      * 云端同步大任务状态
      */
-    fun onSweeperCloudBigTaskStatus(taskId:String,subTaskStatus: SweeperBigTaskStatus.BigTaskStatus)
+    fun onSweeperCloudBigTaskStatus(taskId:String, bigTaskStatus: SweeperCommon.TaskStatus, isPop:Boolean)
+
+    /**
+     * 云端同步大任务暂停 / 恢复 指令
+     */
+    fun onSweeperCloudBigTaskSuspendResume(taskId:String, actionType: ActionType, isPop:Boolean)
+
     /**
      * 设置轨迹坐标点集合
      */

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/constant/SweeperConst.kt

@@ -55,9 +55,9 @@ class SweeperConst {
         const val EVENT_PARAM_UNABLE_START_REASON = "unable_start_reason";
 
         /**
-         * 订单起终点Marker类型
+         * 子任务起终点Marker类型
          */
-        const val TYPE_MARKER_SWEEPER_ORDER = "TYPE_MARKER_SWEEPER_ORDER"
+        const val TYPE_MARKER_SWEEPER_SUBTASK_START_END = "TYPE_MARKER_SWEEPER_SUBTASK_START_END"
 
         const val TIMER_START_AUTOPILOT_INTERVAL = 20 * 1000L
 

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/fragment/BaseSweeperTabFragment.java

@@ -53,6 +53,7 @@ import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.util.ArrayList;
+import java.util.Random;
 
 import mogo.telematics.pad.MessagePad;
 
@@ -207,6 +208,24 @@ public abstract class BaseSweeperTabFragment<V extends IView, P extends Presente
         findViewById(R.id.btnSendTaskStatus).setOnClickListener(view ->
                 SweeperCloudTaskUtils.mockSendCloudBigTaskStatus()
         );
+        // 模拟 添加高精地图Marker
+        findViewById(R.id.btnAddHDMarker).setOnClickListener(view -> {
+                    // 坐标地址：湖南省衡阳市雁峰区金龙坪街道科学城大道衡山科学城停车场
+                    SweeperCloudTaskUtils.mockAddHdMarker("marker_sweeper_subtask_123_start",
+                            112.57742887355035,
+                            26.82068193910221,
+                            true);
+                    // 坐标地址：湖南省衡阳市雁峰区岳屏镇雁鸣路
+                    SweeperCloudTaskUtils.mockAddHdMarker("marker_sweeper_subtask_123_end",
+                            112.56666738544979,
+                            26.822879976829867,
+                            false);
+                }
+        );
+        // 模拟 移除高精地图Marker
+        findViewById(R.id.btnRemoveHDMarker).setOnClickListener(view ->
+                SweeperCloudTaskUtils.mockRemoveHDMarker()
+        );
         mTrafficDataView.getSpeedImage().setOnLongClickListener(new View.OnLongClickListener() {
             @Override
             public boolean onLongClick(View v) {

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/fragment/SweeperFragment.kt

@@ -5,38 +5,48 @@ import android.view.View
 import androidx.lifecycle.lifecycleScope
 import chassis.ChassisStatesOuterClass
 import com.amap.api.maps.model.LatLng
-import com.elegant.utils.UiThreadHandler
 import com.mogo.eagle.core.data.map.MogoLocation
 import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener.Companion.STATUS_AUTOPILOT_ENABLE
+import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener.Companion.STATUS_AUTOPILOT_RUNNING
+import com.mogo.eagle.core.function.call.map.CallerMapUIServiceManager
 import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger
 import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
 import com.mogo.eagle.core.utilcode.util.ToastUtils
+import com.mogo.map.overlay.core.Level
+import com.mogo.map.overlay.point.Point
+import com.mogo.och.common.module.utils.OCHThreadPoolManager
 import com.mogo.och.common.module.voice.VoiceNotice.showNotice
 import com.mogo.och.sweepercloud.R
 import com.mogo.och.sweepercloud.bean.SweeperRoutePlanningUpdateReqBean
 import com.mogo.och.sweepercloud.callback.SweeperCloudDialogClickListener
+import com.mogo.och.sweepercloud.constant.SweeperConst.Companion.TYPE_MARKER_SWEEPER_SUBTASK_START_END
 import com.mogo.och.sweepercloud.database.MyDataBase
 import com.mogo.och.sweepercloud.presenter.SweeperPresenter
 import com.mogo.och.sweepercloud.ui.dialog.SweeperCloudDialog
 import com.mogo.och.sweepercloud.ui.dialog.SweeperCloudLoadingDialog
+import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils
 import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.createConfirmStartSubTaskDialog
-import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.createReceivedTaskInfoDialog
+import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.createReceivedBigTaskInfoDialog
 import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.createSweeperTaskEndDialog
 import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.createSweeperTaskExceptionEndDialog
 import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.createSweeperTaskNormalEndDialog
+import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.createSweeperTaskResumeDialog
+import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.createSweeperTaskSuspendDialog
 import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils.printMessage
 import com.mogo.och.sweepercloud.view.SweeperCurrentTaskInfoView
 import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.common.SweeperCommon
+import com.zhjt.mogo.adas.data.sweeper.common.SweeperCommon.TaskStatus
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.SubTaskInfo
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.TaskModel
-import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop
-import kotlinx.android.synthetic.main.fragment_och_sweeper.*
-import kotlinx.android.synthetic.main.sweeper_no_data_common_view.*
+import kotlinx.android.synthetic.main.fragment_och_sweeper.sweeper_cl_work_mode
+import kotlinx.android.synthetic.main.fragment_och_sweeper.sweeper_current_task_view
+import kotlinx.android.synthetic.main.sweeper_no_data_common_view.noTaskDataView
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
@@ -54,8 +64,13 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
     private var mLocation: MogoLocation? = null
     private var mTaskInfo: SweeperTask.TaskInfo? = null
     private var mSubTaskType: TaskModel = TaskModel.DEFAULT_MODEL //1:自动驾驶子任务 2：人工驾驶子任务 -1:未知任务类型
-    private var mCurrentSubTaskInfo: SubTaskInfo? = null//当前正在执行的子任务
-    private val mLoadingDialog: SweeperCloudLoadingDialog by lazy { SweeperCloudLoadingDialog(requireContext()) }
+    private var mCurrentRunningSubTaskInfo: SubTaskInfo? = null//当前正在执行的子任务
+    private var mCurrentSuspendSubTaskInfo: SubTaskInfo? = null//当前暂停的子任务
+    private val mLoadingDialog: SweeperCloudLoadingDialog by lazy {
+        SweeperCloudLoadingDialog(
+            requireContext()
+        )
+    }
     private var mDialog: SweeperCloudDialog? = null
 
     override fun getTagName(): String {
@@ -111,12 +126,18 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
      * 设置各种监听事件
      */
     private fun initListener() {
-        getCurrentView().getAutoBtn().setOnClickListener {
+        getCurrentTaskView().getAutoBtn().setOnClickListener {
             //前置条件 (1)必须处于人工驾驶状态 （2）必须有正在执行的子任务，且子任务类型为自动驾驶子任务 才能请求云端进入自驾
-            mCurrentSubTaskInfo?.let {
-                if (mPresenter?.autopilotState == STATUS_AUTOPILOT_ENABLE && it.taskModel == TaskModel.AUTO) {
+            mCurrentRunningSubTaskInfo?.let {
+                if (mPresenter?.autopilotState == STATUS_AUTOPILOT_ENABLE
+                    && it.taskModel == TaskModel.AUTO
+                ) {
                     mLoadingDialog.showLoading()
-                    mPresenter?.sendSweeperAutopilotBootable(mTaskInfo?.taskId, it.subTaskId, it.lineId.toLong())
+                    mPresenter?.sendSweeperAutopilotBootable(
+                        mTaskInfo?.taskId,
+                        it.subTaskId,
+                        it.lineId.toLong()
+                    )
                 }
             }
         }
@@ -124,7 +145,10 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
 
     override fun setAutoState(state: Int) {
         super.setAutoState(state)
-        getCurrentView().updateStartAutoPilotBtnState(state)
+        getCurrentTaskView().updateStartAutoPilotBtnByAutoPilotState(
+            state == STATUS_AUTOPILOT_ENABLE,
+            mCurrentRunningSubTaskInfo?.taskModel == TaskModel.AUTO,
+            mCurrentRunningSubTaskInfo?.taskStatus == TaskStatus.RUNNING)
     }
 
     fun onSweeperFutianCleanSystemState(cleanSystemState: ChassisStatesOuterClass.SweeperFuTianTaskSystemStates) {
@@ -179,7 +203,10 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
     /**
      * 设置云端任务信息
      */
-    fun onSweeperCloudTask(messageType: SweeperCloudTask.MessageType, taskInfo: SweeperTask.TaskInfo?) {
+    fun onSweeperCloudTask(
+        messageType: SweeperCloudTask.MessageType,
+        taskInfo: SweeperTask.TaskInfo?
+    ) {
         this.mTaskInfo = taskInfo
         this.mSubMutableList = taskInfo?.subListList
         CallerLogger.d(SceneConstant.M_SWEEPER + TAG, taskInfo?.let { printMessage(it) })
@@ -189,21 +216,36 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
         }
         //主动拉取云端正在执行的任务，有则直接在任务列表展示
         if (messageType == SweeperCloudTask.MessageType.PadSendGetTaskReq) {
-            getCurrentView().setData(taskInfo, getCurrentPosition())
+            getCurrentTaskView().setData(taskInfo, getCurrentRunningSubTaskPosition())
             setShowCurrentTaskPanelView(true)
             addTaskData()
             mPresenter?.isHasTaskInfo(true)
-        } else {//云端下发的任务信息需要弹窗接取
-            if (taskInfo.isPop) {//是否需要弹窗确认
-                receivedTaskInfoDialog()
+
+            //更新自动驾驶按钮样式
+            updateStartAutoPilotBtnByAutoPilotState()
+
+            //恢复高精地图上的Marker
+            mCurrentRunningSubTaskInfo?.also {
+                addHDMapMarkerBySubTask(it)
+            }
+        } else {//云端下发的大任务信息需要弹窗提示（V3.2.0开始不需要安全员确认接取任务，只能默认接收）
+            //是否需要弹窗确认
+            getCurrentTaskView().setData(taskInfo)
+            setShowCurrentTaskPanelView(true)
+            addTaskData()
+            mPresenter?.isHasTaskInfo(true)
+
+            //更新自动驾驶按钮样式
+            updateStartAutoPilotBtnByAutoPilotState()
+
+            if (taskInfo.isPop) {
+                showReceivedBigTaskDialog()
             } else {
-                mPresenter?.sendSweeperStartTaskResp(taskInfo.taskId, SweeperTask.StartTaskCode.RECEIVED)
-                setShowCurrentTaskPanelView(true)
-                getCurrentView().setData(taskInfo)
-                addTaskData()
-                mPresenter?.isHasTaskInfo(true)
-                //延时2秒再上报确认接取任务，防止时间太短跟收到任务指令冲突
-                UiThreadHandler.postDelayed({ mPresenter?.sendSweeperStartTaskResp(taskInfo.taskId, SweeperTask.StartTaskCode.MANUAL_CONFIRM) }, 2000)
+                // 默认发送接收到消息的ACK回执
+                mPresenter?.sendSweeperStartTaskResp(
+                    taskInfo.taskId,
+                    SweeperTask.StartTaskCode.RECEIVED
+                )
             }
             //设置任务进度
             this.mSubMutableList?.let {
@@ -212,18 +254,35 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
         }
     }
 
+    private fun updateStartAutoPilotBtnByAutoPilotState() {
+        getCurrentTaskView().updateStartAutoPilotBtnByAutoPilotState(
+            mPresenter?.autopilotState == STATUS_AUTOPILOT_ENABLE,
+            mCurrentRunningSubTaskInfo?.taskModel == TaskModel.AUTO,
+            mCurrentRunningSubTaskInfo?.taskStatus == TaskStatus.RUNNING
+        )
+    }
+
     /**
      * 根据云端同步的子任务状态，更新列表中任务状态
      */
-    fun onSweeperUpdateSubTaskStatus(taskId: String, subTaskId: String, subTaskStatus: SweeperCommon.TaskStatus) {
+    fun onSweeperUpdateSubTaskStatus(
+        taskId: String,
+        subTaskId: String,
+        subTaskStatus: SweeperCommon.TaskStatus
+    ) {
         mLoadingDialog.hideLoading()
         updateSubTaskInfo(taskId, subTaskId, subTaskStatus)
+        updateStartAutoPilotBtnByAutoPilotState()
     }
 
     /**
      * 子任务确认时，更新子任务信息
      */
-    private fun updateSubTaskInfo(taskId: String, subTaskId: String, subTaskStatus: SweeperCommon.TaskStatus) {
+    private fun updateSubTaskInfo(
+        taskId: String,
+        subTaskId: String,
+        subTaskStatus: SweeperCommon.TaskStatus
+    ) {
         mTaskInfo?.let {
             //如果云端要更新的任务和本地缓存任务不是同一个，在无法更新子任务状态
             if (taskId != it.taskId) {
@@ -235,23 +294,39 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
                         val subBuilder = subTaskList[index].toBuilder()
                         subBuilder.taskStatus = subTaskStatus
                         if (subTaskStatus == SweeperCommon.TaskStatus.RUNNING) {
-                            mCurrentSubTaskInfo = subBuilder.build()
+                            mCurrentRunningSubTaskInfo = subBuilder.build()
                             //更新当前正在执行的任务状态
                             updateCurrentSubTaskInfo(index + 1)
+
+                            // 先移除在添加 起终点 Marker
+                            addHDMapMarkerBySubTask(subTaskList[index])
                         } else {
-                            mCurrentSubTaskInfo = null
+                            mCurrentRunningSubTaskInfo = null
+                        }
+                        if (subTaskStatus == SweeperCommon.TaskStatus.SUSPENDED) {
+                            mCurrentSuspendSubTaskInfo = subBuilder.build()
+                        } else {
+                            mCurrentSuspendSubTaskInfo = null
                         }
                         //判断是否结束子任务
                         if (subTaskStatus == SweeperCommon.TaskStatus.FINISHED) {
                             //已完成的计入任务进度，未完成的不计入
                             ToastUtils.showLong("任务完成")
                             showNotice("任务完成")
+
+                            removeHDMapMarkerBySubTask(subTaskList[index])
+                        }
+                        // 其他异常结束时也需要remove marker
+                        if (subTaskStatus == SweeperCommon.TaskStatus.ABNORMAL ||
+                            subTaskStatus == SweeperCommon.TaskStatus.CANCEL
+                        ) {
+                            removeHDMapMarkerBySubTask(subTaskList[index])
                         }
                         val builder = it.toBuilder()
                         builder.setSubList(index, subBuilder.build())
                         mTaskInfo = builder.build()
                         mSubMutableList = mTaskInfo?.subListList
-                        getCurrentView().setData(mTaskInfo, index)
+                        getCurrentTaskView().setData(mTaskInfo, index)
                     }
                 }
             }
@@ -261,59 +336,76 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
     /**
      * 云端请求结束大任务
      */
-    fun onSweeperCloudTaskStop(taskId: String, stopTaskType: SweeperTaskStop.StopTaskType, isPop: Boolean) {
+    fun onSweeperCloudTaskStop(
+        taskId: String,
+        stopTaskType: SweeperTaskStop.StopTaskType,
+        isPop: Boolean
+    ) {
         mTaskInfo?.let {
             //如果云端要更新的任务和本地缓存任务不是同一个，在无法结束任务
             if (taskId != it.taskId) {
                 return
             }
+
             if (isPop) {
                 sweeperCloudTaskStopDialog(taskId, stopTaskType, it)
             } else {
-                mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.MANUAL_CONFIRM)
+                // 发送接收到信息的ACK回执
+                mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.RECEIVED)
             }
         }
-
     }
 
     /**
-     * 结束任务弹窗处理
+     * 中止任务弹窗处理
      */
-    private fun sweeperCloudTaskStopDialog(taskId: String, stopTaskType: SweeperTaskStop.StopTaskType, taskInfo: SweeperTask.TaskInfo) {
+    private fun sweeperCloudTaskStopDialog(
+        taskId: String,
+        stopTaskType: SweeperTaskStop.StopTaskType,
+        taskInfo: SweeperTask.TaskInfo
+    ) {
         mLoadingDialog.hideLoading()
-        val timeout: String = getTimeSpent(taskInfo.taskEndTime)
+        val timeoutHintString: String =
+            SweeperCloudTaskUtils.getTimeSpentString(taskInfo.taskEndTime)
         //数据重复导致连续弹窗
         if (mDialog != null && mDialog!!.isShowing) {
             return
         }
+
         if (stopTaskType == SweeperTaskStop.StopTaskType.NORMAL) {
-            mPresenter?.isHasTaskInfo(false)
             mDialog = sweeperCloudTaskNormalEndDialog()
             showNotice("任务已结束")
+            ToastUtils.showLong("任务已结束")
         } else {
+            // 产品确认有弹框时不需要同步弹toast, 只需有TTS
             mDialog = createSweeperTaskEndDialog(context, object : SweeperCloudDialogClickListener {
                 override fun onConfirm() {
-                    mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.MANUAL_CONFIRM)
-                    mLoadingDialog.showLoading()
-                    //ToastUtils.showLong("确认")
+//                    mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.MANUAL_CONFIRM)
+//                    mLoadingDialog.showLoading()
+//                    //ToastUtils.showLong("确认")
+                    // 发送接收到信息的ACK回执
+                    mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.RECEIVED)
                 }
 
                 override fun onRefuseOrEnd() {
-                    mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.MANUAL_REFUSE)
-                    mLoadingDialog.showLoading()
-                    //ToastUtils.showLong("拒绝")
+//                    mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.MANUAL_REFUSE)
+//                    mLoadingDialog.showLoading()
+//                    //ToastUtils.showLong("拒绝")
                 }
 
                 override fun onCountDownStop() {
-                    mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.OVER_TIME)
-                    mLoadingDialog.showLoading()
-                    //ToastUtils.showLong("倒计时")
+//                    mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.OVER_TIME)
+//                    mLoadingDialog.showLoading()
+//                    //ToastUtils.showLong("倒计时")
+                    // 发送接收到信息的ACK回执
+                    mPresenter?.sendSweeperStopTaskResp(taskId, SweeperTaskStop.StopTaskCode.RECEIVED)
                 }
 
                 override fun onNext() {
+
                 }
 
-            }, stopTaskType, timeout)
+            }, stopTaskType, timeoutHintString)
         }
         mDialog?.show()
     }
@@ -324,8 +416,8 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
     private fun sweeperCloudTaskNormalEndDialog(): SweeperCloudDialog? {
         return createSweeperTaskNormalEndDialog(context, object : SweeperCloudDialogClickListener {
             override fun onConfirm() {
-                ToastUtils.showLong("任务已结束")
-                resetTaskInfoPanel()
+//                ToastUtils.showLong("任务已结束")
+//                resetTaskInfoPanel()
             }
 
             override fun onRefuseOrEnd() {
@@ -333,14 +425,13 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
             }
 
             override fun onCountDownStop() {
-                ToastUtils.showLong("任务已结束")
-                resetTaskInfoPanel()
+//                ToastUtils.showLong("任务已结束")
+//                resetTaskInfoPanel()
             }
 
             override fun onNext() {
 
             }
-
         })
     }
 
@@ -348,32 +439,36 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
      * 大任务异常结束弹窗（异常 / 取消）
      */
     private fun sweeperCloudTaskExceptionEndDialog(isCancel: Boolean): SweeperCloudDialog? {
-        return createSweeperTaskExceptionEndDialog(context, object : SweeperCloudDialogClickListener {
-            override fun onConfirm() {
-                ToastUtils.showLong("任务已结束")
-                resetTaskInfoPanel()
-            }
+        return createSweeperTaskExceptionEndDialog(
+            context,
+            object : SweeperCloudDialogClickListener {
+                override fun onConfirm() {
+//                ToastUtils.showLong("任务已结束")
+//                resetTaskInfoPanel()
+                }
 
-            override fun onRefuseOrEnd() {
+                override fun onRefuseOrEnd() {
 
-            }
+                }
 
-            override fun onCountDownStop() {
-                ToastUtils.showLong("任务已结束")
-                resetTaskInfoPanel()
-            }
+                override fun onCountDownStop() {
+//                ToastUtils.showLong("任务已结束")
+//                resetTaskInfoPanel()
+                }
 
-            override fun onNext() {
+                override fun onNext() {
 
-            }
+                }
 
-        }, isCancel)
+            },
+            isCancel
+        )
     }
 
     /**
      * 云端同步大任务状态
      */
-    fun onSweeperCloudBigTaskStatus(taskId: String, subTaskStatus: SweeperBigTaskStatus.BigTaskStatus) {
+    fun onSweeperCloudBigTaskStatus(taskId: String, bigTaskStatus: SweeperCommon.TaskStatus, isPop: Boolean) {
         //隐藏loading
         mLoadingDialog.hideLoading()
         mTaskInfo?.let {
@@ -381,20 +476,110 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
             if (it.taskId != taskId) {
                 return
             }
-            //大任务处于取消状态 异常状态pad端都显示无任务列表
-            if (subTaskStatus == SweeperBigTaskStatus.BigTaskStatus.CANCLE || subTaskStatus == SweeperBigTaskStatus.BigTaskStatus.ABNORMAL || subTaskStatus == SweeperBigTaskStatus.BigTaskStatus.FINISHED) {
+            //大任务处于取消状态/异常结束/正常结束 时都代表大任务结束了，任务列表切换为无任务列表状态
+            if (bigTaskStatus == SweeperCommon.TaskStatus.CANCEL
+                || bigTaskStatus == SweeperCommon.TaskStatus.ABNORMAL
+                || bigTaskStatus == SweeperCommon.TaskStatus.FINISHED
+            ) {
                 mPresenter?.isHasTaskInfo(false)
+                if (isPop) {
+                    mDialog = if (bigTaskStatus == SweeperCommon.TaskStatus.CANCEL
+                        || bigTaskStatus == SweeperCommon.TaskStatus.ABNORMAL){
+                        sweeperCloudTaskExceptionEndDialog(bigTaskStatus == SweeperCommon.TaskStatus.CANCEL)}
+                    else
+                        sweeperCloudTaskNormalEndDialog()
+                    mDialog?.show()
+                }
+
+                showNotice("任务已结束")
+                // 大任务这里也判断移除HD Marker, 双重判断
+                removeHDMapMarkerBySubTask(mCurrentRunningSubTaskInfo)
+                resetTaskInfoPanel()
+            } else if (bigTaskStatus == SweeperCommon.TaskStatus.SUSPENDED) {// 暂停
+                showNotice("任务已暂停")
+                ToastUtils.showLong("任务已暂停")
+                //更新任务列表中大任务状态
+                val builder = it.toBuilder()
+                builder.taskStatus = SweeperCommon.TaskStatus.SUSPENDED
+                mTaskInfo = builder.build()
+                getCurrentTaskView().setData(mTaskInfo, getCurrentRunningSubTaskPosition())
+            } else if (it.taskStatus == SweeperCommon.TaskStatus.SUSPENDED
+                && bigTaskStatus == SweeperCommon.TaskStatus.RUNNING
+            ) { //恢复
+                showNotice("任务已恢复")
+                ToastUtils.showLong("任务已恢复")
+
+                //更新任务列表中大任务状态
+                val builder = it.toBuilder()
+                builder.taskStatus = SweeperCommon.TaskStatus.RUNNING
+                mTaskInfo = builder.build()
+                getCurrentTaskView().setData(mTaskInfo, getCurrentRunningSubTaskPosition())
+            } else if (bigTaskStatus == SweeperCommon.TaskStatus.RUNNING) { //首次开始运行的时候，非恢复后的运行
+                //更新任务列表中大任务状态
+                val builder = it.toBuilder()
+                builder.taskStatus = SweeperCommon.TaskStatus.RUNNING
+                mTaskInfo = builder.build()
+                getCurrentTaskView().setData(mTaskInfo, getCurrentRunningSubTaskPosition())
+            }
+        }
+    }
+
+    /**
+     * 云端同步 暂停/恢复 大任务状态
+     */
+    fun onSweeperCloudBigTaskSuspendOrResume(
+        taskId: String,
+        actionType: SweeperTaskCloudSuspendResume.ActionType,
+        isPop: Boolean
+    ) {
+        //隐藏loading
+        mLoadingDialog.hideLoading()
+        mTaskInfo?.let {
+            //如果云端要更新的任务和本地缓存任务不是同一个，在无法进行任务列表状态更新
+            if (it.taskId != taskId) {
+                return
+            }
+            if (isPop) {
                 //数据重复导致连续弹窗
                 if (mDialog != null && mDialog!!.isShowing) {
                     return
                 }
-                mDialog = if (subTaskStatus == SweeperBigTaskStatus.BigTaskStatus.CANCLE
-                               || subTaskStatus == SweeperBigTaskStatus.BigTaskStatus.ABNORMAL)
-                              sweeperCloudTaskExceptionEndDialog(subTaskStatus == SweeperBigTaskStatus.BigTaskStatus.CANCLE)
-                          else
-                              sweeperCloudTaskNormalEndDialog()
+                when (actionType) {
+                    SweeperTaskCloudSuspendResume.ActionType.SUSPENDED -> {
+                        mDialog = sweeperCloudTaskSuspendDialog(it.taskId)
+                        showNotice("云端暂停任务，注意车辆即将停车！")
+                    }
+
+                    else -> {
+                        var ttsString = "云端恢复任务，注意车辆即将启动！"
+                        mCurrentSuspendSubTaskInfo?.also { suspendSub ->
+                            val isAutoPoilotState =
+                                mPresenter?.autopilotState == STATUS_AUTOPILOT_RUNNING
+                            when {
+                                suspendSub.taskModel == TaskModel.MANUAL -> {
+                                    ttsString = "云端恢复任务，请继续手动驾驶完成任务！"
+                                }
+
+                                suspendSub.taskModel == TaskModel.AUTO && isAutoPoilotState -> {
+                                    ttsString = "云端恢复任务，注意车辆即将启动！"
+                                }
+
+                                suspendSub.taskModel == TaskModel.AUTO && !isAutoPoilotState -> {
+                                    ttsString = "云端恢复任务，请到达合适的位置后开启自动驾驶！"
+                                }
+                            }
+                        }
+                        showNotice(ttsString)
+                        mDialog = sweeperCloudTaskResumeDialog(ttsString, it.taskId)
+                    }
+                }
                 mDialog?.show()
-                showNotice("任务已结束")
+            } else {
+                // 发送接收到信息的ACK回执
+                mPresenter?.sendSweeperSuspendResumeTaskResp(
+                    taskId,
+                    SweeperTaskCloudSuspendResume.Code.RECEIVED
+                )
             }
         }
     }
@@ -402,7 +587,11 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
     /**
      * pad请求云端进入自动驾驶回调
      */
-    fun onSweeperCloudAutopilotBootable(taskId: String, subTaskId: String, isBootableResp: SweeperBootable.IsBootableResp) {
+    fun onSweeperCloudAutopilotBootable(
+        taskId: String,
+        subTaskId: String,
+        isBootableResp: SweeperBootable.IsBootableResp
+    ) {
         mLoadingDialog.hideLoading()
         //如果云端要更新的任务和本地缓存任务不是同一个，在无法进行任务列表状态更新
         mTaskInfo?.let {
@@ -411,8 +600,10 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
             }
             if (isBootableResp.code == SweeperCommon.Code.SUCCEED) {
                 ToastUtils.showLong("上报云控成功")
+                showNotice("上报云控成功")
             } else {
                 ToastUtils.showLong("上报云控失败")
+                showNotice("上报云控失败")
             }
         }
     }
@@ -431,7 +622,8 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
         }
         setShowCurrentTaskPanelView(false)
         mTaskInfo = null
-        mCurrentSubTaskInfo = null
+        mCurrentRunningSubTaskInfo = null
+        mCurrentSuspendSubTaskInfo = null
         mSubMutableList = null
         mSubTaskType = TaskModel.DEFAULT_MODEL
         setTaskProgress("0")
@@ -441,12 +633,12 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
      *
      * 获取当前正在执行的子任务在列表中的位置
      */
-    private fun getCurrentPosition(): Int {
+    private fun getCurrentRunningSubTaskPosition(): Int {
         mSubMutableList = mTaskInfo?.subListList
         mSubMutableList?.apply {
             for (index in 0 until size) {
                 if (get(index).taskStatus == SweeperCommon.TaskStatus.RUNNING) {
-                    mCurrentSubTaskInfo = get(index)
+                    mCurrentRunningSubTaskInfo = get(index)
                     updateCurrentSubTaskInfo(index + 1)
                     return index
                 }
@@ -458,7 +650,7 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
     /**
      * 根据子任务id获取子任务信息
      */
-    private fun bySubTaskIdFindSubTaskInfo(subTaskId: String): SubTaskInfo? {
+    private fun getSubTaskInfoBySubId(subTaskId: String): SubTaskInfo? {
         mSubMutableList = mTaskInfo?.subListList
         mSubMutableList?.apply {
             for (index in 0 until size) {
@@ -474,7 +666,7 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
      * 更新当前子任务信息
      */
     private fun updateCurrentSubTaskInfo(position: Int) {
-        mCurrentSubTaskInfo?.let {
+        mCurrentRunningSubTaskInfo?.let {
             mSubTaskType = it.taskModel
             mPresenter?.setSubtask(it.subTaskId, it.taskModel, it.lineId)
             setEndStationMarker(position)
@@ -492,20 +684,24 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
         super.setTaskRouteList(routeList)
     }
 
-    private fun getCurrentView(): SweeperCurrentTaskInfoView = sweeper_current_task_view
-
+    private fun getCurrentTaskView(): SweeperCurrentTaskInfoView = sweeper_current_task_view
 
     fun handleSubTaskInfoDialog(taskId: String, subTaskId: String, isPop: Boolean) {
         if (mTaskInfo == null) return
         if (mTaskInfo?.taskId != taskId) return
-        val subInfo = bySubTaskIdFindSubTaskInfo(subTaskId)
+        val subInfo = getSubTaskInfoBySubId(subTaskId)
         subInfo?.let {
+            updateSubTaskInfo(taskId, subTaskId, SweeperCommon.TaskStatus.RUNNING)
+
             if (isPop) {
-                showSubTaskInfoDialog(taskId, subTaskId, it)
+                showSubTaskConfirmDialog(taskId, subTaskId, it)
             } else {
-                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.MANUAL_CONFIRM)
-                //mPresenter?.setPreLineId(-1)
-                updateSubTaskInfo(taskId, subTaskId, SweeperCommon.TaskStatus.RUNNING)
+                // 发送接收到消息的ACK回执
+                mPresenter?.sendSweeperTaskConfirmResp(
+                    taskId,
+                    subTaskId,
+                    SweeperTaskConfirm.TaskConfirmCode.RECEIVED
+                )
             }
         }
     }
@@ -513,7 +709,11 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
     /**
      * 云控下发子任务确认弹窗
      */
-    private fun showSubTaskInfoDialog(taskId: String, subTaskId: String, subTaskInfo: SubTaskInfo) {
+    private fun showSubTaskConfirmDialog(
+        taskId: String,
+        subTaskId: String,
+        subTaskInfo: SubTaskInfo
+    ) {
         mLoadingDialog.hideLoading()
         if (mTaskInfo == null) return
         if (mTaskInfo?.taskId != taskId) return
@@ -521,103 +721,262 @@ class SweeperFragment : BaseSweeperTabFragment<SweeperFragment?, SweeperPresente
         if (mDialog != null && mDialog!!.isShowing) {
             return
         }
-        mDialog = createConfirmStartSubTaskDialog(context, object : SweeperCloudDialogClickListener {
-            override fun onConfirm() {
-                //ToastUtils.showLong("确认")
-                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.MANUAL_CONFIRM)
-                //mPresenter?.setPreLineId(-1)
-                updateSubTaskInfo(taskId, subTaskId, SweeperCommon.TaskStatus.RUNNING)
-                mLoadingDialog.showLoading()
-            }
+        mDialog =
+            createConfirmStartSubTaskDialog(context, object : SweeperCloudDialogClickListener {
+                override fun onConfirm() {
+//                //ToastUtils.showLong("确认")
+//                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.MANUAL_CONFIRM)
+//                //mPresenter?.setPreLineId(-1)
+//                updateSubTaskInfo(taskId, subTaskId, SweeperCommon.TaskStatus.RUNNING)
+//                mLoadingDialog.showLoading()
+                    // 发送接收到消息的ACK回执
+                    mPresenter?.sendSweeperTaskConfirmResp(
+                        taskId,
+                        subTaskId,
+                        SweeperTaskConfirm.TaskConfirmCode.RECEIVED
+                    )
+                }
 
-            override fun onRefuseOrEnd() {
-                //ToastUtils.showLong("结束")
-                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.MANUAL_REFUSE_ALL)
-                mLoadingDialog.showLoading()
-            }
+                override fun onRefuseOrEnd() {
+//                //ToastUtils.showLong("结束")
+//                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.MANUAL_REFUSE_ALL)
+//                mLoadingDialog.showLoading()
+                }
 
-            override fun onCountDownStop() {
-                //ToastUtils.showLong("倒计时结束")
-                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.OVER_TIME)
-                mLoadingDialog.showLoading()
-            }
+                override fun onCountDownStop() {
+//                //ToastUtils.showLong("倒计时结束")
+//                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.OVER_TIME)
+//                mLoadingDialog.showLoading()
+                    // 发送接收到消息的ACK回执
+                    mPresenter?.sendSweeperTaskConfirmResp(
+                        taskId,
+                        subTaskId,
+                        SweeperTaskConfirm.TaskConfirmCode.RECEIVED
+                    )
+                }
 
-            override fun onNext() {
-                //ToastUtils.showLong("下一个")
-                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.MANUAL_REFUSE_SINGLE)
-                mLoadingDialog.showLoading()
-            }
-
-        }, subTaskInfo)
+                override fun onNext() {
+//                //ToastUtils.showLong("下一个")
+//                mPresenter?.sendSweeperTaskConfirmResp(taskId, subTaskId, SweeperTaskConfirm.TaskConfirmCode.MANUAL_REFUSE_SINGLE)
+//                mLoadingDialog.showLoading()
+                }
+            }, subTaskInfo)
         mDialog?.show()
-        showNotice("请确认是否执行任务")
+        if (subTaskInfo.taskModel == TaskModel.MANUAL) {
+            showNotice("请确认并执行子任务")
+        } else { //自动驾驶子任务，需要提醒在N档且拉起手刹，做好准备工作
+            showNotice("请确认并执行子任务, 保持N档拉手刹再进入自动驾驶")
+        }
     }
 
     /**
-     * 接取云端任务弹窗
+     * 接取云端大任务弹窗提示
+     * （V3.2.0 开始不需要确认/拒绝/下一个 操作了，安全员只能被动接取，弹框只是一个提示）
      */
-    private fun receivedTaskInfoDialog() {
+    private fun showReceivedBigTaskDialog() {
         mTaskInfo?.let {
-            mPresenter?.sendSweeperStartTaskResp(it.taskId, SweeperTask.StartTaskCode.RECEIVED)
             //数据重复导致连续弹窗
             if (mDialog != null && mDialog!!.isShowing) {
                 return
             }
-            mDialog = createReceivedTaskInfoDialog(context, object : SweeperCloudDialogClickListener {
-                override fun onConfirm() {
-                    //ToastUtils.showLong("确认")
-                    mPresenter?.sendSweeperStartTaskResp(it.taskId, SweeperTask.StartTaskCode.MANUAL_CONFIRM)
-                    setShowCurrentTaskPanelView(true)
-                    getCurrentView().setData(it)
-                    mLoadingDialog.showLoading()
-                    addTaskData()
-                    mPresenter?.isHasTaskInfo(true)
-                }
+            mDialog =
+                createReceivedBigTaskInfoDialog(context, object : SweeperCloudDialogClickListener {
+                    override fun onConfirm() {
+//                    ToastUtils.showLong("确认")
+//                    mPresenter?.sendSweeperStartTaskResp(it.taskId, SweeperTask.StartTaskCode.MANUAL_CONFIRM)
+//                    setShowCurrentTaskPanelView(true)
+//                    getCurrentTaskView().setData(it)
+//                    mLoadingDialog.showLoading()
+//                    addTaskData()
+//                    mPresenter?.isHasTaskInfo(true)
+                        // 默认发送接收到消息的ACK回执
+                        mPresenter?.sendSweeperStartTaskResp(
+                            it.taskId,
+                            SweeperTask.StartTaskCode.RECEIVED
+                        )
+                    }
 
-                override fun onRefuseOrEnd() {
-                    //ToastUtils.showLong("拒绝")
-                    mPresenter?.sendSweeperStartTaskResp(it.taskId, SweeperTask.StartTaskCode.MANUAL_REFUSE)
-                    mLoadingDialog.showLoading()
-                    resetTaskInfoPanel()
-                }
+                    override fun onRefuseOrEnd() {
+//                    ToastUtils.showLong("拒绝")
+//                    mPresenter?.sendSweeperStartTaskResp(it.taskId, SweeperTask.StartTaskCode.MANUAL_REFUSE)
+//                    mLoadingDialog.showLoading()
+//                    resetTaskInfoPanel()
+                    }
 
-                override fun onCountDownStop() {
-                    //ToastUtils.showLong("倒计时结束")
-                    resetTaskInfoPanel()
-                    mPresenter?.sendSweeperStartTaskResp(it.taskId, SweeperTask.StartTaskCode.OVER_TIME)
-                    mLoadingDialog.showLoading()
-                }
+                    override fun onCountDownStop() {
+//                    ToastUtils.showLong("倒计时结束")
+//                    resetTaskInfoPanel()
+//                    mPresenter?.sendSweeperStartTaskResp(it.taskId, SweeperTask.StartTaskCode.OVER_TIME)
+//                    mLoadingDialog.showLoading()
+                        // 默认发送接收到消息的ACK回执
+                        mPresenter?.sendSweeperStartTaskResp(
+                            it.taskId,
+                            SweeperTask.StartTaskCode.RECEIVED
+                        )
+                    }
 
-                override fun onNext() {
+                    override fun onNext() {
 
-                }
-
-            }, it)
+                    }
+                }, it)
             mDialog?.show()
-            showNotice("请确认是否接取任务")
+            showNotice("已为您接取任务")
         }
-
     }
 
     /**
-     * 计算任务超时时间
+     * 大任务暂停弹框
      */
-    private fun getTimeSpent(taskEndTime: Long): String {
+    private fun sweeperCloudTaskSuspendDialog(taskId: String): SweeperCloudDialog? {
+        return createSweeperTaskSuspendDialog(context, object : SweeperCloudDialogClickListener {
+            override fun onConfirm() {
+                // 发送接收到信息的ACK回执
+                mPresenter?.sendSweeperSuspendResumeTaskResp(
+                    taskId,
+                    SweeperTaskCloudSuspendResume.Code.RECEIVED
+                )
+            }
 
-        val timeLag: Long = System.currentTimeMillis() - taskEndTime
-        //天
-        val day: Long = timeLag / (24 * 60 * 60 * 1000)
-        //小时
-        val hour = (timeLag / (60 * 60 * 1000) - day * 24)
-        //分钟
-        val minute = ((timeLag / (60 * 1000)) - day * 24 * 60 - hour * 60)
+            override fun onRefuseOrEnd() {
 
-        if (day >= 1) {
-            return "${day}天${hour}时${minute}分钟"
+            }
+
+            override fun onCountDownStop() {
+                // 发送接收到信息的ACK回执
+                mPresenter?.sendSweeperSuspendResumeTaskResp(
+                    taskId,
+                    SweeperTaskCloudSuspendResume.Code.RECEIVED
+                )
+            }
+
+            override fun onNext() {
+
+            }
+        })
+    }
+
+    /**
+     * 大任务恢复弹框
+     */
+    private fun sweeperCloudTaskResumeDialog(contentStr: String, taskId: String): SweeperCloudDialog? {
+        return createSweeperTaskResumeDialog(context, object : SweeperCloudDialogClickListener {
+            override fun onConfirm() {
+                // 发送接收到信息的ACK回执
+                mPresenter?.sendSweeperSuspendResumeTaskResp(
+                    taskId,
+                    SweeperTaskCloudSuspendResume.Code.RECEIVED
+                )
+            }
+
+            override fun onRefuseOrEnd() {
+
+            }
+
+            override fun onCountDownStop() {
+                // 发送接收到信息的ACK回执
+                mPresenter?.sendSweeperSuspendResumeTaskResp(
+                    taskId,
+                    SweeperTaskCloudSuspendResume.Code.RECEIVED
+                )
+            }
+
+            override fun onNext() {
+
+            }
+        }, contentStr)
+    }
+
+    /**
+     * 添加高精地图中的 子任务 起终点 Marker
+     */
+    private fun addHDMapMarkerBySubTask(subTask: SubTaskInfo) {
+        if (subTask.startLocation == null
+            || subTask.endLocation == null
+            || subTask.subTaskId == null
+        ) {
+            return
         }
-        if (hour >= 1) {
-            return "${hour}时${minute}分钟"
+        val startPoint = subTask.startLocation
+        val endPoint = subTask.endLocation
+        val hdMarkerIdStart = "marker_sweeper_subtask_${subTask.subTaskId}_start"
+        val hdMarkerIdEnd = "marker_sweeper_subtask_${subTask.subTaskId}_end"
+
+        val setStartMarkerRunnable = createSetHDMapMakerRunnable(hdMarkerIdStart, startPoint.wgsLongitude, startPoint.wgsLatitude, true)
+        val setEndMarkerRunnable = createSetHDMapMakerRunnable(hdMarkerIdEnd, endPoint.wgsLongitude, endPoint.wgsLatitude, false)
+        val removeMarkerRunnable = createRemoveHDMapMakerRunnable()
+
+        val addSubTaskHDMarkRunnable = Runnable {
+            // 先移除高精地图中的 子任务 起终点 Marker, 避免重复添加
+            removeMarkerRunnable.run()
+            setStartMarkerRunnable.run()
+            setEndMarkerRunnable.run()
         }
-        return "${minute}分钟"
+        OCHThreadPoolManager.getsInstance().execute(addSubTaskHDMarkRunnable)
+    }
+
+    /**
+     * 移除高精地图中的 子任务 起终点 Marker
+     */
+    private fun removeHDMapMarkerBySubTask(subTaskInfo: SubTaskInfo?) {
+        val removeMarkerRunnable = createRemoveHDMapMakerRunnable()
+        OCHThreadPoolManager.getsInstance().execute(removeMarkerRunnable)
+    }
+
+    /**
+     * 设置高精地图里的Marker Runnable
+     */
+    private fun createSetHDMapMakerRunnable(
+        uuid: String,
+        longitude: Double,
+        latitude: Double,
+        isStartMarker: Boolean
+    ) : Runnable {
+        //开启线程执行起终点marker设置
+        val setMapMarkerRunnable = Runnable {
+            CallerLogger.d(
+                SceneConstant.M_SWEEPER + "-" +TAG + "-setMapMaker",
+                "threadName=${Thread.currentThread().name}, uuid=$uuid, latitude=$latitude, longitude=$longitude"
+            )
+
+            val builder =
+                Point.Options.Builder(TYPE_MARKER_SWEEPER_SUBTASK_START_END, Level.MAP_MARKER)
+                    .setId(uuid)
+                    .anchor(0.5f, 0.5f)
+                    .set3DMode(true)
+                    .isUseGps(true)
+                    .controlAngle(true)
+                    .icon3DRes(if (isStartMarker) R.raw.star_marker else R.raw.end_marker)
+                    .longitude(longitude)
+                    .latitude(latitude)
+            val mapUIController = CallerMapUIServiceManager.getMapUIController()
+            if (mapUIController != null) {
+                val centerLine = mapUIController.getCenterLineInfo(longitude, latitude, -1f)
+                if (null != centerLine) { // 有可能鹰眼map为空没有角度。判空使用后可能造成maker角度跟道路角度不一致 地图未初始化会返回空
+                    val angle = centerLine.angle
+                    if (angle != null) {
+                        builder.rotate(angle.toFloat())
+                    }
+                }
+            }
+            val overlayManager = CallerMapUIServiceManager.getOverlayManager()
+            overlayManager?.showOrUpdatePoint(builder.build())
+        }
+        return setMapMarkerRunnable
+    }
+
+    /**
+     * 移除高精地图里的Marker Runnable
+     */
+    private fun createRemoveHDMapMakerRunnable() : Runnable{
+        //开启线程移除起终点marker设置
+        val removeMapMarkerRunnable = Runnable {
+            CallerLogger.d(
+                SceneConstant.M_SWEEPER + "-" +TAG + "-RemoveMapMaker",
+                "threadName=${Thread.currentThread().name}"
+            )
+            val overlayManager = CallerMapUIServiceManager.getOverlayManager()
+            overlayManager?.removeAllPointsInOwner(TYPE_MARKER_SWEEPER_SUBTASK_START_END)
+        }
+        return removeMapMarkerRunnable
     }
 }

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/model/SweeperTaskModel.java

@@ -39,12 +39,13 @@ import com.mogo.och.sweepercloud.constant.SweeperConst;
 import com.mogo.och.sweepercloud.database.MyDataBase;
 import com.mogo.och.sweepercloud.database.bean.WeltDataBean;
 import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils;
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
+import com.zhjt.mogo.adas.data.AiCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
 
@@ -183,7 +184,6 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
         });
     }
 
-
     public void setControllerStatusCallback(ISweeperControllerStatusCallback callback) {
         this.mControllerStatusCallback = callback;
     }
@@ -217,7 +217,6 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
                 }
             }
         }
-
     };
 
     public void setSubtask(String subTaskId, SweeperTask.TaskModel subTaskType, int currentLineId) {
@@ -257,8 +256,9 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
         return this.mAutopilotState;
     }
 
-    public static List<SweeperRoutePlanningUpdateReqBean.Result> coordinateConverterWgsToGcjList(Context mContext,
-                                                                                                 List<MessagePad.Location> mogoLatLngList) {
+    public static List<SweeperRoutePlanningUpdateReqBean.Result> coordinateConverterWgsToGcjList(
+            Context mContext,
+            List<MessagePad.Location> mogoLatLngList) {
         List<SweeperRoutePlanningUpdateReqBean.Result> points = new ArrayList<>();
         for (MessagePad.Location m : mogoLatLngList) {
             LatLng mogoLatLng = CoordinateCalculateRouteUtil.coordinateConverterWgsToGcj(mContext, m);
@@ -305,7 +305,6 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
             }
             if (mSubTaskType == SweeperTask.TaskModel.MANUAL) {//收集人工驾驶子任务坐标点
                 addCoordinates(gnssInfo);
-                return;
             }
         }
     };
@@ -333,7 +332,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
     }
 
     @Override
-    public void onSweeperFutianCloudTask(@NonNull SweeperCloudTask.MessageType messageType, String reqNo, long sysTime,
+    public void onSweeperFutianCloudTask(@NonNull AiCloudTask.MessageType messageType, String reqNo, long sysTime,
                                          SweeperTask.TaskInfo taskInfo) {
 
         CallerLogger.d(M_SWEEPER + TAG,
@@ -345,7 +344,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
     }
 
     @Override
-    public void onSweeperFutianCloudTaskConfirm(@NonNull SweeperCloudTask.MessageType messageType, String reqNo, long sysTime,
+    public void onSweeperFutianCloudTaskConfirm(@NonNull AiCloudTask.MessageType messageType, String reqNo, long sysTime,
                                                 SweeperTaskConfirm.TaskConfirm taskConfirm) {
 
         CallerLogger.d(M_SWEEPER + TAG, "messageType: " + messageType.getNumber() + " sysTime：" + sysTime + " reqNo：" + reqNo + " " +
@@ -357,7 +356,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
     }
 
     @Override
-    public void onSweeperFutianCloudTaskStatus(@NonNull SweeperCloudTask.MessageType messageType, String reqNo, long sysTime,
+    public void onSweeperFutianCloudTaskStatus(@NonNull AiCloudTask.MessageType messageType, String reqNo, long sysTime,
                                                SweeperTaskStatus.TaskStatusPush taskStatusPush) {
         CallerLogger.d(M_SWEEPER + TAG, "messageType: " + messageType.getNumber() + " sysTime：" + sysTime + " reqNo：" + reqNo + " " +
                 "onSweeperFutianCloudTaskStatus：" + printMessage(taskStatusPush));
@@ -368,7 +367,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
     }
 
     @Override
-    public void onSweeperFutianCloudTaskStop(@NonNull SweeperCloudTask.MessageType messageType, String reqNo, long sysTime,
+    public void onSweeperFutianCloudTaskStop(@NonNull AiCloudTask.MessageType messageType, String reqNo, long sysTime,
                                              SweeperTaskStop.StopTaskReq stopTaskReq) {
         CallerLogger.d(M_SWEEPER + TAG, "messageType: " + messageType.getNumber() + " sysTime：" + sysTime + " reqNo：" + reqNo + " " +
                 "onSweeperFutianCloudTaskStop：" + printMessage(stopTaskReq));
@@ -379,7 +378,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
     }
 
     @Override
-    public void onSweeperFutianCloudTaskSuspendResume(@NonNull SweeperCloudTask.MessageType messageType, String reqNo, long sysTime,
+    public void onSweeperFutianCloudTaskSuspendResume(@NonNull AiCloudTask.MessageType messageType, String reqNo, long sysTime,
                                                       SweeperTaskSuspendResume.SuspendResumeTaskResp suspendResumeTaskResp) {
         CallerLogger.d(M_SWEEPER + TAG, "messageType: " + messageType.getNumber() + " sysTime：" + sysTime + " reqNo：" + reqNo + " " +
                 "onSweeperFutianCloudTaskSuspendResume：" + printMessage(suspendResumeTaskResp));
@@ -391,7 +390,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
     }
 
     @Override
-    public void onSweeperFutianCloudBootable(@NonNull SweeperCloudTask.MessageType messageType, String reqNo, long sysTime,
+    public void onSweeperFutianCloudBootable(@NonNull AiCloudTask.MessageType messageType, String reqNo, long sysTime,
                                              SweeperBootable.IsBootableResp isBootableResp) {
         CallerLogger.d(M_SWEEPER + TAG, "messageType: " + messageType.getNumber() + " sysTime：" + sysTime + " reqNo：" + reqNo + " " +
                 "onSweeperFutianCloudBootable：" + printMessage(isBootableResp));
@@ -402,13 +401,24 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
     }
 
     @Override
-    public void onSweeperFutianCloudBigTaskStatus(@NonNull SweeperCloudTask.MessageType messageType, String reqNo, long sysTime,
+    public void onSweeperFutianCloudBigTaskStatus(@NonNull AiCloudTask.MessageType messageType, String reqNo, long sysTime,
                                                   SweeperBigTaskStatus.BigTaskStatusPush bigTaskStatusPush) {
         CallerLogger.d(M_SWEEPER + TAG, "messageType: " + messageType.getNumber() + " sysTime：" + sysTime + " reqNo：" + reqNo + " " +
                 "onSweeperFutianCloudBigTaskStatus：" + printMessage(bigTaskStatusPush));
         if (mSweeperTaskCallback != null && bigTaskStatusPush != null) {
             msgTypeAndReqNo.put(messageType.getNumber(), reqNo);
-            mSweeperTaskCallback.onSweeperCloudBigTaskStatus(bigTaskStatusPush.getTaskId(), bigTaskStatusPush.getTaskStatus());
+            mSweeperTaskCallback.onSweeperCloudBigTaskStatus(bigTaskStatusPush.getTaskId(), bigTaskStatusPush.getTaskStatus(), bigTaskStatusPush.getIsPop());
+        }
+    }
+
+    @Override
+    public void onSweeperFutianCloudTaskCloudSuspendResume(@NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime,
+                                                           @Nullable SweeperTaskCloudSuspendResume.BigTaskActionPush bigTaskActionPush) {
+        CallerLogger.d(M_SWEEPER + TAG, "messageType: " + messageType.getNumber() + " sysTime：" + sysTime + " reqNo：" + reqNo + " " +
+                "onSweeperFutianCloudTaskCloudSuspendResume：" + printMessage(bigTaskActionPush));
+        if (mSweeperTaskCallback != null && bigTaskActionPush != null) {
+            msgTypeAndReqNo.put(messageType.getNumber(), reqNo);
+            mSweeperTaskCallback.onSweeperCloudBigTaskSuspendResume(bigTaskActionPush.getTaskId(), bigTaskActionPush.getAction(), bigTaskActionPush.getIsPop());
         }
     }
 
@@ -430,24 +440,25 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
 
     @Override
     public void onSweeperFutianTaskIndexData(@NonNull RoboSweeperTaskIndexOuterClass.RoboSweeperTaskIndex roboSweeperTaskIndex) {
-        if (roboSweeperTaskIndex == null) {
-            return;
-        }
-
-        long current = System.currentTimeMillis();
-        if (current - mWeltDataCurrentTimeMillis <= WELT_DATA_INTERVAL_MILLIS) {
-            return;
-        }
-        mWeltDataCurrentTimeMillis = current;
-
-        //没有任务数据时，不处理贴边
-        if (!isHasTaskInfo) {
-            return;
-        }
-
-        CallerLogger.d(M_SWEEPER + TAG,
-                "mSubTaskType：" + mSubTaskType + "+ onSweeperFutianTaskIndexData：" + printMessage(roboSweeperTaskIndex));
-        handleWeltData(roboSweeperTaskIndex);
+//        20230728 因小地图不展示了，贴边数据先不处理了，浪费资源
+//        if (roboSweeperTaskIndex == null) {
+//            return;
+//        }
+//
+//        long current = System.currentTimeMillis();
+//        if (current - mWeltDataCurrentTimeMillis <= WELT_DATA_INTERVAL_MILLIS) {
+//            return;
+//        }
+//        mWeltDataCurrentTimeMillis = current;
+//
+//        //没有任务数据时，不处理贴边
+//        if (!isHasTaskInfo) {
+//            return;
+//        }
+//
+//        CallerLogger.INSTANCE.d(M_SWEEPER + TAG,
+//                "mSubTaskType：" + mSubTaskType + "+ onSweeperFutianTaskIndexData：" + printMessage(roboSweeperTaskIndex));
+//        handleWeltData(roboSweeperTaskIndex);
     }
 
     /**
@@ -494,7 +505,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
         }
     }
 
-    public static String format(double value) {
+    private static String format(double value) {
         BigDecimal bd = new BigDecimal(value);
         bd = bd.setScale(2, RoundingMode.HALF_UP);
         return bd.toString();
@@ -508,8 +519,9 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
         builder.setSn(getDriverSn());
         String reqNo = SweeperCloudTaskUtils.getRequestId();
         SweeperTask.GetTaskReq getTaskReq = builder.build();
+
         CallerLogger.d(M_SWEEPER + TAG,
-                "getCurrentTask:" + printMessage(getTaskReq) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.PadSendGetTaskReq.getNumber());
+                "getCurrentTask:" + printMessage(getTaskReq) + " reqNo:" + reqNo + " messageType:" + AiCloudTask.MessageType.PadSendGetTaskReq.getNumber());
         getAutoPilotControlManager().sendSweeperGetTaskReq(reqNo, getTaskReq);
     }
 
@@ -522,10 +534,11 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
         builder.setTaskId(taskId);
         builder.setCode(code);
         SweeperTask.StartTaskResp startTaskResp = builder.build();
-        String reqNo = msgTypeAndReqNo.get(SweeperCloudTask.MessageType.CloudPushTask.getNumber());
+        String reqNo = msgTypeAndReqNo.get(AiCloudTask.MessageType.CloudPushTask.getNumber());
+
         getAutoPilotControlManager().sendSweeperStartTaskResp(reqNo, startTaskResp);
         CallerLogger.d(M_SWEEPER + TAG,
-                "sendSweeperStartTaskResp:" + printMessage(startTaskResp) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.CloudPushTask.getNumber());
+                "sendSweeperStartTaskResp:" + printMessage(startTaskResp) + " reqNo:" + reqNo + " messageType:" + AiCloudTask.MessageType.CloudPushTask.getNumber());
     }
 
     /**
@@ -538,9 +551,9 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
         builder.setSubTaskId(subTaskId);
         builder.setCode(code);
         SweeperTaskConfirm.TaskConfirmResp taskConfirmResp = builder.build();
-        String reqNo = msgTypeAndReqNo.get(SweeperCloudTask.MessageType.CloudPushTaskConfirm.getNumber());
+        String reqNo = msgTypeAndReqNo.get(AiCloudTask.MessageType.CloudPushTaskConfirm.getNumber());
         CallerLogger.d(M_SWEEPER + TAG,
-                "sendSweeperTaskConfirmResp" + printMessage(taskConfirmResp) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.CloudPushTaskConfirm.getNumber());
+                "sendSweeperTaskConfirmResp" + printMessage(taskConfirmResp) + " reqNo:" + reqNo + " messageType:" + AiCloudTask.MessageType.CloudPushTaskConfirm.getNumber());
         getAutoPilotControlManager().sendSweeperTaskConfirmResp(reqNo, taskConfirmResp);
     }
 
@@ -556,9 +569,10 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
         builder.setTaskId(taskId);
         builder.setCode(code);
         SweeperTaskStop.StopTaskResp stopTaskResp = builder.build();
-        String reqNo = msgTypeAndReqNo.get(SweeperCloudTask.MessageType.CloudPushTaskStop.getNumber());
+        String reqNo = msgTypeAndReqNo.get(AiCloudTask.MessageType.CloudPushTaskStop.getNumber());
+
         CallerLogger.d(M_SWEEPER + TAG,
-                "sendSweeperStopTaskResp" + printMessage(stopTaskResp) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.CloudPushTaskStop.getNumber());
+                "sendSweeperStopTaskResp" + printMessage(stopTaskResp) + " reqNo:" + reqNo + " messageType:" + AiCloudTask.MessageType.CloudPushTaskStop.getNumber());
         getAutoPilotControlManager().sendSweeperStopTaskResp(reqNo, stopTaskResp);
     }
 
@@ -577,13 +591,31 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
         builder.setLineId(lineId);
         SweeperBootable.IsBootable isBootable = builder.build();
         String reqNo = SweeperCloudTaskUtils.getRequestId();
+
         CallerLogger.d(M_SWEEPER + TAG,
-                "sendSweeperAutopilotBootable" + printMessage(isBootable) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.PadSendBootable.getNumber());
+                "sendSweeperAutopilotBootable" + printMessage(isBootable) + " reqNo:" + reqNo + " messageType:" + AiCloudTask.MessageType.PadSendBootable.getNumber());
         getAutoPilotControlManager().sendSweeperAutopilotBootable(reqNo, isBootable);
-        // TODO: 2023/5/16
         //SweeperCloudTaskUtils.mockSendCloudBootable();
     }
 
+    /**
+     * 大任务暂停/恢复 接收到指令到 回复
+     * @param taskId
+     * @param code
+     */
+    public void sendSweeperSuspendResumeTaskResp(String taskId, SweeperTaskCloudSuspendResume.Code code) {
+        SweeperTaskCloudSuspendResume.BigTaskActionResp.Builder builder = SweeperTaskCloudSuspendResume.BigTaskActionResp.newBuilder();
+        builder.setSn(getDriverSn());
+        builder.setTaskId(taskId);
+        builder.setCode(code);
+        SweeperTaskCloudSuspendResume.BigTaskActionResp resp = builder.build();
+        String reqNo = msgTypeAndReqNo.get(AiCloudTask.MessageType.CloudPushTaskSuspendResume.getNumber());
+
+        CallerLogger.d(M_SWEEPER + TAG,
+                "sendSweeperSuspendResumeTaskResp" + printMessage(resp) + " reqNo:" + reqNo + " messageType:" + AiCloudTask.MessageType.CloudPushTaskSuspendResume);
+        getAutoPilotControlManager().sendSweeperCloudSuspendResumeTaskResp(reqNo, resp);
+    }
+
     public CallerAutoPilotControlManager getAutoPilotControlManager() {
         return CallerAutoPilotControlManager.INSTANCE;
     }
@@ -594,23 +626,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
 
     @Override
     public void onAutopilotStatusResponse(@NonNull AutopilotStatusInfo autoPilotStatusInfo) {
-        //CallerLogger.d(M_SWEEPER + TAG, "onAutopilotStatusResponse state:" + autoPilotStatusInfo.getState());
-        this.mAutopilotState = autoPilotStatusInfo.getState();
-        if (mControllerStatusCallback != null) {
-            mControllerStatusCallback.onAutopilotState(autoPilotStatusInfo.getState());
-        }
-        switch (autoPilotStatusInfo.getState()) {
-            case IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_DISABLE://不可自动驾驶
-                break;
-            case IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_ENABLE://人工驾驶
-                break;
-            case IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING://自动驾驶中
-                break;
-            case IMoGoAutopilotStatusListener.STATUS_PARALLEL_DRIVING://平行驾驶
-                break;
-            default:
-                break;
-        }
+
     }
 
     @Override
@@ -631,6 +647,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
     @Override
     public void onAutopilotIpcConnectStatusChanged(int status, @Nullable String reason) {
         if (status == 0x00) {//判断工控机重连后，获取当前正在执行的子任务,延时10秒，防止工控机连接上时SN为空
+            CallerAutoPilotControlManager.INSTANCE.setIsSubscribeBackCameraVideoVideo(0, false);//TODO 当前3.2.0版本产品未规划后摄像头展示功能
             UiThreadHandler.postDelayed(() -> {
                 getCurrentTask();
             }, 10000);
@@ -666,11 +683,27 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
 
     @Override
     public void onAutopilotStatusResponse(int state) {
-        // TODO: 2023/6/19 bingbing
+        //CallerLogger.d(M_SWEEPER + TAG, "onAutopilotStatusResponse state:" + state);
+        this.mAutopilotState = state;
+        if (mControllerStatusCallback != null) {
+            mControllerStatusCallback.onAutopilotState(state);
+        }
+        switch (state) {
+            case IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_DISABLE://不可自动驾驶
+                break;
+            case IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_ENABLE://人工驾驶
+                break;
+            case IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_RUNNING://自动驾驶中
+                break;
+            case IMoGoAutopilotStatusListener.STATUS_PARALLEL_DRIVING://平行驾驶
+                break;
+            default:
+                break;
+        }
     }
 
     @Override
     public void onAutopilotDockerInfo(@NonNull String dockerVersion) {
-        // TODO: 2023/6/19 bingbing
+
     }
 }

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/presenter/SweeperPresenter.java

@@ -1,6 +1,9 @@
 package com.mogo.och.sweepercloud.presenter;
 
 
+import androidx.annotation.NonNull;
+import androidx.lifecycle.LifecycleOwner;
+
 import com.mogo.commons.AbsMogoApplication;
 import com.mogo.commons.mvp.Presenter;
 import com.mogo.eagle.core.data.map.MogoLocation;
@@ -8,8 +11,8 @@ import com.mogo.eagle.core.function.call.autopilot.CallerSweeperFutianCleanSyste
 import com.mogo.eagle.core.utilcode.util.ThreadUtils;
 import com.mogo.och.common.module.manager.autopilotmanager.OCHAdasAbilityManager;
 import com.mogo.och.sweepercloud.bean.SweeperRoutePlanningUpdateReqBean;
-import com.mogo.och.sweepercloud.callback.ISweeperControllerStatusCallback;
 import com.mogo.och.sweepercloud.callback.ISweeperCloudTaskCallback;
+import com.mogo.och.sweepercloud.callback.ISweeperControllerStatusCallback;
 import com.mogo.och.sweepercloud.callback.ISweeperTaskRouteCallback;
 import com.mogo.och.sweepercloud.database.bean.WeltDataBean;
 import com.mogo.och.sweepercloud.fragment.SweeperFragment;
@@ -18,15 +21,12 @@ import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.common.SweeperCommon;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
 
-
 import java.util.ArrayList;
 
-import androidx.annotation.NonNull;
-import androidx.lifecycle.LifecycleOwner;
 import chassis.ChassisStatesOuterClass;
 
 /**
@@ -175,6 +175,15 @@ public class SweeperPresenter extends Presenter<SweeperFragment>
         SweeperTaskModel.getInstance().sendSweeperAutopilotBootable(taskId, subTaskId, lineId);
     }
 
+    /**
+     * 大任务暂停/恢复 接收到指令到 回复
+     * @param taskId
+     * @param code
+     */
+    public void sendSweeperSuspendResumeTaskResp(String taskId, SweeperTaskCloudSuspendResume.Code code) {
+        SweeperTaskModel.getInstance().sendSweeperSuspendResumeTaskResp(taskId, code);
+    }
+
     @Override
     public void setRouteList(@NonNull ArrayList<SweeperRoutePlanningUpdateReqBean.Result> routeList) {
         mView.setTaskRouteList(routeList);
@@ -212,8 +221,13 @@ public class SweeperPresenter extends Presenter<SweeperFragment>
     }
 
     @Override
-    public void onSweeperCloudBigTaskStatus(@NonNull String taskId, SweeperBigTaskStatus.BigTaskStatus subTaskStatus) {
-        ThreadUtils.runOnUiThread(() -> mView.onSweeperCloudBigTaskStatus(taskId, subTaskStatus));
+    public void onSweeperCloudBigTaskStatus(@NonNull String taskId, SweeperCommon.TaskStatus bigTaskStatus, boolean isPop) {
+        ThreadUtils.runOnUiThread(() -> mView.onSweeperCloudBigTaskStatus(taskId, bigTaskStatus, isPop));
+    }
+
+    @Override
+    public void onSweeperCloudBigTaskSuspendResume(@NonNull String taskId, @NonNull SweeperTaskCloudSuspendResume.ActionType actionType, boolean isPop) {
+        ThreadUtils.runOnUiThread(() -> mView.onSweeperCloudBigTaskSuspendOrResume(taskId, actionType, isPop));
     }
 
     @Override

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/util/SweeperCloudTaskUtils.kt

@@ -1,27 +1,36 @@
 package com.mogo.och.sweepercloud.util
 
 import android.content.Context
+import android.util.Log
 import com.elegant.utils.UiThreadHandler
 import com.google.protobuf.MessageOrBuilder
 import com.google.protobuf.TextFormat
 import com.mogo.cloud.passport.MoGoAiCloudClientConfig
+import com.mogo.eagle.core.function.call.map.CallerMapUIServiceManager
 import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger
 import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
+import com.mogo.map.overlay.core.Level
+import com.mogo.map.overlay.point.Point
 import com.mogo.och.common.module.utils.DateTimeUtil
+import com.mogo.och.common.module.utils.OCHThreadPoolManager
 import com.mogo.och.common.module.voice.VoiceNotice
+import com.mogo.och.sweepercloud.R
 import com.mogo.och.sweepercloud.callback.SweeperCloudDialogClickListener
+import com.mogo.och.sweepercloud.constant.SweeperConst
 import com.mogo.och.sweepercloud.model.SweeperTaskModel
 import com.mogo.och.sweepercloud.ui.dialog.SweeperCloudDialog
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask.MessageType
+import com.zhjt.mogo.adas.data.AiCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.common.SweeperCommon
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.*
+import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.Location
+import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.SubTaskInfo
+import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.TaskInfo
+import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.TaskModel
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus
-import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus.BigTaskStatus
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm.TaskConfirm
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop
-import java.util.*
+import java.util.UUID
 
 object SweeperCloudTaskUtils {
     const val TAG = "SweeperCloudTaskUtils"
@@ -41,7 +50,7 @@ object SweeperCloudTaskUtils {
      * 模拟云控发送任务给pad
      */
     @JvmStatic
-    fun mockSendCloudTaskInfo(messageType: MessageType) {
+    fun mockSendCloudTaskInfo(messageType: AiCloudTask.MessageType) {
         val builder = TaskInfo.newBuilder()
         builder.sn = getDriverSn()
         builder.taskId = "10"
@@ -160,7 +169,7 @@ object SweeperCloudTaskUtils {
         builder.taskId = "10"
         builder.subTaskId = "1"
         SweeperTaskModel.getInstance().onSweeperFutianCloudTaskConfirm(
-            MessageType.CloudPushTaskConfirm, "${System.currentTimeMillis()}",
+            AiCloudTask.MessageType.CloudPushTaskConfirm, "${System.currentTimeMillis()}",
             System.currentTimeMillis(), builder.build()
         )
     }
@@ -176,7 +185,7 @@ object SweeperCloudTaskUtils {
         builder.subTaskId = "1"
         builder.taskStatus = SweeperCommon.TaskStatus.RUNNING
         SweeperTaskModel.getInstance().onSweeperFutianCloudTaskStatus(
-            MessageType.CloudPushTaskStatus, "${System.currentTimeMillis()}",
+            AiCloudTask.MessageType.CloudPushTaskStatus, "${System.currentTimeMillis()}",
             System.currentTimeMillis(), builder.build()
         )
     }
@@ -191,7 +200,7 @@ object SweeperCloudTaskUtils {
         builder.taskId = "10"
         builder.type = SweeperTaskStop.StopTaskType.ADVANCE
         SweeperTaskModel.getInstance().onSweeperFutianCloudTaskStop(
-            MessageType.CloudPushTaskStop, "${System.currentTimeMillis()}",
+            AiCloudTask.MessageType.CloudPushTaskStop, "${System.currentTimeMillis()}",
             System.currentTimeMillis(), builder.build()
         )
     }
@@ -204,10 +213,10 @@ object SweeperCloudTaskUtils {
         val builder = SweeperBigTaskStatus.BigTaskStatusPush.newBuilder()
         builder.sn = getDriverSn()
         builder.taskId = "10"
-        builder.taskStatus = BigTaskStatus.FINISHED
+        builder.taskStatus = SweeperCommon.TaskStatus.FINISHED
         builder.systemTime = System.currentTimeMillis()
         SweeperTaskModel.getInstance().onSweeperFutianCloudBigTaskStatus(
-            MessageType.CloudPushBigTaskStatus, "${System.currentTimeMillis()}",
+            AiCloudTask.MessageType.CloudPushBigTaskStatus, "${System.currentTimeMillis()}",
             System.currentTimeMillis(), builder.build()
         )
     }
@@ -224,26 +233,73 @@ object SweeperCloudTaskUtils {
         builder.code = SweeperCommon.Code.SUCCEED
         UiThreadHandler.getsUiHandler().postDelayed({
             SweeperTaskModel.getInstance().onSweeperFutianCloudBootable(
-                MessageType.PadSendBootable, "${System.currentTimeMillis()}",
+                AiCloudTask.MessageType.PadSendBootable, "${System.currentTimeMillis()}",
                 System.currentTimeMillis(), builder.build()
             )
         }, 10000)
     }
 
+    /**
+     * 模式添加高精地图Marker
+     */
+    @JvmStatic
+    fun mockAddHdMarker(uuid: String, longitude: Double, latitude: Double, isStartMarker: Boolean) {
+         //开启线程执行起终点marker设置
+        val setMapMarkerRunnable = Runnable {
+            val builder =
+                Point.Options.Builder(SweeperConst.TYPE_MARKER_SWEEPER_SUBTASK_START_END, Level.MAP_MARKER)
+                    .setId(uuid)
+                    .anchor(0.5f, 0.5f)
+                    .set3DMode(true)
+                    .isUseGps(true)
+                    .controlAngle(true)
+                    .icon3DRes(if (isStartMarker) R.raw.star_marker else R.raw.end_marker)
+                    .longitude(longitude)
+                    .latitude(latitude)
+            val mapUIController = CallerMapUIServiceManager.getMapUIController()
+            if (mapUIController != null) {
+                val centerLine = mapUIController.getCenterLineInfo(longitude, latitude, -1f)
+                if (null != centerLine) { // 有可能鹰眼map为空没有角度。判空使用后可能造成maker角度跟道路角度不一致 地图未初始化会返回空
+                    val angle = centerLine.angle
+                    if (angle != null) {
+                        builder.rotate(angle.toFloat())
+                    }
+                }
+            }
+            val overlayManager = CallerMapUIServiceManager.getOverlayManager()
+            Log.d(TAG, "CallerMapUIServiceManager.getOverlayManager()=$overlayManager")
+            overlayManager?.showOrUpdatePoint(builder.build())
+        }
+        OCHThreadPoolManager.getsInstance().execute(setMapMarkerRunnable)
+    }
+
+    /**
+     * 模拟 移除高精地图Marker
+     */
+    @JvmStatic
+    fun mockRemoveHDMarker() {
+        //开启线程移除起终点marker设置
+        val removeMapMarkerRunnable = Runnable {
+            val overlayManager = CallerMapUIServiceManager.getOverlayManager()
+            overlayManager?.removeAllPointsInOwner(SweeperConst.TYPE_MARKER_SWEEPER_SUBTASK_START_END)
+        }
+        OCHThreadPoolManager.getsInstance().execute(removeMapMarkerRunnable)
+    }
+
     private fun getDriverSn(): String? {
         return MoGoAiCloudClientConfig.getInstance().sn
     }
 
     /**
-     * 创建接收任务弹窗
+     * 创建接收大任务弹窗
      */
     @JvmStatic
-    fun createReceivedTaskInfoDialog(context: Context?, listener: SweeperCloudDialogClickListener?, taskInfo: TaskInfo): SweeperCloudDialog? {
+    fun createReceivedBigTaskInfoDialog(context: Context?, listener: SweeperCloudDialogClickListener?, taskInfo: TaskInfo): SweeperCloudDialog? {
         var builder: SweeperCloudDialog.Builder = SweeperCloudDialog.Builder()
         val startCalendar = DateTimeUtil.formatLongToCalendar(taskInfo.taskStartTime)
         val endCalendar = DateTimeUtil.formatLongToCalendar(taskInfo.taskEndTime)
         builder.titleStr = "任务接取"
-        builder.contentStr = "请确认是否接取${taskInfo.taskName}"
+        builder.contentStr = "已为您接取任务${taskInfo.taskName}"
         builder.tipStr = "（任务时间${DateTimeUtil.formatCalendarToString(startCalendar, DateTimeUtil.HH_mm)}-${
             DateTimeUtil.formatCalendarToString(
                 endCalendar,
@@ -252,8 +308,8 @@ object SweeperCloudTaskUtils {
         }）"
         builder.leftStr = "确认"
         builder.middleStr = ""
-        builder.rightStr = "拒绝"
-        builder.countDownTime = 15
+        builder.rightStr = ""
+        builder.countDownTime = 10
         builder.listener = listener
         return context?.let { it1 -> builder.build(it1) }
     }
@@ -268,20 +324,20 @@ object SweeperCloudTaskUtils {
         subTaskInfo: SubTaskInfo
     ): SweeperCloudDialog? {
         var builder: SweeperCloudDialog.Builder = SweeperCloudDialog.Builder()
-        builder.titleStr = "任务确认"
-        builder.contentStr = "请确认是否执行${subTaskInfo.subTaskName}"
+        builder.titleStr = "子任务确认"
+        builder.contentStr = "请确认并执行子任务 ${subTaskInfo.subTaskName}"
         builder.tipStr =
-            if (subTaskInfo.taskModel == TaskModel.MANUAL) "[需手动驾驶至终点${subTaskInfo.endLocation.siteName}]" else "[自动驾驶至终点${subTaskInfo.endLocation.siteName}]"
+            if (subTaskInfo.taskModel == TaskModel.MANUAL) "[需手动驾驶至终点 ${subTaskInfo.endLocation.siteName}]" else "[自动驾驶至终点 ${subTaskInfo.endLocation.siteName}，请保持N档拉手刹再进入自动驾驶]"
         builder.leftStr = "确认"
-        builder.middleStr = "下一个"
-        builder.rightStr = "结束"
-        builder.countDownTime = 15
+        builder.middleStr = ""
+        builder.rightStr = ""
+        builder.countDownTime = 10
         builder.listener = listener
         return context?.let { it1 -> builder.build(it1) }
     }
 
     /**
-     * 创建结束任务弹窗
+     * 创建任务中止弹窗
      */
     @JvmStatic
     fun createSweeperTaskEndDialog(
@@ -291,28 +347,33 @@ object SweeperCloudTaskUtils {
         timeoutStr: String
     ): SweeperCloudDialog? {
         var builder: SweeperCloudDialog.Builder = SweeperCloudDialog.Builder()
-        builder.titleStr = "任务结束"
+        val titleStr = when (stopTaskType) {
+            SweeperTaskStop.StopTaskType.ADVANCE -> "任务中止"
+            SweeperTaskStop.StopTaskType.EXCEPTION -> "任务异常结束"
+            else -> "任务结束"
+        }
+        builder.titleStr = titleStr
         when (stopTaskType) {
             //任务提前结束
             SweeperTaskStop.StopTaskType.ADVANCE -> {
-                builder.contentStr = "云端请求终止任务，请确认"
-                builder.tipStr = "【确认后请接管停车】"
+                builder.contentStr = "云端中止任务，注意车辆即将停车！"
+                builder.tipStr = ""
                 builder.leftStr = "确认"
                 builder.middleStr = ""
-                builder.rightStr = "拒绝"
-                VoiceNotice.showNotice("云端请求终止任务，请确认")
+                builder.rightStr = ""
+                VoiceNotice.showNotice("云端中止任务")
             }
-            //任务超时结束
-            SweeperTaskStop.StopTaskType.TIMEOUT -> {
-                builder.contentStr = "任务已超时${timeoutStr},请确认是否结束"
-                builder.tipStr = "【结束后请接管停车】"
+            //任务异常结束
+            SweeperTaskStop.StopTaskType.EXCEPTION -> {
+                builder.contentStr = "云端异常结束任务！"
+                builder.tipStr = ""
                 builder.leftStr = "确认"
                 builder.middleStr = ""
-                builder.rightStr = "拒绝"
-                VoiceNotice.showNotice("任务已超时${timeoutStr},请确认是否结束")
+                builder.rightStr = ""
+                VoiceNotice.showNotice("云端异常结束任务")
             }
         }
-        builder.countDownTime = 15
+        builder.countDownTime = 10
         builder.listener = listener
         return context?.let { it1 -> builder.build(it1) }
     }
@@ -358,12 +419,72 @@ object SweeperCloudTaskUtils {
         return context?.let { it1 -> builder.build(it1) }
     }
 
+    @JvmStatic
+    fun createSweeperTaskSuspendDialog(
+        context: Context?,
+        listener: SweeperCloudDialogClickListener?
+    ): SweeperCloudDialog? {
+        var builder: SweeperCloudDialog.Builder = SweeperCloudDialog.Builder()
+        builder.titleStr = "任务暂停"
+        builder.contentStr = "云端暂停任务，注意车辆即将停车！"
+        builder.tipStr = "【云端任务恢复前不可启动自动驾驶】"
+        builder.leftStr = "确认"
+        builder.middleStr = ""
+        builder.rightStr = ""
+        builder.countDownTime = 10
+        builder.listener = listener
+        return context?.let { it1 -> builder.build(it1) }
+    }
+
+    @JvmStatic
+    fun createSweeperTaskResumeDialog(
+        context: Context?,
+        listener: SweeperCloudDialogClickListener?,
+        contentStr: String
+    ): SweeperCloudDialog? {
+        var builder: SweeperCloudDialog.Builder = SweeperCloudDialog.Builder()
+        builder.titleStr = "任务恢复"
+        builder.contentStr = contentStr
+        builder.tipStr = "【注意安全，坐稳扶好】"
+        builder.leftStr = "确认"
+        builder.middleStr = ""
+        builder.rightStr = ""
+        builder.countDownTime = 10
+        builder.listener = listener
+        return context?.let { it1 -> builder.build(it1) }
+    }
+
     @JvmStatic
     fun printMessage(message: MessageOrBuilder): String {
         return "\n"+TextFormat.printer().escapingNonAscii(false).printToString(message)
     }
+
     @JvmStatic
     fun getRequestId():String{
         return UUID.randomUUID().toString()
     }
+
+    /**
+     * 计算任务超时时间
+     */
+    @JvmStatic
+    fun getTimeSpentString(taskEndTime: Long): String {
+        val timeLag: Long = System.currentTimeMillis() - taskEndTime
+        //天
+        val day: Long = timeLag / (24 * 60 * 60 * 1000)
+        //小时
+        val hour = (timeLag / (60 * 60 * 1000) - day * 24)
+        //分钟
+        val minute = ((timeLag / (60 * 1000)) - day * 24 * 60 - hour * 60)
+
+        if (day >= 1) {
+            return "${day}天${hour}时${minute}分钟"
+        }
+        if (hour >= 1) {
+            return "${hour}时${minute}分钟"
+        }
+        return "${minute}分钟"
+    }
+
+
 }

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/view/SubTaskView.kt

@@ -30,15 +30,20 @@ class SubTaskView : ConstraintLayout {
     /**
      * 设置子任务信息
      */
-    fun setData(taskInfo: SubTaskInfo,isLastTask: Boolean = false) {
+    fun setData(taskInfo: SubTaskInfo, isLastTask: Boolean = false) {
         tvSubTaskName.text = taskInfo.subTaskName
-        tvSubTaskName.setTextColor(if (taskInfo.taskStatus==SweeperCommon.TaskStatus.RUNNING) Color.parseColor("#3BD2FF") else Color.parseColor("#FFFFFF"))
+        tvSubTaskName.setTextColor(
+            if (taskInfo.taskStatus == SweeperCommon.TaskStatus.RUNNING)
+                Color.parseColor("#3BD2FF")
+            else
+                Color.parseColor("#FFFFFF")
+        )
         if (taskInfo.taskModel == TaskModel.MANUAL) {//人工驾驶子任务
             ivManualDriving.visibility = View.VISIBLE
         } else {
             ivManualDriving.visibility = View.GONE
         }
-        if (taskInfo.taskStatus==SweeperCommon.TaskStatus.RUNNING) {
+        if (taskInfo.taskStatus == SweeperCommon.TaskStatus.RUNNING) {
             ivSubTask.setImageResource(R.drawable.sweeper_icon_select_subtask)
         } else {
             ivSubTask.setImageResource(R.drawable.sweeper_icon_not_select_subtask)

OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/view/SweeperCurrentTaskInfoView.kt

@@ -1,5 +1,6 @@
 package com.mogo.och.sweepercloud.view
 
+import android.annotation.SuppressLint
 import android.content.Context
 import android.graphics.Color
 import android.util.AttributeSet
@@ -10,10 +11,17 @@ import androidx.constraintlayout.widget.ConstraintLayout
 import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener
 import com.mogo.och.common.module.utils.DateTimeUtil
 import com.mogo.och.sweepercloud.R
+import com.zhjt.mogo.adas.data.sweeper.common.SweeperCommon
 import com.zhjt.mogo.adas.data.sweeper.common.SweeperCommon.TaskStatus
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.SubTaskInfo
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.TaskInfo
-import kotlinx.android.synthetic.main.sweeper_current_task_info.view.*
+import kotlinx.android.synthetic.main.sweeper_current_task_info.view.currentSubTask
+import kotlinx.android.synthetic.main.sweeper_current_task_info.view.lastSubTask
+import kotlinx.android.synthetic.main.sweeper_current_task_info.view.preSubTask
+import kotlinx.android.synthetic.main.sweeper_current_task_info.view.tvStartAuto
+import kotlinx.android.synthetic.main.sweeper_current_task_info.view.tvTaskName
+import kotlinx.android.synthetic.main.sweeper_current_task_info.view.tvTaskState
+import kotlinx.android.synthetic.main.sweeper_current_task_info.view.tvTaskTime
 
 /**
  * 清扫车当前任务信息展示
@@ -46,7 +54,7 @@ class SweeperCurrentTaskInfoView : ConstraintLayout {
 
     private fun initView(context: Context) {
         LayoutInflater.from(context).inflate(R.layout.sweeper_current_task_info, this)
-        setSubTaskState(false)
+        updateTaskStateText(TaskStatus.TO_START)
     }
 
     fun getAutoBtn(): TextView {
@@ -56,7 +64,7 @@ class SweeperCurrentTaskInfoView : ConstraintLayout {
     /**
      * 根据当前自动驾驶状态，更新【请求进入自动驾驶】按钮样式
      */
-    fun updateStartAutoPilotBtnState(autopilotState: Int) {
+    fun updateStartAutoPilotBtnByAutoPilotState(autopilotState: Int) {
         when (autopilotState) {
             //不可自动驾驶
             IMoGoAutopilotStatusListener.STATUS_AUTOPILOT_DISABLE -> {
@@ -82,90 +90,119 @@ class SweeperCurrentTaskInfoView : ConstraintLayout {
     }
 
     /**
-     * 设置当前任务数据
+     * 根据 当前自动驾驶状态-是否是自动驾驶子任务-子任务是否在运行，更新【请求进入自动驾驶】按钮样式
      */
-    fun setData(
-        subTaskBean: TaskInfo?,
-        currentPosition: Int = -1
+    fun updateStartAutoPilotBtnByAutoPilotState(
+        isManualAutoPilotState: Boolean,
+        isAutoSubTask: Boolean,
+        isSubTaskRunning: Boolean
     ) {
-        subTaskBean?.apply {
-            this@SweeperCurrentTaskInfoView.listTask = subListList
-            tvTaskName.text = taskName
-            val calendarStart = DateTimeUtil.formatLongToCalendar(taskStartTime)
-            val calendarEnd = DateTimeUtil.formatLongToCalendar(taskEndTime)
-            tvTaskTime.text =
-                "${DateTimeUtil.formatCalendarToString(calendarStart, DateTimeUtil.HH_mm)}-${
-                    DateTimeUtil.formatCalendarToString(
-                        calendarEnd,
-                        DateTimeUtil.HH_mm
-                    )
-                }"
-        }
-        listTask?.let {
-            //特殊处理当前暂无执行中任务的情况
-            if (currentPosition == -1) {
-                setSubTaskState(false)
-                setCurrentData(currentPosition + 1)
-            } else {
-                setSubTaskState(it[currentPosition].taskStatus == TaskStatus.RUNNING)
-                setCurrentData(currentPosition)
-            }
-        }
-    }
-
-    /**
-     * 设置子任务的状态
-     */
-    private fun setSubTaskState(isWorking: Boolean) {
-        if (isWorking) {
-            tvTaskState.text = "任务执行中"
-            tvTaskState.setBackgroundResource(R.drawable.bg_shape_task_state_working)
+        if (isManualAutoPilotState && isAutoSubTask && isSubTaskRunning) {
+            tvStartAuto.setTextColor(Color.parseColor("#FFFFFFFF"))
+            tvStartAuto.isSelected = true
         } else {
-            tvTaskState.text = "任务待开始"
-            tvTaskState.setBackgroundResource(R.drawable.bg_shape_task_state_not_ready)
+            tvStartAuto.setTextColor(Color.parseColor("#66FFFFFF"))
+            tvStartAuto.isSelected = false
         }
     }
 
-    /**
-     * 填充数据
-     */
-    private fun setCurrentData(currentPosition: Int) {
-        listTask?.let {
-            if (it.size == 1) {
-                preSubTask.setData(it[currentPosition], isLastTask = true)
-                currentSubTask.visibility = View.INVISIBLE
-                lastSubTask.visibility = View.INVISIBLE
-            } else if (it.size == 2) {
-                if (currentPosition == 0) {
-                    preSubTask.setData(it[currentPosition])
-                    currentSubTask.setData(it[1], isLastTask = true)
+        /**
+         * 设置当前任务数据
+         */
+        @SuppressLint("SetTextI18n")
+        fun setData(
+            taskInfo: TaskInfo?,
+            currentPosition: Int = -1
+        ) {
+            // 更新 任务名称、任务时间
+            taskInfo?.apply {
+                this@SweeperCurrentTaskInfoView.listTask = subListList
+                tvTaskName.text = taskName
+                val calendarStart = DateTimeUtil.formatLongToCalendar(taskStartTime)
+                val calendarEnd = DateTimeUtil.formatLongToCalendar(taskEndTime)
+                tvTaskTime.text =
+                    "${DateTimeUtil.formatCalendarToString(calendarStart, DateTimeUtil.HH_mm)}-${
+                        DateTimeUtil.formatCalendarToString(
+                            calendarEnd,
+                            DateTimeUtil.HH_mm
+                        )
+                    }"
+            }
+            // 更新大任务状态
+            updateTaskStateText(taskInfo?.taskStatus ?: TaskStatus.TO_START)
+            // 更新子任务列表
+            listTask?.let {
+                //特殊处理当前暂无执行中任务的情况
+                if (currentPosition == -1) {
+                    setCurrentData(currentPosition + 1)
                 } else {
-                    preSubTask.setData(it[currentPosition - 1])
-                    currentSubTask.setData(it[currentPosition], isLastTask = true)
-                }
-                preSubTask.visibility = View.VISIBLE
-                currentSubTask.visibility = View.VISIBLE
-                lastSubTask.visibility = View.GONE
-            } else {
-                preSubTask.visibility = View.VISIBLE
-                currentSubTask.visibility = View.VISIBLE
-                lastSubTask.visibility = View.VISIBLE
-                //当前正在执行的任务是第一个子任务
-                if (currentPosition == 0) {
-                    preSubTask.setData(it[currentPosition])
-                    currentSubTask.setData(it[1])
-                    lastSubTask.setData(it[2], isLastTask = true)
-                    //当前正在执行的任务是最后一个子任务
-                } else if (currentPosition == it.size - 1) {
-                    preSubTask.setData(it[currentPosition - 2])
-                    currentSubTask.setData(it[currentPosition - 1])
-                    lastSubTask.setData(it[currentPosition], isLastTask = true)
-                } else {
-                    preSubTask.setData(it[currentPosition - 1])
-                    currentSubTask.setData(it[currentPosition])
-                    lastSubTask.setData(it[currentPosition + 1], isLastTask = true)
+                    setCurrentData(currentPosition)
                 }
             }
         }
-    }
-}
+
+        /**
+         * 设置任务的状态
+         */
+        private fun updateTaskStateText(taskStatus: SweeperCommon.TaskStatus) {
+            when (taskStatus) {
+                SweeperCommon.TaskStatus.RUNNING -> {
+                    tvTaskState.text = "任务执行中"
+                    tvTaskState.setBackgroundResource(R.drawable.bg_shape_task_state_working)
+                }
+
+                SweeperCommon.TaskStatus.SUSPENDED -> {
+                    tvTaskState.text = "任务已暂停"
+                    tvTaskState.setBackgroundResource(R.drawable.bg_shape_task_state_not_ready)
+                }
+
+                else -> {
+                    tvTaskState.text = "任务待开始"
+                    tvTaskState.setBackgroundResource(R.drawable.bg_shape_task_state_not_ready)
+                }
+            }
+        }
+
+        /**
+         * 填充数据
+         */
+        private fun setCurrentData(currentPosition: Int) {
+            listTask?.let {
+                if (it.size == 1) {
+                    preSubTask.setData(it[currentPosition], isLastTask = true)
+                    currentSubTask.visibility = View.INVISIBLE
+                    lastSubTask.visibility = View.INVISIBLE
+                } else if (it.size == 2) {
+                    if (currentPosition == 0) {
+                        preSubTask.setData(it[currentPosition])
+                        currentSubTask.setData(it[1], isLastTask = true)
+                    } else {
+                        preSubTask.setData(it[currentPosition - 1])
+                        currentSubTask.setData(it[currentPosition], isLastTask = true)
+                    }
+                    preSubTask.visibility = View.VISIBLE
+                    currentSubTask.visibility = View.VISIBLE
+                    lastSubTask.visibility = View.GONE
+                } else {
+                    preSubTask.visibility = View.VISIBLE
+                    currentSubTask.visibility = View.VISIBLE
+                    lastSubTask.visibility = View.VISIBLE
+                    //当前正在执行的任务是第一个子任务
+                    if (currentPosition == 0) {
+                        preSubTask.setData(it[currentPosition])
+                        currentSubTask.setData(it[1])
+                        lastSubTask.setData(it[2], isLastTask = true)
+                        //当前正在执行的任务是最后一个子任务
+                    } else if (currentPosition == it.size - 1) {
+                        preSubTask.setData(it[currentPosition - 2])
+                        currentSubTask.setData(it[currentPosition - 1])
+                        lastSubTask.setData(it[currentPosition], isLastTask = true)
+                    } else {
+                        preSubTask.setData(it[currentPosition - 1])
+                        currentSubTask.setData(it[currentPosition])
+                        lastSubTask.setData(it[currentPosition + 1], isLastTask = true)
+                    }
+                }
+            }
+        }
+    }

OCH/sweeper/sweeper-cloud/src/main/res/layout/sweeper_base_fragment.xml

@@ -199,7 +199,7 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:background="#f80"
-        android:text="pad查询当前任务"
+        android:text="pad查询当前大任务"
         android:textSize="30sp"
         app:layout_constraintRight_toRightOf="@+id/btnStartAutopilot"
         app:layout_constraintTop_toBottomOf="@+id/btnStartAutopilot" />
@@ -209,7 +209,7 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:background="#f00"
-        android:text="接收云控任务"
+        android:text="模拟云控下发任务"
         android:textSize="30sp"
         app:layout_constraintRight_toRightOf="@+id/btnQueryCurrentTask"
         app:layout_constraintTop_toBottomOf="@+id/btnQueryCurrentTask" />
@@ -219,7 +219,7 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:background="#0f0"
-        android:text="云控子任务确认"
+        android:text="模拟云控发送子任务确认"
         android:textSize="30sp"
         app:layout_constraintRight_toRightOf="@id/btnSendTask"
         app:layout_constraintTop_toBottomOf="@id/btnSendTask" />
@@ -229,7 +229,7 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:background="#00f"
-        android:text="云控结束大任务"
+        android:text="模拟云控结束大任务"
         android:textColor="#fff"
         android:textSize="30sp"
         app:layout_constraintRight_toRightOf="@id/btnSendTask"
@@ -240,7 +240,7 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:background="#ffffff"
-        android:text="云控子任务状态"
+        android:text="模拟云控下发子任务状态"
         android:textSize="30sp"
         app:layout_constraintRight_toRightOf="@id/btnSendEndTask"
         app:layout_constraintTop_toBottomOf="@id/btnSendEndTask" />
@@ -250,19 +250,41 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:background="#000000"
-        android:text="云控大任务状态"
+        android:text="模拟云控下发大任务状态"
         android:textColor="#fff"
         android:textSize="30sp"
         app:layout_constraintRight_toRightOf="@id/btnSendSubtaskStatus"
         app:layout_constraintTop_toBottomOf="@id/btnSendSubtaskStatus" />
 
+    <Button
+        android:id="@+id/btnAddHDMarker"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:background="#000000"
+        android:text="添加高精地图Marker"
+        android:textColor="#f30"
+        android:textSize="30sp"
+        app:layout_constraintRight_toRightOf="@id/btnSendTaskStatus"
+        app:layout_constraintTop_toBottomOf="@id/btnSendTaskStatus" />
+
+    <Button
+        android:id="@+id/btnRemoveHDMarker"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:background="#000000"
+        android:text="移除高精地图Marker"
+        android:textColor="#a90"
+        android:textSize="30sp"
+        app:layout_constraintRight_toRightOf="@id/btnAddHDMarker"
+        app:layout_constraintTop_toBottomOf="@id/btnAddHDMarker" />
+
     <androidx.constraintlayout.widget.Group
         android:id="@+id/groupTestPanel"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:visibility="gone"
         app:constraint_referenced_ids="btnStartAutopilot,btnQueryCurrentTask,btnSendTask,btnSendSubTaskConfirm,btnSendEndTask
-        ,btnSendSubtaskStatus,btnSendTaskStatus"
+        ,btnSendSubtaskStatus,btnSendTaskStatus,btnAddHDMarker,btnRemoveHDMarker"
         tools:visibility="visible" />
 
 

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/base/BaseViewModel.kt

@@ -20,7 +20,7 @@ abstract class BaseViewModel<UiState : IUiState, UiIntent : IUiIntent> : ViewMod
     val uiStateFlow: StateFlow<UiState> = _uiStateFlow
 
     private val _uiIntentFlow: Channel<UiIntent> = Channel()
-    val uiIntentFlow: Flow<UiIntent> = _uiIntentFlow.receiveAsFlow()
+    private val uiIntentFlow: Flow<UiIntent> = _uiIntentFlow.receiveAsFlow()
 
     init {
         viewModelScope.launch {

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/bean/TaxiDriverCarServiceBean.kt

@@ -7,19 +7,29 @@ import com.mogo.eagle.core.data.BaseData
  * @date: 2023/8/2
  */
 
-data class GcjLatLon(var gcjLat: Double, var gcjLon: Double)
+data class GcjLatLon(
+    var gcjLat: Double, var gcjLon: Double
+)
 
 data class UnmannedLoginReqBean(
-    var phone: String?,
-    var captcha: String?,
-    var sn: String,
-    var loc: GcjLatLon?
+    var phone: String?, var captcha: String?, var sn: String, var loc: GcjLatLon?
 )
-data class UnmannedLogoutReqBean(var sn: String, var loc: GcjLatLon?)
 
-data class StartServiceReqBean(var sn: String, var gcjLat: Double, var gcjLon: Double)
+data class UnmannedLogoutReqBean(
+    var sn: String, var loc: GcjLatLon?
+)
 
-data class StartServiceRespBean(var data: Result?): BaseData(){
-    data class Result(var siteId: Long,var siteName: String,var gcjLat: Double, var gcjLon: Double,
-                      var wgs84Lon: Double, var wgs84Lat: Double )
+data class StartServiceReqBean(
+    var sn: String, var gcjLat: Double, var gcjLon: Double
+)
+
+data class StartServiceRespBean(var data: Result?) : BaseData() {
+    data class Result(
+        var siteId: Long,
+        var siteName: String,
+        var gcjLat: Double,
+        var gcjLon: Double,
+        var wgs84Lon: Double,
+        var wgs84Lat: Double
+    )
 }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/bean/TaxiDriverTaskWithOrderBean.kt

@@ -81,9 +81,11 @@ data class QueryCurrentTaskRespBean(var data: Result?) : BaseData() {
         var endSite: Site?,
         var order: OrderDetail?
     ) {
-        //servingStatus = 0 //暂停接单  = 1 //开始接单
-        //taskType = 1 //虚拟任务  = 2 //接驾任务 = 3 //送驾任务
-        //currentStatus 0：空闲  1:获取任务 2:开始任务 3:到达目的地
+        /**
+         * servingStatus: 0 -> 暂停接单  1 -> 开始接单
+         * taskType: 1 -> 虚拟任务   2 -> 接驾任务 3-> 送驾任务
+         * currentStatus: 0-> 空闲  1-> 获取任务 2-> 开始任务 3-> 到达目的地
+         */
         override fun equals(other: Any?): Boolean {
             if (this === other) return true
             if (javaClass != other?.javaClass) return false
@@ -184,10 +186,18 @@ data class QueryCurrentTaskRespBean(var data: Result?) : BaseData() {
     }
 }
 
-data class StartTaskReqBean(var sn: String, var lineId: Long)
+data class StartTaskReqBean(
+    var sn: String, var lineId: Long
+)
+
+data class ArriveSiteReqBean(
+    var sn: String, var siteId: Long
+)
+
+data class PrepareTaskReqBean(
+    var sn: String, var siteId: Long
+)
 
-data class ArriveSiteReqBean(var sn: String, var siteId: Long)
-data class PrepareTaskReqBean(var sn: String, var siteId: Long)
 data class PrepareTaskRespBean(var data: Result?) : BaseData() { //taskType 1:虚拟任务 2:接驾任务3:送驾任务
     data class Result(
         var lineId: Long,
@@ -198,10 +208,22 @@ data class PrepareTaskRespBean(var data: Result?) : BaseData() { //taskType 1:
     )
 }
 
-data class JumpPassengerCheckReqBean(var sn: String, var orderNo: String)
-data class CancelOrderReqBean(var sn: String, var orderNo: String, var cancelType: Int)
-data class OrderCompletedReqBean(var sn: String, var orderNo: String)
-data class QueryCarOrderByNoReqBean(var sn: String, var orderNo: String)
+data class JumpPassengerCheckReqBean(
+    var sn: String, var orderNo: String
+)
+
+data class CancelOrderReqBean(
+    var sn: String, var orderNo: String, var cancelType: Int
+)
+
+data class OrderCompletedReqBean(
+    var sn: String, var orderNo: String
+)
+
+data class QueryCarOrderByNoReqBean(
+    var sn: String, var orderNo: String
+)
+
 data class QueryCarOrderByNoRespBean(var data: Result) : BaseData() {
     data class Result(
         var sn: String,

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/callback/ITaxiOrderStatusCallback.java

@@ -12,7 +12,4 @@ public interface ITaxiOrderStatusCallback {
      * @param isShow 是否显示导航地图（否播报声音）
      */
     void onNaviToEnd(boolean isAmap, boolean isShow);
-
-    // 当前位置距离上车点的距离（米）、预估时间（秒）
-    void onCurrentOrderDistToEndChanged(long meters, long timeInSecond);
 }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/callback/ITaxiTaskWithOrderCallback.kt

@@ -9,9 +9,9 @@ interface ITaxiTaskWithOrderCallback {
     fun onTaskTrajectoryDataChanged(data: TrajectoryListRespBean?)
     fun onOrderCancel()
     fun onOrderArriveAtEnd(orderNo: String)
-    fun onOrderTotalMileAndDurationChanged(mileage: Float, duration: Int)
+    fun onOrderTripInfoChanged(mileage: Float, duration: Int)
     fun onOrderJourneyCompleted()
     fun onStartAutopilot()
-
     fun onStartPrepareTask120s(isStart: Boolean)
+    fun onTaskTripInfoLocalCalculateChanged(meters:Long, timeInSecond:Long)
 }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/network/TaxiTaskWithOrderServiceApi.kt

@@ -124,7 +124,7 @@ interface TaxiTaskWithOrderServiceApi {
      */
     @Headers("Content-type:application/json;charset=UTF-8")
     @POST("/och-taxi-cabin/api/business/v1/contrail")
-    fun contrailList(
+    fun queryTrajectoryByLindIds(
         @Header("appId") appId: String = MoGoAiCloudClientConfig.getInstance().serviceAppId,
         @Header("ticket") ticket: String = MoGoAiCloudClientConfig.getInstance().token,
         @Body data: Array<Long>

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/network/TaxiTaskWithOrderServiceManager.kt

@@ -179,9 +179,9 @@ object TaxiTaskWithOrderServiceManager {
         context: Context, linIds: Array<Long>,
         callback: OchCommonServiceCallback<TrajectoryListRespBean>?
     ) {
-        mOCHTaxiServiceApi.contrailList(
+        mOCHTaxiServiceApi.queryTrajectoryByLindIds(
             data = linIds
         ).transformTry()
-            .subscribe(OchCommonSubscribeImpl(context, callback, "contrailList"))
+            .subscribe(OchCommonSubscribeImpl(context, callback, "queryTrajectoryByLindIds"))
     }
 }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/base/BaseTaxiTabFragment.kt

@@ -4,8 +4,6 @@ import android.animation.ObjectAnimator
 import android.annotation.SuppressLint
 import android.content.Intent
 import android.os.Bundle
-import android.os.Handler
-import android.os.Looper
 import android.os.SystemClock
 import android.view.LayoutInflater
 import android.view.View
@@ -75,11 +73,9 @@ abstract class BaseTaxiTabFragment<V : IView, P : Presenter<V>> : MvpFragment<V,
     // 高德地图轨迹展示fragment
     private var taxiRoutingNaviFragment: TaxiRoutingNaviFragment? = null
 
-    // 开发调试时展示信息德panel
+    // 开发调试时展示信息的panel
     private var debugPanelView: View? = null
 
-    private val mHandler = Handler(Looper.getMainLooper())
-
     private val startAutopilotDrawableIds = arrayOf(
         R.drawable.anim_flow_00000, R.drawable.anim_flow_00001, R.drawable.anim_flow_00002,
         R.drawable.anim_flow_00003, R.drawable.anim_flow_00004, R.drawable.anim_flow_00005,
@@ -361,11 +357,7 @@ abstract class BaseTaxiTabFragment<V : IView, P : Presenter<V>> : MvpFragment<V,
         mPreAutoPilotStatus = parallelDrivingValue
     }
 
-    /**
-     *
-     */
-    // TODO 确认
-    fun updateCtvAutopilotStatusTag(tag: Boolean) {
+    private fun updateCtvAutopilotStatusTag(tag: Boolean) {
         module_mogo_och_autopilot_status.tag = tag
     }
 
@@ -460,7 +452,7 @@ abstract class BaseTaxiTabFragment<V : IView, P : Presenter<V>> : MvpFragment<V,
             autopilotLoadingAnimator!!.startDelay = 100
             autopilotLoadingAnimator!!.duration = 1000 //设置持续时间
             autopilotLoadingAnimator!!.start() //动画开始
-            startingAutoApilotCountDown()
+            startingAutopilotCountDown()
         } else {
             isStarting = false
             if (autopilotLoadingAnimator != null) {
@@ -496,13 +488,13 @@ abstract class BaseTaxiTabFragment<V : IView, P : Presenter<V>> : MvpFragment<V,
             )
             module_och_autopilot_iv.setImageResource(R.drawable.taxi_ic_autopilot_failed)
         }
-        mHandler.postDelayed({
+        UiThreadHandler.postDelayed({
             startOrStopLoadingAnim(false)
             onAutopilotStatusChanged(getState())
         }, 1000L)
     }
 
-    private fun startingAutoApilotCountDown() {
+    private fun startingAutopilotCountDown() {
         UiThreadHandler.postDelayed({
             //未启动成功10s后做处理
             if (isStarting) { //判断动画是否在进行
@@ -607,7 +599,8 @@ abstract class BaseTaxiTabFragment<V : IView, P : Presenter<V>> : MvpFragment<V,
             smallMapView.visibility = View.GONE
         } else {
             taxi_close_navi_icon.visibility = View.GONE
-            module_mogo_och_navi_panel_container.visibility = View.INVISIBLE //2023.9.4高德导航由gone设置成INVISIBLE,保留导航实例,避免导航被挂起
+            module_mogo_och_navi_panel_container.visibility =
+                View.INVISIBLE //2023.9.4高德导航由gone设置成INVISIBLE,保留导航实例,避免导航被挂起
             smallMapView.visibility = View.VISIBLE
         }
     }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/base/TaxiFragment.kt

@@ -70,13 +70,13 @@ class TaxiFragment : BaseTaxiTabFragment<TaxiFragment, TaxiPresenter>(),
 //        }
     }
 
-    private fun openOperationalInfoView() {
-        personalDialogFragment = WeakReference(TaxiPersonalDialogFragment())
-        activity?.supportFragmentManager?.let {
-            personalDialogFragment!!.get()
-                ?.show(it, "service_data")
-        }
-    }
+//    private fun openOperationalInfoView() {
+//        personalDialogFragment = WeakReference(TaxiPersonalDialogFragment())
+//        activity?.supportFragmentManager?.let {
+//            personalDialogFragment!!.get()
+//                ?.show(it, "service_data")
+//        }
+//    }
 
     override fun getTagName(): String {
         return "TaxiFragment"
@@ -86,9 +86,7 @@ class TaxiFragment : BaseTaxiTabFragment<TaxiFragment, TaxiPresenter>(),
         super.onActivityCreated(savedInstanceState)
         loginService =
             ARouter.getInstance().build(OchCommonConst.LOGINSERVICE).navigation() as LoginService
-        if (loginService != null) {
-            loginService!!.registerFragment(this, presenter, TaxiDriverLoginImpl())
-        }
+        loginService?.registerFragment(this, presenter, TaxiDriverLoginImpl())
     }
 
     override fun onCreateView(
@@ -259,11 +257,6 @@ class TaxiFragment : BaseTaxiTabFragment<TaxiFragment, TaxiPresenter>(),
         }
     }
 
-    fun onCurrentOrderDistToEndChanged(meters: Long, timeInSecond: Long) {
-        if (null == taskTabFragment || taskTabFragment!!.get() == null) return
-        taskTabFragment!!.get()!!.onCurrentTaskTripInfoChanged(meters, timeInSecond)
-    }
-
     private fun testRouteInfoUpload() {
         TPRouteDataTestUtils.converToRouteData()
     }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/base/TaxiPresenter.java

@@ -137,11 +137,6 @@ public class TaxiPresenter extends Presenter<TaxiFragment> implements ITaxiADASS
         runOnUIThread(() -> mView.onNaviToEnd(isAmap, isShow));
     }
 
-    @Override
-    public void onCurrentOrderDistToEndChanged(long meters, long timeInSecond) {
-        runOnUIThread(() -> mView.onCurrentOrderDistToEndChanged(meters, timeInSecond));
-    }
-
     @Override
     public void onVRModeChanged(boolean isVRMode) {
         runOnUIThread(() -> mView.switchVRFlatMode(isVRMode));

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/common/AvoidLeakDialog.kt

@@ -24,8 +24,6 @@ open class AvoidLeakDialog : Dialog {
     override fun setOnShowListener(listener: OnShowListener?) {}
     override fun dismiss() {
         super.dismiss()
-        if (null != hostFragmentReference && null != hostFragmentReference!!.get()) {
-            hostFragmentReference!!.get()!!.dismissAllowingStateLoss()
-        }
+        hostFragmentReference?.get()?.dismissAllowingStateLoss()
     }
 }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/debug/DebugView.kt

@@ -189,7 +189,7 @@ public class DebugView @JvmOverloads constructor(
     override fun onOrderArriveAtEnd(orderNo: String) {
     }
 
-    override fun onOrderTotalMileAndDurationChanged(mileage: Float, duration: Int) {
+    override fun onOrderTripInfoChanged(mileage: Float, duration: Int) {
     }
 
     override fun onOrderJourneyCompleted() {
@@ -200,4 +200,7 @@ public class DebugView @JvmOverloads constructor(
 
     override fun onStartPrepareTask120s(isStart: Boolean) {
     }
+
+    override fun onTaskTripInfoLocalCalculateChanged(meters: Long, timeInSecond: Long) {
+    }
 }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaskUiState.kt

@@ -23,7 +23,10 @@ sealed class TaskWithOrderUIState {
     data class TaskDriveToNearestStationTask(val driveToNearestStationTask: StartServiceRespBean.Result?) :
         TaskWithOrderUIState()
 
-    data class UpdateTaskTripInfo(val mileage: Float, val duration: Int) : TaskWithOrderUIState()
+    data class UpdateOrderTripInfo(val mileage: Float, val duration: Int) : TaskWithOrderUIState()
+
+    data class UpdateTaskTripLocalCalculateInfo(val meters: Long, val timeInSecond: Long) :
+        TaskWithOrderUIState()
 
     data class UpdatePrepareTaskDelay120S(val isStart: Boolean) : TaskWithOrderUIState()
 }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaxiCurrentTaskFragment.kt

@@ -27,7 +27,6 @@ import com.mogo.eagle.core.utilcode.util.UiThreadHandler
 import com.mogo.och.common.module.map.AmapNaviToDestinationModel
 import com.mogo.och.common.module.map.ICommonNaviChangedCallback
 import com.mogo.och.common.module.utils.DateTimeUtil
-import com.mogo.och.common.module.voice.VoiceNotice
 import com.mogo.och.common.module.wigets.OCHCommitDialog
 import com.mogo.och.taxi.R
 import com.mogo.och.taxi.bean.OrderDetail
@@ -184,7 +183,7 @@ class TaxiCurrentTaskFragment : BaseFragment(),
                         updateViewByCurrentTaskWithOrder(currentTaskWithOrder)
                     }
 
-                    is TaskWithOrderUIState.UpdateTaskTripInfo -> {
+                    is TaskWithOrderUIState.UpdateOrderTripInfo -> {
                         taskOtherInfo.text =
                             TaskUtils.getCurrentTaskTotalAndDurationHtml(
                                 taskAndOrderUiState.mileage,
@@ -192,6 +191,13 @@ class TaxiCurrentTaskFragment : BaseFragment(),
                             )
                     }
 
+                    is TaskWithOrderUIState.UpdateTaskTripLocalCalculateInfo -> {
+                        updateCurrentTaskTripInfo(
+                            taskAndOrderUiState.meters,
+                            taskAndOrderUiState.timeInSecond
+                        )
+                    }
+
                     is TaskWithOrderUIState.UpdatePrepareTaskDelay120S -> {
                         updatePrepareTaskDelay120SUI(taskAndOrderUiState.isStart)
                     }
@@ -205,33 +211,34 @@ class TaxiCurrentTaskFragment : BaseFragment(),
      */
     private fun updatePrepareTaskDelay120SUI(isStart: Boolean) {
 
-        if (!isStart){
-            prepareTaskCountdownTv.visibility  = View.GONE
+        if (!isStart) {
+            prepareTaskCountdownTv.visibility = View.GONE
             mPrepareTasCountDownTimer?.cancel()
             mPrepareTasCountDownTimer = null
             return
         }
 
-        prepareTaskCountdownTv.visibility  = View.VISIBLE
-        mPrepareTasCountDownTimer = object : CountDownTimer(TIMER_PREPARE_TASK_INTERVAL_120S, 1000L) {// 5倒计时后开启自驾
+        prepareTaskCountdownTv.visibility = View.VISIBLE
+        mPrepareTasCountDownTimer =
+            object : CountDownTimer(TIMER_PREPARE_TASK_INTERVAL_120S, 1000L) {// 5倒计时后开启自驾
 
-            override fun onTick(millisUntilFinished: Long) {
-                // 倒计时
-                UiThreadHandler.post {
-                    prepareTaskCountdownTv.text =
-                        "距离任务获取还有 ${DateTimeUtil.second2MMSS(millisUntilFinished/1000)}"
+                override fun onTick(millisUntilFinished: Long) {
+                    // 倒计时
+                    UiThreadHandler.post {
+                        prepareTaskCountdownTv.text =
+                            "距离任务获取还有 ${DateTimeUtil.second2MMSS(millisUntilFinished / 1000)}"
+                    }
+                }
+
+                override fun onFinish() {
+                    //倒计时结束了...
+                    UiThreadHandler.post {
+                        prepareTaskCountdownTv.visibility = View.GONE
+                    }
+                    mPrepareTasCountDownTimer?.cancel()
                 }
             }
 
-            override fun onFinish() {
-                //倒计时结束了...
-                UiThreadHandler.post {
-                    prepareTaskCountdownTv.visibility  = View.GONE
-                }
-                mPrepareTasCountDownTimer?.cancel()
-            }
-        }
-
         mPrepareTasCountDownTimer?.start()
     }
 
@@ -392,7 +399,7 @@ class TaxiCurrentTaskFragment : BaseFragment(),
 
             TaskTypeEnum.ToOrderEndTask.code, TaskTypeEnum.ToOrderStartTask.code -> {// 接驾任务 或 送驾任务
                 order?.also {
-                    updatePathwayPoint(taskType,endSite?.siteName)
+                    updatePathwayPoint(taskType, endSite?.siteName)
                     handleOrderView(it)
                     updateOrderUI(it)
                 }
@@ -403,7 +410,7 @@ class TaxiCurrentTaskFragment : BaseFragment(),
         updateRemainDistanceAndTime(false)
     }
 
-    private fun updatePathwayPoint(taskType: Int,endSiteName: String?) {
+    private fun updatePathwayPoint(taskType: Int, endSiteName: String?) {
         if (TextUtils.isEmpty(endSiteName)) return
         pathwayPoint.visibility = if (taskType == TaskTypeEnum.ToOrderStartTask.code)
             View.VISIBLE else View.GONE
@@ -595,11 +602,21 @@ class TaxiCurrentTaskFragment : BaseFragment(),
      * @param meters 米
      * @param timeInSecond 秒
      */
-    fun updateCurrentTaskTripInfo(meters: Long, timeInSecond: Long) {
-        val currentTaskWithOrder = TaxiTaskModel.getCurrentTaskWithOrder() ?: return
-        if (currentTaskWithOrder.endSite == null && currentTaskWithOrder == null) return
-        d("NaviToDestinationModel", "taskUitl, ${TaskUtils.getCurrentTaskTripHtml(meters, timeInSecond)}")
-        taskOtherInfo.text = TaskUtils.getCurrentTaskTripHtml(meters, timeInSecond)
+    private fun updateCurrentTaskTripInfo(meters: Long, timeInSecond: Long) {
+        UiThreadHandler.post {
+            val currentTaskWithOrder = TaxiTaskModel.getCurrentTaskWithOrder() ?: return@post
+            if (currentTaskWithOrder.endSite == null) return@post
+            d(
+                TAG,
+                "updateCurrentTaskTripInfo, taskUtil, ${
+                    TaskUtils.getCurrentTaskTripHtml(
+                        meters,
+                        timeInSecond
+                    )
+                }"
+            )
+            taskOtherInfo.text = TaskUtils.getCurrentTaskTripHtml(meters, timeInSecond)
+        }
     }
 
     override fun onDestroyView() {
@@ -715,7 +732,8 @@ class TaxiCurrentTaskFragment : BaseFragment(),
             }
             if ((currentTaskWithOrder?.currentStatus == TaskStatusEnum.StartTask.code
                         && currentTaskWithOrder.order == null)
-                || (currentTaskWithOrder?.order?.orderStatus == TaxiOrderStatusEnum.OnTheWayToEnd.code)) {
+                || (currentTaskWithOrder?.order?.orderStatus == TaxiOrderStatusEnum.OnTheWayToEnd.code)
+            ) {
                 if (naviToEnd.visibility == View.GONE) {
                     naviToEnd.visibility = View.VISIBLE
                 }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaxiCurrentTaskViewModel.kt

@@ -173,7 +173,7 @@ class TaxiCurrentTaskViewModel : BaseViewModel<UnmannedState, TaskUiIntent>(),
         }
     }
 
-    private fun updatePrepareTaskDelay120SUI(isStart: Boolean){
+    private fun updatePrepareTaskDelay120SUI(isStart: Boolean) {
         d(TAG, "UpdatePrepareTaskDelay120SUI = $isStart")
         sendUiState {
             copy(
@@ -195,17 +195,28 @@ class TaxiCurrentTaskViewModel : BaseViewModel<UnmannedState, TaskUiIntent>(),
         }
     }
 
-    private fun updateOrderTotalMileAndDurationUI(mileage: Float, duration: Int) {
-        d(TAG, "updateOrderTotalMileAndDurationUI")
+    private fun updateOrderTripInfoUI(mileage: Float, duration: Int) {
+        d(TAG, "updateOrderTripInfoUI")
         sendUiState {
             copy(
-                taskWithOrderUIState = TaskWithOrderUIState.UpdateTaskTripInfo(
+                taskWithOrderUIState = TaskWithOrderUIState.UpdateOrderTripInfo(
                     mileage, duration
                 )
             )
         }
     }
 
+    private fun updateTaskTripInfoLocalCalculateUI(meters: Long, timeInSecond: Long) {
+        d(TAG, "UpdateTaskTripInfoLocalCalculateUI")
+        sendUiState {
+            copy(
+                taskWithOrderUIState = TaskWithOrderUIState.UpdateTaskTripLocalCalculateInfo(
+                    meters, timeInSecond
+                )
+            )
+        }
+    }
+
     override fun onTaskWithOrderDataChanged(result: QueryCurrentTaskRespBean.Result?) {
         d(TAG, "onTaskWithOrderChanged = result = " + GsonUtil.jsonFromObject(result))
         DebugView.printInfoMsg("[查询TaskWithOrder信息] 更新数据, 刷新UI")
@@ -237,9 +248,11 @@ class TaxiCurrentTaskViewModel : BaseViewModel<UnmannedState, TaskUiIntent>(),
         TaxiTaskModel.queryOrderByOrderNo(orderNo)
     }
 
-    override fun onOrderTotalMileAndDurationChanged(mileage: Float, duration: Int) {
-        //更新总全程信息（公里和分钟）
-        updateOrderTotalMileAndDurationUI(mileage, duration)
+    /**
+     * 更新总全程信息（公里和分钟）, 后端返回的数据
+     */
+    override fun onOrderTripInfoChanged(mileage: Float, duration: Int) {
+        updateOrderTripInfoUI(mileage, duration)
     }
 
     override fun onOrderJourneyCompleted() {
@@ -265,13 +278,20 @@ class TaxiCurrentTaskViewModel : BaseViewModel<UnmannedState, TaskUiIntent>(),
         updatePrepareTaskDelay120SUI(isStart)
     }
 
+    /**
+     * 更新本次任务行程信息, 本地计算的数据
+     */
+    override fun onTaskTripInfoLocalCalculateChanged(meters: Long, timeInSecond: Long) {
+        updateTaskTripInfoLocalCalculateUI(meters, timeInSecond)
+    }
+
     override fun onCarEndServiceSuccess(
         driveToNearestStationTask: StartServiceRespBean.Result?,
         currentTaskWithOrder: QueryCurrentTaskRespBean.Result?
     ) {
         if (currentTaskWithOrder?.endSite != null
             && (currentTaskWithOrder.currentStatus < TaskStatusEnum.CompleteTask.code
-                    ||currentTaskWithOrder.order != null)
+                    || currentTaskWithOrder.order != null)
         ) {
             VoiceNotice.showNotice("暂停接单啦！要完成当前订单哦")
             return

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaxiTaskModel.kt

@@ -473,10 +473,12 @@ object TaxiTaskModel {
                 TAG,
                 "dynamicCalculateRouteInfo: lastSumLength=$lastSumLength, lastTime=$lastTime, threadName=Thread.currentThread().name"
             )
-            mOrderStatusCallback?.onCurrentOrderDistToEndChanged(
-                lastSumLength.toLong(),
-                lastTime.toLong()
-            )
+            mTaxiTaskWithOrderCallbackMap.forEach {
+                val listener = it.value
+                listener.onTaskTripInfoLocalCalculateChanged(
+                    lastSumLength.toLong(),
+                    lastTime.toLong())
+            }
         }
     }
 
@@ -862,7 +864,7 @@ object TaxiTaskModel {
                         TaxiOrderStatusEnum.ArriveAtEnd.code -> {
                             mTaxiTaskWithOrderCallbackMap.forEach {
                                 val listener = it.value
-                                listener.onOrderTotalMileAndDurationChanged(
+                                listener.onOrderTripInfoChanged(
                                     data.data.mileage,
                                     data.data.duration.toInt()
                                 )
@@ -979,7 +981,7 @@ object TaxiTaskModel {
      * 查询当前任务的轨迹
      */
     fun queryTaskTrajectoryByLineIds(planningLineIds: Array<Long>, currentTaskLineId: Long) {
-        DebugView.printInfoMsg("[查询轨迹信息] 准备发送请求，currentTaskLineId=$currentTaskLineId, planningLineIds=$planningLineIds")
+        DebugView.printInfoMsg("[查询轨迹信息] 准备发送请求，currentTaskLineId=$currentTaskLineId, planningLineIds=${GsonUtil.jsonFromObject(planningLineIds)}")
         TaxiTaskWithOrderServiceManager.queryTrajectoryByLindIds(
             mContext,
             planningLineIds,
@@ -989,7 +991,7 @@ object TaxiTaskModel {
                         TAG,
                         "queryTaskTrajectoryByLineIds onSuccess: ${GsonUtil.jsonFromObject(data?.data)}"
                     )
-                    DebugView.printInfoMsg("[查询轨迹信息] 请求success, currentTaskLineId=$currentTaskLineId, planningLineIds=$planningLineIds")
+                    DebugView.printInfoMsg("[查询轨迹信息] 请求success, currentTaskLineId=$currentTaskLineId, planningLineIds=${GsonUtil.jsonFromObject(planningLineIds)}")
                     data?.data?.also {
                         mTaskTrajectoryList.addAll(it)
                         mCurrentTaskTrajectory = it.first { currentTaskLineId == it.lineId }

OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaxiTaskTabFragment.kt

@@ -188,11 +188,6 @@ class TaxiTaskTabFragment : BaseFragment() {
         currentTaskFragment!!.onNaviToEndStationByAmap(isShow)
     }
 
-    fun onCurrentTaskTripInfoChanged(meters: Long, timeInSecond: Long) {
-        if (null == currentTaskFragment) return
-        currentTaskFragment!!.updateCurrentTaskTripInfo(meters, timeInSecond)
-    }
-
     fun onCarTakeOrderStatusChanged() {
         if (null == currentTaskFragment) return
         currentTaskFragment!!.onCarTakeOrderStatusChanged()

core/function-impl/mogo-core-function-datacenter/src/main/java/com/mogo/eagle/core/function/datacenter/autopilot/MoGoAutopilotControlProvider.kt

@@ -63,12 +63,14 @@ import com.zhjt.mogo.adas.data.AdasConstants
 import com.zhjt.mogo.adas.data.bean.MogoReport
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop
 import com.zhjt.service.chain.ChainLog
 import io.netty.channel.Channel
 import mogo.telematics.pad.MessagePad
+import mogo.yycp.paralleldriving.protocol.ParallelDrivingRequest
 import java.util.*
 import java.util.concurrent.TimeUnit
 
@@ -1080,6 +1082,25 @@ class MoGoAutopilotControlProvider :
         return AdasManager.getInstance().sendSweeperAutopilotBootable(reqNo, isBootable)
     }
 
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    override fun sendSweeperCloudSuspendResumeTaskResp(reqNo: String, bigTaskActionResp: SweeperTaskCloudSuspendResume.BigTaskActionResp): Boolean {
+        return AdasManager.getInstance().sendSweeperCloudSuspendResumeTaskResp(reqNo, bigTaskActionResp)
+    }
+
+    override fun sendParallelDrivingReq(
+        reqNo: String,
+        parallelRequest: ParallelDrivingRequest.ParallelRequest
+    ): Boolean {
+        return AdasManager.getInstance().sendParallelDrivingReq(reqNo, parallelRequest)
+    }
+
     override fun setIsDrawPointCloud(isDrawPointCloud: Boolean) {
         if (isDrawPointCloud) {
             AdasManager.getInstance().subscribeInterface(

core/function-impl/mogo-core-function-datacenter/src/main/java/com/mogo/eagle/core/function/datacenter/autopilot/adapter/MoGoAdasListenerImpl.kt

@@ -56,13 +56,14 @@ import com.mogo.support.obu.ObuScene
 import com.zhidao.support.adas.high.OnAdasListener
 import com.zhjt.mogo.adas.data.bean.AdasParam
 import com.zhidao.support.adas.high.common.ProtocolStatus
+import com.zhjt.mogo.adas.data.AiCloudTask
 import com.zhjt.mogo.adas.data.bean.AutopilotStatistics
 import com.zhjt.mogo.adas.data.bean.UnableAutopilotReason
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop
@@ -72,6 +73,7 @@ import mogo.telematics.pad.MessagePad
 import mogo.telematics.pad.MessagePad.TrackedObject
 import mogo.v2x.MogoV2X
 import mogo.v2x.RoadOverviewEvents
+import mogo.yycp.paralleldriving.protocol.ParallelTaskProcessNoticeOuterClass
 import mogo_msg.MogoReportMsg
 import perception.TrafficLightOuterClass
 import planning.RoboSweeperTaskIndexOuterClass
@@ -575,7 +577,7 @@ class MoGoAdasListenerImpl : OnAdasListener {
      */
     override fun onSweeperFutianCloudTask(
         header: MessagePad.Header,
-        messageType: SweeperCloudTask.MessageType,
+        messageType: AiCloudTask.MessageType,
         reqNo: String?,
         sysTime: Long,
         taskInfo: SweeperTask.TaskInfo?
@@ -599,7 +601,7 @@ class MoGoAdasListenerImpl : OnAdasListener {
      */
     override fun onSweeperFutianCloudTaskConfirm(
         header: MessagePad.Header,
-        messageType: SweeperCloudTask.MessageType,
+        messageType: AiCloudTask.MessageType,
         reqNo: String?,
         sysTime: Long,
         taskConfirm: SweeperTaskConfirm.TaskConfirm?
@@ -623,7 +625,7 @@ class MoGoAdasListenerImpl : OnAdasListener {
      */
     override fun onSweeperFutianCloudTaskStatus(
         header: MessagePad.Header,
-        messageType: SweeperCloudTask.MessageType,
+        messageType: AiCloudTask.MessageType,
         reqNo: String?,
         sysTime: Long,
         taskStatusPush: SweeperTaskStatus.TaskStatusPush?
@@ -647,7 +649,7 @@ class MoGoAdasListenerImpl : OnAdasListener {
      */
     override fun onSweeperFutianCloudTaskStop(
         header: MessagePad.Header,
-        messageType: SweeperCloudTask.MessageType,
+        messageType: AiCloudTask.MessageType,
         reqNo: String?,
         sysTime: Long,
         stopTaskReq: SweeperTaskStop.StopTaskReq?
@@ -672,7 +674,7 @@ class MoGoAdasListenerImpl : OnAdasListener {
      */
     override fun onSweeperFutianCloudTaskSuspendResume(
         header: MessagePad.Header,
-        messageType: SweeperCloudTask.MessageType,
+        messageType: AiCloudTask.MessageType,
         reqNo: String?,
         sysTime: Long,
         suspendResumeTaskResp: SweeperTaskSuspendResume.SuspendResumeTaskResp?
@@ -696,7 +698,7 @@ class MoGoAdasListenerImpl : OnAdasListener {
      */
     override fun onSweeperFutianCloudBootable(
         header: MessagePad.Header,
-        messageType: SweeperCloudTask.MessageType,
+        messageType: AiCloudTask.MessageType,
         reqNo: String?,
         sysTime: Long,
         isBootableResp: SweeperBootable.IsBootableResp?
@@ -720,7 +722,7 @@ class MoGoAdasListenerImpl : OnAdasListener {
      */
     override fun onSweeperFutianCloudBigTaskStatus(
         header: MessagePad.Header,
-        messageType: SweeperCloudTask.MessageType,
+        messageType: AiCloudTask.MessageType,
         reqNo: String?,
         sysTime: Long,
         bigTaskStatusPush: SweeperBigTaskStatus.BigTaskStatusPush?
@@ -733,13 +735,46 @@ class MoGoAdasListenerImpl : OnAdasListener {
         )
     }
 
+    /**
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+     *
+     * @param header            头
+     * @param messageType       消息类型
+     * @param reqNo             请求编号
+     * @param sysTime           当前时间戳
+     * @param bigTaskActionPush 数据
+     */
+    override fun onSweeperFutianCloudTaskCloudSuspendResume(header: MessagePad.Header, messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskActionPush: SweeperTaskCloudSuspendResume.BigTaskActionPush?) {
+        CallerSweeperFutianCloudTaskListenerManager.invokeSweeperFutianCloudTaskCloudSuspendResume(messageType, reqNo, sysTime, bigTaskActionPush)
+    }
+
+    /**
+     * 无人化场景
+     * 平行驾驶请求相关状态反馈
+     *
+     * @param header                    头
+     * @param messageType               消息类型
+     * @param reqNo                     请求编号
+     * @param sysTime                   当前时间戳
+     * @param parallelTaskProcessNotice 数据
+     */
+    override fun onParallelDrivingResp(
+        header: MessagePad.Header,
+        messageType: AiCloudTask.MessageType,
+        reqNo: String?,
+        sysTime: Long,
+        parallelTaskProcessNotice: ParallelTaskProcessNoticeOuterClass.ParallelTaskProcessNotice?
+    ) {
+        CallerParallelDrivingListenerManager.invokeParallelDrivingListener(parallelTaskProcessNotice)
+    }
+
     /**
      * 清扫车云端任务未知类型
      *
      * @param header 头
      * @param bytes  原始数据
      */
-    override fun onSweeperFutianCloudTaskUnknown(header: MessagePad.Header, bytes: ByteArray) {
+    override fun onAiCloudTaskUnknown(header: MessagePad.Header, bytes: ByteArray) {
         CallerSweeperFutianCloudTaskListenerManager.invokeSweeperFutianCloudTaskUnknown(bytes)
     }
 

core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/mofang/MoFangCommandExecutor.kt

@@ -3,8 +3,10 @@ package com.zhjt.mogo_core_function_devatools.mofang
 import android.os.*
 import android.util.*
 import android.view.KeyEvent
+import com.mogo.eagle.core.data.config.*
 import com.mogo.eagle.core.function.call.autopilot.*
 import com.mogo.eagle.core.network.utils.GsonUtil
+import com.mogo.eagle.core.utilcode.mogo.*
 import com.zhjt.mogo_core_function_devatools.mofang.MoFangAnalyticUtils.Companion.EVENT_EXECUTE
 import com.zhjt.mogo_core_function_devatools.mofang.MoFangAnalyticUtils.Companion.EVENT_EXECUTE_SUB_KEYCODE
 import com.zhjt.mogo_core_function_devatools.mofang.MoFangAnalyticUtils.Companion.EVENT_EXECUTE_SUB_TYPE
@@ -82,7 +84,13 @@ internal class MoFangCommandExecutor {
                     MoFangAnalyticUtils.track(EVENT_EXECUTE, mutableMapOf(EVENT_EXECUTE_SUB_KEYCODE to (getKeycodeByWhat(msg.what) ?: ""), EVENT_EXECUTE_SUB_TYPE to (getInputTypeByWhat(msg.what) ?: "")))
                     linkedLog?.record(mapOf("执行:${System.currentTimeMillis()}" to "$message, $json"))
                     Log.d(TAG, "--- 启动自驾 ----入参:$json")
-                    CallerAutoPilotControlManager.startAutoPilot(parameters)
+                    //清扫车有FSM模块，魔方启动自驾时需要将Source修改为魔方，以便telamatics做区分并在转发时增加flag标记
+                    if (AppIdentityModeUtils.isSweeper(FunctionBuildConfig.appIdentityMode)) {
+                        CallerAutoPilotControlManager.startAutoPilotByMoFang(parameters)
+                    } else{
+                        CallerAutoPilotControlManager.startAutoPilot(parameters)
+                    }
+
                 } catch (t: Throwable) {
                     t.printStackTrace()
                     Log.e(TAG, "error: ${t.message}, msg-> $msg")

core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/report/IPCReportManager.kt

@@ -2,14 +2,12 @@ package com.zhjt.mogo_core_function_devatools.report
 
 import android.app.Activity
 import android.content.Context
-import com.mogo.eagle.core.data.config.FunctionBuildConfig
 import com.mogo.eagle.core.data.msgbox.MsgBoxBean
 import com.mogo.eagle.core.data.msgbox.MsgBoxType
 import com.mogo.eagle.core.data.deva.report.ReportEntity
 import com.mogo.eagle.core.function.api.autopilot.IMoGoAutopilotStatusListener
 import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager
 import com.mogo.eagle.core.function.call.msgbox.CallerMsgBoxManager
-import com.mogo.eagle.core.utilcode.mogo.AppIdentityModeUtils
 import com.mogo.eagle.core.utilcode.util.TimeUtils
 import mogo_msg.MogoReportMsg
 
@@ -47,11 +45,8 @@ class IPCReportManager : IMoGoAutopilotStatusListener {
     private val reportList = arrayListOf<ReportEntity>()
 
     fun initServer(){
-        //乘客屏不显示监控信息弹窗,只在司机端提示
-        if(AppIdentityModeUtils.isDriver(FunctionBuildConfig.appIdentityMode)){
-            // 添加 ADAS状态 监听
-            CallerAutoPilotStatusListenerManager.addListener(TAG, this)
-        }
+        // 添加 ADAS状态 监听
+        CallerAutoPilotStatusListenerManager.addListener(TAG, this)
     }
 
     fun showReportListWindow(context: Context, isShow: Boolean){
@@ -149,11 +144,8 @@ class IPCReportManager : IMoGoAutopilotStatusListener {
     }
 
     fun destroy(){
-        //乘客屏不显示监控信息弹窗,只在司机端提示
-        if(AppIdentityModeUtils.isDriver(FunctionBuildConfig.appIdentityMode)){
-            // 移除 ADAS状态 监听
-            CallerAutoPilotStatusListenerManager.removeListener(TAG)
-        }
+        // 移除 ADAS状态 监听
+        CallerAutoPilotStatusListenerManager.removeListener(TAG)
     }
 
 }

core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoAutopilotControlProvider.kt

@@ -8,10 +8,12 @@ import com.mogo.eagle.core.function.api.base.IMoGoFunctionServerProvider
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable.IsBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.GetTaskReq
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.StartTaskResp
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume.SuspendResumeTaskReq
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume.SuspendResumeTaskReq
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm.TaskConfirmResp
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop.StopTaskResp
 import com.zhjt.mogo.adas.data.AdasConstants
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.BigTaskActionResp
+import mogo.yycp.paralleldriving.protocol.ParallelDrivingRequest
 
 /**
  * @author xiaoyuzhou
@@ -457,6 +459,25 @@ interface IMoGoAutopilotControlProvider : IMoGoFunctionServerProvider {
      */
     fun sendSweeperAutopilotBootable(reqNo: String, isBootable: IsBootable): Boolean
 
+    /**
+     * PAD发起平行驾驶请求
+     *
+     * @param reqNo           请求编号（目前没有传递需求,可以传null）
+     * @param parallelRequest 参数
+     * @return boolean
+     */
+    fun sendParallelDrivingReq(reqNo: String, parallelRequest: ParallelDrivingRequest.ParallelRequest): Boolean
+
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    fun sendSweeperCloudSuspendResumeTaskResp(reqNo: String, bigTaskActionResp: BigTaskActionResp): Boolean
+
     /**
      * 打开点云绘制
      *

core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoParallelDrivingStatusListener.kt

@@ -0,0 +1,16 @@
+package com.mogo.eagle.core.function.api.autopilot
+
+import mogo.yycp.paralleldriving.protocol.ParallelTaskProcessNoticeOuterClass
+
+/**
+ * 平行驾驶状态
+ */
+interface IMoGoParallelDrivingStatusListener {
+
+    /**
+     * 需要判空
+     */
+    fun onParallelDrivingResp(
+        parallelTaskProcessNotice: ParallelTaskProcessNoticeOuterClass.ParallelTaskProcessNotice?
+    )
+}

core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoSweeperFutianCloudTaskListener.kt

@@ -1,14 +1,14 @@
 package com.mogo.eagle.core.function.api.autopilot
 
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask
+import com.zhjt.mogo.adas.data.AiCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable.IsBootableResp
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume.SuspendResumeTaskResp
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus.BigTaskStatusPush
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.BigTaskActionPush
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm.TaskConfirm
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume.SuspendResumeTaskResp
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus.TaskStatusPush
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop.StopTaskReq
-import mogo.telematics.pad.MessagePad
 
 /**
  * 清扫车（福田）云端任务接口
@@ -24,7 +24,7 @@ interface IMoGoSweeperFutianCloudTaskListener {
      * @param sysTime     当前时间戳
      * @param taskInfo    数据
      */
-    fun onSweeperFutianCloudTask(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, taskInfo: SweeperTask.TaskInfo?)
+    fun onSweeperFutianCloudTask(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, taskInfo: SweeperTask.TaskInfo?)
 
     /**
      * 2、云端下发子任务，请求pad确认（type：100002）-> sweeper_task_confirm.proto
@@ -34,7 +34,7 @@ interface IMoGoSweeperFutianCloudTaskListener {
      * @param sysTime     当前时间戳
      * @param taskConfirm 数据
      */
-    fun onSweeperFutianCloudTaskConfirm(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, taskConfirm: TaskConfirm?)
+    fun onSweeperFutianCloudTaskConfirm(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, taskConfirm: TaskConfirm?)
 
     /**
      * 3、云端下发任务状态到pad（type：100003）-> sweeper_task_status.proto
@@ -44,7 +44,7 @@ interface IMoGoSweeperFutianCloudTaskListener {
      * @param sysTime        当前时间戳
      * @param taskStatusPush 数据
      */
-    fun onSweeperFutianCloudTaskStatus(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, taskStatusPush: TaskStatusPush?)
+    fun onSweeperFutianCloudTaskStatus(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, taskStatusPush: TaskStatusPush?)
 
     /**
      * 4、云端请求pad结束任务（type：100004）-> sweeper_task_stop.proto
@@ -54,7 +54,7 @@ interface IMoGoSweeperFutianCloudTaskListener {
      * @param sysTime     当前时间戳
      * @param stopTaskReq 数据
      */
-    fun onSweeperFutianCloudTaskStop(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, stopTaskReq: StopTaskReq?)
+    fun onSweeperFutianCloudTaskStop(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, stopTaskReq: StopTaskReq?)
 
     /**
      * 5、pad请求挂起任务（type：100005）-> sweeper_task_suspend_resume.proto
@@ -65,7 +65,7 @@ interface IMoGoSweeperFutianCloudTaskListener {
      * @param sysTime               当前时间戳
      * @param suspendResumeTaskResp 数据
      */
-    fun onSweeperFutianCloudTaskSuspendResume(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, suspendResumeTaskResp: SuspendResumeTaskResp?)
+    fun onSweeperFutianCloudTaskSuspendResume(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, suspendResumeTaskResp: SuspendResumeTaskResp?)
 
     /**
      * 8、接管后回自驾-pad上报状态给云端 云端下发启动自驾（type: 100008）-> sweeper_autopilot.proto
@@ -75,7 +75,7 @@ interface IMoGoSweeperFutianCloudTaskListener {
      * @param sysTime        当前时间戳
      * @param isBootableResp 数据
      */
-    fun onSweeperFutianCloudBootable(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, isBootableResp: IsBootableResp?)
+    fun onSweeperFutianCloudBootable(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, isBootableResp: IsBootableResp?)
 
     /**
      * 9、云端下发pad大任务状态（type: 100009）-> sweeper_big_task_status.proto
@@ -85,7 +85,17 @@ interface IMoGoSweeperFutianCloudTaskListener {
      * @param sysTime           当前时间戳
      * @param bigTaskStatusPush 数据
      */
-    fun onSweeperFutianCloudBigTaskStatus(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskStatusPush: BigTaskStatusPush?)
+    fun onSweeperFutianCloudBigTaskStatus(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskStatusPush: BigTaskStatusPush?)
+
+    /**
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+     *
+     * @param messageType           消息类型
+     * @param reqNo                 请求编号
+     * @param sysTime               当前时间戳
+     * @param bigTaskActionPush 数据
+     */
+    fun onSweeperFutianCloudTaskCloudSuspendResume(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskActionPush: BigTaskActionPush?)
 
     /**
      * 清扫车云端任务未知类型

core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerAutoPilotControlManager.kt

@@ -17,12 +17,14 @@ import com.mogo.eagle.core.utilcode.mogo.AppIdentityModeUtils
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable.IsBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.GetTaskReq
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.StartTaskResp
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume.SuspendResumeTaskReq
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume.SuspendResumeTaskReq
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm.TaskConfirmResp
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop.StopTaskResp
 import com.zhjt.mogo.adas.data.AdasConstants
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.BigTaskActionResp
 import com.zhjt.service.chain.ChainLog
 import com.zhjt.service_biz.BizConfig
+import mogo.yycp.paralleldriving.protocol.ParallelDrivingRequest
 import kotlin.random.Random
 
 
@@ -629,6 +631,28 @@ object CallerAutoPilotControlManager {
         return providerApi?.sendSweeperAutopilotBootable(reqNo, isBootable) ?: false
     }
 
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    fun sendSweeperCloudSuspendResumeTaskResp( reqNo: String,   bigTaskActionResp: BigTaskActionResp): Boolean {
+        return providerApi?.sendSweeperCloudSuspendResumeTaskResp(reqNo, bigTaskActionResp) ?: false
+    }
+
+    /**
+     * PAD发起平行驾驶请求
+     *
+     * @param reqNo           请求编号（目前没有传递需求,可以传null）
+     * @param parallelRequest 参数
+     * @return boolean
+     */
+    fun sendParallelDrivingReq( reqNo: String,  parallelRequest: ParallelDrivingRequest.ParallelRequest): Boolean {
+        return providerApi?.sendParallelDrivingReq(reqNo, parallelRequest) ?: false
+    }
 
     /**
      * 打开点云绘制

core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerParallelDrivingListenerManager.kt

@@ -0,0 +1,21 @@
+package com.mogo.eagle.core.function.call.autopilot
+
+import com.mogo.eagle.core.function.api.autopilot.IMoGoParallelDrivingStatusListener
+import com.mogo.eagle.core.function.call.base.CallerBase
+import mogo.telematics.pad.MessagePad
+import mogo.yycp.paralleldriving.protocol.ParallelTaskProcessNoticeOuterClass
+
+/**
+ * 平行驾驶状态回调，云端说有状态变化就回调
+ */
+object CallerParallelDrivingListenerManager : CallerBase<IMoGoParallelDrivingStatusListener>() {
+
+
+    fun invokeParallelDrivingListener(parallelTaskProcessNotice: ParallelTaskProcessNoticeOuterClass.ParallelTaskProcessNotice?) {
+        M_LISTENERS.forEach {
+            val listener = it.value
+            listener.onParallelDrivingResp(parallelTaskProcessNotice)
+        }
+    }
+
+}

core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerSweeperFutianCloudTaskListenerManager.kt

@@ -2,11 +2,12 @@ package com.mogo.eagle.core.function.call.autopilot
 
 import com.mogo.eagle.core.function.api.autopilot.IMoGoSweeperFutianCloudTaskListener
 import com.mogo.eagle.core.function.call.base.CallerBase
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask
+import com.zhjt.mogo.adas.data.AiCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop
@@ -25,7 +26,7 @@ object CallerSweeperFutianCloudTaskListenerManager : CallerBase<IMoGoSweeperFuti
      * @param sysTime     当前时间戳
      * @param taskInfo    数据
      */
-    fun invokeSweeperFutianCloudTask(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, taskInfo: SweeperTask.TaskInfo?) {
+    fun invokeSweeperFutianCloudTask(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, taskInfo: SweeperTask.TaskInfo?) {
         M_LISTENERS.forEach {
             val listener = it.value
             listener.onSweeperFutianCloudTask(messageType, reqNo, sysTime, taskInfo)
@@ -40,7 +41,7 @@ object CallerSweeperFutianCloudTaskListenerManager : CallerBase<IMoGoSweeperFuti
      * @param sysTime     当前时间戳
      * @param taskConfirm 数据
      */
-    fun invokeSweeperFutianCloudTaskConfirm(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, taskConfirm: SweeperTaskConfirm.TaskConfirm?) {
+    fun invokeSweeperFutianCloudTaskConfirm(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, taskConfirm: SweeperTaskConfirm.TaskConfirm?) {
         M_LISTENERS.forEach {
             val listener = it.value
             listener.onSweeperFutianCloudTaskConfirm(messageType, reqNo, sysTime, taskConfirm)
@@ -55,7 +56,7 @@ object CallerSweeperFutianCloudTaskListenerManager : CallerBase<IMoGoSweeperFuti
      * @param sysTime        当前时间戳
      * @param taskStatusPush 数据
      */
-    fun invokeSweeperFutianCloudTaskStatus(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, taskStatusPush: SweeperTaskStatus.TaskStatusPush?) {
+    fun invokeSweeperFutianCloudTaskStatus(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, taskStatusPush: SweeperTaskStatus.TaskStatusPush?) {
         M_LISTENERS.forEach {
             val listener = it.value
             listener.onSweeperFutianCloudTaskStatus(messageType, reqNo, sysTime, taskStatusPush)
@@ -70,7 +71,7 @@ object CallerSweeperFutianCloudTaskListenerManager : CallerBase<IMoGoSweeperFuti
      * @param sysTime     当前时间戳
      * @param stopTaskReq 数据
      */
-    fun invokeSweeperFutianCloudTaskStop(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, stopTaskReq: SweeperTaskStop.StopTaskReq?) {
+    fun invokeSweeperFutianCloudTaskStop(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, stopTaskReq: SweeperTaskStop.StopTaskReq?) {
         M_LISTENERS.forEach {
             val listener = it.value
             listener.onSweeperFutianCloudTaskStop(messageType, reqNo, sysTime, stopTaskReq)
@@ -86,7 +87,7 @@ object CallerSweeperFutianCloudTaskListenerManager : CallerBase<IMoGoSweeperFuti
      * @param sysTime               当前时间戳
      * @param suspendResumeTaskResp 数据
      */
-    fun invokeSweeperFutianCloudTaskSuspendResume(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, suspendResumeTaskResp: SweeperTaskSuspendResume.SuspendResumeTaskResp?) {
+    fun invokeSweeperFutianCloudTaskSuspendResume(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, suspendResumeTaskResp: SweeperTaskSuspendResume.SuspendResumeTaskResp?) {
         M_LISTENERS.forEach {
             val listener = it.value
             listener.onSweeperFutianCloudTaskSuspendResume(messageType, reqNo, sysTime, suspendResumeTaskResp)
@@ -101,7 +102,7 @@ object CallerSweeperFutianCloudTaskListenerManager : CallerBase<IMoGoSweeperFuti
      * @param sysTime        当前时间戳
      * @param isBootableResp 数据
      */
-    fun invokeSweeperFutianCloudBootable(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, isBootableResp: SweeperBootable.IsBootableResp?) {
+    fun invokeSweeperFutianCloudBootable(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, isBootableResp: SweeperBootable.IsBootableResp?) {
         M_LISTENERS.forEach {
             val listener = it.value
             listener.onSweeperFutianCloudBootable(messageType, reqNo, sysTime, isBootableResp)
@@ -116,13 +117,28 @@ object CallerSweeperFutianCloudTaskListenerManager : CallerBase<IMoGoSweeperFuti
      * @param sysTime           当前时间戳
      * @param bigTaskStatusPush 数据
      */
-    fun invokeSweeperFutianCloudBigTaskStatus(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskStatusPush: SweeperBigTaskStatus.BigTaskStatusPush?) {
+    fun invokeSweeperFutianCloudBigTaskStatus(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskStatusPush: SweeperBigTaskStatus.BigTaskStatusPush?) {
         M_LISTENERS.forEach {
             val listener = it.value
             listener.onSweeperFutianCloudBigTaskStatus(messageType, reqNo, sysTime, bigTaskStatusPush)
         }
     }
 
+    /**
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+     *
+     * @param messageType       消息类型
+     * @param reqNo             请求编号
+     * @param sysTime           当前时间戳
+     * @param bigTaskActionPush 数据
+     */
+    fun invokeSweeperFutianCloudTaskCloudSuspendResume(messageType: AiCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskActionPush: SweeperTaskCloudSuspendResume.BigTaskActionPush?) {
+        M_LISTENERS.forEach {
+            val listener = it.value
+            listener.onSweeperFutianCloudTaskCloudSuspendResume(messageType, reqNo, sysTime, bigTaskActionPush)
+        }
+    }
+
     /**
      * 清扫车云端任务未知类型
      *

gradle.properties

@@ -172,6 +172,6 @@ CHARTER_DRIVER_VERSION=6.0.0
 # 包车模式乘客端端版本号
 CHARTER_PASSENGER_VERSION=5.0.0
 # 支持云控清扫车模式司机端版本号
-SWEEPERCLOUD_DRIVER_VERSION=3.1.4
+SWEEPERCLOUD_DRIVER_VERSION=3.2.0
 # 清扫车模式司机端版本号
 SWEEPEROPERATE_DRIVER_VERSION=3.1.0

libraries/mogo-adas-data/src/main/proto/ai_cloud_task.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package com.zhjt.mogo.adas.data.sweeper;
+package com.zhjt.mogo.adas.data;
 
 //清扫车云端任务调度
 
@@ -16,11 +16,14 @@ enum MessageType
   PadSendGetTaskReq = 100007; //7、pad主动拉取当前车辆正在执行任务的完整信息（type：100007）-> sweeper_task.proto
   PadSendBootable = 100008; //8、接管后回自驾-pad上报状态给云端 云端下发启动自驾（type: 100008）-> sweeper_bootable.proto
   CloudPushBigTaskStatus = 100009; //9、云端下发pad大任务状态（type: 100009）-> sweeper_big_task_status.proto
+  CloudPushTaskSuspendResume = 100010; //10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+
+  ParallelDrivingCmd = 200001; //无人化场景，平行驾驶请求相关指令及状态反馈, 云控<->鹰眼双向透传
 }
 
 //云下行消息
 //PAD上行消息
-message SweeperMessage
+message AiCloudPadMessage
 {
   uint32 msgType = 1; //消息类型，响应请求时，使用对应请求的消息类型
   bytes payload = 2; //消息内容

libraries/mogo-adas-data/src/main/proto/message_pad.proto

@@ -72,6 +72,7 @@ enum MessageType
     MsgTypeFSMStatusReasonQueryReq = 0x10123; //fsm状态原因查询
     MsgTypeFSMStatusReasonQueryResp = 0x10124; //fsm状态原因查询应答
     MsgTypeGetDebugInfo = 0x10125; //debug信息查询 pad->telematics
+    MsgTypeParallelDrivingCmd = 0x10126; //无人化场景，平行驾驶请求相关指令及状态反馈, 云控<->鹰眼双向透传
 }
 
 message Header
@@ -713,3 +714,7 @@ message SessionInfo
 
 //message definition for MsgTypeSSMState
 //refer to ssm_info.proto for details
+
+//message definition for MsgTypeParallelDrivingCmd
+//查看云端和鹰眼的接口
+

libraries/mogo-adas-data/src/main/proto/parallelDrivingRequest.proto

@@ -0,0 +1,11 @@
+syntax = "proto3";
+package mogo.yycp.paralleldriving.protocol;
+option java_package = "mogo.yycp.paralleldriving.protocol";
+
+message ParallelRequest {
+  string sn = 1;
+  int32 type = 2; //类型:1，预接管，2，鹰眼请求 3 遇困，4，自检异常
+  int32 takeover = 3;  //1接管请求，2取消请求接管
+  string code = 4 ; // 请求上报的类型，如："PAD_ACTIVE",用于描述type的具体内容，不同的code可以对应同一个type
+  string reason = 5; // 具体的请求原因描述,如：因底盘消息掉帧强退自动驾驶
+}

libraries/mogo-adas-data/src/main/proto/parallelTaskProcessNotice.proto

@@ -0,0 +1,8 @@
+syntax = "proto3";
+package mogo.yycp.paralleldriving.protocol;
+option java_package = "mogo.yycp.paralleldriving.protocol";
+
+message ParallelTaskProcessNotice {
+  string code = 1;  // 消息code：      START_SYNC  ; EXIT_SYNC ; UNABLE_TAKEOVER ; EXCEPTION_EXIT_SYNC ; TASK_REJECTED ; PARALLEL_EXCEPTION_MANUAL_DRIVING ; EXCEPTION_EXIT_PARALLEL_DRIVING
+  string content = 2; //消息具体内容：进入同步状态 ;  同步结束 ;      无法接管   ;   同步异常结束      ; 任务已被拒绝  ;   异常请人工驾驶                  ;  平行驾驶异常结束
+}

libraries/mogo-adas-data/src/main/proto/special_vehicle_task_cmd.proto

@@ -14,6 +14,9 @@ message RoboSweeperFuTianCleanCmd {
     optional uint32 sweepdisk_speed_requirement = 8 [default = 0]; // 扫盘加速需求 0--no req, 1--decelerate req, 2--accelerate req（扫盘加速需求，每点一次为加速一次，每次加速为5%pwm）
     optional uint32 sweepdisk_desire_speed_requirement = 9 [default = 0]; // 扫盘期望转速, 0-100%  必须是5的倍数
     optional uint32 one_touch_take_out_trash_requirement = 10 [default = 0]; // 一键倒垃圾请求，0：no req; 1: take out; 2: stop take out
+    optional uint32 clean_tail_door_requirement = 11 [default = 0]; // 垃圾尾门开关请求，0--no req; 1-- open; 2:--stop take out
+    optional uint32 clean_tail_tip_requirement = 12 [default = 0]; // 垃圾箱举升请求，0--no req;  1 -- tail ret,2-- tail tip
+    optional uint32 clean_work_Enc_des_requirement = 13 [default = 0]; // 垃圾箱清淤请求，0--no req; 1:--open; 2--close
 }
 
 message RoboSweeperFuTianTaskCmd {

libraries/mogo-adas-data/src/main/proto/sweeper/README.md

@@ -12,6 +12,7 @@
 |7、pad主动拉取当前车辆正在执行任务的完整信息（type：100007）|sweeper/sweeper_task.proto|
 |8、接管后回自驾-pad上报状态给云端 云端下发启动自驾（type: 100008）|sweeper/sweeper_bootable.proto|
 |9、云端下发pad大任务状态（type: 100009）|sweeper/sweeper_big_task_status.proto|
+|10、云端下发任务暂停/恢复指令到pad（type: 100010）|sweeper/sweeper_task_cloud_suspend_resume.proto|
 
 # 接口使用说明
 ## 回调接口类：IMoGoSweeperFutianCloudTaskListener
@@ -181,4 +182,28 @@ fun onSweeperFutianCloudBigTaskStatus(messageType: SweeperCloudTask.MessageType,
     
 客户端回复：
 无
+~~~
+
+~~~
+服务端发：
+/**
+ * 10、云端下发任务暂停/恢复指令到pad（type: 100010）
+ *
+ * @param messageType           消息类型
+ * @param reqNo                 请求编号
+ * @param sysTime               当前时间戳
+ * @param bigTaskActionPush 数据
+ */
+fun onSweeperFutianCloudTaskCloudSuspendResume(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskActionPush: BigTaskActionPush?)
+
+客户端回复:
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+CallerAutoPilotControlManager.INSTANCE.sendSweeperSuspendResumeTaskReq(）
 ~~~

libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_big_task_status.proto

@@ -1,25 +1,19 @@
 syntax = "proto3";
 package com.zhjt.mogo.adas.data.sweeper.task.big;
 
+import "sweeper/sweeper_common.proto";
 
 /**** 9、云端下发pad大任务状态（type: 100009） ****/
 
 //9.1、请求信息
 // 任务状态
-enum BigTaskStatus {
-  DEFAULT_STATUS = 0; // 无效值
-  TO_START = 1; //待开始
-  RUNNING = 2; // 运行中
-  CANCLE = 3; // 取消
-  FINISHED = 4; // 结束
-  ABNORMAL = 5; // 异常
-}
 
 message BigTaskStatusPush {
   string sn = 1;// sn
   string taskId = 2;// 大任务编号
-  BigTaskStatus TaskStatus = 3;// 大任务状态
+  common.TaskStatus TaskStatus = 3;// 大任务状态
   uint64 systemTime = 4; // 时间戳
+  bool isPop = 5; // 是否弹窗(0725新增)
 }
 
 //4.2、响应信息

libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_common.proto

@@ -7,9 +7,10 @@ enum TaskStatus
   DEFAULT_STATUS = 0; // 无效值
   TO_START = 1; //待开始
   RUNNING = 2; // 运行中
-  SUSPENDED = 3; // 暂停
-  FINISHED = 4; // 结束
-  ABNORMAL = 5; // *异常
+  CANCEL = 3; // 取消（提前结束）
+  FINISHED = 4; // 正常结束
+  ABNORMAL = 5; // 异常结束
+  SUSPENDED = 6; // 暂停 (新增)
 }
 
 // 响应状态

libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task.proto

@@ -55,16 +55,17 @@ message TaskInfo {
   uint64 currentTime = 6; //当前时间戳
   repeated SubTaskInfo subList = 7; // 子任务列表信息
   bool isPop = 8; // 是否弹窗
+  common.TaskStatus taskStatus = 9; //  大任务状态（新增）
 }
 
 //1.2、响应信息
 // 响应状态
 enum StartTaskCode {
   DEFAULT_CODE = 0; // 无效值
-  MANUAL_CONFIRM = 1; // 安全员确认执行任务-pad
-  MANUAL_REFUSE = 2; // 安全员拒绝任务-pad
+  MANUAL_CONFIRM = 1; // 安全员确认执行任务-pad（无效值）
+  MANUAL_REFUSE = 2; // 安全员拒绝任务-pad（无效值）
   RECEIVED = 3; // 收到任务
-  OVER_TIME = 4; // 超时未确认
+  OVER_TIME = 4; // 超时未确认（无效值）
 }
 
 /**

libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_cloud_suspend_resume.proto

@@ -0,0 +1,40 @@
+syntax = "proto3";
+package com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r;
+
+
+/**** 10、云端下发任务暂停/恢复指令到pad（type: 100010） ****/
+
+//10.1、请求信息
+
+// 指令类型
+enum ActionType {
+  DEFAULT_TYPE = 0; // 无效值
+  SUSPENDED = 1; // 暂停
+  RESUME = 2; //恢复
+}
+
+message BigTaskActionPush {
+  string sn = 1;// sn
+  string taskId = 2;// 大任务编号
+  ActionType action = 3;// 指令类型
+  uint64 systemTime = 4; // 时间戳
+  bool isPop = 5; // 是否弹窗
+}
+
+
+//10.2、响应信息
+
+// 响应状态
+enum Code {
+  DEFAULT_CODE = 0; // 无效值
+  RECEIVED = 1; // 收到指令
+}
+
+/**
+开始大任务响应
+*/
+message BigTaskActionResp {
+  string sn = 1;// sn
+  string taskId = 2;// 大任务编号
+  Code code = 3; //响应状态
+}

libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_confirm.proto

@@ -19,10 +19,11 @@ message TaskConfirm {
 // 响应状态
 enum TaskConfirmCode {
   DEFAULT_CODE = 0; // 无效值
-  MANUAL_CONFIRM = 1; // 安全员确认执行任务-pad
-  MANUAL_REFUSE_ALL = 2; // 安全员拒绝全部任务-pad
-  MANUAL_REFUSE_SINGLE = 3; // 安全员拒绝单个子任务-pad
-  OVER_TIME = 4; // 超时未确认
+  MANUAL_CONFIRM = 1; // 安全员确认执行任务-pad（无效值）
+  MANUAL_REFUSE_ALL = 2; // 安全员拒绝全部任务-pad（无效值）
+  MANUAL_REFUSE_SINGLE = 3; // 安全员拒绝单个子任务-pad（无效值）
+  OVER_TIME = 4; // 超时未确认（无效值）
+  RECEIVED = 5; // 收到子任务（新增）
 }
 
 /**

libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_stop.proto

@@ -8,9 +8,10 @@ package com.zhjt.mogo.adas.data.sweeper.task.stop;
 // 任务状态
 enum StopTaskType {
   DEFAULT_TYPE = 0; // 无效值
-  TIMEOUT = 1; //超时结束
+  TIMEOUT = 1; //超时结束（无效值）
   ADVANCE = 2; // 提前结束
   NORMAL = 3; // 正常结束
+  EXCEPTION = 4; // 异常结束（新增）
 }
 
 
@@ -29,9 +30,10 @@ message StopTaskReq {
 // 响应状态
 enum StopTaskCode {
   DEFAULT_CODE = 0; // 无效值
-  MANUAL_CONFIRM = 1; // 安全员确认
-  MANUAL_REFUSE = 2; // 安全员拒绝
-  OVER_TIME = 3; // 超时未确认
+  MANUAL_CONFIRM = 1; // 安全员确认（无效值）
+  MANUAL_REFUSE = 2; // 安全员拒绝（无效值）
+  OVER_TIME = 3; // 超时未确认（无效值）
+  RECEIVED = 4; // 收到结束指令（新增）
 }
 
 /**

libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_suspend_resume.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package com.zhjt.mogo.adas.data.sweeper.task;
+package com.zhjt.mogo.adas.data.sweeper.task.s_r;
 
 import "sweeper/sweeper_common.proto";
 

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/AdasChannel.java

@@ -45,13 +45,14 @@ import com.zhidao.support.adas.high.subscribe.SubscribeInterface;
 import com.zhidao.support.adas.high.subscribe.SubscribeInterfaceOptions;
 import com.zhidao.support.adas.high.thread.DispatchHandler;
 import com.zhjt.mogo.adas.data.AdasConstants;
+import com.zhjt.mogo.adas.data.AiCloudTask;
 import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhjt.mogo.adas.data.bean.AutopilotStatistics;
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
 import com.zhjt.service.chain.ChainLog;
 
@@ -70,6 +71,7 @@ import common.HeaderOuterClass;
 import function_state_management.FSMStatusReasonQueryOuterClass;
 import mogo.telematics.ParamSetCmdOuterClass;
 import mogo.telematics.pad.MessagePad;
+import mogo.yycp.paralleldriving.protocol.ParallelDrivingRequest;
 import okio.ByteString;
 
 /**
@@ -1888,15 +1890,16 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
     }
 
     /**
-     * 发送清扫车指令到云控
+     * 发送云控指令
      *
-     * @param messageType 消息类型
-     * @param reqNo       请求编号
-     * @param payload     有效数据
+     * @param padMessageType PAD到域控消息类型
+     * @param messageType    PAD到AI云消息类型
+     * @param reqNo          请求编号
+     * @param payload        有效数据
      * @return boolean
      */
-    private boolean sendSweeperCloudTaskCmd(@NonNull SweeperCloudTask.MessageType messageType, @NonNull String reqNo, @NonNull com.google.protobuf.ByteString payload) {
-        SweeperCloudTask.SweeperMessage.Builder builder = SweeperCloudTask.SweeperMessage.newBuilder()
+    private boolean sendAiCloudTaskCmd(@NonNull MessageType padMessageType, @NonNull AiCloudTask.MessageType messageType, @NonNull String reqNo, @NonNull com.google.protobuf.ByteString payload) {
+        AiCloudTask.AiCloudPadMessage.Builder builder = AiCloudTask.AiCloudPadMessage.newBuilder()
                 .setMsgType(messageType.getNumber())
                 .setSysTime(System.currentTimeMillis());
         if (!TextUtils.isEmpty(reqNo)) {
@@ -1905,8 +1908,8 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
         if (payload != null && !payload.isEmpty()) {
             builder.setPayload(payload);
         }
-        SweeperCloudTask.SweeperMessage message = builder.build();
-        return sendPBMessage(MessageType.TYPE_SEND_SWEEPER_CLOUD_TASK_CMD.typeCode, message.toByteArray());
+        AiCloudTask.AiCloudPadMessage message = builder.build();
+        return sendPBMessage(padMessageType.typeCode, message.toByteArray());
     }
 
     /**
@@ -1919,7 +1922,7 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
      */
     @Override
     public boolean sendSweeperStartTaskResp(@NonNull String reqNo, @NonNull SweeperTask.StartTaskResp startTaskResp) {
-        return sendSweeperCloudTaskCmd(SweeperCloudTask.MessageType.CloudPushTask, reqNo, startTaskResp.toByteString());
+        return sendAiCloudTaskCmd(MessageType.TYPE_SEND_SWEEPER_CLOUD_TASK_CMD, AiCloudTask.MessageType.CloudPushTask, reqNo, startTaskResp.toByteString());
     }
 
     /**
@@ -1932,7 +1935,7 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
      */
     @Override
     public boolean sendSweeperTaskConfirmResp(@NonNull String reqNo, @NonNull SweeperTaskConfirm.TaskConfirmResp taskConfirmResp) {
-        return sendSweeperCloudTaskCmd(SweeperCloudTask.MessageType.CloudPushTaskConfirm, reqNo, taskConfirmResp.toByteString());
+        return sendAiCloudTaskCmd(MessageType.TYPE_SEND_SWEEPER_CLOUD_TASK_CMD, AiCloudTask.MessageType.CloudPushTaskConfirm, reqNo, taskConfirmResp.toByteString());
     }
 
     /**
@@ -1945,7 +1948,7 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
      */
     @Override
     public boolean sendSweeperStopTaskResp(@NonNull String reqNo, @NonNull SweeperTaskStop.StopTaskResp stopTaskResp) {
-        return sendSweeperCloudTaskCmd(SweeperCloudTask.MessageType.CloudPushTaskStop, reqNo, stopTaskResp.toByteString());
+        return sendAiCloudTaskCmd(MessageType.TYPE_SEND_SWEEPER_CLOUD_TASK_CMD, AiCloudTask.MessageType.CloudPushTaskStop, reqNo, stopTaskResp.toByteString());
     }
 
     /**
@@ -1960,7 +1963,7 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
      */
     @Override
     public boolean sendSweeperSuspendResumeTaskReq(boolean isSuspend, @NonNull String reqNo, @NonNull SweeperTaskSuspendResume.SuspendResumeTaskReq suspendResumeTaskReq) {
-        return sendSweeperCloudTaskCmd(isSuspend ? SweeperCloudTask.MessageType.PadSendTaskSuspend : SweeperCloudTask.MessageType.PadSendTaskResume, reqNo, suspendResumeTaskReq.toByteString());
+        return sendAiCloudTaskCmd(MessageType.TYPE_SEND_SWEEPER_CLOUD_TASK_CMD, isSuspend ? AiCloudTask.MessageType.PadSendTaskSuspend : AiCloudTask.MessageType.PadSendTaskResume, reqNo, suspendResumeTaskReq.toByteString());
     }
 
 
@@ -1974,7 +1977,7 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
      */
     @Override
     public boolean sendSweeperGetTaskReq(@NonNull String reqNo, @NonNull SweeperTask.GetTaskReq getTaskReq) {
-        return sendSweeperCloudTaskCmd(SweeperCloudTask.MessageType.PadSendGetTaskReq, reqNo, getTaskReq.toByteString());
+        return sendAiCloudTaskCmd(MessageType.TYPE_SEND_SWEEPER_CLOUD_TASK_CMD, AiCloudTask.MessageType.PadSendGetTaskReq, reqNo, getTaskReq.toByteString());
     }
 
     /**
@@ -1987,7 +1990,33 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
      */
     @Override
     public boolean sendSweeperAutopilotBootable(@NonNull String reqNo, @NonNull SweeperBootable.IsBootable isBootable) {
-        return sendSweeperCloudTaskCmd(SweeperCloudTask.MessageType.PadSendBootable, reqNo, isBootable.toByteString());
+        return sendAiCloudTaskCmd(MessageType.TYPE_SEND_SWEEPER_CLOUD_TASK_CMD, AiCloudTask.MessageType.PadSendBootable, reqNo, isBootable.toByteString());
     }
+
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    @Override
+    public boolean sendSweeperCloudSuspendResumeTaskResp(@NonNull String reqNo, @NonNull SweeperTaskCloudSuspendResume.BigTaskActionResp bigTaskActionResp) {
+        return sendAiCloudTaskCmd(MessageType.TYPE_SEND_SWEEPER_CLOUD_TASK_CMD, AiCloudTask.MessageType.CloudPushTaskSuspendResume, reqNo, bigTaskActionResp.toByteString());
+    }
+
+    /**
+     * PAD发起平行驾驶请求
+     *
+     * @param reqNo           请求编号
+     * @param parallelRequest 参数
+     * @return boolean
+     */
+    @Override
+    public boolean sendParallelDrivingReq(@NonNull String reqNo, @NonNull ParallelDrivingRequest.ParallelRequest parallelRequest) {
+        return sendAiCloudTaskCmd(MessageType.TYPE_SEND_PARALLEL_DRIVING_REQ, AiCloudTask.MessageType.ParallelDrivingCmd, reqNo, parallelRequest.toByteString());
+    }
+
 }
 

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/AdasManager.java

@@ -16,8 +16,9 @@ import com.zhjt.mogo.adas.data.AdasConstants;
 import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
 
 import java.util.HashSet;
@@ -31,6 +32,7 @@ import java.util.regex.Pattern;
 import bag_manager.BagManagerOuterClass;
 import chassis.SpecialVehicleTaskCmdOuterClass;
 import mogo.telematics.pad.MessagePad;
+import mogo.yycp.paralleldriving.protocol.ParallelDrivingRequest;
 
 /**
  * @ProjectName: lib-adas-fpga
@@ -1180,6 +1182,31 @@ public class AdasManager implements IAdasNetCommApi {
         return mChannel != null && mChannel.sendSweeperAutopilotBootable(reqNo, isBootable);
     }
 
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    @Override
+    public boolean sendSweeperCloudSuspendResumeTaskResp(@NonNull String reqNo, @NonNull SweeperTaskCloudSuspendResume.BigTaskActionResp bigTaskActionResp) {
+        return mChannel != null && mChannel.sendSweeperCloudSuspendResumeTaskResp(reqNo, bigTaskActionResp);
+    }
+
+    /**
+     * PAD发起平行驾驶请求
+     *
+     * @param reqNo           请求编号
+     * @param parallelRequest 参数
+     * @return boolean
+     */
+    @Override
+    public boolean sendParallelDrivingReq(@NonNull String reqNo, @NonNull ParallelDrivingRequest.ParallelRequest parallelRequest) {
+        return mChannel != null && mChannel.sendParallelDrivingReq(reqNo, parallelRequest);
+    }
+
     /**
      * 获取工控机固定IP列表
      *

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/IAdasNetCommApi.java

@@ -9,8 +9,9 @@ import com.zhidao.support.adas.high.common.MessageType;
 import com.zhjt.mogo.adas.data.AdasConstants;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
 
 import java.util.List;
@@ -20,6 +21,7 @@ import java.util.Set;
 import bag_manager.BagManagerOuterClass;
 import chassis.SpecialVehicleTaskCmdOuterClass;
 import mogo.telematics.pad.MessagePad;
+import mogo.yycp.paralleldriving.protocol.ParallelDrivingRequest;
 
 /**
  * @author nie yunlong
@@ -739,6 +741,25 @@ public interface IAdasNetCommApi {
      */
     boolean sendSweeperAutopilotBootable(@NonNull String reqNo, @NonNull SweeperBootable.IsBootable isBootable);
 
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    boolean sendSweeperCloudSuspendResumeTaskResp(@NonNull String reqNo, @NonNull SweeperTaskCloudSuspendResume.BigTaskActionResp bigTaskActionResp);
+
+    /**
+     * PAD发起平行驾驶请求
+     *
+     * @param reqNo           请求编号
+     * @param parallelRequest 参数
+     * @return boolean
+     */
+    boolean sendParallelDrivingReq(@NonNull String reqNo, @NonNull ParallelDrivingRequest.ParallelRequest parallelRequest);
+
     // TODO 需求暂停 待讨论
 //    boolean getRoutes();
 

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/OnAdasListener.java

@@ -7,15 +7,16 @@ import com.mogo.support.obu.ObuScene;
 import com.zhidao.support.adas.high.common.MessageType;
 import com.zhidao.support.adas.high.common.ProtocolStatus;
 import com.zhjt.mogo.adas.data.AdasConstants;
+import com.zhjt.mogo.adas.data.AiCloudTask;
 import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhjt.mogo.adas.data.bean.AutopilotStatistics;
 import com.zhjt.mogo.adas.data.bean.UnableAutopilotReason;
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
 
@@ -28,6 +29,7 @@ import function_state_management.FunctionStates;
 import mogo.telematics.pad.MessagePad;
 import mogo.v2x.MogoV2X;
 import mogo.v2x.RoadOverviewEvents;
+import mogo.yycp.paralleldriving.protocol.ParallelTaskProcessNoticeOuterClass;
 import mogo_msg.MogoReportMsg;
 import perception.TrafficLightOuterClass;
 import planning.RoboSweeperTaskIndexOuterClass;
@@ -301,7 +303,7 @@ public interface OnAdasListener {
      * @param sysTime     当前时间戳
      * @param taskInfo    数据
      */
-    void onSweeperFutianCloudTask(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTask.TaskInfo taskInfo);
+    void onSweeperFutianCloudTask(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTask.TaskInfo taskInfo);
 
     /**
      * 2、云端下发子任务，请求pad确认（type：100002）-> sweeper_task_confirm.proto
@@ -312,7 +314,7 @@ public interface OnAdasListener {
      * @param sysTime     当前时间戳
      * @param taskConfirm 数据
      */
-    void onSweeperFutianCloudTaskConfirm(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskConfirm.TaskConfirm taskConfirm);
+    void onSweeperFutianCloudTaskConfirm(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskConfirm.TaskConfirm taskConfirm);
 
     /**
      * 3、云端下发任务状态到pad（type：100003）-> sweeper_task_status.proto
@@ -323,7 +325,7 @@ public interface OnAdasListener {
      * @param sysTime        当前时间戳
      * @param taskStatusPush 数据
      */
-    void onSweeperFutianCloudTaskStatus(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskStatus.TaskStatusPush taskStatusPush);
+    void onSweeperFutianCloudTaskStatus(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskStatus.TaskStatusPush taskStatusPush);
 
     /**
      * 4、云端请求pad结束任务（type：100004）-> sweeper_task_stop.proto
@@ -334,7 +336,7 @@ public interface OnAdasListener {
      * @param sysTime     当前时间戳
      * @param stopTaskReq 数据
      */
-    void onSweeperFutianCloudTaskStop(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskStop.StopTaskReq stopTaskReq);
+    void onSweeperFutianCloudTaskStop(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskStop.StopTaskReq stopTaskReq);
 
     /**
      * 5、pad请求挂起任务（type：100005）-> sweeper_task_suspend_resume.proto
@@ -346,7 +348,7 @@ public interface OnAdasListener {
      * @param sysTime               当前时间戳
      * @param suspendResumeTaskResp 数据
      */
-    void onSweeperFutianCloudTaskSuspendResume(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskSuspendResume.SuspendResumeTaskResp suspendResumeTaskResp);
+    void onSweeperFutianCloudTaskSuspendResume(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskSuspendResume.SuspendResumeTaskResp suspendResumeTaskResp);
 
     /**
      * 8、接管后回自驾-pad上报状态给云端 云端下发启动自驾（type: 100008）-> sweeper_autopilot.proto
@@ -357,7 +359,7 @@ public interface OnAdasListener {
      * @param sysTime        当前时间戳
      * @param isBootableResp 数据
      */
-    void onSweeperFutianCloudBootable(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperBootable.IsBootableResp isBootableResp);
+    void onSweeperFutianCloudBootable(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperBootable.IsBootableResp isBootableResp);
 
     /**
      * 9、云端下发pad大任务状态（type: 100009）-> sweeper_big_task_status.proto
@@ -368,15 +370,38 @@ public interface OnAdasListener {
      * @param sysTime           当前时间戳
      * @param bigTaskStatusPush 数据
      */
-    void onSweeperFutianCloudBigTaskStatus(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperBigTaskStatus.BigTaskStatusPush bigTaskStatusPush);
+    void onSweeperFutianCloudBigTaskStatus(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperBigTaskStatus.BigTaskStatusPush bigTaskStatusPush);
 
     /**
-     * 清扫车云端任务未知类型
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+     *
+     * @param header            头
+     * @param messageType       消息类型
+     * @param reqNo             请求编号
+     * @param sysTime           当前时间戳
+     * @param bigTaskActionPush 数据
+     */
+    void onSweeperFutianCloudTaskCloudSuspendResume(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskCloudSuspendResume.BigTaskActionPush bigTaskActionPush);
+
+    /**
+     * 无人化场景
+     * 平行驾驶请求相关状态反馈
+     *
+     * @param header                    头
+     * @param messageType               消息类型
+     * @param reqNo                     请求编号
+     * @param sysTime                   当前时间戳
+     * @param parallelTaskProcessNotice 数据
+     */
+    void onParallelDrivingResp(@NonNull MessagePad.Header header, @NonNull AiCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable ParallelTaskProcessNoticeOuterClass.ParallelTaskProcessNotice parallelTaskProcessNotice);
+
+    /**
+     * AI云端任务未知类型
      *
      * @param header 头
      * @param bytes  原始数据
      */
-    void onSweeperFutianCloudTaskUnknown(@NonNull MessagePad.Header header, @NonNull byte[] bytes);
+    void onAiCloudTaskUnknown(@NonNull MessagePad.Header header, @NonNull byte[] bytes);
 
     /**
      * Bag管理应答

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/MessageType.java

@@ -73,6 +73,8 @@ public enum MessageType {
     TYPE_RECEIVE_SWEEPER_CLOUD_TASK_CMD(MessagePad.MessageType.MsgTypeTaskCmd, "云控下发清扫车任务指令"),
     TYPE_SEND_FSM_STATUS_REASON_QUERY_REQ(MessagePad.MessageType.MsgTypeFSMStatusReasonQueryReq, "FSM状态原因查询"),
     TYPE_RECEIVE_FSM_STATUS_REASON_QUERY_RESP(MessagePad.MessageType.MsgTypeFSMStatusReasonQueryResp, "FSM状态原因查询应答"),
+    TYPE_SEND_PARALLEL_DRIVING_REQ(MessagePad.MessageType.MsgTypeParallelDrivingCmd, "平行驾驶请求"),
+    TYPE_RECEIVE_PARALLEL_DRIVING_STATUS(MessagePad.MessageType.MsgTypeParallelDrivingCmd, "平行驾驶状态"),
     //TODO 透传原始pb文件中不存在以下type。由于Java中无法强转,所以在mogo-adas-data/message_pad.proto中放开注释
     TYPE_RECEIVE_PLANNING_DECISION_STATE(MessagePad.MessageType.MsgTypePlanningDecisionState, "Planning决策状态"),
     TYPE_RECEIVE_SWEEPER_TASK_INDEX_DATA(MessagePad.MessageType.MsgTypeSweeperTaskIndexData, "清扫车指标数据"),

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/autopilot/ability/AutopilotAbility250.java

@@ -13,6 +13,7 @@ import java.util.TimerTask;
 
 import chassis.Chassis;
 import chassis.ChassisStatesOuterClass;
+import chassis.VehicleStateOuterClass;
 import system_master.SystemStatusInfo;
 
 /**
@@ -26,6 +27,7 @@ public class AutopilotAbility250 {
     private static final String TAG = AutopilotAbility250.class.getSimpleName();
     private volatile Timer timer;
     private ChassisStatesOuterClass.ChassisStates chassisStates;
+    private VehicleStateOuterClass.VehicleState vehicleState;
     private int mapVersion = -1;//MAP版本
     private int masterVersion = -1;//Master版本
     private OnAutopilotAbilityListener listener;
@@ -57,6 +59,10 @@ public class AutopilotAbility250 {
         this.chassisStates = chassisStates;
     }
 
+    protected void setVehicleState(VehicleStateOuterClass.VehicleState vehicleState) {
+        this.vehicleState = vehicleState;
+    }
+
     private void onCallback(SystemStatusInfo.StatusInfo statusInfo) {
         boolean isAutopilotAbility = true;//是否能启动自动驾驶
         ArrayList<UnableAutopilotReason> unableAutopilotReasons = null;//不能启动自动驾驶原因
@@ -144,17 +150,19 @@ public class AutopilotAbility250 {
                     unableAutopilotReasons = AutopilotAbilityManager.getInstance().addUnableAutopilotReason(unableAutopilotReasons, UnableAutopilotReason.SourceType.CHASSIS, "档位异常");
                 }
             }
-            //TODO 关于手刹：不同车型的实现不同所以目前没法使用此字段
-
-//                //电子驻车制动系统
-//                if (chassisStates.hasEpbSystemStates()) {
-//                    ChassisStatesOuterClass.EPBSystemStates epb = chassisStates.getEpbSystemStates();
-//                    if (epb.hasEpbEnableState()){
-//                        epb.getEpbWorkState();
-//                    }
-//                }
-
         }
+        if (vehicleState != null) {
+            //TODO 关于手刹：目前只有老底盘中存在这个字段，df360开始，其他车型未知
+            //电子驻车制动系统
+            if (vehicleState.hasParkingBrake()) {
+                boolean isBrake = vehicleState.getParkingBrake();
+                if (isBrake) {
+                    isAutopilotAbility = false;
+                    unableAutopilotReasons = AutopilotAbilityManager.getInstance().addUnableAutopilotReason(unableAutopilotReasons, UnableAutopilotReason.SourceType.CHASSIS, "施加驻车");
+                }
+            }
+        }
+
         if (listener != null) {
             listener.onAutopilotAbility(isAutopilotAbility, unableAutopilotReasons);
         }

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/autopilot/ability/AutopilotAbility350And360.java

@@ -10,6 +10,7 @@ import java.util.ArrayList;
 
 import chassis.Chassis;
 import chassis.ChassisStatesOuterClass;
+import chassis.VehicleStateOuterClass;
 import system_master.SsmInfo;
 
 /**
@@ -21,6 +22,7 @@ import system_master.SsmInfo;
 public class AutopilotAbility350And360 {
     private static final String TAG = AutopilotAbility250.class.getSimpleName();
     private ChassisStatesOuterClass.ChassisStates chassisStates;
+    private VehicleStateOuterClass.VehicleState vehicleState;
     private int masterVersion = -1;//Master版本
     private OnAutopilotAbilityListener listener;
 
@@ -43,6 +45,10 @@ public class AutopilotAbility350And360 {
         this.chassisStates = chassisStates;
     }
 
+    protected void setVehicleState(VehicleStateOuterClass.VehicleState vehicleState) {
+        this.vehicleState = vehicleState;
+    }
+
     private void onCallback(SsmInfo.SsmStatusInf statusInfo) {
         boolean isAutopilotAbility = true;//是否能启动自动驾驶
         ArrayList<UnableAutopilotReason> unableAutopilotReasons = null;//不能启动自动驾驶原因
@@ -117,17 +123,19 @@ public class AutopilotAbility350And360 {
                     unableAutopilotReasons = AutopilotAbilityManager.getInstance().addUnableAutopilotReason(unableAutopilotReasons, UnableAutopilotReason.SourceType.CHASSIS, "档位异常");
                 }
             }
-            //TODO 关于手刹：不同车型的实现不同所以目前没法使用此字段
-
-//                //电子驻车制动系统
-//                if (chassisStates.hasEpbSystemStates()) {
-//                    ChassisStatesOuterClass.EPBSystemStates epb = chassisStates.getEpbSystemStates();
-//                    if (epb.hasEpbEnableState()){
-//                        epb.getEpbWorkState();
-//                    }
-//                }
-
         }
+        if (vehicleState != null) {
+            //TODO 关于手刹：目前只有老底盘中存在这个字段，df360开始，其他车型未知
+            //电子驻车制动系统
+            if (vehicleState.hasParkingBrake()) {
+                boolean isBrake = vehicleState.getParkingBrake();
+                if (isBrake) {
+                    isAutopilotAbility = false;
+                    unableAutopilotReasons = AutopilotAbilityManager.getInstance().addUnableAutopilotReason(unableAutopilotReasons, UnableAutopilotReason.SourceType.CHASSIS, "施加驻车");
+                }
+            }
+        }
+
         if (listener != null) {
             listener.onAutopilotAbility(isAutopilotAbility, unableAutopilotReasons);
         }

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/autopilot/ability/AutopilotAbilityManager.java

@@ -19,6 +19,7 @@ import java.util.TimerTask;
 
 import chassis.Chassis;
 import chassis.ChassisStatesOuterClass;
+import chassis.VehicleStateOuterClass;
 import function_state_management.FSMStatusReasonQueryOuterClass;
 import mogo.telematics.pad.MessagePad;
 import system_master.SsmInfo;
@@ -206,6 +207,20 @@ public class AutopilotAbilityManager implements AutopilotAbility230.OnAutopilotA
         }
     }
 
+    /**
+     * 老底盘中手刹状态更新（新底盘PB中没有所以单独传递）
+     *
+     * @param vehicleState 底盘
+     */
+    public void setVehicleState(VehicleStateOuterClass.VehicleState vehicleState) {
+        if (autopilotAbility250 != null) {
+            autopilotAbility250.setVehicleState(vehicleState);
+        }
+        if (autopilotAbility350And360 != null) {
+            autopilotAbility350And360.setVehicleState(vehicleState);
+        }
+    }
+
     /**
      * FSM OFF状态原因更新
      *

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/AiCloudTaskMessage.java

@@ -1,122 +1,138 @@
 package com.zhidao.support.adas.high.msg;
 
 import android.os.SystemClock;
-import android.util.Log;
 
 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
-import com.google.protobuf.TextFormat;
 import com.zhidao.support.adas.high.AdasChannel;
 import com.zhidao.support.adas.high.OnAdasListener;
 import com.zhidao.support.adas.high.common.ByteUtil;
 import com.zhidao.support.adas.high.common.CupidLogUtils;
 import com.zhidao.support.adas.high.protocol.RawData;
-import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
+import com.zhjt.mogo.adas.data.AiCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
 
 import mogo.telematics.pad.MessagePad;
+import mogo.yycp.paralleldriving.protocol.ParallelTaskProcessNoticeOuterClass;
 
 /**
- * 清扫车云端任务调度
+ * 云控任务：清扫车任务调度、无人化场景，平行驾驶请求相关指令及状态反馈
  */
-public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
+public class AiCloudTaskMessage extends MyAbstractMessageHandler {
 
-    public SweeperCloudTaskMessage() {
+    public AiCloudTaskMessage() {
     }
 
     @Override
     public void handlerMsg(RawData raw, OnAdasListener adasListener) throws InvalidProtocolBufferException {
         byte[] bytes = raw.originalData.toByteArray();
-        SweeperCloudTask.SweeperMessage message = SweeperCloudTask.SweeperMessage.parser().parseFrom(bytes, raw.getOffsetValue(), raw.getPackageLengthValue() - raw.getOffsetValue());
-        AdasChannel.calculateTimeConsumingOnDispatchRaw("清扫车云端任务调度", raw.receiveTime);
+        AiCloudTask.AiCloudPadMessage message = AiCloudTask.AiCloudPadMessage.parser().parseFrom(bytes, raw.getOffsetValue(), raw.getPackageLengthValue() - raw.getOffsetValue());
+        AdasChannel.calculateTimeConsumingOnDispatchRaw("云控任务", raw.receiveTime);
         long nowTime = 0;
         if (CupidLogUtils.isEnableLog())
             nowTime = SystemClock.elapsedRealtime();
         if (adasListener != null) {
             MessagePad.Header header = raw.getHeader();
-            SweeperCloudTask.MessageType msgType = SweeperCloudTask.MessageType.forNumber(message.getMsgType());//消息类型，响应请求时，使用对应请求的消息类型
+            AiCloudTask.MessageType msgType = AiCloudTask.MessageType.forNumber(message.getMsgType());//消息类型，响应请求时，使用对应请求的消息类型
             String reqNo = message.getReqNo(); //请求编号，响应请求时，使用请求方的请求编号
             long sysTime = message.getSysTime(); //当前时间戳
             ByteString payload = message.getPayload();
-            Log.i("SweeperCloudTaskMessage", "MsgType=" + (msgType == null ? "null" : msgType.getNumber()) + " reqNo=" + reqNo + " sysTime=" + sysTime);
+            CupidLogUtils.i("SweeperCloudTaskMessage", "MsgType=" + (msgType == null ? "null" : msgType.getNumber()) + " reqNo=" + reqNo + " sysTime=" + sysTime);
             boolean isExistPayload = payload != null && !payload.isEmpty();
-            if (msgType == SweeperCloudTask.MessageType.CloudPushTask || msgType == SweeperCloudTask.MessageType.PadSendGetTaskReq) {
+            if (msgType == AiCloudTask.MessageType.CloudPushTask || msgType == AiCloudTask.MessageType.PadSendGetTaskReq) {
                 //1、云端下发大任务信息（type: 100001）-> sweeper_task.proto
                 //7、pad主动拉取当前车辆正在执行任务的完整信息（type：100007）-> sweeper_task.proto
                 SweeperTask.TaskInfo taskInfo = null;
                 if (isExistPayload) {
                     taskInfo = SweeperTask.TaskInfo.parseFrom(payload);
                 }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskInfo == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(taskInfo)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskInfo == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(taskInfo)));
                 adasListener.onSweeperFutianCloudTask(header, msgType, reqNo, sysTime, taskInfo);
-            } else if (msgType == SweeperCloudTask.MessageType.CloudPushTaskConfirm) {
+            } else if (msgType == AiCloudTask.MessageType.CloudPushTaskConfirm) {
                 //2、云端下发子任务，请求pad确认（type：100002）-> sweeper_task_confirm.proto
                 SweeperTaskConfirm.TaskConfirm taskConfirm = null;
                 if (isExistPayload) {
                     taskConfirm = SweeperTaskConfirm.TaskConfirm.parseFrom(payload);
                 }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskConfirm == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(taskConfirm)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskConfirm == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(taskConfirm)));
                 adasListener.onSweeperFutianCloudTaskConfirm(header, msgType, reqNo, sysTime, taskConfirm);
-            } else if (msgType == SweeperCloudTask.MessageType.CloudPushTaskStatus) {
+            } else if (msgType == AiCloudTask.MessageType.CloudPushTaskStatus) {
                 //3、云端下发任务状态到pad（type：100003）-> sweeper_task_status.proto
                 SweeperTaskStatus.TaskStatusPush taskStatusPush = null;
                 if (isExistPayload) {
                     taskStatusPush = SweeperTaskStatus.TaskStatusPush.parseFrom(payload);
                 }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskStatusPush == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(taskStatusPush)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskStatusPush == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(taskStatusPush)));
                 adasListener.onSweeperFutianCloudTaskStatus(header, msgType, reqNo, sysTime, taskStatusPush);
-            } else if (msgType == SweeperCloudTask.MessageType.CloudPushTaskStop) {
+            } else if (msgType == AiCloudTask.MessageType.CloudPushTaskStop) {
                 //4、云端请求pad结束任务（type：100004）-> sweeper_task_stop.proto
                 SweeperTaskStop.StopTaskReq stopTaskReq = null;
                 if (isExistPayload) {
                     stopTaskReq = SweeperTaskStop.StopTaskReq.parseFrom(payload);
                 }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (stopTaskReq == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(stopTaskReq)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (stopTaskReq == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(stopTaskReq)));
                 adasListener.onSweeperFutianCloudTaskStop(header, msgType, reqNo, sysTime, stopTaskReq);
-            } else if (msgType == SweeperCloudTask.MessageType.PadSendTaskSuspend || msgType == SweeperCloudTask.MessageType.PadSendTaskResume) {
+            } else if (msgType == AiCloudTask.MessageType.PadSendTaskSuspend || msgType == AiCloudTask.MessageType.PadSendTaskResume) {
                 //5、pad请求挂起任务（type：100005）-> sweeper_task_suspend_resume.proto
                 //6、pad请求恢复挂起的任务（type：100006）-> sweeper_task_suspend_resume.proto
                 SweeperTaskSuspendResume.SuspendResumeTaskResp suspendResumeTaskResp = null;
                 if (isExistPayload) {
                     suspendResumeTaskResp = SweeperTaskSuspendResume.SuspendResumeTaskResp.parseFrom(payload);
                 }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (suspendResumeTaskResp == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(suspendResumeTaskResp)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (suspendResumeTaskResp == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(suspendResumeTaskResp)));
                 adasListener.onSweeperFutianCloudTaskSuspendResume(header, msgType, reqNo, sysTime, suspendResumeTaskResp);
-            } else if (msgType == SweeperCloudTask.MessageType.PadSendBootable) {
+            } else if (msgType == AiCloudTask.MessageType.PadSendBootable) {
                 //8、接管后回自驾-pad上报状态给云端 云端下发启动自驾（type: 100008）-> sweeper_autopilot.proto
                 SweeperBootable.IsBootableResp isBootableResp = null;
                 if (isExistPayload) {
                     isBootableResp = SweeperBootable.IsBootableResp.parseFrom(payload);
                 }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (isBootableResp == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(isBootableResp)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (isBootableResp == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(isBootableResp)));
                 adasListener.onSweeperFutianCloudBootable(header, msgType, reqNo, sysTime, isBootableResp);
-            } else if (msgType == SweeperCloudTask.MessageType.CloudPushBigTaskStatus) {
+            } else if (msgType == AiCloudTask.MessageType.CloudPushBigTaskStatus) {
                 //9、云端下发pad大任务状态（type: 100009）-> sweeper_big_task_status.proto
                 SweeperBigTaskStatus.BigTaskStatusPush bigTaskStatusPush = null;
                 if (isExistPayload) {
                     bigTaskStatusPush = SweeperBigTaskStatus.BigTaskStatusPush.parseFrom(payload);
                 }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (bigTaskStatusPush == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(bigTaskStatusPush)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (bigTaskStatusPush == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(bigTaskStatusPush)));
                 adasListener.onSweeperFutianCloudBigTaskStatus(header, msgType, reqNo, sysTime, bigTaskStatusPush);
+            } else if (msgType == AiCloudTask.MessageType.CloudPushTaskSuspendResume) {
+                //10、云端下发任务暂停/恢复指令到pad（type: 100010）
+                SweeperTaskCloudSuspendResume.BigTaskActionPush bigTaskActionPush = null;
+                if (isExistPayload) {
+                    bigTaskActionPush = SweeperTaskCloudSuspendResume.BigTaskActionPush.parseFrom(payload);
+                }
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (bigTaskActionPush == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(bigTaskActionPush)));
+                adasListener.onSweeperFutianCloudTaskCloudSuspendResume(header, msgType, reqNo, sysTime, bigTaskActionPush);
+            } else if (msgType == AiCloudTask.MessageType.ParallelDrivingCmd) {
+                //无人化场景，平行驾驶请求相关指令及状态反馈
+                ParallelTaskProcessNoticeOuterClass.ParallelTaskProcessNotice parallelTaskProcessNotice = null;
+                if (isExistPayload) {
+                    parallelTaskProcessNotice = ParallelTaskProcessNoticeOuterClass.ParallelTaskProcessNotice.parseFrom(payload);
+                }
+                adasListener.onParallelDrivingResp(header, msgType, reqNo, sysTime, parallelTaskProcessNotice);
             } else {
                 //未知数据类型
-                Log.i("SweeperCloudTaskMessage", " 错误数据=" + ByteUtil.byteArrToHex(bytes));
-                adasListener.onSweeperFutianCloudTaskUnknown(header, bytes);
+                CupidLogUtils.i("SweeperCloudTaskMessage", " 错误数据=" + ByteUtil.byteArrToHex(bytes));
+                adasListener.onAiCloudTaskUnknown(header, bytes);
             }
         }
-        AdasChannel.calculateTimeConsumingBusiness("清扫车云端任务调度", nowTime);
+        AdasChannel.calculateTimeConsumingBusiness("云控任务", nowTime);
     }
 }

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/MyMessageFactory.java

@@ -42,7 +42,7 @@ public class MyMessageFactory implements IMyMessageFactory {
     private IMsg v2nCongestionEventMessage;//主车附近事件推送
     private IMsg v2nGlobalPathEventsMessage;//主车路径全局事件推送
     private IMsg getParamRespMessage;//参数获取应答
-    private IMsg sweeperCloudTaskMessage;//云控下发清扫车任务指令
+    private IMsg aiCloudTaskMessage;//云控任务：清扫车任务指令、无人化场景，平行驾驶请求相关指令及状态反馈
     private IMsg m1StitchedVideoMessage;//M1拼接视频
     private IMsg fSMStatusReasonRespondMessage;//FSM状态原因查询
 
@@ -228,12 +228,12 @@ public class MyMessageFactory implements IMyMessageFactory {
                 getParamRespMessage = new GetParamRespMessage();
             }
             return getParamRespMessage;
-        } else if (messageType == MessageType.TYPE_RECEIVE_SWEEPER_CLOUD_TASK_CMD.typeCode) {
-            //云控下发清扫车任务指令
-            if (sweeperCloudTaskMessage == null) {
-                sweeperCloudTaskMessage = new SweeperCloudTaskMessage();
+        } else if (messageType == MessageType.TYPE_RECEIVE_SWEEPER_CLOUD_TASK_CMD.typeCode || messageType == MessageType.TYPE_RECEIVE_PARALLEL_DRIVING_STATUS.typeCode) {
+            //云控任务：清扫车任务指令、无人化场景，平行驾驶请求相关指令及状态反馈
+            if (aiCloudTaskMessage == null) {
+                aiCloudTaskMessage = new AiCloudTaskMessage();
             }
-            return sweeperCloudTaskMessage;
+            return aiCloudTaskMessage;
         } else if (messageType == MessageType.TYPE_RECEIVE_M1_STITCHED_VIDEO.typeCode) {
             //M1拼接视频
             if (m1StitchedVideoMessage == null) {

libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/VehicleStateMessage.java

@@ -26,6 +26,7 @@ public class VehicleStateMessage extends MyAbstractMessageHandler {
         long nowTime = 0;
         if (CupidLogUtils.isEnableLog())
             nowTime = SystemClock.elapsedRealtime();
+        AutopilotAbilityManager.getInstance().setVehicleState(vehicleState);
         ChassisStatesOuterClass.ChassisStates chassisStates = compatibility(adasListener, raw, vehicleState);
         if (adasListener != null) {
             //TODO 暂时关闭老底盘转发 后期 会删除 onVehicleState