import org.ros.node.Node; //导入依赖的package包/类
private void startMoveBaseNode() {
    // Create ROS node for base move
    mLog.info("Starting move base native node");
    mRosNavigationStatusIndicator.updateStatus(ModuleStatusIndicator.Status.LOADING);
    NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(mHostName);
    nodeConfiguration.setMasterUri(mMasterUri);
    nodeConfiguration.setNodeName(MoveBaseNode.NODE_NAME);
    mMoveBaseNode = new MoveBaseNode();
    mNodeMainExecutor.execute(mMoveBaseNode, nodeConfiguration,
            new ArrayList<NodeListener>(){{
                add(new DefaultNodeListener() {
                    @Override
                    public void onStart(ConnectedNode connectedNode) {
                        mRosNavigationStatusIndicator.updateStatus(ModuleStatusIndicator.Status.OK);
                    }

                    @Override
                    public void onError(Node node, Throwable throwable) {
                        mRosNavigationStatusIndicator.updateStatus(ModuleStatusIndicator.Status.ERROR);
                    }
                });
            }});
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdown(Node node) {
    synchronized (mPublisherLock) {
        mColorPublisher = null;
    }

    super.onShutdown(node);
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdown(Node node) {
  for (Layer layer : layers) {
    layer.onShutdown(this, node);
  }
  this.connectedNode = null;
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdown(Node node) {
    this.logI("Stop node !");

    if (this.serverReconfig != null)
        this.serverReconfig.close();

    if (this.threadZeroconf != null && this.threadZeroconf.isAlive()) {
        this.threadZeroconf.interrupt();
    }

    super.onShutdown(node);
    this.connectedNode = null;
}
 

import org.ros.node.Node; //导入依赖的package包/类
public void startTangoRosNode() {
    mTangoStatusIndicator.updateStatus(ModuleStatusIndicator.Status.LOADING);

    if (TangoInitializationHelper.loadTangoSharedLibrary() != TangoInitializationHelper.ARCH_ERROR &&
            TangoInitializationHelper.loadTangoRosNodeSharedLibrary() != TangoInitializationHelper.ARCH_ERROR) {

        // Remap topic names from default Tango ROS Node to those used in the standard
        // Turtlebot demos and apps.
        String[] topicMap = {
                "/tango/laser_scan:=/scan",
                "/tango/camera/color_1/image_raw/compressed:=/compressed_image"
        };

        mTangoNodeletManager = new TangoNodeletManager(topicMap);
        TangoInitializationHelper.bindTangoService(this, mTangoServiceConnection);
        if (TangoInitializationHelper.isTangoVersionOk()) {
            mLog.info("Tango Core version is supposedly OK, starting Tango node.");

            // ServiceClient node which is responsible for calling ros services.
            mTangoServiceClient = new TangoServiceClientNode();
            mTangoServiceClient.setCallbackListener(this);
            NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(mHostName);
            nodeConfiguration.setMasterUri(mMasterUri);
            nodeConfiguration.setNodeName(mTangoServiceClient.getDefaultNodeName());
            mNodeMainExecutor.execute(mTangoServiceClient, nodeConfiguration);

            // Create and start Tango ROS Node
            nodeConfiguration.setNodeName(TangoNodeletManager.NODE_NAME);
            ArrayList<NodeListener> listeners = new ArrayList<>();
            listeners.add(new DefaultNodeListener() {
                @Override
                public void onStart(ConnectedNode connectedNode) {
                    boolean connected = false;
                    try {
                        for (int i = 0; i < MAX_TANGO_CONNECTION_TRIES; i++) {
                            if (mTangoServiceClient.callTangoConnectService(TangoConnectRequest.CONNECT)) {
                                mLog.info("Successfully connected to Tango");
                                connected = true;
                                break;
                            }
                            mLog.warn("Failed to connect to Tango, try " + i);
                            Thread.sleep(200);
                        }
                    } catch (InterruptedException e) {
                        mLog.warn("Tango connection loop interrupted.", e);
                    }
                    if (!connected) {
                        mLog.error("Failed to connect to Tango.");
                        mTangoStatusIndicator.updateStatus(ModuleStatusIndicator.Status.ERROR);
                    }
                }

                @Override
                public void onError(Node node, Throwable throwable) {
                    mLog.error("Error running TangoRosNode", throwable);
                    mTangoStatusIndicator.updateStatus(ModuleStatusIndicator.Status.ERROR);
                }
            });
            mNodeMainExecutor.execute(mTangoNodeletManager, nodeConfiguration, listeners);
        } else {
            mLog.error(getString(R.string.tango_version_error));
            mTangoStatusIndicator.updateStatus(ModuleStatusIndicator.Status.ERROR);
            displayToastMessage(R.string.tango_version_error);
        }
    } else {
        mLog.error(getString(R.string.tango_lib_error));
        mTangoStatusIndicator.updateStatus(ModuleStatusIndicator.Status.ERROR);
        displayToastMessage(R.string.tango_lib_error);
    }
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onError(Node node, Throwable throwable) {
    if (super.executeReturnCode != 0 && mLog != null) {
        mLog.error("Execute error code: " + Integer.toString(super.executeReturnCode), throwable);
    }
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public synchronized void onShutdown(Node node) {
    m_node = null;
    m_cmdPublisher = null;
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdown(Node node) {
    super.onShutdown(node);
}
 

import org.ros.node.Node; //导入依赖的package包/类
/**
 * Callback for when the RobotController is shutdown.
 * @param node The Node
 */
@Override
public void onShutdown(Node node) {
    shutdownTopics();
}
 

import org.ros.node.Node; //导入依赖的package包/类
/**
 * Callback for when the shutdown is complete.
 * @param node The Node
 */
@Override
public void onShutdownComplete(Node node) {
    this.connectedNode = null;
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdown(Node node) {
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdownComplete(Node node) {
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onError(Node node, Throwable throwable) {
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdownComplete(Node node) {
  publisherTimer.cancel();
  publisherTimer.purge();
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdown(VisualizationView view, Node node) {
  posePublisher.shutdown();
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdown(VisualizationView view, Node node) {
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdown(VisualizationView view, Node node) {
  subscriber.shutdown();
  super.onShutdown(view, node);
}
 

import org.ros.node.Node; //导入依赖的package包/类
@Override
public void onShutdownComplete(Node node) {
  // Save the existing settings before exiting.
  distanceRenderer.savePreferences(this.getContext());
}
 

import org.ros.node.Node; //导入依赖的package包/类
/**
 * On node error is throw.
 */
@Override
public void onError(Node node, Throwable throwable) {
    super.onError(node, throwable);
    this.logE(throwable.getMessage());
}