Buenos dias chicos.
Tengo un servidor corriendo en Android, que simplemente devuelve un numero entero. He realizado un aplicacion de Unity para Android, la cual quiero que llame a esa servidor por la direccion de loopback 127.0.0.1 . En resumen, mi duda es como hacer desde el cliente de unity una llamada al servidor para recibir un dato, nada mas.
Muchas gracias.
Ummm, cierto. Voy a intentar explicarme un poco mas.
Servidor
Es simplemente un servidor Java que esta escuchando en la direccion 127.0.0.1 (loopback) en el puerto 8888. Es java, ya que esta diseñada para correr en el background de una app Android. Tiene una unica funcion, que al recibir una peticion de un cliente, le devuelve un numero entero. De momento para las pruebas que estoy haciendo con eso me valdria, luego le implementaria la funcion real.
Cliente
En donde tengo la duda es en realizar una llamada desde un juego Unity para Android, Este juego, deberia tener una parte del codigo, que llame al servidor que estara corriendo en el background y recoger la respuesta de este, en este caso el numero entero, para despues trabajar con el. Se me habia ocurrido utilizar un RPC pero no se si es la forma adecuada.
Este es el codigo que de momento tengo en Unity para establecer la conexion, me hace falta realizar la llamada una vez conectado.
public void SetupClient()
{
myClient = new NetworkClient();
myClient.Connect("127.0.0.1", 8888);
}
#4 Pero sea Java o no, ese punto de entrada que tienes en el puerto 8888 tendrá que ser o TCP o UDP. ¿Cómo le pasas la petición, que es lo que espera el servidor? Igual si muestras algo del código del servidor es más sencillo.
#5 TIenes razon, ahi va el server.
package com.example.androidserversocket;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.Enumeration;
import android.os.Bundle;
import android.app.Activity;
import android.widget.TextView;
public class MainActivity extends Activity {
ServerSocket serverSocket;
Thread socketServerThread = new Thread(new SocketServerThread());
socketServerThread.start();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (serverSocket != null) {
try {
serverSocket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private class SocketServerThread extends Thread {
static final int SocketServerPORT = 8888;
int count = 0;
@Override
public void run() {
try {
serverSocket = new ServerSocket(SocketServerPORT);
while (true) {
Socket socket = serverSocket.accept();
count++;
message += "#" + count ;
MainActivity.this.runOnUiThread(new Runnable() {
@Override
public void run() {
msg.setText(message);
}
});
SocketServerReplyThread socketServerReplyThread = new SocketServerReplyThread(
socket, count);
socketServerReplyThread.run();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private class SocketServerReplyThread extends Thread {
private Socket hostThreadSocket;
int cnt;
SocketServerReplyThread(Socket socket, int c) {
hostThreadSocket = socket;
cnt = c;
}
@Override
public void run() {
OutputStream outputStream;
String msgReply = "Hello from Android, you are #" + cnt;
try {
outputStream = hostThreadSocket.getOutputStream();
message += "replayed: " + msgReply + "\n";
MainActivity.this.runOnUiThread(new Runnable() {
@Override
public void run() {
msg.setText(message);
}
});
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
message += "Something wrong! " + e.toString() + "\n";
}
MainActivity.this.runOnUiThread(new Runnable() {
@Override
public void run() {
msg.setText(message);
}
});
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
ip += "Something Wrong! " + e.toString() + "\n";
}
return ip;
}
}En tu código de servidor estás usando un SocketServer, lo cual me hace pensar que es TCP (hace años que no toco Java y no lo tengo muy fresco).
Una vez aceptas el cliente e instancias el hilo para manejarlo, aumentas el contador y le mandas la cadena:
"Hello from Android, you are #1" para la primera conexión.
Para poder recibir esta cadena desde tu cliente Unity tendrías que usar un socket TCP (por ejemplo, en System.Net.Sockets). Desde tu socket defines el IPEndPoint a 127.0.0.1 con puerto 8888, haces un Connect() y un Recv() bloqueante. En el byte array que recibas tendrás tu cadena. Para parsear el número ya puedes hacer un Split con el #, usar una expresión regular o el método que más te mole.
Te paso un ejemplo de cómo hacer la conexión TCP en C#:
https://msdn.microsoft.com/es-es/library/kb5kfec7(v=vs.110).aspx
De todas formas también sería interesante que comentases lo que quieres hacer, por que igual hay formas más sencillas de hacerlo.
#7 Muchas gracias tio.
Tengo una aplicacion en Android que a traves del wifi y unas bases de datos, te da una localizacion en interiores. Una vez hecho esto, con las coordenadas x e y que me proporciona la App quiero poder pasarselas a Unity para que use esas coordenadas y me represente un muñequito justamente en la posicion en la que me encuentro.
En definitiva, simplemente queria comunicar la App Android que me proporciona unas coordenadas X e Y con la App de Unity para poder usarlas. Y se me habia ocurrido hacerlo mediante sockets.
#8 Para hacer eso me parece una buena idea usar sockets, sí. Si las posiciones no se van a actualizar muy a menudo (con una frecuencia de varios segundos o así) TCP es más que suficiente.
Para pasar las coordenadas creo que te vendría bien usar un formato como JSON, imagino que ya lo conoces. O si no, usar directamente un formato binario usando un BinaryOutputStream en el servidor y parseando los bytes en el cliente.