jueves, 20 de diciembre de 2007

Guía de desarrollo de aplicaciones móviles - J2ME (3)

Guía 1 – La primera aplicación (3)

  • Ahora nos paramos en el paquete view, damos clic derecho, seleccionamos New >> Java Class… (Figura 11), y nombramos la nueva clase (Figura 12) yo la llame IntroForm.

Figura 11. Nueva Clase

Figura 12. Nombre de la Clase
De igual forma creamos una nueva clase llamada ItemsForm.

Figura 13. Estructura General
Al final de crear la MIDlet como las clases, la estructura general se vera como la figura 13, con cada uno de sus archivos en sus paquetes respectivos, en el paquete res añadí unas imágenes en formato png, las cuales serán desplegadas en algunos de los screens de la aplicación, las imágenes tienen que ser pequeñas, por ejemplo la más grande que tengo es de unos 200x140 pixeles aprox. Las imágenes las puedes añadir directamente a la carpeta res desde el Explorer de Windows.
  • Ahora el código genérico para las clase será el siguiente (IntroForm.java, ItemsForm.java):
package view;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
public class IntemsForm extends Form implements CommandListener{
public ItemsForm() {
super(" Items Menu");
initForm();
}
private void initForm() {
}
public void commandAction(Command command, Displayable displayable) {
}
}
Ambas clases parten del mismo código genérico, solamente debes cambiar el nombre que se encuentra subrayado y en negrita (ItemsForm -> ItensForm.java) para cada una de las clases (IntroForm -> IntroForm.java). Este tipo de clase son heredan la clase Form que se utilizan como, formas de visualización para el dispositivo, en ellas se pueden manejar ciertos Ítems que se adicionan a estas formas como, Imágenes, StringItem, Comandos, ChoceeGroup, TextField, etc. Todo esto para formar la interfaz grafica que visualizara el usuario, también hay que trasformar la clase para que maneje eventos, como por ejemplo al pulsar la tecla select del dispositivo en algún item de la forma se debe ejecutar cierta acción como salir de la aplicación o pasar a la siguiente visualización esto se hace mediante la implementación de la interfaz CommandListener.
En el constructor aparece la línea de código super(" Items Menu"); esta línea de código es necesaria ya que se requiere por heredar de la clase Form, y es el nombre de nuestra forman, la función initForm se utilizara para inicializar todos los ítems y comandos que manejara nuestra forma, y la función commandAction se utiliza para desarrollar el código necesario cuando ocurre algún evento por parte del usuario o el dispositivo.
  • Ahora comenzaremos a construir nuestra primera forma IntroForm, lo que se realizara es crear una pantalla de bienvenida, solamente clocaremos algunos ítems como un StrinItem que sirve para desplegar texto, y una imagen, algunos comandos y listo ya tenemos nuestra primera forma el código esta en la figura 14.
Se adicionaron 3 nuevos imports que manejan a los Ítems como Image (línea 20), ImageItem (línea 21), StringItem (línea 22), se crearon los atributos respectivos y dos atributos tipo Command que servirán para ver la siguiente pantalla o salir de la aplicación (linaes de la 32 a 34 y 39 a 40).
En la función InitForm Se inicializan los atributos sItMensaje que será el mensaje que se desplegara en pantalla para esto al constructor se le pasan 2 parámetros, el primero es el nombre de label o del Ítems y el segundo el mensaje que queremos desplegar (línea 51 y 52). Después viene la inicialización de la imagen para esto primero inicializamos un atributo tipo Image img1 con la función Image.createImage(“ruta del archivo”), en este caso la ruta la tome comenzando desde el directorio del proyecto, después el paquete res y por ultimo el nombre de la imagen png “/res/helloword.png” (línea 55) , una recomendación es que siempre que se intente cargar una imagen se realice dentro de un try y catch como se ve en el código, para evitar ejecución erróneas de la aplicación, después se inicializa el atributo imgItem1 el cual sea el que se desplegara en pantalla, el constructor recibe 3 parámetros, el primero es el nombre que se desplegara antes de la imagen, en este caso coloque puros saltos de línea para que la imagen “aparezca” casi en el centro de la pantalla del dispositivo, el segundo parámetro es la imagen que la cual ya la hemos cargado en el atributo img1, y el tercer parámetro es su distribución si se quiere que la imagen aparezca al lado izquierdo de la pantalla, en el centro, o a la derecha, en este caso se dejo que apareciera en el centro (línea 56).
Ahora inicializaremos los comandos, por ejemplo el comando que nombramos cmdExit se utilizara para finalizar la aplicación, para inicializar un comando se necesita pasar 3 atributos al constructor, el primero es el nombre con el cual aparecerá en el dispositivo, el segundo es el tipo de comando, en este caso un comando de salida y el tercero es la prioridad del comando (líneas 61 y 62), el tipo de comando Command.Exit es para salir de la aplicación, Command.Screen se utiliza para cambiar la pantalla hacia otra Forma o Lista, Command.Back para retornar a una visualización anterior, etc. Puedes ver todos los tipos de comandos con la ayuda del IDE de netbeans hay como unos 8 tipos de comandos.

Figura 14. Código IntroForm.java
Luego de inicializar los Ítems como los comandos, estos se deben adicionar a la forma, los ítems se adicionan con la función append(“nombre item”), y los comandos con addCommand(“nombre comando”) (líneas 64, 65 y 67, 68), por ultimo activos el detector de eventos llamando a la función setCommandListener(“forma o lista”), a esta hay que pasarle como parámetro un objeto en este caso la forma initForm la cual también la nombramos internamente como this (línea 73).
Ahora veremos como capturamos los eventos, esto se realiza dentro de la función commandAction (Command command, Displayable displayable), el parámetro de entrada importante en este caso es command, ya que este es el comando que se activara en el momento, el parámetro command de entrada se comparará con alguno de los dos comandos que creamos (cmdExit o cmdItems), si este comando es igual a alguno de nuestros comandos, se procederá a ejecutar cierta acción, en el caso de que sea igual al comando cmdExit se ejecutan las líneas 78 y 79 que finalizan la aplicación, y si es igual cmdItems, se ejecuta la línea 82 la cual llama a nuestra otra forma ItemsForm para que se visualice en pantalla. Una aclaración en este código y que todavía no he explicado, es la forma en como se llaman estas funciones, primero hacemos referencia a la midlet, y luego ejecutamos una función, por ejemplo en la línea 82 tenemos GuiaMidlet.midlet.getDisplay().setCurrent(GuiaMidlet.itemsForm); con lo cual queremos decir que al despliegue de nuestra midlet lo actualicemos con nuestra forma itemsForm para que se vea en pantalla, a continuación aclarare un poco esto.
  • En la explicación anterior, vimos como inicializar una forma o interfaz de usuario la cual se vera en el dispositivo, también como se capturan eventos, tal vez esta parte no se haya entendido bien pero con el código de la midlet quedara un poco más claro, el código de la midlet esta en la figura 15.
Lo que realizaremos aquí es, realizar el import respectivo del paquete en donde creamos nuestras formas el paquete view (línea 11), luego creamos un objeto de la MIDlet que sea genérico y el mismo para toda la aplicación (línea 20), luego creamos dos atributos que manejaremos de manera global de nuestras formas (introForm y itemsForm) (líneas 23 y 24).
En la función inicializar, inicializaremos nuestra MIDlet, en este caso cargaremos en memoria apenas inicia nuestra aplicación, las dos formas (líneas 31 y 32) y la aplicación la inicializaremos para que despliegue en pantalla una forma predeterminada en este caso introForm, esto se hace por medio de la función getDisplay().setCurrent(introForm) (línea 34), getDisplay obtiene el despliegue actual y setCurrent establece el despliegue actual con alguna forma o lista que pasemos como parámetro, en nuestro caso introForm.
La función startApp se ejecuta cuando la aplicación inicia, este lugar será apropiado para establecer nuestro objeto global de la MIDlet, el cual lo hemos llamado midlet (línea 45), ya que cuando se ejecuta esta función ya se ha realizado el proceso de inicialización de la MIDlet.
La función destroyApp se ejecuta cuando deseamos finalizar la aplicación, aquí colocamos a nuestra dos formas (introForm y itemsForm) en nulo (líneas 52 y 53) y llamamos a recolector de basura para que libere memoria del dispositivo (línea 54).
Espero que con esto ya que de más clara la explicación que realice de la clase introForm.java

Figura 15. Código GuiaMidlet.java
  • Ahora el código de la forma ItemsForm.java figura 16. En este código no hay nada raro, solamente se añadió un comando el cual se utilizara para salir de la aplicación.

Figura 16. Código ItemsForm.java

  • Después de haber realizado la respectiva codificación de los archivos, podremos ver ahora lo que se ha creado ejecutando el proyecto, primeros colocamos el cursor del Mouse en el proyecto, presionamos el clic derecho del Mouse, seleccionamos Build Project (figura 17.), luego de nuevo damos click derecho en el proyecto y seleccionamos Run Project
Figura 17.
Figura 18.
Luego se ejecuta automáticamente el emulador (Figura 19.), seleccionamos el nombre de la aplicación y corremos la aplicación.

Figura 19.
Ahora nos aparece esto (figura 20), si seleccionamos entrar nos pasara a la siguiente forma (figura 21), y si seleccionamos Salir cerraremos la aplicación, en la siguiente pantalla que visualizamos (figura 21) solo hay un comando, Salir, lo seleccionamos y finalizamos nuestra aplicación:
Figura 20
Espero que con esta pequeña introducción a desarrollo de aplicaciones móviles, haya aumentado su motivación, la aplicación no realiza gran cosa, pero lo que si funciona es lo que va de fondo, trate de presentarles un código funcional y genérico que puedan reutilizar para sus aplicaciones, en una siguiente guía tratare de presentar como manejar algunos de los Ítems que se pueden adicionar a la interfaz de usuario y algunas otras cosas más
Cualquier comentario pueden hacerlo a:

miércoles, 12 de diciembre de 2007

Guía de desarrollo de aplicaciones móviles - J2ME (2)

Guía 1 – La primera aplicación (2)

Que necesitas para seguir esta guía y realizar la aplicación:

La versión de netbeans puede ser anterior o superior a esta pero necesariamente debe concordar con el paquete netbeans-mobility-5_x-win para Windows, claro y también sirve para los amantes de sistemas UNIX, como Linux. Todo este software lo puedes descargar de la pagina oficial de java ] http://java.sun.com/.
La aplicación la realice en NetBeans 5.5 y los paquetes anteriormente mencionados; sun_java_wireless_toolkit-2_5-windows es un conjunto de herramientas para el desarrollo de aplicaciones móviles, en este se encuentra el emulador, configuraciones generarles, etc.
Como aclaración debo decir que netbeans y su netbeans-mobility no son necesarios para empezar a desarrollar aplicaciones móviles, solamente se puede utilizar el J2SE 5.0 y el sun_java_wireless_toolkit-2_5, pero como un entorno de desarrollo es más eficiente para agilizar el trabajo y revisión de código por esta razón recomiendo utilizar el netbeans.
La instalación de cada uno de estos programas y paquetes no tiene nada de especial, solamente es seguir el cuadro de dialogo de instalación, lo que si recomiendo es que el sun_java_wireless_toolkit-2_5 lo instales en su carpeta por defecto.

Desarrollo del ejemplo
La pequeña aplicación se basara en como iniciar una Midlet y de utilizar elementos como imágenes, comandos (botones), listas entre otras, será una aplicación un poco más amplia que el ejemplo típico de ¡hola mundo!
Primero que todo vamos a crear el proyecto:
  • Ejecutamos el IDE de Netbeans.
  • Damos click en el menú File >> New Project
  • Seleccionamos en categorías la de Mobile y tipo de proyecto Mobile Application, y damos clic en Next (Figura 2.)

Figura 2. Selección tipo de proyecto.
  • En el siguiente cuadro de dialogo, colocamos un nombre para la aplicación (yo lo nombre GuiaMovil) y el directorio donde se guardara, como recomendación, es mejor guardar el proyecto en carpetas que no tengan un nombre muy extenso y que el nombre no contenga espacios entre sus letras, y quitamos la selección de la casilla/opción Create Hello MIDlet (Figura 3), y click en Next.

Figura 3. Nombre y directorio de proyecto.
  • Ahora realizaremos la configuración de la aplicación para un dispositivo con ciertas características, y seleccionaremos el emulador, en Emulator Platform seleccionamos el emulador en este caso Sun Java(TM) Wireless Toolkit 2.5 for CLDC, en Device se seleccionamos el tipo de dispositivo, es el dispositivo a emular hay varios que se pueden descargar pero por el momento vasta con el que trae por defecto
Ahora lo importante es la configuración para el dispositivo en donde instalaras la aplicación Device configuration, debes seleccionarlo según el soporte de tu celular si es CLDC 1.0 o CLDC 1.1, también es importante el soporte para la MIDP, estas opciones selecciónalas de acuerdo a la configuración o las características permitidas para tu dispositivo, y clic en Next (Figura 4.).

Figura 4. Emulador y Configuración dispositivo.
  • El siguiente cuadro de dialogo no es por el momento importante, así que solo vamos a dar click en el botón de Finís, y no aparecerá el nombre de nuestro proyecto con un icono que identifica que es una aplicación móvil (Figura 5).

Figura 5.
  • Ahora crearemos una pequeña estructura para el proyecto, nos paramos en el proyecto con el cursor, damos clic derecho, seleccionamos New >> Java Package… (Figura 6), y nombramos el nuevo paquete como control y damos clic en Finís (Figura 7).

Figura 6. Nuevo Paquete.

Figura 7.
  • Realiza los mismos pasos hasta obtener la siguiente estructura de paquetes (Figura 8).

Figura 8. Estructura de paquetes.
Esta estructura es para hacer nuestro trabajo un poco mas organizado, en el paquete de control colocaremos la MIDlet (el alma de la aplicación movil) y clases que manejen cosas genéricas, como conexiones bluetooth o web, manejo de base de datos, etc, en el paquete res almacenaremos recursos de aplicación como iconos, imágenes, alguno que otro archivo de perfiles, sonidos, etc, en el paquete view, guardaremos todas las clase que se desplegaran en pantalla como los Form, List, etc, esta es la estructura que yo utilizo pero si prefieres puedes crear tu propia estructura.
  • Ahora crearemos la MIDlet, nos paramos en el paquete control, presionamos el botón derecho del mouse y seleccionamos New >> MIDlet (Figura 9), la nombramos, yo la llame GuiaMidlet, y damos click en el botón Finísh (Figura 10).

Figura 9. MIDlet

Figura 10. Nombre MIDlet
  • Ahora modifica el código de la MIDlet (GuiaMidlet.java) de esta forma:
package control;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;

public class GuiaMidlet extends MIDlet{
public GuiaMidlet()
{
inicializar();
}

private void inicializar() { }
public void startApp() {
}
public void pauseApp() {
}
public void destroyApp(boolean unconditional) {}

}

Cap anterior: Guía 1 - La primera aplicación (1)
Cap siguiente: Guía 1 - La primera aplicación (3)

Referencias
  • Introduction to Mobility Java Technology.

lunes, 10 de diciembre de 2007

Guía de desarrollo de aplicaciones móviles - J2ME

Guía 1 – La primera aplicación (1)


Guía por: Rubén Dario Orozco
2007
Este es el comienzo de un corto tutorial para desarrollar aplicaciones móviles con J2ME


Que se necesita para entender esta guía:
  • Conocimientos básicos en el lenguaje de programación java y tecnología java.
  • Conocimiento General del IDE NetBeans (opcional)
Descarga el código de la aplicación: GuiaMovil
Hoy en día se ve el auge de los dispositivos móviles, teniendo como actor principal el teléfono celular, que a miles de personas se les ha convertido en un aparato esencial para su vida cotidiana, no solo para comunicarse vía voz, sino para seguir adelantando su trabajo en un ambiente desconectado y lejos de su oficina de trabajo, ahora no solo se conforma con tener el ultimo celular de moda, si no que este debe proporcionarle servicios adicionales como comunicación bluetooth, GPRS, WAP, etc., todo esto para llevar el ritmo de la vida de hoy en la cual, todo tiene que realizarse en el menor tiempo posible.
Por eso hoy, la programación para estos dispositivos móviles (celulares, PDA´s, pocketpc, etc.), se ve como el mercado del futuro, por que las redes de la nueva generación están tendiendo a ser en su totalidad inalámbricas, y estos dispositivos cuenta con lo necesario para conectarse a esta redes, en este articulo realizare una pequeña introducción a la creación de una pequeña aplicación para un dispositivo móvil en especifico un celular que cumpla con ciertos requerimientos.
Pero antes de adentrarnos en código fuente, voy a reseñar algunos conceptos generales.

Plataforma Java 2 (Java 2 Platform)
La plataforma de Java se divide entres partes generales:
  • Java 2, edición estándar (J2SE) es diseñado para computadoras de escritorio. Con frecuencia corre encima de sistemas OS X, Linux, en Solaris, o en Microsoft Windows [2].
  • Java 2, edición empresarial (J2EE) es una plataforma exhaustiva para aplicaciones multiusuario y empresas. Está basado en lo J2SE y adiciona API´s para la programación en el lado del servidor [2].
  • Java 2, Micro edición (J2ME) es un juego de tecnologías y especificaciones desarrollado para dispositivos pequeños como buscapersonas, teléfonos móviles, etc. J2ME usa un subconjunto de componentes de J2SE, como una pequeña máquina virtual y API “reducida” [2], esta división será con la cual desarrollaremos la guía
Acerca de J2ME
J2ME es una plataforma, una colección de tecnologías y especificaciones que son diseñadas para diferente partes del mercado para dispositivos pequeños. J2ME se divide en configuraciones, perfiles, y paquetes opcionales. Las configuraciones son especificaciones que detallan una máquina virtual y un juego de base de API que pueden ser usadas con cierta clase de dispositivos. Una configuración, por ejemplo, puede ser diseñada para dispositivos que tienen menos de 512 KBs de memoria y una conexión de la red. Un perfil se basa en una configuración pero añade API más específicas para hacer un ambiente completo para desarrollar aplicaciones, los perfiles incluyen API´s para el ciclo vital de aplicación, interfaz de usuario, persistente y almacenamiento generalmente. Un paquete opcional suministra la funcionalidad que no puede ser asociada con una configuración específica o perfil, un paquete opcional es la API de Bluetooth (82 de JSR). [2].
El universo de J2ME
J2ME Overview
Figura 1. El Universo de J2ME.
Tomada de [2]
- Introduction to Mobility Java Technology.
Como en la figura 1 indica, J2ME tiene dos ramas principales. La primera está basada en la configuración de dispositivo conectada y limitada (CLDC). Esta configuración es para dispositivos inalámbricos pequeños con conexión de red intermitentes, de la misma manera que un buscapersonas, teléfonos móviles, y asistente personal digital (PDA). El perfil de dispositivo de información de Móvil (Mobile Information Device Profile (MIDP)), que está basado en CLDC [2].
La otra rama del árbol de J2ME está basada en la configuración de dispositivo conectada (CDC). Esta configuración es para dispositivos más grandes (en relación con memoria y poder de procesamiento) [2]
Bueno con esta pequeña introducción a J2ME, comenzaremos con la guía de aplicación móvil para celulares, pero antes quiero hacer una aclaración, en la introducción anterior deje por fuera varios aspectos importantes como las tecnología de red celular (TDMA, CDMA, GSM, PCS, WAP, UMTS) que son necesarias conocer para saber como realizar conexiones y que API´s necesitamos para realizar aplicaciones en estas tecnologías, también hay que tener claro que en el desarrollo de aplicaciones móviles una aplicación no es totalmente portables entre dispositivos diferentes, para una aplicación móvil las empresas desarrolladoras de la aplicación realizan casi una que versión por cada dispositivo que difiere en varias características, a este problema de portabilidad se le llama fragmentación, ahora si comencemos con la guía.
Capitulo siguiente: Guía 1 - La primera aplicación (2)
Referencias
  • Introduction to Mobility Java Technology.

lunes, 3 de diciembre de 2007