Objective-C

Diccionarios:

Los diccionario cumplen un propósito similar a los arreglos, almacenar información, excepto que cada objeto almacenado en el diccionario está asociada con una clave única (para ser más precisos, la clave es única para el objeto de diccionario particular). La clave única (key) puede ser de cualquier tipo de objeto, aunque para ser útil por lo general son cadenas.

En Objective-C los objetos de tipo diccionario se crean utilizando las clases NSDictionary y NSMutableDictionary. Los objetos NSDictionary ​​son inmutables (en otras palabras, una vez que se han creado e inicializado su contenido no se puede modificar).

Los diccionarios que se pueden modificar en tiempo de ejecución son instanciados de la clase NSMutableDictionary y puede ser modificada después de la creación y la inicialización.

Creación de objetos de diccionario

Un objeto diccionario "inmutable" (para seguir con la terminología de Apple) se puede crear de la siguiente manera:

NSDictionary *miDiccionario = [NSDictionary dictionary];

Un objeto diccionario que se pueda modificar en tiempo de ejecución, es decir, mutable (no mutante) se crea de la siguiente forma:

NSMutableDictionary *miDiccionario = [NSMutableDictionary dictionary];

Crear y poblar un objeto diccionario

Cada par de clave-valor contenido dentro de un diccionario se refiere a una entrada. Una vez que una relación entre una clave y un valor se ha establecido, la relación no se pueden modificar en tiempo de ejecución.

Las nuevas entradas se agregan a un diccionario utilizando el método de instancia setObject. Este método toma como argumentos un objeto y una tecla correspondiente:

NSMutableDictionary *misLibros = [NSMutableDictionary dictionary];

[misLibros setObject: @"La guerra y la paz"  forKey: @"100-432112"];
[misLibros setObject: @"Crimen y castigo" forKey:  @"200-532874"];
[misLibros setObject: @"Cien años de soledad" forKey:  @"202-546549"];
[misLibros setObject: @"La guerra de los mundos" forKey: @"104-109834"];

También es posible crear e inicializar un diccionario con un número de pares de clave-valor utilizando el método de la clase dictionaryWithObjectsAndKeys. Por ejemplo, una alternativa al código anterior es como sigue:

NSDictionary *misLibros = [NSDictionary dictionaryWithObjectsAndKeys: @"La guerra y la paz", @"100-432112", @"Crimen y castigo", @"200-532874", @"Cien años de soledad", @"202-546549", @"La guerra de los mundos", @"104-109834", nil];

Los diccionarios también se pueden poblar utilizando claves-valores contenidos en los arreglos utilizando el método arrayWithObjects:

NSArray *objectsArray = [NSArray arrayWithObjects: @"La guerra y la paz", @"Crimen y castigo", @"Cien años de soledad", @"La guerra de los mundos", nil];
NSArray *keysArray = [NSArray arrayWithObjects: @"100-432112", @"200-532874", @"202-546549", @"104-109834", nil];

NSDictionary *miLibros = [[NSDictionary alloc] initWithObjects: objectsArray  forKeys: keysArray];

Número de elementos en un diccionario

Para obtener el número de elementos de un diccionario, utilizamos el método count:

NSLog (@"Los libros en la lista son = %lu", [misLibros count]);

Acceder a los datos de un diccionario

Para acceder a los datos de un diccionario se hace referencia a la llave correspondiente a la entrada deseada mediante el método objectForKey. Por ejemplo:

NSLog ( @"100-432112 = %@", [misLibros objectForKey: @"100-432112"]);
NSLog ( @"200-532874 = %@", [misLibros objectForKey: @"200-532874"]);
NSLog ( @"202-546549 = %@", [misLibros objectForKey: @"202-546549"]);
NSLog ( @"104-109834 = %@", [misLibros objectForKey: @"104-109834"]);

Borrar un elemento del diccionario

Podemos borrar entradas específicas del diccionario mediante referencia a la llave como argumento al método removeObjectForKey. Por ejemplo, para eliminar la entrada de un libro, podemos escribir el siguiente código:

[misLibros removeObjectForKey: @"104-109834"];

Para eliminar todo el contenido de un diccionario utilizamos:

[misLibros removeAllObjects];

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"));
            }
        }
    }
}

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.

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

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.

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...

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