End of Life for Twilio Programmable Video - Upgrade to VideoSDKLearn More

How to Integrate Socket.IO with Android?

Learn how to integrate Socket.IO with Android to enable real-time communication in your apps. This comprehensive guide covers setup, initialization, event handling, and troubleshooting.


Socket.IO is a popular library used for real-time communication in web applications, leveraging WebSocket as a transport layer and providing additional features to enhance reliability and performance. When it comes to Android development, integrating Socket.IO can enable features such as real-time messaging, live updates, and multiplayer gaming, making applications more interactive and dynamic. This article will guide you through the process of setting up and using Socket.IO in your Android applications, ensuring seamless real-time communication.

Benefits of Using Socket.IO in Android

Socket.IO offers several advantages for Android applications:
  • Low Latency Communication: Socket.IO ensures low-latency communication, which is crucial for real-time applications like chat apps and live notifications.
  • Event-Driven Architecture: With its event-driven model, Socket.IO allows developers to emit and listen to custom events, facilitating efficient communication between the client and server.
  • Automatic Reconnection: One of the standout features of Socket.IO is its ability to automatically reconnect in case of network disruptions, making it highly reliable for mobile environments.
  • Fallback Mechanisms: If a WebSocket connection cannot be established, Socket.IO falls back to HTTP long-polling, ensuring communication continuity even in restrictive network conditions.
In the following sections, we will delve into the practical aspects of integrating Socket.IO with your Android application, covering everything from initial setup to handling real-time events.

Implementation Guide of Socket.IO with Android

Before diving into the coding, it's essential to set up the development environment. Make sure you have Android Studio installed. The first step involves adding the necessary dependencies to your Android project.

Setting Up the Environment

Install Android Studio

Ensure you have the latest version of Android Studio installed.

Add Socket.IO Dependency

Open your build.gradle file and add the following dependency:
1    implementation ('io.socket:socket.io-client:2.0.0') {  
2        exclude group: 'org.json', module: 'json'  
3    }

Grant Internet Permission

To allow your app to connect to the internet, add the following permission to your AndroidManifest.xml file:


1    <manifest xmlns:android="http://schemas.android.com/apk/res/android">
2        <uses-permission android:name="android.permission.INTERNET" />
3    </manifest>
This setup ensures that your project can access Socket.IO and make network requests necessary for real-time communication.

Initializing Socket.IO Client in Android

With the dependencies and permissions in place, you can now initialize the Socket.IO client in your Android app.

Import Required Libraries

Start by importing the necessary libraries:


1    import io.socket.client.IO;
2    import io.socket.client.Socket;
3    import java.net.URISyntaxException;

Initialize the Socket Instance

Create a new instance of the Socket.IO client:


1    private Socket mSocket;
2    {
3        try {
4            mSocket = IO.socket("http://chat.socket.io");
5        } catch (URISyntaxException e) {
6            e.printStackTrace();
7        }
8    }

Connect the Socket

In your onCreate method, connect the socket to the server:


1    @Override
2    public void onCreate(Bundle savedInstanceState) {
3        super.onCreate(savedInstanceState);
4        mSocket.connect();
5    }
This code sets up the Socket.IO client and connects it to the specified server URL. The try-catch block handles potential URI syntax exceptions, ensuring the connection attempt does not crash the application.

Emitting Events

Once connected, you can emit events from the client to the server. This is crucial for sending data such as chat messages or updates.

Create a Method to Send Messages

Define a method to emit messages:


1    private void attemptSend() {
2        String message = mInputMessageView.getText().toString().trim();
3        if (TextUtils.isEmpty(message)) {
4            return;
5        }
7        mInputMessageView.setText("");
8        mSocket.emit("new message", message);
9    }

Handle Input Validation

The method checks if the input message is not empty before sending it. It uses the emit method of the Socket.IO client to send the message to the server under the event name "new message".

Listening for Events

Socket.IO allows you to listen for events emitted by the server, enabling real-time updates from other clients or the server itself.

Create a Listener for New Messages

Define a listener for the "new message" event:


1    private Emitter.Listener onNewMessage = new Emitter.Listener() {
2        @Override
3        public void call(final Object... args) {
4            getActivity().runOnUiThread(new Runnable() {
5                @Override
6                public void run() {
7                    JSONObject data = (JSONObject) args[0];
8                    String username;
9                    String message;
10                    try {
11                        username = data.getString("username");
12                        message = data.getString("message");
13                    } catch (JSONException e) {
14                        return;
15                    }
16                    // Add the message to the UI
17                    addMessage(username, message);
18                }
19            });
20        }
21    };

Register the Listener

In your onCreate method, register this listener:


1    @Override
2    public void onCreate(Bundle savedInstanceState) {
3        super.onCreate(savedInstanceState);
4        mSocket.on("new message", onNewMessage);
5        mSocket.connect();
6    }
The listener captures incoming messages and updates the UI accordingly. Wrapping the callback in runOnUiThread ensures that UI updates occur on the main thread, preventing threading issues.

Get Free 10,000 Minutes Every Months

No credit card required to start.

Handling Connection Issues

Ensuring a stable connection is vital for real-time applications. Socket.IO provides mechanisms to handle disconnections and reconnections gracefully.

Handle Disconnections

Define listeners for connection events:


1    mSocket.on(Socket.EVENT_DISCONNECT, new Emitter.Listener() {
2        @Override
3        public void call(Object... args) {
4            // Handle disconnection
5        }
6    });
7    mSocket.on(Socket.EVENT_RECONNECT, new Emitter.Listener() {
8        @Override
9        public void call(Object... args) {
10            // Handle reconnection
11        }
12    });

Manage Reconnection Attempts

The library automatically attempts to reconnect in case of network failures. You can configure reconnection attempts and intervals if needed:


1    IO.Options opts = new IO.Options();
2    opts.reconnectionAttempts = 5;
3    opts.reconnectionDelay = 1000; // 1 second
4    mSocket = IO.socket("http://chat.socket.io", opts);
These handlers ensure that your application can recover from network interruptions, maintaining a seamless user experience.


In this article, we’ve explored how to integrate Socket.IO into Android applications to enable real-time communication. Starting from setting up the development environment and adding the necessary dependencies, we moved through initializing the Socket.IO client, emitting events, and listening for server messages. Additionally, we covered handling connection issues to ensure your app remains robust and reliable even in fluctuating network conditions. By following these steps, you can leverage Socket.IO’s powerful features to enhance your Android app with real-time capabilities.

Want to level-up your learning? Subscribe now

Subscribe to our newsletter for more tech based insights