Introduction to WebSockets: Revolutionizing Real-Time Communication

In the ever-evolving landscape of web development, the need for real-time communication between clients and servers has become increasingly crucial. Traditional HTTP (Hypertext Transfer Protocol) connections have served us well for many years, but they are not optimized for handling real-time data streams. This is where WebSockets come into play, providing a more efficient and seamless approach to bidirectional communication.


What are WebSockets?

Websockets are a communication protocol that enables real-time, full-duplex communication between a client and a server over a single, long-lived connection. Unlike HTTP, which follows a request-response paradigm, WebSockets allows both the client and server to send and receive data at any time without the need for multiple connections.

How do WebSockets work?

The WebSocket protocol begins with a handshake initiated by the client, which requests an upgrade from the standard HTTP connection to a WebSocket connection. If the server supports Websockets, it acknowledges the request, and the connection is upgraded. This handshake is crucial as it ensures compatibility between the client and server.

Once the WebSocket connection is established, data can be transmitted back and forth between the client and server using a simple message-based system. Messages can be sent in either direction, and the connection remains open until either the client or server decides to close it.


Advantages of Websockets

1. Real-time Updates: WebSockets facilitate instant data transfer, making them ideal for applications requiring real-time updates, such as chat applications, online gaming, stock market monitoring, and collaborative tools.

2. Reduced Latency: Unlike traditional HTTP connections, where the client has to request data from the server continually, WebSockets establish a persistent connection, reducing latency and overhead.

3. Bi-directional Communication: WebSockets enable both the client and server to send data independently, allowing for more dynamic and interactive applications.

4. Efficient Resource Utilization: The persistent nature of Websockets reduces the need for repeated handshakes, minimizing server load and conserving resources.

5. Cross-Domain Support: WebSockets support cross-domain communication, enabling seamless integration between different applications and services.


Websockets and Security

While WebSockets offer powerful capabilities, they also introduce potential security concerns. Developers must be vigilant about implementing proper security measures to prevent issues like data tampering, cross-site scripting (XSS), and other attacks. Using secure WebSocket connections (wss://) with SSL/TLS encryption is essential for protecting sensitive data.

WebSockets Implementation on Android

Attach maven repo on build.gradle or settings.gradle



maven { url 'https://jitpack.io' }


Step 1: Add WebSockets Library

AAR file link if gradle sync failure

AAR file click to download

dependencies {   
  implementation files('libs/NaikSoftwareStompProtocolAndroid-1.6.6.aar')
  }

On AndroidProject 

Create a "libs" folder then Add that AAR file

__________________


build.gradle
api "com.github.NaikSoftware:StompProtocolAndroid:1.6.4"
api "io.reactivex.rxjava2:rxjava:2.2.5"

Step 2: Request Internet Permission:

AndroidManifest.xml 
<uses-permission android:name="android.permission.INTERNET" />

Step 3: Establish WebSocket Connection


MainActivity.java
Attach this code on OnCreate
StompClient stompClient = Stomp.over(Stomp.ConnectionProvider.OKHTTP, "wss://your -url.com");
stompClient.connect();
StompUtils.lifecycle(stompClient);

Step 4: Create a StompUtils.java file


StompUtils.java
public class StompUtils {
@SuppressWarnings({"ResultOfMethodCallIgnored", "CheckResult"})
public static void lifecycle(StompClient stompClient) {
stompClient.lifecycle().subscribe(lifecycleEvent -> {
switch (lifecycleEvent.getType()) {
case OPENED:
               Log.d("stomp","Stomp connection opened");break;
case ERROR:
               Log.d("Error",lifecycleEvent.getException().toString()); break;
 case CLOSED:
                Log.d("stomp closed","Stomp connection closed");  break;
            }});}}

Step 5: Subscribe to the topic with the destination

MainActivity.java
Attach this code on OnCreate
stompClient.topic("/root_path/your-path/your-id").subscribe(stompMessage -> {  JSONObject jsonObject = new JSONObject(stompMessage.getPayload());
            Log.i(Const.TAG, "Receive: " + stompMessage.getPayload());
            runOnUiThread(() -> {
                try { Log.d("wsTAG",jsonObject.getString("message") + "\n");
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            });
        });

Step 6: Send a message to the path

MainActivity.java
Attach this code on OnClick
stompClient.send("/path/path_name", "your message").subscribe();

Follow this link for GitHub Repo


Conclusion

Websockets have revolutionized the way real-time communication is handled on the web. With their ability to provide low-latency, bidirectional, and persistent connections, Websockets have become an essential tool for building interactive and dynamic web applications. As web technologies continue to evolve, Websockets will likely remain a critical component in creating cutting-edge, real-time experiences for users across the globe.