Detectar con PHP el dispositivo en el que se ve la página HTML

Este script es muy util. Gracias a Heriberto Samayoa

<?php
 
   $es_movil=FALSE; //Aquí se declara la variable falso o verdadero XD
   $usuario = $_SERVER['HTTP_USER_AGENT']; //Con esta leemos la info de su navegador
 
   $usuarios_moviles = "Android, AvantGo, Blackberry, Blazer, Cellphone, Danger, DoCoMo, EPOC, EudoraWeb, Handspring, HTC, Kyocera, LG, MMEF20, MMP, MOT-V, Mot, Motorola, NetFront, Newt, Nokia, Opera Mini, Palm, Palm, PalmOS, PlayStation Portable, ProxiNet, Proxinet, SHARP-TQ-GX10, Samsung, Small, Smartphone, SonyEricsson, SonyEricsson, Symbian, SymbianOS, TS21i-10, UP.Browser, UP.Link, WAP, webOS, Windows CE, hiptop, iPhone, iPod, portalmmm, Elaine/3.0, OPWV"; //En esta cadena podemos quitar o agregar navegadores de dispositivos moviles, te recomiendo que hagas un echo $_SERVER['HTTP_USER_AGENT']; en otra pagina de prueba y veas la info que arroja para que despues agregues el navegador que quieras detectar
 
   $navegador_usuario = explode(',',$usuarios_moviles);
 
   foreach($navegador_usuario AS $navegador){ //Este ciclo es el que se encarga de detectar el navegador y devolver un TRUE si encuentra la cadena
      if(eregi(trim($navegador),$usuario)){
         $es_movil=TRUE;
      }
   }
 
   if($es_movil==TRUE){
      header('Location:http://Aquí va la URL de tu web movil');
   }
   else{
      header('Location:http://Aquí va la URL de tu web normal');
   }
 
?>

Grabar un archivo xml pequeño en disco con AIR

Guarda en disco las preferencias en un archivo de tipo XML:

import flash.filesystem.File;

var dir:File;

var fs:FileStream = new FileStream();
fs.addEventListener(Event.COMPLETE, onFileStreamComplete);
fs.openAsync(new File("app-storage:/prefs.xml"), FileMode.WRITE);
var fileData:String = '<?xml version="1.0" encoding="utf-8"?>';
fileData += "<prefs><defaulDirectory>"+dir.nativePath+"</defaultDirectory></prefs>";
fs.writeUTFBytes( fileData);

function onFileStreamComplete(e:Event):void{
   var fs:FileStream = e.target as FileStream;
   fs.close();
}

Seleccionar un directorio de la computadora por medio de AIR y lee las imágenes

Seleccionar un directorio de la computadora por medio de AIR y lee las imágenes

Con la instrucción browseForDirectory se abre una ventana para seleccionar un directorio y selecciona las imagenes jpg y las carga en un componente de tipo tile llamado imagenes_list:

import flash.filesystem.File;

var file:File = new File();
file.addEventListener(Event.SELECT, onSeleccionaDirectorio);
file.browseForDirectory("Imágenes");

function onSeleccionaDirectorio(e:Event):void{
   //Directorio seleccionado
  //
   //Es un componente lista
   imagenes_list.removeAll();
   var fileRef:File = event.target as File;
   //Creamos un arreglo con la lista de los archivos en el directorio
   var dir_array:Array = fileRef.getDirectoryListing();
   for each(var file:File in dir_array){
      if(file.isDirectory==false && file.isSymbolicLink==false && (file.nativePath.search(".jpg") != -1){
         var o:Object = new Object();
         o.data = file.nativePath;
         o.source = file.nativePath;
         imagenes_list.addItem(o);
      }
   }
}

Proceso asíncrono vs. proceso síncrono en la lectura de archivos en AIR

Proceso síncrono

var stream:FileStream = new FileStream();
stream.open(fileRef, FileMode.READ);

var data:String = stream.readUTFBytes(stream.bytesAvailable);
stream.close();

Proceso asíncrono

var stream:FileStream = new FileStream();
stream.addEventListener(Event.COMPLETE, onComplete);

function onComplete(e;Event):void{
   var data:String = stream.readUTFBytes(stream.bytesAvailable);
   stream.close();
}

Creamos una nueva instancia de FileStream, y la controlamos con un evento Event.COMPLETE
y cuando este completa, leemos el archivo y lo cerramos.

El proceso síncrono es facil de codificar pero hace que la aplicación se detenga en lo que se lee el archivo, por lo que debe utilizarse en el proceso de archivos pequeños.

El proceso asíncrono es más código, pero se pueden utilizar en archivos grandes, ya que no detiene la operación del sistema.

Introducciòn al manejo de archivos en AIR

Mejor conocido como File System Support

flash.filesystem.File
Información sobre los archivos, como tamaño, nombre, tipo, etc.

flash.fileSystem.FileMode
Es el el modo en como fue abierto el archivo, READ, WRITE, APPEND, UPDATE

flash.filesystem.FileStream
Esta clase abre archivos, los lee y escribe sobre ellos

AIR permite tambien:

Copiar un archivo o un directorio
Borrar un archivo o directorio
Enviar un archivo o directorio al cesto de basura
Mover un archivo o directorio
Leer la lista de archivos de un directorio

La clase File contiene referencias estáticas para especificar directorios de trabajo sin importar el sistema operativo:

File.applicationDirectory
Es donde se ejecuta la película app:/

File.applicationStorageDirectory
Es donde se almacenan los datos de la aplicación app-storage:/

File.desktopDirectory
El escritorio de la computadora

File.documentsDirectory
Hace referencia al directorio de documentos

File.userDirectory
Hace referencia al directorio del usuario

Ojo: cuando se borra un archivo y no se mando al cesto de reciclaje, se BORRA definitivamente el archivo

La sentencia Include en ActionScript 3.0

La sentencia Include sigue siendo utilizada en ActionScript 3.0, aunque no es muy buena idea si se tienen clases, pero si se requiere hay que utilizarla sin el símbolo de número o "gatito" como se utiliza en ActionScrip 2.0 y otros lenguajes.

Tampoco es buena idea colocar sus script en el mismo directorio que sus clases, y de preferencia escribir el nombre del archivo con minúscula (para que no se confundan).Curiosamente pueden llevar punto y coma al final esta directiva del compilador, pero el nombre del archivo debe estar entre comillas.

include "scripts/botones.as"

Cominicarse con una película que se carga en ActionScript 3.0

Ahora con ActionScript es muy sencillo comunicarse con un archivo SWF. Un ejemplo clásico es tener un lanzador y cargar  diferentes SWF con contenido. Supongamos que deseamos controlar el volumen de los archivos cargados desde el lanzador, de lo contrario, cada título que carguemos tendríamos que modificar el volumen. Para ello necesitamos pasar un parámetro a cada película. Otra posible modalidad es que el lanzador pase un parámetro de seguridad, para que las películas no se ejecuten si no se cargan desde el lanzador.

Primero debemos cargar el swf en un objeto de la clase Loader:

function cargaSWF(archivo:String):void {
            loader = new Loader();
            var req:URLRequest = new URLRequest(archivo+".swf");
            //
            loader.load(req);
            addChild(loader);
            loader.contentLoaderInfo.addEventListener(Event.INIT,onInit);
            //
}

private function onInit(event:Event ):void {
            //Aqui esta el truco, la propiedad content y manejarla como movieClip
            movie=loader.content as MovieClip;
            //A partir de este punto ya lo podemos tratar como un movieClip
           //mas del escenario y llamar propiedades
            movie.parametros(_volumenSonido, _volumenMusica);
            movie.addEventListener(BOTONES,onBotonesPelicula);
            movie.addEventListener("fin",onFinPelicula);
 }


Aqui el único problema es que en la película que carga le tengo que poner el dispatchEvent en el segundo fotograma. Las funciones que se llaman si se escriben desde el primer fotograma, pero funciona muy bien.

Detectar cuando el cursor deja el escenario

Es muy util detectar cuando el apuntador del ratón deja el escenario

Necesitamos detectar el evento

Event.MOUSE_LEAVE:

package {
   import flash.display.MovieClip;
   import flash.events.MouseEvent;
   import flash.events.Event;
   import flash.text.TextField;

   public class MiPelicula extends MovieClip{

       public function MiPelicula () {
          stage.addEventListener(Event.MOUSE_LEAVE, onSaleApuntador);
       }

       function onApuntadorAdentro(event: MouseEvent){
          trace("El apuntador esta dentro");
         stage.removeEventListener(MouseEvent.MOUSE_MOVE, onApuntadorAdentro);
       }

       function onApuntadorAfuera(event: Event){
          trace("Salio el apuntador del ratón");
          stage.addEventListener(MouseEvent.MOUSE_MOVE, onApuntadorAdentro);
       }
    }
} 

La zona de datos encriptada en AIR

Primero necesitamos importar las siguientes clases:

import flash.data.*;
import flash.filesystem.File;
import flash.data.EncryptedLocalStore;
import flash.utils.ByteArray;


Encriptamos datos por medio de la clase flash.utils.BytesArray, que nos servirá para guardar datos en forma binaria. Cada una de las aplicaciones (y cada uno de los usuarios de la aplicación) tendrá una archivo cifrado, el cual se puede guardar y extraer información con la clase EncryptedLocalStore.
Los datos encriptados se colocan en un subdirectorio del directorio de datos de aplicación del usuario; la ruta del subdirectorio es Adobe/AIR/ELS/ seguido del identificador de la aplicación.
Si se manejan datos en el disco duro del usuario, se recomienda que la información se encuentre encriptada.
Si actualiza una aplicación de AIR, se recomienda el uso de BytesArray.
Se debe usar una instacia BytesArray dentro de la clase EncryptedLocalStore.

//Almacenar como datos binarios:
var data:String = "Esta es una cadena";
var ba:BytesArray = new BytesArray();
ba.writeUTFBytes(data);

//Recuperar los datos binarios a datos decimales
var returnedData:String = ba.readUTFBytes(ba.bytesAvailable);

La clase BytesArraytiene varios métodos para escribir y leer información en diferentes formatos:

writeUTFBytes()	readUTFBytes()
writeInt()	readInt()
writeBoolena()	readBoolena()

Información encriptada

Sólo se puede almacenar 10MB de información encriptada por aplicación AIR

var ba:BytesArray = new BytesArray();
ba.writesUTFBytes( password.text);
EncrypedLocalStore.setItem(username.text, ba);
username.text = "";
password.text = "";

Leer los datos encriptados:

var ba:ByteArray = EncryptedLoaclStore.getItem(username.text);
if(ba){
var returnedPassword:String = ba.readUTFBytes( ba.bytesAvailable );
if(password.text==returnedPassword){
     this.visible = false;
} else {
      trace("Password incorrecto");
} else {


Otro ejemplo:

var str:String = "Bob";  
var bytes:ByteArray = new ByteArray();  
bytes.writeUTFBytes(str);  
EncryptedLocalStore.setItem("firstName", bytes);    

var storedValue:ByteArray = EncryptedLocalStore.getItem("firstName");  
trace(storedValue.readUTFBytes(storedValue.length)); // "Bob"    

EncryptedLocalStore.removeItem("firstName");

Guardar datos en la computadora con ActionScript/Flash

Una manera sencilla de almacenar datos en la computadora del usuario, sin necesidad de utilizar AIR, es por medio de las "super cookies" de la instrucción ShareObject:

Para crear un objeto persistente (almacenado en el disco duro del cliente) basta con definirlo: si existe lo lee y si no lo crea en blanco:

var datos:ShareObject = SharedObject.getLocal("datos");

Para almacenar datos basta con guardarlos en la propiedad "data" del objeto.

datos.data.boleta = boleta_array;

Para almacenar los datos explícitamente en disco, se utiliza el método flush()

datos,flush();

Se puede determinar el tamaño del objeto por medio de la propiedad size:

if(datos.size==0){
   trace("No hay datos");
}

Para llamar un valor ya existente, basta con nombrarlo:

trace(datos.data.nombre);

El único inconveniente es que si el usuario no permite gravar los datos, con la seguridad del Flash Player (botón secundario del ratón) pues no se podrá gravar los datos.

AIR tiene muchas tras formas de gravar los datos en el disco duro, esta es la más sencilla.

Si programas con clases, hay que importar:

import flash.net.SharedObject;