Aplicación para Android Conectando al servidor Node.js usando Socket.io

sockets ssl

Question

Tengo problemas para conectar mi aplicación de Android a un servidor de chat de socket.io. Estoy usando socket.io-java-client creado por Gottox que se puede encontrar aquí: https://github.com/Gottox/socket.io-java-client

El servidor se ejecuta localmente en el puerto 7000. Estoy usando el emulador de Android, así que estoy usando 10.0.2.2:7000 para acceder al servidor.

Cualquier ayuda sería apreciada, no tengo mucha experiencia con SSL. Si encuentro una solución que funcione, también la publicaré.

Servidor Node.js

var express = require(''express'');
var app = express();
var server = require(''http'').createServer(app).listen(7000);
var io = require(''socket.io'').listen(server);
io.sockets.on(''connection'', function(client){
client.on(''message'', function(err, msg){
client.broadcast.emit(''message'', msg);
});
});

paquete.json

{
"name": "simplechat",
"version": "0.0.1",
"main": "app.js",
"dependencies": {
"express" : "~4.0.0",
"socket.io" : "~0.9.13"
}
}

Android: SendMessageActivity

public class SendMessageActivity extends Activity {
private static final String SERVER_ADDRESS = "https://10.0.2.2:7000";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_send_message);
System.out.println("Sever: " + SERVER_ADDRESS);
try {
SocketIO socket = new SocketIO(new URL(SERVER_ADDRESS), new IOCallback() {
@Override
public void onDisconnect() {
System.out.println("disconnected");
}
@Override
public void onConnect() {
System.out.println("connected");
}
@Override
public void onMessage(String s, IOAcknowledge ioAcknowledge) {
}
@Override
public void onMessage(JSONObject jsonObject, IOAcknowledge ioAcknowledge) {
}
@Override
public void on(String event, IOAcknowledge ioAcknowledge, Object... objects) {
}
@Override
public void onError(SocketIOException e) {
e.printStackTrace();
}
});
} catch (MalformedURLException ex) {
ex.printStackTrace();
}
}

Permisos de Android

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

Código de error

08-09 16:07:28.224 8411-8441/com.example.puma.chatexample W/System.err﹕ io.socket.SocketIOException: Error while handshaking
08-09 16:07:28.225 8411-8441/com.example.puma.chatexample W/System.err﹕ at io.socket.IOConnection.handshake(IOConnection.java:322)
08-09 16:07:28.225 8411-8441/com.example.puma.chatexample W/System.err﹕ at io.socket.IOConnection.access$600(IOConnection.java:39)
08-09 16:07:28.225 8411-8441/com.example.puma.chatexample W/System.err﹕ at io.socket.IOConnection$ConnectThread.run(IOConnection.java:199)
08-09 16:07:28.226 8411-8441/com.example.puma.chatexample W/System.err﹕ Caused by: java.lang.NullPointerException: Attempt to invoke virtual method ''javax.net.ssl.SSLSocketFactory javax.net.ssl.SSLContext.getSocketFactory()'' on a null object reference
08-09 16:07:28.226 8411-8441/com.example.puma.chatexample W/System.err﹕ at io.socket.IOConnection.handshake(IOConnection.java:302)
08-09 16:07:28.227 8411-8441/com.example.puma.chatexample W/System.err﹕ ... 2 more

Answer 1

De hecho, resolví el problema. Usé IP local de mi PC http://192.168.0.xxx:7000 y la aplicación pudo conectarse al servidor de chat desde el emulador. No sé por qué funciona, pero podría ayudar a alguien en el futuro :)

Actualizar:

Así es como terminé estructurando el proyecto. Creé una clase singleton para manejar las conexiones de socket de Android (también podrías hacerlo como un servicio). Al recibir un mensaje, la clase singleton emite un intento para el resto de la aplicación. La intención es recogida por un receptor de difusión en la actividad relevante.

Android Side (singleton):

public class SocketSingleton {
private static SocketSingleton instance;
private static final String SERVER_ADDRESS = "http://1.2.3.4:1234";
private SocketIO socket;
private Context context;
public static SocketSingleton get(Context context){
if(instance == null){
instance = getSync(context);
}
instance.context = context;
return instance;
}
public static synchronized SocketSingleton getSync(Context context){
if (instance == null) {
instance = new SocketSingleton(context);
}
return instance;
}
public SocketIO getSocket(){
return this.socket;
}
private SocketSingleton(Context context){
this.context = context;
this.socket = getChatServerSocket();
this.friends = new ArrayList<Friend>();
}
private SocketIO getChatServerSocket(){
try {
SocketIO socket = new SocketIO(new URL(SERVER_ADDRESS), new IOCallback() {
@Override
public void onDisconnect() {
System.out.println("disconnected");
}
@Override
public void onConnect() {
System.out.println("connected");
}
@Override
public void on(String event, IOAcknowledge ioAcknowledge, Object... objects) {
if (event.equals("chatMessage")) {
JSONObject json = (JSONObject) objects[0];
ChatMessage chatMessage = new ChatMessage(json);
Intent intent = new Intent();
intent.setAction("newChatMessage");
intent.putExtra("chatMessage", chatMessage);
context.sendBroadcast(intent);
}
}
@Override
public void onError(SocketIOException e) {
e.printStackTrace();
}
});
return socket;
} catch (MalformedURLException ex) {
ex.printStackTrace();
}
return null;
}
}

Android Side (actividad):

public class ChatActivity extends Activity {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_chat);
IntentFilter newChatMessageFilter = new IntentFilter("newChatMessage");
this.registerReceiver(new MessageReceiver(), newChatMessageFilter);
...
public class MessageReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent){
final ChatMessage chatMessage =(ChatMessage) intent.getExtras().get("chatMessage");
runOnUiThread(new Runnable() {
@Override
public void run() {
mAdapter.add(chatMessage);
mAdapter.notifyDataSetChanged();
}
});
}
}
}

Lado del servidor:

var express = require(''express'');
var app = express();
var server = require(''http'').createServer(app).listen(1234);
var io = require(''socket.io'').listen(server);
io.sockets.on(''connection'', function(client){
console.log("client connected: " + client.id);
client.on("sendTo", function(chatMessage){
console.log("Message From: " + chatMessage.fromName);
console.log("Message To: " + chatMessage.toName);
io.sockets.socket(chatMessage.toClientID).emit("chatMessage", {"fromName" : chatMessage.fromName,
"toName" : chatMessage.toName,
"toClientID" : chatMessage.toClientID,
"msg" : chatMessage.msg});
});
});

Answer 2

Puma ya ha respondido sobre cómo puede implementar una conexión de socket usando SocketIO. Esto no tiene nada nuevo que aportar. Sin embargo, es un intento de ayudar a los novatos compañeros, como también presentar la implementación de la biblioteca java de Socket.io.

Socket.IO tiene su propia implementación java en Github , que puede seguir para crear una aplicación de socket para Android / Java.

Lado de Android:

Incluye esto en tu gradle de construcción

compile (''io.socket:socket.io-client:0.8.3'') {
// excluding org.json which is provided by Android
exclude group: ''org.json'', module: ''json''
}

Proporcione permiso en su aplicación:

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

Código de Android: la estructura del código es similar a cómo codificaría en Node. El mensaje en socket.on es similar al socket.on (''message'', ...) del nodo

import io.socket.client.Socket;
import io.socket.client.IO;
import io.socket.emitter.Emitter;
final Socket socket;
try{
socket = IO.socket("http://192.168.1.1:8080");
socket.on(Socket.EVENT_CONNECT, new Emitter.Listener() {
@Override
public void call(Object... args) {
socket.emit("message", "hi");
socket.disconnect();
}
}).on("message", new Emitter.Listener() {
//message is the keyword for communication exchanges
@Override
public void call(Object... args) {
socket.emit("message", "hi");
}
}).on(Socket.EVENT_DISCONNECT, new Emitter.Listener() {
@Override
public void call(Object... args) {}
});
socket.connect();
}
catch(Exception e){
}

Node.js side

Crea tomas normales usando socket.io

Answer 3

Sé que esto no responde realmente a las publicaciones de OP, pero para aquellos que puedan estar interesados, este es un tutorial que hice para comunicar su Android con un servidor Node.js, sin ninguna biblioteca adicional :

https://causeyourestuck.io/2016/04/27/node-js-android-tcpip/

Esto es un anticipo de cómo se ve al final:

Client socket = new Client("192.168.0.8", 1234);
socket.setOnEventOccurred(new Client.OnEventOccurred() {
@Override
public void onMessage(String message) {
}
@Override
public void onConnected(Socket socket) {
socket.send("Hello World!");
socket.disconnect();
}
@Override
public void onDisconnected(Socket socket, String message) {
}
});
socket.connect();

Answer 4

Tu red de emuladores es diferente de la de tu PC, como he escuchado. Por lo tanto, si pudiera cambiar, intente esto en un teléfono real que esté conectado a la misma red que su PC.

Probablemente no podrá hacer ping 10.0.2.2 desde su emulador o al revés desde su PC al emulador.