Rosbridge 2.0 in Java

edit

Check out https://github.com/WPI-RAIL/jrosbridge/ . Documentation is still a work in progress but the API itself is pretty easy to follow! Tested on Ubuntu and Windows with OpenJDK and Oracle's JDK.

All you need to do is include any websocket library into your Java project. I use the Tyrus implementation. https://java.net/projects/tyrus

as an example I implemented a small programm that promt for text input and send it to a topic in ros as std_msgs/String

package myPack;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;

import javax.websocket.ContainerProvider;
import javax.websocket.DeploymentException;
import javax.websocket.EncodeException;
import javax.websocket.Session;
import javax.websocket.WebSocketContainer;

import org.json.JSONException;

public class App {

    public Session session;
    public static MyClient myClient = new MyClient();

    protected void start()
             {

            WebSocketContainer container = ContainerProvider.getWebSocketContainer();

            String uri = "ws://localhost:9090";
            System.out.println("Connecting to " + uri);
            try {
                session = container.connectToServer(myClient, URI.create(uri));
            } catch (DeploymentException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }            

    }
    public static void main(String args[]) throws JSONException, EncodeException, IOException{
        App client = new App();
        client.start();
        //myClient.subscribe("/face_detection","std_msgs/String");
        //myClient.subscribe("/face_detection","std_msgs/String");

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = "";
        try {
            do{
                input = br.readLine();
                if(!input.equals("exit")){
                    myClient.publish("/speech",input);
                }
            }while(!input.equals("exit"));

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

And the class myclient

package myPack;

import java.io.IOException;

import javax.websocket.ClientEndpoint;
import javax.websocket.EncodeException;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import org.json.JSONException;
import org.json.JSONObject;

@ClientEndpoint
public class MyClient {

    Session _session;
    JSONObject _message = new JSONObject();
    JSONObject _messageData = new JSONObject();

    @OnOpen
    public void onOpen(Session session) throws JSONException, IOException, EncodeException {
        _session = session;
        System.out.println("Connected to endpoint: " + session.getBasicRemote());
    }

    @OnMessage
    public void onMessage(String message) throws JSONException, IOException, EncodeException {
        _message = new JSONObject(message);
        System.out.println((_message.getJSONObject("msg")).getString("data"));
        switch((_message.getJSONObject("msg")).getString("data")){
        case "FaceAppeared":
            publish("/speech","Hello");
            break;
        case "FaceDisappeared":
            publish("/speech","See you");
            break;                  
        }               
    }

    @OnError
    public void onError(Throwable t) {
        t.printStackTrace();
    }


    public void subscribe(String topic,String type) throws JSONException, IOException, EncodeException {
        _message = new JSONObject();
        _message.put("op", "subscribe");
        _message.put("topic", topic);
        _message.put("type", type);
        _session.getBasicRemote().sendObject(_message);     
    }
    public void publish(String topic,String messageData) throws JSONException, IOException, EncodeException {
        _message = new JSONObject();
        _messageData = new JSONObject();
        _message.put("op", "publish");
        _messageData.put("linear",messageData);
        _message.put("msg",_messageData);
        _message.put("topic", topic);
        _session.getBasicRemote().sendObject(_message);     
        System.out.println("Send Message "+_message);
    }

}

The method onMessage is always called when a topic that your java programm subscribed for through rosbridge is sending something. You can then check first from what topic it came and what to do (in my case I just checked the content of the message, sent when a face appears or disappears from the webcam field of view)

To publish something from your java programm you just use the publish function that I added to the class.

Of course don't forget to start the rosbridge server first.