BÚSCAME EN: Last FM Filmaffinity Facebook Youtuve Blogger Twitter Feed Instagram
Puedes acceder a este blog mediante las direcciones www.ignacionario.com o ignacionario.blogspot.com. También puedes contactar a través de la dirección de correo electrónico contacto@ignacionario.com.
Mostrando entradas con la etiqueta Desarrollo. Mostrar todas las entradas
Mostrando entradas con la etiqueta Desarrollo. Mostrar todas las entradas

4 de julio de 2011

Android (VI): Creación de gráficas estadísticas con Android Plot

Android (VI): Creación de gráficas estadísticas con Android Plot


¡Dos meses después de publicar el último tutorial vuelvo a la carga con un nuevo capítulo de esta emocionante aventura de ayudas para programar en Android! Desde que publiqué mi aplicación Train Yourself en el market de Android - enlace al market - , hace casi un mes (y hoy precisamente puedo decir muy contento que he superado las 1000 descargas) me han preguntado ya varias personas sobre cómo hice las gráficas estadísticas en la aplicación y todas ellas les dirigí a una página bastante completa y a la vez sencilla: Android Plot, y ahora intentaré hacer un breve resumen sobre cómo se usan.


Con Android Plot en concreto puedes realizar montones de gráficas distintas, pero aquí sólo me encargaré de indicaros brevemente cómo utilizarla para hacer tareas simples, ya que yo personalmente no he necesitado nada más.


1. Instalación de la librería en el proyecto
Una vez descargadas las librerías, debemos incluirlas en la carpeta LIB del proyecto, que es la que contiene las librerías externas al SDK de Android. Si la carpeta no existe podemos crearla sin ningún problema. Una vez añadidos los archivos, refrescamos la carpeta raíz del proyecto para que sean visibles desde Eclipse, y entonces debemos indicar que dichos archivos son librerías que deben usarse con el proyecto: Hacemos clic derecho a cada una de ellas y las importamos tal y como se muestra en la imagen.

Android (VI): Agregando las librerías al proyecto en Eclipse

2. Incluir el elemento (view) de la gráfica estadística en el layout en el que queremos mostrarla

Una vez añadida la librería ya podemos hacer uso de sus elementos sin que no de fallos el compilador. El siguiente paso es añadir al layout que deseemos el elemento VIEW llamado com.androidplot.xy.XYPlot correspondiente a la gráfica, que será el que se mostrará en pantalla. Se pueden añadir junto a él otros elementos como botones o algún TextView que se usen a modo de título.


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
 
    <com.androidplot.xy.XYPlot
    android:id="@+id/mySimpleXYPlot"
    android:layout_width="fill_parent"
    android:layout_height="100px"
    android:layout_marginTop="10px"
    android:layout_marginLeft="10px"
    android:layout_marginRight="10px"
    title="A Simple XYPlot Example"/>
</LinearLayout

3. Introducir los datos desde el Activity que usa el layout 
Por último, una vez añadida la gráfica a la vista de diseño sólo nos quedaría indicarle qué datos se quieren mostrar. El código que se muestra a continuación (copiado literalmente desde la página original y comentado en español) nos muestra cómo indicar a la gráfica qué datos tiene que mostrar.

package com.example;
 
import android.app.Activity;
import android.graphics.Color;
import android.os.Bundle;
import com.androidplot.xy.SimpleXYSeries;
import com.androidplot.series.XYSeries;
import com.androidplot.xy.*;
 
import java.text.DecimalFormat;
import java.util.Arrays;
 
public class MyActivity extends Activity
{
 
    private XYPlot mySimpleXYPlot;
 
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
 
        // Inicializamos el objeto XYPlot búscandolo desde el layout:
        mySimpleXYPlot = (XYPlot) findViewById(R.id.mySimpleXYPlot);
 
        // Creamos dos arrays de prueba. En el caso real debemos reemplazar
        // estos datos por los que realmente queremos mostrar
        Number[] series1Numbers = {1, 8, 5, 2, 7, 4};
        Number[] series2Numbers = {4, 6, 3, 8, 2, 10};
 
        // Añadimos Línea Número UNO:
        XYSeries series1 = new SimpleXYSeries(
                Arrays.asList(series1Numbers),  // Array de datos
                SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, // Sólo valores verticales
                "Series1"); // Nombre de la primera serie
 
        // Repetimos para la segunda serie
        XYSeries series2 = new SimpleXYSeries(Arrays.asList(series2Numbers
), SimpleXYSeries.ArrayFormat.Y_VALS_ONLY, "Series2");
 
        // Modificamos los colores de la primera serie
        LineAndPointFormatter series1Format = new LineAndPointFormatter(
                Color.rgb(0, 200, 0),                   // Color de la línea
                Color.rgb(0, 100, 0),                   // Color del punto
                Color.rgb(150, 190, 150));              // Relleno
 
        // Una vez definida la serie (datos y estilo), la añadimos al panel
        mySimpleXYPlot.addSeries(series1, series1Format);
 
        // Repetimos para la segunda serie
        mySimpleXYPlot.addSeries(series2, new LineAndPointFormatter
(Color.rgb(0, 0, 200), Color.rgb(0, 0, 100), Color.rgb(150, 150, 190)));
 
    }
}
Una vez terminado de añadir todo el código, sólo nos queda ejecutar nuestra aplicación y comprobar el resultado.

Android (VI): Resultado visible de la gráfica estadística


SIGUE LEYENDO

6 de junio de 2011

Train Yourself: Mi primera aplicación Android


¡Hola a todos! Llevaba bastante tiempo sin postear nada por aquí, y es porque he estado bastante liado terminando de desarrollar una primera versión estable del proyecto fin de curso del curso que acabo de terminar: Desarrollo de Aplicaciones y Servicios sobre Dispositivos Móviles.

Pues bien, la aplicación en cuestión se llama Train Yourself. Es una aplicación desarrollada específicamente para dispositivos móviles con sistema operativo Android que tengan al menos la versión 1.6 del sistema.

El objetivo de la aplicación es que llevemos un seguimiento constante y detallado de todos los ejercicios que realizamos en el gimnasio llevando una rutina de trabajo. Pero sobre todo, lo más importante es que ese control nos ayude a mejorar nuestras marcas semana tras semanas, y que ese resultado podamos palparlo con el paso del tiempo.

Con Train Yourself podemos crear nuestros propios ejercicios y rutinas, personalizándolo a nuestro objetivo final y adaptando los ejercicios que hacer en el número de días que consideremos necesario.
El logo de Train Yourself hace alusión a una persona levantando pesas, formando con su movimiento una “T” y una “Y”, que a su vez hacen referencia a las primeras letras de cada palabra del nombre de la aplicación.

Podéis ver más información en el siguiente blog promocional: http://trainyourselfapp.blogspot.com/

La aplicación estará disponible en el market de Android en unos días, y será totalmente gratuita para quien quiera probarla.


Algunas capturas de pantalla de la aplicación::

Train Yourself: Pantalla principal
Pantalla Principal

Train Yourself: Gráfica de avances
Gráfica de avances

Train Yourself: Estadísticas
Estadísticas

Train Yourself: Valoración semanal
Valoración Semanal

Train Yourself: Guardar ejercicio
Registrando Ejercicios


PD: Tanto el logo como la mascota de la aplicación han sido creados por Sonia Espada García, podéis visitar su blog (enlace), os recomiendo que le hechéis un vistazo.

SIGUE LEYENDO

22 de abril de 2011

Android (V): Crear opciones de menú

Android: Desarrollo de opciones de menú en layouts (Activity)

¡Ya iba tocando dejar por aquí un nuevo post sobre desarrollo en Android!, esta vez voy a intentar explicar algo bastante sencillo pero al mismo tiempo muy útil y versátil en las aplicaciones: las opciones de menú dentro de cada pantalla, donde normalmente añadimos las pequeñas funcionalidades que no tienen que mostrarse siempre en pantalla pero que de vez en cuando usamos, lo explicaré en 4 sencillos pasos:

  • Crear imágenes de icono (opcional)
  • Crear elemento XML con las diferentes opciones de menú
  • Añadir opciones al Activity deseado
  • Añadir funcionalidad a cada una de las opciones de menú

1. Crear los iconos para cada opción de menú (opcional)

Si queremos que el tamaño de la imagen cambie según la resolución del dispositivo que ejecuta la aplicación deberemos generar distintos tamaños de cada imagen. En general las aplicaciones suelen tener imágenes para tres resoluciones como mínimo: HDPI (alta), MDPI (media) y LDPI (baja), a continuación os dejo una relación de las distintas resoluciones existentes para aplicaciones android. Debemos tener cada imagen para cada resolución dentro de la carpeta correspondiente en res: drawable-hdpi, drawable-mdpi o drawable-ldpi.

Android: Diferentes carpetas de imagenes según la resolución
Dando soporte a distintas resoluciones de pantalla (clic aquí para más info)

2. Crear elemento XML que contiene las diferentes opciones de menú

El siguiente paso necesario es definir un medio desde el cual leamos las opciones de menú. Puede configurarse desde una base de datos, desde el propio código o (la parte más sencilla a mi parecer) desde un fichero XML dentro de la carpeta menu, en res.

Como costumbre, suelo nombrar a los ficheros XML que forman parte de un menú con el mismo nombre que el layout al que van a pertenecer y así tener mejor organizados los ficheros a la hora de reconocerlos, esto es muy aconsejable sobre todo si la aplicación va a tener una estructura de ficheros bastante amplias. Como en este caso el menú va a ir asociado al layout home, lo he nombrado home_menu.xml.
Android: Desarrollo de opciones de menú en layouts (Activity) - Estructura de carpetas
Estructura de ficheros del proyecto
El contenido de home_menu.xml tiene la siguiente estructura:


<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
      <item
            android:id="@+id/btConfig"
            android:title="Configuración"
            android:icon="@drawable/config">
      </item>
      <item
            android:id="@+id/btInfo"
            android:title="Acerca de"
            android:icon="@drawable/info">
      </item>
</menu>


3. Añadir las opciones de menú dentro del Activity deseado

Este paso es bastante sencillo, sólo debemos sobreescribir el método onCreateOptionsMenu dentro del Activity que implemente el menú e indicarle el documento XML que contiene dichas opciones.

// Añadiendo las opciones de menú
      @Override
      public boolean onCreateOptionsMenu(Menu menu) {
          MenuInflater inflater = getMenuInflater();
          inflater.inflate(R.menu.home_menu, menu);
          return true;
      }

Android: Desarrollo de opciones de menú en layouts (Activity) - Resultado final
Vista final de la pantalla cuando se pulsa el botón MENÚ

4. Dando funcionalidad a cada una de las opciones de menú

El código que muestra a continuación muestra un mensaje de texto diferente según que opción se pulsa, se deberá cambiar el contenido de cada case según la funcionalidad que queremos dar a la aplicación: Acceder a la base de datos para modificar algún registro, cambiar de Activity, etc.

// Añadiendo funcionalidad a las opciones de menú
@Override
public boolean onOptionsItemSelected(MenuItem item) {
   switch (item.getItemId()) {
        case R.id.btConfig:
           Toast.makeText(getApplicationContext(), "Has pulsado Config", 
                 Toast.LENGTH_SHORT).show();
           return true;
        case R.id.btInfo:
           Toast.makeText(getApplicationContext(), "Has pulsado la opción 
                 Info", Toast.LENGTH_SHORT).show();
           return true;
        default:
           return super.onOptionsItemSelected(item);
    }
}


SIGUE LEYENDO

10 de marzo de 2011

Android (IV): Diseño de layouts o interfaces

Diseño de interfaces (layouts) con Android
Personalización de nuestros layouts o interfaces

Bienvenidos a uno más de los experimentos que poco a poco voy realizando en el aprendizaje de mi curso de desarrollo en Android. En este cuarto post voy a intentar explicar algunas de las propiedades y "truquillos" que he aprendido a la hora de realizar el diseño de la aplicación a mi gusto.

Supongo que todos sabremos (tanto desarrolladores como usuarios) que uno de los puntos claves de una buena aplicación es un buen diseño. Por eso, una vez sabemos qué debe aparecer en cada pantalla o página web el siguiente paso es cómo mostrar esa información para que aparezca de la mejor manera tanto en lo visual como en lo práctico.

A continuación haré un repaso de todas las modificaciones que he realizado en la interfaz de la pantalla principal de mi aplicación para cambiar el diseño que aparece por defecto al diseño que he querido enfocar.
Como ejemplo, vamos a diseñar una pantalla en la que mostraremos el título de la aplicación, un mensaje de bienvenida, cuatro botones que nos darán acceso a diferentes partes del programa y un pie en el que indicaremos información correspondiente a la aplicación, ya sea la versión de la aplicación, el autor, empresa, derechos, año de publicación, etc.

Diseño de interfaces (layouts) con Android
Cambios de aspecto de una vista con los mismos elementos


1. Creación del archivo XML que define el Layout o interfaz
Todos los archivos que definen la interfaz se encuentran en una carpeta llamada "layout" dentro de la carpeta "res" perteneciente al proyecto de Android. Si no tenemos creado ningúin layout o deseamos crear el diseño en un nuevo archivo, dentro de la propia carpeta "layout" hacemos clic derecho y pulsamos "New" - "Other" - "Android XML File". Nos aparecerá una pantalla en la que debemos indicar el tipo de archivo que crearemos y el nombre del mismo. Podemos dejar la opción por defecto "LinearLayout" e indicar el nombre de archivo que nos apetezca.

IMPORTANTE: Debemos indicar la extensión ".xml" en el nombre de nuestro Layout para poder crear el archivo. NUNCA deben crearse los archivos con lestras en Mayúscula, si se desea diferenciar dos palabras debemos usar el guión bajo ( _ ).


2. Insertar los elementos en nuestro layout.xml
En primer lugar debemos insertar los elementos citados anteriormente, que serán los que aparecerán en la pantalla:

  • Título de la aplicación: TextView
  • Mensaje de bienvenida: TextView
  • Botón "Nuevo Evento": Button
  • Botón "Calendario": Button
  • Botón "Contactos": Button
  • Botón "Opciones": Button
  • Pie de pantalla 1: TextView
  • Pie de pantalla 2: TextView

Por defecto, los elementos en nuestra interfaz los definimos dentro de un LinearLayout, que es un tipo de estructura que define cómo se ordenan los elementos que contiene en su interior, en el siguiente apartado de este post se explicará de forma más detallada.
Todos los elementos deben formar una estructura en XML, y se suelen crear con las siguientes propiedades:

  • Todas las propiedades se indican como android:nombre_propiedad="contenido_propiedad"
  • ID: Nombre de la variable asociada al elemento que estamos creando
  • layout_width: Ancho máximo ocupado por el elemento. "fill_parent" hace referencia a que el ancho máximo será lo ocupado por el padre (en este caso el LinearLayout que engloba a todos los elementos)
  • layout_height: Altura máxima. "wrap_content" indica que el elemento puede ocupar el espacio que necesite para mostrarse, por lo que su altura variará según el tamaño de la letra, tipo de elemento, etc.
  • text: Texto que se mostrara en pantalla para dicho elemento. En un botón, hace referencia al nombre representativo del botón.

<TextView  
android:id="@+id/txBienvenida"
android:layout_width="fill_parent" 
android:layout_height="wrap_content" 
android:text="AGENDA Y CONTACTOS"
/>


3. Acoplar los elementos en diferentes estructuras
Una vez tenemos todos los elementos en la pantalla toca estructurarlos en diferentes zonas. Para cada zona utilizaremos un a estructura diferente que afecte a un conjunto de elementos. Según cómo queramos mostrar los elementos podemos agrupar las vistas de diferentes elementos: De forma linear (LinearLayout), como una tabla (TableLayout), etc.


La estructura de elementos quedaría de la siguiente manera
  • LinearLayout principal, que comprende toda la pantalla
    • LinearLayout - Cabecera
      • TextView - Título
      • TextView - Mensaje de bienvenida
    • TableLayout - Estructura de botones
      • Fila 1
        • Button - Nuevo Evento
        • Button - Calendario
      • Fila 2
        • Button - Contactos
        • Button - Opciones
    • LinearLayout
      • TextView - Mensaje de pie de página


Diseño de interfaces (layouts) con Android
En la pantalla de ejemplo tenemos tres zonas diferenciadas:

  • Cabecera: La cabecera contiene el título de la pantalla y un mensaje de bienvenida. Estos dos elementos se definirán dentro de un LinearLayout que ordene los elementos verticalmente (de arriba hacia abajo).
  • Conjunto de botones: Los botones quedan estructurados como una tabla (TableLayout) con cuatro elementos (dos filas y dos columnas), en cada uno de los elementos de la tabla añadimos el botón correspondiente.
  • Pié de página: Al igual que la cabecera, se usará un LinearLayout que contenga los elementos en orden vertical, ocupando el espacio restante.




4. Pulir los detalles
Ya definida la estructura, el resto de tareas pendientes son definir correctamente las propiedades de los elementos para aparezcan en pantalla de la forma que queremos, empezando por el tamaño de las imágenes, el color del fondo, las imágenes que queremos añadir al botón o el tamaño de cada estructura en la pantalla. A continuación indicare varias propiedades que he usado en cada uno de los elementos, para ver todo al detalle puedes descargarte el proyecto completo.


    <LinearLayout 
   android:orientation="vertical"
   android:layout_width="fill_parent"
   android:layout_height="fill_parent"
   android:layout_weight="2"
   android:gravity="center"
    >    
            (Aquí especificamos el contenido del LinearLayout)
    
    </LinearLayout>


  • layout_weight: Esta propiedad es fundamental para la estructura que queremos diseñar. Hace referencia al peso que tiene el elemento sobre el resto, dentro de la misma pantalla. Cuanto mayor sea el peso, menor será su proporción de tamaño en la pantalla. Por ello, a la zona más importante (en este caso la tabla de botones), le pondremos peso 1 y a la cabecera le pondremos peso 2. Esto quiere decir que el espacio ocupado por la estructura de tipo tabla ocupará el doble de espacio que la cabecera. Si pusieramos relación 1-3, el tamaño de la estructura con peso 1 sería 3 veces mayor que el tamaño de la estructura con peso 3.
  • gravity="center": Los elementos que forman parte de la estructura se alinean al centro de la pantalla.
  • padding="20px": El elemento con dicha propiedad tendrá un margen del tamaño de los píxeles establecidos con todo lo que le rodea. Existen las variantes PaddingTop, PaddingLeft, PaddingButtom y PaddingRight.

Descarga el código Android

Descarga el código del proyecto de prueba:

Accede a Windows Skyline para descargar el archivo





SIGUE LEYENDO

3 de febrero de 2011

Android (III): Transferencia de datos entre dos Activity

Android (III): Transferencia de datos entre dos Activity
Con un poquito de tiempo, aprender Android es sólo cosa de niños

Si por casualidad habéis seguido mis dos anteriores post sobre Android, os habréis dado cuenta que teniendo unos conocimientos mínimos resulta bastante sencillo empezar a desarrollar con eclipse. En esta ocasión voy a intentar contar los pasos necesarios para enviar datos desde una pantalla (Activity) a otra.

  1. Definir y crear los elementos de la interfaz que usaremos para trabajar los datos en cada pantalla
  2. Crear una clase Activity por cada pantalla y asociar las interfaces creadas
  3. Enviar la información entre los dos Activity
  4. Recibir y tratar la información enviada


DEFINIR LA INTERFAZ

Interfaz del Activity que envía los datos: Caja de texto editable y un botón para realizar el envío.
<EditText
android:id="@+id/etInfo"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_weight="5"
android:numeric="decimal"
/>

<Button
android:id="@+id/btEnviarDatos"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="+"
android:layout_weight="1"
/>

Interfaz del Activity que recibe los datos: Etiqueta de texto (sólo lectura) en la que ponemos la información.
<textview
android:id="@+id/txInfoRecibida"
android:layout_height="wrap_content"
android:layout_width="fill_parent"
android:textsize="25sp"
android:textstyle="bold"
android:gravity="center"
>


CREAR LAS CLASES ACTIVITY'S

La primera de las clases normalmente viene creada al inicio del proyecto. Para añadir una nueva clase nos vamos a la carpeta en la que queremos crear el archivo (dentro de eclipse) y entre las propiedades escogemos "New" --> "Class. Indicamos el nombre de la clase y el padre (superclass), que en este caso debe ser la clase Activity.


IMPORTANTE: Cada vez que añadamos un Activity debemos indicarlo en el archivo AndroidManifiest.xml. Si intentamos ejecutar una pantalla que no hallamos notificado se lanzará un error y la aplicación se cerrará. 
Una vez abierto el archivo, nos aparecerán varias pestañas en la parte inferior de la pantalla: dentro de la pestaña Aplication pulsamos "Add" y añadimos un elemento del tipo "Activity". Dentro de las propiedades de este elemento se encuentra la opción "Name", en la que debemos indicar el nombre del Activity recién creado.

Android (III): Transferencia de datos entre dos Activity
Configuracion de nuevos Activity en el archivo androidManifiest.xml


ENVIAR DATOS
// Definimos las variables EdidText (caja de texto) y Button (Botón), recuperando el
// elemento a partir del ID que se genera cuando lo añadimos al layout usado para esta pantalla.
EditText edInfo= (EditText) findViewById(R.id.etInfo);
Button btEnviarDatos= (Button) findViewById(R.id.btEnviarDatos);
btEnviarDatos.setOnClickListener(new Button.OnClickListener() {

@Override
public void onItemClick(AdapterView parent, View view, int position, long id) {
// Se llama a este método cuando pulsamos el boton btEnviarDatos
String cadenaTexto= edInfo.getText();
Intent intent = new Intent(ActivityPrincipal.this, ActivitySecundaria.class);
intent.putExtra("Datos", cadenaTexto);
intent.putExtra("Longitud", cadenaTexto.length());
// Llamamos al Activity con nombre ActivitySecundaria pasandole la cadena como parametro startActivity(intent);
}
});


RECIBIR DATOS
Bundle extras = getIntent().getExtras();
if(extras!=null){
    String cadenaRecibida = extras.getString("Datos");
    int logitudCadena = extras.getInt("Longitud");
}


OTRAS ENTRADAS SOBRE ANDROID EN ESTE BLOG

SIGUE LEYENDO

9 de enero de 2011

Android (II): Creando el primer proyecto

Creación de un nuevo proyecto Android

Hace ya bastante que escribí una entrada sobre la instalación del entorno de desarrollo de Android, he tardado en continuar con las explicaciones pero bueno, más vale tarde que nunca.

A continuación explicaré una breve introducción sobre las siguientes cuestiones básicas a la hora de programar en Android, que son las siguientes:


Crear un nuevo proyecto
Estructura de carpetas
Uso de Layouts
Código de prueba







CREACIÓN DEL PROYECTO
Para crear un nuevo proyecto, nos vamos a eclipse y en File à Newà Proyect àAndroid Proyect especificamos las siguientes propiedades del proyecto:

Project Name: Nombre del proyecto. El nombre de la carpeta coincidirá por defecto con el nombre del proyecto.
Build Target: Aquí indicamos la versión a la que estará orientada la aplicación de Android. En aconsejable elegir la versión teniendo en cuenta las versiones predominantes en el mercado. Si elegimos la última versión podremos dar mas funcionalidad y mejoras a la aplicación pero podrá ejecutarla menos gente en sus terminales, ya que no todo el mundo tiene su móvil actualizado a la última versión.
Aplication Name: Tal y como dice el nombre de la propiedad, pues el nombre que queramos darle a la aplicación.
Package Name: Nombre del paquete al que pertenecerá la aplicación. Se podría decir que un package es un ámbito de funcionalidad al que puede acceder una aplicación. Si quieres utilizar algún código perteneciente a un paquete deberás importarlo primero a tu archivo de código. En necesario que el nombre tenga al menos dos identificadores, separados por un punto. Normalmente se les suele llamar por el nombre de la empresa o del cliente seguido por el nombre del proyecto. En mi caso los llamo "iio.nombreProyecto", donde "iio" son mis iniciales y sobre "nombreProyecto" sobras las explicaciones.
Create Activity: No es un campo obligatorio y se puede desactivar. En caso de activarlo, se creará el proyecto con una Activity Inicial. Cada Activity corresponde a una pantalla de la aplicación en la que podremos ir añadiendo Views tales como botones, imágenes, textos o campos editables por el usuario.
Min SDK Version: Este campo tampoco es obligatorio, e indica que versión mínima de Android será necesaria para poder ejecutar la aplicación. Es aconsejable indicar la mísma versión que indicamos en el "Build Target". Hay que tener en cuenta que cada versión lleva un identificador asociado, que será el número que haya que poner. Dicho identificador es el número correspondiente a la columna "API Level" que aparece en la selección de versión de Android en la propiedad Build Target. Por ejemplo: A la versión 1.6 de Android le corresponde el número 4.


ESTRUCTURA DE CARPETAS DEL PROYECTO
Una vez creado el proyecto se generará una estructura de carpetas, de las que comentaré qué archivos son los más importantes y debemos tener más en cuenta, sobre todo en las primeras pruebas, ya que serán los únicos que usaremos.
  • En la carpeta src están todos los archivos de código fuente de Java que han sido generados a lo largo del proyecto. Todos los Activity (pantallas de la aplicación) se encontrarán en esta carpeta.
  • En la carpeta gen podremos encontrar todos los archivos que se generan de forma automática, por lo que en principio no debemos tocar nada de ahí. El más importante de todos los archivos el el R.java, donde se crearán de forma automática todos los identificadores de los elementos que tengamos en cada pantalla.
  • Android.jar contiene todas las librerías que se incluyen en la instalación del entorno de desarrollo, gracias a las cuales podemos crear una aplicación específica de Android.
  • Dentro de la carpeta res están todos los archivos que se crean en formato xml. Especialmente usaremos la carpeta layout, donde debemos declarar y diseñar qué elementos se encuentran en cada pantalla y cómo lo vamos a mostrar.
  • AndroidManifest.xml contiene toda la información de implementación del proyecto: Los Activity existentes (cada vez que creemos uno nuevo debemos añadirlo aquí), los permisos de acceso a ciertas funcionalidades como realizar llamadas o conectarse a Internet, etc.


USO DE LAYOUTS
Más adelante explicaré un poco más detenidamente el uso y flexibilidad que se puede conseguir a la hora de crear interfaces, pero de momento empezaremos con algo básico. Básicamente, debemos ir añadiendo elementos uno detrás de otro en forma de árbol.

Hay dos tipos de elementos:
  • Contenedores: No son elementos visibles pero se usan para estructurar la estructura del Activity. Los más básicos son LinearLayout, que inserta los elementos en forma linear según su horientación (Hortizontal o Vertical), y TableLayout, que muestra los elementos como una tabla.
  • Elementos:  Son los componentes visibles del Activity y normalmente se alojan dentro de un contenedor. Los más básicos son TextView (Texto), Button (Botón) y EditText (Texto Editable).
A continuación añado un pequeño ejemplo de cómo quedaría un archivo xml de una Activity con un campo de texto, otro texto editable y un botón:

       <?xml version="1.0" encoding="utf-8"?>
       <LinearLayout 
        xmlns:android="http://schemas.android.com/apk/res/android"
           android:orientation="vertical"
           android:layout_width="fill_parent"
           android:layout_height="fill_parent"
       >
           <TextView  
            android:layout_width="fill_parent" 
            android:layout_height="wrap_content" 
            android:text="Mi primera aplicación Android"
           />
           <EditText
            android:id="@+id/txTextoEditable"
            android:layout_width="fill_parent" 
            android:layout_height="wrap_content" 
           />
           <Button
            android:id="@+id/btNombreBoton"
            android:layout_width="fill_parent" 
            android:layout_height="wrap_content" 
            android:text="Nombre del botón"
           /> 
   
       </LinearLayout>



LAS PRIMERAS LÍNEAS DE CÓDIGO
Como primer ejemplo para aprender a entender la filosofía de programación con Android lo hice copiando basándome en el libro "Android: Guía para desarrolladores", de Anaya. Está en español y vale unos 33 euros.
El ejemplo en sí es bastante sencillo: Una aplicación de una sola pantalla que calcula cuánta propina se debería dar en base al precio que indiques. A continuación os dejo un enlace al proyecto completo, para que lo tengáis para probarlo en vivo y en directo.

El resultado es bastante simple y queda de la siguiente manera una vez ejecutado en el emulador:.

Primera creación Android


Descarga el código Android

Descarga el código del proyecto de prueba:

Accede a Windows Skyline para descargar el archivo




OTRAS ENTRADAS SOBRE ANDROID EN ESTE BLOG

SIGUE LEYENDO
Related Posts Plugin for WordPress, Blogger...