AJAX (Asynchronous JavaScript And XML) nos propone una técnica de desarrollo web basada en el cambio de contenido de las páginas de forma asíncrona, sin necesidad de recargarlas, lo que reduce el trafico con el servidor y nos permite crear aplicaciones interactivas en las que potenciaremos la velocidad y usabilidad de las mismas. La interfaz de estas aplicaciones se ejecutará integramente en el navegador del usuario, de manera que tan solo se comunicará con el servidor para enviar y obtener nueva información.

Para ello dispondremos de los siguientes elementos:

• (X)HTML + CSS
• Lenguaje interpretado: típicamente Javascript.
• Lenguaje de marcas: XML
• Interfaz de comunicación asíncrona: XMLHttpRequest

El funcionamiento de todo esto es muy simple: cuando se den las circustancias adecuadas o el usuario genere un evento concreto, se enviará una petición HTTP estandar al servidor de manera asíncrona, y cuando tengamos dicha información la procesaremos y pasaremos a actualizar la interfaz como corresponda.

Esto se ve mas claro en el siguiente gráfico:

Esquema de llamadas AJAX

Además, debido a que muchas de estas llamadas se realizan para obtener información actualizada en tiempo real o recoger eventos que ocurrieron en la parte del servidor, deberemos escoger una estrategia adecuada que nos permita tener la información de la aplicación lo mas actualizada posible. Para ello disponemos de 3 estrategias diferentes en cuanto a como y cuando hacer estas llamadas:

1.- Polling

AJAX: Polling

Se realizará una petición y el servidor responderá al momento, haya o no haya datos nuevos a aportar. Si se produce un evento en el servidor que provoque que se deba enviar nueva información, el envío de la misma deberá esperar hasta que al cliente AJAX (navegador del usuario) quiera actualizarla, con lo cual se perderá tiempo y se perderá el concepto de tiempo real.

2.- Long Polling

AJAX: Long Polling

En este caso, al contrario que en el polling simple, el servidor no responderá a la petición hasta que tenga algo que enviar y, en cuanto el navegador reciba dicha respuesta, mandará de nuevo otra petición cuya respuesta esperará a que haya un evento que enviar.

3.- HTTP Streming (Push)

AJAX: HTTP Streaming

Por último tenemos el llamado HTTP Streaming, en el que abriremos al inicio una conexión enviando una petición y posteriormente iremos recibiendo datos según los vaya generando el servidor, sin necesidad de cerrar la conexión. Esta es la principal diferencia con long polling, en la primera se abre y se cierra una conexión por cada comunicación con el servidor, al contrario que en HTTP Streming donde la primera conexión se reutiliza para enviar los datos a lo largo de toda la sesión. Al mantener la conexión abierta reduciremos el retardo entre la generación del evento y la llegada del mismo a la interfaz, pero por otra parte podemos colapsar el cliente si la información a recibir es muy voluminosa, lo que provocará que la información no se pueda actualizar en tiempo real, con lo cual perdemos la ventaja de la baja latencia.

Por norma general usaremos Polling cuando queramos actualizar la interfaz si no importa que haya un retardo y no sea en tiempo real, y usaremos Long Polling o HTTP Streaming en caso de que queramos información actualizada al momento.

Nada mas por hoy. Proximamente volveré con un breve tutorial de AJAX con JQuery.
Hasta entonces.

Además, el codigo JS será compatible con la práctica totalidad de los navegadores web del momento, con lo que no tenemos que rompernos la cabeza con incompatibilidades entre los mismos, especialmente al emplear la técnica de desarrollo web AJAX.

En esta introducción veremos que cambios ocasiona el uso de JQuery y cómo realizar las tareas más comunes que veniamos realizando con Javascript, incluyendo llamadas asíncronas (AJAX).

1.- Selección de elementos

Comunmente, en JS utilizábamos sentencias tipo “document.getElementById(‘id_elemento’)” para obtener un elemento concreto y posteriormente realizar tareas sobre el mismo u obtener un valor concreto.

Con JQuery esto es muchisimo mas sencillo:

• Seleccion por id: $(“#id_elemento”)
• Seleccion por class: $(“.clase”)
• Seleccion de todos los elementos de un tipo: $(“p”), $(“img”), $(“input”)
• Seleccion con filtro por valor de atributo: $(“input[name='username']“) (selecciona todos los input cuyo atributo name sea igual a “username”).
• Podemos combinarlos: $(“input.clase[name='username']“)

Guia de selectores de JQuery
Todos estos selectores nos devolveran un objeto de tipo Array, por lo tanto podremos recorrelo con un “.each(function() {})” pudiendo hacer referencia a cada objeto usando el selector “$(this)” u obtener un objeto de JS estandar con un “.get(int)”.

2.- Atributos , Clases y Estilos CSS

En JS estandar accedemos a los mismos como “element.attribute”, sin embargo en JQuery podremos actuar directamente sobre el array devuelto por el selector, aunque solo sobre el primer elemento del mismo.

• Obtener valor de atributo: $(selector).attr(“attr_name”) (devuelve un string).
• Establecer valor: $(selector).attr(“nombre_atributo”, “valor”)
• Eliminar atributo: $(selector).removeAttr(“nombre_atributo”)
• Añadir clase (class): $(selector).addClass(“nombre_clase”)
• Eliminar clase: $(selector).removeClass(“nombre_clase”)
• Obtener valor (value): $(selector).val()
• Establecer valor (value): $(selector).val(“valor”)
• Establecer valor de estilo CSS: $(selector).css(“elemento”, “valor”) ( pj: .css(“display”, “none”) )
• Obtener valor de elemento CSS: $(selector).css(“elemento”)
• Establecer tamaño CSS: $(selector).width(anchura), $(selector).height(altura)
• Obtener tamaño CSS: $(selector).width(), $(selector).height()

Guia de manipulación de atributos en JQuery
Guia de CSS en JQuery

3.- Manipulación de contenido

• Obtener contenido HTML: $(selector).html()
• Establecer contenido HTML: $(selector).html(“contenido”)
• Añadir contenido al principio: $(selector).prepend(“contenido”)
• Añadir contenido al final: $(selector).append(“contenido”)

Guia de manipulación de contenido en JQuery

4.- Eventos

• Función de click, se llama al hacer click sobre el elemento: $(selector).click( fn ).
• Función de focus, se llama al hacer focus en un elemento: $(selector).focus( fn ).
• Función de submit (típica de un formulario, se llama cuando este se envia): $(selector).submit( fn ).

Las funciones indicadas como “fn” se pueden haber definido antes como “var fn = function() { … }” o bien se puede escribir de forma implicita, pj, “$(selector).click(function() { alert(“Me han pulsado “);  })”. Al igual que en casos anteriores podemos utilizar “$(this)” para referenciar al objeto pulsado.

Guía de eventos en JQuery

5.- Efectos

Llegamos a una de las partes mas sorprendentes de JQuery, ya que con muy poco código podremos realizar animaciones complejas sin despeinarnos. Veamos algunos de los efectos mas comunes:

• Esconder/Mostrar un elemento: $(selector).hide(), $(selector).show() Esto esconderá/mostrará un elemento al momento, pero podremos animarlo con un simple .hide(velocidad), donde “velocidad” puede ser un string de entre “slow”, “normal” y “fast” o bien un valor numérico en milisegundos que durará dicha animación. Ademas podremos añadir una parámetro más en el que definiremos una función que se llamará cuando finalice la animación, ideal para componer animaciones ( .show(“slow”, function(){…})).
• Efecto slide (cortina): $(selector).slideUp(velocidad) $(selector).slideDown(…).
• Efecto desvanecimiento: $(selector).fadeIn(velocidad), $(selector).fadeOut(…)
• Parar animación en curso: $(selector).stop()

Además, podemos crear nuestros propios efectos de animación de forma simple:

• $(selector).animate(opciones, duracion) donde “opciones” será una serie de parámetros, por ejemplo:
• $(selector).animate({width: “100px”, height: “100px”}, 500): Haremos una animación que dure medio segundo y que vaya cambiando el tamaño actual del elemento a un tamaño de 100×100 pixels.

Guía de efectos en JQuery

Nada mas, espero que haya ayudado a conocer y comprender el funcionamiento de JQuery, al menos para las operaciones más básicas. No he comentado nada de la parte de AJAX, ya que esto lo dejo para otra ocasión, en la que entraré con más detalle en el uso de AJAX con JQuery, utlizando XML como respuesta de las llamadas asíncronas.

Enlaces relevantes:

JQuery

1.- Introducción

Para empezar empezaremos explicando FUSE y sus implicaciones. FUSE (Filesystem in Userspace) como su propio nombre indica, nos permitirá implementar sistemas de ficheros que se ejecuten en espacio de usuario, de manera que no deberemos tocar código del kernel para implementar un nuevo sistema de ficheros, ademas de que, en caso de fallo, no ocasionaremos inestabilidad alguna en el sistema. Para ello deberemos cargar un modulo de FUSE especifico en el kernel como muestra el siguiente gráfico:

FUSE arch

Como vemos, desde espacio de usuario (programa que usa el FS concreto) accederemos al espacio de kernel (a través de la capa de abstracción VFS) y volveremos al espacio de usuario donde tenemos el modulo FUSE de nuestro sistema de ficheros ejecutándose.

2.- Funciones de FUSE (VFS)

Ya que la interfaz con el kernel sigue siendo basada en VFS (como si lo implementasemos en el nucleo), deberemos conocer las operaciones de VFS y su funcion. La API de FUSE no es exactamente VFS, pero esta basadco en la misma y tienen la mismas operaciones. Pasamos a enumerar y describir las funciones de VFS más comunes:

• int(* getattr )(const char *, struct stat *)
  • Es llamada a la hora de obtener el estado de cada archivo. Su función es devolver el estado para el archivo dado, para ello deberemos devolver una estructura de tipo “struct stat” donde almacenaremos los datos de acceso, tamaño, fechas, etc.ç
  • El primer parametro indica el path del fichero concreto.
• int(* mkdir )(const char *, mode_t)
  • Es llamada cuando se desea crear una carpeta.
  • Los parámetros indican el path de la carpeta nueva y el modo de creación.
• int(* unlink )(const char *)
  • Recibe el path de un fichero concreto que se desea eliminar.
• int(* rmdir )(const char *)
  • Recibe el path completo de un directorio que se desea eliminar.

  int(* rename )(const char *, const char *)

  • Llamada cuando se renombra o se mueve un archivo.
  • Recibe como argumentos el path antiguo y el nuevo.
• int(* mknod )(const char *, mode_t, dev_t)
  • Crea un nuevo fichero en el path y con los permisos dados.
• int(* truncate )(const char *, off_t)
  • Cambia el tamaño de un archivo al numero de bytes dado.
  • Se llama al guardar un fichero al que se le ha cambiado el tamaño (pj: un fichero de texto).
• int(* opendir )(const char *, struct fuse_file_info *)
• int(* open )(const char *, struct fuse_file_info *)
  • Se llama al abrir un directorio (opendir) o  un fichero (open).
  • Deberemos devolver si se autoriza el permiso o no. Mas tarde veremos los posibles valores a devolver.
• int(* read )(const char *, char *, size_t, off_t, struct fuse_file_info *)
• int(* write )(const char *, const char *, size_t, off_t, struct fuse_file_info *)
  • Se llaman al leer/escribir en un fichero.
  • En el caso de lectura, deberemos escribir en el buffer los datos recuperados del fichero.
  • En caso de escritura deberemos leer del buffer la información a escribir en el fichero.
• int(* readdir )(const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info *)
  • Se llama al listar el contenido de un directorio, por lo tanto deberemos rellenar la lista (void *) con una funcion filler que nos proporcionan de tipo “fuse_fill_dir_t”.
  • Para ello, por cada archivo deberemos llamar al filler:
    • filler (buffer, file->filename, &file->stat, 0);
      • Donde “buffer” es el buffer que nos proporcionan, “file->filename” es el nombre del fichero y “&file->stat” es la dirección de memoria de una estructura de tipo “struct stat” que contendrá el estado del fichero.
• int(* flush )(const char *, struct fuse_file_info *)
• int(* fsync )(const char *, int, struct fuse_file_info *)
  • Se llaman al hacer un flush sobre un archivo (flush) o al cerrar un archivo (fsync).
  • Deberemos confirmar cambios en el FS o realizar otro tipo de acción al cerrar cada archivo.
• void(* destroy )(void *)
  • Se llama al desmontar un volumen.
  • Deberemos liberar memoria.

Vamos a ver que valores podemos devolver desde estas funciones para hacerlo mas completo:

• -ENOENT: El fichero/directorio solicitado no existe.
• -EPERM: No dispone de los permisos adecuados para realizar la operación solicitada.
• -EEXIST: El fichero/directorio ya existe.
• -EACCES: No tiene permisos de acceso.
• -ENOSPC: No hay espacio disponible.
• -EINVAL: Argumento no válido.
• 0: Operación finalizada con éxito.

Y con esto ya podemos implementar un sistema de ficheros simple y completo.

3.- Ejemplo de estructura

Veamos un ejemplo de estructura principal de una implementación simple en FUSE:

static int readDirectory (const char *path, void *buffer, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *fi)
{
[........]
}

[...............]

int main(int argc, char **argv) {

static struct fuse_operations _operations;
_operations.getattr = readAttr;
_operations.readdir = readDirectory;
_operations.open = openFile;
_operations.read = readFile;
_operations.write = writeFile;
_operations.statfs = getFSStats;
_operations.destroy = cleanFS;
_operations.unlink = removeFile;
_operations.flush = syncFlushFS;
_operations.fsync = syncFS;
_operations.mknod = createNode;
_operations.rename = renameFile;

return fuse_main (argc, argv, &_operations, NULL);
}

Posteriormente lo compilares con un simple:

gcc main.c  -o fusexample -lfuse

Una vez lo hayamos compilado podremos ejecutarlo como:

./fusexample mount_point

En caso de que queramos pasarle un parametro propio, como un dispositivo (/dev/sdb1) deberiamos ejecutarlo como:

./fusexample /dev/sdb1 mount_point

y en el codigo interno deberemos filtrar el primer parametro (/dev/sdb1) para no madnarselo a FUSE a traves de la llamada a fuse_main, por ejemplo usando esto: “return fuse_main (argc-1, &argv[1], &_operations, NULL);”.

Nada mas por hoy, espero que haya sido de ayuda y haya ayudado a comprender un poco mas el funcionamiento de FUSE.

Enlaces:

• FUSE Operations API

• Arturo
• Artu
• Turo
• Turito
• Torito
• Toro
• Tori
• Arthur
• Arthuri
• Hart
• Néno
• Né
• Berfenger
• Berfen
• Notas
• Notario

Y dentro de poco “El de la cara cómica”, o algo.

Vamos, que si algún dia respondo al nombre de pepe o gumersindo, que nadie se extrañe.

Y hasta aquí el post chorra del… dia, semana, mes, o cuando cuadre.

Los cambios respecto a la anterior version son:

• Corregido bug de renombrado cuando se cambiaba la ID.
• Incluidos parches de usb loader 1.5.
• Añadido scrubbing por defecto.
• Añadidas opciones para control de scrubbing.
• Corregido bug de borrado que corrompia el sistema de ficheros WBFS.

Para incluir estas funcionalidades se ha añadido opciones:

Uso: ./wbfuse /dev/sdxy punto_montaje [opciones]

Opciones:
-g :Activar Image Scrubbing manteniendo solo la partición de juego.
-n : Desactivar Image Scrubbing.

Por defecto el scrubbing esta activado, manteniendo todas las particiones.

Comandos de renombrado:

• Cambiar ID y/o nombre: Renombrar a “ABCDEF|Nombre de juego” (sin comillas).
• Scrubear imagen previamente copiada: Renombrar a “scrub” (sin comillas).

Descarga:

• Descarga precompilado 32 bits (i386)
• Descarga precompilado 64 bits (x86_64)
• Descarga codigo fuente

Los cambios respecto a la primera version son:

• Corrección de bugs menores.
• Añadido soporte completo para 64 bits (x86_64).
• Añadido soporte para scrubear imagenes (hacer que ocupen menos de 4,4GB).
• Añadido soporte para scrubear imagenes previamente añadidas.

Para incluir estas funcionalidades se ha añadido una opcion:

Uso: ./wbfuse /dev/sdxy punto_montaje [opciones]

Opciones:
-s :Activar Image Scrubbing.

Comandos de renombrado:

• Cambiar ID y/o nombre: Renombrar a “ABCDEF|Nombre de juego” (sin comillas).
• Scrubear imagen previamente copiada: Renombrar a “scrub” (sin comillas).

Aquí os dejo los enlaces de descarga:

• Descarga precompilado 32 bits (i386)
• Descarga precompilado 64 bits (x86_64)
• Descarga codigo fuente

Caracteristicas:

• Integracion con todos los navegadores de linux y consola (ext VFS mediante FUSE).
• Poder usar la particion como almacenamiento generico.
• Poder renombrar tanto archivos como nombre e ID de las isos de Wii (para ello sera necesario renombrarlas como ID|Nombre, pj R64P01|Wii Musica).
• Poder conocer espacio total y libre mediante el navegador, asi como borrar archivos o isos de wii.
• Poder leer y escribir isos de wii a tamaño completo 4.4GB o 8,75GB.
• Poder utilizar la partición WBFS como almacenamiento de isos completas de wii.

Desventajas:

• Escritura y lectura lenta (Al tener que manejar isos a tamaño completo (4.4GB o 8,75GB)).
• Solo es posible escribir las ISOs a tamaño completo, no se pueden eliminar particiones ni espacios en blanco. (Limitación de FUSE)

En unos dias publicaré un pequeño manual de FUSE donde expondré parte de lo aprendido durante la realización de esta aplicación.

Hasta otra.

Enlaces: Descarga

Para activarlo de nuevo haremos lo siguiente:

$ sudo aptitude install dontzap
$ sudo dontzap –disable

Una vez reiniciemos el servidor X11, ya podremos reiniciarlo de nuevo con la magica combinación.

El juego nos propone una historia simple, basada en el archiconocido mundo de desaveniencias entre trolls y elfos, con la originalidad, hasta cierto punto, de los guerreros elementales. Es decir, cuando tengamos el poder de uno de estos guerreros, podremos, en cualquier momento, convertirnos en el mismo para usar sus habilidades, de las que no podremos abusar, ya que contamos con una barra de poder que se recarga cada cierto tiempo. Pasemos a describir brevemente aspectos mas concretos del juego.

Gráficos

En este campo no destaca especialmente, ya que fue uno de los primeros de la actual generacion de consolas. Aunque cabe resaltar los buenisimos efectos de agua y mojado de los personajes, algo que incluso hoy sigue impresionando, y que ya incorporaban otros titulos de Rare como Starfox Adventures para NGC.

Sonido

Este apartado no pasa de correcto, no hay nada que destaque especialmente y las músicas pueden resultar repetitivas por momentos, aunque ayudan a la inmersión en el mundo de fantasía creado para la ocasión. También hay muy poca variedad de voces, que se repiten en zonas concretas (entrada a menús, etc), aunque como punto a favor, diré que para la mayoría de los textos narrados y de personajes, existe una voz doblada al castellano, aunque el doblaje deja bastante que desear; pero al menos se han tomado la molestia de hacerlo.

Jugabilidad

Este es, sin duda, el punto fuerte del juego. Durante el juego iremos liberando guerreros elementales que nos darán nuevas habilidades y tendremos que explorar el escenario de nuevo para encontrar nuevos caminos a desbloquear con nuestro nuevo amigo. En cada situacion deberemos utilizar las habilidades que necesitemos de entre las que poseen nuestros guerreros, lo que da algo de libertad a la hora de afrontar situaciones y enemigos. Ademas, consiguiendo los extras del juego (que no son pocos) conseguiremos nuevas habilidades y movimientos para nuestros guerreos elementales, lo que le da un toque de rol al juego y aumenta mucho las posibilidades del mismo.

En cuanto a la dificultad, está bastante ajustada. En el modo normal no es algo dificil hasta el final, pero sigue siendo facil. En el modo dificil, ya se complica algo mas, aunque por lo general se podria decir que es un juego facilon para todos los publicos.

Multijugador

El modo multijugador se ha implementado de la mejor forma posible según mi parecer, esto es, un modo cooperativo online, aunque para ello es necesario descargar una actualizacion gratuita a traves de Xbox live. No lo he probado, asi que no lo puedo analizar con mas profundidad.

Duración

La historia principal es mas bien corta, aunque si queremos conseguir todos los extras, nos llevara bastante más tiempo, ya que son muchos. Recordemos que los extras nos permiten conseguir nuevas habilidades para nuestros guerreros elementales, habilidades generales, etc.

Conclusión

Estamos ante un juego muy grande, tanto en los pequeños detalles, como en ambientación, el numero de extras, la magia que respira todo el titulo, la “magia Rare”, que le llame antes. Sin duda un juego recomendable para todos los seguidores de Rare y plataformas que busquen algo de originalidad.

Nombre: Kameo: Elements of Power
Estudio de desarrollo: Rare
Plataformas: Xbox 360
Nota final: 8.0

¿Por qué quiero jailbreakearlo? (me acabo de inventar un nuevo verbo). Pues por diversas razones, desde poder acceder al dispositivo por SSH, pasando por poder bajar archivos desde Safari y librarme, por fin, del maldito iTunes, entre otras muchas cosas. Después de leer el post, lo entenderéis

Empecemos:

1.- Nos descargamos, instalamos y ejecutamos QuickFreedom

2.- Tras iniciar el programa pulsaremos en “Jailbreak iPod”.

3.- Deberemos bajar e instalar libUSB y el firmware 2.2.1 para el iPod. Deberemos asegurarnos que nuestro iPod ya se encuentre con la versión 2.2.1, si no, deberemos actualizar.

Deberemos instalar libUSB y descargar el firmware 2.2.1

4.- Seleccionaremos si queremos instalar “Installer” o si queremos cambiar la imagen que se muestra al arranque (mientras se enciende), y pulsaremos en “Create Firmware”. Puede tardar entre 10 y 15  minutos.

5.- Conectaremos el iPod al PC mediante USB y lo pondremos en modo DFU.

Para ponerlo en modo DFU deberemos apagarlo, pulsar y mantener Power+Home y, a los 10 segundos, soltar el botón Power. Seguiremos apretando el botón Home hasta que Windows nos reconozca el dispositivo como Apple DFU Driver (10 segundos mas). La pantalla debería quedarse en negro.

Si esta correctamente configurado, nos debería aparecer en QuickFreedom “iPod is connected in DFU mode”.

5.- Pulsaremos en “Start Pre-Jailbreak” para que aplique el parche redsnow y lo deje listo para el jailbreak.

Haremos un Pre-Jailbreak (redsnow)

6.- Una vez esté en Pre-Jailbreak mode, abriremos el iTunes (si no se nos ha abierto ya) y pulsaremos en “Restaurar” mientras mantenemos la tecla “Mayusculas” presionada. Seleccionamos el archivos que nos ha generado anteriormente el QuickFreedom y comenzara el proceso de jailbreak. Suele tardar unos 15 minutos.

Tras el próximo arranque, deberemos ver el dispositivo “pelado” con Cydia e Installer (si lo hemos seleccionado previamente).

Vale, ya hemos hecho el jailbreak. ¿Y ahora qué?

Lo primero, y mas recomendable, es conectarlo de nuevo, iniciar el iTunes y dejar que este restaure una copia de seguridad del dispositivo, para recuperar Configuracion, Bookmarks, Aplicaciones, Música, Vídeo, etc que teníamos antes. Posteriormente procederemos a la instalación de aplicaciones desde Cydia, de las que recomiendo:

• Cydia Community Sources: Añade repositorios de la comunidad de Cydia, que nos permitirán bajar la mayoría de las aplicaciones que menciono en este post.
• OpenSSH: Nos permite conectarnos al dispositivo por SSH tanto para copiar archivos, como para administrarlo por linea de comandos
• Backgrounder: Nos permite mantener aplicaciones en segundo plano. Aunque no es muy recomendable, ya que se funde la batería en nada.
• Five Icon Dock: Nos permite tener 5 iconos en el dock del springboard.
• Winterboard: Nos permite cambiar por completo la apariencia del springboard y aplicaciones varias.
• Mobile Finder: Como el Finder de Mac OS, pero para el iPod.
• Mobile Terminal: Un terminal en toda regla. Nos permite tanto ejecutar comandos en local como conectarnos a maquinas remotas por SSH.
• Safari Download Plugin: Permite descargar archivos desde Safari (por fin!!!).
• Boss Prefs: Permite (des)habilitar los interfaces externos como GPRS, Bluetooth, SSH Server, Wifi, etc. (También se puede usar SBSettings, que integra esta funcionalidad en el Springboard, lo que nos permite acceder al menú en cualquier momento con solo pasar el dedo por la barra de estado (pero consume bastante bateria).
• vlc4iphone y mplayer: Ports de estos míticos reproductores de medios, que les queda mucho por mejorar, pero hacen bastante bien su funcion con vídeos pequeños.
• MxTube: Descargar vídeos de youtube.

En cuanto a juegos tenemos muchas alternativas, sobre todo en cuanto a emuladores se refiere (no vienen en los repositorios por defecto):

• NES
• snes4iphone
• ScummVM
• Quake 3

Monkey Island en un iPhone a traves de ScummVM

También podremos añadir manualmente a Cydia el repositorio XSellize (http://xsellize.com/cydia/user-pass/) donde user y pass son tu usuario y contraseña de registro en dicha web. Una vez lo hagamos, se nos actualizara la base de datos de Cydia y podremos instalar mas programas como:

• IPA Prep 2.2: Nos permite instalar aplicaciones sin verificar desde iTunes.
• Emuladores y ROMS de NES y SNES.
• Hackulo.us’s Source: Añade un nuevo repositorio, con aplicaciones de dudosa legalidad, de las que no hablare en este post.
• iBlueTooth: Desbloquea el Bluetooth del iPhone (inútil para un iPod Touch).

Espero que haya sido de ayuda y que disfruteis (los que tengais oportunidad) de este magnifico trasto, sobre todo a partir del jailbreaking.