Android app can't connect to socket.io Golang server

I don't know if I'm missing something, because my Kotlin code isn't finding the Golang socket server. I did a netstat -ano and the port 8000 was being used for TCP already so I think the socket server is running fine. But my android still can't find it. Both the server and the emulator is on the same network. Here's my code:

//server(Golang)

import (
	"fmt"
	"net/http"

	socketio "github.com/googollee/go-socket.io"
	"github.com/googollee/go-socket.io/engineio"
	"github.com/googollee/go-socket.io/engineio/transport"
	"github.com/googollee/go-socket.io/engineio/transport/polling"
	"github.com/googollee/go-socket.io/engineio/transport/websocket"
)

server := socketio.NewServer(&engineio.Options{
	Transports: []transport.Transport{
		&polling.Transport{
			CheckOrigin: allowOriginFunc,
		},
		&websocket.Transport{
			CheckOrigin: allowOriginFunc,
		},
	},
})

server.OnConnect("/", func(s socketio.Conn) error {
	s.SetContext("")
	fmt.Println("connected:", s.ID())
	return nil
})

server.OnEvent("/", "notice", func(s socketio.Conn, msg string) {
	fmt.Println("notice:", msg)
	s.Emit("reply", "have "+msg)
})

server.OnError("/", func(s socketio.Conn, e error) {
	fmt.Println("meet error:", e)
})

server.OnDisconnect("/", func(s socketio.Conn, reason string) {
	fmt.Println("closed", reason)
})

go server.Serve()
defer server.Close()

http.Handle("/socket.io/", server)
http.Handle("/", http.FileServer(http.Dir("./asset")))

fmt.Println("ScktSrv Serving at localhost:8000...")
fmt.Print(http.ListenAndServe(":8000", nil))

//android(Kotlin)

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

implementation ('io.socket:socket.io-client:2.0.0') {
	exclude group: 'org.json', module: 'json'
}

try {
	mSocket = IO.socket("http://localhost:8000/skt")
	Log.d(TAG, "success: ${mSocket.id()}")
} catch (e: Exception) {
	e.localizedMessage?.let { Log.e(TAG, it) }
}

mSocket.connect()
mSocket.on(Socket.EVENT_CONNECT, onConnect)
mSocket.on("reply", onReply)

private var onConnect = Emitter.Listener {
	Log.i(TAG, "onConnect")
	mSocket.emit("notice", "{\"relay_num\": 4, \"to_status\": 1}")
}

private var onReply = Emitter.Listener {
	Log.i(TAG, "replyMsg: ${it[0]}")
}

UPDATE:

Before @dev.bmax's answer, I already found out something about enabling cleartexttraffic and already added android:usesCleartextTraffic="true" on my AndroidManifest.xml, but the app still can't connect to the server. Socket.connected() returns false right now.

Also, how should you actually connect to the server? Do I just need http://10.0.2.2:8000 without any path?

UPDATE:

I just noticed that I keep getting a log that looks like this:

tagSocket(6) with statsTag=0xffffffff, statsUid=-1

And it keeps popping up on the logcat

UPDATE:

I looked around for other code, and I found a working one. Which fortunately or unfortunately, is quite simple. Here's the codes I found:

//Golang

listener, _ := net.Listen("tcp", ":8000")
for {
	conn, _ := listener.Accept()
	fmt.Printf("%s --- %s\n", conn.LocalAddr(), conn.RemoteAddr())
	io.WriteString(conn, "welcome to socket")
}

//Android Kotlin

val host = "192.168.100.250"
val port = 8000

Executors.newSingleThreadExecutor().execute {
    try {
        val socket = java.net.Socket(host, port)
        receiveMove(socket)
    } catch (e: ConnectException) {
        Log.e(TAG, "Socket ConnExc: ${e.localizedMessage}")
        runOnUiThread {
            Toast.makeText(this, "connection failed", Toast.LENGTH_SHORT).show()
        }
    }catch (e: Exception) {
        Log.e(TAG, "Socket ConnExc: ${e.localizedMessage}")
    }
}

Now I'm wondering, why does that barebones code work and the one provided by googollee library doesn't? I don't think I missed any settings for both sides.

UPDATE:

Got some progress. Found an android code that works, but for some reason is doing some unexpected issue. Here's the details of the change I made on the android side:

// app build.gradle

implementation('io.socket:socket.io-client:0.8.3') {
	exclude group: 'org.json', module: 'json'
}

// MainActivity.kt

import io.socket.client.IO
import io.socket.client.Socket

init {
	try {
		mSocket = IO.socket("http://<local_IP>:8000/socket.io/")
	}catch (e: ConnectException) {
		Log.e(TAG, "Socket ConnExc: ${e.localizedMessage}")
	}catch (e: URISyntaxException) {
		Log.e(TAG, "Socket URISynExc: ${e.localizedMessage}")
	}catch (e: Exception){
		Log.e(TAG, "Socket Exc: ${e.localizedMessage}")
	}
}

// AndroidManifest.xml

android:usesCleartextTraffic="true"
//I used to have android:networkSecurityConfig="@xml/network_security_config" here as well

With those changes, the app connects to the server now. But immediately after connecting, the app seems to get disconnected. Then it connects to the server again, then gets disconnected again, then connects to the server, and this cycle doesn't seem to stop. I'm getting a closed client namespace disconnect on the disconnects.

It's hard to identify the problem without seeing the logs, error messages.
One thing that could be the reason (besides an incorrect IP address or port number) is using cleartext connection (HTTP instead of HTTPS). Note that starting with Android 9 (API level 28), cleartext support is disabled by default.

You can try to either use a secure connection (HTTPS) or enable cleartext traffic in the AndroidManifest using the android:networkSecurityConfig attribute. More information can be found in the docs.

The client namespace disconnect error receiving due to the namespace (url path) /skt is not defined in the golang code.

See the sample

package main
import (
"log"
"net/http"
socketio "github.com/googollee/go-socket.io"
"github.com/googollee/go-socket.io/engineio"
"github.com/googollee/go-socket.io/engineio/transport"
"github.com/googollee/go-socket.io/engineio/transport/polling"
"github.com/googollee/go-socket.io/engineio/transport/websocket"
)
// Easier to get running with CORS. Thanks for help @Vindexus and @erkie
var allowOriginFunc = func(r *http.Request) bool {
return true
}
func main() {
server := socketio.NewServer(&engineio.Options{
Transports: []transport.Transport{
&polling.Transport{
CheckOrigin: allowOriginFunc,
},
&websocket.Transport{
CheckOrigin: allowOriginFunc,
},
},
})
server.OnConnect("/", func(s socketio.Conn) error {
s.SetContext("")
log.Println("connected:", s.ID())
return nil
})
server.OnEvent("/", "notice", func(s socketio.Conn, msg string) {
log.Println("notice:", msg)
s.Emit("reply", "have "+msg)
})
server.OnError("/", func(s socketio.Conn, e error) {
log.Println("meet error:", e)
})
// I've added a new endpoint skt
// Comment this block of code and refresh the htmt page
// and this will show `closed client namespace disconnect`
{
server.OnConnect("/skt", func(s socketio.Conn) error {
s.SetContext("")
log.Println("connected:", s.ID())
return nil
})
server.OnEvent("/skt", "notice", func(s socketio.Conn, msg string) {
log.Println("notice:", msg)
s.Emit("reply", "have [SKT]"+msg)
})
}
server.OnDisconnect("/", func(s socketio.Conn, reason string) {
log.Println("closed", reason)
})
go func() {
if err := server.Serve(); err != nil {
log.Fatalf("socketio listen error: %s\n", err)
}
}()
defer server.Close()
http.Handle("/socket.io/", server)
http.Handle("/", http.FileServer(http.Dir("../asset")))
log.Println("Serving at localhost:8000...")
log.Fatal(http.ListenAndServe(":8000", nil))
}

and here is a sample socket connection html

<!doctype html>
<html>
<head>
<title>Socket.IO chat</title>
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
body { font: 13px Helvetica, Arial; }
form { background: #000; padding: 3px; position: fixed; bottom: 0; width: 100%; }
form input { border: 0; padding: 10px; width: 90%; margin-right: .5%; }
form button { width: 9%; background: rgb(130, 224, 255); border: none; padding: 10px; }
#messages { list-style-type: none; margin: 0; padding: 0; }
#messages li { padding: 5px 10px; }
#messages li:nth-child(odd) { background: #eee; }
</style>
</head>
<body>
<ul id="messages"></ul>
<form action="">
<input id="m" autocomplete="off" /><button>Send</button>
</form>
<script src="https://cdn.socket.io/socket.io-1.2.0.js"></script>
<script src="https://code.jquery.com/jquery-1.11.1.js"></script>
<script>
var socket = io("http://localhost:8000/skt");
//   var socket = io("http://localhost:8000"); you can try like this as well
socket.on('reply', function(msg){
$('#messages').append($('<li>').text(msg));
});
$('form').submit(function(){
socket.emit('notice', $('#m').val());
$('#m').val('');
return false;
});
</script>
</body>
</html>

hope this will helps you to resolve your problem

If I understand your code correctly, you should try connecting to http://localhost:8000/socket.io/ or using 127.0.0.1 with the Android app, because you are serving in the Go server the /socket.io endpoint for SocketIO.

I finally found the bits to make this work. I think the biggest issue was on the android side. Replacing the library to use seemed to have fixed all the issue, then just a minor change to fix the immediate disconnection issue. Here's the final code and additional details for both side:

// Golang

package main
import (
"fmt"
"net/http"
socketio "github.com/googollee/go-socket.io"
"github.com/googollee/go-socket.io/engineio"
"github.com/googollee/go-socket.io/engineio/transport"
"github.com/googollee/go-socket.io/engineio/transport/polling"
"github.com/googollee/go-socket.io/engineio/transport/websocket"
)
var allowOriginFunc = func(r *http.Request) bool {
return true
}
func main() {
server := socketio.NewServer(&engineio.Options{
Transports: []transport.Transport{
&polling.Transport{
CheckOrigin: allowOriginFunc,
},
&websocket.Transport{
CheckOrigin: allowOriginFunc,
},
},
})
server.OnConnect("/", func(s socketio.Conn) error {
s.SetContext("")
fmt.Println("connected:", s.ID())
return nil
})
server.OnEvent("/", "notice", func(s socketio.Conn, msg string) {
fmt.Println("notice:", msg)
s.Emit("reply", "have "+msg)
})
server.OnError("/", func(s socketio.Conn, e error) {
fmt.Println("error:", e)
})
server.OnDisconnect("/", func(s socketio.Conn, reason string) {
fmt.Println("closed", reason)
})
go server.Serve()
defer server.Close()
http.Handle("/socket.io/", server)
http.Handle("/", http.FileServer(http.Dir("./asset")))
fmt.Println("Socket server serving at localhost:8000...")
fmt.Print(http.ListenAndServe(":8000", nil))
}

// android kotlin

AndroidManifest.xml

<uses-permission android:name="android.permission.INTERNET" />
<application
...
android:usesCleartextTraffic="true">

app build.gradle

implementation('io.socket:socket.io-client:0.8.3') {
	exclude group: 'org.json', module: 'json'
}

// MainActivity.kt or wherever you want to put this

import io.socket.client.IO
import io.socket.client.Socket
class MainActivity : AppCompatActivity() {
private lateinit var mSocket: Socket
...
init {
try {
mSocket = IO.socket("http://<host>:8000/")
}catch (e: ConnectException) {
Log.e(TAG, "Socket ConnExc: ${e.localizedMessage}")
}catch (e: URISyntaxException) {
Log.e(TAG, "Socket URISynExc: ${e.localizedMessage}")
}catch (e: Exception){
Log.e(TAG, "Socket Exc: ${e.localizedMessage}")
}
}
override fun onCreate(savedInstanceState: Bundle?) {
...
mSocket.connect()
binding.btnSend.setOnClickListener {
Log.i(TAG, "isConnected: ${mSocket.connected()}")
mSocket.emit("notice", "from_app_msg")
}
}
override fun onDestroy() {
super.onDestroy()
mSocket.off()
mSocket.disconnect()
}
}

About the immediate disconnection, it seems like you don't really need to add /socket.io when trying to connect on the android side. Removing that fixed the disconnection issue. And you don't need an asset folder on your project. Man, this socket.io thing is weird.

Before trying to access your server using your own client, try accessing it with a CLI tool or browser.

Here's how you could do it using cURL:

curl -i -X GET http://0.0.0.0:8000

In your case, http.Fileserver will result in a 404 - Not Found or 403 - Permission Denied in case './asset' directory does not exist within your Go project's root path, or if you don't have read access.

Reference:

1. http.Fileserver.ServeHTTP calls toHTTPError which returns non-specific HTTP error message.

Based on the code you provided, it seems that your Golang socket server is running on port 8000 and you're trying to connect to it from an Android app using Kotlin.

There are a couple of things you can check to troubleshoot the issue:

1. Ensure that the server and the Android emulator are on the same network: Make sure both the server and the Android emulator are connected to the same network, such as your local Wi-Fi network.
2. Update the server code: In your Golang server code, you are using the /socket.io/ namespace for the socket.io events, but in your Android code, you are trying to connect to /skt. Make sure the namespaces match. Update the Android code to use the correct namespace if necessary.
   3.Use the server's IP address instead of "localhost": Instead of using "localhost" in the Android code, try using the IP address of the machine running the Golang server. If the server is running on the same machine as the Android emulator, you can try using the IP address 10.0.2.2, which is a special alias to refer to the host machine's loopback interface from the Android emulator.

Replace this line in your Android code:

mSocket = IO.socket("http://localhost:8000/skt")

with:

mSocket = IO.socket("http://10.0.2.2:8000/socket.io/")

Note that in this example, I've assumed the /socket.io/ namespace for the server.

4. Check for any firewall or security settings: Ensure that there are no firewall rules or security settings blocking the communication between the server and the Android emulator. Temporarily disabling any firewall or security software could help identify if they are causing the issue.

5. Verify the network permissions: Double-check that you have the

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

permission declared in your AndroidManifest.xml file. Without this permission, the app won't be able to connect to the server.

By addressing these points, you should be able to troubleshoot and resolve the connectivity issue between your Golang socket server and the Android app.