Native java and android client for socketcluster framework in node.js
Branch: master
Clone or download
sacOO7 Merge pull request #42 from aveworks/fix-concurrency-issues
Use ConcurrentHashMap to avoid any concurrency issue
Latest commit 10f1e95 Nov 3, 2018
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.idea bumped up version, updated readme Mar 18, 2018
gradle/wrapper added remaining intelliJ specific idea and gradle files Mar 18, 2018
src/main/java Merge pull request #42 from aveworks/fix-concurrency-issues Nov 3, 2018
.gitignore Sachin | Updated gitignore, ignoring every file under .idea Jun 25, 2018
LICENSE.txt Update LICENSE.txt Dec 5, 2016
README.md added public link to the jar artifacts Jun 29, 2018
build.gradle Sachin | Bumped up and published version to 1.7.5, published new arti… Jun 26, 2018
gradlew
gradlew.bat Implemented handshake and some basic emitters Nov 8, 2016
settings.gradle Implemented handshake and some basic emitters Nov 8, 2016

README.md

Java and Android Socketcluster Client

Overview

This client provides following functionality

  • Support for emitting and listening to remote events
  • Automatic reconnection
  • Pub/sub
  • Authentication (JWT)

License

Apache License, Version 2.0

Gradle

For java

dependencies {
    compile 'io.github.sac:SocketclusterClientJava:1.7.5'
}

for sample java examples visit Java Demo

For android

compile ('io.github.sac:SocketclusterClientJava:1.7.5'){
        exclude group :'org.json', module: 'json'
}

for sample android demo visit Android Demo

Download

Description

Create instance of Socket class by passing url of socketcluster-server end-point

    //Create a socket instance
    String url="ws://localhost:8000/socketcluster/";
    Socket socket = new Socket(url);
     

Important Note : Default url to socketcluster end-point is always ws://somedomainname.com/socketcluster/.

Registering basic listeners

Implemented using BasicListener interface

        socket.setListener(new BasicListener() {
        
            public void onConnected(Socket socket,Map<String, List<String>> headers) {
                System.out.println("Connected to endpoint");
            }

            public void onDisconnected(Socket socket,WebSocketFrame serverCloseFrame, WebSocketFrame clientCloseFrame, boolean closedByServer) {
                System.out.println("Disconnected from end-point");
            }

            public void onConnectError(Socket socket,WebSocketException exception) {
                System.out.println("Got connect error "+ exception);
            }

            public void onSetAuthToken(String token, Socket socket) {
                System.out.println("Token is "+ token);
            }

            public void onAuthentication(Socket socket,Boolean status) {
                if (status) {
                    System.out.println("socket is authenticated");
                } else {
                    System.out.println("Authentication is required (optional)");
                }
            }

        });

Connecting to server

  • For connecting to server:
    //This will send websocket handshake request to socketcluster-server
    socket.connect();
  • For connecting asynchronously to server:
    //This will send websocket handshake request to socketcluster-server
    socket.connectAsync();
  • By default reconnection to server is not enabled , to enable it :
    //This will set automatic-reconnection to server with delay of 2 seconds and repeating it for 30 times
    socket.setReconnection(new ReconnectStrategy().setDelay(2000).setMaxAttempts(30));
    socket.connect();
  • To disable reconnection :
   socket.setReconnection(null); 
  • By default logging of messages is enabled ,to disable :
   socket.disableLogging();

Emitting and listening to events

Event emitter

  • eventname is name of event and message can be String, boolean, Long or JSON-object
    socket.emit(eventname,message);
    
    //socket.emit("chat","Hi");
  • To send event with acknowledgement
    socket.emit(eventname, message, new Ack() {
                public void call(String eventName,Object error, Object data) {
                    //If error and data is String
                    System.out.println("Got message for :"+eventName+" error is :"+error+" data is :"+data);
                }
        });

Event Listener

  • For listening to events :

The object received can be String, Boolean, Long or JSONObject.

    socket.on(eventname, new Emitter.Listener() {
                public void call(String eventName,Object object) {
                    
                    // Cast object to its proper datatype
                    System.out.println("Got message for :"+eventName+" data is :"+data);
                }
        }); 
  • To send acknowledgement back to server
    socket.on(eventname, new Emitter.AckListener() {
            public void call(String eventName,Object object, Ack ack) {
                
                // Cast object to its proper datatype                     
                System.out.println("Got message :: " + object);
                /...
                    Some logic goes here
                .../
                if (error){
                
                ack.call(eventName,error,null);
                
                }else{
                
                //Data can be of any data type
                
                ack.call(eventName,null,data);
                }
                
                //Both error and data can be sent to server
                
                ack.call(eventName,error,data);
            }
        });
        

Implementing Pub-Sub via channels

Creating channel

  • For creating and subscribing to channels:
    Socket.Channel channel = socket.createChannel(channelName);
    //Socket.Channel channel = socket.createChannel("yolo"); 
    
    
    /**
     * without acknowledgement
     */
     channel.subscribe();
     
    /**
     * with acknowledgement
     */
     
    channel.subscribe(new Ack() {
                public void call(String channelName, Object error, Object data) {
                    if (error == null) {
                        System.out.println("Subscribed to channel "+channelName+" successfully");
                    }
                }
        });
  • For getting list of created channels :
    List <Socket.Channel> channels=socket.getChannels();
  • To get channel by name :
        Socket.Channel channel=socket.getChannelByName("yolo");
        //Returns null if channel of given name is not present
        

Publishing event on channel

  • For publishing event :
       // message can have any data type
    /**
     * without acknowledgement
     */
     channel.publish(message);
     
    /**
     * with acknowledgement
     */
       channel.publish(message, new Ack() {
                public void call(String channelName,Object error, Object data) {
                    if (error == null) {
                        System.out.println("Published message to channel "+channelName+" successfully");
                    }
                }
        });
        

Listening to channel

  • For listening to channel event :
    channel.onMessage(new Emitter.Listener() {
             public void call(String channelName , Object object) {
                
                 System.out.println("Got message for channel "+channelName+" data is "+data);
                 
             }
         });

Un-subscribing to channel

    /**
     * without acknowledgement
     */
     
     channel.unsubscribe();
     
    /**
     * with acknowledgement
     */
     
    channel.unsubscribe(new Ack() {
                public void call(String channelName, Object error, Object data) {
                    if (error == null) {
                        System.out.println("channel unsubscribed successfully");
                    }
                }
        });    

Handling logging

  • Once logger object is received, it is very easy to set internal logging level of library, applying handler for each log messages.
  • It can be received using following code
    Logger logger = socket.getLogger();

Handling SSL connection with server

WebSocketFactory class is responsible for creating websocket instances and handling settings with server, for more information visit here

To get instance of WebSocketFactory class :

   
    WebSocketFactory factory=socket.getFactorySettings();
    

The following is an example to set a custom SSL context to a WebSocketFactory instance. (Again, you don't have to call a setSSL* method if you use the default SSL configuration.)

// Create a custom SSL context.
SSLContext context = NaiveSSLContext.getInstance("TLS");

// Set the custom SSL context.
factory.setSSLContext(context);

NaiveSSLContext used in the above example is a factory class to create an SSLContext which naively accepts all certificates without verification. It's enough for testing purposes. When you see an error message "unable to find valid certificate path to requested target" while testing, try NaiveSSLContext.

Setting HTTP proxy with server

If a WebSocket endpoint needs to be accessed via an HTTP proxy, information about the proxy server has to be set to a WebSocketFactory instance before creating a WebSocket instance. Proxy settings are represented by ProxySettings class. A WebSocketFactory instance has an associated ProxySettings instance and it can be obtained by calling WebSocketFactory.getProxySettings() method.

// Get the associated ProxySettings instance.
ProxySettings settings = factory.getProxySettings();

ProxySettings class has methods to set information about a proxy server such as setHost method and setPort method. The following is an example to set a secure (https) proxy server.

// Set a proxy server.
settings.setServer("https://proxy.example.com");

If credentials are required for authentication at a proxy server, setId method and setPassword method, or setCredentials method can be used to set the credentials. Note that, however, the current implementation supports only Basic Authentication.

// Set credentials for authentication at a proxy server.
settings.setCredentials(id, password);

Star the repo. if you love the client :).