ROS DefaultNode 监听器的注册和执行

  
  
 /***************监听器包EventDispatcher  然后交注册进事件分配器中******************/
  
 public DefaultNode(NodeConfiguration nodeConfiguration, Collection<NodeListener> nodeListeners,
      ScheduledExecutorService scheduledExecutorService) {
    this.nodeConfiguration = NodeConfiguration.copyOf(nodeConfiguration);
	//建立DefaultNode监听事件链表
    this.nodeListeners = new ListenerGroup<NodeListener>(scheduledExecutorService);
    //将监听事件注册到链表中
	this.nodeListeners.addAll(nodeListeners);
    
	this.scheduledExecutorService = scheduledExecutorService;
    masterUri = nodeConfiguration.getMasterUri();
    masterClient = new MasterClient(masterUri);
    topicParticipantManager = new TopicParticipantManager();
    serviceManager = new ServiceManager();
    parameterManager = new ParameterManager(scheduledExecutorService);

    GraphName basename = nodeConfiguration.getNodeName();
    NameResolver parentResolver = nodeConfiguration.getParentResolver();
    nodeName = parentResolver.getNamespace().join(basename);
    resolver = new NodeNameResolver(nodeName, parentResolver);
    slaveServer =
        new SlaveServer(nodeName, nodeConfiguration.getTcpRosBindAddress(),
            nodeConfiguration.getTcpRosAdvertiseAddress(),
            nodeConfiguration.getXmlRpcBindAddress(),
            nodeConfiguration.getXmlRpcAdvertiseAddress(), masterClient, topicParticipantManager,
            serviceManager, parameterManager, scheduledExecutorService);
    slaveServer.start();

    NodeIdentifier nodeIdentifier = slaveServer.toNodeIdentifier();

    parameterTree =
        DefaultParameterTree.newFromNodeIdentifier(nodeIdentifier, masterClient.getRemoteUri(),
            resolver, parameterManager);

    publisherFactory =
        new PublisherFactory(nodeIdentifier, topicParticipantManager,
            nodeConfiguration.getTopicMessageFactory(), scheduledExecutorService);
    subscriberFactory =
        new SubscriberFactory(nodeIdentifier, topicParticipantManager, scheduledExecutorService);
    serviceFactory =
        new ServiceFactory(nodeName, slaveServer, serviceManager, scheduledExecutorService);

    registrar = new Registrar(masterClient, scheduledExecutorService);
    topicParticipantManager.setListener(registrar);
    serviceManager.setListener(registrar);

    scheduledExecutorService.execute(new Runnable() {
      @Override
      public void run() {
        start();
      }
    });
  }
    private void start() {
    // The Registrar must be started first so that master registration is
    // possible during startup.
    registrar.start(slaveServer.toNodeIdentifier());

    // During startup, we wait for 1) the RosoutLogger and 2) the TimeProvider.
    final CountDownLatch latch = new CountDownLatch(2);

    log = new RosoutLogger(this);
    log.getPublisher().addListener(new DefaultPublisherListener<rosgraph_msgs.Log>() {
      @Override
      public void onMasterRegistrationSuccess(Publisher<rosgraph_msgs.Log> registrant) {
        latch.countDown();
      }
    });

    boolean useSimTime = false;
    try {
      useSimTime =
          parameterTree.has(Parameters.USE_SIM_TIME)
              && parameterTree.getBoolean(Parameters.USE_SIM_TIME);
    } catch (Exception e) {
      signalOnError(e);
    }
    if (useSimTime) {
      ClockTopicTimeProvider clockTopicTimeProvider = new ClockTopicTimeProvider(this);
      clockTopicTimeProvider.getSubscriber().addSubscriberListener(
          new DefaultSubscriberListener<rosgraph_msgs.Clock>() {
            @Override
            public void onMasterRegistrationSuccess(Subscriber<rosgraph_msgs.Clock> subscriber) {
              latch.countDown();
            }
          });
      timeProvider = clockTopicTimeProvider;
    } else {
      timeProvider = nodeConfiguration.getTimeProvider();
      latch.countDown();
    }

    try {
      latch.await();
    } catch (InterruptedException e) {
      signalOnError(e);
      shutdown();
      return;
    }
 
 
   //向事件监听ListenerGroup注册监听事件
    signalOnStart();  
  }
  
  
  /**
   * SignalRunnable all {@link NodeListener}s that the {@link Node} has started.
   * <p>
   * Each listener is called in a separate thread.
   */
   
   /*
  任务链结构
| nodeListener1—————————————nodeListener2——————————————nodeListener3------------|
			|注册任务1_1            |                             |
			|注册任务2_1            |                             |
			|注册任务3_1            |                             |
			|注册任务4_1            |                             |
			                      	|注册任务1_2                  |
									|注册任务2_2                  |
									|注册任务3_2                  |
									|注册任务4_2                  |
                                                                  |注册任务1_3
																  |注册任务2_3
															 	  |注册任务3_3
																  |注册任务4_3
			 
   */
  private void signalOnStart() {
	  
	//注册参数  DefaultNode ： connectedNode  
    final ConnectedNode connectedNode = this; 
	//监听任务链 中的每个监听任务 注册SignalRunnable 任务
    nodeListeners.signal(new SignalRunnable<NodeListener>() {
      @Override
      public void run(NodeListener listener) {
        listener.onStart(connectedNode);
      }
    });
	
	
	
  }

  
  
  
  /***************监听器运行******************/
  public Collection<EventDispatcher<T>> addAll(Collection<T> listeners, int limit) {
    Collection<EventDispatcher<T>> eventDispatchers = Lists.newArrayList();
    for (T listener : listeners) {
      eventDispatchers.add(add(listener, limit)); // 注册监听器，并且执行监听
    }
    return eventDispatchers;
  }
  
  
    public EventDispatcher<T> add(T listener, int queueCapacity) {
    EventDispatcher<T> eventDispatcher = new EventDispatcher<T>(listener, queueCapacity);
    eventDispatchers.add(eventDispatcher);    //注册监听
    executorService.execute(eventDispatcher); //执行监听
    return eventDispatcher;
  }