Socket is a combination of IP address and port number used to establish connections between devices on a network. There are two main types of sockets: datagram sockets which use UDP and are not fully reliable, and stream sockets which use TCP and provide reliable transmission. Socket.io is a library that enables real-time bidirectional communication between clients and servers using websockets. It has client-side and server-side components, and is commonly used for building applications with real-time features like chats.

2. What are sockets?
Socket is a combination of an IP address and a port number
Socket example: 192.168.0.1:80
Sockets have two types:
Datagram sockets
● Use UDP for data transmission.
● Not 100% reliable and may lose data.
● Data sent/received order might not be the same
● Don't care or rapid recovering lost/mistaken data
Stream sockets
● Use TCP protocol for data transmission.
● Reliable and Lossless.
● Data sent/received in the similar order.
● Long time for recovering lost/mistaken
data
Socket usage in Android: Push notifications

3. WebSockets
Communication protocol providing full-duplex communication
channels over a single TCP connection.
The WebSocket protocol enables interaction between a client
and a web server with lower overheads, facilitating real-time
data transfer from and to the server.
The communications are done over TCP port number 80 (or 443
in the case of TLS-encrypted connections)
The WebSocket Protocol has two parts: a handshake to
establish the upgraded connection, then the actual data transfer.
Client handshake
Server response

4. What is Socket.io?
Socket.io is a library ported from javascript to java for real-time applications.
It enables real-time, bi-directional communication between clients and servers.
It has two parts: client-side library which used in Android and server-side library
for Node.js.
Example of real-time applications: chats, trading apps.

5. Getting started

6. Add dependency
implementation(“io.socket:socket.io-client:$socketIoVersion”) {
// excluding org.json which is provided by Android
exclude group: 'org.json', module: 'json'
}

7. Add internet permission into manifest
<uses-permission android:name="android.permission.INTERNET" />

8. Create service which handle sockets and declare it into manifest
<manifest
...
<application
…
<service
android:name=".network.service.SocketService"
android:exported="false" />
...
</application>
</manifest>

9. Preparing socket.io client

10. IO.Options
Options class represents object with default parameters for socket client
forceNew - is need to create new connection each time.
reconnection - is reconnection allowed.
reconnectionAttempts - reconnection attempts number.
reconnectionDelay - delay before each reconnection attempt.
reconnectionDelayMax - maximum delay before each reconnection attempt.
transports - List of transport names.
hostname - host name.
secure - is connection secured
port - port of sockets, if secured connection default port = 443 else 80

11. Options creation example
val options = IO.Options()
with(options) {
forceNew = true
secure = true
transports = arrayOf("websocket")
reconnectionDelay = 2000L
reconnectionDelayMax = 5000L
}

12. Initializing of socket client
Socket client have 2 parameters for initialization url (URI or String) and optional
parameter Options with socket parameters
var socket: Socket? = IO.socket(url, options)
?: IO.socket(uri, options)
?: IO.socket(url)
?: IO.socket(uri)

13. Connecting/Disconnecting
Usually called in onCreate() method of service
socket.connect()
Usually called in onDestroy() method of service
socket.disconnect()

14. Socket events

15. Start event listening
socket.on(“Event name”, Emitter.Listener listener)
Emitter.Listener - interface where we receive response from our events. In this
listener we receive vararg arguments:Any
// example of event
socket.on(“some event name”, { /*do something with received data*/ })

16. One time listener
If there was an event which we need to listen only once and then unsubscribe
from it we can to use socket.once(“Event name”, Emitter.Listener listener)
// example of event
socket.once(“some event name”, { /*do something with received data*/ })
After event received we unsubscribe from this event automatically.

17. Stop listening event
socket.off(“Event name”, Emitter.Listener listener)
or
socket.off(“Event name”) to remove all listeners of the specified event.
or
socket.off() to remove all registered listeners

18. Send an event
socket.emit(“Event name”, vararg arguments: Any)
vararg arguments: Any - arguments to emitting event, it most of cases this will be
json
socket.emit(“some event name”, “{“id”:1, “name”: “Some name”}”)

19. Default events
Socket.io already have default listened events
EVENT_OPEN = “open” - fired when socket open
EVENT_PACKET = “packet” - fired when packet received. Packet object represents any received event
such as “connect”, “disconnect”,”event” etc.
EVENT_CLOSE = “close” - fired when socket closed

20. Heartbeat events
Heartbeat protocol generally used to negotiate and monitor the availability of a
resource
socket.on(Socket.EVENT_PING, { }) Fired when a ping packet is written out to the server.
socket.on(Socket.EVENT_PONG, { /* here we receive latency */ }) Fired when a pong is received from the
server. Also we receive latency.

21. Under the box
Socket.io works under the okhttp3 WebSocket client for websocket transport
and HttpUrlConnection for polling transport
When socket connection opened socket.io emmits handshake event with received
handshake data from server which sets ping interval and ping timeout for
heartbeat event.
All tasks run with EventThread class which handles all socket.io events

22. Stored events
All event listeners stored in ConcurrentMap<String, ConcurrentLinkedQueue<Listener>>
All this listeners can be received by method socket.listeners(String event) which
return list of listeners which subscribed to event.

23. Best practice
● Create service for handle socket connection, with this way you can create
socket connection only once and use it in your whole app
● Close socket connection when you don’t need them, it reduce battery usage
● Unsubscribe from unnecessary events
● Use “once” listener for events which need to handle only once, this event will
be unsubscribed automatically