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

2023-09-12 17:14:40 +08:00
parent d1b61008e5 6576304457
commit d02b1fcb6d
62 changed files with 1714 additions and 637 deletions
--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/callback/ISweeperCloudTaskCallback.kt
+++ b/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)
+
    /**
     * 设置轨迹坐标点集合
     */
--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/constant/SweeperConst.kt
+++ b/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

--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/fragment/BaseSweeperTabFragment.java
+++ b/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) {
--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/fragment/SweeperFragment.kt
+++ b/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
    }
 }
--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/model/SweeperTaskModel.java
+++ b/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
+
    }
 }
--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/presenter/SweeperPresenter.java
+++ b/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
--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/util/SweeperCloudTaskUtils.kt
+++ b/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}分钟"
+    }
+
+
 }
--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/view/SubTaskView.kt
+++ b/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)
--- a/OCH/sweeper/sweeper-cloud/src/main/java/com/mogo/och/sweepercloud/view/SweeperCurrentTaskInfoView.kt
+++ b/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)
+                    }
+                }
+            }
+        }
+    }
--- a/OCH/sweeper/sweeper-cloud/src/main/res/layout/sweeper_base_fragment.xml
+++ b/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" />


--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/base/BaseViewModel.kt
+++ b/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 {
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/bean/TaxiDriverCarServiceBean.kt
+++ b/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
+    )
 }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/bean/TaxiDriverTaskWithOrderBean.kt
+++ b/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,
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/callback/ITaxiOrderStatusCallback.java
+++ b/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);
 }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/callback/ITaxiTaskWithOrderCallback.kt
+++ b/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)
 }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/network/TaxiTaskWithOrderServiceApi.kt
+++ b/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>
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/network/TaxiTaskWithOrderServiceManager.kt
+++ b/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"))
    }
 }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/base/BaseTaxiTabFragment.kt
+++ b/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
        }
    }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/base/TaxiFragment.kt
+++ b/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()
    }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/base/TaxiPresenter.java
+++ b/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));
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/common/AvoidLeakDialog.kt
+++ b/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()
    }
 }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/debug/DebugView.kt
+++ b/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) {
+    }
 }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaskUiState.kt
+++ b/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()
 }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaxiCurrentTaskFragment.kt
+++ b/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
                }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaxiCurrentTaskViewModel.kt
+++ b/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
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaxiTaskModel.kt
+++ b/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 }
--- a/OCH/taxi/unmanned-driver/src/main/java/com/mogo/och/taxi/ui/task/TaxiTaskTabFragment.kt
+++ b/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()