martes, 1 de noviembre de 2011

Hacer menús del sistema con Adobe AIR

Las clases de “menú nativo” permiten acceder a las funciones del menú nativo del sistema operativo donde se ejecuta la aplicación.

Se pueden utilizar los objetos NativeMenu para:
  • menús de aplicación (disponibles en Mac OS X),
  • menús de ventana (disponibles en Windows y Linux),
  • menús contextuales y
  • menús emergentes. 
Aqui un ejemplo genérico de cómo hacer menús básicos en Windows y Mac:

package {
    import flash.display.NativeMenu;
    import flash.display.NativeMenuItem;
    import flash.display.NativeWindow;
    import flash.desktop.NativeApplication;
    import flash.display.Sprite;

    public class Menu01 extends Sprite {

        public function Menu01():void {
            var fileMenu:NativeMenuItem;
            var editMenu:NativeMenuItem;
           
            //Es Windows
            if (NativeWindow.supportsMenu) {
                stage.nativeWindow.menu = new NativeMenu();
                fileMenu=stage.nativeWindow.menu.addItem(new NativeMenuItem("Archivo"));
                editMenu=stage.nativeWindow.menu.addItem(new NativeMenuItem("Edición"));
            }
            //Es MAC
            if (NativeApplication.supportsMenu) {
                var mm:NativeMenu = new NativeMenu();
                NativeApplication.nativeApplication.menu = mm;
                fileMenu = NativeApplication.nativeApplication.menu.addItem(new NativeMenuItem("xxxxxxx"));
                editMenu = NativeApplication.nativeApplication.menu.addItem(new NativeMenuItem("ccccccc"));
            }
        }
    }
}

lunes, 10 de octubre de 2011

Leer los archivos los directorios del iPhone y Android con Adobe AIR

Parte fundamental de una aplicación para iPhone o Android será poder saber en que directorios se encuentra la aplicacion y los datos de la misma. Afortunadamente podemos leer y escribir información en los dispositivos móviles desde AIR. Contamos con las clases File y FileStream, así como el método resolvePath() y la propiedad nativePath. Un ejemplo de una clase que lea los directorios principales del dispositivos (en relación a la aplicación) sería el siguiente:

package com.app.dirFile {
    import flash.display.Sprite;
    import flash.filesystem.File;
   
    public class DirFile extends Sprite{

        public function DirFile() {
            init();
        }
       
        private function init(){
            salida_txt.text = "applicationDirectory: " + File.applicationDirectory.nativePath+ "\n\n";
            salida_txt.appendText("applicationStorageDirectory: " + File.applicationStorageDirectory.nativePath + "\n\n");
            salida_txt.appendText("userDirectory: " + File.userDirectory.nativePath + "\n\n");
            salida_txt.appendText("documentsDirectory: " + File.documentsDirectory.nativePath+ "\n\n");
            salida_txt.appendText("desktopDirectory: " + File.desktopDirectory.nativePath+ "\n\n");
            salida_txt.appendText("applicationDirectory URL: " + File.applicationDirectory.url+"\n\n");
            salida_txt.appendText("desktopDirectory URL: " + File.desktopDirectory.url +"\n\n");           
        }
    }
}
iPhone no soporta la opcíon de desktopDirectory ni applicationDirectory, a comparación de Android que si las soporta.

jueves, 6 de octubre de 2011

Marcar una llamada telefónica desde tu iPhone con ActionScript 3.0

Aunque usted no lo crea, el iPhone también sirve para hacer llamadas telefónicas. Solo necesitamos invocar el protocolo "tel:" más el número que deseamos marcar. Se levantará el servicio telefónico del equipo y se realizará la llamada como si la hubiera marcado desde el teléfono. El código básico para realizar una llamada es el siguiente:

package  {
    import flash.display.MovieClip;
    import flash.net.URLRequest;
    import flash.net.navigateToURL;
    import flash.events.MouseEvent;
   
   
    public class Telefono extends MovieClip {
       
       
        public function Telefono() {
            init()
        }
       
        private function init(){
            marcar_btn.addEventListener(MouseEvent.CLICK, onMarcar);
        }
       
        private function onMarcar(e:MouseEvent):void {
            var num:String = "tel:"+telefono_txt.text;
            ejecutaComando(num);
        }

        private function ejecutaComando(comando:String):void{
            var req:URLRequest = new URLRequest(comando);
            try{
                navigateToURL(req);
            }
            catch(e:Error){
                trace("Ocurrio un error");
            }
        }
    }
   
}
En el archivo fla necesitará una caja de texto de entrada (del tipo que desee) y un botón con el nombre de instancia marcar_btn

martes, 4 de octubre de 2011

Detectar la geolocalizacion en iPhone con ActionScript 3.0

Por medio de dos clases podemos recibir la psoción geográfica del iPhone: Geolocation y GeolocationEvent.

La clase GeolocationEvent.nos proporciona los datos de geolocalización. Estos datos son los siguientes:


Propiedad isSupported:Boolean indica si el dispositivo soporta la geolocalización

Propiedad muted:Boolean Indica si el usuario autoriza el uso del geolocalizador en su dispositivo

Método setRequestedUpdateInterval(interval) Establece el intervalo en milisegundos de la frecuencia de monitoreo del geolocalizador

Evento StatusEvent.Indica si el usuario modificó el acceso al geolocalizador

Evento GeolocationEvent. Actualiza cuando el sensor del dispositivo actualiza la localización

La estructura clásica previa al uso del geolocalizador es la siguiente:

if (Geolocation.isSupported)
{
     var geo:Geolocation = new Geolocation();
     geo.setRequestedUpdateInterval(200);
     geo.addEventListener(GeolocationEvent.UPDATE, onGeo);
     geo.addEventListener(StatusEvent.STATUS, onGeoStatus);
}
else
{
    trace("Lo siento, no posees GPS");
}

Dentro del objeto de evento del manejador GeolocationEvent.UPDATE tendremos los siguientes parámetros:

altitude La altitud en metros.
heading La dirección del movimiento en grados (0–359) donde el norte es cero.
horizontalAccuracy Exactitud horizontal en metros
latitude Latitud en gradosentre  90 y –90. Si es positiva es norte y negativa el sur.
longitude Longitud entre 180 y –180.Positivo es este y negativo oeste.
speed Velocidad de movimiento en metros por segundo
timestamp Tiempo de actualización del sensor en milisegundos
verticalAccuracy Exactitud vertical en metros.

lunes, 26 de septiembre de 2011

Hacer una línea que se estira con ActionScript 3.0

Algunas veces queremos tener una línea que se estire de ambos extremos. Eso nos podría servir para juegos, diagramas, etc. El siguiente código genera una linea, creada desde el archivo SWF, de una linea. Se le indica la ubicación, la longitud y el color:

package {
   import flash.display.Sprite;
   import flash.events.MouseEvent;
   import flash.utils.Timer;
   import flash.events.TimerEvent;

   public class Linea extends Sprite {
      var tiempo:Timer = new Timer(60,0);
      var contenedor:Sprite;
      var cuadro1:Sprite;
      var cuadro2:Sprite;
      var x1:int = 0;
      var y1:int = 0;
      var x2:int = 100;
      var y2:int = 100;
      var color:uint = 0;

      public function Linea(xx,yy,lon,color):void {
         //Sujetador
         this.color = color;
         this.x1 = xx;
         this.y1 = yy;
         this.x2 = xx + lon;
         this.y2 = yy;
         //
         cuadro1=new Sprite ;
         cuadro1.graphics.beginFill(0xffffff);
         cuadro1.graphics.lineStyle(1,0,1);
         cuadro1.graphics.moveTo(0,0);
         cuadro1.graphics.lineTo(0,5);
         cuadro1.graphics.lineTo(5,5);
         cuadro1.graphics.lineTo(5,0);
         cuadro1.graphics.lineTo(0,0);
         //Sujetador 2
         cuadro2=new Sprite;
         cuadro2.graphics.beginFill(0xffffff);
         cuadro2.graphics.lineStyle(1,0,1);
         cuadro2.graphics.moveTo(0,0);
         cuadro2.graphics.lineTo(0,5);
         cuadro2.graphics.lineTo(5,5);
         cuadro2.graphics.lineTo(5,0);
         cuadro2.graphics.lineTo(0,0);
         //
        contenedor=new Sprite ;
        contenedor.graphics.lineStyle(2,color,.7);
        contenedor.graphics.moveTo(x1,y1);
        contenedor.graphics.lineTo(x2,y2);
        //contenedor.x=xx;
        //contenedor.y=yy;
        addChild(contenedor);
        addChild(cuadro1);
        addChild(cuadro2);
        //
        cuadro1.x=x1-2.5;
        cuadro1.y=y1-2.5;
        cuadro2.x=x2-2.5;
        cuadro2.y=y2-2.5;
        //
        cuadro1.addEventListener(MouseEvent.MOUSE_DOWN, onMueveCuadro1);
        cuadro2.addEventListener(MouseEvent.MOUSE_DOWN, onMueveCuadro1);
        //
        cuadro1.addEventListener(MouseEvent.MOUSE_UP, onMueveCuadro2);
        cuadro2.addEventListener(MouseEvent.MOUSE_UP, onMueveCuadro2);
     }

     function onMueveCuadro1(e:MouseEvent):void {
         e.target.startDrag();
         tiempo.addEventListener(TimerEvent.TIMER, onMueve);
         tiempo.start();
         //trace("inicio",e.target.name,e.target.x, e.target.y);
     }

    function onMueveCuadro2(e:MouseEvent):void {
         tiempo.stop();
         e.target.stopDrag();
         pintaLinea();
     }

     function onMueve(e:TimerEvent):void {
           pintaLinea();
     }

     function pintaLinea () {
         this.removeChild(contenedor);
         contenedor=new Sprite;
         contenedor.graphics.lineStyle(2,color,1);
         contenedor.graphics.moveTo(cuadro1.x+2.5,cuadro1.y+2.5);
         contenedor.graphics.lineTo(cuadro2.x+2.5,cuadro2.y+2.5);
         addChild(contenedor);
         swapChildrenAt(2, 0);
     }
   }
}

Ejemplo de linea que se estira...

viernes, 23 de septiembre de 2011

Uso de la clase TransformGestureEvent en ActionScript 3.0 para dispositivos móviles

Los Gestures en los dispositivos móviles, es cuando el usuario toca con más de un dedo la pantalla, por ejemplo, cuando toca con al menos dos dedos la pantalla para hacer un zoom de la imagen. Lo primero que debemos hacer para utilizar los Gestures en ActionScript 3.0 es definir si el dispositivo puede generar los eventos de Gestures.

Hay que importar la clase:

import flash.ui.Multitouch;

En esta clase sabremos si el dispositivo tiene o no la propiedad de recibir los Gestures. Por ejemplo, el emulador de Flash NO detecta estos eventos, ya que la pantalla, por lo general, no es TouchScreen. Lo primero que debemos preguntar es si el dispositivo soporta los eventos:

if (Multitouch.supportsTouchEvents)
{

   /* el código va aqui */  
}

Observe que no instanciamos el objeto, lo utilizamnos directamente, como lo hacemos con la clase Math.

El siguiente paso es indicarle a Flash (o Flex) que vamos a utilizar el modelo de Gestures:

Multitouch.inputMode = MultitouchInputMode.GESTURE;
Hay que importar la siguiente clase, la cual tiene las constantes:

import flash.ui.MultitouchInputMode;

Una vez que ya tenemos la definición del modelo de eventos, hay que detectar a los mismos, en este caso hay que importar la clase correspondiente:

import flash.events.TransformGestureEvent;
Los eventos que podemos detectar son:

 GESTURE_PAN : String = "gesturePan"

GESTURE_ROTATE : String = "gestureRotate"

GESTURE_SWIPE : String = "gestureSwipe"

GESTURE_TWO_FINGER_TAP : String = "gestureTwoFingerTap"

GESTURE_ZOOM : String = "gestureZoom"

Más adelante daremos ejemplos para cada uno de los eventos

martes, 13 de septiembre de 2011

Cómo leer el portapapeles de la computadora y grabarlo en un archivo con AIR

En muchas aplicaciones de escritorio nos sería de utilidad leer el portapapeles de la computadora para transmitir información (texto o imágenes) de otras aplicaciones. Para ello hay que importar las clases relacionadas, como son:

    import flash.desktop.Clipboard;
    import flash.desktop.ClipboardFormats;
    import flash.desktop.NativeDragManager;
    import flash.desktop.ClipboardTransferMode;
    import flash.events.NativeDragEvent;

Supongamos que desea grabar la informacion del clipboard en un archivo. Podría servirle una función como la siguiente:

            if(Clipboard.generalClipboard.getData( ClipboardFormats.BITMAP_FORMAT)!=null){
                var bm:Bitmap = new Bitmap(Clipboard.generalClipboard.getData( ClipboardFormats.BITMAP_FORMAT) as BitmapData)
                var f:File = new File("salida.jpg");
                var fs:FileStream = new FileStream();
                var jpgEncoder:JPGEncoder=new JPGEncoder(100);
                var jpgStream:ByteArray=jpgEncoder.encode(bm.bitmapData);
                try {
                    fs.open(f,FileMode.WRITE);
                    fs.writeBytes(jpgStream);
                    fs.close();
                } catch (e:Error) {
                    trace(e.message);
                }
            }

Hay que importar las clases para el manejo de archivos y de imágenes, como son:


    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import com.adobe.images.JPGEncoder;
    import flash.utils.ByteArray;
    import flash.filesystem.FileStream;
    import flash.filesystem.FileMode;

lunes, 12 de septiembre de 2011

Leer un bitmap de la librería con ActionScript 3.0



Con AS 3.0 podemos leer un mapa de bits desde la librería al escenario en tiempo de ejecución. Primero debemos exportar el bitmap desde la librería, seleccionando con botón derecho y seleccinando las Propiedades. Observe que se liga a una clase BitmapData:







Se crea un identificador de vínculo en el campo Clase, con el cual se llamará en el programa. Dentro del script necesitamos importar las clases, si es que se programa orientado a objetos:

import flash.display.Bitmap;
import flash.display.BitmapData;


En el script cree un objeto de la clase BitmapData y lígelo con el bitmap de la librería:

var imagenData:BitmapData = new Imagen1(0,0);

Los parámetros (0,0) son necesarios. Ahora vacie el objeto de datos en un objeto Bitmap, y añádalo a la lista de visualización:

var imagen:Bitmap = new Bitmap(imagenData);
addChild(imagen);

Lsto, ahora se podrá manipular el mapa de bits