Microsoft has just released a Java SignalR SDK which allows Java and Android clients to access ASP.NET SignalR back ends. The library is open source, and currently it is up to you to build the .jar packages yourself. For your convenience I’ve uploaded my built .jar files. Given that this library as of yet is still fairly undocumented, and I spent quite some time on getting it up and running, I figured I’d provide a short introduction tutorial here. I found the C# SignalR client documentation to be the most useful while figuring out the API as the classes and methods overall seem to correspond. The tests in the GitHub repository are another useful resource. I’ll mainly be focusing on the specific differences in the Java library, and refer you to the original documentation for more elaborate information.
We will create a simple Hub supporting bidirectional communication. A quick and easy way to get a C# back end up and running for the purpose of this tutorial is to self-host a SignalR server in a simple console or WPF application. The following C# code shows a simple hub with one method which can be called by the Java client, SendMessage.
public class MessageHub : Hub
{
public static event Action<string, string> MessageReceived = delegate { };
public void SendMessage( string name, string message )
{
MessageReceived( name, message );
}
}
I added a static event handler which can be consumed by the console or WPF front end to display the received message. SendMessage is called from a different thread, so in case you want to update the UI, don’t forget to use a dispatcher!
MessageHub.MessageReceived += ( name, message ) => _dispatcher.Invoke(
() => { MessageBox.Content = String.Format( "{0} said {1}", name, message ); } );
Onwards to the client side code! To set up a Java project which can use the SignalR client API, add the ‘signalr-client-sdk.jar’ and ‘gson-2.2.2.jar’ to the project build path. For Android projects the references need to be added differently. Drag the two jars, and the additional ‘signalr-client-sdk-android.jar’ to the libs folder in Eclipse. By doing so they will automatically be added as Android libraries.
As mentioned before, the SignalR Java client follows the same structure as the C# client API, thus setting up a connection is quite similar. However, for Android applications an additional platform component needs to be loaded as shown below; also don’t forget to add internet permission to your manifest file, or you will receive a SocketException when trying to connect.
Platform.loadPlatformComponent( new AndroidPlatformComponent() ); // Change to the IP address and matching port of your SignalR server. String host = "http://192.168.0.xxx:8080"; HubConnection connection = new HubConnection( host ); HubProxy hub = connection.createHubProxy( "MessageHub" );
This simply configures the connection. Establishing the actual connection is somewhat different than the C# documentation due to limitations of Java. To mimic language support for async in C#, the SignalRFuture class is introduced. Asynchronous operations return an instance of this class, without actually performing any real work yet. What follows is example code of how to start the connection synchronously by calling get() on the SignalRFuture. Don’t forget to cleanly stop() the connection when shutting down the application.
SignalRFuture<Void> awaitConnection = connection.start();
try {
awaitConnection.get();
} catch (InterruptedException e) {
// Handle ...
} catch (ExecutionException e) {
// Handle ...
}
In case your server is up and running, you should now be ready to start listening to and submitting messages. Again, listening to events in C# is more straightforward since it supports lambdas as the C# client API documentation demonstrates.
stockTickerHubProxy.On<Stock>( "UpdateStockPrice", stock => Console.WriteLine(
"Stock update for {0} new price {1}", stock.Symbol, stock.Price) );
Doing something similar in Java requires elaborate inline anonymous classes, or the creation of a handler class per event you want to listen to. Suppose the server would send a message “context.Clients.All.UpdateStatus( “Online” );”, handling this the ‘C# way’ would like as follows:
hub.on( "UpdateStatus",
new SubscriptionHandler<String>() {
@Override
public void run( String status ) {
// Since we are updating the UI,
// we need to use a handler of the UI thread.
final String fStatus = status;
handler.post( new Runnable() {
@Override
public void run() {
statusField.setText( fStatus );
}
} );
}
}
, String.class );
Therefore, Microsoft has seemingly added a method not available in the C# API to the Java client. Calling hub.subscribe( listener ) where listener is an object implementing corresponding methods for every available incoming event is a much more straightforward way to listen to messages. Under the covers this uses reflection to hook everything up correctly. These methods need to be public!
hub.subscribe( this );
...
public void UpdateStatus( String status )
{
final String fStatus = status;
handler.post(new Runnable(){
@Override
public void run() {
statusField.setText( fStatus );
}});
}
More complex types work as well, as long as it is supported by JSON. I don’t know the specifics, but this will be dependent on the SignalR server and the gson library used by the SignalR Java client. The following code prepares the client to call a new method on the server which you can add to the MessageHub: “public void SendCustomType( CustomType object ) { … }“.
// A simple C# class which can be sent over SignalR.
public class CustomType
{
public string Name;
public int Id;
}
// The same type as defined in Java.
public class CustomType
{
public String Name;
public int Id;
}
Finally, calling the earlier SendMessage() and the newly added SendCustomType() can be done as follows. As you can see, remote method invocation again returns a SignalRFuture, and a subsequent get() is needed.
try {
hub.invoke( "SendMessage", "Client", "Hello world!" ).get();
hub.invoke( "SendCustomType",
new CustomType() {{ Name = "Universe"; Id = 42; }} ).get();
} catch (InterruptedException e) {
// Handle ...
} catch (ExecutionException e) {
// Handle ...
}
Similarly, you can simply pass custom objects from the server to the client by adding the custom type as a method parameter: “public void SomeMethod( CustomType bleh ) { … }“
whatheco.de 