Listar adaptadores de red en AIR 2.0 NetworkInfo

La clase NetworkInfo es nueva dentro del paquete flash.net de Adobe AIR 2.0, esta clase nos permite listar los adaptadores de red que cuente nuestro SO y acceder a la información del mismo para poder manipular o comunicar con algún tipo de cliente o servidor.

Este ejemplo esta confeccionado desde Adobe Flash CS5 que entre esta novedad incluye muchas más que voy a ir ejemplificando.

ActionScript
< view plain text >
  1. //importamos las clases necesarias
  2. import flash.net.InterfaceAddress;
  3. import flash.net.NetworkInfo;
  4. import flash.net.NetworkInterface;
  5.  
  6. //creamos una variable NetworkInfo
  7. var adaptadorInfo:NetworkInfo = NetworkInfo.networkInfo;
  8. //guardamos todos los adaptadore de red en un Vector que es un conjunto
  9. //de elementos del mismo tipo
  10. var adaptadores:Vector.<NetworkInterface> = adaptadorInfo.findInterfaces();
  11.  
  12. //listamos en el panel de salida los datos de nuestros adaptadores de red
  13. if (adaptadores != null)
  14. {
  15.     trace("cantidad de adaptadores:"+adaptadores.length);
  16.     //
  17.     for each (var interfacesObj:NetworkInterface in adaptadores)
  18.     {
  19.         trace("//////////////////////////////////////////////////////");
  20.         trace("Nombre de visualización: "+interfacesObj.displayName);
  21.         trace("Nombre del adaptador: "+interfacesObj.name);
  22.         trace("MAC del adaptador:   "+interfacesObj.hardwareAddress);
  23.         //de esta manera optenemos las ip correspondiente a cada adaptador
  24.         //como tambien el la version de ip
  25.         for each (var direcciones:InterfaceAddress in interfacesObj.addresses)
  26.         {
  27.             trace("                 ip ---> "+direcciones.address);
  28.             trace("                 ip versión ---> "+direcciones.ipVersion);
  29.         }
  30.         trace("Estado: "+interfacesObj.active);
  31.         trace("Unidad máxima de transmición: "+interfacesObj.mtu);
  32.     }
  33. }
  34. else
  35. {
  36.     trace("no hay adaptadores de red en su sistema");
  37. }

Detectar inactividad o ausencia de un usuario (USER_IDLE) AIR

Hay aplicaciones que son sensibles a tareas como pueden ser controles de producción por tiempo, en esos casos es adecuado que nuestra aplicación pueda detectar que nos ausentamos o hay inactividad por cierto periodo de tiempo, para ello vamos a utilizar el evento userIdle de la clase NativeApplication para saber cuando el usuario se ausento y cuando volvió.

ActionScript
< view plain text >
  1. //creamos una variable con NativeApplication
  2. var natApp:NativeApplication = NativeApplication.nativeApplication
  3. //establecemos el tiempo de limite en segundos
  4. natApp.idleThreshold = 60
  5. //evento para cuando se detecto la inactividad
  6. natApp.addEventListener(Event.USER_IDLE,userOff)
  7. //evento para cuando se detecto actividad nuevamente
  8. natApp.addEventListener(Event.USER_PRESENT,userOn)
  9. ///
  10. function userOff (e:Event):void {
  11.     trace("No estoy usando la pc")
  12. }
  13. function userOn (e:Event):void {
  14.     trace("Ya regrese!!!")
  15. }

Alerta al cerrar una aplicación en AIR (CLOSING)

Las aplicaciones en AIR cuando uno llama al método close() de la clase NativeWindow inmediatamente dicha ventana se cierra y es lo esperado en primer momento, pero puede que muchas veces el usuario lo haga por error. Para evitarlo simplemente podemos hacer uso del evento CLOSING para notificar al usuario que la aplicación se esta por cerrar y validar dicha acción, también es útil para aquellas aplicaciones que sean sensibles a tareas que se deban efectuar antes de ser cerradas definitivamente.

Para este ejemplo utilizaremos una clase personalizada para crear una ventana de alerta donde se le notifica al usuario de la acción y se le pide que confirme. Aprovecho para dejarle la referencia de esta clase Alert que es muy buena y útil para muchos casos, ya sea para proyectos en AS3, Flex o AIR.

ActionScript
< view plain text >
  1. //importa la clase personalizada
  2. import Alert;
  3. //creo el objeto alert
  4. Alert.init(stage);
  5. //agregamos el escuchador al stage para detectar si se
  6. //llamo a cerrar la aplicación, el evento encargado del mismo es Event.CLOSING
  7. stage.nativeWindow.addEventListener(Event.CLOSING,cerrarAplicacion);
  8. //
  9. function cerrarAplicacion(e:Event):void {
  10.     //aquí detenemos el evento por defecto de cerrar
  11.     e.preventDefault();
  12.     //ejecuto el alert, para ver mejor como funciona la
  13.     //clase alert recomiendo que vean el site y su referencias
  14.     Alert.show("¿Realmente decea salir?",{background:"blur",colour:0xFFFFFF,buttons:["Si", "Cancelar"], callback:handleResponse});
  15.     function handleResponse(response:String):void {
  16.         if (response=="Si") {
  17.             //si es correcto cierra
  18.             stage.nativeWindow.close();
  19.         } else {
  20.             //sino hacemos otra cosa si queremos!
  21.         }
  22.     }
  23. }

Notificar al usuario de un evento o alerta (notifyUser – activate) en AIR

En el ejemplo anterior vimos como detectar el estado de la ventana para notificar o preparar nuestros eventos según sea el caso. Ahora lo que haremos será de alguna manera llamar la atención del usuario de manera visual para que atienda dicho evento. Vamos hacer de dos manera diferentes muy efectivas, la primera será activando la ventana, lo cual si la misma esta minimizada pasara al primer plano y se restaurara a su tamaño anterior, y la segunda alternativa en caso de que la ventano no este minimizada pero inactiva el foco, será por medio de una llamada visual, haciendo que la aplicación parpadee.

ActionScript
< view plain text >
  1. //para este ejemplo agrego un timer para ver el efecto
  2. //minimicen la aplicación o póngala en segundo plano, pasado
  3. //los 10 seg verán el efecto
  4. var time:Timer=new Timer(1000,10);
  5. time.start();
  6. time.addEventListener(TimerEvent.TIMER_COMPLETE,completeTimer);
  7. //
  8. function completeTimer(e:TimerEvent):void {
  9.     //aquí activa la ventana y la coloca en primer plano si es que esta minimizada
  10.     stage.nativeWindow.activate();
  11.     //aquí hace que parpadee nuestra aplicación en la barra de Windows
  12.     stage.nativeWindow.notifyUser(NotificationType.CRITICAL);
  13.     //CRITICAL / INFORMATIONAL
  14.     //si usan CRITICAL, parpadea muchas veces en cambio con INFORMATIONAL solo 1 vez
  15. }

Detectar estado de una ventana Adobe AIR maximized – minimized – normal

Cuando creamos aplicaciones para escritorio de seguro en alguna etapa necesitaremos averiguar el estado de la ventana en el sentido si esta por ejemplo minimizada, normal o maximizada.
Para esto contamos con el evento NativeWindowDisplayStateEvent que nos devuelve dos propiedades que son: afterDisplayState, que es el estado de la ventana después del cambio y beforeDisplayState que es el estado de la ventana antes del cambio.
Para utilizar NativeWindowDisplayStateEvent necesitamos hacernos de uso de la constante DISPLAY_STATE_CHANGE en un escuchador al stage.

En este ejemplo devolvera el estado de la ventana despues de su cambio.

ActionScript
< view plain text >
  1. stage.nativeWindow.addEventListener(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGE,cambioStateWindows);
  2. function cambioStateWindows(e:NativeWindowDisplayStateEvent):void {
  3. trace(e.afterDisplayState);
  4. }

Otro ejemplo seria evaluar el estado de la ventana con las constantes de NativeWindowDisplayState

ActionScript
< view plain text >
  1. stage.nativeWindow.addEventListener(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGE,cambioStateWindows);
  2. function cambioStateWindows(e:NativeWindowDisplayStateEvent):void {
  3. if (e.afterDisplayState==NativeWindowDisplayState.MINIMIZED) {
  4. trace("la ventana esta minimizada");
  5. }
  6. //maximized - minimized - normal
  7. //trace(e.beforeDisplayState);
  8. //trace(e.afterDisplayState);
  9. }

Tambien es posible asi:

ActionScript
< view plain text >
  1. stage.nativeWindow.addEventListener(NativeWindowDisplayStateEvent.DISPLAY_STATE_CHANGE,cambioStateWindows);
  2. function cambioStateWindows(e:NativeWindowDisplayStateEvent):void {
  3.     if (e.afterDisplayState=="minimized") {
  4.         trace("la ventana esta minimizada");
  5.     }
  6.     //maximized - minimized - normal
  7.     //trace(e.beforeDisplayState);
  8.     //trace(e.afterDisplayState);
  9. }

Gestión de ventanas adobe AIR controles básicos cerrar, arrastrar y minimizar

Siguiendo con las clases o tutorial básico para principiantes de adobe AIR, en muchos de los casos vamos a querer utilizar controles de cerrar, minimizar y arrastrar una ventana con un diseño personalizado o porque preferimos utilizar la configuración de fondo cromático, sea opaco o transparente. Los controles de los mismos lo vamos hacer mediante el uso de la clase NativeWindow la cual nos proporcionara los métodos y propiedades para dichos controles y más.

En este caso vamos hacer una barra superior que es la encargada de arrastrar nuestra ventana, la misma es un MovieClip (toolsWin_mc) que dentro de ella colocaremos 2 botones (close_btn y min_btn), uno para cerrar y otro para minimizar, en otros ejemplos vamos a abordar restaurar y redimensionar una ventana.

ActionScript
< view plain text >
  1. toolsWin_mc.addEventListener(MouseEvent.MOUSE_DOWN,onMDownBar);
  2. function onMDownBar(e:MouseEvent):void {
  3. // evaluo el nombre de instancia del target
  4. switch (e.target.name) {
  5. case "close_btn" :
  6. // cierra una ventana de AIR
  7. this.stage.nativeWindow.close();
  8. break;
  9. case "min_btn" :
  10. // minimiza una ventana en AIR
  11. this.stage.nativeWindow.minimize();
  12. break;
  13. case "toolsWin_mc" :
  14. // arrastra una ventana en AIR
  15. this.stage.nativeWindow.startMove();
  16. break;
  17. }
  18. }

El ejemplo es muy simple, a nuestra barra le asignamos un listener de tipo MouseEvent, y cuando se llama la función simplemente evaluamos el name del objeto para efectuar la acción. Vean que esto es posible ya que evalúo el target y no el currentTarget en el switch case.

Feliz Año nuevo!!!!!