actionscript 3 - Escuche las conexiones entrantes en AS3(AIR) Client sin usar Socket Server

actionscript-3 sockets

Question

Logré crear un servidor C # que envíe archivos a clientes AS3 (AIR) que usan sockets . En el lado de AS3 estoy usando la biblioteca flash.net.Socket para recibir los datos a través de TCP .

Así es como funciona:
-> enciendo mi servidor, y escucha a los clientes (además puedo crear una lista de dispositivos conectados);
-> enciendo mi cliente y automáticamente recibe los datos;

El evento desencadenante para recibir los datos se realiza en el cliente, es decir, simplemente enciendo el servidor y cuando el cliente se enciende, obtiene los datos y desencadena estos eventos:

socket.addEventListener(Event.CONNECT, onConnect); -> to connect to the server  
socket.addEventListener(Event.SOCKET_DATA, onDataArrival); -> to receive the data  

Ahora quiero hacer algo diferente. No quiero activarlo en el cliente, quiero que el servidor lo haga, es decir, quiero activar mi cliente y en el servidor poner en qué cliente obtendrá los datos.

Entonces, ¿por qué estoy tratando de hacer que el cliente sea un cliente / servidor? Bueno, porque mi servidor es una máquina, y mis clientes son XXX dispositivos móviles que conectan el servidor, y este es mi enfoque para lograrlo.

Entonces, dado lo que acabo de decir, me las arreglé para crear mi aplicación cliente / servidor AS3 que funciona como yo quiero, utilizando la biblioteca flash.net.ServerSocket .

Primero puse al cliente a escuchar:

serverSocket.bind(portNumber, "10.1.1.212");
serverSocket.addEventListener(ServerSocketConnectEvent.CONNECT, onConnectServer);
serverSocket.listen();

Y luego recibo los datos usando flash.net.Socket Event.SOCKET_DATA

Y eso es más o menos. Funciona como yo quiero.
Sin embargo, flash.net.ServerSocket no es compatible con dispositivos móviles, sin embargo ...

Así que aquí está mi problema: necesito enviar archivos desde el servidor C # (que necesita escuchar a los clientes para poder crear una lista de dispositivos conectados) a los clientes AS3 (AIR), pero tengo que definir qué cliente está obteniendo los datos en el servidor. servidor, y los clientes deben estar preparados para recibir esa información en cualquier momento, por lo tanto, escuchando, pero hay muchos de ellos, es por eso que los considero como clientes.

Y mi pregunta es: ¿hay alguna manera de hacer que un cliente escuche las conexiones entrantes y desencadenar un evento cuando sucede, sin usar el Socket Server en AS3?

Además, si tiene un enfoque diferente para lograr mi objetivo sin usar la lógica del cliente / servidor del servidor C # <-> AS3, no dude en dar su opinión.

Answer 1

Sí. Su cliente debe conectarse al servidor a través de un flash.net.Socket ( doc ) o flash.net.XMLSocket ( doc ). En la mayoría de los casos, solo necesita un servidor al que se puedan conectar muchos clientes . No está del todo claro por qué tienes servidores en ambos extremos?

Editar:

A continuación se muestra un ejemplo rápido de un cliente que escucha continuamente los mensajes del servidor utilizando un Socket . Esto se conecta al servidor y luego espera (indefinidamente) los datos. Cuando se recibe un fragmento de datos (en este caso, estoy esperando cadenas terminadas por un nuevo carácter de línea), los datos se pasan junto con un evento.

Si probó este enfoque sin éxito, debería ver si hay algún error o si la conexión se está cerrando.

Clase de documento:

package  {
    import flash.display.Sprite;

    public class Main extends Sprite {
        protected var socket:SocketTest;

        public function Main() {
            this.socket = new SocketTest();
            this.socket.addEventListener(SocketMessageEvent.MESSAGE_RECEIVED, onSocketMessage);
            this.socket.connect("127.0.0.1", 7001);
        }

        protected function onSocketMessage(e:SocketMessageEvent):void {
            var date:Date = new Date();
            trace(date.hoursUTC + ":" + date.minutesUTC + ":" + date.secondsUTC + " Incoming message: " + e.message);
        }
    }
}

Clase SocketTest:

package  {
    import flash.net.Socket;
    import flash.events.Event;
    import flash.events.IOErrorEvent;
    import flash.events.SecurityErrorEvent;
    import flash.events.ProgressEvent;
    import flash.errors.IOError;

    public class SocketTest extends Socket {
        protected var _message:String;

        public function SocketTest() {
            super();
            this._message = "";

            this.addEventListener(Event.CONNECT, socketConnected);
            this.addEventListener(Event.CLOSE, socketClosed);
            this.addEventListener(ProgressEvent.SOCKET_DATA, socketData);
            this.addEventListener(IOErrorEvent.IO_ERROR, socketError);
            this.addEventListener(SecurityErrorEvent.SECURITY_ERROR, socketError);
        }

        protected function socketData(event:ProgressEvent):void {
            var str:String = readUTFBytes(bytesAvailable);

            //For this example, look for /n as a message terminator
            var messageParts:Array = str.split("/n");

            //There could be multiple messages or a partial message, 
            //pass on complete messages and buffer any partial
            for (var i = 0; i < messageParts.length; i++) {
                this._message += messageParts[i];
                if (i < messageParts.length - 1) {
                    this.notifyMessage(this._message);
                    this._message = "";
                }
            }
        }

        protected function notifyMessage(value:String):void {
            this.dispatchEvent(new SocketMessageEvent(SocketMessageEvent.MESSAGE_RECEIVED, value));
        }

        protected function socketConnected(event:Event):void {
            trace("Socket connected");
        }

        protected function socketClosed(event:Event):void {
            trace("Connection was closed");
            //TODO: Reconnect if needed
        }

        protected function socketError(event:Event):void {
            trace("An error occurred:", event);
        }
    }
}

Clase SocketMessageEvent:

package  {
    import flash.events.Event;

    public class SocketMessageEvent extends Event {
        public static const MESSAGE_RECEIVED:String = "messageReceived";

        protected var _message:String;

        public function SocketMessageEvent(type:String, message:String = "", bubbles:Boolean = false, cancelable:Boolean = false) {
            super(type, bubbles, cancelable);
            this._message = message;
        }

        public function get message():String {
            return this._message;
        }
    }
}

Como prueba configuré el servidor para enviar un mensaje cada 5 segundos, esta es la salida en la consola:

Socket connected
21:36:24 Incoming message: Message from server: 0
21:36:29 Incoming message: Message from server: 1
21:36:34 Incoming message: Message from server: 2
21:36:39 Incoming message: Message from server: 3
21:36:44 Incoming message: Message from server: 4
21:36:49 Incoming message: Message from server: 5