[660][adas][data-center] 添加节点检测功能，节点状态接口，移除节点超时接口

OCH/common/common/src/main/java/com/mogo/och/common/module/manager/autopilot/autopilot/IOchAutopilotStatusListener.java

@@ -64,14 +64,6 @@ public interface IOchAutopilotStatusListener {
     default void onAutopilotIpcConnectStatusChanged(AdasConstants.IpcConnectionStatus status, String reason) {
     }
 
-    /**
-     * 域控SSM接口接收超时
-     * 状态变动时才会回调，默认SSM状态正常
-     *
-     * @param isTimeout true：SSM接口接收超时  false：SSM接口恢复正常
-     */
-    default void onSsmReceiveTimeout(boolean isTimeout) {
-    }
 
     /**
      * 工控机主动查询 AdasManager#sendStatusQueryReq()，后会收到如下回调

OCH/common/common/src/main/java/com/mogo/och/common/module/manager/autopilot/autopilot/OchAutoPilotStatusListenerManager.kt

@@ -148,14 +148,6 @@ object OchAutoPilotStatusListenerManager : CallerBase<IOchAutopilotStatusListene
         }
     }
 
-    override fun onSsmReceiveTimeout(isTimeout: Boolean) {
-        super.onSsmReceiveTimeout(isTimeout)
-        M_LISTENERS.forEach {
-            val listener = it.value
-            listener.onSsmReceiveTimeout(isTimeout)
-        }
-    }
-
     override fun onAutopilotStatusRespByQuery(status: SystemStatusInfo.StatusInfo) {
         super.onAutopilotStatusRespByQuery(status)
         M_LISTENERS.forEach {

OCH/sweeper/driver/src/main/java/com/mogo/och/sweeper/cloud/model/SweeperCloudTaskModel.java

@@ -783,18 +783,8 @@ public class SweeperCloudTaskModel implements IMoGoSweeperFutianCloudTaskListene
 
     }
 
-    @Override
-    public void onSsmReceiveTimeout(boolean isTimeout) {
-
-    }
-
     @Override
     public void onAutopilotTrajectoryDownloadReq(@NonNull AutopilotControlParameters.AutoPilotLine autoPilotLine, int downloadType) {
 
     }
-
-    @Override
-    public void onFsmReceiveTimeout(boolean isTimeout) {
-
-    }
 }

OCH/sweeper/driver/src/main/java/com/mogo/och/sweeper/operate/presenter/SweeperOperatePresenter.java

@@ -461,17 +461,7 @@ public class SweeperOperatePresenter extends Presenter<SweeperOperateFragment>
     public void onAutopilotDockerInfo(@NonNull String dockerVersion) {
     }
 
-    @Override
-    public void onSsmReceiveTimeout(boolean isTimeout) {
-
-    }
-
     @Override
     public void onAutopilotTrajectoryDownloadReq(@NonNull AutopilotControlParameters.AutoPilotLine autoPilotLine, int downloadType) {
     }
-
-    @Override
-    public void onFsmReceiveTimeout(boolean isTimeout) {
-
-    }
 }

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

@@ -68,6 +68,7 @@ import com.zhjt.mogo.adas.common.MessageType
 import com.zhjt.mogo.adas.data.Adas
 import com.zhjt.mogo.adas.data.AdasConstants
 import com.zhjt.mogo.adas.data.bean.MogoReport
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo
 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.cloud.s_r.SweeperTaskCloudSuspendResume
@@ -1376,7 +1377,7 @@ class MoGoAutopilotControlProvider :
         return AdasManager.getInstance().sendSeatPressure(driver, copilot, backRow) > -1
     }
 
-    override fun getNodeStateInfo(name: AdasConstants.NodeName): Adas.NodeStateInfo {
+    override fun getNodeStateInfo(name: AdasConstants.NodeName): NodeStateInfo {
         return AdasManager.getInstance().getNodeStateInfo(name)
     }
 

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

@@ -29,6 +29,9 @@ import com.mogo.eagle.core.data.deva.chain.ChainConstant.Companion.CHAIN_TYPE_SO
 import com.mogo.eagle.core.data.deva.chain.ChainConstant.Companion.CHAIN_TYPE_SOCKET_TRAJECTORY
 import com.mogo.eagle.core.data.deva.chain.ChainConstant.Companion.CHAIN_TYPE_SOCKET_VEHICLE
 import com.mogo.eagle.core.data.deva.chain.ChainConstant.Companion.CHAIN_TYPE_STATUS
+import com.mogo.eagle.core.data.msgbox.MsgBoxBean
+import com.mogo.eagle.core.data.msgbox.MsgBoxType
+import com.mogo.eagle.core.data.msgbox.SSMMsg
 import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager
 import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager.invokeArriveAtStation
 import com.mogo.eagle.core.function.call.autopilot.CallerAutoPilotStatusListenerManager.invokeAutopilotGuardian
@@ -70,6 +73,7 @@ import com.mogo.eagle.core.function.call.autopilot.CallerSweeperFutianCloudTaskL
 import com.mogo.eagle.core.function.call.autopilot.CallerNodeStateListenerManager
 import com.mogo.eagle.core.function.call.autopilot.CallerV2XListenerManager
 import com.mogo.eagle.core.function.call.autopilot.CallerV2nNioEventListenerManager
+import com.mogo.eagle.core.function.call.msgbox.CallerMsgBoxManager
 import com.mogo.eagle.core.function.call.obu.CallerObuMapMathListenerManager
 import com.mogo.eagle.core.function.call.obu.CallerObuWarningRsiListenerManager
 import com.mogo.eagle.core.function.call.obu.CallerObuWarningRsmListenerManager
@@ -83,11 +87,12 @@ import com.zhidao.support.adas.high.chain.AdasChain
 import com.zhjt.mogo.adas.data.bean.AdasParam
 import com.zhidao.support.adas.high.common.ProtocolStatus
 import com.zhjt.mogo.adas.common.MessageType
-import com.zhjt.mogo.adas.data.Adas
 import com.zhjt.mogo.adas.data.AdasConstants
+import com.zhjt.mogo.adas.data.AdasConstants.NodeExistState
 import com.zhjt.mogo.adas.data.AiCloudTask
 import com.zhjt.mogo.adas.data.bean.AutopilotStatistics
 import com.zhjt.mogo.adas.data.bean.LaunchConditionData
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo
 import com.zhjt.mogo.adas.data.bean.ReceivedAck
 import com.zhjt.mogo.adas.data.bean.UnableLaunchReason
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable
@@ -1007,32 +1012,29 @@ class MoGoAdasListenerImpl : OnAdasListener {
      * 目前包含状态 节点是否存在；节点是否超时；
      * SSM 只判断超时状态
      * FSM 是否存在；是否超时；
+     * <p>
+     * 状态变动时才会回调
+     * 主动获取状态：{@link AdasManager#getNodeStateInfo(AdasConstants.NodeName)}
      *
-     * @param name      节点名称
+     * @param stateInfo 节点状态
-     * @param stateInfo 节点状态信息 包含：未知；存在；不存在；    以及存在的一些状态
+     *                  {@link NodeStateInfo#getNodeState()}包含：未知；存在；不存在；
+     *                  {@link NodeStateInfo#getExistState()}包含：正常；超时；
      */
-    override fun onNodeStateInfo(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo) {
+    override fun onNodeStateInfo(stateInfo: NodeStateInfo) {
-        CallerNodeStateListenerManager.invokeNodeState(name, stateInfo)
+        CallerNodeStateListenerManager.invokeNodeState(stateInfo)
-    }
+        if (stateInfo.existState != null) {
-
+            if (stateInfo.nodeName == AdasConstants.NodeName.SSM) {
-    /**
+                //域控SSM接口接收是否超时
-     * 域控SSM接口接收超时
+                if (stateInfo.existState == NodeExistState.NODE_EXIST_TIMEOUT) {
-     * 状态变动时才会回调，默认SSM状态正常
+                    CallerMsgBoxManager.saveMsgBox(MsgBoxBean(MsgBoxType.SSMINFO, SSMMsg(0, "连接超时", "SSM超时无响应", System.currentTimeMillis())))
-     *
+                } else {
-     * @param isTimeout true：SSM接口接收超时  false：SSM接口恢复正常
+                    CallerMsgBoxManager.saveMsgBox(MsgBoxBean(MsgBoxType.SSMINFO, SSMMsg(0, "连接恢复", "SSM连接恢复", System.currentTimeMillis())))
-     */
+                }
-    override fun onSsmReceiveTimeout(isTimeout: Boolean) {
+            } else if (stateInfo.nodeName == AdasConstants.NodeName.FSM2024) {
-        CallerAutoPilotStatusListenerManager.invokeSsmReceiveTimeout(isTimeout)
+                //域控FSM接口接收是否超时
-    }
+//                (stateInfo.existState == NodeExistState.NODE_EXIST_TIMEOUT)
-
+            }
-    /**
+        }
-     * 域控FSM接口接收超时
-     * 状态变动时才会回调，默认FSM状态正常 前提是存在FSM接口
-     *
-     * @param isTimeout true：FSM接口接收超时  false：FSM接口恢复正常
-     */
-    override fun onFsm2024ReceiveTimeout(isTimeout: Boolean) {
-        CallerAutoPilotStatusListenerManager.invokeFsmReceiveTimeout(isTimeout)
     }
 
     /**

core/function-impl/mogo-core-function-devatools/src/main/java/com/zhjt/mogo_core_function_devatools/status/flow/fsm/FSMImpl.kt

@@ -12,8 +12,8 @@ import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger
 import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant.Companion.M_DEVA
 import com.mogo.eagle.core.utilcode.util.DateTimeUtils
 import com.mogo.eagle.core.utilcode.util.UiThreadHandler
-import com.zhjt.mogo.adas.data.Adas
 import com.zhjt.mogo.adas.data.AdasConstants
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo
 import com.zhjt.mogo_core_function_devatools.status.entity.FSMStateCode
 import com.zhjt.mogo_core_function_devatools.status.entity.FSMStatus
 import com.zhjt.mogo_core_function_devatools.status.flow.IFlow
@@ -129,10 +129,10 @@ internal class FSMImpl(ctx: Context) : IFlow<FSMStatus>(ctx), IMoGoAutopilotStat
      * @param name      节点名称
      * @param stateInfo 节点状态信息 包含：未知；存在；不存在；    以及存在的一些状态
      */
-    override fun onNodeStateInfo(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo) {
+    override fun onNodeStateInfo(stateInfo: NodeStateInfo) {
         CallerLogger.d(
             "$M_DEVA$TAG",
-            "-- onNodeStateInfo[nodeName=$name, stateName=${stateInfo.nodeState.name}] --"
+            "-- onNodeStateInfo[stateName=${stateInfo.nodeState.name}] --"
         )
         val fsmStatusCode = getStateCodeByNodeStateInfo(stateInfo.nodeState)
         val fsmStatusDesc = getStateDescByNodeStateInfo(stateInfo.nodeState)

core/function-impl/mogo-core-function-hmi/src/main/java/com/mogo/eagle/core/function/hmi/ui/msgbox/DriverMsgBoxBubbleView.kt

@@ -32,9 +32,9 @@ import com.mogo.eagle.core.function.msgbox.MsgBoxConfig
 import com.mogo.eagle.core.utilcode.mogo.AppIdentityModeUtils
 import com.mogo.eagle.core.utilcode.util.SoundPoolUtils
 import com.mogo.eagle.core.utilcode.util.UiThreadHandler
-import com.zhjt.mogo.adas.data.Adas
 import com.zhjt.mogo.adas.data.AdasConstants
 import com.zhjt.mogo.adas.data.AdasConstants.NodeState
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo
 import kotlinx.android.synthetic.main.layout_driver_msg_box_bubble.view.*
 import java.util.concurrent.atomic.AtomicReference
 
@@ -221,8 +221,8 @@ class DriverMsgBoxBubbleView @JvmOverloads constructor(
      * @param name      节点名称
      * @param stateInfo 节点状态信息 包含：未知；存在；不存在；    以及存在的一些状态
      */
-    override fun onNodeStateInfo(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo) {
+    override fun onNodeStateInfo(stateInfo: NodeStateInfo) {
-        if (AdasConstants.NodeName.FSM2024 == name) {
+        if (AdasConstants.NodeName.FSM2024 == stateInfo.nodeName) {
             fsmNodeState.set(stateInfo.nodeState)
         }
     }

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

@@ -7,6 +7,7 @@ import com.mogo.eagle.core.data.deva.badcase.BagManagerEntity
 import com.mogo.eagle.core.function.api.base.IMoGoFunctionServerProvider
 import com.zhjt.mogo.adas.data.Adas
 import com.zhjt.mogo.adas.data.AdasConstants
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo
 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
@@ -612,6 +613,6 @@ interface IMoGoAutopilotControlProvider : IMoGoFunctionServerProvider {
      * @param name 节点名称 目前只有SSM和FSM2024
      * @return 状态   SSM只能查询到超时状态；FSM2024可以查询到节点是否存在状态以及超时状态；
      */
-    fun getNodeStateInfo(name: AdasConstants.NodeName): Adas.NodeStateInfo
+    fun getNodeStateInfo(name: AdasConstants.NodeName): NodeStateInfo
 
 }

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

@@ -49,21 +49,6 @@ interface IMoGoAutopilotStatusListener {
      */
     fun onAutopilotIpcConnectStatusChanged(status: AdasConstants.IpcConnectionStatus, reason: String?) {}
 
-    /**
-     * 域控SSM接口接收超时
-     * 状态变动时才会回调，默认SSM状态正常
-     * @param isTimeout true：SSM接口接收超时  false：SSM接口恢复正常
-     */
-    fun onSsmReceiveTimeout(isTimeout: Boolean) {}
-
-    /**
-     * 域控FSM接口接收超时
-     * 状态变动时才会回调，默认FSM状态正常 前提是存在FSM接口
-     *
-     * @param isTimeout true：FSM接口接收超时  false：FSM接口恢复正常
-     */
-    fun onFsmReceiveTimeout(isTimeout: Boolean) {}
-
     /**
      * 工控机主动查询 AdasManager#sendStatusQueryReq()，后会收到如下回调
      */

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

@@ -1,7 +1,6 @@
 package com.mogo.eagle.core.function.api.autopilot
 
-import com.zhjt.mogo.adas.data.Adas
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo
-import com.zhjt.mogo.adas.data.AdasConstants
 
 /**
  *节点状态
@@ -17,8 +16,7 @@ interface IMoGoNodeStateListener {
      * @param name      节点名称
      * @param stateInfo 节点状态信息 包含：未知；存在；不存在；    以及存在的一些状态
      */
-    fun onNodeStateInfo(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo)
+    fun onNodeStateInfo(stateInfo: NodeStateInfo)
-
 
 
 }

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

@@ -30,6 +30,7 @@ import com.zhjt.mogo.adas.data.sweeper.task.s_r.SweeperTaskSuspendResume.Suspend
 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.bean.NodeStateInfo
 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
@@ -927,7 +928,7 @@ object CallerAutoPilotControlManager {
      * @param name 节点名称 目前只有SSM和FSM2024
      * @return 状态   SSM只能查询到超时状态；FSM2024可以查询到节点是否存在状态以及超时状态；
      */
-    fun getNodeStateInfo(name: AdasConstants.NodeName): Adas.NodeStateInfo? {
+    fun getNodeStateInfo(name: AdasConstants.NodeName): NodeStateInfo? {
         return providerApi?.getNodeStateInfo(name)
     }
 }

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

@@ -224,35 +224,6 @@ object CallerAutoPilotStatusListenerManager : CallerBase<IMoGoAutopilotStatusLis
         }
     }
 
-    /**
-     * 域控SSM接口接收超时
-     * 状态变动时才会回调，默认SSM状态正常
-     * @param isTimeout true：SSM接口接收超时  false：SSM接口恢复正常
-     */
-    fun invokeSsmReceiveTimeout(isTimeout: Boolean) {
-        M_LISTENERS.forEach {
-            val listener = it.value
-            listener.onSsmReceiveTimeout(isTimeout)
-        }
-        if (isTimeout) {
-            CallerMsgBoxManager.saveMsgBox(MsgBoxBean(MsgBoxType.SSMINFO, SSMMsg(0, "连接超时", "ssm超时无响应", System.currentTimeMillis())))
-        } else {
-            CallerMsgBoxManager.saveMsgBox(MsgBoxBean(MsgBoxType.SSMINFO, SSMMsg(0, "连接恢复", "ssm连接恢复", System.currentTimeMillis())))
-        }
-    }
-
-    /**
-     * 域控FSM接口接收超时
-     * 状态变动时才会回调，默认FSM状态正常 前提是存在FSM接口
-     *
-     * @param isTimeout true：FSM接口接收超时  false：FSM接口恢复正常
-     */
-    fun invokeFsmReceiveTimeout(isTimeout: Boolean) {
-        M_LISTENERS.forEach {
-            val listener = it.value
-            listener.onFsmReceiveTimeout(isTimeout)
-        }
-    }
 
     /**
      * 主动调查询接口：AdasManager#sendStatusQueryReq(), 会收到以下回调

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

@@ -2,8 +2,8 @@ package com.mogo.eagle.core.function.call.autopilot
 
 import com.mogo.eagle.core.function.api.autopilot.IMoGoNodeStateListener
 import com.mogo.eagle.core.function.call.base.CallerBase
-import com.zhjt.mogo.adas.data.Adas
 import com.zhjt.mogo.adas.data.AdasConstants
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo
 
 /**
  *节点状态
@@ -11,6 +11,9 @@ import com.zhjt.mogo.adas.data.AdasConstants
 object CallerNodeStateListenerManager : CallerBase<IMoGoNodeStateListener>() {
     private val mutableMap = mutableMapOf<String, Set<AdasConstants.NodeName>>()
 
+    /**
+     * nodeName传入要监听的节点状态名称，如果传递注册的时候将返回所有节点的状态
+     */
     fun addNodeStateListener(
         tag: String,
         nodeName: Set<AdasConstants.NodeName>?,
@@ -29,15 +32,15 @@ object CallerNodeStateListenerManager : CallerBase<IMoGoNodeStateListener>() {
         super.removeListener(tag)
     }
 
-    fun invokeNodeState(name: AdasConstants.NodeName, stateInfo: Adas.NodeStateInfo) {
+    fun invokeNodeState(stateInfo: NodeStateInfo) {
         M_LISTENERS.forEach {
             val names = mutableMap[it.key]
             val listener = it.value
             if (names.isNullOrEmpty()) {
-                listener.onNodeStateInfo(name, stateInfo)
+                listener.onNodeStateInfo(stateInfo)
             } else {
-                if (names.contains(name)) {
+                if (names.contains(stateInfo.nodeName)) {
-                    listener.onNodeStateInfo(name, stateInfo)
+                    listener.onNodeStateInfo(stateInfo)
                 }
             }
         }
@@ -47,11 +50,11 @@ object CallerNodeStateListenerManager : CallerBase<IMoGoNodeStateListener>() {
         super.doSomeAfterAddListener(tag, listener)
         mutableMap.forEach { it ->
             if (it.key == tag) {
-                val value = it.value
+                val names = it.value
-                value.forEach { name ->
+                names.forEach { name ->
                     val state = CallerAutoPilotControlManager.getNodeStateInfo(name)
                     state?.let {
-                        listener.onNodeStateInfo(name, state)
+                        listener.onNodeStateInfo(state)
                     }
                 }
             }

libraries/mogo-adas-data/src/main/java/com/zhjt/mogo/adas/data/bean/NodeStateInfo.java

@@ -0,0 +1,65 @@
+package com.zhjt.mogo.adas.data.bean;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.zhjt.mogo.adas.data.AdasConstants;
+
+import java.util.Objects;
+
+public class NodeStateInfo {
+    private final AdasConstants.NodeName nodeName; //节点名称
+    @NonNull
+    private AdasConstants.NodeState nodeState;//节点主状态 包含：未知；存在；不存在；
+    @Nullable
+    private AdasConstants.NodeExistState existState;//节点存在时的状态 null表示未知
+
+    public NodeStateInfo(AdasConstants.NodeName nodeName, @NonNull AdasConstants.NodeState nodeState) {
+        this.nodeName = nodeName;
+        this.nodeState = nodeState;
+    }
+
+    public AdasConstants.NodeName getNodeName() {
+        return nodeName;
+    }
+
+    @NonNull
+    public AdasConstants.NodeState getNodeState() {
+        return nodeState;
+    }
+
+    public void setNodeState(@NonNull AdasConstants.NodeState nodeState) {
+        this.nodeState = nodeState;
+    }
+
+    @Nullable
+    public AdasConstants.NodeExistState getExistState() {
+        return existState;
+    }
+
+    public void setExistState(@Nullable AdasConstants.NodeExistState existState) {
+        this.existState = existState;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        NodeStateInfo that = (NodeStateInfo) o;
+        return nodeName == that.nodeName && nodeState == that.nodeState && existState == that.existState;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(nodeName, nodeState, existState);
+    }
+
+    @Override
+    public String toString() {
+        return "NodeStateInfo{" +
+                "nodeName=" + nodeName +
+                ", nodeState=" + nodeState +
+                ", existState=" + existState +
+                '}';
+    }
+}

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

@@ -3,7 +3,6 @@ package mogo.telematics.pad;
 option java_package = "com.zhjt.mogo.adas.data";
 
 import "message_pad.proto";
-import "personal/adas_constants.proto";
 
 //发送的数据ID持久化，只保留最后一条的消息id，每天重新累计
 message LastMessage{
@@ -16,10 +15,3 @@ message LastMessage{
 message MessageIdInfo{
   map<uint64, LastMessage> lastMessages = 1;// key：data（日期） value：数据
 }
-
-//节点状态信息
-message NodeStateInfo{
-  com.zhjt.mogo.adas.data.NodeName nodeName = 1;//节点名称
-  com.zhjt.mogo.adas.data.NodeState nodeState = 2;//节点主状态 包含：未知；存在；不存在；
-  com.zhjt.mogo.adas.data.NodeExistState existState = 3;//节点存在时的状态
-}

libraries/mogo-adas-data/src/main/proto/personal/adas_constants.proto

@@ -110,9 +110,8 @@ enum SubscribeType {
  * 节点名称
  */
 enum NodeName{
-  DEFAULT_NAME = 0;//无用
+  SSM = 0;//SSM默认存在
-  SSM = 1;//SSM默认存在
+  FSM2024 = 1;//FSM 2024版本的Topic名称
-  FSM2024 = 2;//FSM 2024版本的Topic名称
 }
 
 /**

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

@@ -19,6 +19,7 @@ import com.zhjt.mogo.adas.common.MessageType;
 import com.zhjt.mogo.adas.data.Adas;
 import com.zhjt.mogo.adas.data.AdasConstants;
 import com.zhjt.mogo.adas.data.bean.AdasParam;
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo;
 import com.zhjt.mogo.adas.data.bean.ReceivedAck;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
 import com.zhjt.mogo.adas.data.sweeper.task.SweeperTask;
@@ -1721,7 +1722,7 @@ public class AdasManager implements IAdasNetCommApi {
      * @param name 节点名称 目前只有SSM和FSM2024
      * @return 状态   SSM只能查询到超时状态；FSM2024可以查询到节点是否存在状态以及超时状态；
      */
-    public Adas.NodeStateInfo getNodeStateInfo(AdasConstants.NodeName name) {
+    public NodeStateInfo getNodeStateInfo(@NonNull AdasConstants.NodeName name) {
         return AutopilotAbilityManager.getInstance().getNodeStateInfo(name);
     }
 

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

@@ -7,12 +7,12 @@ import com.google.protobuf.ByteString;
 import com.mogo.support.obu.ObuScene;
 import com.zhidao.support.adas.high.common.ProtocolStatus;
 import com.zhjt.mogo.adas.common.MessageType;
-import com.zhjt.mogo.adas.data.Adas;
 import com.zhjt.mogo.adas.data.AdasConstants;
 import com.zhjt.mogo.adas.data.AiCloudTask;
 import com.zhjt.mogo.adas.data.bean.AdasParam;
 import com.zhjt.mogo.adas.data.bean.AutopilotStatistics;
 import com.zhjt.mogo.adas.data.bean.LaunchConditionData;
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo;
 import com.zhjt.mogo.adas.data.bean.ReceivedAck;
 import com.zhjt.mogo.adas.data.bean.UnableLaunchReason;
 import com.zhjt.mogo.adas.data.sweeper.bootable.SweeperBootable;
@@ -538,27 +538,15 @@ public interface OnAdasListener {
      * 目前包含状态 节点是否存在；节点是否超时；
      * SSM 只判断超时状态
      * FSM 是否存在；是否超时；
+     * <p>
+     * 状态变动时才会回调
+     * 主动获取状态：{@link AdasManager#getNodeStateInfo(AdasConstants.NodeName)}
      *
-     * @param name      节点名称
+     * @param stateInfo 节点状态
-     * @param stateInfo 节点状态信息 包含：未知；存在；不存在；    以及存在的一些状态
+     *                  {@link NodeStateInfo#getNodeState()}包含：未知；存在；不存在；
+     *                  {@link NodeStateInfo#getExistState()}包含：正常；超时；
      */
-    void onNodeStateInfo(@NonNull AdasConstants.NodeName name, @NonNull Adas.NodeStateInfo stateInfo);
+    void onNodeStateInfo(@NonNull NodeStateInfo stateInfo);
-
-    /**
-     * 域控SSM接口接收超时
-     * 状态变动时才会回调，默认SSM状态正常
-     *
-     * @param isTimeout true：SSM接口接收超时  false：SSM接口恢复正常
-     */
-    void onSsmReceiveTimeout(boolean isTimeout);
-
-    /**
-     * 域控FSM接口接收超时
-     * 状态变动时才会回调，默认FSM状态正常 前提是存在FSM接口
-     *
-     * @param isTimeout true：FSM接口接收超时  false：FSM接口恢复正常
-     */
-    void onFsm2024ReceiveTimeout(boolean isTimeout);
 
     /**
      * 是否有能力启动自动驾驶

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

@@ -13,7 +13,7 @@ import fsm.Fsm2024;
  * 是否可以启动自动驾驶能力检测   工控机版本>=4400&&(isJinlv||isJinlvM1||isJinlvM) 使用此类
  * 目前监控了FSM2024状态
  */
-public class AutopilotAbility440 {
+public class AutopilotAbilityFSM {
     private final String TAG = this.getClass().getSimpleName();
 
     @NonNull
@@ -21,7 +21,7 @@ public class AutopilotAbility440 {
     private OnAutopilotAbilityListener listener;
 
 
-    public AutopilotAbility440(@NonNull AutopilotAbilityManager manager) {
+    public AutopilotAbilityFSM(@NonNull AutopilotAbilityManager manager) {
         this.manager = manager;
     }
 

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

@@ -1,6 +1,8 @@
 package com.zhidao.support.adas.high.common.autopilot.ability;
 
 
+import android.text.TextUtils;
+
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
@@ -9,18 +11,20 @@ import com.zhidao.support.adas.high.AdasOptions;
 import com.zhidao.support.adas.high.BuildConfig;
 import com.zhidao.support.adas.high.OnAdasListener;
 import com.zhidao.support.adas.high.common.CupidLogUtils;
-import com.zhjt.mogo.adas.data.Adas;
 import com.zhjt.mogo.adas.data.AdasConstants;
 import com.zhjt.mogo.adas.data.bean.LaunchConditionData;
+import com.zhjt.mogo.adas.data.bean.NodeStateInfo;
 import com.zhjt.mogo.adas.data.bean.UnableLaunchReason;
 
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.Timer;
 import java.util.TimerTask;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 
 import chassis.Chassis;
 import chassis.ChassisStatesOuterClass;
@@ -59,17 +63,19 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
     private AutopilotAbility330 autopilotAbility330;
     private AutopilotAbility350And360 autopilotAbility350And360;
     private AutopilotAbility360 autopilotAbility360;
-    private AutopilotAbility440 autopilotAbility440;
+    private AutopilotAbilityFSM autopilotAbilityFsm;
     private Timer startTimer;
     private Timer timeoutTimer;//SSM和FSM超时计时器
     private long ssmReceiveTime;//SSM接收时间
     private long fsmReceiveTime;//FSM接收时间
 
+    private final AtomicBoolean isInitAutopilotAbility = new AtomicBoolean(false);//是否初始化完成
     private final AtomicBoolean isOldSsmTimeout = new AtomicBoolean(false);//SSM是否超时 老状态
     private final AtomicBoolean isOldFsmTimeout = new AtomicBoolean(false);//FSM是否超时 老状态
     private final AtomicBoolean isInitCarConfig = new AtomicBoolean(false);//车辆信息是否初始化
-    private final Map<AdasConstants.NodeName, Adas.NodeStateInfo> nodeStateInfos = new HashMap<>();
+    private final AtomicInteger isSupportFSM2024 = new AtomicInteger(-1);//-1：未初始化  0：不支持   1：通过SSM V2判断支持   2：通过FSM数据源判断支持
-    private boolean isSupportFSM2024 = false;
+    private final Map<AdasConstants.NodeName, NodeStateInfo> nodeStateInfos = new ConcurrentHashMap<>();
+
 
     private AutopilotAbilityManager() {
     }
@@ -85,6 +91,20 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
         return INSTANCE;
     }
 
+    private void initStartData() {
+        nodeStateInfos.clear();
+        NodeStateInfo ssmInfo = new NodeStateInfo(AdasConstants.NodeName.SSM, AdasConstants.NodeState.NODE_EXIST);
+        ssmInfo.setExistState(AdasConstants.NodeExistState.NODE_EXIST_NORMAL);
+        nodeStateInfos.put(AdasConstants.NodeName.SSM, ssmInfo);
+        nodeStateInfos.put(AdasConstants.NodeName.FSM2024, new NodeStateInfo(AdasConstants.NodeName.FSM2024, AdasConstants.NodeState.NODE_UNKNOWN));
+    }
+
+    private void initStopData() {
+        nodeStateInfos.clear();
+        nodeStateInfos.put(AdasConstants.NodeName.SSM, new NodeStateInfo(AdasConstants.NodeName.SSM, AdasConstants.NodeState.NODE_UNKNOWN));
+        nodeStateInfos.put(AdasConstants.NodeName.FSM2024, new NodeStateInfo(AdasConstants.NodeName.FSM2024, AdasConstants.NodeState.NODE_UNKNOWN));
+    }
+
     public void setLaunchAutopilotGear(Set<Chassis.GearPosition> launchAutopilotGear) {
         if (autopilotAbility230 != null) {
             autopilotAbility230.setLaunchAutopilotGear(launchAutopilotGear);
@@ -156,7 +176,7 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
      */
     public void setStatusInfo(SystemStatusInfo.StatusInfo statusInfo) {
         ssmReceiveTime = System.currentTimeMillis();
-        onCallSSMTimeout(false);
+        onCallSSMTimeout(AdasConstants.SsmSource.SSM_VER1, false);
         if (autopilotAbility250 != null) {
             autopilotAbility250.setStatusInfo(statusInfo);
         }
@@ -167,7 +187,8 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
 
     public void setStatusInfo(SsmInfo.SsmStatusInf statusInfo) {
         ssmReceiveTime = System.currentTimeMillis();
-        onCallSSMTimeout(false);
+        onCallSSMTimeout(AdasConstants.SsmSource.SSM_VER2, false);
+        detectionTopicExistence(statusInfo);
         if (autopilotAbility350And360 != null) {
             autopilotAbility350And360.setStatusInfo(statusInfo);
         }
@@ -177,10 +198,10 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
     }
 
     public void setFSM2024State(Fsm2024.FSMStateMsg fsmState) {
-        fsmReceiveTime = System.currentTimeMillis();
+        updateFSMNormalStateFromFSM();
         onCallFSMTimeout(false);
-        if (autopilotAbility440 != null) {
+        if (autopilotAbilityFsm != null) {
-            autopilotAbility440.setFSMState(fsmState);
+            autopilotAbilityFsm.setFSMState(fsmState);
         }
     }
 
@@ -219,67 +240,85 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
      * @param name 节点名称 目前只有SSM和FSM2024
      * @return 状态   SSM只能查询到超时状态；FSM2024可以查询到节点是否存在状态以及超时状态；
      */
-    public Adas.NodeStateInfo getNodeStateInfo(AdasConstants.NodeName name) {
+    public NodeStateInfo getNodeStateInfo(@NonNull AdasConstants.NodeName name) {
-        Adas.NodeStateInfo state = nodeStateInfos.get(name);
+        NodeStateInfo state = nodeStateInfos.get(name);
         if (state == null) {
-            state = Adas.NodeStateInfo.newBuilder().setNodeState(AdasConstants.NodeState.NODE_UNKNOWN).build();
+            return new NodeStateInfo(name, AdasConstants.NodeState.NODE_UNKNOWN);
-            nodeStateInfos.put(name, state);
         }
         return state;
     }
 
-    //检测节点是否存在
+    /**
-    private void detectionTopicExistence() {
+     * 检测节点是否存在
-
+     * 判断条件：SSM消息中冷启动完成（statusInfo.getAutoPilotReady()==ture）
+     * 后查询自动驾驶关键节点列表中是否有包含fsm节点名称
+     */
+    private void detectionTopicExistence(SsmInfo.SsmStatusInf statusInfo) {
+        if (isSupportFSM2024.get() == -1) {
+            if (statusInfo.getAutoPilotReady()) {
+                List<SsmInfo.NodeInf> list = statusInfo.getAutoPilotUnreadyListList();
+                boolean isSupport = false;
+                for (SsmInfo.NodeInf info : list) {
+                    String name = info.getNodeName();
+                    if (!TextUtils.isEmpty(name) && name.toLowerCase().contains("fsm")) {
+                        //支持FSM
+                        isSupport = true;
+                        break;
+                    }
+                }
+                updateFSMStateFromSSM(isSupport ? 1 : 0);
+            }
+        }
     }
 
     private void initAutopilotAbility() {
-        stopAllTimer();
+        if (!isInitAutopilotAbility.get()) {
-        isSupportFSM2024 = false;
+            isInitAutopilotAbility.set(true);
-        if (mapVersion >= 40400 && (isJinlv || isJinlvM1 || isJinlvM2)) {
+            stopAllTimer();
-            isSupportFSM2024 = true;
+            if (isSupportFSM2024.get() > 0) {
-            CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：440");
+                CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：FSM版本");
-            if (autopilotAbility440 == null) {
+                if (autopilotAbilityFsm == null) {
-                autopilotAbility440 = new AutopilotAbility440(this);
+                    autopilotAbilityFsm = new AutopilotAbilityFSM(this);
-                autopilotAbility440.start(this);
+                    autopilotAbilityFsm.start(this);
-            }
+                }
-        } else if (mapVersion >= 30600 && isFutianSweeper) {
+            } else if (mapVersion >= 30600 && isFutianSweeper) {
-            CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：360清扫车专用");
+                CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：360清扫车专用");
-            if (autopilotAbility360 == null) {
+                if (autopilotAbility360 == null) {
-                autopilotAbility360 = new AutopilotAbility360(this);
+                    autopilotAbility360 = new AutopilotAbility360(this);
-                autopilotAbility360.start(this);
+                    autopilotAbility360.start(this);
-            }
+                }
-        } else if ((mapVersion >= 30500 && (isJinlvM1 || isHQ)) || mapVersion >= 30600) {
+            } else if ((mapVersion >= 30500 && (isJinlvM1 || isHQ)) || mapVersion >= 30600) {
-            CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：350和360共用");
+                CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：350和360共用");
-            if (autopilotAbility350And360 == null) {
+                if (autopilotAbility350And360 == null) {
-                autopilotAbility350And360 = new AutopilotAbility350And360(this);
+                    autopilotAbility350And360 = new AutopilotAbility350And360(this);
-                autopilotAbility350And360.start(this);
+                    autopilotAbility350And360.start(this);
-            }
+                }
 
-        } else if (mapVersion >= 30300 && isFutianSweeper) {//目前只有MAP330的清扫车用的新的FSM状态原因查询
+            } else if (mapVersion >= 30300 && isFutianSweeper) {//目前只有MAP330的清扫车用的新的FSM状态原因查询
-            CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：330清扫车专用");
+                CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：330清扫车专用");
-            if (autopilotAbility330 == null) {
+                if (autopilotAbility330 == null) {
-                autopilotAbility330 = new AutopilotAbility330(this, mapVersion);
+                    autopilotAbility330 = new AutopilotAbility330(this, mapVersion);
-                autopilotAbility330.start(this);
+                    autopilotAbility330.start(this);
+                }
+            } else if (mapVersion >= 20500) {
+                CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：250");
+                if (autopilotAbility250 == null) {
+                    autopilotAbility250 = new AutopilotAbility250(this);
+                    autopilotAbility250.start(this);
+                }
+            } else {
+                CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：230");
+                if (autopilotAbility230 == null) {
+                    autopilotAbility230 = new AutopilotAbility230(this);
+                    autopilotAbility230.start(this);
+                }
             }
-        } else if (mapVersion >= 20500) {
-            CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：250");
-            if (autopilotAbility250 == null) {
-                autopilotAbility250 = new AutopilotAbility250(this);
-                autopilotAbility250.start(this);
-            }
-        } else {
-            CupidLogUtils.log(TAG, "能否启动自驾能力检测使用版本：230");
             if (autopilotAbility230 == null) {
-                autopilotAbility230 = new AutopilotAbility230(this);
+                startTimeoutTimer();//MAP230及以下没有SSM和FSM所以不需要超时
-                autopilotAbility230.start(this);
             }
+            Set<Chassis.GearPosition> launchAutopilotGear = getGearPositions();
+            setLaunchAutopilotGear(launchAutopilotGear);
         }
-        if (autopilotAbility230 == null) {
-            startTimeoutTimer();//MAP230及以下没有SSM和FSM所以不需要超时
-        }
-        Set<Chassis.GearPosition> launchAutopilotGear = getGearPositions();
-        setLaunchAutopilotGear(launchAutopilotGear);
     }
 
     private @Nullable Set<Chassis.GearPosition> getGearPositions() {
@@ -307,6 +346,130 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
         return launchAutopilotGear;
     }
 
+
+    /**
+     * 连接工控机成功调用此函数，如果dockerVersion还未获取到将启动最低版本的启动自动驾驶能力检测
+     * 此函数为保险措施 以防无法获取工控机版本时 也能 正常执行逻辑
+     */
+    public synchronized void start() {
+        isInitAutopilotAbility.set(false);
+        initStartData();
+        if (startTimer == null) {
+            startTimer = new Timer();
+            startTimer.schedule(new TimerTask() {
+                @Override
+                public void run() {
+                    if (!isInitCarConfig.get() && AdasManager.getInstance().getIpcConnectionStatus() == AdasConstants.IpcConnectionStatus.CONNECTED) {
+                        mapVersion = 20300;
+                        isSupportFSM2024.set(-1);
+                        initAutopilotAbility();
+                        isInitAutopilotAbility.set(false);
+                    }
+                }
+            }, 15000L);//15秒原因：需要后去CarConfig 对象，两个地方调用initAutopilotAbility(); 初始化 一个在这，另一个在setCarConfig(),如果setCarConfig() 证明获取版本还未成功，获取版本会重试3次每次间隔四秒
+        }
+    }
+
+    /**
+     * 连接工控机成功调用此函数，如果dockerVersion还未获取到将启动最低版本的启动自动驾驶能力检测
+     * 此函数为保险措施 以防无法获取工控机版本时 也能 正常执行逻辑
+     */
+    public synchronized void startTimeoutTimer() {
+        if (timeoutTimer == null) {
+            ssmReceiveTime = System.currentTimeMillis();
+            fsmReceiveTime = System.currentTimeMillis();
+            timeoutTimer = new Timer();
+            timeoutTimer.schedule(new TimerTask() {
+                @Override
+                public void run() {
+                    //SSM超时检测
+                    long timeDifference = System.currentTimeMillis() - ssmReceiveTime;
+                    if (timeDifference >= DEFAULT_TIMEOUT) {
+                        onCallSSMTimeout(AdasConstants.SsmSource.SSM_UNKNOWN, true);
+                        //超时
+                        if (autopilotAbility250 != null) {
+                            autopilotAbility250.onCallTimeout();
+                        }
+                        if (autopilotAbility330 != null) {
+                            autopilotAbility330.onCallTimeout();
+                        }
+                        if (autopilotAbility350And360 != null) {
+                            autopilotAbility350And360.onCallTimeout();
+                        }
+                        if (autopilotAbility360 != null) {
+                            autopilotAbility360.onCallTimeout();
+                        }
+                    }
+                    //FSM超时检测
+                    if (isSupportFSM2024.get() > 0) {
+                        timeDifference = System.currentTimeMillis() - fsmReceiveTime;
+                        if (timeDifference >= DEFAULT_TIMEOUT) {
+                            onCallFSMTimeout(true);
+                            if (autopilotAbilityFsm != null) {
+                                autopilotAbilityFsm.onCallFsmTimeout();
+                            }
+                        }
+                    }
+                }
+            }, 1000L, DEFAULT_TIMEOUT);
+        }
+    }
+
+
+    private void updateFSMNormalStateFromFSM() {
+        fsmReceiveTime = System.currentTimeMillis();
+        if (isSupportFSM2024.get() != 2) {
+            updateFSMSupportState(2, AdasConstants.NodeExistState.NODE_EXIST_NORMAL);
+        }
+    }
+
+    private void updateFSMStateFromSSM(int isSupport) {
+        if (isSupportFSM2024.get() == -1) {
+            updateFSMSupportState(isSupport, null);
+        }
+    }
+
+    private void updateFSMSupportState(int isSupport, AdasConstants.NodeExistState existState) {
+        isSupportFSM2024.set(isSupport);
+        CupidLogUtils.i(TAG, "是否支持FSM=" + isSupport);
+        if (isSupport > 0) {
+            isInitAutopilotAbility.set(false);
+            initAutopilotAbility();
+        }
+        NodeStateInfo info = getNodeStateInfo(AdasConstants.NodeName.FSM2024);
+        info.setNodeState(isSupport > 0 ? AdasConstants.NodeState.NODE_EXIST : AdasConstants.NodeState.NODE_NOT_EXIST);
+        info.setExistState(existState);
+        listener.onNodeStateInfo(info);
+    }
+
+    private synchronized void onCallSSMTimeout(AdasConstants.SsmSource source, boolean isTimeout) {
+        if (isTimeout != isOldSsmTimeout.get()) {
+            isOldSsmTimeout.set(isTimeout);
+            if (!isTimeout) {
+                if (source == AdasConstants.SsmSource.SSM_VER1) {
+                    //SSM 1版本时 不支持FSM
+                    CupidLogUtils.i(TAG, "SSM版本1不支持FSM");
+                    updateFSMStateFromSSM(0);
+                }
+            }
+            NodeStateInfo info = getNodeStateInfo(AdasConstants.NodeName.SSM);
+            info.setNodeState(AdasConstants.NodeState.NODE_EXIST);
+            info.setExistState(isTimeout ? AdasConstants.NodeExistState.NODE_EXIST_TIMEOUT : AdasConstants.NodeExistState.NODE_EXIST_NORMAL);
+            listener.onNodeStateInfo(info);
+        }
+    }
+
+    private synchronized void onCallFSMTimeout(boolean isTimeout) {
+        if (isTimeout != isOldFsmTimeout.get()) {
+            isOldFsmTimeout.set(isTimeout);
+            NodeStateInfo info = getNodeStateInfo(AdasConstants.NodeName.FSM2024);
+            info.setNodeState(AdasConstants.NodeState.NODE_EXIST);
+            info.setExistState(isTimeout ? AdasConstants.NodeExistState.NODE_EXIST_TIMEOUT : AdasConstants.NodeExistState.NODE_EXIST_NORMAL);
+            listener.onNodeStateInfo(info);
+        }
+    }
+
+
     private void stop230() {
         if (autopilotAbility230 != null) {
             autopilotAbility230.stop();
@@ -343,9 +506,9 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
     }
 
     private void stop440() {
-        if (autopilotAbility440 != null) {
+        if (autopilotAbilityFsm != null) {
-            autopilotAbility440.stop();
+            autopilotAbilityFsm.stop();
-            autopilotAbility440 = null;
+            autopilotAbilityFsm = null;
         }
     }
 
@@ -356,97 +519,13 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
         }
     }
 
-    /**
-     * 连接工控机成功调用此函数，如果dockerVersion还未获取到将启动最低版本的启动自动驾驶能力检测
-     * 此函数为保险措施 以防无法获取工控机版本时 也能 正常执行逻辑
-     */
-    public synchronized void start() {
-        if (startTimer == null) {
-            startTimer = new Timer();
-            startTimer.schedule(new TimerTask() {
-                @Override
-                public void run() {
-                    if (!isInitCarConfig.get() && AdasManager.getInstance().getIpcConnectionStatus() == AdasConstants.IpcConnectionStatus.CONNECTED) {
-                        mapVersion = 20300;
-                        initAutopilotAbility();
-                    }
-                }
-            }, 15000L);//15秒原因：需要后去CarConfig 对象，两个地方调用initAutopilotAbility(); 初始化 一个在这，另一个在setCarConfig(),如果setCarConfig() 证明获取版本还未成功，获取版本会重试3次每次间隔四秒
-        }
-
-    }
-
-
     private void stopTimeoutTimer() {
         if (timeoutTimer != null) {
-            isOldSsmTimeout.set(false);
-            isOldFsmTimeout.set(false);
-            ssmReceiveTime = 0;
-            fsmReceiveTime = 0;
             timeoutTimer.cancel();
             timeoutTimer = null;
         }
     }
 
-    /**
-     * 连接工控机成功调用此函数，如果dockerVersion还未获取到将启动最低版本的启动自动驾驶能力检测
-     * 此函数为保险措施 以防无法获取工控机版本时 也能 正常执行逻辑
-     */
-    public synchronized void startTimeoutTimer() {
-        if (timeoutTimer == null) {
-            ssmReceiveTime = System.currentTimeMillis();
-            fsmReceiveTime = System.currentTimeMillis();
-            timeoutTimer = new Timer();
-            timeoutTimer.schedule(new TimerTask() {
-                @Override
-                public void run() {
-                    //SSM超时检测
-                    long timeDifference = System.currentTimeMillis() - ssmReceiveTime;
-                    if (timeDifference >= DEFAULT_TIMEOUT) {
-                        onCallSSMTimeout(true);
-                        //超时
-                        if (autopilotAbility250 != null) {
-                            autopilotAbility250.onCallTimeout();
-                        }
-                        if (autopilotAbility330 != null) {
-                            autopilotAbility330.onCallTimeout();
-                        }
-                        if (autopilotAbility350And360 != null) {
-                            autopilotAbility350And360.onCallTimeout();
-                        }
-                        if (autopilotAbility360 != null) {
-                            autopilotAbility360.onCallTimeout();
-                        }
-                    }
-                    //FSM超时检测
-                    if (isSupportFSM2024) {
-                        timeDifference = System.currentTimeMillis() - fsmReceiveTime;
-                        if (timeDifference >= DEFAULT_TIMEOUT) {
-                            onCallFSMTimeout(true);
-                            if (autopilotAbility440 != null) {
-                                autopilotAbility440.onCallFsmTimeout();
-                            }
-                        }
-                    }
-                }
-            }, 1000L, DEFAULT_TIMEOUT);
-        }
-    }
-
-    private synchronized void onCallSSMTimeout(boolean isTimeout) {
-        if (isTimeout != isOldSsmTimeout.get()) {
-            isOldSsmTimeout.set(isTimeout);
-            listener.onSsmReceiveTimeout(isTimeout);
-        }
-    }
-
-    private synchronized void onCallFSMTimeout(boolean isTimeout) {
-        if (isTimeout != isOldFsmTimeout.get()) {
-            isOldFsmTimeout.set(isTimeout);
-            listener.onFsm2024ReceiveTimeout(isTimeout);
-        }
-    }
-
     private void stopAllTimer() {
         stopTimeoutTimer();
         stopTimer();
@@ -456,10 +535,17 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
         stop350And360();
         stop360();
         stop440();
+        isOldSsmTimeout.set(false);
+        isOldFsmTimeout.set(false);
+        ssmReceiveTime = 0;
+        fsmReceiveTime = 0;
     }
 
     public synchronized void stop() {
         stopAllTimer();
+        initStopData();
+        isInitAutopilotAbility.set(false);
+        isSupportFSM2024.set(-1);
         isInitCarConfig.set(false);
         mapVersion = -1;
         isFutianSweeper = false;
@@ -469,7 +555,6 @@ public class AutopilotAbilityManager implements OnAutopilotAbilityListener {
         isJinlvM1 = false;
         isJinlvM2 = false;
         isKaiwo = false;
-        isSupportFSM2024 = false;
     }
 
 }