Tipos de datos de MobileProcessing

Primitivos boolean true/false
byte 8 bits -128 a 127
char 16 bits Carácteres UNICODE.Los carácteres se encierran entre comillas simples (Ejemplo: ‘a’, ‘b’, ‘c’).
int 32 bits -2,147,483,648 a 2,147,483,647.
color 32 bits AAAAAAAARRRRRRRRGGGGGGGGBBBBBBBB donde las A representan el valor del canal ALFA, las R son el valor rojo/tinte, las G son el verde/saturación y las B son el azul/brillo.Internamente es manejado como un int en MobileProcessing.
Compuestos Array Son listas finitas de elementos del mismo tipo.Ejemplo: tipo[] arreglo = new tipo[tamaño];

Los elementos del arreglo son referenciados por índices que empiezan en cero y van hasta la longitud del arreglo – 1.

Object Los objetos son instancias de clases, tienen métodos y atributos. Las instancias se crean con el operador new.
String Son secuencias de carácteres. La clase String incluye múltiples métodos para su manipulación.

Conversión a String.

La conversión desde un tipo primitivo hacia String se realiza mediante la función str(valor).

boolean b = true;
byte y = -120;
char c = 'J';
float f = -64.9;
int i = 1024;
String sb = str(b);
String sy = str(y);
String sc = str(c);
String sf = str(f);
String si = str(i);

Funciones y métodos de la clase String.

A continuación se explican las funciones que incluye el lenguaje para el manejo de cadenas.

join(arreglo, separador) Combina un arreglo en una cadena uniéndolo con el separador.
int arreglo = new int[3];
arreglo[0] = 100;
arreglo[1] = 200;
arreglo[2] = 300;
String resultado = join(arreglo, ", ");
// resultado = "100, 200, 300".

nf(entero, digitos)Da formato a un número entero según la cantidad de digitos especificada completando el número con ceros a la izquierda.

int i1 = 7;
int i2 = 30;
int i3 = 2008;
String s1 = nf(i1, 5);
// s1 = "00007".
String s2 = nf(i2, 3);
// s2 = "030".
String s3 = nf(i3, 6);
// s3 = "002008".

nfp(entero, digitos)Similar a nf() pero esta función agrega el símbolo mas (+) como prefijo de los valores positivos y el símbolo menos () como prefijo de los valores negativos.

int i1 = -7;
int i2 = 30;
int i3 = -2008;
String s1 = nfp(i1, 5);
// s1 = "-00007".
String s2 = nfp(i2, 3);
// s2 = "+030".
String s3 = nfp(i3, 6);
// s3 = "-002008".

nfs(entero, digitos)Es similar a nf() para dar formato a números enteros, sin embargo esta función agrega un espacio como prefijo a los valores positivos para que sus cifras se alineen correctamente con los valores negativos.

int i1 = -7;
int i2 = 30;
int i3 = -2008;
String s1 = nfp(i1, 5);
// s1 = "-00007".
String s2 = nfp(i2, 3);
// s2 = " 030".
String s3 = nfp(i3, 6);
// s3 = "-002008".

split(cadena, delimitador)Parte una cadena en subcadenas según las ocurrencias del delimitador y retorna un arreglo de las cadenas resultantes. Es funcionalmente opuesta a la función join().

String fecha = "31/03/2008";
String[] partes = split(fecha, '/');
// partes[0] = "31".
// partes[1] = "03".
// partes[2] = "2008".String numeros = "8 85 52 70";
int arreglo = int(split(numeros));
// arreglo[0] = 8.
// arreglo[1] = 85.
// arreglo[2] = 52.
// arreglo[3] = 70.

trim(cadena)Remueve los siguientes carácteres de ambos lados de la cadena: espacios en blanco, saltos de línea, tabulaciones y el carácter UNICODE “nbsp“.

String cadena = "     Esta cadena tiene espacios de sobra             ";
String corta = trim(cadena);
// corta = "Esta cadena tiene espacios de sobra".

La clase String por su parte incluye una gran variedad de métodos con los siguientes.

charAt(indice) Este método retorna el iésimo elemento de la cadena.
String saludo = "Hola Mundo";
char p1 = saludo.charAt(0);
// p1 = 'H'.
char p2 = saludo.charAt(3);
// p2 = 'a'.
char p3 = saludo.charAt(7);
// p3 = 'n'.

equals(cadena)Este método compara la cadena contra una segunda cadena recibida a través del parámetro y verifica si son la misma o no. Retorna true si las cadenas son la misma, false de lo contrario.indexOf(cadena, indice_inicio)Verifica si la cadena especificada es una subcadena de la propia y en caso de serlo retorna el índice de la ocurrencia, en caso de no serlo retorna siempre -1. El segundo parámetro: indice_inicio es opcional, en caso de especificarse la búsqueda se realiza a partir de dicho índice.

String cadena = "Esta es una cadena de ejemplo";
int p1 = cadena.indexOf("e");
// p1 = 5.
int p2 = cadena.indexOf("e", 6);
// p2 = 15.
int p3 = cadena.indexOf("no_esta");
// p3 = -1.

length()Este método retorna la longitud de la cadena.

String cadena = "Hola Mundo Loco";
int longitud = cadena.length();
// longitud = 15.

substring(indice_inicio, indice_final)Este método retorna una subcadena enmarcada en los índices especificados. El segundo índice: indice_final es opcional, en caso de no especificarse se considerará hasta el final de la cadena.

String cadena = "Esto es lo que somos";
String sub1 = cadena.substring(15);
// sub1 = "somos".
String sub2 = cadena.substring(8, 14);
// sub2 = "lo que".

toLowerCase()Este método retorna la cadena en letras minúsculas completamente.

String cadena = "Esta es una CADENA MuY vaRiaDa";
String lower = cadena.toLowerCase();
// lower = "esta es una cadena muy variada".

toUpperCase()Este método retorna la cadena en letras mayúsculas completamente.

String cadena = "Esta es una CADENA MuY vaRiaDa";
String upper = cadena.toUpperCase();
// upper = "ESTA ES UNA CADENA MUY VARIADA".

Para consultar la información de más métodos de la clase String refiérase a la documentación del API de Java.

Funciones relacionadas con arreglos.

append(arreglo, elemento) Agrega el elemento al final del arreglo. El elemento debe ser de igual tipo que el arreglo
String[] arreglo = {"uno", "dos", "tres"};
String[] nuevo = append(arreglo, "CUATRO");
// nuevo = {"uno", "dos", "tres", "CUATRO"}.

concat(arreglo1, arreglo2)Retorna la unión del arreglo1 con el arreglo2. Ambos arreglos deberán ser de igual tipo.

int[] arr1 = {1, 2, 3, 4};
int[] arr2 = {10, 20, 30, 40};
int[] resultado = concat(arr1, arr2);
// resultado = {1, 2, 3, 4, 10, 20, 30, 40}.

contract(arreglo, nuevo_tamaño)Retorna la versión contraída del arreglo referenciado. Los valores sobrantes son descartados.

int[] arreglo = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int longitud_completa = arreglo.length;
// longitud_completa = 10.
int[] resultado = contract(arreglo, 7);
int longitud_parcial = resultado.length;
// longitud_parcial = 7;

expand(arreglo, nuevo_tamaño)Esta función aumenta el tamaño del arreglo al nuevo_tamaño especificado. Si este segundo parámetro no se especifica se considerará el doble del tamaño actual.

int[] arreglo = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int longitud_completa = arreglo.length;
// longitud_completa = 10.
int[] resultado = expand(arreglo, 15);
int longitud_ampliada = resultado.length;
// longitud_ampliada = 15;

length(arreglo)Retorna la longitud o tamaño del arreglo. Esta función es análoga al atributo length.

String[] arreglo = {"primero", "segundo", "tercero", "cuarto"};
int longitud = length(arreglo);
// longitud = 4.
int tamano = arreglo.length;
// tamano = 4.

reverse(arreglo)Retorna una versión invertida: los elementos dispuestos en orden inverso, del arreglo original.

int[] arreglo = {1, 2, 3, 4, 5};
int[] inverso = reverse(arreglo);
// inverso = {5, 4, 3, 2, 1}.

shorten(arreglo)Retorna una copia del arreglo con su último elemento removido.

String[] arreglo = {"rojo", "azul", "verde", "cafe", "naranja"};
String[] corto = shorten(arreglo);
// corto = {"rojo", "azul", "verde", "cafe"}.

splice(arreglo, elemento, indice)Retorna una versión ampliada del arreglo con el elemento (puede ser un valor u otro arreglo) insertado en la posición indice.

int[] arreglo = {10, 20, 30, 40, 50};
arreglo = splice(arreglo, 15, 1);
// arreglo = {10, 15, 20, 30, 40, 50}.
int[] seccion = {32, 34, 36, 38};
arreglo = splice(arreglo, seccion, 4);
// arreglo = {10, 15, 20, 30, 32, 34, 36, 38, 40, 50}.

Eventos de teclado con MobileProcessing

El manejo de eventos de teclado con MP es bastante sencillo. A manera de callbacks se ejecutan determinadas funciones según suceda el evento.

keyPressed() Es llamado cada vez que se presiona una tecla.
keyReleased() Es llamado cada vez que se libera una tecla, es decir, se deja de presionar.
softKeyPressed(String etiqueta) Es llamado cada vez que es presionada una tecla suave. Para definir la tecla suave (aparece como opción derecha) debe utilizarse la función softkey(String etiqueta).

Las siguientes variables almacenan la información relacionada con la tecla presionada.

key Almacena el valor de la última tecla presionada.
keyCode Permite detectar la presión de una tecla especial mediante el uso de constantes predefinidas: UP, DOWN, LEFT, y RIGHT así como FIRE, GAME_A, GAME_B, GAME_C, y GAME_D

Para mayor información acerca de su uso consultar el siguiente ejemplo: demo_teclas

Introducción a Mobile Processing

Al parecer MobileProcessing es un lenguaje orientado a funciones el cual permite también la especificación de clases y con ellas la creación de objetos. Entiendo también que su ampliación a través de la utilización de código Java es muy fácil.

A continuación enuncio las funciones que pueden ser manipuladas por el desarrollador según su finalidad.

setup()

Se ejecuta una única vez cuando el programa se inicia. Es útil para especificar el estado inicial de la aplicación.

destroy()

Se ejecuta una única vez cuando la aplicación se está terminando. Es útil para disponer adecuadamente de los recursos como por ejemplo guardar y cerrar los archivos abiertos.

draw()

Se ejecuta después de terminado el llamado a setup(). Esta función se ejecuta constantemente según la información proporcionada por las funciones delay() y framerate(). Su utilidad radica principalmente en preparar y actualizar el contenido a mostrarse al usuario a través de la pantalla del dispositivo.

noLoop()

El llamado a esta función detiene la ejecución periódica de la función draw().

redraw()

Ejecuta el contenido de la función draw() una única vez. Es útil para actualizar la presentación después de sucedido un evento.

loop()

Obliga a que la función draw() se ejecute periódicamente.

suspend()

Esta función es llamada por el teléfono cuando este suspende al programa lo cual sucede por motivos como la entrada de una llamada o el cierre de la tapa.

resume()

Esta función es llamada por el teléfono cuando se le permite continuar a la aplicación después de un llamado a suspend().

exit()

El llamado a esta función termina la ejecución del programa.

El punto de inicio de un programa en MobileProcessing es la función setup(). Las funciones destroy(), draw(), suspend() y resume() pueden ser sobreescritas para especificar el código a ejecutarse ante las circunstancias particulares. Las funciones noLoop(), loop() y exit() pueden ser llamadas desde el programa para modificar su comportamiento general.

Instalación de Mobile Processing

Descargué los siguientes paquetes.

  1. Sun Java Wireless Toolkit 2.5.2 for CLDC (http://java.sun.com/javame/downloads/index.jsp)
  2. Mobile Processing 0006 ALPHA (http://mobile.processing.org/download/index.php)

En una carpeta llamada MobileProcessingSoftware en la que descomprimí el archivo mobile-0006-expert.zip bajo la carpeta 0006.

Por la parte de Java también creé la carpeta JavaSoftware en la que instalé el sun_java_wireless_toolkit-2_5_2-windows.exe bajo la carpeta WTK2.5.2.

El JDK se encuentra previamente instalado en mi equipo de desarrollo.

Ejecuto el archivo MobileProcessingSoftware006mobile.exe y aparece el IDE de MobileProcessing.

Voy al menú File > Preferences > Mobile y en la sección Wireless Toolkit location especificó su ubicación: F:JavaSoftwareWTK2.5.2.

En el IDE escribo el siguiente código.

void draw()
{
background(0);
stroke(255);

line(10, 10, 10, 50);
line(10, 30, 30, 30);
line(30, 10, 30, 50);
line(50, 10, 50, 50);
}

Selecciono la opción Sketch > Build and Run y aparece mi primer programa en MobileProcessing corriendo en el emulador.

Aprendiendo MobileProcessing

Bien, por fin he tomado la decisión inaplazable y definitiva. Voy a aprender MobileProcessing de una buena vez. De tantas cosas que hay en este mundo que quisiera tener el tiempo suficiente para aprenderlas, MP va a ser la siguiente que voy a aprender.Hice una búsqueda y no encontré una documentación muy sólida y estructurada que digamos, sin embargo encontré algunas cositas interesantes y suficientes para aprender lo necesario.

También estuve ojeando un poco el libro Processing: A Programming Handbook for Visual Designers and Artists el cual habla de muchas cosas en especial de temas de diseño y de imágenes, sin embargo debido a la hora me tocará posponer una mejor revisión para después.

Espero poder dedicarle mas tiempo para practicar un poco y hacer alguna cosita con el lenguaje, pero ya será la otra semana porque esta semana ya se acabó y el fin de semana tengo clases … otra vez.