comunicacion de App air corriendo en maquina diferentes

Saludos

Tengo una aplicacion air de escritorio, la cual al ser instalada crea una carpeta en el escritorio de cada usuario.
Me interesaria de alguna manera comunicar la app que este siendo ejecutada por lo menos por dos usuarios de una red local, de tal manera que un el usuario de la maquina 192.168.1.3,pueda acceder a la carpeta que se creo en el escritorio de la maquina 192.168.1.5, y asi poder cargar un archivo cualquiera de la maquina 192.168.1.5

BuenAS:

Mírate las clases Socket y ServerSocket.

La app principal puede crear un ServerSocket y las otras crear Socket's que se conecten al primero.

Con esta conexión podrías pasarle a tus app's secundarias la ruta de la que hablas. Y creo que no vas a tener problemas en acceder al escritorio de otra máquina; lo que creo que está prohibido es acceder a la carpeta de instalación de la app.

Un saludo.

Gracias por la respuesta.
Ya probe un socket UDP que hay en la pagina de adobe, que es el que me interesa ya que lo que quiero cargar es video, el problema es que en el ejemplo del socket hay que poner las ip con la cual se creara el socket manualmente, y no es lo que quiero.
Debido a que la aplicacion es como una serie de red p2p, pues cuando un usuario realiza una busqueda, dicho usuario sabe la direccion ip de quien tiene el archivo, pero el problema esta en crear el socket con dicha maquina ya que la app debe ser inteligente y de manera interna acceder a la carpeta que contiene el video del usuario que lo tiene.

BuenAS:

Lo primero, la app principal que actue como ServerSocket debería estar siempre funcionando.

Como lo veo yo: la app se lanza, crea la carpeta de la que hablas e informa a un servidor (ServerSocket) de dónde ha creado dicha carpeta (esto en principio sólo lo va a saber esta app).

Cuando otra app se lanza, informa de dónde ha creado la carpeta de vídeos.

Cuando quiera consultar la carpeta de otra máquina pide al servidor (que en el paso primero debe haber registrado la ruta y la máquina que la ha creado) que le informe dónde está la carpeta que ha creado la primera app. El servidor mira la ruta que le pasó la primer app e informa a esta segunda.

Esto se puede extender a tantas máquinas como quieras, o sea, cuando se conecte la app 3 dice al servidor dónde ha creado la carpeta de vídeos. Y cuando quiera obtener vídeos pide las rutas del resto de apps.

Un saludo.

Gracias por la respuesta.
Cuando la app se ejecuta crea la carpeta en el escritorio en caso de no existir, y luego pasa informacion de su ip y contenido de la carpeta a una base de datos.
Cuando un usuario hace una busqueda, se escanea en la base de datos para saber cuales usuarios lo tienen y obtener la ip de los mismos, entonces el usuario que esta buscando tiene las ip de quienes tienen el archivo. como ya le eh planteado no se como acceder por lo menos a una de las ip de quien tiene el archivo. .....

Podria explicarme mejor la sugerencia que me dio, por favor.
Disculpe la molestia..

BuenAS:

Veo que las apps se conectan a una base de datos. En principio hacerlo con Socket ta va a dar el mismo resultado, sólo que suele ser más rápido que con una base de datos en un servidor que, imagino, tirará de php.

Pero al contestar ayer me dio la sensación de que el problema que se te plantea es otro: que las carpetas de las que hables NO ESTÉN VISIBLES EN LA RED, ya que creo que las creas en el escritorio de cada máquina y esta localización suele estar oculta a la red.

Es que si es el caso, que las carpetas no sean visible en la red, cualquier app, independientemente de que le pases la ruta de la máquina via Sockets o accediendo a una BBDD, no va a verla y por tanto, no podrá acceder a ella. Esto es una cuestión de seguridad: si un usuario tiene su escritorio NO VISIBLE a la red local, salvo que te crees un virus (que creo, no es el caso ) va a estar oculta.

Opciones:

1. Crear carpetas públicas a la red y guardar ahí los vídeos de los que hablas y dar las rutas ya sea via socket o BBDD a cada app.

2 .Dejar las carpetas ocultas a la red y pasar los archivos via Socket o a través de la BBDD (en este caso, no lo guardes en la BBDD, sino que lo guardas en una carpeta del servidor y guardas en la BBDD la ruta). Imagino que tu mejor opción será la de la BBDD si ya la tienes medio montada, como comentas.

3. Otra opción que se te pueda ocurrir.

Un saludo.

OK, gracias por la pronta respuesta.
Ya vere cual opcion eligir, pero otro inconveniente es el siguiente
Resulta que las redes p2p se comportan como cliente-servidor, es decir que en un determinado momento un usuario de la red hace la funcion de cliente y en otro la de servidor.
En el caso de que un usuario realice una busqueda de archivo, ese usuario se debe comportar como cliente y no puede correr el servidor de socket, mientras que los usuarios que tiene el archivo buscado, deben hacer la funcion la servidor de socket y proveerle la informacion al que hizo la peticion.
La duda esta en como ese usuario que esta buscando el archivo deja de escuchar peticiones entrantes, mientras este haciendo la funcion de cliente, ya que en determinado momento puede convertirse en un servidor.


Muchismas gracias por sus Tips.

...ups! Perdón, había supuesto que se trataba de una red local; vamos, la típica intranet de cualquier empresa y que las app's iban a ejecutarse en distintas máquinas de esa red. Sorry O

Para fines de prueba hay que hacerlo en una red local, y si la app debe ejecuatrse en distintas maquinas, pero con el concepto del funcionamiento de las redes p2p.

Y entonces usa P2P
Podes hacer streaming de ByteArray en P2P usando FileStream... como si fuese un cliente BitTorrent.
Caso contrario necesitas un webserver para hacer un request de los archivos.

Podria ser mas explicito por favor...

Es dificil ser mas explicito porque tu consulta original es bastante amplia, y tiene muchos puntos para ver.
A ver, dejame probar:
Desde FlashPlayer10 tenes un nuevo protocolo para NetConnection "rtmfp", que te permite una comunicación asincronica entre clientes usando p2p.


Aca tenes una

http://www.slideshare.net/peterelst/p2p-on-the-local-network escribió:

de Peter Elst de como hicieron

https://code.google.com/p/cocoon-p2p/wiki/PureAS3 escribió:

, eso te va a ayudar a entender como funciona.

Particularmente la clase que uso yo es

http://blog.andrewwalpole.com/2013/02/27/introducing-netgrouper-for-easy-real-time-rtmfp-p2p-connections-between-swfs/ escribió:

, es muy simple y me ha resultado muy práctica.

En tu caso seria asi:

Código ActionScript :

// SERVER
netgrouper = new NetGrouper();
netgrouper.addEventListener(NetGrouperEvent.CONNECT, onConnected);
netgrouper.addEventListener(NetGrouperEvent.RECEIVE, onReceivePost);
netgrouper.addEventListener(NetGrouperEvent.NEIGHBOR_CONNECT, onNeighborConnected);
netgrouper.addEventListener(NetGrouperEvent.NEIGHBOR_DISCONNECT, onNeighborDisconnected);

// connecta
netgrouper.connect(NetGrouper.LOCAL_CONNECTION, 'grupo/casa');

private function onNeighborConnected(event:NetGrouperEvent):void {
      trace('p2p neighbour connected', netgrouper.getPeerId(event));
   var postObj:Object = {} ;
   postObj.timestamp = new Date().getTime();
   postObj.ip = getMyIP();
      netgrouper.post(postObj);
}

private function onReceivePost(event:NetGrouperEvent):void {
   trace( 'P2P post received:', event.message.ip, ' from client:',netgrouper.getPeerId(event));
}

// utilitario para devolver la IP de este client.
public static function getMyIP():String {
      var netInterfaces:Vector.<NetworkInterface> = NetworkInfo.networkInfo.findInterfaces();
      var loopCheck:RegExp = /^127/; //anything beginning with 127 is the loopback interface, skip it
      var goodIP:RegExp = /(\d+)\.(\d+)\.(\d+)\.(\d+)/;
      if (netInterfaces && netInterfaces.length > 0) {
         for each (var i:NetworkInterface in netInterfaces) {
            if (i.active) {
               var addresses:Vector.<InterfaceAddress> =i.addresses;
               if(addresses){
                  for each (var j:InterfaceAddress in addresses) {
//                     trace( "[NetUtils] Host IP address: " + j.address );
                     if(!loopCheck.test(j.address) && goodIP.test(j.address)){
                        trace( "[NetUtils] Host IP address: " + j.address );
                        return j.address ;
                     }
                  }
               }
            }
         }
      }
      return null ;
   }

Entonces... para enviar usas netgrouper.post(postObj), y para recibir usas el callback NetGrouperEvent.RECEIVE...

Las maquinas asi van a notificar su IP, despues podes como comandos atraves de ::pos() para hacer requests de datos....

Código ActionScript :

var requestObj:Object = {action:"getFileList", folder: null }; // null = seria el primer request.
netgrouper.post( requestObj )

// la otra maquina parsea el comando:
if(event.message.action == "getFileList"){
   var rootFolder:String = event.message.folder ;
   var file:File ;
   if( !rootFolder ){
        file = File.desktopDirectory ; 
   } else {
        file = new File( rootFolder );
   }
   var fileList:Array = file.getDirectoryListing() ;
   netgrouper.post( {action:"resultGetFileList", data: fileList );
}

La verdad estoy improvisando el codigo para que veas, este editor de Cristalab es un desastre para escribir codigo
Pero supongo que te das una idea clara del tema.
Eso es para la comunicacion.... ahora para "compartir" archivos es mas complicado.

http://tomkrcha.com/?p=1646 escribió:

Yo particularmente he usado un

http://www.freeutils.net/source/jlhttp/ escribió:

, es bien livianito (39kb). Ejecutandolo con NativeProcess (eso si, asegurate de tener los puertos abiertos en las maquinas).
De esa forma, solo usas P2P para hacer un request de la IP, y despues te manejas con el webserver para cargar las cosas, que va a ser mucho mas fácil, pero quizas menos flexbile, ya que los archivos que quieras visualizar van a tener que estar dentro de la carpeta www que definas para el servidor web.

Jaja, te dije que era un tópico medio avanzado. En fin, si necesitas ayuda ESPECIFICA con algo, chifla.