Titulo de la entradaTitulo de la entrada

Android: Definiciones Básicas y Desarrollo de Aplicaciones


Tabla de Contenidos


1 - Introducción
1.1 - Versiones (API Levels)
1.1.1 - Root en Android
1.2 - Incidencia en el Mercado
2 - Arquitectura
2.1 - Dalvik Virtual Machine (DVM)
2.2 - Diferencias entre JVM vs DVM
3 - Desarrollo de Aplicaciones para Android en Java
3.1 - Requisitos para Desarrollar desde Eclipse
3.1.1 - Instalación y configuración
3.1.2 - Alternativas de depuración y ejecución
3.1.2.1 - Dispositivo real
3.1.2.2 - Android Virtual Device
3.1.2.3 - Android-x86
3.2 - Requisitos para Desarrollar desde AIDE
3.2.1 - Instalación y configuración de AIDE en un equipo móvil
3.2.2 - Instalación y configuración de AIDE desde PC
4 - Desarrollo de Aplicaciones para Android en C/C++
5 - Ciclo de Vida de Aplicaciones


INFORMACIÓN MundoGP

Hay proyectos que se comienzan sin saber muy bien el rumbo exacto que se tomará, ni el destino que se pretende alcanzar. Proyectos cuyo único impulso es el día a día, sin planes, sin reglas, tan solo con el entusiasmo de seguir adelante, a veces con ganas, a veces sin fuerzas, pero siempre con la intuición de que va a salir bien.
El papel bajo estas líneas es uno de esos proyectos. Nació casi de la casualidad allá por 2006. Hoy, varios años después, sigue más vivo que nunca.
A pesar de llevar metido en el desarrollo para Java y Android casi desde sus inicios, nunca había tratado estos temas, pretendía mantenerme fiel a su temática original: el desarrollo bajo las plataformas Java y .NET. Surgieron en algún momento algunos escarceos con otros lenguajes, pero siempre con un ojo puesto en los dos primeros.


Bases de Datos y conexion con un ListView utilizando vistas personalizadas

“Desarrollo de Aplicaciones Móviles en Android”
Ejercicio Avanzado A: Bases de Datos y conexión con un
ListView utilizando vistas personalizadas



A. Descripción
Con este ejercicio, veremos cómo funcionan las bases de datos SQLite en Android, crearemos una, y la conectaremos con una actividad en forma de ListView muy simple. A continuación, el alumno deberá mejorar la forma en que se visualizan de forma que sea elegante sin que la interfaz de usuario sufra ralentización alguna.


Interfaces Auto-Adaptativas Android

“Desarrollo de Aplicaciones Móviles en Android”
Ejercicio Básico E: Interfaces Auto-Adaptativas



Localización por GPS_A

“Desarrollo de Aplicaciones Móviles en Android”
Ejercicio Intermedio D: Localización por GPS
A.  Descripción

En    este    ejercicio,    introduciremos    cómo   funcionan    los    servicios    de   localización    en Android   y   explicaremos   cómo   conseguir   que   la    API   de   Android   nos   indique   nuestra   posición GPS.  Para   ello   crearemos    una  aplicación muy   sencilla   que  activa   y  desactiva   el  receptor   GPS   del
dispositivo Android, devolviendo la posición al usuario.


Localización por GPS con Mapa_B

“Desarrollo de Aplicaciones Móviles en Android”
Ejercicio Intermedio D: Localización por GPS

A. Descripción
En este ejercicio, introduciremos cómo funcionan los servicios de localización en Android y explicaremos cómo conseguir que la API deAndroid nos indique nuestraposición GPS. Para ello crearemos una aplicación muy sencilla que activa y desactiva el receptor GPS del dispositivo Android, devolviendo la posición al usuario.
En Android, tenemos dos paquetes de servicios relacionados con la geolocalización, el mapa y la posición. Veremos cómo obtener nuestra posición de forma sencilla y rápida.


25_ JAVA_VECTORES

JAVA: VECTORES
Vectores en Java

El manejo de vectores en Java es similar al manejo de vectores en C. Solo hay que tener en cuenta que un vector en Java se tiene primero que declarar, y luego se tiene que construir, ya que los vectores son, al igual que todo en Java, objetos.

Declaración de un vector
Para declarar un vector se seguirá la siguiente sintaxis:

tipodatos  nombrevector[];

-       tipodatos es el tipo de datos de los elementos del vector (int, double, String, etc.)
-       nombrevector es el nombre que tu quieras darle a tu vector.
Por ejemplo, supongamos que queremos crear un vector de enteros llamado v. La declaración será la siguiente:

int v[];

Como puedes ver, en la declaración de un vector no se indica la dimensión, de éste, es decir, el número de elementos que tiene. Esto se hace en la construcción del vector.

Construcción de un vector
Para construir un vector que ya haya sido declarado se sigue la siguiente sintaxis:

nombrevector = new tipodatos[dim];

-       nombrevector  es el nombre del vector a construir.
-       tipodatos  es el tipo de datos del vector.
-       dim  es la dimensión del vector (el número de elementos)

Por ejemplo, si queremos que el vector v declarado antes tenga 10 elementos, tendremos que hacer lo siguiente:

v = int[10];

En el momento de la construcción del vector, podemos usar una variable entera  para asignar el número de elementos que se quiera.
Por ejemplo, en el siguiente caso el número de elementos del vector v viene dado por la variable num:

v = int[num];
Acceso a los elementos de un vector

Una vez declarado el vector y construido, este se puede usar de la misma manera que en C. Se puede acceder a un elemento del vector escribiendo el nombre del vector y entre corchetes el índice del elemento que quieres usar. Recuerda que los índices comienzan a numerarse en 0.

Ejemplo 1:

etiResultado.setText(“El resultado es: “+v[3]);

Aquí se coloca en una etiqueta el valor contenido en el elemento de la posición cuarta del vector v.

Ejemplo 2:

for (i=0;i<10;i++) {
   v[i]=0;
}

Este código recorre un vector de 10 elementos y almacena en dichos 10 elementos un 0.
Una forma rápida de saber la longitud que tiene un vector es usar lo siguiente:

nombrevector.length

Por ejemplo, si el vector se llama v, su longitud (el número de elementos que tiene) sería:

v.length

El siguiente código rellena el vector v con ceros, da igual el número de elementos que tenga:

for (i=0;i<v.length;i++) {
       v[i]=0;

}
Es posible crear un vector e introducir datos directamente en él al mismo tiempo. La forma general de hacerlo sería la siguiente:

tipodatos nombrevector[] = {elemento1, elemento2, elemento3, …, elemento n};

Por ejemplo:

int v[] = {5, 2, 7, 6};

Este código crea un vector con cuatro números enteros: 5, 2, 7, 6.

Ejemplo 2:
                    String dias[] = {“Lunes”, “Martes”,
                   “Miércoles”, “Jueves”, “Viernes”, “Sábado”, “Domingo”};

Este código crea un vector que contiene 7 cadenas, correspondientes a los días de la semana.


VECTORES DE COMPONENTES




24_JAVA_EVENTOS_DESDE_CODIGO_GENERAL

JAVA: EVENTOS DESDE CÓDIGO. IDEAS GENERALES

Eventos desde código. Consideraciones Generales

Se finalizará el estudio de los eventos desde código, planteando de forma general el código necesario para programarlos.

A la hora de programar eventos sobre un componente concreto, será necesario tener en cuenta lo siguiente:

-          Primero hay que enlazar el componente con el oyente o adaptador correspondiente al evento.

-          El oyente o adaptador contendrá aquellos eventos que interesen programar.

-          Cada evento tiene un parámetro asociado con información sobre el evento.

-          Cada evento realiza una llamada a un procedimiento y es en este procedimiento donde se programa la respuesta al evento.

La sintaxis general de programación de eventos es la siguiente:

Componente.MetodoParaAñadirOyente(new TipoOyente() {

       public void evento1(TipoEvento evt) {
             LlamadaAProcedimiento1(evt);
       }

       public void evento2(TipoEvento evt) {
             LlamadaAProcedimiento2(evt);
       }

       ...otros eventos...
});

Para poder programar un evento es necesario conocer lo siguiente:

-          El componente sobre el que se programará.
-          El tipo oyente o adaptador al que pertenece el evento.
-          El método usado para asignar el oyente al componente.
-          El nombre del evento.

-          El tipo de evento para el parámetro.

Ejemplo 1. Eventos del Ratón

Los eventos de ratón son: mouseEntered, mouseExited, mousePressed, mouseReleased, mouseClicked.

Pertenecen al adaptador MouseAdapter.

El adaptador se asigna al componente con el método addMouseListener.

Los métodos llevan como parámetro un objeto del tipo MouseEvent.

Conociendo esto, si queremos programar los eventos del ratón de una etiqueta llamada etiTexto, solo tenemos que hacer lo siguiente:


etiTexto.addMouseListener(new MouseAdapter() {

      public void mouseEntered(MouseEvent evt) {
            etiTextoMouseEntered(evt);
      }

      public void mouseExited(MouseEvent evt) {
            etiTextoMouseExited(evt);
      }

      public void mousePressed(MouseEvent evt) {
            etiTextoMousePressed(evt);
      }

      public void mouseReleased(MouseEvent evt) {
            etiTextoMouseReleased(evt);
      }

      public void mouseClicked(MouseEvent evt) {
            etiTextoMouseClicked(evt);
      }


});

Ejemplo 2. Eventos del teclado

Los eventos de teclado controlan las pulsaciones de tecla. Entre ellos, podemos mencionar a los siguientes:

-          keyPressed, que define la pulsación de una tecla.
-          keyReleased, que define el momento en que se suelta una tecla.
-          keyTyped, que define el pulsar-soltar una tecla.

Los eventos de teclado pertenecen al adaptador KeyAdapter.


23_JAVA_EVENTOS_DESDE_CODIGO_RATON

JAVA: EVENTOS DESDE CÓDIGO. EVENTOS DE RATÓN
Eventos desde código


Se estudió en la hoja de teoría anterior la forma de programar eventos desde código. Concretamente se estudió como programar eventos de acción. En esta hoja se estudiará como programar eventos de ratón.

Los eventos de ratón son los siguientes:

-          mouseEntered
o   Indica que el ratón entró en la superficie del elemento (etiqueta, botón, etc)
-          mouseExited
o   Indica que el ratón salió de la superficie del elemento (etiqueta, botón, etc)
-          mousePressed
o   Indica que un botón del ratón ha sido presionado sobre el elemento.
-          mouseReleased
o   Indica que un botón del ratón ha sido soltado sobre el elemento.
-          mouseClicked
o   Indica que se ha pulsado/soltado un botón del ratón.

Como se dijo en la hoja anterior, todos los eventos pertenecen a un objeto “oyente” o “adaptador”. En este caso concreto, todos los eventos del ratón pertenecen a un objeto “adaptador” llamado MouseAdapter.

Cada uno de los eventos se programará dentro del adaptador MouseAdapter. Cada evento es en realidad un procedimiento que recibe un parámetro con información sobre el evento. Este parámetro, en el caso de los eventos del ratón, es del tipo MouseEvent.

Cada evento a su vez hace una llamada a un procedimiento, y es en este procedimiento donde realmente se programa la respuesta al evento.

Todo esto resulta complicado al principio, pero verás que en realidad siempre es igual. Solo hay que conocer el nombre de cada evento, el adaptador u oyente al que pertenece y el tipo de parámetro que recibe cada evento.

Como enlazar eventos de ratón con un componente

Supongamos que tenemos un componente (botón, etiqueta, etc...) llamado XXX.
Si queremos asociarle eventos de ratón, tendremos que añadir el siguiente código dentro del constructor:

XXX.addMouseListener(new MouseAdapter() {

       public void mouseEntered(MouseEvent evt) {
             XXXMouseEntered(evt);
       }

       public void mouseExited(MouseEvent evt) {
             XXXMouseExited(evt);
       }
       public void mousePressed(MouseEvent evt) {
             XXXMousePressed(evt);
       }

       public void mouseReleased(MouseEvent evt) {
             XXXMouseReleased(evt);
       }

       public void mouseClicked(MouseEvent evt) {
             XXXMouseClicked(evt);
       }


});

Veamos este mismo código comentado:

                                                                                                                     Los eventos de ratón 
Para asignar el adaptador al elemento                                                         pertenecen al adaptador
XXX se usa el método addMouseListener                                                   llamado MouseAdapter

 XXX.addMouseListener(new MouseAdapter() {

public void mouseEntered(MouseEvent evt){         Estos son los eventos de
XXXMouseEntered(evt);                            ratón que pertenecen al
}                                                 adaptador MouseAdapter.

public void mouseExited(MouseEvent evt){          En realidad no hay que
XXXMouseExited(evt);                             ponerlos todos, solo hay
}                                                 que añadir los que necesites.                                                                 
public void mousePressed(MouseEvent evt) {
XXXMousePressed(evt);
}

public void mouseReleased(MouseEvent evt) {
XXXMouseReleased(evt);
}

public void mouseClicked(MouseEvent evt) {
XXXMouseClicked(evt);
}

});

(... Cada evento hace una llamada a un                                   (.. Cada evento recibe como parámetro un
procedimiento, cuyo nombre puede ser                                       objeto del tipo MouseEvent al que por
cualquiera, aunque suele construirse                                           convención se le suele llamar evt.
uniendo el nombre del componente XXX                                    Este objeto suele contener información
junto con el nombre del evento.                                                 sobre la pulsación del ratón (qué botón se
                                                                                                                             ha pulsado, cuantas veces, etc...)    
Es luego en estos procedimientos donde 
se programa la respuesta a cada evento... )

EJERCICIO GUIADO

1. Crea un nuevo proyecto.
2. Accede al código del proyecto.


3. Inserta una llamada dentro del constructor a un procedimiento CreacionVentana de la siguiente forma:
                                                                                               La llamada...
                                                                         Y el procedimiento.

4. La ventana va a contener dos etiquetas, que tendremos que declarar en la zona de variables globales:


5. Ahora vamos a diseñar la ventana. Introduce el siguiente código dentro del procedimiento CreacionVentana:

6. Ejecuta ya el programa para observar el resultado de nuestro diseño. El aspecto debe ser el siguiente:


7. El objetivo del programa es simple. Queremos que al entrar el ratón dentro de la superficie de la etiqueta roja, aparezca un mensaje en la otra etiqueta indicándolo. También queremos que aparezca un mensaje al salir el ratón de la etiqueta. Y también al pulsar un botón del ratón sobre la etiqueta.


22_JAVA:_EVENTOS_DESDE_CODIGO

JAVA: EVENTOS DESDE CÓDIGO

Eventos desde código
La ventana de diseño de NetBeans nos permite crear cada componente, colocarlo en la ventana y acceder a los eventos que necesitemos fácilmente para programar en ellos las acciones que se tengan que realizar.
Sin embargo, si el diseño de la ventana se ha realizado directamente desde código, será necesario crear también desde código los distintos eventos a usar, y asociarlos al componente correspondiente.
Para programar eventos hay que tener en cuenta lo siguiente:
- Un evento pertenece a un objeto “Oyente” (Listener) o a un objeto “Adaptador” (Adapter)
- El objeto oyente/adaptador hay que asociarlo al elemento sobre el que sucede el evento.

Por ejemplo: Programar la pulsación de un botón btnSumar.

La pulsación de un botón es un evento actionPerformed como ya se sabe.
El evento actionPerformed pertenece a un objeto llamado ActionListener. El objeto ActionListener es lo que se denomina un oyente.
El objeto ActionListener se asociará al botón btnSumar

Programación de eventos

La programación de eventos es compleja, ya que cada evento pertenece a un oyente/adaptador, y a su vez, hay que asociar cada oyente/adaptador al componente que responde al evento.

Por otro lado, la sintaxis de programación para los eventos es distinta a lo que se ha visto hasta ahora, por lo que puede resultar bastante oscura, aunque por otro lado, siempre sigue el mismo patrón.

Para simplificar el estudio de la programación de eventos, nos limitaremos a los eventos más usados, los cuales pueden clasificarse en los siguientes grupos:

-          Eventos de Acción:

o   actionPerformed
§  Activar un componente (pulsación de botón, enter en un cuadro de texto)

-          Eventos de Teclado:

o   keyPressed
§  Se pulsó una tecla, pero no se soltó.
o   keyReleased
§  Se soltó una tecla.
o   keyTyped
§  Se pulsó y soltó una tecla.

-          Eventos de Ratón:
o   mousePressed
§  Se pulsó un botón del ratón.
o   mouseReleased
§  Se soltó un botón del ratón.
o   mousePressed
§  Se pulsó y soltó un botón del ratón.
o   mouseEntered
§  El ratón entró en la superficie del control.
o   mouseExited
§  El ratón salió de la superficie del control.

-          Eventos de Ventana:

o   windowOpened
§  Se abrió la ventana
o   windowClosing
§  Se cerró la ventana
o   windowActivated
§  Se activó la ventana
o   windowDeactivated
§  Se desactivó la ventana


En esta explicación guiada nos limitaremos a estudiar los eventos de acción.

PROGRAMACIÓN DE EVENTOS DE ACCIÓN

Un evento de acción hace referencia a la activación de un objeto (un botón, un cuadro de texto, un combo, etc...)
Solo existe un tipo de evento de acción, llamado actionPerformed.
El evento actionPerformed pertenece a un objeto oyente llamado ActionListener.

Eventos de Acción

Eventos


Oyente/Adaptador

 

actionPerformed



Se programan dentro de...


ActionListener

La forma de programar el evento actionPerformed de un componente xxx es la siguiente:

xxx.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent evt) {
          xxxActionPerformed(evt);
     }
});

Para entender la sintaxis de la programación de un evento de acción, supongamos el siguiente ejemplo:
Se quiere programar el evento de un botón llamado btnSumar desde código. He aquí el código para crear el evento:

btnSumar.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent evt) {
          btnSumarActionPerformed(evt);
     }
});

Una explicación del código:

1) El componente cuyo evento   2) El método addActionListener            3) El evento actionPerformed 
se quiere programar. En              permite asignar el oyente al                  pertenece a un objeto oyente
 btnSumar)                                     botón.)                                                    llamado ActionListener.

btnSumar.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent evt) {
          btnSumarActionPerformed(evt);
   
}
});


( Dentro del procedimiento actionPerformed se                      (  El evento actionPerformed, es en
hace una llamada a otro procedimiento. El                                    realidad un procedimiento, que tiene 
nombre de este otro procedimiento puede ser                              como parámetro un objeto del tipo
cualquiera, pero usaremos el nombre del                                      ActionEvent al que llamaremos evt por 
componente seguido de “ActionPerformed”  )                               convención. )

El código anterior permite crear y asignar el evento actionPerformed al botón btnSumar, pero no programa el evento. Para programar el evento es necesario crear el procedimiento cuya llamada se incluye dentro del evento actionPerformed:

public void btnSumarActionPerformed(ActionEvent evt) {
       … aquí se programa el evento actionPerformed del botón btnSumar …

}

A pesar de lo complicado que resulta, hay que tener en cuenta que siempre se programa de la misma forma. Solo hay que cambiar el componente que se quiere programar y asignar un nombre a la función donde se programará el evento.

Hay que tener en cuenta que en el código expuesto antes participan nuevas clases como son ActionEvent y ActionListener, y se tendrán que agregar los import correspondientes.



21_JAVA_DISEÑO_FORMULARIOS_DESDE_CODIGO

JAVA: DISEÑO DE FORMULARIOS DESDE CÓDIGO
La Ventana de Diseño
La ventana de diseño es una gran herramienta que nos permite diseñar formularios de forma relativamente sencilla. Simplemente tenemos que añadir los componentes del formulario: botones, etiquetas, cuadros de textos, etc, y cambiar sus propiedades según nos interese.
Todo esto tiene un código asociado que se genera de forma automática, y del que no nos hemos preocupado hasta el momento.
Por ejemplo, cada vez que añades un botón o una etiqueta, se generan automáticamente las instrucciones de código que permiten crear dicho botón o dicha etiqueta. También se genera el código que permite cambiar el texto del botón, o cambiar el texto de la etiqueta.
Un buen ejercicio para comprobar esto puede ser el siguiente:

Ejercicio guiado 1.

1. Crea un proyecto y añade en su ventana un botón (JButton), una etiqueta (JLabel) y un cuadro de texto (JTextField).
2. El nombre del botón será “btnBoton”, el de la etiqueta “etiEtiqueta” y el del cuadro de texto “txtCuadroTexto”.
3. A continuación asigna un texto a cada elemento. La ventana final podría tener un aspecto como el que sigue:

4. Todas estas operaciones que has realizado tienen asociado unas instrucciones de código que se han generado automáticamente. Para estudiar estas instrucciones, activa el botón Origen en la parte superior de la pantalla:

5. En el código, observarás una línea llamada Código Generado. Esta línea está señalada en color azul (al igual que todas las instrucciones generadas automáticamente) Observarás que tiene un + en la parte izquierda. Si haces clic sobre el signo + aparecerá el código generado automáticamente:

                                   Haz clic en el + para ver el código generado.




20_JAVA_DIALOGOS

JAVA: DIÁLOGOS
Cuadros de Diálogo
Un cuadro de diálogo es un cuadro con opciones que aparece normalmente cuando se activa una opción del menú principal del programa.
Los cuadros de diálogo tienen forma de ventana aunque no poseen algunas características de estas. Por ejemplo, no pueden ser minimizados ni maximizados.
Los cuadros de diálogo, aparte de las opciones que muestran, suelen contener dos botones típicos: el botón Aceptar y el botón Cancelar. El primero de ellos da por válidas las opciones elegidas y cierra el cuadro de diálogo. El segundo simplemente cierra el cuadro de diálogo sin hacer ninguna modificación.
He aquí algunos ejemplos de cuadros de diálogo del programa Word:




Para crear cuadros de diálogo en Java, se usa un tipo de objetos llamado JDialog. Estos objetos pueden ser diseñados como si fueran ventanas, aunque representan realmente cuadros de diálogo.



19_JAVA_LAYOUTS_Y_PANELES

LAYOUTS Y PANELES

Técnicas de distribución de elementos en las ventanas
A la hora de diseñar una ventana se tienen en cuenta dos cosas:
- La facilidad a la hora de colocar muchos componentes en la ventana.
- Que dichos componentes estén siempre visibles independientemente del tamaño de la ventana.
La distribución AbsoluteLayout por ejemplo nos da mucha facilidad a la hora de colocar los elementos en la ventana, pero sin embargo los componentes no se adaptan a los cambios de tamaño.
El Diseño Libre en cambio permite crear ventanas en las que sus componentes se “recolocan” según el tamaño de estas pero a cambio crece la dificultad del diseño.
Para aprovechar las ventajas de los distintos layouts y minimizar sus inconvenientes, es habitual en java crear una estructura de paneles cada uno de ellos con un layout distinto, según nuestras necesidades.
Normalmente, al JFrame se le asigna un layout que lo divida en zonas, como puede ser el BorderLayout o el GridLayout. Luego, dentro de cada una de estas zonas se introduce un panel (objeto JPanel). Y a cada uno de estos paneles se le asigna el layout que más le convenga al programador (FlowLayout, Diseño Libre, AbsoluteLayout, etc…) Finalmente, dentro de cada panel se añaden los componentes de la ventana.

 JFrame
(BorderLayout o GridLayout
                                                                                                                                     etc…

                     JPanel 1(Diseño Libre,                                                        JPanel 2(Diseño Libre, 
                            AbsoluteLayout o FlowLayout)                                            AbsoluteLayout o FlowLayout  
                     Componentes                                                                         Componentes            
                                                                                                                              
Ejercicio guiado


1. Crea un nuevo proyecto en java.
Se pretende crear un proyecto con una ventana de diseño complejo. Para ello sigue los siguiente pasos:
2. En primer lugar, asigna un BorderLayout al JFrame:


3. El BorderLayout divide la ventana principal en zonas. Ahora añade un panel (JPanel) a la zona norte de la ventana.                                                                                                              
                                                                                                           Panel en la zona norte.

4. Cambia el nombre a este panel y llámalo panelTitulo, ya que contendrá el nombre del programa.


5. Añade otro panel, esta vez a la parte central. El panel se llamará panelDatos: