InteractionsManager.java

Go to the documentation of this file.

/*
 * Copyright (C) 2013, OSRF.
 * Copyright (c) 2013, Yujin Robot.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package com.github.rosjava.android_remocons.common_tools.rocon;

import android.os.AsyncTask;
import android.util.Log;

import com.github.rosjava.android_remocons.common_tools.master.MasterId;

import org.ros.address.InetAddressFactory;
import org.ros.android.NodeMainExecutorService;
import org.ros.exception.RosRuntimeException;
import org.ros.exception.ServiceNotFoundException;
import org.ros.internal.node.client.ParameterClient;
import org.ros.internal.node.server.NodeIdentifier;
import org.ros.namespace.GraphName;
import org.ros.node.AbstractNodeMain;
import org.ros.node.ConnectedNode;
import org.ros.node.Node;
import org.ros.node.NodeConfiguration;
import org.ros.node.service.ServiceClient;
import org.ros.node.service.ServiceResponseListener;

import java.net.URI;
import java.net.URISyntaxException;

import rocon_interaction_msgs.GetInteraction;
import rocon_interaction_msgs.GetInteractionRequest;
import rocon_interaction_msgs.GetInteractionResponse;
import rocon_interaction_msgs.GetInteractions;
import rocon_interaction_msgs.GetInteractionsRequest;
import rocon_interaction_msgs.GetInteractionsResponse;
import rocon_interaction_msgs.RequestInteraction;
import rocon_interaction_msgs.RequestInteractionRequest;
import rocon_interaction_msgs.RequestInteractionResponse;

import static com.github.rosjava.android_remocons.common_tools.rocon.Constants.ANDROID_PLATFORM_INFO;

public class InteractionsManager extends AbstractNodeMain {
    public interface FailureHandler {
        void handleFailure(String reason);
    }

    public enum Action {
        NONE, GET_INTERACTIONS_FOR_ROLE, GET_INTERACTION_INFO, REQUEST_INTERACTION_USE
    };

    private String role;
    private String interactionsNamespace;
    private Action action = Action.NONE;
        private rocon_interaction_msgs.Interaction app;
    private int app_hash;  // need this separately since headless starts don't have any app info.
    private String remocon_name;  // need this separately since headless starts don't have any app info.
    private ConnectNodeThread connectThread;
    private ConnectedNode connectedNode;
    private NodeMainExecutorService nodeMainExecutorService;
    private FailureHandler failureCallback;
        private ServiceResponseListener<RequestInteractionResponse> requestServiceResponseListener;
        private ServiceResponseListener<GetInteractionsResponse>    getAppsServiceResponseListener;
    private ServiceResponseListener<GetInteractionResponse>     appInfoServiceResponseListener;


        public InteractionsManager(FailureHandler failureCallback) {

        this.failureCallback = failureCallback;
    }

    public void init(String interactionsNamespace) {
        this.interactionsNamespace = interactionsNamespace;
    }

    public void setRemoconName(String remocon_name) {
        this.remocon_name = remocon_name;
    }


    public void setupRequestService(ServiceResponseListener<RequestInteractionResponse> serviceResponseListener) {
        this.requestServiceResponseListener = serviceResponseListener;
    }

    public void setupGetInteractionsService(ServiceResponseListener<GetInteractionsResponse> serviceResponseListener) {
        this.getAppsServiceResponseListener = serviceResponseListener;
    }

    public void setupAppInfoService(ServiceResponseListener<GetInteractionResponse> serviceResponseListener) {
        this.appInfoServiceResponseListener = serviceResponseListener;
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        shutdown();  // TODO not warrantied to be called, so user should call shutdown; finalize works at all in Android???  I think no....
    }

    public void shutdown() {
        if (nodeMainExecutorService != null)
            nodeMainExecutorService.shutdownNodeMain(this);
        else
            Log.i("InteractionsMng", "Shutting down an uninitialized apps manager");
    }

    public void getAppsForRole(final MasterId masterId, final String role) {
        this.action = Action.GET_INTERACTIONS_FOR_ROLE;
        this.role = role;

        // If this is the first action requested, we need a connected node, what must be done in a different thread
        // The requested action will be executed once we have a connected node (this object itself) in onStart method
        if (this.connectedNode == null) {
            Log.i("InteractionsMng", "First action requested (" + this.action + "). Starting node...");
            new ConnectNodeThread(masterId).start();
        }
        else {
            // But we don't need all this if we already executed an action, and so have a connected node. Anyway,
            // we must execute any action asynchronously to avoid the android.os.NetworkOnMainThreadException
            new AsyncTask<Void, Void, Void>() {
                @Override
                protected Void doInBackground(Void... params) {
                    getAppsForRole();
                    return null;
                }
            }.execute();  // TODO: can we use this to incorporate a timeout to service calls?
        }
    }

    public void requestAppUse(final MasterId masterId, final String role, final rocon_interaction_msgs.Interaction app) {
        this.action = Action.REQUEST_INTERACTION_USE;
        this.role = role;
        this.app  = app;
        this.app_hash = app.getHash();

        // If this is the first action requested, we need a connected node, what must be done in a different thread
        // The requested action will be executed once we have a connected node (this object itself) in onStart method
        if (this.connectedNode == null) {
            Log.i("InteractionsMng", "First action requested (" + this.action + "). Starting node...");
            new ConnectNodeThread(masterId).start();
        }
        else {
            // But we don't need all this if we already executed an action, and so have a connected node. Anyway,
            // we must execute any action asynchronously to avoid the android.os.NetworkOnMainThreadException
            new AsyncTask<Void, Void, Void>() {
                @Override
                protected Void doInBackground(Void... params) {
                    requestAppUse();
                    return null;
                }
            }.execute();
        }
    }

    public void getAppInfo(final MasterId masterId, final int hash) {
        this.action = Action.GET_INTERACTION_INFO;
        this.app_hash = hash;

        // If this is the first action requested, we need a connected node, what must be done in a different thread
        // The requested action will be executed once we have a connected node (this object itself) in onStart method
        if (this.connectedNode == null) {
            Log.i("InteractionsMng", "First action requested (" + this.action + "). Starting node...");
            new ConnectNodeThread(masterId).start();
        }
        else {
            // But we don't need all this if we already executed an action, and so have a connected node. Anyway,
            // we must execute any action asynchronously to avoid the android.os.NetworkOnMainThreadException
            new AsyncTask<Void, Void, Void>() {
                @Override
                protected Void doInBackground(Void... params) {
                    getAppInfo();
                    return null;
                }
            }.execute();  // TODO: can we use this to incorporate a timeout to service calls?
        }
    }

    private void getAppsForRole() {
        // call get_roles_and_apps concert service
        ServiceClient<GetInteractionsRequest, GetInteractionsResponse> srvClient;
        String serviceName = this.interactionsNamespace + "/get_interactions";

        try {
            Log.i("InteractionsMng", "List interactions service client created [" + serviceName + "]");
            srvClient = connectedNode.newServiceClient(serviceName, GetInteractions._TYPE);
        } catch (ServiceNotFoundException e) {
            Log.i("InteractionsMng", "List interactions service not found [" + serviceName + "]");
            throw new RosRuntimeException(e); // TODO we should recover from this calling onFailure on listener
        }
        final GetInteractionsRequest request = srvClient.newMessage();

        request.getRoles().add(role);
        request.setUri(ANDROID_PLATFORM_INFO.getUri());

        srvClient.call(request, getAppsServiceResponseListener);
        Log.i("InteractionsMng", "List interactions service call done [" + serviceName + "]");
    }

    private void requestAppUse() {
        // call request_interaction concert service
        ServiceClient<RequestInteractionRequest, RequestInteractionResponse> srvClient;
        String serviceName = this.interactionsNamespace + "/request_interaction";
        try {
            Log.i("InteractionsMng", "Request app service client created [" + serviceName + "]");
            srvClient = connectedNode.newServiceClient(serviceName, RequestInteraction._TYPE);
        } catch (ServiceNotFoundException e) {
            Log.i("InteractionsMng", "Request app service not found [" + serviceName + "]");
            throw new RosRuntimeException(e); // TODO we should recover from this calling onFailure on listener
        }
        final RequestInteractionRequest request = srvClient.newMessage();

        request.setRemocon(this.remocon_name);
        request.setHash(this.app.getHash());

        srvClient.call(request, requestServiceResponseListener);
        Log.i("InteractionsMng", "Request app service call done [" + serviceName + "]");
    }

    private void getAppInfo() {
        // call get_app concert service
        ServiceClient<GetInteractionRequest, GetInteractionResponse> srvClient;
        String serviceName = this.interactionsNamespace + "/get_interaction";
        try {
            Log.i("InteractionsMng", "Get app info service client created [" + serviceName + "]");
            srvClient = connectedNode.newServiceClient(serviceName, GetInteraction._TYPE);
        } catch (ServiceNotFoundException e) {
            Log.i("InteractionsMng", "Get app info not found [" + serviceName + "]");
            throw new RosRuntimeException(e); // TODO we should recover from this calling onFailure on listener
        }
        final GetInteractionRequest request = srvClient.newMessage();
        request.setHash(this.app_hash);

        srvClient.call(request, appInfoServiceResponseListener);
        Log.i("InteractionsMng", "Get app info service call done [" + serviceName + "]");
    }

    private class ConnectNodeThread extends Thread {
        private MasterId masterId;

        public ConnectNodeThread(MasterId masterId) {
            this.masterId = masterId;
            setDaemon(true);
            setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
                @Override
                public void uncaughtException(Thread thread, Throwable ex) {
                    failureCallback.handleFailure("exception: " + ex.getMessage());
                }
            });
        }

        @Override
        public void run() {
            try {
                URI concertUri = new URI(masterId.getMasterUri());

                // Check if the master exists by looking for a master parameter
                // getParam throws when it can't find the parameter (DJS: what does it throw?).
                // Could get it to look for a hardcoded rocon parameter for extra guarantees
                // (e.g. /rocon/version) however we'd still have to do some checking below
                // when the info is there but interactions not.
                ParameterClient paramClient = new ParameterClient(
                        NodeIdentifier.forNameAndUri("/concert_checker", concertUri.toString()), concertUri);
                String name = (String) paramClient.getParam(GraphName.of("/rosversion")).getResult();
                Log.i("Remocon", "Concert " + name + " found; retrieve additional information");

                nodeMainExecutorService = new NodeMainExecutorService();
                NodeConfiguration nodeConfiguration = NodeConfiguration.newPublic(
                        InetAddressFactory.newNonLoopback().getHostAddress(), concertUri);
                nodeMainExecutorService.execute(InteractionsManager.this, nodeConfiguration.setNodeName("apps_manager_node"));

            } catch (URISyntaxException e) {
                Log.i("InteractionsMng", "invalid concert URI [" + masterId.getMasterUri() + "][" + e.toString() + "]");
                failureCallback.handleFailure("invalid concert URI");
            } catch (RuntimeException e) {
                // thrown if concert could not be found in the getParam call (from java.net.ConnectException)
                Log.i("InteractionsMng", "could not find concert [" + masterId.getMasterUri() + "][" + e.toString() + "]");
                failureCallback.handleFailure(e.toString());
            } catch (Throwable e) {
                Log.i("InteractionsMng", "exception while creating node in concert checker for URI " + masterId.getMasterUri(), e);
                failureCallback.handleFailure(e.toString());
            }
        }
    }

    @Override
        public GraphName getDefaultNodeName() {
                return null;
        }

        @Override
        public void onStart(final ConnectedNode connectedNode) {
        if (this.connectedNode != null) {
            Log.e("InteractionsMng", "App manager re-started before previous shutdown; ignoring...");
            return;
        }

        this.connectedNode = connectedNode;

        Log.i("InteractionsMng", "onStart() - " + action);

        switch (action) {
            case NONE:
                Log.i("InteractionsMng", "Node started without specifying an action");
                break;
            case REQUEST_INTERACTION_USE:
                requestAppUse();
                break;
            case GET_INTERACTIONS_FOR_ROLE:
                getAppsForRole();
                break;
            case GET_INTERACTION_INFO:
                getAppInfo();
                break;
            default:
                Log.i("InteractionsMng", "Unrecognised action requested: " + action);
        }

        Log.i("InteractionsMng", "Done");
        }

    @Override
    public void onShutdown(Node node) {
        Log.i("InteractionsMng", "Shutdown connected node...");
        super.onShutdown(node);

        // Required so we get reconnected the next time
        this.connectedNode = null;
        Log.i("InteractionsMng", "Done; shutdown apps manager node main");
    }

    @Override
    public void onShutdownComplete(Node node) {
        super.onShutdownComplete(node);
    }

    @Override
    public void onError(Node node, Throwable throwable) {
        super.onError(node, throwable);

        Log.e("InteractionsMng", node.getName().toString() + " node error: " + throwable.getMessage());
        failureCallback.handleFailure(node.getName().toString() + " node error: " + throwable.toString());
    }
}