Creaciones Móviles

Almacenamiento persistente: Record Management System (Parte 4)

2012-01-22T11:23:00.000-05:00

Este tutorial es el último de la serie de RMS, aquí veremos cómo utilizar un listener (RecordListener) para capturar los eventos (crear, editar, eliminar) de un RS. Para el ejemplo de este tutorial modificaré el primer ejemplo de la primera parte de esta serie.


public class RMSListener extends Form implements CommandListener, RecordListener {



    private RecordStore miRS = null;

    private int recordID = 0;//identificador del registro

    private Command save = new Command("Guardar", Command.OK, 0);

    private Command delete = new Command("Eliminar", Command.SCREEN, 0);

    private Command update = new Command("Editar", Command.SCREEN, 0);



    public RMSListener(String title) {

        super(title);

        openRecordStore();//Abrimos el RS   

        addCommand(save);

        addCommand(delete);

        addCommand(update);

        setCommandListener(this);

    }



    private void openRecordStore() {

        try {

            miRS = RecordStore.openRecordStore("Primer Registro", true);

            /*

             * Añadimos el listener a nuestro RS

             */

            miRS.addRecordListener(this);

        } catch (Exception e) {

            append("Error al abrir el Record Store");

        }

    }



    private void writeData(String data) {

        byte[] rec = data.getBytes();

        try {

            recordID = miRS.addRecord(rec, 0, rec.length);

        } catch (Exception e) {

            append("Error al guardar los datos");

        }

    }



    public void deleteRecord(int id) {

        try {

            miRS.deleteRecord(id);

        } catch (Exception e) {

            System.out.println("Hubo un problema eliminando el registro");

        }

    }



    private void updateRecord(String new_data) {

        try {

            /*

             * El metodo set permite editar un registro, los parametros son

             * el id del registro a editar, los nuevos datos, el offset (byte de

             * inicio de la escritura) y la cantidad de datos que se desea 

             * escribir

             */

            miRS.setRecord(1, new_data.getBytes(), 0, new_data.length());

        } catch (Exception e) {

        }

    }



    public void commandAction(Command c, Displayable d) {

        if (c == save) {

            writeData("Primer Registro");

        }   

        if (c == delete) {

            deleteRecord(recordID);

        }

        if (c == update) {

            updateRecord("Primer Registro Editado");       

        }

    }



    /*

     * La interfaz contiene 3 metodos (uno por cada operacion: añadir, editar y

     * eliminar). Los parametros que reciben los metodos son: el RS en cual

     * ocurrio la operacion y el ID del registro afectado por la operacion

     */

    public void recordAdded(RecordStore recordStore, int recordId) {

        try {

            append("Se añadio con exito el registro: "

                    + new String(recordStore.getRecord(recordId)));

        } catch (Exception e) {

        }

    }



    public void recordChanged(RecordStore recordStore, int recordId) {

        try {

            append("Se edito correctamente el registro con id #"

                    + recordId);

            append("El nuevo valor es: "

                    + new String(recordStore.getRecord(recordId)));

        } catch (Exception e) {

        }

    }



    public void recordDeleted(RecordStore recordStore, int recordId) {

        try {

            append("Se elimino el registro con id #" + recordId);

            append("El numero actual de registros es: " + 

                    recordStore.getNumRecords());

        } catch (Exception e) {

        }

    }

}

El ejemplo anterior es muy sencillo pero sirve para ilustrar el uso de RecordListener. Esto es muy útil para actualizar listas de acuerdo a los cambios hechos en el RS o para gestionar las operaciones realizadas sobre un RS en un hilo diferente al principal. Para terminar este tutorial, les dejo la documentación de un framework realizado por Diego Blanco para la gestión de RS: Manual de Usuario del Framework de Interfaz de RMS (J2ME).

En el siguiente tutorial, usaremos lo que hemos aprendido hasta el momento para realizar una aplicación real.

El código fuente de la serie de tutoriales sobre RMS se encuentra disponible aquí

Almacenamiento persistente: Record Management System (Parte 3)

2012-01-13T14:23:00.001-05:00

Para continuar con esta serie de tutoriales sobre RMS, vamos a ver cómo organizar registros (alfabéticamente por ejemplo) y cómo filtrar registros (para implementar un sistema de búsqueda).

Como vimos en el tutorial anterior, cuando creamos un RecordEnumeration podemos pasarle como parámetros un RecordComparator y un RecordFilter. En los siguientes dos ejemplos veremos cómo implementar cada uno de estos.

Organizar Registros

En este ejemplo organizaremos los registros de forma alfabética y numérica. Como ya mencioneé anteriormente, para organizar los registro de un RS es necesario implementar la interfaz RecordComparator. Esta interfaz posee un único método, el método compare. En este método deberemos implementar el código para comparar los registros y devolver un valor de acuerdo al resultado de la comparación. Primero mostraré el código de los comparadores y finalmente el código del formulario.

Comparador de Cadenas


public class ComparadorAlfa implements RecordComparator {



    byte[] data = new byte[100];

    ByteArrayInputStream byteAIS = null;

    DataInputStream dataIS = null;



    public int compare(byte[] rec1, byte[] rec2) {

        try {

            String reg1, reg2;

            //determinamos el tamaño maximo de los registros

            int maxSize = Math.max(rec1.length, rec2.length);

            //si es tamaño de los registros es mayor, redefinimos el tamaño de data

            if (data.length < maxSize) {

                data = new byte[maxSize];

            }

            //Leemos el primer registro (rec1)

            byteAIS = new ByteArrayInputStream(rec1);

            dataIS = new DataInputStream(byteAIS);

            reg1 = dataIS.readUTF();

            //Leemos el segundo registro (rec1)

            byteAIS = new ByteArrayInputStream(rec2);

            dataIS = new DataInputStream(byteAIS);

            reg2 = dataIS.readUTF();

            System.out.println(reg1 + " - " + reg2);

            //Ahora debemos comparar las dos cadenas para determinar el orden

            //alfabetico, para esto utilizamos el metodo compareTo de la clase

            //String. Este metodo nos devuelve:

            //cero si las cadenas son iguales

            //un numero negativo si la cadena a es "menor" que b

            //un numero positivo si la cadena a es "mayor" que b

            int resultado = reg1.compareTo(reg2);

            if (resultado == 0) {

                return RecordComparator.EQUIVALENT;

            } else if (resultado < 0) {

                return RecordComparator.PRECEDES;

            } else {

                return RecordComparator.FOLLOWS;

            }

        } catch (Exception e) {

            return RecordComparator.EQUIVALENT;

        }

    }

}

El comparador numérico es muy similar, no pondré el código en este tutorial para evitar extenderme tanto, pero en el archivo que les dejare al final de los tutoriales sobre RMS estará el código completo.

Formulario


public class OrganizarRegistros extends Form implements CommandListener{



    private RecordStore miRS = null;

    private Command organizar_alfa = new Command("Alfabeticamente", Command.OK, 1);

    private Command leer = new Command("Leer",Command.CANCEL, 0);

    private Command organizar_num = new Command("Numericamente", Command.SCREEN, 1);

    private Command limpiar = new Command("Limpiar", Command.CANCEL, 1);



    public OrganizarRegistros(String title) {

        super(title);

        openRecordStore();

        WriteData();

        addCommand(leer);

        addCommand(organizar_alfa);

        addCommand(organizar_num);

        addCommand(limpiar);

        setCommandListener(this);

    }



    private void openRecordStore() {

        try {

            miRS = RecordStore.openRecordStore("Primer Registro", true);

        } catch (Exception e) {

            append("Error al abrir el Record Store");

        }

    }



    private void WriteData() {

        String[] nombre = {"Juan", "Pedro", "Maria", "Luz"};

        int id[] = {1234, 5432, 1357,4321};

        boolean[] mayor_edad = {true, false, false, true}; 

        ByteArrayOutputStream data = new ByteArrayOutputStream(); 

        DataOutputStream dataOutputStream = new DataOutputStream(data);

        byte[] record;

        try {

            for (int i = 0; i < 4; i++) {         

                dataOutputStream.writeUTF(nombre[i]);

                dataOutputStream.writeInt(id[i]);

                dataOutputStream.writeBoolean(mayor_edad[i]);               

                dataOutputStream.flush();               

                record = data.toByteArray();         

                miRS.addRecord(record, 0, record.length);

                data.reset();

            }     

            data.close();

            dataOutputStream.close();

        } catch (Exception e) {

        }

    }



    private void readData(RecordComparator rc) {       

        byte[] readedData = new byte[200];

        ByteArrayInputStream inStream = new ByteArrayInputStream(readedData);

        DataInputStream dataIn = new DataInputStream(inStream);

        try {

            if (miRS.getNumRecords() > 0) {

                int i = 0;                         

                RecordEnumeration re = miRS.enumerateRecords(null, rc, true);         

                while (re.hasNextElement()) {             

                    miRS.getRecord(re.nextRecordId(), readedData, 0);

                    append("Registro #" + i++ + "\n");

                    append("Nombre: " + dataIn.readUTF() + "\n");

                    append("Identificacion: " + dataIn.readInt() + "\n");

                    append("¿es mayor de edad?: " + dataIn.readBoolean() + "\n");

                    append("--------------------\n");

                    inStream.reset();



                }

            }

            inStream.close();

            dataIn.close();

        } catch (Exception e) {

            System.out.println("Error leyendo el RS");

        }



    }



    public void commandAction(Command c, Displayable d) {

        if(c == leer){

            readData(null);

        }

        if(c == organizar_alfa){

            ComparadorAlfa ca = new ComparadorAlfa();

            readData(ca);

        }

        if(c == organizar_num){

            ComparadorNum cn = new ComparadorNum();

            readData(cn);

        }

        if(c == limpiar){

            deleteAll();

        }

    } 

}

En el siguiente vídeo vemos el resultado del ejemplo. Es muy interesante ver cómo se realiza la comparación, si se fijaron en el vídeo, el RecordComparator compara uno a uno cada registro y de esta forma determina el orden correcto.

Filtrar Registros

Haciendo uso de la interface RecordFilter podremos buscar un registro específico dentro de nuestro RS siguiendo un criterio determinado. Esta interfaz posee un único método, el método matches que compara lo que le indiquemos con cada registro del sistema, es responsabilidad del desarrollador implementar la comparación, en caso de coincidencia devuelve true, en caso contrario false.

Filtro


public class Filtro implements RecordFilter{



    private String cadena_busqueda;



    public Filtro(String cadena_busqueda) {

        //pasamos a minusculas la cadena de busqueda

        this.cadena_busqueda = cadena_busqueda.toLowerCase();

    }    



    public boolean matches(byte[] candidate) {

        String s = new String(candidate).toLowerCase();

        //Busca coincidencias con los registros    

        if(cadena_busqueda != null && s.indexOf(cadena_busqueda) != -1){

            return true;

        } else{

            return false;

        }

    }

}

Formulario


public class FiltrarRegistros extends Form implements CommandListener {



    private RecordStore miRS = null;

    private Command buscar = new Command("Buscar", Command.OK, 0);

    private Command leer = new Command("Leer", Command.CANCEL, 0);

    private TextField campo_busqueda = new TextField("Buscar", "", 15, TextField.ANY);

    private Command limpiar = new Command("Limpiar", Command.CANCEL, 1);



    public FiltrarRegistros(String title) {

        super(title);

        openRecordStore();

        WriteData();

        append(campo_busqueda);

        addCommand(buscar);

        addCommand(leer);

        addCommand(limpiar);

        setCommandListener(this);

    }



    private void openRecordStore() {

        try {

            miRS = RecordStore.openRecordStore("Primer Registro", true);

        } catch (Exception e) {

            append("Error al abrir el Record Store");

        }

    }



    private void WriteData() {

        String[] nombre = {"Juan", "Pedro", "Maria", "Luz", "Jose", "Sandra", "Miguel", "Penelope"};

        byte[] record;

        try {

            ByteArrayOutputStream data = new ByteArrayOutputStream();

            DataOutputStream dataOutputStream = new DataOutputStream(data);

            for (int i = 0; i < 8; i++) {

                dataOutputStream.writeUTF(nombre[i]);

                dataOutputStream.flush();

                record = data.toByteArray();

                miRS.addRecord(record, 0, record.length);

                data.reset();

            }

            data.close();

            dataOutputStream.close();

        } catch (Exception e) {

        }

    }



    private void readData(RecordFilter rf) {

        byte[] readedData = new byte[50];

        ByteArrayInputStream inStream = new ByteArrayInputStream(readedData);

        DataInputStream dataIn = new DataInputStream(inStream);

        try {

            if (miRS.getNumRecords() > 0) {

                int i = 0;

                RecordEnumeration re = miRS.enumerateRecords(rf, null, true);

                while (re.hasNextElement()) {

                    miRS.getRecord(re.nextRecordId(), readedData, 0);                  

                    append(dataIn.readUTF() + "\n");                  

                    inStream.reset();

                }

            }

            inStream.close();

            dataIn.close();

        } catch (Exception e) {

            System.out.println("Error leyendo el RS");

        }



    }



    public void commandAction(Command c, Displayable d) {

        if (c == leer) {

            readData(null);

        }

        if (c == buscar) {

            Filtro f = new Filtro(campo_busqueda.getString());          

            readData(f);

        }

        if (c == limpiar) {

            deleteAll();

            append(campo_busqueda);

        }

    }

}

Como podemos ver, no es difícil realizar búsquedas en los RS. En el siguiente tutorial veremos cómo utilizar Listeners para capturar eventos de los RS.

Almacenamiento persistente: Record Management System (Parte 2)

2012-01-13T09:26:00.001-05:00

En el tutorial anterior vimos las operaciones básicas para trabajar con RMS, en este tutorial veremos cómo almacenar datos diferentes de texto, y como recorrer un Record Store para recuperar sus registros.

Almacenar diferentes tipos de datos


public class StreamDatos extends Form implements CommandListener {



    private RecordStore miRS = null;

    private Command save = new Command("Guardar", Command.OK, 0);

    private Command read = new Command("Leer", Command.CANCEL, 0);

    private Command exit = new Command("Salir", Command.SCREEN, 0);



    public StreamDatos(String title) {

        super(title);

        openRecordStore();

        addCommand(read);

        addCommand(save);

        addCommand(exit);

        setCommandListener(this);

    }



    private void openRecordStore() {

        try {

            miRS = RecordStore.openRecordStore("Primer Registro", true);

        } catch (Exception e) {

            append("Error al abrir el Record Store");

        }

    }



    private void WriteData() {

        String nombre = "Juan Camilo";

        int id = 123456789;

        boolean casado = false;

        // Crea el arreglo de bytes interno donde se van a almacenar los datos

        ByteArrayOutputStream data = new ByteArrayOutputStream();

        // Crea el objeto que va a contener el flujo de bytes a escribir sobre el RecordStore

        DataOutputStream dataOutputStream = new DataOutputStream(data);

        byte[] record;

        try {

            //Utilizamos los metodos de la clase DataOutputStream para escribir

            //los diferentes tipos de datos a la variable data

            dataOutputStream.writeUTF(nombre);

            dataOutputStream.writeInt(id);

            dataOutputStream.writeBoolean(casado);

            //terminamos la escritura

            dataOutputStream.flush();

            //convertimos el stream a un arreglo de bytes

            record = data.toByteArray();

            //guardamos en el RS

            miRS.addRecord(record, 0, record.length);

            //Cerramos los streams

            data.reset();

            data.close();

            dataOutputStream.close();

        } catch (Exception e) {

        }

    }



    private void readData() {

        //Creamos el array donde recuperaremos los datos del RS, debemos asegurarnos

        //que sea lo suficientemente grande

        byte[] readedData = new byte[200];

        ByteArrayInputStream inStream = new ByteArrayInputStream(readedData);

        DataInputStream dataIn = new DataInputStream(inStream);

        try {

            for (int i = 1; i <= miRS.getNumRecords(); i++) {

                miRS.getRecord(i, readedData, 0);

                //Leemos los datos utilizando los metodos correspondientes

                //al tipo de datos que necesitemos, es importante que el 

                //contenido sea leido en el mismo orden en el que fue

                //almacenado

                append("Nombre: " + dataIn.readUTF());

                append("Identificacion: " + dataIn.readInt());

                append("Esta Casado?: " + dataIn.readBoolean());

                inStream.reset();

            }

            inStream.close();

            dataIn.close();

        } catch (Exception e) {

            System.out.println("Error leyendo el RS");

        }



    }



    private void closeRecordStore() {

        try {

            miRS.closeRecordStore();

        } catch (Exception e) {

            System.out.println("Hubo un problema cerrando el RS");

        }

    }



    public void commandAction(Command c, Displayable d) {

        if (c == save) {

            WriteData();

            System.out.println("Registro guardado con exito");

        }

        if (c == read) {

            readData();

        }

        if (c == exit) {

            closeRecordStore();

            RMSMidlet.rmsMidlet.destroyApp(true);

            RMSMidlet.rmsMidlet.notifyDestroyed();

        }

    }

}

Como podemos ver es muy sencillo almacenar diferentes tipos de datos, de esta forma podemos crear registros más completos.

Recuperar Registros

En los ejemplos anteriores vimos cómo recuperar un registro previamente almacenado en un RS, simplemente utilizábamos un ciclo for e íbamos recuperando los diferentes registros, pero recorrer los registros de un RS asumiendo que todos los ID son continuos, puede generar errores. La solución a este problema es la clase RecordEnumeration, la cual tiene los métodos necesarios para recorrer los registros de un RS.

De forma opcional se puede usar RecordFilter para recuperar un subconjunto de registros que coincidan con un filtro especifico (puede ser usado para implementar búsquedas), también RecordComparator para enumerar los registros en un orden especifico (puede ser usado para ordenar registros). A continuación les presento un ejemplo sobre el uso de la clase RecordEnumeration


public class Recuperar extends Form implements CommandListener {



    private RecordStore miRS = null;

    private Command read = new Command("Leer", Command.CANCEL, 0);



    public Recuperar(String title) {

        super(title);

        openRecordStore();

        WriteData();

        addCommand(read);

        setCommandListener(this);

    }



    private void openRecordStore() {

        try {

            miRS = RecordStore.openRecordStore("Primer Registro", true);

        } catch (Exception e) {

            append("Error al abrir el Record Store");

        }

    }



    private void WriteData() {

        String[] nombre = {"Juan", "Jose", "Maria", "Luz"};

        int id[] = {1234, 4321, 2468, 1357};

        boolean[] mayor_edad = {true, false, false, true};

        // Crea el arreglo de bytes interno donde se van a almacenar los datos

        ByteArrayOutputStream data = new ByteArrayOutputStream();

        // Crea el objeto que va a contener el flujo de bytes a escribir sobre el RecordStore

        DataOutputStream dataOutputStream = new DataOutputStream(data);

        byte[] record;

        try {

            for (int i = 0; i < 4; i++) {

                //Utilizamos los metodos de la clase DataOutputStream para escribir

                //los diferentes tipos de datos a la variable data

                dataOutputStream.writeUTF(nombre[i]);

                dataOutputStream.writeInt(id[i]);

                dataOutputStream.writeBoolean(mayor_edad[i]);

                //terminamos la escritura

                dataOutputStream.flush();

                //convertimos el stream a un arreglo de bytes

                record = data.toByteArray();

                //guardamos en el RS

                miRS.addRecord(record, 0, record.length);

                data.reset();

            }

            //Cerramos los streams     

            data.close();

            dataOutputStream.close();

        } catch (Exception e) {

        }

    }



    private void readData() {

        //Creamos el array donde recuperaremos los datos del RS, debemos asegurarnos

        //que sea lo suficientemente grande

        byte[] readedData = new byte[200];

        ByteArrayInputStream inStream = new ByteArrayInputStream(readedData);

        DataInputStream dataIn = new DataInputStream(inStream);

        try {

            if (miRS.getNumRecords() > 0) {

                int i = 0;

                /*

                 * Crearmos el enumerador, los dos primeros parametros que recibe

                 * son un filtro (RecordFilter) y un comparador (RecordComparator),

                 * si el filtro y el comparador son nulos, el enumerador buscara

                 * en todos los registros y sin ningun orden especial. El tercer

                 * parametro, si es verdadero el enumerador se mantendra al tanto

                 * de cualquier cambio en los registros (edicion, eliminacion o 

                 * adicion de registros), este parametro debe ser utilizado con

                 * precaucion debido a posibles problemas de rendimiento. Si es

                 * falso no se mantendra acutalizado y puede retornar recordId de 

                 * registros que hayan sido eliminados, o retornar la version

                 * no actualizada de un registro.

                 */

                RecordEnumeration re = miRS.enumerateRecords(null, null, true);

                //utilizamos el metodo hasNextElement para determinar si hay registros

                while (re.hasNextElement()) {

                    /*el metodo nextRecordId, se mueve a traves de los registros

                     * empezando en el registro 1

                     */

                    miRS.getRecord(re.nextRecordId(), readedData, 0);

                    append("Registro #" + i++ + "\n");

                    append("Nombre: " + dataIn.readUTF() + "\n");

                    append("Identificacion: " + dataIn.readInt() + "\n");

                    append("¿es mayor de edad?: " + dataIn.readBoolean() + "\n");

                    inStream.reset();



                }

            }

            inStream.close();

            dataIn.close();

        } catch (Exception e) {

            System.out.println("Error leyendo el RS");

        }



    }



    private void closeRecordStore() {

        try {

            miRS.closeRecordStore();

        } catch (Exception e) {

            System.out.println("Hubo un problema cerrando el RS");

        }

    }



    public void commandAction(Command c, Displayable d) {

        if (c == read) {

            readData();

        }

    }

}

Hasta aquí la segunda parte del tutorial sobre RMS, como pudimos ver es muy sencillo utilizar la clase RecordEnumeration para recuperar registros. En el siguiente tutorial veremos cómo organizar registros (RecordComparator) y cómo filtrar registros (RecordFilter).

Almacenamiento persistente: Record Management System (Parte 1)

2012-01-10T09:47:00.002-05:00

Cuando estamos desarrollando software, es muy común que necesitemos almacenar cierto tipo de datos de forma persistente para poder utilizarlos en el futuro. Un ejemplo clásico, es un sistema de inicio de sesión, donde se debe tener almacenado el nombre de usuario y la contraseña de los usuarios, o un juego donde queremos almacenar el progreso o los puntajes maximos.

Java ME soluciona el problema del almacenamiento persistente con los RMS (Record Management System), el cual es un sistema de almacenamiento de datos muy sencillo. En los RMS el elemento básico es el Record (registro). Un registro es la unidad de información mas pequeña que puede ser almacenada y estos son almacenados en Record Stores. Cada uno de los registros se compone de un identificador único y de los datos (arreglo de bytes). Ahora vamos a ver unos ejemplos sobre el uso de RMS.

Lectura/Escritura


public class LecturaEscritura extends Form implements CommandListener {



    private RecordStore miRS = null;

    private int recordID = 0;//identificador del registro

    private Command save = new Command("Guardar", Command.OK, 0);

    private Command read = new Command("Leer", Command.CANCEL, 0);

    private Command delete = new Command("Eliminar", Command.SCREEN, 0);

    private Command exit = new Command("Salir", Command.SCREEN, 0);



    public LecturaEscritura(String title) {

        super(title);

        openRecordStore();//Abrimos el RS

        addCommand(read);

        addCommand(save);

        addCommand(delete);

        addCommand(exit);

        setCommandListener(this);

    }



    private void openRecordStore() {

        /*

         * El primer paso para utilizar un RS es abrirlo, para esto utilizamos

         * el metodo estatico de la clase RecordStore, openRecordStore. Los 

         * parametros que recibe son

         * -nombre del record store: debe ser un identificador unico dentro

         * de la aplicacion

         * -createIfNecesary: si es true, crea el registro si es necesario

         */

        try {

            miRS = RecordStore.openRecordStore("Primer Registro", true);

        } catch (Exception e) {

            append("Error al abrir el Record Store");

        }

    }



    private void writeData(String data) {

        /*

         * Para almacenar datos en un RS, en necesario convertilos a un array 

         * de bytes, en este caso como queremos almacenar un String, simplemente

         * utilizamos el metodo getBytes.

         * 

         */

        byte[] rec = data.getBytes();

        /*

         * Ahora utilizamos el metodo addRecord, para almacenar el registro. Los

         * parametros que recibe son

         * -data: el array de bytes

         * -offset:el indice del primer byte del array desde el cual queremos 

         * guardar la informacion

         * -numBytes:numero de bytes del array que se desean almacenar (cuenta

         * desde el offset)

         */

        try {

            recordID = miRS.addRecord(rec, 0, rec.length);

            /*

             * en recordID almacenamos el identificador unico del registro que

             * acabamos de crear

             */

        } catch (Exception e) {

            append("Error al guardar los datos");

        }

    }



    public void readRecord() {

        /*

         * tenemos dos formas de consultar un registro. 

         * 1. con el identificador del registro (recordID)

         * 2. recorriendo todos los registros y almacenando cada uno

         * 

         * El primer caso es mas sencillo, pero es impracticable para una 

         * situacion en la cual tengamos muchos registros o en la cual no 

         * sepamos cuantos registros vamos a tener (caso mas comun). En el ejemplo

         * vamos a hacerlo de ambas formas

         */



        ///---Forma 1---



        try {

            byte[] forma1 = miRS.getRecord(recordID);

            String a = new String(forma1);//obtenemos el string a partir del

            //array de bytes

            append("Registro leido de la forma 1: " + a);

        } catch (Exception e) {

            System.out.println("Hubo un problema leyendo el registro");

        }



        ///---Forma 2---

        try {

            byte[] forma2 = new byte[100];//creamos un array de bytes de un tamaño

            //que garantice que todos lo bytes sean leidos

            int numBytes;

            for (int i = 1; i <= miRS.getNumRecords(); i++) {

                /*

                 * los parametros que recibe son: id del registro, array de bytes

                 * en el cual se copiaran lo datos, y offset que indica desde que

                 * byte se copiaran los datos

                 */

                numBytes = miRS.getRecord(i, forma2, 0);

                String b = new String(forma2, 0, numBytes);

                append("Registro leido de la forma 2: " + b);

            }

        } catch (Exception e) {

            System.out.println("Hubo un problema leyendo el registro");

        }



    }



    public void deleteRecord(int id) {

        /*

         * Para borrar un registro se puede usar cualqueira de las dos formas

         * que mostre en el metodo readRecord, en este caso utilizare el metodo

         * uno, a uds les queda de ejercicio implementar la forma 2

         */

        try {

            miRS.deleteRecord(id);

        } catch (Exception e) {

            System.out.println("Hubo un problema eliminando el registro");

        }

    }

 

    private void closeRecordStore() {

        try {

            miRS.closeRecordStore();

        }

        catch (Exception e) {

            System.out.println("Hubo un problema cerrando el RS");

        }

    }



    public void commandAction(Command c, Displayable d) {

        if (c == save) {

            writeData("Primer Registro");

            System.out.println("Registro guardado con exito");

        }

        if (c == read) {

            readRecord();

        }

        if (c == delete) {

            deleteRecord(recordID);

        }

        //es una buena practica cerrar el registro cuando no se lo vaya a usar mas

        //por ejemplo al cerrar la aplicacion

        if(c == exit){         

            closeRecordStore();

            RMSMidlet.rmsMidlet.destroyApp(true);

            RMSMidlet.rmsMidlet.notifyDestroyed();

        }

    }

}

En el video que demuestra el funcionamiento, no se puede ver si los datos se mantienen después de cerrar la aplicación, debido a que el emulador no tiene esta funcionalidad. Otros emuladores como el de Nokia, si permiten trabajar con RS. Para los que deseen probar el funcionamiento pueden instalarlo es sus propios celulares o instalar el emulador de Nokia.

Es importante tener en cuenta que en este ejemplo faltan muchas cosas por tener en cuenta, es simplemente una introducción al uso de RS y no esta pensado para ser utilizado en una aplicación real. En el próximo tutorial veremos cómo guardar datos que no sean texto y cómo recorrer registros en un RS, tomando en cuenta que no siempre los identificadores de los registros son continuos.

Navegación entre diferentes GUI

2012-01-05T11:16:00.000-05:00

Hasta el momento hemos visto cómo crear diferentes interfaces gráficas, pero para poder desarrollar aplicaciones más complejas necesitamos poder crear un flujo de navegación entre las diferentes pantallas. La navegación entre pantallas aunque es sencilla de implementar, es vital en cuanto a la experiencia de usuario; una aplicación donde el usuario tenga que navegar a través de muchas pantallas para lograr su objetivo, es una aplicación mal diseñada.

Como vimos en los primeros tutoriales la clase encargada de controlar la visualización de los elementos en pantalla es la clase Display, y es precisamente esta la clase la que utilizaremos para realizar la navegación entre diferentes GUI.

En el siguiente ejemplo veremos cómo navegar entre diferentes GUI. Utilizaremos todos los ejemplos anteriores y crearemos menús que permitan navegar entre los diferentes ejemplos. El código de los ejemplos anteriores es prácticamente el mismo por lo tanto no voy a ponerlo nuevamente (se extiende mucho el post), los cambios son menores, al final les pasaré el código completo del ejemplo, para que lo revisen con más detenimiento.

MIDlet


public class NavMIDlet extends MIDlet {



    public Display display;

    public static NavMIDlet midlet; //referencia estatica al MIDlet 





    public void startApp() {

        display = Display.getDisplay(this); //Obtenemos la referencia

        midlet = this;

        display.setCurrent(new Menu("Menu Principal"));

    }



    public void destroyApp(boolean unconditional) {

    }



    protected void pauseApp() {

   

    }

}

Menú Principal


public class Menu extends List implements CommandListener {



    private Command exit = new Command("Salir", Command.EXIT, 0);



    public Menu(String title) {

        super(title, List.IMPLICIT);

        append("Formularios", null);

        append("Listas", null);

        append("TextBox", null);

        append("Alert", null);

        append("Alert con Command", null);

        append("Ticker", null);

        addCommand(exit);

        setCommandListener(this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == exit){

            NavMIDlet.midlet.destroyApp(true);

            NavMIDlet.midlet.notifyDestroyed();

        }

        if (c == List.SELECT_COMMAND) {

            int index = getSelectedIndex();

            switch (index) {

                case 0:

                    NavMIDlet.midlet.display.setCurrent(new MenuFormulario("Menu Formularios"));

                    break;

                case 1:

                    NavMIDlet.midlet.display.setCurrent(new MenuListas("Menu Listas"));

                    break;

                case 2:

                    NavMIDlet.midlet.display.setCurrent(new TextBoxExample("TextBox"));

                    break;

                case 3:

                    NavMIDlet.midlet.display.setCurrent(new AlertExample("Alert"));

                    break;

                case 4:

                    NavMIDlet.midlet.display.setCurrent(new AlertCommandExample("Alert con Command"));

                    break;

                case 5:

                    NavMIDlet.midlet.display.setCurrent(new TickerExample("Ticker"));

                    break;

            }

        }

    }

}

En esta clase ya podemos ver cómo se realiza la navegación, simplemente usamos la clase Display y su método setCurrent, para poner en pantalla lo que necesitemos. Como dije anteriormente, implementar la navegación es muy sencillo, ahora les dejo el video de como funciona la aplicación.

Con este tutorial ya pueden ir construyendo aplicaciones con un poco más de contenido, en el siguiente tutorial veremos cómo almacenar información de nuestras aplicaciones, por ejemplo, puntajes de un juego, preferencias de un usuario, etc.

El código fuente del ejemplo se encuentra disponible aquí

Interfaces gráficas de usuario de alto nivel - TextBox, Alert y Ticker

2012-01-04T13:33:00.001-05:00

TextBox

Un TextBox es una pantalla que permite al usuario ingresar y editar texto. Desciende de la clase Screen al igual que los formularios y las listas. Este elemento es similar al TextField, la única diferencia es que el TextField esta diseñado para integrarse en un formulario en vez de ocupar toda la pantalla.

Ahora vamos a ver un ejemplo sobre la utilización de TextBox


public class TextBoxExample extends TextBox implements CommandListener{



    private Command capturar = new Command("Capturar", Command.ITEM, 0);



    public TextBoxExample(String title) {

        super(title, "", 250, TextField.ANY);//llamamos al constructor de la

        //clase padre, los parametros son titulo, texto que contiene el TextBox

        //numero maximo de caracteres, y limitaciones

        addCommand(capturar);

        setCommandListener(this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == capturar){

            String texto = getString();

            System.out.println(texto);

        }

    }

}

Para mostrar el TextBox se utiliza la clase Display (al igual que con los formularios o las listas).


public class GUIMIDlet extends MIDlet {



    public Display display;

    public static GUIMIDlet midlet; //referencia estatica al MIDlet



    public GUIMIDlet() {

        display = Display.getDisplay(this); //Obtenemos la referencia

        midlet = this;

        //al objeto display

    }



    public void startApp() {

        display.setCurrent(new TextBoxExample("Ejemplo TextBox"));//ponemos en pantalla al textbox

    }



    public void pauseApp() {

    }



    public void destroyApp(boolean unconditional) {

    }

}

Alert y AlertType

Los Alert son pantallas que muestran información al usuario y esperan por un periodo de tiempo antes de proceder a la siguiente pantalla, usualmente son utilizadas para mostrar advertencias o errores. Existen dos clases de Alert:

Modal: la alerta permanece en pantalla hasta que el usuario decida abandonarlo.
Temporizado: la alerta permanece en pantalla por un tiempo determinado

La clase AlertType proporciona un indicador sobre el tipo de la alerta que se va a presentar. Los tipos predeterminados son: INFO, WARNING, ERROR, ALARM y CONFIRMATION.

Ahora vamos a ver un ejemplo sobre cómo utilizar Alert y AlertType.


public class AlertExample extends Form implements CommandListener{



    private StringItem label = new StringItem("", "Presiona el command para ver un Alert!");

    private Command mostrar = new Command("Ver", Command.OK, 0);

    private Alert alerta;



    public AlertExample(String title) {

        super(title);

        append(label);

        addCommand(mostrar);

        setCommandListener(this);

    }



    public void showAlert(){

        Image img = null;

        try{

            img = Image.createImage("/content.png");

        } catch(Exception e){

            append("error al cargar la imagen");

        }

        //creamos la alerta con los parametros correspondientes

        alerta = new Alert("Titulo Alerta", "Este es el contenido de la alerta", img, AlertType.CONFIRMATION);

   

        alerta.setTimeout(Alert.FOREVER);//fijamos la alerta como modal

        //utilizamos la referencia estatica al MIDLet para mostrar la alerta,

        //los parametros son alerta y la pantalla que se mostrara despues de que

        //desaparezca la alerta

        GUIMIDlet.midlet.display.setCurrent(alerta, this);

   

    }



    public void commandAction(Command c, Displayable d) {

        if(c == mostrar){

            showAlert();

        }

    }

}

Al definir el timeout como Alert.FOREVER, fijamos la alerta como modal. Si queremos que la alerta se desvanezca despues de un tiempo determinado, simplemente reemplazamos Alert.FOREVER con el tiempo (en milisegundos) que deseemos.

Como vimos en el ejemplo anterior, aparece un command con el texto done, el cual permite cerrar el Alert, este command es el DISMISS_COMMAND.

Hasta el momento las Alert sólo nos sirven para mostrar información a los usuarios, pero, ¿qué pasa si queremos pedir confirmación al usuario, por ejemplo para confirmar la eliminación de un mensaje?.

Java ME nos ofrece la posibilidad de añadir command a los Alert y de fijarles un CommandListener, en el siguiente ejemplo veremos como.


public class AlertCommandExample extends Form implements CommandListener{



    private StringItem label = new StringItem("", "Presiona el command para ver un Alert!");

    private Command mostrar = new Command("Ver", Command.ITEM, 0);

    private Command ok = new Command("SI", Command.OK, 0);

    private Command cancel = new Command("NO", Command.CANCEL, 0);

    private Alert alerta;



    public AlertCommandExample(String title) {

        super(title);

        append(label);

        addCommand(mostrar);

        setCommandListener(this);

    }



    public void showAlert(){

        Image img = null;

        try{

            img = Image.createImage("/content.png");

        } catch(Exception e){

            append("error al cargar la imagen");

        }

        //creamos la alerta con los parametros correspondientes

        alerta = new Alert("Advertencia", "¿Estas seguro que deseas eliminar?", img, AlertType.WARNING);

        alerta.addCommand(ok);

        alerta.addCommand(cancel);

        alerta.setCommandListener(this);

        alerta.setTimeout(Alert.FOREVER);//fijamos la alerta como modal   

        GUIMIDlet.midlet.display.setCurrent(alerta, this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == mostrar){

            showAlert();

        }

        if(c == ok){

            append("Mensaje Eliminado");

            GUIMIDlet.midlet.display.setCurrent(this);

        }

        if(c == cancel){

            GUIMIDlet.midlet.display.setCurrent(this);

        }    

    }

}

Como podemos ver, al agregar nuestro command al Alert, es nuestra responsabilidad cerrar el Alert desde el listener.

Ticker

Un Ticker es una porción de texto que se desplaza a través de la pantalla, es muy parecido a los anuncios publicitarios que muestran un letrero que se desplaza de un lado a otro. Implementar un ticker es muy sencillo como lo veremos en el siguiente ejemplo.


public class TickerExample extends Form{

 

    private ImageItem imgItem;

    private Image img;

    private Ticker t;

 

    public TickerExample(String title) {

        super(title);     

        try{

            img = Image.createImage("/example.png");

            imgItem = new ImageItem("", img, ImageItem.LAYOUT_CENTER, "blackboard");

        }catch(Exception e){

            append("no se pudo cargar la imagen");

        }

        append("Tutorial de Java ME");

        append(imgItem);

     

        //ahora si vamos a crear un ticker

        t = new Ticker("mas tutoriales en Creaciones Moviles");//creamos el ticker

        //con el texto que queremos que se mueva en la pantalla

        setTicker(t);//fijamos el ticker a la pantalla

    }     

}

Cabe resaltar que un Ticker se puede poner en cualquier objeto que descienda de la clase Displayable.

Con este tutorial terminamos la parte de interfaces gráficas de usuario de alto nivel, espero que todo haya quedado claro, cualquier duda que tengan por favor dejen un comentario o escriban a creacionesmoviles@hotmail.com. Estos tutoriales fueron solo una introducción, queda en sus manos profundizar en lo que quedó pendiente.

PD: Les recomiendo revisar el javadoc de Java ME, este es muy importante para ver la documentación completa de todas las clases de la plataforma.

La siguiente parte de este conjunto de tutoriales es muy corta pero es vital para desarrollar aplicaciones moviles, allí veremos como navegar entre diferentes pantallas.

El código fuente del ejemplo se encuentra disponible aquí

Interfaces gráficas de usuario de alto nivel - Listas

2012-01-02T20:26:00.002-05:00

Las listas son elementos gráficos que están en el mismo nivel que los formularios (ambos descienden de la clase Screen), y son muy útiles para presentar conjuntos de opciones (por ejemplo, un menú o una lista de contactos).

Existen 3 tipos de listas:

Múltiple: Se puede escoger más de una opción, es similar al ChoiceGroup multiple.
Exclusive: Se puede escoger una sola opción, es similar al ChoiceGroup exclusive.
Implicit: En este tipo de lista se genera un evento cada vez que se selecciona una opción.

La principal diferencia entre las listas múltiples y exclusivas con los choicegroups, es que estos últimos se ponen dentro de un formulario (pueden ir acompañados de otros elementos).

Para crear una lista:


public class ListaMultiple extends List{



    public ListaMultiple(String title) {

        super(title, List.MULTIPLE);//Llamamos al constructor de la clase padre

        //el primer parametro es el titulo de la lista (similar al de los formularios)

        //el segundo parametros es el tipo de lista, puede ser MULTIPLE, EXCLUSIVE,

        //IMPLICIT

    }



}

Al igual que con los formularios, se puede crear una lista desde el MIDlet, pero es recomendado crear una nueva clase que herede de List. Para mostrar la lista en pantalla:


public class ListMIDlet extends MIDlet {



    public Display display;

    public static ListMIDlet midlet; //referencia estatica al MIDlet



    public ListMIDlet() {

        display = Display.getDisplay(this); //Obtenemos la referencia

        midlet = this;

    }



    public void startApp() {

        display.setCurrent(new ListaMultiple("Lista Multiple"));

    }

    public void pauseApp() {}

    public void destroyApp(boolean unconditional) {}

}

Como se puede ver, el MIDlet es prácticamente igual al de los tutoriales anteriores, simplemente usamos el objeto display para poner en pantalla a la lista. Con este MIDlet vamos a trabajar todo lo que hagamos con listas.

Listas Múltiples

Para este primer ejemplo, vamos a ver las listas múltiples (continuación del ejemplo anterior)


public class ListaMultiple extends List implements CommandListener{



    private Command seleccion = new Command("Ver Seleccion", Command.ITEM, 0);

    private boolean[] selectedFlags = new boolean[5]; //un array que va a contener

    //los elementos seleccionados de la lista



    public ListaMultiple(String title) {

        super(title, List.MULTIPLE);//Llamamos al constructor de la clase padre

        //el primer parametro es el titulo de la lista (similar al de los formularios)

        //el segundo parametros es el tipo de lista, puede ser MULTIPLE, EXCLUSIVE,

        //IMPLICIT



        //Al igual que con los formularios, se utiliza el metodo append para 

        //agregar items a la lista. Los parametros son Etiqueta, Imagen

        //La imagen debe ser pequeña max. 16x16 px

        append("Opcion 1", null);

        append("Opcion 2", null);

        append("Opcion 3", null);

        append("Opcion 4", null);

        append("Opcion 5", null);

        addCommand(seleccion);

        setCommandListener(this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == seleccion){

            int numItems = getSelectedFlags(selectedFlags);   

            //numItems determina el numero de elementos seleccionados

            //selectedFlags debera ser del mismo tamaño que el ChoiceGroup

            //pues es el que indica cuales elementos estan seleccionados

   

            //Con este ciclo recorremos el array selectedFlags, para saber

            //cuales items estan seleccionados, size() me devuelve el tamaño 

            //de la lista

            for(int i=0;i<size();i++){

                if(selectedFlags[i]){

                    //realizamos lo que necesitemos con los elementos seleccionados

                    System.out.println("Seleccionado el Item #" + i);

                }

            }

        }

    }

}

Listas Exclusivas


public class ListaExclusiva extends List implements CommandListener{



    private Command seleccion = new Command("Ver Seleccion", Command.ITEM, 0);



    public ListaExclusiva(String title) {

        super(title, List.EXCLUSIVE);

        append("Opcion 1", null);

        append("Opcion 2", null);

        append("Opcion 3", null);

        append("Opcion 4", null);

        append("Opcion 5", null);

        addCommand(seleccion);

        setCommandListener(this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == seleccion){

            //Con el metodo getString obtenemos la etiqueta del elemento

            //seleccionado (getSelectedIndex())

            String selectedItem = getString(getSelectedIndex());

            //realizamos lo que necesitemos con selectedItem

            System.out.println(selectedItem);

        }

    }         

}

Listas Implicitas


public class ListaImplicita extends List implements CommandListener{



    public ListaImplicita(String title) {

        super(title, List.IMPLICIT);

        append("Opcion 1", null);

        append("Opcion 2", null);

        append("Opcion 3", null);

        append("Opcion 4", null);

        append("Opcion 5", null);   

        setCommandListener(this);

        //hasta aqui todo igual, la gran diferencia es que cuando seleccionamos

        //una opcion se genera un evento command, es decir, es como si se 

        //hubiera presionado un command

    }



    public void commandAction(Command c, Displayable d) {

        //desde este listener capturamos los eventos de la lista

        if(c == List.SELECT_COMMAND){

            int index = getSelectedIndex();//el indice del elemento seleccionado

            switch(index){

                case 0:

                    System.out.println("Seleccionaste la opcion 1");

                    break;

                case 1:

                    System.out.println("Seleccionaste la opcion 2");

                    break;

                case 2:

                    System.out.println("Seleccionaste la opcion 3");

                    break;

                case 3:

                    System.out.println("Seleccionaste la opcion 4");

                    break;

                case 4:

                    System.out.println("Seleccionaste la opcion 5");

                    break;               

            }

        }

    }

}

Como pudimos ver, las listas múltiples y exclusivas tienen el mismo comportamiento de los ChoiceGroup, personalmente prefiero los ChoiceGroup debido a que pueden ir con otros elementos en un formulario. Las listas implícitas son las más utilizadas puesto que son perfectas para realizar menús de opciones. En estos 3 ejemplos puede que no quede clara la utilidad de las listas, pero mas adelante cuando veamos la navegación entre diferentes GUI, este tema quedará mucho más claro.

Con este tutorial termina la parte de Listas, en el próximo tutorial veremos los elementos TextBox, Alert y Ticker, para terminar con la parte de Interfaces gráficas de alto nivel.

El código fuente del ejemplo se encuentra disponible aquí

Futuro de Java ME

2012-01-02T15:21:00.003-05:00

Acabo de leer un artículo en CNN, basado en un estudio de NetApplications, sobre las plataformas móviles mas populares. En este articulo muestran una gráfica muy interesante sobre la cuota de mercado de diferentes plataformas, y la gran sorpresa ha sido Java ME, la cual ha tenido el mayor crecimiento y se ubica actualmente en el segundo puesto del mercado móvil, superando a Android de Google.

Data: NetApplications. Chart: PED

El crecimiento se debe principalmente a que en los países en vía de desarrollo los teléfonos móviles de bajo costo son los mas vendidos; en países como India (el segundo país mas poblado del mundo) el desarrollo de software ha tenido un gran crecimiento, y Java ME es una de las tecnologías más utilizadas. Como podemos ver Java ME es una tecnología vigente y que se ajusta perfectamente al contexto latinoamericano.

Fuentes:

http://tech.fortune.cnn.com/2012/01/01/if-android-is-so-hot-why-has-java-me-overtaken-it/

http://www.netmarketshare.com/mobile-market-share

Interfaces gráficas de usuario de alto nivel - Formularios (Parte 3)

2011-12-28T11:43:00.001-05:00

En este tutorial vamos a ver cómo implementar barras de progreso (Gauge) y campos de fecha (DateField).

Gauge

Un Gauge es un control gráfico que muestra una barra de progreso que oscila entre 0 y un valor máximo. Al igual que todos los elementos en LCDUI, el dispositivo es el encargado de la implementación visual de la barra, por lo tanto es necesario tener en cuenta que el valor máximo especificado en la aplicación puede ser mayor que el número de representaciones visuales en el dispositivo, así que más de un valor puede tener la misma representación visual. Por ejemplo, supongamos que tenemos una barra que va de 0 a 99, y nuestra aplicación esta dirigida a un dispositivo que muestra máximo 10 barras (10 estados diferentes), en este caso el dispositivo mostrara una barra para los valores de 0-9, dos barras para los valores de 10-19, etc. Despues de tanto texto vamos a lo que nos interesa.

Para crear una barra de progreso basta con poner el siguiente codigo:


Gauge barra_progreso = new Gauge("Mi Barra", true, 100, 0);

Los parámetros son respectivamente:
-Etiqueta -> cadena de texto que aparece junto a la barra
-Interactivo -> un campo booleano que indica si la barra es interactiva o no. Las barras interactivas permiten al usuario modificar el valor (por ejemplo, un control de volumen) y las barras no interactivas modifican su valor desde el código (por ejemplo, una pagina de loading).
-Valor Máximo -> El valor máximo que tendrá la barra
-Valor Inicial -> Un valor desde el cual queremos que inicie nuestra barra (debe estar entre 0 y el valor maximo)

Vamos a ver un par de ejemplo sobre barras interactivas y no interactivas:

Barras Interactivas


public class InteractiveGaugeForm extends Form implements CommandListener{



    private Gauge barra_progreso = new Gauge("Mi Barra", true, 100, 50);

    private Command capturarValor = new Command("Capturar", Command.OK, 0);





    public InteractiveGaugeForm(String title) {

        super(title);

        append(barra_progreso);

        addCommand(capturarValor);

        setCommandListener(this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == capturarValor){

            int valor = barra_progreso.getValue();//obtenemos el valor de la barra

            append(valor+"");

        }

    }



}

El resultado es el siguiente

Barra no interactiva


public class NonInteractiveGauge extends Form implements CommandListener{



    public Gauge barra_progreso = new Gauge("Cargando", false, 100, 0);

    private Command iniciar = new Command("Iniciar", Command.OK, 0);

    private Command parar = new Command("Parar", Command.CANCEL, 0); 

    //Creamos un timer para que actualize la barra

    private Timer t = new Timer();

    public int contador = 0;



    public NonInteractiveGauge(String title) {

        super(title);

        append(barra_progreso);

        addCommand(iniciar);

        addCommand(parar);

        setCommandListener(this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == iniciar){

            actualizarGauge();

        }

        if(c == parar){

            t.cancel();

        }

    }



    public void actualizarGauge(){

        //TimerTask es un tarea que se ejecuta periodicamente en un Timer,

        //en el metodo run(), ponemos el codigo que queremos que se ejecute

        //periodicamente

        TimerTask task = new TimerTask() {

            public void run() {

                //aumentamos en 1 el contador

                contador++;

                //fijamos el nuevo valor en la barra

                barra_progreso.setValue(contador);

            }

        };

        //programamos la tarea para que se ejecute cada 200 ms

        t.scheduleAtFixedRate(task, 0, 200);

    }

}

El resultado es el siguiente

Como podemos ver es muy sencillo utilizar las barras de progreso y las posibilidades que nos ofrecen son muchísimas.

DateField

Por último vamos a ver los campos de fecha o DateField.


public class DateFieldForm extends Form implements CommandListener{



    //Los parametros para crear un objeto DateField son: etiqueta y modo (DATE, 

    //DATE_TIME o TIME)

    private DateField fechaForm = new DateField("Fecha", DateField.DATE);   

    private Command capturar = new Command("Capturar", Command.OK, 0);



    public DateFieldForm(String title) {

        super(title);

        append(fechaForm);

        fechaForm.setDate(new Date());//Fijamos la fecha actual           

        addCommand(capturar);

        setCommandListener(this);

    }   



    public void commandAction(Command c, Displayable d) {

        if(c == capturar){                   

            Date fecha = fechaForm.getDate();       

            //Ahora ya podemos tratar estos campos para lo que necesitemos

            append(fecha.toString());

       

        }

    }



}

El resultado es el siguiente:

Hasta aquí va la parte de Formularios, espero les haya servido. En los próximos tutoriales veremos otra forma para crear interfaces: Las Listas.

Pueden encontrar todo el código de los tutoriales de formularios aquí

Parte 1
Parte 2

Interfaces gráficas de usuario de alto nivel - Formularios (Parte 2)

2011-12-27T11:42:00.000-05:00

En el tutorial anterior vimos cómo crear un formulario sencillo con un TextField y un StringItem, ahora vamos a ver otros elementos que se pueden añadir a los formularios.

Antes de empezar con los ejemplos, es importante señalar que en j2me podemos hacer uso de imágenes, sonidos, videos, archivos de texto, archivos xml, entre otros. Estos archivos son llamados recursos y podemos acceder a ellos desde nuestra aplicación, simplemente debemos crear una carpeta llamada res en el directorio raíz de nuestro proyecto (C:\Users\usuario\Documents\NetBeansProjects\MiPrimeraApp), en esta carpeta pondremos todos los archivos que queramos usar en la aplicación. Ahora debemos indicarle al NetBeans que la carpeta res almacenará nuestros recursos, el procedimiento es el siguiente:

En el árbol del proyecto damos click derecho sobre Resources (Recursos en español)

Seleccionamos la opción Add Folder y seleccionamos la carpeta res que creamos anteriormente. Esta es la forma más organizada para utilizar recursos, pues define una clara separación entre el código y los demás archivos, la otra forma es simplemente crear un nuevo paquete y almacenar allí los recursos.

En el tutorial anterior vimos que para agregar items a un formulario utilizamos el método append, este método tiene 3 variantes:


append(item);//donde item es cualquier elemento que hereda de la 

//clase item (ver http://www.ibm.com/developerworks/java/tutorials/j-j2me1/display_diagram3.gif)

append(str);//donde str es una cadena de texto simple

append(img);//donde img es una imagen

Imagenes

Hay dos formas de agregar imágenes a un formulario:


import javax.microedition.lcdui.Form;

import javax.microedition.lcdui.Image;

import javax.microedition.lcdui.ImageItem;



/**

 *

 * @author Juan Camilo

 */

public class ImageForm extends Form {



    private Image img;

    private ImageItem logo_java;



    public ImageForm(String title) {

        super(title);

        //Creamos la imagen

        try {

            //primero debemos crear la imagen, la cual previamente debera estar

            //guardada en la carpeta res, usando como referencia su nombre

            //en este caso java-ubuntu-logo.png; en caso de que la imagen estuviera

            //por ejemplo en /res/images/, el parametro seria: /images/java-ubuntu-logo.png

            img = Image.createImage("/java_logo.png");

        } catch (Exception e) {

            append("Error al cargar la imagen");//en caso de que exista un

            //error al cargar la imagen, mostramos un texto al usuario

        }

        //-------------------------------------------------------------

        //La primera forma de añadir una imagen es:

        logo_java = new ImageItem("Logo Java", img, ImageItem.LAYOUT_CENTER, "logo de java ubuntu");

        //Los parametros son: etiqueta, imagen, layout (indica la forma en que se

        //muestra la imagen), y por ultimo el texto alternativo que se muestra

        //en caso de que la imagen no cargue

        append(logo_java);

        //---------------------------------------------------------------

        //La segunda forma es:

        append(img);

        //simplemente añade la imagen al formulario sin ninguna informacion

        //sadicional

    }

}

El resultado final es el siguiente:

Forma 1

Forma 2

Como podemos ver la primer forma de agregar imágenes, permite un mayor control en la ubicación de las imágenes, ademas permite ponerle un titulo sin necesidad de elementos adicionales.

Nota:
El codigo presentado arriba corresponde simplemente al formulario, el código del MIDlet el el mismo que el de la parte 1 de este tutorial, solamente debemos cambiarlo para que muestre este formulario:


display.setCurrent(new ImageForm("formulario imagen"));

ChoiceGroup

Es un elemento que permite escoger entre múltiples opciones, este puede ser creado de tal forma que permita una única selección o múltiples selecciones. Es muy utilizado para presentar al usuario un conjunto de opciones predeterminadas como por ejemplo: sexo (masculino/femenino), dificultad en un juego (fácil/medio/difícil) o seleccionar un conjunto de preferencias como sonido, ayudas, etc. en un juego.

Selección Única


public class ChoiceGroupForm extends Form implements CommandListener{



    private ChoiceGroup radio_button = new ChoiceGroup("Sexo", ChoiceGroup.EXCLUSIVE);

    //Las opciones en un ChoiceGroup estan representadas por una parte de texto

    //y un icono (si se desea se puede evitar poner un icono), en este caso

    //usaremos 2 iconos para la seleccion unica

    private Image female;

    private Image male;

    //Command para capturar las opciones seleccionadas

    private Command ok = new Command("OK", Command.OK, 0);



    public ChoiceGroupForm(String title) {

        super(title);

        try{

            female = Image.createImage("female.png");

            male = Image.createImage("male.png");

        }catch(Exception e){

            append("error al cargar imagenes");

        }

        //Para agregar opciones a un ChoiceGroup utilizamos el metodo append

        radio_button.setLabel("Sexo");//Fija la etiqueta para el conjunto

        //completo

        radio_button.append("Femenino", female);//El primer parametro es el titulo

        //el segundo es la imagen

        radio_button.append("Masculino", male);

        //--------------------------------------------------

        append(radio_button);

        addCommand(ok);

        setCommandListener(this);



    }



    public void commandAction(Command c, Displayable d) {

        if(c == ok){

            int index = radio_button.getSelectedIndex();//capturamos el indice

            //del elemento seleccionado (el primer elemento tiene indice 0)

            String item = radio_button.getString(index);//obtenemos el nombre

            //de la opcion a partir del indice

            append(item);

        }

    }



}

El resultado es el siguiente:

Selección Múltiple


public class ChoiceGroupForm extends Form implements CommandListener{



    private ChoiceGroup check_box = new ChoiceGroup("Preferencias del Juego", ChoiceGroup.MULTIPLE);

    //Las opciones en un ChoiceGroup estan representadas por una parte de texto

    //y un icono (si se desea se puede evitar poner un icono), en este caso

    //usaremos 2 iconos para la seleccion unica

    private Image sound;

    private Image help;

    //Command para capturar las opciones seleccionadas

    private Command ok = new Command("OK", Command.OK, 0);   

    private boolean[] selectedFlags = new boolean[2]; //un array que va a contener

    //los elementos seleccionados del ChoiceGroup



    public ChoiceGroupForm(String title) {

        super(title);

        try{

            sound = Image.createImage("sound.png");

            help = Image.createImage("help.png");

        }catch(Exception e){

            append("error al cargar imagenes");

        }

        //Para agregar opciones a un ChoiceGroup utilizamos el metodo append

        check_box.append("Sonido", sound);//El primer parametro es el titulo

        //el segundo es la imagen

        check_box.append("Ayuda", help);

        check_box.setSelectedIndex(0, true);//indicamos que el primer elemento

        //este seleccionado por defecto

        //--------------------------------------------------

        append(check_box);

        addCommand(ok);

        setCommandListener(this);



    }



    public void commandAction(Command c, Displayable d) {

        if(c == ok){

            int numItems = check_box.getSelectedFlags(selectedFlags);

            //numItems determina el numero de elementos seleccionados

            //selectedFlags debera ser del mismo tamaño que el ChoiceGroup

            //pues es el que indica cuales elementos estan seleccionados

            if(selectedFlags[0]){

                append("Seleccionaste Sonido ON");

            } else{

                append("Seleccionaste Sonido OFF");

            }

    

        }

    }



}

El resultado es el siguiente:

Hasta aquí la segunda parte del tutorial de formularios, en el siguiente tutorial veremos las barras de progreso.

Parte 1
Parte 3

Interfaces gráficas de usuario de alto nivel - Formularios (Parte 1)

2011-12-22T11:35:00.001-05:00

Interfaces Gráficas de Alto Nivel

En j2me las clases necesarias para implementar una interfaz gráfica de alto nivel estan contenidas en el paquete javax.microedition.lcdui.

LCDUI (Limited Capability Device User Interface ) define un conjunto de elementos que podemos utilizar para crear las interfaces gráficas de nuestra aplicación, cada celular es responsable de "dibujar" y ubicar los elementos en pantalla, por lo tanto, aunque en ocasiones esto es ventajoso (por ejemplo, una sola aplicación funciona para diferentes tamaños de pantalla) existen otras ocasiones donde es importante que en el celular se muestre exactamente lo que queremos y donde lo queremos (por ejemplo, juegos).

En J2ME todos los componentes gráficos descienden de la clase Displayable

En esta primera parte del tutorial de GUI en j2me voy a explicarles qué es un formulario, cómo crearlo y haré un par de ejemplos para que quede más claro .

Un formulario es un componente gráfico que puede contener campos de texto, cadenas de texto, imágenes, barras de progreso, cajas de chequeo, campos de fecha, entre otros. Es un elemento muy común para presentar información al usuario o para pedir datos al usuario (por ejemplo una pantalla de inicio de sesión). Al igual que todos los objetos en Java para crearlo simplemente se usa el operador new


Form simpleForm = new Form("mi formulario") //Formulario vacio;

El parámetro que recibe el nuevo formulario es el titulo que aparecerá en la parte superior de la pantalla. En el tutorial anterior creamos el formulario en la clase principal (el MIDlet), pero para tener el código de nuestra aplicación mas organizado (y para facilitar futuras modificaciones) es recomendable crear una nueva clase por cada formulario (mas adelante veremos que esto aplica también para cualquier interfaz gráfica), ¿cómo hacemos esto?, simplemente aplicando el concepto de herencia


import javax.microedition.lcdui.Form;



public class SimpleForm extends Form{





    public SimpleForm(String title) {

        //esto es un formulario vacio

        super(title);

    }



}

Vamos a mejorar nuestro Hola Mundo del tutorial anterior y ahora nuestro formulario va a estar en una nueva clase, el código quedaría así:

MIDlet


import javax.microedition.lcdui.Display;

import javax.microedition.midlet.*;


public class HelloMIDlet extends MIDlet{



    public Display display;

    public static HelloMIDlet midlet; //referencia estatica al MIDlet

    public SimpleForm simpleForm = new SimpleForm("Mi Formulario");

    //el parametro entre parentesis es el titulo del formulario





    public HelloMIDlet() {

        display = Display.getDisplay(this); //Obtenemos la referencia

        midlet = this;

        //al objeto display

    }





    public void startApp() {

        display.setCurrent(simpleForm);//utilizando el metodo setCurrent

        //del objeto display, le indicamos al programa que ponga en pantalla

        //el formulario

    }



    public void pauseApp() {

    }



    public void destroyApp(boolean unconditional) {

    }



}

Formulario


import javax.microedition.lcdui.Command;

import javax.microedition.lcdui.CommandListener;

import javax.microedition.lcdui.Displayable;

import javax.microedition.lcdui.Form;

import javax.microedition.lcdui.StringItem;



public class SimpleForm extends Form implements CommandListener{





    private StringItem miCadena = new StringItem("", "Hola Mundo");

    private Command exit = new Command("Exit", Command.EXIT, 0);   



    public SimpleForm(String title) {

        super(title);

        append(miCadena);

        addCommand(exit);

        setCommandListener(this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == exit){

            HelloMIDlet.midlet.destroyApp(true);

            HelloMIDlet.midlet.notifyDestroyed();

        }

    }



}

El resultado después de la simulación es el mismo que en el caso anterior, pero este es un código mucho más organizado y escalable.

Ahora vamos a mejorar un poco el ejemplo anterior, ahora en vez de decir hola mundo, la aplicación dirá hola a un nombre que tu le indiques. El código del MIDlet queda igual.

Formulario


import javax.microedition.lcdui.Command;

import javax.microedition.lcdui.CommandListener;

import javax.microedition.lcdui.Displayable;

import javax.microedition.lcdui.Form;

import javax.microedition.lcdui.StringItem;

import javax.microedition.lcdui.TextField;



public class SimpleForm extends Form implements CommandListener{





    private StringItem miCadena = new StringItem("", "");// una cadena vacia

    private TextField nombre = new TextField("Nombre", "", 20, TextField.ANY);

    /*

     * La clase TextField permite al usuario ingresar texto, los parametros que

     * recibe son: Etiqueta, Texto que se muestra, numero maximo de caracteres,

     * y las constraints o limitaciones, que indican el tipo de caracteres que 

     * se pueden ingresar en el campo de texto (en este caso cualquier caracter)

     */

    private Command exit = new Command("Exit", Command.EXIT, 0);

    private Command saluda = new Command("Saluda", Command.SCREEN, 0);



    public SimpleForm(String title) {

        super(title);   

        append(miCadena); //añadimos la cadena al formulario

        append(nombre);// añadimos el campo de texto al formulario

        //añadimos los command al formulario

        addCommand(exit);

        addCommand(saluda);

        //fijamos el listener

        setCommandListener(this);

    }



    public void commandAction(Command c, Displayable d) {

        if(c == exit){

            HelloMIDlet.midlet.destroyApp (true);

            HelloMIDlet.midlet.notifyDestroyed();

        }

        if(c == saluda){

            //Si se presiona el boton saluda, utilizamos el metodo setText 

            //de miCadena para fijar un texto en el elemento, y el metodo

            //getString del campo de texto para capturar lo que escribimos

            miCadena.setText("Hola " + nombre.getString());

        }

    }

}

Como se puede ver, es muy sencillo crear formularios y añadirles elementos, en el próximo tutorial veremos como crear formularios más avanzados

Parte 2
Parte 3

Introducción a J2ME (Parte 2)

2011-12-20T22:20:00.000-05:00

En esta segunda parte del primer tutorial, voy a crear un nuevo proyecto en Netbeans 7.0, explicaré el funcionamiento de un MIDlet y crearemos nuestra primera aplicación

En el vídeo anterior pudo quedar alguna confusión en cuanto a qué perfil y configuración escoger, los celulares nuevos todos soportan CLDC 1.1 y MIDP 2.1, pero si tienen dudas sobre la configuración y el perfil, pueden buscar en las especificaciones del celular en la página del fabricante. Para Nokia las especificaciones de sus dispositivos están disponibles aqui

Como escogimos la opción de no Crear Hello MIDlet en el asistente de creación de proyectos, nuestro proyecto esta vacío, es decir no tiene ninguna clase. En el siguiente vídeo veremos como crear nuestra primera aplicación, pero antes voy a explicar un concepto fundamental para crear aplicaciones móviles en J2ME.

MIDLET

El MIDlet sera nuestra clase principal (todo midlet debe heredar de la clase MIDlet), es la que controla el ciclo de vida de nuestra aplicación (similar a la clase main en J2SE) y tiene 3 metodos principales:

startApp(): este método es llamado en el momento en que la aplicación es lanzada, generalmente se utiliza para inicializar recursos como interfaces gráficas, RMS (lo veremos mas adelante) y conexiones de red
pauseApp(): este método es llamado cuando la aplicación entra en estado de pausa (por ejemplo cuando entra una llamada o llega un mensaje), se utiliza para liberar los recursos inicializados en startApp()
destroyApp(): este método es llamado cuando se termina la ejecución de la aplicación, además libera todos los recursos de la aplicación

Ciclo de Vida de un MIDlet

Con estos conceptos básicos podemos crear nuestro primer MIDlet:

Una vez terminamos de crear nuestro MIDlet, podemos empezar a poner elementos en la pantalla.

La Clase Display (javadoc)

Cada MIDlet tiene una referencia a la clase Display, esta clase proporciona los métodos que nos permiten controlar la visualización de los objetos en pantalla.
El código final del MIDlet quedaría así:


/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package primeraapp;



import javax.microedition.lcdui.Command;

import javax.microedition.lcdui.CommandListener;

import javax.microedition.lcdui.Display;

import javax.microedition.lcdui.Displayable;

import javax.microedition.lcdui.Form;

import javax.microedition.lcdui.StringItem;

import javax.microedition.midlet.*;



/**

 * @author Juan Camilo

 */

public class HelloMIDlet extends MIDlet implements CommandListener{



    public Display display;

    private Form simpleForm = new Form("mi formulario");//Creamos un nuevo formulario

    //el parametro entre parentesis es el titulo del formulario

    private StringItem miCadena = new StringItem("", "Hola Mundo");//Creamos un nuevo

    //StringItem el cual es una cadena de texto que se puede mostrar en un

    //formulario, los parametros son etiqueta y texto respectivamente

    private Command exit = new Command("Exit", Command.EXIT, 0);

    // Un command es un boton que se ubica en la parte baja de la pantalla

    //los parametros son etiqueta, tipo de boton (para indicar la posicion, izq. o der.)

    // y por ultimo la prioridad sobre otros command (0 es maxima prioridad)



    public HelloMIDlet() {

        display = Display.getDisplay(this); //Obtenemos la referencia

        //al objeto display

        simpleForm.append(miCadena);//añadimos la cadena de texto al formulario

        //utilizando el metodo append y pasando como parametro el objeto 

        //StringItem   

        simpleForm.addCommand(exit);//añadimos el command al formulario

        simpleForm.setCommandListener(this);//fijamos el listener(capturador de 

        //eventos) de los command, es decir un metodo que se llama cada vez

        //que presionamos un command -> si se fijan la clase implementa la

        //interfaz CommandListener

    }



   

    public void startApp() {

        display.setCurrent(simpleForm);//utilizando el metodo setCurrent

        //del objeto display, le indicamos al programa que ponga en pantalla

        //el formulario

    }



    public void pauseApp() {

    }



    public void destroyApp(boolean unconditional) {

    }



    public void commandAction(Command c, Displayable d) {

        if (c == exit) { //determinamos si el commando que disparo el evento

            //fue exit

        destroyApp(false); //liberamos recursos

        notifyDestroyed();//notificamos de la finalizacion de la ejecucion de la

        //aplicacion

      }

    }

}

Si se quiere probar la aplicación en el celular para ver que todo funciona correctamente (primero es necesario compilar), simplemente vamos a la ruta del proyecto, en mi caso C:\Users\usuario\Documents\NetBeansProjects\MiPrimeraApp, allí encontraremos una carpeta llamada dist en la cual hay 2 archivos: un .jar y un .jad.
El archivo .jar es el ejecutable de la aplicación y es el que pasamos al celular para instalar la aplicación. El .jad es el Java Application Descriptor y es un archivo que contiene información relacionada con el .jar, por ejemplo, versión de la aplicación, nombre de la aplicación, nombre del desarrollador, tamaño, la configuración y el perfil. Desde las propiedades del proyecto en Netbeans podemos añadir más atributos al JAD como veremos más adelante, por defecto el Netbeans añade aquellos atributos que son obligatorios.

Mas información sobre los parámetros de un JAD aquí

Con esto finalizamos nuestro primer tutorial sobre programación en j2me, si te quedaron algunas dudas sobre el programa que acabo de hacer no te preocupes, muchas de esas dudas se aclararan con el tiempo, pero si gustas puedes dejar un comentario y con gusto responderé tus inquietudes

Muy pronto el segundo tutorial

Ir a primera parte
Ir al inicio

Introducción a J2ME (Parte 1)

2011-12-20T13:55:00.000-05:00

En el primer tutorial aprenderemos los conceptos básicos de j2me, además crearemos un proyecto en netbeans 7.0 (disponible aqui) y nuestra primera aplicación.

Nota: para poder entender completamente los tutoriales de este blog, es necesario tener conocimientos en el lenguaje de programación Java

Conceptos Básicos de Java ME:

¿Qué es Java ME? - Es un subconjunto de la plataforma java orientada al desarrollo de aplicaciones para dispositivos con recursos limitados.
¿En qué dispositivos funciona Java ME? - en la actualidad casi todos los celulares del mercado soportan J2ME (incluyendo Smartphones), aunque su uso esta cada vez mas restringido para dispositivos con limitaciones de memoria (Ej, Serie 40 de Nokia).
J2ME se basa en dos conceptos clave: Configuraciones y Perfiles

Configuración: se compone de una máquina virtual y un conjunto mínimo de librerías. Existen dos configuraciones para J2ME

CDC (Connected Device Configuration ): diseñado para dispositivos de alta gama como set top boxes o PDAs, incluye la JVM (Java Virtual Machine) completa y un subconjunto amplio de las librerías disponibles para J2SE.
CLDC (Connected Limited Device Configuration): diseñado para dispositivos con limitaciones de memoria y procesadores lentos, incluye la KVM (Kilobyte Virtual Machine) y un subconjunto reducido de las librerías disponibles para J2SE. Esta configuración es la que se utiliza para desarrollar aplicaciones para celulares y es la que trataré en todos los tutoriales

Perfil: es un conjunto de APIs orientado a un ámbito de aplicación específico, estipula las librerías necesarias para implementar una aplicación en un conjunto de dispositivos. Para teléfonos celulares existe un único perfil denominado MIDP (Mobile Information Device Profile).

Una aplicación desarrollada con el perfil MIDP recibe el nombre de MIDlet.
Java SE funciona sobre la popular Máquina Virtual de Java (JVM), en contraste J2ME funciona sobre la KVM (Kilobyte Virtual Machine) la cual esta especificamente diseñada para manejar aspectos específicos de dispositivos con recursos limitados.
Relacion de librerias entre las diferentes plataformas de Java

Nota: para conocer el conjunto completo de librerías que soporta Java ME pulsa aquí

Aquí finaliza la primera parte del primer tutorial, muy pronto la segunda parte.

Volver al Inicio
Ir a segunda parte

Tutorial Java ME (J2ME)

2011-12-20T12:28:00.000-05:00

He decidido publicar algunos tutoriales para introducir una de las plataformas más populares para el desarrollo de aplicaciones móviles: Java ME o J2ME.
Aunque con el auge de los smartphones y de nuevas plataformas de desarrollo mas potentes, como Android de Google, QT de Nokia y HTML5, J2ME ha quedado relegado a dispositivos de gama baja, aún sigue siendo la plataforma más utilizada sobre todo en países en vía de desarrollo, incluso hace poco terminó un concurso de desarrollo de aplicaciones móviles de Nokia para sus dispositivos serie 40 donde J2ME es protagonista.

Programa:

1. Introducción a J2ME: conceptos básicos, como crear un proyecto en Netbeans 7.0 y nuestra primera aplicación.
Parte 1
Parte 2
2. Construir interfaces gráficas de usuario de alto nivel (GUI): Formularios, listas, imágenes, botones
Formularios (Parte 1)
Formularios (Parte 2)
Formularios (Parte 3)
Listas
TextBox, Alert y Ticker
3. Construyendo aplicaciones más complejas: navegación entre diferentes GUI
4. Almacenamiento persistente: uso de RMS para almacenar datos persistentes de nuestra aplicación
Parte 1
Parte 2
Parte 3
Parte 4
5. Aplicando los que sabemos: primera aplicación "real" para poner en práctica nuestros conocimientos
6. Introducción a Canvas (interfaz de usuario de bajo nivel): manejo de coordenadas, dibujar lineas, círculos, rectángulos y cadenas de texto
7. Eventos: cómo capturar las pulsaciones del teclado y en pantallas táctiles
8. GameCanvas: mejora de la clase Canvas para el desarrollo de juegos
9. Manejos de gestos y animaciones: Gesture y Frameanimator API

El objetivo de estos tutoriales es simplemente introducir al lector en la programación en J2ME mas no volverlo un experto. En el futuro realizaré tutoriales de programación en Android, una plataforma cada vez más popular y que se proyecta como sistema operativo líder en smartphones.

Geo Genius Video

2011-10-19T21:15:00.000-05:00

Geo Genius

2011-10-19T20:11:00.000-05:00

Geo Genius es un juego de preguntas de geografía muy entretenido, en el cual se ponen a prueba tus conocimientos sobre la ubicación de diferentes ciudades del mundo. El juego ademas te ofrece datos curiosos sobre diferentes ciudades y países A medida que vayas jugando, puedes conseguir logros por tus habilidades. Disponible en Inglés y Español

A continuación algunas imágenes (próximamente un video)

Fig 1. Icono

Fig 2. Pregunta

Fig 3. Datos Curiosos

Video News on the Go

2011-09-20T14:15:00.000-05:00

Pequeño video que muestra el funcionamiento de News on the Go para dispositivos S40

Pequeño video que muestra el funcionamiento de News on the Go para dispositivos S60

2011-09-11T09:10:00.000-05:00

News on the Go

News on the Go es una aplicación de noticias que utiliza múltiples servicios para ofrecer un conjunto muy completo de información a los usuarios. Los Servicios son los siguientes:

Noticias:
Para las noticias se utiliza el servicio de noticias de google, el cual está disponible para más de 50 países y en más de 20 idiomas

Twitter:

La red de microblogging más grande en la actualidad, donde es posible encontrar información en tiempo real sobre cualquier tema. La aplicación ofrece la posibilidad de ver las tendencias del momento y además buscar sobre cualquier tema.

Yahoo! Weather:
El servicio de clima de una las grandes compañías de Internet, que ofrece información de las condiciones actuales del clima (+/- 2 horas) con datos sobre humedad, visibilidad, temperatura, viento, entre otras, además de pronósticos del día actual y del día siguiente.

Adicionalmente para el Reino Unido y Estados Unidos se ofrece información en tiempo real del tráfico mediante los servicios proporcionados por Highways Agency y NAVTEQ Traffic.com respectivamente.

Algunos Screenshots de la aplicación (próximamente un vídeo)

Cualquier duda que tengan sobre la aplicación, no duden en contactarme en el correo creacionesmoviles@hotmail.com

Vídeo disponible aquí

2011-09-10T14:37:00.003-05:00

FORMULA DB

Esta es una pequeña guía sobre el uso general de Formula DB, si tienes alguna inquietud adicional por favor remitirla a juan.ospina.quintero@gmail.com

1. Esta es la pantalla inicial de la aplicación, en ella encontraras las 3 categorías principales de formulas: Matemáticas Física y Electrónica. Además una categoría adicional llamada Usuario, en la cual el usuario podrá crear sus propias categorías de formulas.

2. Seleccionar cualquiera de las 3 categorías principales, le permite al usuario observar las subcategorías que contiene, en la imagen se muestran las subcategorías de Electrónica.

Posteriormente, ya se puede ingresar a las formulas deseadas:

2011-09-10T14:37:00.001-05:00

DANCING MADNESS

Dancing Madness es un juego para dispositivos Nokia táctiles serie 40, en donde el objetivo es anotar la mayor cantidad de puntos, siguiendo el ritmo de la música en una pista de baile.

Figura 1. Imagen de Splash

Figura 2. Menú Principal

Figura 3. Pista de Baile

2011-09-10T14:36:00.003-05:00

FINGER FREE KICK

Fig. 1 Imagen de Splash

Fig. 2 Menú Principal

Fig. 3 Campo de Juego

Fig. 4 Gol

Fig. 5 Balón pega en barrera

2011-09-10T14:36:00.001-05:00

Finger Free Kick

Finger Free Kick es una aplicación para dispositivos Nokia táctiles serie 40, el objetivo es anotar la mayor cantidad de goles pateando un balón con los dedos de la misma forma como lo harías con los pies, aquí dejo un video de demostración

2011-09-10T14:35:00.001-05:00

QUICK STICKY NOTES

Quick Sticky Notes es una aplicación para dispositivos táctiles Nokia serie 40 que permite organizar tus notas personales de una forma mucho más divertida que la aplicación de notas por defecto que traen la mayoría de los celulares, puedes escoger temas para el tablero de notas, además de los colores de las notas y del texto. A continuación algunas imágenes de la aplicación