Merge branch 'release_sweeper-d_230717_3.2.0.1' into 'master'

[Publish] Sweeper 云控V3.2.0 See merge request SCA/L4HA/AndroidApp/MoGoEagleEye!817
2023-08-18 06:19:13 +00:00
parent cc434b7d42 da62eb37de
commit ea468d9eb1
43 changed files with 1344 additions and 488 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
@@ -10,6 +10,8 @@ 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

 /**
@@ -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
@@ -59,6 +59,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;

@@ -213,6 +214,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
@@ -42,9 +42,10 @@ import com.mogo.och.sweepercloud.util.SweeperCloudTaskUtils;
 import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;

@@ -182,7 +183,6 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
        });
    }

-
    public void setControllerStatusCallback(ISweeperControllerStatusCallback callback) {
        this.mControllerStatusCallback = callback;
    }
@@ -216,7 +216,6 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
                }
            }
        }
-
    };

    public void setSubtask(String subTaskId, SweeperTask.TaskModel subTaskType, int currentLineId) {
@@ -256,8 +255,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);
@@ -304,7 +304,6 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
            }
            if (mSubTaskType == SweeperTask.TaskModel.MANUAL) {//收集人工驾驶子任务坐标点
                addCoordinates(gnssInfo);
-                return;
            }
        }
    };
@@ -334,7 +333,6 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
    @Override
    public void onSweeperFutianCloudTask(@NonNull SweeperCloudTask.MessageType messageType, String reqNo, long sysTime,
                                         SweeperTask.TaskInfo taskInfo) {
-
        CallerLogger.INSTANCE.d(M_SWEEPER + TAG,
                "messageType: " + messageType.getNumber() + " sysTime：" + sysTime + " reqNo：" + reqNo + " onSweeperFutianCloudTask：" + (taskInfo == null ? "null" : printMessage(taskInfo)) + " mSweeperTaskCallback：" + mSweeperTaskCallback);
        if (mSweeperTaskCallback != null) {
@@ -407,7 +405,18 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
                "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 SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime,
+                                                           @Nullable SweeperTaskCloudSuspendResume.BigTaskActionPush bigTaskActionPush) {
+        CallerLogger.INSTANCE.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());
        }
    }

@@ -429,24 +438,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.INSTANCE.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);
    }

    /**
@@ -493,7 +503,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();
@@ -507,6 +517,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
        builder.setSn(getDriverSn());
        String reqNo = SweeperCloudTaskUtils.getRequestId();
        SweeperTask.GetTaskReq getTaskReq = builder.build();
+
        CallerLogger.INSTANCE.d(M_SWEEPER + TAG,
                "getCurrentTask:" + printMessage(getTaskReq) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.PadSendGetTaskReq.getNumber());
        getAutoPilotControlManager().sendSweeperGetTaskReq(reqNo, getTaskReq);
@@ -522,6 +533,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
        builder.setCode(code);
        SweeperTask.StartTaskResp startTaskResp = builder.build();
        String reqNo = msgTypeAndReqNo.get(SweeperCloudTask.MessageType.CloudPushTask.getNumber());
+
        getAutoPilotControlManager().sendSweeperStartTaskResp(reqNo, startTaskResp);
        CallerLogger.INSTANCE.d(M_SWEEPER + TAG,
                "sendSweeperStartTaskResp:" + printMessage(startTaskResp) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.CloudPushTask.getNumber());
@@ -538,6 +550,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
        builder.setCode(code);
        SweeperTaskConfirm.TaskConfirmResp taskConfirmResp = builder.build();
        String reqNo = msgTypeAndReqNo.get(SweeperCloudTask.MessageType.CloudPushTaskConfirm.getNumber());
+
        CallerLogger.INSTANCE.d(M_SWEEPER + TAG,
                "sendSweeperTaskConfirmResp" + printMessage(taskConfirmResp) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.CloudPushTaskConfirm.getNumber());
        getAutoPilotControlManager().sendSweeperTaskConfirmResp(reqNo, taskConfirmResp);
@@ -556,6 +569,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
        builder.setCode(code);
        SweeperTaskStop.StopTaskResp stopTaskResp = builder.build();
        String reqNo = msgTypeAndReqNo.get(SweeperCloudTask.MessageType.CloudPushTaskStop.getNumber());
+
        CallerLogger.INSTANCE.d(M_SWEEPER + TAG,
                "sendSweeperStopTaskResp" + printMessage(stopTaskResp) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.CloudPushTaskStop.getNumber());
        getAutoPilotControlManager().sendSweeperStopTaskResp(reqNo, stopTaskResp);
@@ -576,13 +590,31 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM
        builder.setLineId(lineId);
        SweeperBootable.IsBootable isBootable = builder.build();
        String reqNo = SweeperCloudTaskUtils.getRequestId();
+
        CallerLogger.INSTANCE.d(M_SWEEPER + TAG,
                "sendSweeperAutopilotBootable" + printMessage(isBootable) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.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(SweeperCloudTask.MessageType.CloudPushTaskSuspendResume.getNumber());
+
+        CallerLogger.INSTANCE.d(M_SWEEPER + TAG,
+                "sendSweeperSuspendResumeTaskResp" + printMessage(resp) + " reqNo:" + reqNo + " messageType:" + SweeperCloudTask.MessageType.CloudPushTaskSuspendResume);
+        getAutoPilotControlManager().sendSweeperCloudSuspendResumeTaskResp(reqNo, resp);
+    }
+
    public CallerAutoPilotControlManager getAutoPilotControlManager() {
        return CallerAutoPilotControlManager.INSTANCE;
    }
@@ -593,23 +625,7 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM

    @Override
    public void onAutopilotStatusResponse(@NonNull AutopilotStatusInfo autoPilotStatusInfo) {
-        //CallerLogger.INSTANCE.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
@@ -630,6 +646,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);
@@ -660,11 +677,27 @@ public class SweeperTaskModel implements IMoGoSweeperFutianCloudTaskListener, IM

    @Override
    public void onAutopilotStatusResponse(int state) {
-        // TODO: 2023/6/19 bingbing
+        //CallerLogger.INSTANCE.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.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.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"
@@ -204,7 +213,7 @@ 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()}",
@@ -230,20 +239,67 @@ object SweeperCloudTaskUtils {
        }, 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/core/function-impl/mogo-core-function-datacenter/src/main/java/com/mogo/eagle/core/function/datacenter/autopilot/MoGoAutopilotControlProvider.kt
+++ b/core/function-impl/mogo-core-function-datacenter/src/main/java/com/mogo/eagle/core/function/datacenter/autopilot/MoGoAutopilotControlProvider.kt
@@ -61,7 +61,8 @@ import com.zhjt.mogo.adas.data.AdasConstants
 import com.zhjt.mogo.adas.data.bean.MogoReport
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop
 import com.zhjt.service.chain.ChainLog
@@ -1002,6 +1003,18 @@ class MoGoAutopilotControlProvider :
        return AdasManager.getInstance().sendSweeperAutopilotBootable(reqNo, isBootable)
    }

+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    override fun sendSweeperCloudSuspendResumeTaskResp(reqNo: String, bigTaskActionResp: SweeperTaskCloudSuspendResume.BigTaskActionResp): Boolean {
+        return AdasManager.getInstance().sendSweeperCloudSuspendResumeTaskResp(reqNo, bigTaskActionResp)
+    }
+
    override fun setIsDrawPointCloud(isDrawPointCloud: Boolean) {
        if (isDrawPointCloud) {
            AdasManager.getInstance().subscribeInterface(
@@ -1032,6 +1045,14 @@ class MoGoAutopilotControlProvider :
        }
    }

+    override fun setIsSubscribeBackCameraVideoVideo(role: Int, isSubscribe: Boolean) {
+        val type =
+            if (isSubscribe) Constants.SUBSCRIBE_TYPE.SUBSCRIBE else Constants.SUBSCRIBE_TYPE.UNSUBSCRIBE
+        AdasManager.getInstance().subscribeInterface(
+            role, type, MessageType.TYPE_RECEIVE_BACK_CAMERA_VIDEO
+        )
+    }
+
    override fun sendRoboBusJinlvM1FrontDoorCmd(switchCmd: Int): Boolean {
        return AdasManager.getInstance().sendRoboBusJinlvM1FrontDoorCmd(switchCmd)
    }
--- a/core/function-impl/mogo-core-function-datacenter/src/main/java/com/mogo/eagle/core/function/datacenter/autopilot/adapter/MoGoAdasListenerImpl.kt
+++ b/core/function-impl/mogo-core-function-datacenter/src/main/java/com/mogo/eagle/core/function/datacenter/autopilot/adapter/MoGoAdasListenerImpl.kt
@@ -58,8 +58,9 @@ import com.zhjt.mogo.adas.data.bean.AutopilotStatistics
 import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop
@@ -534,7 +535,7 @@ class MoGoAdasListenerImpl : OnAdasListener {
     * @param data   数据
     */
    override fun onBackCameraVideo(header: MessagePad.Header, data: ByteArray) {
-        CallerSweeperFutianBackCameraVideoListenerManager.invokeSweeperFutianBackCameraVideo(data)
+        CallerBackCameraVideoListenerManager.invokeBackCameraVideo(data)
    }

    /**
@@ -646,6 +647,19 @@ class MoGoAdasListenerImpl : OnAdasListener {
        CallerSweeperFutianCloudTaskListenerManager.invokeSweeperFutianCloudBigTaskStatus(messageType, reqNo, sysTime, bigTaskStatusPush)
    }

+    /**
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+     *
+     * @param header            头
+     * @param messageType       消息类型
+     * @param reqNo             请求编号
+     * @param sysTime           当前时间戳
+     * @param bigTaskActionPush 数据
+     */
+    override fun onSweeperFutianCloudTaskCloudSuspendResume(header: MessagePad.Header, messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskActionPush: SweeperTaskCloudSuspendResume.BigTaskActionPush?) {
+        CallerSweeperFutianCloudTaskListenerManager.invokeSweeperFutianCloudTaskCloudSuspendResume(messageType, reqNo, sysTime, bigTaskActionPush)
+    }
+
    /**
     * 清扫车云端任务未知类型
     *
--- a/core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/lookaround/MoGoLookAroundProviderImpl.kt
+++ b/core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/lookaround/MoGoLookAroundProviderImpl.kt
@@ -21,7 +21,7 @@ import mogo.telematics.pad.MessagePad.SetParamReq
 import java.util.concurrent.atomic.AtomicInteger
 import kotlin.concurrent.*

-internal class MoGoLookAroundProviderImpl: IMoGoLookAroundProvider, IMoGoSweeperFutianBackCameraVideoListener, IMoGoRoboBusJinlvM1StitchedVideoListener, IMoGoGetParamResponseListener {
+internal class MoGoLookAroundProviderImpl: IMoGoLookAroundProvider, IMoGoBackCameraVideoListener, IMoGoRoboBusJinlvM1StitchedVideoListener, IMoGoGetParamResponseListener {

    companion object {
        private const val TAG = "MoGoLookAroundProvider"
@@ -58,7 +58,7 @@ internal class MoGoLookAroundProviderImpl: IMoGoLookAroundProvider, IMoGoSweeper
    private var job: Job? = null

    override fun init(ctx: Context) {
-        CallerSweeperFutianBackCameraVideoListenerManager.addListener(TAG, this)
+        CallerBackCameraVideoListenerManager.addListener(TAG, this)
        CallerRoboBusJinlvM1StitchedVideoListenerManager.addListener(TAG, this)
        CallerAutopilotGetParamResponseDispatcher.addListener(TAG, this)
        if (AppIdentityModeUtils.isM1(FunctionBuildConfig.appIdentityMode)) {
@@ -116,7 +116,7 @@ internal class MoGoLookAroundProviderImpl: IMoGoLookAroundProvider, IMoGoSweeper

    }

-    override fun onSweeperFutianBackCameraVideo(data: ByteArray) {
+    override fun onBackCameraVideo(data: ByteArray) {
        if (bitmapWidth.get() == 0 || bitmapHeight.get() == 0) {
            val options = BitmapFactory.Options()
            options.inJustDecodeBounds = true
--- a/core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/mofang/MoFangCommandExecutor.kt
+++ b/core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/mofang/MoFangCommandExecutor.kt
@@ -3,8 +3,10 @@ package com.zhjt.mogo_core_function_devatools.mofang
 import android.os.*
 import android.util.*
 import android.view.KeyEvent
+import com.mogo.eagle.core.data.config.*
 import com.mogo.eagle.core.function.call.autopilot.*
 import com.mogo.eagle.core.network.utils.GsonUtil
+import com.mogo.eagle.core.utilcode.mogo.*
 import com.zhjt.mogo_core_function_devatools.mofang.MoFangAnalyticUtils.Companion.EVENT_EXECUTE
 import com.zhjt.mogo_core_function_devatools.mofang.MoFangAnalyticUtils.Companion.EVENT_EXECUTE_SUB_KEYCODE
 import com.zhjt.mogo_core_function_devatools.mofang.MoFangAnalyticUtils.Companion.EVENT_EXECUTE_SUB_TYPE
@@ -13,14 +15,14 @@ internal class MoFangCommandExecutor {

    companion object {
        private const val TAG = "MoFangCommandExecutor"
-        private const val MSG_WHAT_KEY_CODE_A = 0x01
-        private const val MSG_WHAT_KEY_CODE_B = 0x02
-        private const val MSG_WHAT_KEY_CODE_BL = 0x03
-        private const val MSG_WHAT_KEY_CODE_C = 0x04
-        private const val MSG_WHAT_KEY_CODE_D = 0x05
-        private const val MSG_WHAT_KEY_CODE_E = 0x06
-        private const val MSG_WHAT_KEY_CODE_EL = 0x07
-        private const val MSG_WHAT_KEY_CODE_AB = 0x08
+        private const val MSG_WHAT_KEY_CODE_A  = 0x01
+        private const val MSG_WHAT_KEY_CODE_AL = 0x02
+        private const val MSG_WHAT_KEY_CODE_B  = 0x03
+        private const val MSG_WHAT_KEY_CODE_AB = 0x04
+        private const val MSG_WHAT_KEY_CODE_C  = 0x05
+        private const val MSG_WHAT_KEY_CODE_D  = 0x06
+        private const val MSG_WHAT_KEY_CODE_E  = 0x07
+        private const val MSG_WHAT_KEY_CODE_EL = 0x08
    }

    @Volatile
@@ -34,7 +36,7 @@ internal class MoFangCommandExecutor {
        val message = whatToString(msg.what, ", msg_info:[obj:${msg.obj}, arg1: ${msg.arg1}, arg2: ${msg.arg2}]")
        linkedLog?.record(mapOf("收到:${System.currentTimeMillis()}" to "$message"))
        when(msg.what) {
-            MSG_WHAT_KEY_CODE_A, MSG_WHAT_KEY_CODE_B, MSG_WHAT_KEY_CODE_AB, MSG_WHAT_KEY_CODE_BL -> {
+            MSG_WHAT_KEY_CODE_A, MSG_WHAT_KEY_CODE_B, MSG_WHAT_KEY_CODE_AB, MSG_WHAT_KEY_CODE_AL -> {
                var send = false
                try {
                    val acc = msg.obj as? Double
@@ -82,7 +84,13 @@ internal class MoFangCommandExecutor {
                    MoFangAnalyticUtils.track(EVENT_EXECUTE, mutableMapOf(EVENT_EXECUTE_SUB_KEYCODE to (getKeycodeByWhat(msg.what) ?: ""), EVENT_EXECUTE_SUB_TYPE to (getInputTypeByWhat(msg.what) ?: "")))
                    linkedLog?.record(mapOf("执行:${System.currentTimeMillis()}" to "$message, $json"))
                    Log.d(TAG, "--- 启动自驾 ----入参:$json")
-                    CallerAutoPilotControlManager.startAutoPilot(parameters)
+                    //清扫车有FSM模块，魔方启动自驾时需要将Source修改为魔方，以便telamatics做区分并在转发时增加flag标记
+                    if (AppIdentityModeUtils.isSweeper(FunctionBuildConfig.appIdentityMode)) {
+                        CallerAutoPilotControlManager.startAutoPilotByMoFang(parameters)
+                    } else{
+                        CallerAutoPilotControlManager.startAutoPilot(parameters)
+                    }
+
                } catch (t: Throwable) {
                    t.printStackTrace()
                    Log.e(TAG, "error: ${t.message}, msg-> $msg")
@@ -124,14 +132,14 @@ internal class MoFangCommandExecutor {
            MSG_WHAT_KEY_CODE_A -> {
                "单击键A->加速度每隔500ms，减少1$extra"
            }
-            MSG_WHAT_KEY_CODE_AB -> {
-                "组合键AB->加速度每隔500毫秒，减小2$extra"
+            MSG_WHAT_KEY_CODE_AL -> {
+                "长按键A->加速度每隔500ms，减少2$extra"
            }
            MSG_WHAT_KEY_CODE_B -> {
                "单击键B->复原$extra"
            }
-            MSG_WHAT_KEY_CODE_BL -> {
-                "长按键B->加速度每隔500ms，增加1$extra"
+            MSG_WHAT_KEY_CODE_AB -> {
+                "组合键AB->加速度每隔500毫秒，增加1$extra"
            }
            MSG_WHAT_KEY_CODE_C -> {
                "单击键C->左变道$extra"
@@ -151,12 +159,12 @@ internal class MoFangCommandExecutor {

    private fun getKeycodeByWhat(what: Int): String? {
        return when(what) {
-            MSG_WHAT_KEY_CODE_A -> KeyEvent.keyCodeToString(KeyEvent.KEYCODE_A)
-            MSG_WHAT_KEY_CODE_B,MSG_WHAT_KEY_CODE_BL -> KeyEvent.keyCodeToString(KeyEvent.KEYCODE_B)
+            MSG_WHAT_KEY_CODE_A, MSG_WHAT_KEY_CODE_AL -> KeyEvent.keyCodeToString(KeyEvent.KEYCODE_A)
+            MSG_WHAT_KEY_CODE_B -> KeyEvent.keyCodeToString(KeyEvent.KEYCODE_B)
+            MSG_WHAT_KEY_CODE_AB -> "${KeyEvent.keyCodeToString(KeyEvent.KEYCODE_A)},${KeyEvent.keyCodeToString(KeyEvent.KEYCODE_B)}"
            MSG_WHAT_KEY_CODE_C -> KeyEvent.keyCodeToString(KeyEvent.KEYCODE_C)
            MSG_WHAT_KEY_CODE_D -> KeyEvent.keyCodeToString(KeyEvent.KEYCODE_D)
            MSG_WHAT_KEY_CODE_E, MSG_WHAT_KEY_CODE_EL -> KeyEvent.keyCodeToString(KeyEvent.KEYCODE_E)
-            MSG_WHAT_KEY_CODE_AB -> "${KeyEvent.keyCodeToString(KeyEvent.KEYCODE_A)},${KeyEvent.keyCodeToString(KeyEvent.KEYCODE_B)}"
            else -> null
        }
    }
@@ -170,7 +178,7 @@ internal class MoFangCommandExecutor {
            MSG_WHAT_KEY_CODE_E -> {
               "1"
            }
-            MSG_WHAT_KEY_CODE_BL,MSG_WHAT_KEY_CODE_EL -> {
+            MSG_WHAT_KEY_CODE_AL,MSG_WHAT_KEY_CODE_EL -> {
                "2"
            }
            MSG_WHAT_KEY_CODE_AB -> {
@@ -189,7 +197,7 @@ internal class MoFangCommandExecutor {
            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
            handler.removeMessages(MSG_WHAT_KEY_CODE_B)
            handler.removeMessages(MSG_WHAT_KEY_CODE_AB)
-            handler.removeMessages(MSG_WHAT_KEY_CODE_BL)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_AL)
            handler.sendMessage(Message.obtain().also {
                it.what = MSG_WHAT_KEY_CODE_A
                it.obj = -1.0
@@ -198,10 +206,10 @@ internal class MoFangCommandExecutor {
        }
        if (keycode == KeyEvent.KEYCODE_B) {
            Log.d(TAG, "--- 单机键B --- 复原 ----")
-            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
            handler.removeMessages(MSG_WHAT_KEY_CODE_B)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
            handler.removeMessages(MSG_WHAT_KEY_CODE_AB)
-            handler.removeMessages(MSG_WHAT_KEY_CODE_BL)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_AL)
            handler.sendMessage(Message.obtain().also {
                it.what = MSG_WHAT_KEY_CODE_B
                it.obj = 0.0
@@ -241,6 +249,19 @@ internal class MoFangCommandExecutor {
    }

    fun handleLongClick(keyCode: Int) {
+        if (keyCode == KeyEvent.KEYCODE_A) {
+            Log.d(TAG, "---- 长按键A ---- 加速度每隔500毫秒，减小2 ---")
+            handler.removeMessages(MSG_WHAT_KEY_CODE_AL)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_B)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_AB)
+            handler.sendMessage(Message.obtain().also {
+                it.what = MSG_WHAT_KEY_CODE_AL
+                it.obj = -2.0
+            })
+            linkedLog?.record(mapOf("发送[AL]:${System.currentTimeMillis()}" to "${whatToString(MSG_WHAT_KEY_CODE_AL)}"))
+        }
+
        if (keyCode == KeyEvent.KEYCODE_E) {
            Log.d(TAG, "--- 长按键E --- 鸣笛 ----")
            handler.removeMessages(MSG_WHAT_KEY_CODE_EL)
@@ -250,31 +271,19 @@ internal class MoFangCommandExecutor {
            })
            linkedLog?.record(mapOf("发送[EL]:${System.currentTimeMillis()}" to "${whatToString(MSG_WHAT_KEY_CODE_EL)}"))
        }
-        if (keyCode == KeyEvent.KEYCODE_B) {
-            Log.d(TAG, "--- 长按键B --- 加速度加1 ----")
-            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
-            handler.removeMessages(MSG_WHAT_KEY_CODE_B)
-            handler.removeMessages(MSG_WHAT_KEY_CODE_AB)
-            handler.removeMessages(MSG_WHAT_KEY_CODE_BL)
-            handler.sendMessage(Message.obtain().also {
-                it.what = MSG_WHAT_KEY_CODE_BL
-                it.obj = 1.0
-            })
-            linkedLog?.record(mapOf("发送[BL]:${System.currentTimeMillis()}" to "${whatToString(MSG_WHAT_KEY_CODE_BL)}"))
-        }
    }

    fun handleCombineClick(vararg keyCodes: Int) {
        if (isCombineEqual(KeyEvent.KEYCODE_A, KeyEvent.KEYCODE_B, *keyCodes)) {
-            //AB组合键，加速度每隔500毫秒，减小2
-            Log.d(TAG, "---- 组合键AB ---- 按下，加速度每隔500毫秒，减小2 ---")
+            //AB组合键，加速度每隔500毫秒，增加1
+            Log.d(TAG, "---- 组合键AB ---- 按下, 加速度加1 ----")
            handler.removeMessages(MSG_WHAT_KEY_CODE_A)
            handler.removeMessages(MSG_WHAT_KEY_CODE_B)
            handler.removeMessages(MSG_WHAT_KEY_CODE_AB)
-            handler.removeMessages(MSG_WHAT_KEY_CODE_BL)
+            handler.removeMessages(MSG_WHAT_KEY_CODE_AL)
            handler.sendMessage(Message.obtain().also {
-                it.what =  MSG_WHAT_KEY_CODE_AB
-                it.obj = -2.0
+                it.what = MSG_WHAT_KEY_CODE_AB
+                it.obj = 1.0
            })
            linkedLog?.record(mapOf("发送[AB]:${System.currentTimeMillis()}" to "${whatToString(MSG_WHAT_KEY_CODE_AB)}"))
        }
--- a/core/function-impl/mogo-core-function-hmi/src/main/java/com/mogo/eagle/core/function/hmi/ui/widget/MogoVideoView.java
+++ b/core/function-impl/mogo-core-function-hmi/src/main/java/com/mogo/eagle/core/function/hmi/ui/widget/MogoVideoView.java
@@ -15,18 +15,17 @@ import com.bumptech.glide.load.engine.DiskCacheStrategy;
 import com.bumptech.glide.request.RequestOptions;
 import com.bumptech.glide.request.target.CustomTarget;
 import com.bumptech.glide.request.transition.Transition;
+import com.mogo.eagle.core.function.api.autopilot.IMoGoBackCameraVideoListener;
 import com.mogo.eagle.core.function.api.autopilot.IMoGoRoboBusJinlvM1StitchedVideoListener;
-import com.mogo.eagle.core.function.api.autopilot.IMoGoSweeperFutianBackCameraVideoListener;
+import com.mogo.eagle.core.function.call.autopilot.CallerBackCameraVideoListenerManager;
 import com.mogo.eagle.core.function.call.autopilot.CallerRoboBusJinlvM1StitchedVideoListenerManager;
-import com.mogo.eagle.core.function.call.autopilot.CallerSweeperFutianBackCameraVideoListenerManager;
 import com.mogo.eagle.core.utilcode.mogo.glide.GlideApp;
 import com.mogo.eagle.core.utilcode.util.ThreadUtils;

 /**
- * 清扫车摄像头展示View 10Hz
- * M1拼接视频展示View 10Hz  需要订阅（连接成功后订阅才生效）：CallerAutoPilotControlManager.setIsSubscribeM1StitchedVideo(isSubscribe)
+ * 图片帧展示View
 */
-public class MogoVideoView extends AppCompatImageView implements IMoGoSweeperFutianBackCameraVideoListener, IMoGoRoboBusJinlvM1StitchedVideoListener {
+public class MogoVideoView extends AppCompatImageView implements IMoGoBackCameraVideoListener, IMoGoRoboBusJinlvM1StitchedVideoListener {
    private static final String TAG = MogoVideoView.class.getSimpleName();
    private final RequestOptions requestOptions = new RequestOptions()
            .priority(Priority.HIGH)
@@ -49,14 +48,14 @@ public class MogoVideoView extends AppCompatImageView implements IMoGoSweeperFut
    @Override
    protected void onAttachedToWindow() {
        super.onAttachedToWindow();
-        CallerSweeperFutianBackCameraVideoListenerManager.INSTANCE.addListener(TAG, this);
+        CallerBackCameraVideoListenerManager.INSTANCE.addListener(TAG, this);
        CallerRoboBusJinlvM1StitchedVideoListenerManager.INSTANCE.addListener(TAG, this);
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();
-        CallerSweeperFutianBackCameraVideoListenerManager.INSTANCE.removeListener(this);
+        CallerBackCameraVideoListenerManager.INSTANCE.removeListener(this);
        CallerRoboBusJinlvM1StitchedVideoListenerManager.INSTANCE.removeListener(this);
    }

@@ -90,7 +89,7 @@ public class MogoVideoView extends AppCompatImageView implements IMoGoSweeperFut
    }

    @Override
-    public void onSweeperFutianBackCameraVideo(@NonNull byte[] data) {
+    public void onBackCameraVideo(@NonNull byte[] data) {
        draw(data);
    }

--- a/core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoAutopilotControlProvider.kt
+++ b/core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoAutopilotControlProvider.kt
@@ -8,10 +8,11 @@ import com.mogo.eagle.core.function.api.base.IMoGoFunctionServerProvider
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable.IsBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.GetTaskReq
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.StartTaskResp
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume.SuspendResumeTaskReq
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume.SuspendResumeTaskReq
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm.TaskConfirmResp
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop.StopTaskResp
 import com.zhjt.mogo.adas.data.AdasConstants
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.BigTaskActionResp

 /**
 * @author xiaoyuzhou
@@ -399,6 +400,16 @@ interface IMoGoAutopilotControlProvider : IMoGoFunctionServerProvider {
     */
    fun sendSweeperAutopilotBootable(reqNo: String, isBootable: IsBootable): Boolean

+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    fun sendSweeperCloudSuspendResumeTaskResp(reqNo: String, bigTaskActionResp: BigTaskActionResp): Boolean
+
    /**
     * 打开点云绘制
     *
@@ -412,6 +423,13 @@ interface IMoGoAutopilotControlProvider : IMoGoFunctionServerProvider {
     */
    fun setIsSubscribeM1StitchedVideo(isSubscribe: Boolean)

+    /**
+     * 后摄像头接口订阅 目前用于清扫车后摄像头接口和Taxi右后摄像头接口
+     * @param role 角色 详情参见{@link Constants.TERMINAL_ROLE}
+     * @param isSubscribe 是否订阅
+     */
+    fun setIsSubscribeBackCameraVideoVideo(role: Int,isSubscribe: Boolean)
+
    fun sendRoboBusJinlvM1FrontDoorCmd(switchCmd: Int): Boolean

    fun sendRoboBusJinlvM1AirConditionerCmd(
--- a/core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoBackCameraVideoListener.kt
+++ b/core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoBackCameraVideoListener.kt
@@ -0,0 +1,13 @@
+package com.mogo.eagle.core.function.api.autopilot
+
+/**
+ * 后摄像头视频数据
+ * 目前用于清扫车（福田）后摄像头和Taxi右后摄像头
+ * 需要进行接口订阅才能 CallerAutoPilotControlManager.setIsSubscribeBackCameraVideoVideo(role: Int, isSubscribe: Boolean)
+ */
+interface IMoGoBackCameraVideoListener {
+    /**
+     * 后摄像头视频数据 10Hz 每一帧为一张图片
+     */
+    fun onBackCameraVideo(data: ByteArray)
+}
--- a/core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoSweeperFutianBackCameraVideoListener.kt
+++ b/core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoSweeperFutianBackCameraVideoListener.kt
@@ -1,11 +0,0 @@
-package com.mogo.eagle.core.function.api.autopilot
-
-/**
- * 清扫车（福田）后摄像头视频数据
- */
-interface IMoGoSweeperFutianBackCameraVideoListener {
-    /**
-     * 清扫车（福田）后摄像头视频数据 10Hz 每一帧为一张图片
-     */
-    fun onSweeperFutianBackCameraVideo(data: ByteArray)
-}
--- a/core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoSweeperFutianCloudTaskListener.kt
+++ b/core/mogo-core-function-api/src/main/java/com/mogo/eagle/core/function/api/autopilot/IMoGoSweeperFutianCloudTaskListener.kt
@@ -3,12 +3,12 @@ package com.mogo.eagle.core.function.api.autopilot
 import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable.IsBootableResp
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume.SuspendResumeTaskResp
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus.BigTaskStatusPush
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.BigTaskActionPush
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm.TaskConfirm
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume.SuspendResumeTaskResp
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus.TaskStatusPush
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop.StopTaskReq
-import mogo.telematics.pad.MessagePad

 /**
 * 清扫车（福田）云端任务接口
@@ -87,6 +87,16 @@ interface IMoGoSweeperFutianCloudTaskListener {
     */
    fun onSweeperFutianCloudBigTaskStatus(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskStatusPush: BigTaskStatusPush?)

+    /**
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+     *
+     * @param messageType           消息类型
+     * @param reqNo                 请求编号
+     * @param sysTime               当前时间戳
+     * @param bigTaskActionPush 数据
+     */
+    fun onSweeperFutianCloudTaskCloudSuspendResume(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskActionPush: BigTaskActionPush?)
+
    /**
     * 清扫车云端任务未知类型
     *
--- a/core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerAutoPilotControlManager.kt
+++ b/core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerAutoPilotControlManager.kt
@@ -17,10 +17,11 @@ import com.mogo.eagle.core.utilcode.mogo.AppIdentityModeUtils
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable.IsBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.GetTaskReq
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask.StartTaskResp
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume.SuspendResumeTaskReq
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume.SuspendResumeTaskReq
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm.TaskConfirmResp
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop.StopTaskResp
 import com.zhjt.mogo.adas.data.AdasConstants
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume.BigTaskActionResp
 import com.zhjt.service.chain.ChainLog
 import com.zhjt.service_biz.BizConfig
 import kotlin.random.Random
@@ -550,6 +551,17 @@ object CallerAutoPilotControlManager {
        return providerApi?.sendSweeperAutopilotBootable(reqNo, isBootable) ?: false
    }

+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    fun sendSweeperCloudSuspendResumeTaskResp( reqNo: String,   bigTaskActionResp: BigTaskActionResp): Boolean {
+        return providerApi?.sendSweeperCloudSuspendResumeTaskResp(reqNo, bigTaskActionResp) ?: false
+    }

    /**
     * 打开点云绘制
@@ -566,6 +578,15 @@ object CallerAutoPilotControlManager {
        providerApi?.setIsSubscribeM1StitchedVideo(isSubscribe)
    }

+    /**
+     * 后摄像头接口订阅 目前用于清扫车后摄像头接口和Taxi右后摄像头接口
+     * @param role 角色 详情参见{@link Constants.TERMINAL_ROLE}
+     * @param isSubscribe 是否订阅
+     */
+    fun setIsSubscribeBackCameraVideoVideo(role: Int, isSubscribe: Boolean) {
+        providerApi?.setIsSubscribeBackCameraVideoVideo(role, isSubscribe)
+    }
+
    fun sendRoboBusJinlvM1FrontDoorCmd(switchCmd: Int): Boolean {
        return providerApi?.sendRoboBusJinlvM1FrontDoorCmd(switchCmd) ?: false
    }
--- a/core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerBackCameraVideoListenerManager.kt
+++ b/core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerBackCameraVideoListenerManager.kt
@@ -0,0 +1,20 @@
+package com.mogo.eagle.core.function.call.autopilot
+
+import com.mogo.eagle.core.function.api.autopilot.IMoGoBackCameraVideoListener
+import com.mogo.eagle.core.function.call.base.CallerBase
+
+/**
+ * 后摄像头视频数据
+ */
+object CallerBackCameraVideoListenerManager : CallerBase<IMoGoBackCameraVideoListener>() {
+
+    /**
+     * 后摄像头视频数据
+     */
+    fun invokeBackCameraVideo(data: ByteArray) {
+        M_LISTENERS.forEach {
+            val listener = it.value
+            listener.onBackCameraVideo(data)
+        }
+    }
+}
--- a/core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerSweeperFutianBackCameraVideoListenerManager.kt
+++ b/core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerSweeperFutianBackCameraVideoListenerManager.kt
@@ -1,20 +0,0 @@
-package com.mogo.eagle.core.function.call.autopilot
-
-import com.mogo.eagle.core.function.api.autopilot.IMoGoSweeperFutianBackCameraVideoListener
-import com.mogo.eagle.core.function.call.base.CallerBase
-
-/**
- * 清扫车（福田）后摄像头视频数据
- */
-object CallerSweeperFutianBackCameraVideoListenerManager : CallerBase<IMoGoSweeperFutianBackCameraVideoListener>() {
-
-    /**
-     * 后摄像头视频数据
-     */
-    fun invokeSweeperFutianBackCameraVideo(data: ByteArray) {
-        M_LISTENERS.forEach {
-            val listener = it.value
-            listener.onSweeperFutianBackCameraVideo(data)
-        }
-    }
-}
--- a/core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerSweeperFutianCloudTaskListenerManager.kt
+++ b/core/mogo-core-function-call/src/main/java/com/mogo/eagle/core/function/call/autopilot/CallerSweeperFutianCloudTaskListenerManager.kt
@@ -5,8 +5,9 @@ import com.mogo.eagle.core.function.call.base.CallerBase
 import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop
@@ -123,6 +124,21 @@ object CallerSweeperFutianCloudTaskListenerManager : CallerBase<IMoGoSweeperFuti
        }
    }

+    /**
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+     *
+     * @param messageType       消息类型
+     * @param reqNo             请求编号
+     * @param sysTime           当前时间戳
+     * @param bigTaskActionPush 数据
+     */
+    fun invokeSweeperFutianCloudTaskCloudSuspendResume(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskActionPush: SweeperTaskCloudSuspendResume.BigTaskActionPush?) {
+        M_LISTENERS.forEach {
+            val listener = it.value
+            listener.onSweeperFutianCloudTaskCloudSuspendResume(messageType, reqNo, sysTime, bigTaskActionPush)
+        }
+    }
+
    /**
     * 清扫车云端任务未知类型
     *
--- a/gradle.properties
+++ b/gradle.properties
@@ -171,6 +171,6 @@ CHARTER_DRIVER_VERSION=3.3.2
 # 包车模式乘客端端版本号
 CHARTER_PASSENGER_VERSION=2.3.2
 # 支持云控清扫车模式司机端版本号
-SWEEPERCLOUD_DRIVER_VERSION=3.1.4
+SWEEPERCLOUD_DRIVER_VERSION=3.2.0
 # 清扫车模式司机端版本号
 SWEEPEROPERATE_DRIVER_VERSION=3.1.0
--- a/libraries/mogo-adas-data/src/main/proto/special_vehicle_task_cmd.proto
+++ b/libraries/mogo-adas-data/src/main/proto/special_vehicle_task_cmd.proto
@@ -14,6 +14,9 @@ message RoboSweeperFuTianCleanCmd {
    optional uint32 sweepdisk_speed_requirement = 8 [default = 0]; // 扫盘加速需求 0--no req, 1--decelerate req, 2--accelerate req（扫盘加速需求，每点一次为加速一次，每次加速为5%pwm）
    optional uint32 sweepdisk_desire_speed_requirement = 9 [default = 0]; // 扫盘期望转速, 0-100%  必须是5的倍数
    optional uint32 one_touch_take_out_trash_requirement = 10 [default = 0]; // 一键倒垃圾请求，0：no req; 1: take out; 2: stop take out
+    optional uint32 clean_tail_door_requirement = 11 [default = 0]; // 垃圾尾门开关请求，0--no req; 1-- open; 2:--stop take out
+    optional uint32 clean_tail_tip_requirement = 12 [default = 0]; // 垃圾箱举升请求，0--no req;  1 -- tail ret,2-- tail tip
+    optional uint32 clean_work_Enc_des_requirement = 13 [default = 0]; // 垃圾箱清淤请求，0--no req; 1:--open; 2--close
 }

 message RoboSweeperFuTianTaskCmd {
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/README.md
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/README.md
@@ -12,6 +12,7 @@
 |7、pad主动拉取当前车辆正在执行任务的完整信息（type：100007）|sweeper/sweeper_task.proto|
 |8、接管后回自驾-pad上报状态给云端 云端下发启动自驾（type: 100008）|sweeper/sweeper_bootable.proto|
 |9、云端下发pad大任务状态（type: 100009）|sweeper/sweeper_big_task_status.proto|
+|10、云端下发任务暂停/恢复指令到pad（type: 100010）|sweeper/sweeper_task_cloud_suspend_resume.proto|

 # 接口使用说明
 ## 回调接口类：IMoGoSweeperFutianCloudTaskListener
@@ -181,4 +182,28 @@ fun onSweeperFutianCloudBigTaskStatus(messageType: SweeperCloudTask.MessageType,
    
 客户端回复：
 无
+~~~
+
+~~~
+服务端发：
+/**
+ * 10、云端下发任务暂停/恢复指令到pad（type: 100010）
+ *
+ * @param messageType           消息类型
+ * @param reqNo                 请求编号
+ * @param sysTime               当前时间戳
+ * @param bigTaskActionPush 数据
+ */
+fun onSweeperFutianCloudTaskCloudSuspendResume(messageType: SweeperCloudTask.MessageType, reqNo: String?, sysTime: Long, bigTaskActionPush: BigTaskActionPush?)
+
+客户端回复:
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+CallerAutoPilotControlManager.INSTANCE.sendSweeperSuspendResumeTaskReq(）
 ~~~
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_big_task_status.proto
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_big_task_status.proto
@@ -1,25 +1,19 @@
 syntax = "proto3";
 package com.zhjt.mogo.adas.data.sweeper.task.big;

+import "sweeper/sweeper_common.proto";

 /**** 9、云端下发pad大任务状态（type: 100009） ****/

 //9.1、请求信息
 // 任务状态
-enum BigTaskStatus {
-  DEFAULT_STATUS = 0; // 无效值
-  TO_START = 1; //待开始
-  RUNNING = 2; // 运行中
-  CANCLE = 3; // 取消
-  FINISHED = 4; // 结束
-  ABNORMAL = 5; // 异常
-}

 message BigTaskStatusPush {
  string sn = 1;// sn
  string taskId = 2;// 大任务编号
-  BigTaskStatus TaskStatus = 3;// 大任务状态
+  common.TaskStatus TaskStatus = 3;// 大任务状态
  uint64 systemTime = 4; // 时间戳
+  bool isPop = 5; // 是否弹窗(0725新增)
 }

 //4.2、响应信息
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_cloud_task.proto
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_cloud_task.proto
@@ -16,6 +16,7 @@ enum MessageType
  PadSendGetTaskReq = 100007; //7、pad主动拉取当前车辆正在执行任务的完整信息（type：100007）-> sweeper_task.proto
  PadSendBootable = 100008; //8、接管后回自驾-pad上报状态给云端 云端下发启动自驾（type: 100008）-> sweeper_bootable.proto
  CloudPushBigTaskStatus = 100009; //9、云端下发pad大任务状态（type: 100009）-> sweeper_big_task_status.proto
+  CloudPushTaskSuspendResume = 100010; //10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
 }

 //云下行消息
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_common.proto
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_common.proto
@@ -7,9 +7,10 @@ enum TaskStatus
  DEFAULT_STATUS = 0; // 无效值
  TO_START = 1; //待开始
  RUNNING = 2; // 运行中
-  SUSPENDED = 3; // 暂停
-  FINISHED = 4; // 结束
-  ABNORMAL = 5; // *异常
+  CANCEL = 3; // 取消（提前结束）
+  FINISHED = 4; // 正常结束
+  ABNORMAL = 5; // 异常结束
+  SUSPENDED = 6; // 暂停 (新增)
 }

 // 响应状态
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task.proto
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task.proto
@@ -55,16 +55,17 @@ message TaskInfo {
  uint64 currentTime = 6; //当前时间戳
  repeated SubTaskInfo subList = 7; // 子任务列表信息
  bool isPop = 8; // 是否弹窗
+  common.TaskStatus taskStatus = 9; //  大任务状态（新增）
 }

 //1.2、响应信息
 // 响应状态
 enum StartTaskCode {
  DEFAULT_CODE = 0; // 无效值
-  MANUAL_CONFIRM = 1; // 安全员确认执行任务-pad
-  MANUAL_REFUSE = 2; // 安全员拒绝任务-pad
+  MANUAL_CONFIRM = 1; // 安全员确认执行任务-pad（无效值）
+  MANUAL_REFUSE = 2; // 安全员拒绝任务-pad（无效值）
  RECEIVED = 3; // 收到任务
-  OVER_TIME = 4; // 超时未确认
+  OVER_TIME = 4; // 超时未确认（无效值）
 }

 /**
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_cloud_suspend_resume.proto
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_cloud_suspend_resume.proto
@@ -0,0 +1,40 @@
+syntax = "proto3";
+package com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r;
+
+
+/**** 10、云端下发任务暂停/恢复指令到pad（type: 100010） ****/
+
+//10.1、请求信息
+
+// 指令类型
+enum ActionType {
+  DEFAULT_TYPE = 0; // 无效值
+  SUSPENDED = 1; // 暂停
+  RESUME = 2; //恢复
+}
+
+message BigTaskActionPush {
+  string sn = 1;// sn
+  string taskId = 2;// 大任务编号
+  ActionType action = 3;// 指令类型
+  uint64 systemTime = 4; // 时间戳
+  bool isPop = 5; // 是否弹窗
+}
+
+
+//10.2、响应信息
+
+// 响应状态
+enum Code {
+  DEFAULT_CODE = 0; // 无效值
+  RECEIVED = 1; // 收到指令
+}
+
+/**
+开始大任务响应
+*/
+message BigTaskActionResp {
+  string sn = 1;// sn
+  string taskId = 2;// 大任务编号
+  Code code = 3; //响应状态
+}
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_confirm.proto
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_confirm.proto
@@ -19,10 +19,11 @@ message TaskConfirm {
 // 响应状态
 enum TaskConfirmCode {
  DEFAULT_CODE = 0; // 无效值
-  MANUAL_CONFIRM = 1; // 安全员确认执行任务-pad
-  MANUAL_REFUSE_ALL = 2; // 安全员拒绝全部任务-pad
-  MANUAL_REFUSE_SINGLE = 3; // 安全员拒绝单个子任务-pad
-  OVER_TIME = 4; // 超时未确认
+  MANUAL_CONFIRM = 1; // 安全员确认执行任务-pad（无效值）
+  MANUAL_REFUSE_ALL = 2; // 安全员拒绝全部任务-pad（无效值）
+  MANUAL_REFUSE_SINGLE = 3; // 安全员拒绝单个子任务-pad（无效值）
+  OVER_TIME = 4; // 超时未确认（无效值）
+  RECEIVED = 5; // 收到子任务（新增）
 }

 /**
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_stop.proto
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_stop.proto
@@ -8,9 +8,10 @@ package com.zhjt.mogo.adas.data.sweeper.task.stop;
 // 任务状态
 enum StopTaskType {
  DEFAULT_TYPE = 0; // 无效值
-  TIMEOUT = 1; //超时结束
+  TIMEOUT = 1; //超时结束（无效值）
  ADVANCE = 2; // 提前结束
  NORMAL = 3; // 正常结束
+  EXCEPTION = 4; // 异常结束（新增）
 }


@@ -29,9 +30,10 @@ message StopTaskReq {
 // 响应状态
 enum StopTaskCode {
  DEFAULT_CODE = 0; // 无效值
-  MANUAL_CONFIRM = 1; // 安全员确认
-  MANUAL_REFUSE = 2; // 安全员拒绝
-  OVER_TIME = 3; // 超时未确认
+  MANUAL_CONFIRM = 1; // 安全员确认（无效值）
+  MANUAL_REFUSE = 2; // 安全员拒绝（无效值）
+  OVER_TIME = 3; // 超时未确认（无效值）
+  RECEIVED = 4; // 收到结束指令（新增）
 }

 /**
--- a/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_suspend_resume.proto
+++ b/libraries/mogo-adas-data/src/main/proto/sweeper/sweeper_task_suspend_resume.proto
@@ -1,5 +1,5 @@
 syntax = "proto3";
-package com.zhjt.mogo.adas.data.sweeper.task;
+package com.zhjt.mogo.adas.data.sweeper.task.s_r;

 import "sweeper/sweeper_common.proto";

--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/AdasChannel.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/AdasChannel.java
@@ -5,7 +5,6 @@ import static com.zhidao.support.adas.high.chain.AdasChain.CHAIN_CODE_ADAS_INIT;
 import static com.zhidao.support.adas.high.chain.AdasChain.CHAIN_CODE_ADAS_SEND_GLOBAL_PATH;
 import static com.zhidao.support.adas.high.chain.AdasChain.CHAIN_CODE_ADAS_SEND_SYSTEM_CMD;
 import static com.zhidao.support.adas.high.chain.AdasChain.CHAIN_CODE_ADAS_SEND_TRAJECTORY_DOWNLOAD;
-import static com.zhidao.support.adas.high.chain.AdasChain.CHAIN_CODE_ADAS_START_AUTOPILOT;
 import static com.zhidao.support.adas.high.chain.AdasChain.CHAIN_CODE_CONNECT_ADDRESS;
 import static com.zhidao.support.adas.high.chain.AdasChain.CHAIN_CODE_STATUS_CHANGE_REASON;
 import static com.zhidao.support.adas.high.chain.AdasChain.CHAIN_SOURCE_ADAS;
@@ -16,13 +15,11 @@ import android.os.Handler;
 import android.os.Message;
 import android.os.SystemClock;
 import android.text.TextUtils;
-import android.util.Log;

 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;

 import com.google.protobuf.InvalidProtocolBufferException;
-import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhidao.support.adas.high.bean.VersionCompatibility;
 import com.zhidao.support.adas.high.common.AutopilotReview;
 import com.zhidao.support.adas.high.common.ByteUtil;
@@ -47,12 +44,14 @@ import com.zhidao.support.adas.high.subscribe.SubscribeInterface;
 import com.zhidao.support.adas.high.subscribe.SubscribeInterfaceOptions;
 import com.zhidao.support.adas.high.thread.DispatchHandler;
 import com.zhjt.mogo.adas.data.AdasConstants;
+import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhjt.mogo.adas.data.bean.AutopilotStatistics;
 import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
 import com.zhjt.service.chain.ChainLog;

@@ -68,8 +67,8 @@ import java.util.concurrent.atomic.AtomicInteger;
 import bag_manager.BagManagerOuterClass;
 import chassis.SpecialVehicleTaskCmdOuterClass;
 import common.HeaderOuterClass;
-import mogo.telematics.ParamSetCmdOuterClass;
 import function_state_management.FSMStatusReasonQueryOuterClass;
+import mogo.telematics.ParamSetCmdOuterClass;
 import mogo.telematics.pad.MessagePad;
 import okio.ByteString;

@@ -1748,6 +1747,7 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
        ParamSetCmdOuterClass.ParamSetCmd req = builder.build();
        return sendPBMessage(MessageType.TYPE_SEND_SET_PARAM_REQ_V2.typeCode, req.toByteArray());
    }
+
    /**
     * FSM状态原因查询
     * 当FSMFunctionStates的类型是XXX_DRIVING_OFF时查询OFF的原因
@@ -1866,5 +1866,18 @@ public class AdasChannel implements IAdasNetCommApi, FpgaSocket.IWebSocketConnec
    public boolean sendSweeperAutopilotBootable(@NonNull String reqNo, @NonNull SweeperBootable.IsBootable isBootable) {
        return sendSweeperCloudTaskCmd(SweeperCloudTask.MessageType.PadSendBootable, reqNo, isBootable.toByteString());
    }
+
+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    @Override
+    public boolean sendSweeperCloudSuspendResumeTaskResp(@NonNull String reqNo, @NonNull SweeperTaskCloudSuspendResume.BigTaskActionResp bigTaskActionResp) {
+        return sendSweeperCloudTaskCmd(SweeperCloudTask.MessageType.CloudPushTaskSuspendResume, reqNo, bigTaskActionResp.toByteString());
+    }
 }

--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/AdasManager.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/AdasManager.java
@@ -5,7 +5,6 @@ import android.text.TextUtils;

 import androidx.annotation.NonNull;

-import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhidao.support.adas.high.bean.VersionCompatibility;
 import com.zhidao.support.adas.high.common.AppPreferenceHelper;
 import com.zhidao.support.adas.high.common.Constants;
@@ -13,12 +12,14 @@ import com.zhidao.support.adas.high.common.CupidLogUtils;
 import com.zhidao.support.adas.high.common.Define;
 import com.zhidao.support.adas.high.common.MessageType;
 import com.zhidao.support.adas.high.common.ReceiveTimeoutManager;
+import com.zhjt.mogo.adas.data.AdasConstants;
+import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
-import com.zhjt.mogo.adas.data.AdasConstants;

 import java.util.HashSet;
 import java.util.List;
@@ -929,7 +930,7 @@ public class AdasManager implements IAdasNetCommApi {
     * 参数获取请求
     * 结果回调{@link OnAdasListener#onGetParamResp(MessagePad.Header, MessagePad.SetParamReq, AdasParam)}
     *
-     * @param paramType  参数类型:libraries/mogo-adas-data/src/main/proto/personal/adas_constants.proto
+     * @param paramType 参数类型:libraries/mogo-adas-data/src/main/proto/personal/adas_constants.proto
     * @return boolean
     */
    @Override
@@ -1081,6 +1082,19 @@ public class AdasManager implements IAdasNetCommApi {
        return mChannel != null && mChannel.sendSweeperAutopilotBootable(reqNo, isBootable);
    }

+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    @Override
+    public boolean sendSweeperCloudSuspendResumeTaskResp(@NonNull String reqNo, @NonNull SweeperTaskCloudSuspendResume.BigTaskActionResp bigTaskActionResp) {
+        return mChannel != null && mChannel.sendSweeperCloudSuspendResumeTaskResp(reqNo, bigTaskActionResp);
+    }
+
    /**
     * 获取工控机固定IP列表
     *
--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/IAdasNetCommApi.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/IAdasNetCommApi.java
@@ -6,12 +6,13 @@ import com.zhidao.support.adas.high.bean.VersionCompatibility;
 import com.zhidao.support.adas.high.common.Constants;
 import com.zhidao.support.adas.high.common.Define;
 import com.zhidao.support.adas.high.common.MessageType;
+import com.zhjt.mogo.adas.data.AdasConstants;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;
-import com.zhjt.mogo.adas.data.AdasConstants;

 import java.util.List;
 import java.util.Set;
@@ -572,7 +573,7 @@ public interface IAdasNetCommApi {
    /**
     * 参数获取请求
     *
-     * @param paramType  参数类型:libraries/mogo-adas-data/src/main/proto/personal/adas_constants.proto
+     * @param paramType 参数类型:libraries/mogo-adas-data/src/main/proto/personal/adas_constants.proto
     * @return boolean
     */
    boolean sendGetParamReq(AdasConstants.MapSystemParamType paramType);
@@ -690,6 +691,16 @@ public interface IAdasNetCommApi {
     */
    boolean sendSweeperAutopilotBootable(@NonNull String reqNo, @NonNull SweeperBootable.IsBootable isBootable);

+    /**
+     * pad收到云端下发暂停恢复响应
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）sweeper_task_cloud_suspend_resume.proto/BigTaskActionResp
+     *
+     * @param reqNo             请求编号
+     * @param bigTaskActionResp 参数
+     * @return boolean
+     */
+    boolean sendSweeperCloudSuspendResumeTaskResp(@NonNull String reqNo, @NonNull SweeperTaskCloudSuspendResume.BigTaskActionResp bigTaskActionResp);
+
    // TODO 需求暂停 待讨论
 //    boolean getRoutes();

--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/OnAdasListener.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/OnAdasListener.java
@@ -4,18 +4,18 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;

 import com.mogo.support.obu.ObuScene;
-import com.zhjt.mogo.adas.data.AdasConstants;
 import com.zhidao.support.adas.high.common.MessageType;
 import com.zhidao.support.adas.high.common.ProtocolStatus;
+import com.zhjt.mogo.adas.data.AdasConstants;
 import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhjt.mogo.adas.data.bean.AutopilotStatistics;
-
 import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.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;

@@ -261,7 +261,8 @@ public interface OnAdasListener {
 //    void onFSMStatusReasonRespond(@NonNull MessagePad.Header header, @NonNull FSMStatusReasonQueryOuterClass.FSMStatusReasonRespond respond);

    /**
-     * 清扫车后部摄像头视频 10Hz
+     * 后部摄像头视频 10Hz
+     * 目前用于清扫车后摄像头和Taxi右右后摄像头
     *
     * @param header 头
     * @param data   数据
@@ -355,6 +356,17 @@ public interface OnAdasListener {
     */
    void onSweeperFutianCloudBigTaskStatus(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperBigTaskStatus.BigTaskStatusPush bigTaskStatusPush);

+    /**
+     * 10、云端下发任务暂停/恢复指令到pad（type: 100010）-> sweeper_task_cloud_suspend_resume.proto
+     *
+     * @param header            头
+     * @param messageType       消息类型
+     * @param reqNo             请求编号
+     * @param sysTime           当前时间戳
+     * @param bigTaskActionPush 数据
+     */
+    void onSweeperFutianCloudTaskCloudSuspendResume(@NonNull MessagePad.Header header, @NonNull SweeperCloudTask.MessageType messageType, @Nullable String reqNo, long sysTime, @Nullable SweeperTaskCloudSuspendResume.BigTaskActionPush bigTaskActionPush);
+
    /**
     * 清扫车云端任务未知类型
     *
--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/MessageType.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/common/MessageType.java
@@ -28,7 +28,7 @@ public enum MessageType {
    TYPE_RECEIVE_PLANNING_OBJECTS(MessagePad.MessageType.MsgTypePlanningObjects, "Planning障碍物"),
    TYPE_RECEIVE_CHASSIS_STATES(MessagePad.MessageType.MsgTypeChassisStates, "底盘状态"),
    TYPE_RECEIVE_FUNCTION_STATES(MessagePad.MessageType.MsgTypeFunctionStates, "重构后功能状态"),
-    TYPE_RECEIVE_BACK_CAMERA_VIDEO(MessagePad.MessageType.MsgTypeBackCameraVideo, "清扫车后摄像头"),
+    TYPE_RECEIVE_BACK_CAMERA_VIDEO(MessagePad.MessageType.MsgTypeBackCameraVideo, "后摄像头"),
    TYPE_RECEIVE_M1_STITCHED_VIDEO(MessagePad.MessageType.MsgTypeM1StitchedVideo, "M1拼接视频"),

    TYPE_RECEIVE_BASIC_INFO_REQ(MessagePad.MessageType.MsgTypeBasicInfoReq, "自动驾驶设备基础信息请求"),
--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/BackCameraVideoMessage.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/BackCameraVideoMessage.java
@@ -9,7 +9,8 @@ import com.zhidao.support.adas.high.common.CupidLogUtils;
 import com.zhidao.support.adas.high.protocol.RawData;

 /**
- * 清扫车后摄像头 10Hz
+ * 清扫车和Taxi后摄像头
+ * 需要主动订阅，否则工控机不会发送此数据
 */
 public class BackCameraVideoMessage extends MyAbstractMessageHandler {

@@ -21,13 +22,13 @@ public class BackCameraVideoMessage extends MyAbstractMessageHandler {
        int len = raw.getPackageLengthValue() - raw.getOffsetValue();
        byte[] data = new byte[len];
        System.arraycopy(raw.originalData.toByteArray(), raw.getOffsetValue(), data, 0, len);
-        AdasChannel.calculateTimeConsumingOnDispatchRaw("清扫车后摄像头", raw.receiveTime);
+        AdasChannel.calculateTimeConsumingOnDispatchRaw("后摄像头", raw.receiveTime);
        long nowTime = 0;
        if (CupidLogUtils.isEnableLog())
            nowTime = SystemClock.elapsedRealtime();
        if (adasListener != null) {
            adasListener.onBackCameraVideo(raw.getHeader(), data);
        }
-        AdasChannel.calculateTimeConsumingBusiness("清扫车后摄像头", nowTime);
+        AdasChannel.calculateTimeConsumingBusiness("后摄像头", nowTime);
    }
 }
--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/M1StitchedVideoMessage.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/M1StitchedVideoMessage.java
@@ -10,6 +10,7 @@ import com.zhidao.support.adas.high.protocol.RawData;

 /**
 * M1拼接视频 10Hz
+ * 需要主动订阅，否则工控机不会发送此数据
 */
 public class M1StitchedVideoMessage extends MyAbstractMessageHandler {

--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/SweeperCloudTaskMessage.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/msg/SweeperCloudTaskMessage.java
@@ -1,11 +1,9 @@
 package com.zhidao.support.adas.high.msg;

 import android.os.SystemClock;
-import android.util.Log;

 import com.google.protobuf.ByteString;
 import com.google.protobuf.InvalidProtocolBufferException;
-import com.google.protobuf.TextFormat;
 import com.zhidao.support.adas.high.AdasChannel;
 import com.zhidao.support.adas.high.OnAdasListener;
 import com.zhidao.support.adas.high.common.ByteUtil;
@@ -14,9 +12,10 @@ import com.zhidao.support.adas.high.protocol.RawData;
 import com.zhjt.mogo.adas.data.sweeper.SweeperCloudTask;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
-import com.zhjt.mogo.adas.data.sweeper.task.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.big.SweeperBigTaskStatus;
+import com.zhjt.mogo.adas.data.sweeper.task.cloud.s_r.SweeperTaskCloudSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.confirm.SweeperTaskConfirm;
+import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume;
 import com.zhjt.mogo.adas.data.sweeper.task.status.SweeperTaskStatus;
 import com.zhjt.mogo.adas.data.sweeper.task.stop.SweeperTaskStop;

@@ -44,7 +43,7 @@ public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
            String reqNo = message.getReqNo(); //请求编号，响应请求时，使用请求方的请求编号
            long sysTime = message.getSysTime(); //当前时间戳
            ByteString payload = message.getPayload();
-            Log.i("SweeperCloudTaskMessage", "MsgType=" + (msgType == null ? "null" : msgType.getNumber()) + " reqNo=" + reqNo + " sysTime=" + sysTime);
+            CupidLogUtils.i("SweeperCloudTaskMessage", "MsgType=" + (msgType == null ? "null" : msgType.getNumber()) + " reqNo=" + reqNo + " sysTime=" + sysTime);
            boolean isExistPayload = payload != null && !payload.isEmpty();
            if (msgType == SweeperCloudTask.MessageType.CloudPushTask || msgType == SweeperCloudTask.MessageType.PadSendGetTaskReq) {
                //1、云端下发大任务信息（type: 100001）-> sweeper_task.proto
@@ -53,8 +52,8 @@ public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
                if (isExistPayload) {
                    taskInfo = SweeperTask.TaskInfo.parseFrom(payload);
                }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskInfo == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(taskInfo)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskInfo == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(taskInfo)));
                adasListener.onSweeperFutianCloudTask(header, msgType, reqNo, sysTime, taskInfo);
            } else if (msgType == SweeperCloudTask.MessageType.CloudPushTaskConfirm) {
                //2、云端下发子任务，请求pad确认（type：100002）-> sweeper_task_confirm.proto
@@ -62,8 +61,8 @@ public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
                if (isExistPayload) {
                    taskConfirm = SweeperTaskConfirm.TaskConfirm.parseFrom(payload);
                }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskConfirm == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(taskConfirm)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskConfirm == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(taskConfirm)));
                adasListener.onSweeperFutianCloudTaskConfirm(header, msgType, reqNo, sysTime, taskConfirm);
            } else if (msgType == SweeperCloudTask.MessageType.CloudPushTaskStatus) {
                //3、云端下发任务状态到pad（type：100003）-> sweeper_task_status.proto
@@ -71,8 +70,8 @@ public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
                if (isExistPayload) {
                    taskStatusPush = SweeperTaskStatus.TaskStatusPush.parseFrom(payload);
                }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskStatusPush == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(taskStatusPush)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (taskStatusPush == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(taskStatusPush)));
                adasListener.onSweeperFutianCloudTaskStatus(header, msgType, reqNo, sysTime, taskStatusPush);
            } else if (msgType == SweeperCloudTask.MessageType.CloudPushTaskStop) {
                //4、云端请求pad结束任务（type：100004）-> sweeper_task_stop.proto
@@ -80,8 +79,8 @@ public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
                if (isExistPayload) {
                    stopTaskReq = SweeperTaskStop.StopTaskReq.parseFrom(payload);
                }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (stopTaskReq == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(stopTaskReq)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (stopTaskReq == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(stopTaskReq)));
                adasListener.onSweeperFutianCloudTaskStop(header, msgType, reqNo, sysTime, stopTaskReq);
            } else if (msgType == SweeperCloudTask.MessageType.PadSendTaskSuspend || msgType == SweeperCloudTask.MessageType.PadSendTaskResume) {
                //5、pad请求挂起任务（type：100005）-> sweeper_task_suspend_resume.proto
@@ -90,8 +89,8 @@ public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
                if (isExistPayload) {
                    suspendResumeTaskResp = SweeperTaskSuspendResume.SuspendResumeTaskResp.parseFrom(payload);
                }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (suspendResumeTaskResp == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(suspendResumeTaskResp)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (suspendResumeTaskResp == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(suspendResumeTaskResp)));
                adasListener.onSweeperFutianCloudTaskSuspendResume(header, msgType, reqNo, sysTime, suspendResumeTaskResp);
            } else if (msgType == SweeperCloudTask.MessageType.PadSendBootable) {
                //8、接管后回自驾-pad上报状态给云端 云端下发启动自驾（type: 100008）-> sweeper_autopilot.proto
@@ -99,8 +98,8 @@ public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
                if (isExistPayload) {
                    isBootableResp = SweeperBootable.IsBootableResp.parseFrom(payload);
                }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (isBootableResp == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(isBootableResp)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (isBootableResp == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(isBootableResp)));
                adasListener.onSweeperFutianCloudBootable(header, msgType, reqNo, sysTime, isBootableResp);
            } else if (msgType == SweeperCloudTask.MessageType.CloudPushBigTaskStatus) {
                //9、云端下发pad大任务状态（type: 100009）-> sweeper_big_task_status.proto
@@ -108,12 +107,21 @@ public class SweeperCloudTaskMessage extends MyAbstractMessageHandler {
                if (isExistPayload) {
                    bigTaskStatusPush = SweeperBigTaskStatus.BigTaskStatusPush.parseFrom(payload);
                }
-                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (bigTaskStatusPush == null ? "null" :
-                        TextFormat.printer().escapingNonAscii(false).printToString(bigTaskStatusPush)));
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (bigTaskStatusPush == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(bigTaskStatusPush)));
                adasListener.onSweeperFutianCloudBigTaskStatus(header, msgType, reqNo, sysTime, bigTaskStatusPush);
+            } else if (msgType == SweeperCloudTask.MessageType.CloudPushTaskSuspendResume) {
+                //10、云端下发任务暂停/恢复指令到pad（type: 100010）
+                SweeperTaskCloudSuspendResume.BigTaskActionPush bigTaskActionPush = null;
+                if (isExistPayload) {
+                    bigTaskActionPush = SweeperTaskCloudSuspendResume.BigTaskActionPush.parseFrom(payload);
+                }
+//                Log.i("SweeperCloudTaskMessage", " msgType=" + msgType + " " + (bigTaskActionPush == null ? "null" :
+//                        TextFormat.printer().escapingNonAscii(false).printToString(bigTaskActionPush)));
+                adasListener.onSweeperFutianCloudTaskCloudSuspendResume(header, msgType, reqNo, sysTime, bigTaskActionPush);
            } else {
                //未知数据类型
-                Log.i("SweeperCloudTaskMessage", " 错误数据=" + ByteUtil.byteArrToHex(bytes));
+                CupidLogUtils.i("SweeperCloudTaskMessage", " 错误数据=" + ByteUtil.byteArrToHex(bytes));
                adasListener.onSweeperFutianCloudTaskUnknown(header, bytes);
            }
        }
--- a/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/subscribe/SubscribeInterface.java
+++ b/libraries/mogo-adas/src/main/java/com/zhidao/support/adas/high/subscribe/SubscribeInterface.java
@@ -139,8 +139,8 @@ public class SubscribeInterface {
        if (types.length > 0) {
            for (MessageType messageType : types) {
                if (messageType.name().toLowerCase().contains("type_receive")) {
-                    //连接成功后只有M1拼接视频接收接口默认不进行订阅，其他接收接口默认自动订阅
-                    if (messageType == MessageType.TYPE_RECEIVE_M1_STITCHED_VIDEO) {
+                    //连接成功后只有M1拼接视频接收接口和后摄像头接口默认不进行订阅，其他接收接口默认自动订阅
+                    if (messageType == MessageType.TYPE_RECEIVE_M1_STITCHED_VIDEO || messageType == MessageType.TYPE_RECEIVE_BACK_CAMERA_VIDEO) {
                        unsubscribedInterface.put(messageType, messageType.typeCode.getNumber());
                    } else {
                        subscribedInterface.put(messageType, messageType.typeCode.getNumber());