17 - Layout (TableLayout)

El Layout de tipo TableLayout agrupa componentes en filas y columnas. Un TableLayout contiene un conjunto de componentes de tipo TableRow que es el que agrupa componentes visuales por cada fila (cada fila puede tener distinta cantidad de componentes visuales) Cuando disponemos un control de Layouts de tipo TableLayout automticamente crea cuatro componentes de tipo TableRow que los podemos ver en la ventana "Outline". Podemos borrar o agregar componentes de tipo TableRow segn las necesidades de nuestro TableLayout:

Luego de borrar un control de tipo TableRow y agregar componentes de tipo Button la interfaz visual queda como sigue (muchas veces es ms fcil agregar los controles visuales en la ventana Outline para disponerlos dentro de cada tableRow):

Otra propiedad que nos puede ser til inicializar en los controles que se disponen dentro de un TableLayout es layout_span. Esta propiedad permite que un control se expanda ms de una celda. En el siguiente ejemplo el objeto de la clase Button de la segunda fila hemos dispuesto la propiedad layout_span con el valor 2:

Si la propiedad no aparece en la ventana "Properties" cuando seleccionamos el objeto debemos entrar al archivo XML y agregar manualmente dicha propiedad:

18 - Layout (RelativeLayout)
El layout RelativeLayout es el que dispone el ADT por defecto cuando creamos un proyecto en Android. Hay varias posibilidades cuando empleamos el RelativeLayout. Primero podemos alinear un control con respecto al Layout que lo contiene. Para probarlo dispondremos un botn en cada vrtice y veremos que propiedades son afectadas e inicializadas:

Como podemos ver cada control que agregamos se inicializan alguna de las propiedades:
alignParentLeft alignParentRight alignParentTop alignParentBottom centerHorizontal centerVertical centerInParent

Con este tipo de layout podemos disponer un control en forma relativa a otro control que haya dentro del RelativeLayout. Veamos un ejemplo:

En este ejemplo hemos dispuesto el segundo botn debajo (below) del botn 1 y alineado a la izquierda (luego si desplazamos el botn 1 se desplazar el botn 2) La posicin relativa con respecto a otro control puede ser:
above (por encima) below (debajo) toLeftOf (a la izquierda de) toRightOf (a la derecha)

19 - Layout (FrameLayout)
El control de tipo FrameLayout dispone dentro del contenedor todos los controles visuales alineados al vrtice superior izquierdo. Es decir si disponemos dos o ms controles los mismos se apilan.

Por ejemplo si disponemos dentro de un FrameLayout un ImageView y un Button luego el botn se superpone a la imagen:

Otra aplicacin del control FrameLayout es disponer una serie de controles visuales no visibles e ir alternando cual se hace visible.

Problema:

Disponer un ImageView y un Button dentro de un layout FrameLayout. Cuando se inicia la aplicacin mostrar solo el botn y al ser presionado ocultar el botn y hacer visible la imagen que muestra el ImageView. Creamos una interfaz visual similar a la siguiente:

Seleccionamos el control ImageView y fijarmos la propiedad Visibility con el valor invisible (esto hace que la imagen no se muestre en pantalla)

Luego inicializamos la propiedad On click del control Button indicando el nombre del mtodo que se ejecutar al ser presionado:

El cdigo fuente de la clase es:

package com.androidya.proyecto016; import android.app.Activity;

import import import import import

android.os.Bundle; android.view.Menu; android.view.View; android.widget.Button; android.widget.ImageView;

public class MainActivity extends Activity { Button b1; ImageView iv1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); b1 = (Button) findViewById(R.id.button1); iv1 = (ImageView) findViewById(R.id.imageView1); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void ocultarBoton(View v) { b1.setVisibility(View.INVISIBLE); iv1.setVisibility(View.VISIBLE); }

}
Cuando se presiona el botn procedemos a ocultar el botn y hacer visible la imagen:
public void ocultarBoton(View v) { b1.setVisibility(View.INVISIBLE); iv1.setVisibility(View.VISIBLE); }

Este proyecto lo puede descargar en un zip desde este enlace: proyecto016.zip

20 - Layout (ScrollView y LinearLayout)

El ScrollView junto con un LinearLayout nos permite disponer una cantidad de componentes visuales que superan la cantidad de espacio del visor del celular o tablet. Luego el usuario puede desplazar con el dedo la interfaz creada.
Problema:

Disponer un control de tipo ScrollView (que se encuentra en la pestaa Composite). Como veremos automticamente se crea una componente de tipo LinearLayout y fijemos la propiedad Orientation del LinearLayout con el valor vertical:

Luego dispongamos numerosos botones que superen la cantidad de espacio del dispositivo. Numerar los botones con los nmeros del 1 en adelante (recordar que podemos ir arrastrando los botones a la ventana Outline):

Luego si ejecutamos el programa veremos que podemos desplazar (scroll) todo el contenido del visor con el dedo:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto017.zip Otra posibilidad para la implementacin de una interfaz en Android es disponer un LinearLayout en la parte superior y un ScrollView en la parte inferior:

Esto hace que en tiempo de ejecucin quede fijo el LinearLayout y podamos desplazar con el dedo el ScrollView que aparece en la parte inferior:

21 - Icono de la aplicacin

Cuando creamos un proyecto para implementar una aplicacin con el plugin de Android nos crea un cono por defecto:

Los conos e imgenes se almacenan en la carpeta res (resources) y en esta hay cuatro carpetas llamadas:
drawable-ldpi drawable-mdpi drawable-hdpi drawable-xhdpi

Y en cada una de estas hay un archivo llamado ic_launcher.png:

Como las resoluciones de los dispositivos Android pueden ser muy distintos (un celular, una tablet, un televisor etc.) se recomienda proporcionar mltiples copias de cada imagen de recursos a diferentes resoluciones y almacenarlos en las carpetas nombradas respetando las siguientes reglas:
res/drawable-ldpi/ 75% del tamao de las imgenes almacenadas en la carpeta drawablemdpi El cono debe ser de 36*36 pxeles.

res/drawable-mdpi/ El cono debe ser de 48*48 pxeles. res/drawable-hdpi/ 150% del tamao de las imgenes almacenadas en la carpeta drawablemdpi El cono debe ser de 72*72 pxeles. res/drawable-xhdpi/ 200% del tamao de las imgenes almacenadas en la carpeta drawablemdpi El cono debe ser de 96*96 pxeles.

Problema:

Crear una aplicacin, dibujar y almacenar tres archivos llamados icon.png. Tener en cuenta que el archivo que se almacena en la carpeta drawable-mdpi debe ser de 48 pxeles, el de la carpeta drawable-mdpi de 36 pxeles y el de la carpeta drawable-hdpi debe ser de 72 pxeles de ancho y alto. Ejecutar la aplicacin y ver el cono nuevo.

Este proyecto lo puede descargar en un zip desde este enlace: proyecto018.zip

22 - Reproduccin de audio (archivo

contenido en la aplicacin)
Veremos los pasos para reproducir un archivo mp3 (otros formatos soportados por Android son: Ogg, Wav)
Problema:

Disponer dos botones con las etiquetas: Gato y Len, luego cuando se presione reproducir el archivo de audio respectivo. Los archivos de sonidos almacenarlos en la misma aplicacin. Luego de crear el proyecto procedemos a crear una carpeta llamada raw que dependa de la carpeta res, almacenamos los dos archivos mp3 en dicha carpeta (para crear la carpeta presionamos el botn derecho del mouse sobre la carpeta res y seleccionamos new -> folder):

Luego de copiar los archivos a la carpeta debemos refrescar los archivos contenidos en el proyecto presionando el botn derecho del mouse y seleccionando la opcin "Refresh":

Podemos comprobar que los dos archivos estn referenciados en el proyecto. Creamos una interfaz con dos botones e inicializamos las propiedades Text y On Click de cada botn:

El cdigo fuente de la clase Proyecto019Activity.java es:

package com.androidya.proyecto019; import android.app.Activity; import android.media.MediaPlayer;

import android.os.Bundle; import android.view.Menu; import android.view.View; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void presionGato(View v) { MediaPlayer mp = MediaPlayer.create(this, R.raw.gato); mp.start(); } public void presionLeon(View v) { MediaPlayer mp = MediaPlayer.create(this, R.raw.leon); mp.start(); } }

Cuando copiamos los archivos mp3 se genera luego en la clase R la referencia a los dos archivos y posteriormente los podemos rescatar cuando creamos un objeto de la clase MediaPlayer:
MediaPlayer mp=MediaPlayer.create(this,R.raw.gato);

Seguidamente llamamos al mtodo start:

mp.start();

Este proyecto lo puede descargar en un zip desde este enlace: proyecto019.zip

23 - Reproduccin, pausa, continuacin y detencin de un archivo de audio.

Problema:

Confeccionar una aplicacin que permita Iniciar un archivo mp3, detener, continuar, detener en forma definitiva y activacin o no de la reproduccin en forma circular. Crear un archivo mp3 con el programa Audacity contando del 1 al 30. Primero creamos un proyecto y definimos los 5 botones y mtodos a ejecutar cuando se presionen los botones respectivos:

Creamos la carpeta raw y almacenamos en la misma el archivo mp3 creado previamente. Refrescamos la carpeta raw para actualizar el archivo mp3:

El cdigo fuente es:

package com.androidya.proyecto020; import import import import import import android.app.Activity; android.media.MediaPlayer; android.os.Bundle; android.view.Menu; android.view.View; android.widget.Button;

public class MainActivity extends Activity { MediaPlayer mp; Button b1; int posicion = 0; @Override

protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); b1 = (Button) findViewById(R.id.button5); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void destruir() { if (mp != null) mp.release(); } public void iniciar(View v) { destruir(); mp = MediaPlayer.create(this, R.raw.numeros); mp.start(); String op = b1.getText().toString(); if (op.equals("No reproducir en forma circular")) mp.setLooping(false); else mp.setLooping(true); } public void pausar(View v) {

if (mp != null && mp.isPlaying()) { posicion = mp.getCurrentPosition(); mp.pause(); } } public void continuar(View v) { if (mp != null && mp.isPlaying() == false) { mp.seekTo(posicion); mp.start(); } } public void detener(View v) { if (mp != null) { mp.stop(); posicion = 0; } } public void circular(View v) { detener(null); String op = b1.getText().toString(); if (op.equals("No reproducir en forma circular")) b1.setText("reproducir en forma circular"); else b1.setText("No reproducir en forma circular"); } }
Primero definimos tres atributos uno de la clase MediaPlayer para administrar el archivo mp3, un entero donde se almacena la posicin actual de reproduccin en milisegundos (para poder continuarla en el futuro) y la referencia de un objeto de la clase Button:

MediaPlayer mp; Button b1; int posicion=0;

El mtodo destruir verifica con un if si el objeto de la clase MediaPlayer est creado procede a liberar recursos del mismo llamando al mtodo release:
public void destruir() { if(mp!=null) mp.release(); }

El mtodo iniciar que se ejecuta al presionar el botn "Iniciar" primero llama al mtodo destruir (para el caso que el mp3 este en ejecucin actualmente) seguidamente creamos un objeto de la clase MediaPlayer llamando al mtodo create (en este hacemos referencia al archivo que copiamos a la carpeta raw) Llamamos al mtodo start. Por ltimo extraemos el texto del quinto botn y verificamos si la reproduccin debe ejecutarse en forma circular (en forma indefinida una y otra vez):
public void iniciar(View v) { destruir(); mp = MediaPlayer.create(this,R.raw.numeros); mp.start(); String op=b1.getText().toString(); if (op.equals("No reproducir en forma circular")) mp.setLooping(false); else mp.setLooping(true); }

El mtodo pausar verifica que el objeto de la clase MediaPlayer este creado y en ejecucin, en caso afirmativo recuperamos la posicin actual de reproduccin y llamamos seguidamente al mtodo pause:
public void pausar(View v) { if(mp != null && mp.isPlaying()) { posicion = mp.getCurrentPosition(); mp.pause(); } }

El mtodo continuar verifica que el objeto de la clase MediaPlayer este creado y la propiedad isPlaying retorne false para proceder a posicionar en que milisegundo continuar la reproduccin:
public void continuar(View v) { if(mp != null && mp.isPlaying()==false) { mp.seekTo(posicion); mp.start(); } }

El mtodo detener interrumpe la ejecucin del mp3 e inicializa el atributo posicion con cero:
public void detener(View v) { if(mp != null) { mp.stop(); posicion = 0; }

Cuando se presiona el botn que cambia si la reproduccin se efecta en forma circular o no procedemos a extraer su texto y segn dicho valor almacenamos el valor opuesto:
public void circular(View v) { detener(null); String op=b1.getText().toString(); if (op.equals("No reproducir en forma circular")) b1.setText("reproducir en forma circular"); else b1.setText("No reproducir en forma circular"); }

Este proyecto lo puede descargar en un zip desde este enlace: proyecto020.zip

24 - Reproduccin de audio (archivo contenido en una tarjeta SD)

El objetivo de este concepto es acceder a un archivo mp3 almacenado en la tarjeta SD de nuestro equipo.
Problema:

Disponer un botn con la etiqueta: "Gato", luego cuando se presione reproducir el archivo de audio respectivo. El archivo de sonido almacenarlo en la tarjeta SD. Luego de crear el proyecto debemos ejecutar la aplicacin en modo depuracin para poder acceder a la tarjeta SD que crea el emulador Android. Para ejecutar la aplicacin en modo "Debug" presionamos el botn derecha del mouse sobre el proyecto y seleccionamos la opcin "Debug A" "Android Aplication":

Una vez que se este ejecutando la aplicacin (no importa que todava no hemos implementado su funcionalidad) procedemos a abrir la ventana "File Explorer" de Android. Seleccionamos del men de opciones de Eclipse: Window -> Show View -> Other :

Y en esta ventana seleccionamos Android -> FileExplorer:

Ahora podemos ver la ventana donde administramos los archivos contenidos en la tarjeta SD que emula el "Android Virtual Device":

En la carpeta sdcard debemos subir el archivo mp3 (debemos seleccionar esta carpeta con el mouse) Esto lo hacemos mediante un botn que aparece en la parte derecha de esta

ventana "Push a file onto device", luego de esto tenemos el archivo montado en la tarjeta SD:

Ahora implementemos la interfaz de nuestra aplicacin (un solo botn) que cuando se presione llame al mtodo ejecutar:

El cdigo fuente es:

package com.androidya.proyecto021; import import import import import import android.app.Activity; android.media.MediaPlayer; android.net.Uri; android.os.Bundle; android.os.Environment; android.view.Menu;

import android.view.View; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void ejecutar(View v) { Uri datos = Uri.parse(Environment.getExternalStorageDirectory () .getPath() + "/gato.mp3"); MediaPlayer mp = MediaPlayer.create(this, datos); mp.start(); } }
Creamos un objeto de la clase Uri llamando al mtodo parse donde indicamos el path y nombre del archivo a recuperar:
Uri datos Uri.parse(Environment.getExternalStorageDirectory().getPath() +"/gato.mp3"); =

Creamos el objeto de la clase MediaPlayer pasando ahora la referencia del objeto de la clase Uri:
MediaPlayer mp=MediaPlayer.create(this, datos);

Iniciamos la reproduccin del mp3:

mp.start();

Este proyecto lo puede descargar en un zip desde este enlace: proyecto021.zip Recordar que para ejecutar este proyecto se debe subir un archivo mp3 llamado "gato.mp3" a la tarjeta SD.

25 - Reproduccin de audio (archivo localizado en internet)

Ahora vamos a ver los pasos para reproducir un archivo almacenado en un servidor de internet.
Problema:

Disponer un botn con la etiqueta: "Gato", luego cuando se presione reproducir el archivo de audio respectivo. El archivo de sonido se encuentra almacenado en http://www.codigofuenteya.com.ar/recursos/gato.mp3 El primer paso es modificar el archivo AndroidManifest.xml donde autorizamos a la aplicacin a acceder a recursos localizados en internet:

Creamos la interfaz de la aplicacin e inicializamos el evento On click del Button con el mtodo que implementaremos:

El cdigo fuente es:

package com.androidya.proyecto022; import java.io.IOException; import import import import android.app.Activity; android.media.MediaPlayer; android.os.Bundle; android.view.Menu;

import android.view.View; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void ejecutar(View v) { MediaPlayer mp = new MediaPlayer(); try { mp.setDataSource("http://www.codigofuenteya.com.a r/recursos/gato.mp3"); mp.prepare(); mp.start(); } catch (IOException e) { } } }
Para recuperar un archivo mp3 de internet procedemos de la siguiente manera, primero creamos un objeto de la clase MediaPlayer:
MediaPlayer mp=new MediaPlayer();

Luego llamamos al mtodo setDataSource indicando la direccin de internet donde se almacena el archivo mp3:
mp.setDataSource("http://www.codigofuenteya.com.ar/recursos/gato.mp3");

Llamamos al mtodo prepare y seguidamente llamamos a start:

mp.prepare(); mp.start();

Todo esto lo hacemos en un bloque try/catch para capturar excepciones de tipo IOException. Esta primera aproximacin para ejecutar un mp3 localizado en internet bloquea la aplicacin hasta que se carga por completo el archivo, es decir queda ejecutndose el mtodo mp.prepare() hasta que finaliza la recuperacin en forma completa. Este proyecto lo puede descargar en un zip desde este enlace: proyecto022.zip
Problema:

Confeccionar otra aplicacin similar a la anterior pero que no se congele la interfaz de la aplicacin mientras se carga el mp3. Mostrar un mensaje que el archivo se est cargando. Desarrollamos un nuevo proyecto, asignamos el permiso de acceder a internet en el archivo AndroidManifest.xmp y creamos una interfaz similar al problema anterior. El cdigo fuente es:

package com.androidya.proyecto023; import java.io.IOException; import android.app.Activity; import android.media.MediaPlayer; import android.media.MediaPlayer.OnPreparedListener; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.widget.Toast; public class MainActivity extends Activity implements OnPreparedListener{ MediaPlayer mp; @Override

protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void ejecutar(View v) { mp = new MediaPlayer(); mp.setOnPreparedListener(this); try { mp.setDataSource("http://www.codigofuenteya.com.a r/recursos/gato.mp3"); mp.prepareAsync(); } catch (IOException e) { } Toast t = Toast.makeText(this, "Espere un momento mientras se carga el mp3", Toast.LENGTH_SHORT); t.show(); } public void onPrepared(MediaPlayer mp) { mp.start(); }

}
Para poder capturar el evento que el archivo se termin de recuperar debemos implementar la interface OnPreparedListener:
public class Proyecto023Activity OnPreparedListener { extends Activity implements

Con esto decimos que nuestra clase implementar el mtodo onPrepared donde iniciamos la ejecucin del mp3:
public void onPrepared(MediaPlayer mp) { mp.start(); }

En el evento click del botn creamos el objeto de la clase MediaPlayer, le pasamos al mtodo setOnPreparedListener la direccin del objeto que capturar el evento de que el recurso est completo. Luego llamamos a los mtodos setDataSource y prepareAsync para inicializar la carga del mp3. Finalmente mostramos un mensaje para informar al usuario que el archivo se est descargando:
public void ejecutar(View v) { mp=new MediaPlayer(); mp.setOnPreparedListener(this); try { mp.setDataSource("http://www.codigofuenteya.com.ar/recursos/gato.mp3"); mp.prepareAsync(); }catch(IOException e) { } Toast t=Toast.makeText(this,"Espere un momento mientras se carga el mp3", Toast.LENGTH_SHORT); t.show(); }

Este proyecto lo puede descargar en un zip desde este enlace: proyecto023.zip

26 - Reproduccin de audio utilizando el reproductor propio de Android (va Intent)

Otra forma de ejecutar un archivo mp3 es mediante el reproductor interno de Android. Esta aplicacin reproduce todos los formatos soportados por Android y tiene una interfaz que le ser familiar al usuario de nuestra aplicacin.
Problema:

Disponer un botn con la etiqueta: "Ejecutar mp3 con el reproductor propio de Android", luego cuando se presione reproducir el archivo de audio respectivo

con el reproductor de Android via Intent. El archivo de sonido almacenarlo en la tarjeta SD. Luego de crear el proyecto debemos ejecutar la aplicacin en modo depuracin para poder acceder a la tarjeta SD que crea el emulador Android. Para ejecutar la aplicacin en modo "Debug" presionamos el botn derecha del mouse sobre el proyecto y seleccionamos la opcin "Debug A" "Android Aplication":

Una vez que se este ejecutando la aplicacin (no importa que todava no hemos implementado su funcionalidad) procedemos a abrir la ventana "File Explorer" de Android. Seleccionamos del men de opciones de Eclipse: Window -> Show View -> Other :

Y en esta ventana seleccionamos Android -> FileExplorer:

Ahora podemos ver la ventana donde administramos los archivos contenidos en la tarjeta SD que emula el "Android Virtual Device":

En la carpeta sdcard debemos subir el archivo mp3 (debemos seleccionar esta carpeta con el mouse) Esto lo hacemos mediante un botn que aparece en la parte derecha de esta

ventana "Push a file onto device", luego de esto tenemos el archivo montado en la tarjeta SD:

Creamos la interfaz con el Button y especificamos el evento On click:

El cdigo fuente es:

package com.androidya.proyecto024; import import import import import import android.app.Activity; android.content.Intent; android.net.Uri; android.os.Bundle; android.view.Menu; android.view.View;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void ejecutar(View v) { Intent intent = new Intent(android.content.Intent.ACTION_VIEW); Uri data = Uri.parse("file:///sdcard" + "/gato.mp3"); intent.setDataAndType(data, "audio/mp3"); startActivity(intent); } }
Creamos un objeto de la clase Intent y un objeto de la clase Uri referenciando al archivo mp3 almacenado en la tarjeta SD. Indicamos mediante el mtodo setDataAndType el Uri y el tipo de archivo a reproducir. Activamos la aplicacin mediante startActivity. Este proyecto lo puede descargar en un zip desde este enlace: proyecto024.zip

27 - Grabacin de audio mediante el

grabador provisto por Android (via Intent)

La forma ms sencilla de capturar audio en Android es mediante el grabador que provee el sistema operativo Android. Invocamos la aplicacin de grabacin (tiene como ventana que la interfaz le es familiar al usuario, ya que muchas aplicaciones utilizan esta caracterstica) y luego recuperamos el audio grabado.
Problema:

Disponer dos objetos de la clase Button con las etiquetas "Grabar" y "Reproducir". Cuando se presione el primer botn proceder a activar la grabadora provista por Android. Cuando se presione el segundo botn reproducir el audio grabado. Crear la interfaz e inicializar los eventos On click de cada botn:

El cdigo fuente es:

package com.javaya.proyecto025; import import import import import android.net.Uri; android.os.Bundle; android.provider.MediaStore; android.view.Menu; android.view.View;

public class MainActivity extends Activity {

int peticion = 1; Uri url1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void grabar(View v) { Intent intent = new Intent(MediaStore.Audio.Media.RECORD_SOUND_ACTION ); startActivityForResult(intent, peticion); } public void reproducir(View v) { MediaPlayer mediaPlayer = MediaPlayer.create(this, url1); mediaPlayer.start(); } protected void onActivityResult(int requestCode, int resultCode, Intent data) {

if (resultCode == RESULT_OK && requestCode == peticion) { url1 = data.getData(); } } }

Cuando se presiona el botn de grabar el audio mediante un Intent activamos la aplicacin de grabacin propia de Android. Seguidamente llamamos al mtodo startActivityForResult para poder recuperar la grabacin luego de finalizada a travs del mtodo onActivityResult:
public void grabar(View v) { Intent intent = Intent(MediaStore.Audio.Media.RECORD_SOUND_ACTION); startActivityForResult(intent, peticion); } new

Debemos pasar al mtodo startActivityForResult adems de la referencia del Intent una variable con un valor 0 o positivo (luego este valor retornar al mtodo onActivityResult) Cuando finalizamos la grabacin se ejecuta el mtodo onActivityResult, donde almacenamos en la variable url1 la referencia al archivo de audio creado:
protected void onActivityResult (int requestCode, int resultCode, Intent data) { if (resultCode == RESULT_OK && requestCode == peticion) { url1 = data.getData(); } }

Por ltimo para ejecutar el contenido de la grabacin utilizamos la clase ya vista MediaPlayer:
public void reproducir(View v) { MediaPlayer mediaPlayer = MediaPlayer.create(this, url1); mediaPlayer.start(); }

Este proyecto lo puede descargar en un zip desde este enlace: proyecto025.zip

28 - Captura de audio mediante la clase MediaRecorder

Otra forma de grabar audio en Android es el empleo de la clase MediaRecorder. Esta clase nos da ms libertades a la hora de construir una aplicacin que requiere grabar audio.

Problema:

Disponer tres objetos de la clase Button con las etiquetas "Grabar", "Detener Grabacin" y "Reproducir Grabacin". Disponer adems un TextView para informar del estado actual. Cuando se presione el botn "Grabar" permitir registrar todos los sonidos hasta que se presione el botn "Detener Grabacin". Cuando se presione el botn "Reproducir Grabacin" emitir el archivo de audio previamente generado. La interfaz visual a implementar es la siguiente:

Tener en cuenta de no olvidar definir los tres mtodos para los tres botones: grabar, detener y reproducir.

Tambin debemos modificar el archivo AndroidManifest.xml donde debemos indicar que nuestra aplicacin acceder a la grabadora de sonido y a la tarjeta SD donde se almacenar el archivo de sonido. Esto lo hacemos seleccionando el archivo AndroidManifest.xml y en la pestaa Permissions registramos los dos permisos:

El cdigo fuente es:

package com.androidya.proyecto026; import java.io.File; import java.io.IOException; import android.app.Activity; import android.media.MediaPlayer; import android.media.MediaPlayer.OnCompletionListener; import android.media.MediaRecorder; import android.os.Bundle; import android.os.Environment; import android.view.Menu; import android.view.View; import android.widget.Button; import android.widget.TextView; public class MainActivity extends Activity implements OnCompletionListener { TextView tv1; MediaRecorder recorder;

MediaPlayer player; File archivo; Button b1, b2, b3; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); tv1 = (TextView) this.findViewById(R.id.textView1); b1 = (Button) findViewById(R.id.button1); b2 = (Button) findViewById(R.id.button2); b3 = (Button) findViewById(R.id.button3); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void grabar(View v) { recorder = new MediaRecorder(); recorder.setAudioSource(MediaRecorder.AudioSource .MIC); recorder.setOutputFormat(MediaRecorder.OutputForm at.THREE_GPP);

recorder.setAudioEncoder(MediaRecorder.AudioEncod er.AMR_NB); File path = new File(Environment.getExternalStorageDirectory() .getPath()); try { archivo = File.createTempFile("temporal", ".3gp", path); } catch (IOException e) { } recorder.setOutputFile(archivo.getAbsolutePath()) ; try { recorder.prepare(); } catch (IOException e) { } recorder.start(); tv1.setText("Grabando"); b1.setEnabled(false); b2.setEnabled(true); } public void detener(View v) { recorder.stop(); recorder.release(); player = new MediaPlayer(); player.setOnCompletionListener(this); try { player.setDataSource(archivo.getAbsolutePath()); } catch (IOException e) { } try { player.prepare(); } catch (IOException e) {

} b1.setEnabled(true); b2.setEnabled(false); b3.setEnabled(true); tv1.setText("Listo para reproducir"); } public void reproducir(View v) { player.start(); b1.setEnabled(false); b2.setEnabled(false); b3.setEnabled(false); tv1.setText("Reproduciendo"); } public void onCompletion(MediaPlayer mp) { b1.setEnabled(true); b2.setEnabled(true); b3.setEnabled(true); tv1.setText("Listo"); } }
Declaramos un objeto de la clase MediaRecorder para grabar audio:
MediaRecorder recorder;

Declaramos un objeto de la clase MediaPlayer para reproducir el archivo de sonido generado:

MediaPlayer player;

Declaramos un objeto de la clase File que hace referencia al archivo que se crear:
File archivo;

Declaramos las variables que harn referencia a los tres botones y al TextView:
TextView tv1; Button b1,b2,b3;

En el mtodo onCreate obtenemos la referencia de los cuatro objetos creados en el archivo XML:
tv1 = (TextView) this.findViewById(R.id.tv1); b1=(Button)findViewById(R.id.button1); b2=(Button)findViewById(R.id.button2); b3=(Button)findViewById(R.id.button3);

El mtodo ms importante de este concepto es el grabar:

public void grabar(View v) { recorder = new MediaRecorder(); recorder.setAudioSource(MediaRecorder.AudioSource.MIC); recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP); recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB); File path = new File(Environment.getExternalStorageDirectory().getPath()); try { archivo = File.createTempFile("temporal", ".3gp", path); } catch (IOException e) { } recorder.setOutputFile(archivo.getAbsolutePath()); try { recorder.prepare(); } catch (IOException e) { } recorder.start(); tv1.setText("Grabando"); b1.setEnabled(false); b2.setEnabled(true); }

Creamos un objeto de la clase MediaRecorder:

recorder = new MediaRecorder();

Seguidamente definimos el micrfono como fuente de audio:

recorder.setAudioSource(MediaRecorder.AudioSource.MIC);

Luego llamamos al mtodo setOutputFormat especificando que el archivo ser almacenado con la especificacin 3GPP y con extensin .3gp
recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);

Especificamos el codec a emplear llamando al mtodo setAudioEncoder:

recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);

Obtenemos el path de la tarjeta SD y creamos un archivo temporal con extensin 3gp:

File path = File(Environment.getExternalStorageDirectory().getPath()); try { archivo = File.createTempFile("temporal", ".3gp", path); } catch (IOException e) { } new

Con el mtodo setOutputFile de la clase MediaRecorder le indicamos el archivo donde debe almacenarse la grabacin:
recorder.setOutputFile(archivo.getAbsolutePath());

Llamamos al mtodo prepare y finalmente al mtodo start para comenzar la grabacin:

try { recorder.prepare(); } catch (IOException e) { } recorder.start();

El mtodo detener:
public void detener(View v) { recorder.stop(); recorder.release(); player = new MediaPlayer();

player.setOnCompletionListener(this); try { player.setDataSource(archivo.getAbsolutePath()); } catch (IOException e) { } try { player.prepare(); } catch (IOException e) { } b1.setEnabled(true); b2.setEnabled(false); b3.setEnabled(true); tv1.setText("Listo para reproducir"); }

Llamamos primero al mtodo stop de la clase MediaRecorder y liberamos los recursos consumidos llamando a release:
recorder.stop(); recorder.release();

Creamos un objeto de la clase MediaPlayer para poder reproducir el archivo de audio que acabamos de grabar. Indicamos mediante el mtodo setOnCompletionListener la referencia de la clase que ser informada cuando el audio finalice:
player = new MediaPlayer(); player.setOnCompletionListener(this);

Referenciamos el archivo a que debe reproducir:

try { player.setDataSource(archivo.getAbsolutePath()); } catch (IOException e) { }

Finalmente llamamos al mtodo prepare de la clase MediaPlayer:

try { player.prepare(); } catch (IOException e) { }

El mtodo reproducir simplemente llama al mtodo start de la clase MediaPlayer para iniciar la reproduccin del archivo previamente grabado:
public void reproducir(View v) { player.start(); b1.setEnabled(false); b2.setEnabled(false); b3.setEnabled(false); tv1.setText("Reproduciendo"); }

El mtodo onCompletion se ejecuta cuando termina de reproducirse el archivo de audio:

public void onCompletion(MediaPlayer mp) { b1.setEnabled(true); b2.setEnabled(true); b3.setEnabled(true); tv1.setText("Listo"); }

Este proyecto lo puede descargar en un zip desde este enlace: proyecto026.zip

29 - Men de opciones
En Android la implementacin de un men de opciones permite mostrar opciones de una forma estandarizada entre aplicaciones (esto hace que todos los programas tengan una vista de un men muy parecidos) Los mens aparecen en la parte inferior de la pantalla cuando el usuario presiona el botn Men del celular. La implementacin del men se puede hacer de forma similar a la interfaz visual de la aplicacin mediante la creacin de un archivo XML y la construccin del mismo empleando las herramientas que provee el ADT.
Problema:

Confeccionar una aplicacin que muestre un men con dos opciones: una que visualice el "Acerca de..." (nombre de la aplicacin, programador etc.) del programa y otra que finalice el programa. El ADT ya creo el archivo XML para el activity principal y se encuentra localizado en la carpeta res/menu y se llama activity_main.xml La intefaz del editor de menu que nos provee el plugin de Android para Eclipse es:

Procedemos a insertar la primera opcin presionando el botn "Add", seguidamente seleccionamos "Item":

Luego nos queda inicializar como mnimo el ttulo de que mostrar dicha opcin:

Ahora nuevamente presionamos el botn "Add" para aadir la segunda opcin. En el dilogo que aparece seleccionamos "Create a new element at the top level, in Menu", seguidamente seleccionamos "Item" y confirmamos:

Configuramos la propiedad Title de la segunda opcin:

Paso seguido debemos sobreescribir los mtodos onCreateOptionsMenu (que ya lo tenemos codificado en el archivo Java) y onOptionsItemSelected heredados de la clase Activity. El cdigo fuente de la clase Proyecto027Activity.java es:

package com.javaya.proyecto027; import android.app.Activity;

import import import import

android.os.Bundle; android.view.Menu; android.view.MenuItem; android.widget.Toast;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.item1: Toast.makeText(this, "Programador: Diego (23/08/2011)", Toast.LENGTH_SHORT).show(); break; case R.id.item2: finish(); }

return true; } }
En el mtodo onCreateOptionsMenu creamos un objeto de la clase MenuInflater y mediante el mtodo inflate vinculamos el identificador del archivo de recursos: R.menu.activity_main y el objeto de la clase menu que llega como parmetro. Debemos retornar true:
@Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; }

En el mtodo onOptionsItemSelected debemos disponer un switch para identificar cual de las opciones del men fue seleccionado. El parmetro item de la clase MenuItem tiene la referencia del objeto que fue pulsado. Luego obtenemos su Id llamando al mtodo getItemId y a travs del switch verificamos con el recurso que coincide y procedemos a efectuar la actividad respectiva (si se selecciona la primer opcin mostramos un mensaje mediante la clase Toast, si se seleccion la segunda opcin llamamos al mtodo finish para finalizar el programa:
@Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.item1: Toast.makeText(this, "Programador: Diego (23/08/2011)", Toast.LENGTH_SHORT).show(); break; case R.id.item2: finish(); } return true; }

Desde el emulador para activar el men debemos presionar el siguiente botn:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto027.zip

30 - Men de opciones con submen

Ahora veremos que podemos desplegar un submen cuando se selecciona una opcin del men principal.
Problema:

Confeccionar una aplicacin que muestre un men con dos opciones: una que visualice el texto "Sitios interesantes..." y al ser seleccionado muestre otro submen con una serie de buscadores. y otra opcin en el men principal para que finalice el programa. Modificaremos el archivo activity_main.xml de la carpeta res/menu. Podemos eliminar el item que crea por defecto el ADT (menu_settings(Item) Primero insertamos un item que mostrar el mensaje "Sitios interesantes..." para esto presionamos el botn "Add" y seleccionamos "Item" en Title disponemos "Sitios interesantes..."

Presionamos "Add" y seleccionamos "Sub-Menu":

Luego aadimos varios Menu Item al Sub-Menu (uno por cada sitio web a enlazar):

La estructura final del men de opciones debe ser la siguiente:

El cdigo fuente de la clase Proyecto028Activity.java es:

package com.androidya.proyecto028; import android.app.Activity; import android.content.Intent; import android.net.Uri;

import android.os.Bundle; import android.view.Menu; import android.view.MenuItem; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { Intent i; switch (item.getItemId()) { case R.id.item2: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.google.com")); startActivity(i); break; case R.id.item3:

i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.yahoo.com")); startActivity(i); break; case R.id.item4: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.bing.com")); startActivity(i); break; case R.id.item5: finish(); } return true; } }
El mtodo onCreateOptionsMenu es idntico al concepto anterior. En el mtodo onOptionsItemSelected verificamos cual de los MenuItem es seleccionado y procedemos a invocar mediante un Intent al navegador configurado por defecto para el dispositivo. La visualizacin del submen en tiempo de ejecucin es similar a:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto028.zip

31 - Men de opciones con conos en los MenuItem

Otra posibilidad es disponer grficos dentro de los MenuItem de nuestro programa.
Problema:

Confeccionar una aplicacin que muestre un men con dos opciones: una que active el navegador con YouTube y otra que active Facebook. Disponer un cono para cada MenuItem. Luego de crear el proyecto procedemos a buscar dos conos representativos de Youtube y Facebook (dos archivos png de 48 pxeles de ancho y alto) y los almacenamos en la carpeta drawable-mdpi. Luego de refrescar la carpeta debemos tener en nuestro proyecto en dicha carpeta tres archivos:

Ahora tenemos que crear los dos Item y especificar las propiedades Title (con el texto que queremos que se muestre) y la propiedad Icon. Para configurar cada icon procedemos a asignar los valores @drawable/youtube y @drawable/facebook (los nombres coinciden con los nombres de archivos que copiamos a la carpeta drawable) Nos queda agregar solo la funcionalidad de cada MenuItem:

package com.androidya.proyecto029;

import import import import import import

android.app.Activity; android.content.Intent; android.net.Uri; android.os.Bundle; android.view.Menu; android.view.MenuItem;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } @Override public boolean onOptionsItemSelected(MenuItem item) { Intent i; switch (item.getItemId()) { case R.id.item1: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.youtube.com"));

startActivity(i); break; case R.id.item2: i = new Intent("android.intent.action.VIEW", Uri.parse("http://www.facebook.com")); startActivity(i); } return true; } }
Luego cuando lo ejecutamos podemos observar el cono que se muestra en cada MenuItem:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto029.zip

32 - Men contextuales
Otra variante de men de opciones son los men contextuales que se pueden asociar a distintos componentes visuales del formulario (TextView, EditText, ListView etc.) Un men contectual aparece cuando el usuario presiona por un tiempo ms o menos prolongado el control visual.
Problema:

Confeccionar una aplicacin que muestre un EditText y asociarle un men contextual que permita cambiar el color de fondo del mismo. El men debe permitir seleccionar entre el rojo, verde y azul. Primero creamos un proyecto y creamos una interfaz con un control de tipo EditText:

Luego creamos el archivo XML que contendr el men de opciones (presionamos el botn derecho del mouse sobre la carpeta res de nuestro proyecto y seleccionamos New -> Android XML File):

Aparece un dilogo donde debemos indicar el nombre del archivo de recursos a crear (lo llamamos menu1, este es el nombre del archivo XML que se crear en una carpeta llamada menu que depende de la carpeta res) y seleccionamos el RadioButton de menu Ya tenemos una nueva carpeta llamada menu y un archivo llamado menu1. Creamos las tres opciones del men:

Ahora veamos como asociar el archivo XML donde definimos el men con el cdigo Java:

package androidya.proyecto030; import android.app.Activity; import android.graphics.Color; import android.os.Bundle;

import import import import import import

android.view.ContextMenu; android.view.ContextMenu.ContextMenuInfo; android.view.MenuInflater; android.view.MenuItem; android.view.View; android.widget.EditText;

public class Proyecto030Activity extends Activity { EditText et1; /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.editText1); registerForContextMenu(et1); } @Override public void onCreateContextMenu(ContextMenu menu, View v,ContextMenuInfo menuInfo) { menu.setHeaderTitle("Elija el color de fondo:"); MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menu1, menu); } @Override public boolean onContextItemSelected(MenuItem item) {

switch (item.getItemId()) { case R.id.item1:et1.setBackgroundColor(Color.rgb(255, 0, 0)) ; break; case R.id.item2:et1.setBackgroundColor(Color.rgb(0, 255, 0)) ; break; case R.id.item3:et1.setBackgroundColor(Color.rgb(0, 0, 255)) ; break; } return true; } }
En el mtodo onCreateContextMenu asociamos el archivo XML llamando al mtodo inflate de la clase MenuInflate. Podemos tambin llamar al mtodo setHeaderTitle para mostrar un ttulo en el men emergente.
@Override public void onCreateContextMenu(ContextMenu v,ContextMenuInfo menuInfo) { menu.setHeaderTitle("Elija el color de fondo:"); MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menu1, menu); } menu, View

Para la captura de eventos de los MenuItem debemos implementar el mtodo onContextItemSelected donde mediante un switch verificamos cual de los MenuItem fue seleccionado y cambiamos el color de fondo del control EditText:
@Override public boolean onContextItemSelected(MenuItem item) { switch (item.getItemId()) { case R.id.item1:et1.setBackgroundColor(Color.rgb(255, 0, 0)) ; break; case R.id.item2:et1.setBackgroundColor(Color.rgb(0, 255, 0)) ; break; case R.id.item3:et1.setBackgroundColor(Color.rgb(0, 0, 255)) ; break; } return true; }

Este proyecto lo puede descargar en un zip desde este enlace: proyecto030.zip

33 - AlertDialog simple
El dilogo ms simple que podemos crear con Android en una ventana con un ttulo, un mensaje y un botn para cerrarlo. Muy til si tenemos que informar al usuario y no queremos que la ventana desaparezca hasta que el usuario presione un botn para ocultar el dilogo.
Problema:

Confeccionar una aplicacin que muestre un dilogo cada vez que se inicie la aplicacin informando que el programa que est ejecutando es un programa de prueba y no el completo. Primero creamos un proyecto llamado: proyecto031 Lo almacenamos en el paquete: androidya.proyecto031 El cdigo fuente de la aplicacin queda como sigue:

package androidya.proyecto021; import android.app.Activity; import android.app.AlertDialog; import android.os.Bundle; public class Proyecto031Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); AlertDialog.Builder builder = new AlertDialog.Builder(this); builder.setTitle("Importante"); builder.setMessage("Este es un programa solo de prueba y no la versin completa"); builder.setPositiveButton("OK",null); builder.create(); builder.show();

} }
Como queremos que el dilogo aparezca inmediatamente se arranque la aplicacin procedemos a incorporar el cdigo en el mtodo onCreate. Primero debemos importar la clase AlertDialog:
import android.app.AlertDialog;

La clase AlertDialog contiene otra clase llamada Builder que es la que encapsula la creacin de objetos de la clase AlertDialog. Procedemos a definir y crear un objeto de la clase Builder contenida en la clase AlertDialog:
AlertDialog.Builder builder = new AlertDialog.Builder(this);

Una vez creado el objeto procedemos a llamar al mtodo que define el ttulo a mostrar en el dilogo:
builder.setTitle("Importante");

El mensaje propiamente dicho lo configuramos llamando al mtodo setMessage:

builder.setMessage("Este es un programa solo de prueba y no la versin completa");

Mostramos un botn para poder cerrar el dilogo:

builder.setPositiveButton("OK",null);

Finalmente llamamos al mtodo que crea el dilogo y el que lo visualiza:

builder.create(); builder.show();

La interfaz visual del dilogo en tiempo de ejecucin es:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto031.zip

34 - AlertDialog con botones de confirmar y cancelar

Problema:

Confeccionar una aplicacin que muestre un dilogo cada vez que se inicie la aplicacin informando: "Acepta la ejecucin de este programa en modo prueba?" y dos botones para confirmar o rechazar. En caso que se rechace finalizar la ejecucin del programa. Primero creamos un proyecto llamado: proyecto032 Lo almacenamos en el paquete: androidya.proyecto032 El cdigo fuente de la aplicacin queda como sigue:

package androidya.proyecto032; import import import import import android.app.Activity; android.app.AlertDialog; android.content.DialogInterface; android.os.Bundle; android.widget.Toast;

public class Proyecto032Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); AlertDialog.Builder dialogo1 = new AlertDialog.Builder(this); dialogo1.setTitle("Importante"); dialogo1.setMessage(" Acepta la ejecucin de este programa en modo prueba ?"); dialogo1.setCancelable(false); dialogo1.setPositiveButton("Confirmar", new DialogInterface.OnClickListener() {

public void onClick(DialogInterface dialogo1, int id) { aceptar(); } }); dialogo1.setNegativeButton("Cancelar", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialogo1, int id) { cancelar(); } }); dialogo1.show(); } public void aceptar() { Toast t=Toast.makeText(this,"Bienvenido a probar el programa.", Toast.LENGTH_SHORT); t.show(); } public void cancelar() { finish(); } }
Creamos un objeto de la clase AlertDialog a travs de la clase Builder:
AlertDialog.Builder dialogo1 = new AlertDialog.Builder(this);

Configuramos el ttulo del dilogo:

dialogo1.setTitle("Importante");

Configuramos el mensaje del dilogo:

dialogo1.setMessage(" Acepta la ejecucin de este programa en modo prueba ?");

Evitamos que el dilogo sea salteado por cualquier medio distinto a presionar alguno de los dos botones:
dialogo1.setCancelable(false);

Llamamos al mtodo setPositiveButton indicando el texto a mostrar en el botn y la clase annima que capturar el evento clic del botn:
dialogo1.setPositiveButton("Confirmar", DialogInterface.OnClickListener() { public void onClick(DialogInterface dialogo1, int id) { aceptar(); } new

});

De forma similar procedemos con el botn de cancelar:

dialogo1.setNegativeButton("Cancelar", DialogInterface.OnClickListener() { public void onClick(DialogInterface dialogo1, int id) { cancelar(); } }); new

Mostramos el dilogo:
dialogo1.show();

Definimos los mtodos del Activity que se llamaran desde las clases annimas:
public void aceptar() { Toast t=Toast.makeText(this,"Bienvenido a probar el programa.", Toast.LENGTH_SHORT); t.show(); } public void cancelar() { finish(); }

La interfaz del dilogo es similar a esta:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto032.zip

35 - Notificaciones o mensajes mediante la clase Toast

La clase Toast nos permite mostrar un mensaje superpuesto a la ventana por un perodo de tiempo pero sin congelar la aplicacin. Este mensaje no permite interactuar con el usuario (no se pueden ingresar datos, seleccionar botones ni obligar a que se cierre) Eventualmente se lo puede localizar en distintas partes del dispositivo.
Problema:

Confeccionar una aplicacin que muestre una serie de botones y active mensajes de notificaciones con la clase Toast. Primero creamos un proyecto llamado: proyecto033 Lo almacenamos en el paquete: androidya.proyecto033 La interfaz visual a implementar son tres botones:

No olvidemos inicializar la propiedad On Click de cada botn con los mtodos: prueba1, prueba2 y prueba3. El cdigo fuente de la aplicacin queda como sigue:

package androidya.proyecto033; import import import import import import android.app.Activity; android.os.Bundle; android.view.Gravity; android.view.LayoutInflater; android.view.View; android.widget.Toast;

public class Proyecto033Activity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } public void prueba1(View v) { Toast toast = Toast.makeText(this, "Mensaje 1", Toast.LENGTH_SHORT); toast.show(); } public void prueba2(View v) { Toast toast = Toast.makeText(this, "Mensaje 2", Toast.LENGTH_SHORT); toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0); toast.show(); } public void prueba3(View v) { LayoutInflater inflater = getLayoutInflater();

View layout = inflater.inflate(R.layout.toast1, null); Toast toast = new Toast(getApplicationContext()); toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0); toast.setDuration(Toast.LENGTH_LONG); toast.setView(layout); toast.show(); } }
Para el evento click del primer botn mostramos el mensaje con las estructura ms simple que nos provee la clase Toast. Definimos un objeto de la clase Toast y llamamos al mtodo makeText pasando como parmetro la referencia del Activity, el mensaje a mostrar y una constante indicando si queremos que el mensaje aparezca por un perodo corto o largo de tiempo en la pantalla. Por ltimo llamamos al mtodo show para que se muestre el mensaje:
public void prueba1(View v) { Toast toast = Toast.makeText(this, Toast.LENGTH_SHORT); toast.show(); } "Mensaje 1",

Si queremos ubicar en otra parte de la pantalla debemos llamar al mtodo setGravity e indicar en el primer parmetro una constante (en este ejemplo lo centramos verticalmente) En el segundo y tercer parmetro de setGravity podemos desplazarlo una

cantidad de pxeles hacia derecha o izquierda, arriba o abajo segn indiquemos valores positivos o negativos. Luego el mtodo completo para este segundo Toast es:
public void prueba2(View v) { Toast toast = Toast.makeText(this, Toast.LENGTH_SHORT); toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0); toast.show(); } "Mensaje 2",

Para generar un Toast customizado debemos crear un archivo XML donde creamos visualmente los controles a mostrar, en este ejemplo creamos el siguiente archivo (crear un archivo llamado toast1.xml):

Este recurso luego lo incorporamos en el Toast mediante el siguiente cdigo:

public void prueba3(View v) { LayoutInflater inflater = getLayoutInflater(); View layout = inflater.inflate(R.layout.toast1,null); Toast toast = new Toast(getApplicationContext()); toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);

toast.setDuration(Toast.LENGTH_LONG); toast.setView(layout); toast.show(); }

Mediante la clase LayoutInflate procedemos a leer el contenido del archivo XML creado anteriormente y lo enlazamos con el toast mediante el mtodo:
toast.setView(layout);

En pantalla luego el Toast customizado aparece de la siguiente forma:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto033.zip

36 - Dibujar: graficar un pxel

Problema:

Graficar un pxel de color negro en medio de la pantalla del dispositivo. Para poder hacer esta simple tarea debemos seguir una serie de pasos: 1 Creamos un proyecto llamado: proyecto034 Lo almacenamos en el paquete: com.androidya.proyecto034 Borramos el TextView que agrega automticamente el plug-in de Eclipse y a definir un id para el RelativeLayout (le asignamos como Id el valor @+Id/layout1) y grabamos las modificaciones:

Ahora codificamos la clase donde se encuentra toda la lgica para encender el pxel:

package com.androidya.proyecto034; import import import import import import import import android.app.Activity; android.content.Context; android.graphics.Canvas; android.graphics.Paint; android.os.Bundle; android.view.Menu; android.view.View; android.widget.RelativeLayout;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RelativeLayout layout1 = (RelativeLayout) findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } class Lienzo extends View {

public Lienzo(Context context) { super(context); } protected void onDraw(Canvas canvas) { int ancho = canvas.getWidth(); int alto = canvas.getHeight(); Paint pincel1 = new Paint(); pincel1.setARGB(255, 0, 0, 0); canvas.drawPoint(ancho / 2, alto / 2, pincel1); } } }
Debemos crear una clase que herede de la clase View (todos los controles visuales en Android heredan de esta clase) y sobreescribir el mtodo onDraw. El mtodo onDraw se ejecuta cuando tiene que graficarse. Para acceder a las primitivas grficas hay una clase llamada Canvas que encapsula todo lo relacionado a pintar pxeles, lneas, rectngules etc.:
protected void onDraw(Canvas canvas) { int ancho=canvas.getWidth(); int alto=canvas.getHeight(); Paint pincel1=new Paint(); pincel1.setARGB(255,0,0,0); canvas.drawPoint(ancho/2, alto/2, pincel1); }

Lo primero que hacemos en el mtodo onDraw es obtener el ancho y alto en pxeles del dispositivo mediante los mtodos getWidth() y getHeight() que nos provee la clase Canvas. Seguidamente creamos un objeto de la clase Paint. Llamamos al mtodo setARGB para definir el color del pincel (el primer parmetro indica el valor de transparencia con 255 indicamos que no hay transparencia, luego indicamos la cantidad de rojo, verde y azul. Por ltimo debemos llamar al mtodo drawPoint que dibuja el pxel en la columna, fila y pincel que le pasamos como parmetros. Como podemos observar la clase Lienzo hereda de View e implementa el constructor donde llegar la referencia del Activity donde se inserta:
class Lienzo extends View { public Lienzo(Context context) { super(context); }

protected void onDraw(Canvas canvas) { int ancho=canvas.getWidth(); int alto=canvas.getHeight(); Paint pincel1=new Paint(); pincel1.setARGB(255,0,0,0); canvas.drawPoint(ancho/2, alto/2, pincel1); } }

Por ltimo en el mtodo onCreate del Activity obtenemos la referencia del RelativeLayout que tiene el Activity. Creamos un objeto de la clase Lienzo (llamado fondo) y agregamos el objeto fondo al RelativeLayout llamando al mtodo addView:
public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); RelativeLayout layout1 findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } = (RelativeLayout)

Cuando ejecutemos el programa veremos un pxel en medio de la pantalla de color negro:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto034.zip

37 - Dibujar: pintar fondo y dibujar

lneas
Problema:

Pintar el fondo de color amarillo y dibujar una serie de lneas con distintos estilos. 1 Creamos un proyecto llamado: proyecto035 Lo almacenamos en el paquete: com.androidya.proyecto035 Borramos el TextView que agrega automticamente el plug-in de Eclipse y difinimos el id del RelativeLayout con el valor: @+id/layout1:

Ahora codificamos la clase donde se encuentra toda la lgica para pintar el fondo y dibujar las lneas:

package com.androidya.proyecto035; import import import import import import import import android.app.Activity; android.content.Context; android.graphics.Canvas; android.graphics.Paint; android.os.Bundle; android.view.Menu; android.view.View; android.widget.RelativeLayout;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RelativeLayout layout1 = (RelativeLayout) findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; }

class Lienzo extends View { public Lienzo(Context context) { super(context); } protected void onDraw(Canvas canvas) { canvas.drawRGB(255, 255, 0); int ancho = canvas.getWidth(); Paint pincel1 = new Paint(); pincel1.setARGB(255, 255, 0, 0); canvas.drawLine(0, 30, ancho, 30, pincel1); pincel1.setStrokeWidth(4); canvas.drawLine(0, 60, ancho, 60, pincel1); } } }
Veamos el mtodo onDraw donde pintamos el fondo de la componente llamando al mtodo drawRGB donde indicamos la cantidad de rojo, verde a azul:
protected void onDraw(Canvas canvas) { canvas.drawRGB(255,255,0);

Creamos un objeto de la clase paint y definimos el color rojo (recordemos que el primer parmetro indica el valor de la transparencia, si vale 255 es totalmente opaco, con un valor menor el trazo de la lnea tendr transparencia. El mtodo para graficar una lnea se llama drawLine y tiene como parmetros la columna y fila del punto inicial y el tercer y cuarto parmetro indica la columna y fila del punto final de la lnea (en este ejemplo se dibujar una lnea horizontal en la fila 30 y tendr un ancho que coincide con el ancho del dispositivo), el ltimo parmetro es el objeto de la clase Paint que indica el color de la lnea:
Paint pincel1=new Paint(); pincel1.setARGB(255,255,0,0); canvas.drawLine(0, 30, ancho, 30, pincel1);

La siguiente lnea la dibujamos en la fila 60 pero previamente cambiamos el grosor del pincel llamando al mtodo setTrokeWidth indicando que sern 4 pxeles el grosor:
pincel1.setStrokeWidth(4); canvas.drawLine(0, 60, ancho, 60, pincel1);

La vista previa en el dispositivo ser:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto035.zip

Problema propuesto
1. Confeccionar una aplicacin que muestre una hoja en la pantalla similar a esta:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto036.zip

38 - Dibujar: rectngulos

Problema:

Pintar el fondo de color blanco y dibujar una serie de rectngulos con distintos estilos. 1 Creamos un proyecto llamado: proyecto037 Lo almacenamos en el paquete: com.androidya.proyecto037 Borramos el TextView que agrega automticamente el plug-in de Eclipse y difinimos el id del RelativeLayout con el valor: @+id/layout1:

Ahora codificamos la clase donde se encuentra toda la lgica:

package com.androidya.proyecto037;

import import import import import import import import import

android.app.Activity; android.content.Context; android.graphics.Canvas; android.graphics.Paint; android.graphics.Paint.Style; android.os.Bundle; android.view.Menu; android.view.View; android.widget.RelativeLayout;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RelativeLayout layout1 = (RelativeLayout) findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } class Lienzo extends View {

public Lienzo(Context context) { super(context); } protected void onDraw(Canvas canvas) { canvas.drawRGB(255,255,255); int ancho=canvas.getWidth(); Paint pincel1=new Paint(); pincel1.setARGB(255,255,0,0); canvas.drawRect(10,10,ancho10,40,pincel1); pincel1.setStyle(Style.STROKE); canvas.drawRect(10,60,ancho10,90,pincel1); pincel1.setStrokeWidth(3); canvas.drawRect(10,110,ancho10,140,pincel1); } } }
En el mtodo onDraw de la clase Lienzo procedemos a pintar el fondo de color blanco:
canvas.drawRGB(255,255,255);

Obtenemos el ancho del dispositivo:

int ancho=canvas.getWidth();

Creamos un objeto de la clase Paint:

Paint pincel1=new Paint();

Activamos el color rojo:

pincel1.setARGB(255,255,0,0);

Dibujamos un rectngulo desde la coordenada columna:10 y fila 10 hasta la columna que coincide con el ancho de la pantalla menos 10 pxeles y la fila 40. Adems le pasamos el pincel a utilizar:
canvas.drawRect(10,10,ancho-10,40,pincel1);

Para el siguiente rectngulo configuramos el pincel para que solo pinte el permetro llamando al mtodo setStyle y pasando la constante STROKE:
pincel1.setStyle(Style.STROKE); canvas.drawRect(10,60,ancho-10,90,pincel1);

Por ltimo dibujamos otro rectngulo que solo se pinta el permetro pero cambiamos el grosor del lapiz llamando al mtodo setStrokeWidth:
pincel1.setStrokeWidth(3); canvas.drawRect(10,110,ancho-10,140,pincel1);

La vista previa de la aplicacin es:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto037.zip

39 - Dibujar: crculos

Problema:

Pintar el fondo de color blanco y dibujar 10 crculos crecientes desde el medio de la pantalla. 1 Creamos un proyecto llamado: proyecto038 Lo almacenamos en el paquete: com.androidya.proyecto038 Borramos el TextView que agrega automticamente el plug-in de Eclipse y difinimos el id del RelativeLayout con el valor: @+id/layout1:

Ahora codificamos la clase donde se encuentra toda la lgica:

package com.androidya.proyecto038; import import import import import import import import import android.app.Activity; android.content.Context; android.graphics.Canvas; android.graphics.Paint; android.graphics.Paint.Style; android.os.Bundle; android.view.Menu; android.view.View; android.widget.RelativeLayout;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RelativeLayout layout1 = (RelativeLayout) findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; }

class Lienzo extends View { public Lienzo(Context context) { super(context); } protected void onDraw(Canvas canvas) { canvas.drawRGB(255, 255, 255); int ancho = canvas.getWidth(); int alto = canvas.getHeight(); Paint pincel1 = new Paint(); pincel1.setARGB(255, 255, 0, 0); pincel1.setStyle(Style.STROKE); for (int f = 0; f < 10; f++) { canvas.drawCircle(ancho / 2, alto / 2, f * 15, pincel1); } } } }
Pintamos el fondo de blanco y obtenemos el ancho y alto del control:
protected void onDraw(Canvas canvas) { canvas.drawRGB(255,255,255); int ancho=canvas.getWidth(); int alto=canvas.getHeight();

Creamos un objeto de la clase Paint, fijamos el color rojo y mediante setStyle indicamos que solo se debe pintar el permetro:
Paint pincel1=new Paint(); pincel1.setARGB(255, 255, 0, 0); pincel1.setStyle(Style.STROKE);

Disponemos un for para dibujar los 10 crculos concntricos (indicamos en los dos primeros parmetros el punto central del crculo y en el tercer parmetro el radio del crculo:
for(int f=0;f<10;f++) { canvas.drawCircle(ancho/2, alto/2, f*15, pincel1); } }

La vista previa de la aplicacin es:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto038.zip

40 - Dibujar: valos
Problema:

Dibujar un valo que ocupe toda la pantalla y un crculo en su interior. 1 Creamos un proyecto llamado: proyecto039 Lo almacenamos en el paquete: com.androidya.proyecto039 Borramos el TextView que agrega automticamente el plug-in de Eclipse y difinimos el id del RelativeLayout con el valor: @+id/layout1:

Ahora codificamos la clase donde se encuentra toda la lgica:

package com.androidya.proyecto039; import import import import import import import import import import import import android.app.Activity; android.content.Context; android.graphics.Canvas; android.graphics.Paint; android.graphics.Paint.Style; android.graphics.RectF; android.os.Bundle; android.view.Menu; android.view.View; android.view.Window; android.view.WindowManager; android.widget.RelativeLayout;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { requestWindowFeature(Window.FEATURE_NO_TITLE); getWindow().setFlags(WindowManager.LayoutParams.F LAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RelativeLayout layout1 = (RelativeLayout) findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } @Override

public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } class Lienzo extends View { public Lienzo(Context context) { super(context); } protected void onDraw(Canvas canvas) { canvas.drawRGB(255, 255, 255); int ancho = canvas.getWidth(); int alto = canvas.getHeight(); Paint pincel1 = new Paint(); pincel1.setARGB(255, 0, 0, 0); pincel1.setStrokeWidth(5); pincel1.setStyle(Style.STROKE); RectF rectangulo1 = new RectF(0, 0, ancho, alto); canvas.drawOval(rectangulo1, pincel1); int menor; if (ancho < alto) menor = ancho; else menor = alto; pincel1.setStyle(Style.FILL);

pincel1.setARGB(255, 255, 255, 0); canvas.drawCircle(ancho / 2, alto / 2, menor / 2, pincel1); } } }

Para ocultar la barra del ttulo y la barra superior debemos hacer lo siguiente en el mtodo onCreate:
@Override protected void onCreate(Bundle savedInstanceState) { requestWindowFeature(Window.FEATURE_NO_TITLE); getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RelativeLayout layout1 findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } = (RelativeLayout)

En el mtodo onDraw pintamos el fondo de blanco y obtenemos el ancho y alto de la pantalla:

protected void onDraw(Canvas canvas) { canvas.drawRGB(255,255,255); int ancho=canvas.getWidth(); int alto=canvas.getHeight();

Seguidamente creamos el objeto de la clase Paint y configuramos el color, grosor de lnea y estilo:
Paint pincel1=new Paint(); pincel1.setARGB(255,0,0,0); pincel1.setStrokeWidth(5); pincel1.setStyle(Style.STROKE);

Creamos un objeto de la clase RectT pasando como dato la coordenada superior izquierda del valo y la coordenada inferior derecha del mismo (teniendo en cuenta que el valo se dibujar en ese rectngulo imaginario que indicamos con dichas coordenadas):
RectF rectangulo1=new RectF(0,0,ancho,alto); canvas.drawOval(rectangulo1, pincel1);

Obtenemos el valor menor del ancho y alto del dispositivo:

int menor; if (ancho<alto) menor=ancho;

else menor=alto;

Configuramos ahora el pincel para dibujar el crculo y lo dibujamos:

pincel1.setStyle(Style.FILL); pincel1.setARGB(255, 255, 255, 0); canvas.drawCircle(ancho/2, alto/2, menor/2, pincel1); }

La vista previa de la aplicacin es:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto039.zip

41 - Dibujar: texto
Otra recurso que nos permite la clase Canvas es el de graficar texto. 1 Creamos un proyecto llamado: proyecto040 Lo almacenamos en el paquete: com.androidya.proyecto040 Borramos el TextView que agrega automticamente el plug-in de Eclipse y difinimos el id del RelativeLayout con el valor: @+id/layout1:

Ahora codificamos la clase donde se encuentra toda la lgica:

package com.androidya.proyecto040; import import import import import import import import import import import android.app.Activity; android.content.Context; android.graphics.Canvas; android.graphics.Paint; android.graphics.Typeface; android.os.Bundle; android.view.Menu; android.view.View; android.view.Window; android.view.WindowManager; android.widget.RelativeLayout;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { requestWindowFeature(Window.FEATURE_NO_TITLE); getWindow().setFlags(WindowManager.LayoutParams.F LAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RelativeLayout layout1 = (RelativeLayout) findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } @Override

public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } class Lienzo extends View { public Lienzo(Context context) { super(context); } protected void onDraw(Canvas canvas) { canvas.drawRGB(0, 0, 255); Paint pincel1 = new Paint(); pincel1.setARGB(255, 255, 0, 0); pincel1.setTextSize(30); pincel1.setTypeface(Typeface.SERIF); canvas.drawText("Hola Mundo (SERIF)", 0, 70, pincel1); pincel1.setTypeface(Typeface.SANS_SERIF); canvas.drawText("Hola Mundo (SANS SERIF)", 0, 100, pincel1); pincel1.setTypeface(Typeface.MONOSPACE); canvas.drawText("Hola Mundo (MONOSPACE)", 0, 140, pincel1); Typeface tf = Typeface.create(Typeface.SERIF, Typeface.ITALIC); pincel1.setTypeface(tf); canvas.drawText("Hola Mundo (SERIF ITALIC)", 0, 180, pincel1);

tf = Typeface.create(Typeface.SERIF, Typeface.ITALIC | Typeface.BOLD); pincel1.setTypeface(tf); canvas.drawText("Hola Mundo (SERIF ITALIC BOLD)", 0, 220, pincel1); } } }
Para graficar texto disponemos del mtodo drawText que nos permite imprimir un String en una determinada columna, fila con un determinado pincel que podemos definir su color:
Paint pincel1=new Paint(); pincel1.setARGB(255,255,0,0);

El tamao de la letra:
pincel1.setTextSize(30);

El estilo de la letra:
pincel1.setTypeface(Typeface.SERIF);

La interfaz del programa es:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto040.zip

42 - Dibujar: texto con fuentes externas

Podemos confeccionar aplicaciones e incorporar fuentes True Type externas. Para ello implementaremos una aplicacin que muestre un texto con una fuente externa. 1 Creamos un proyecto llamado: proyecto041 Lo almacenamos en el paquete: com.androidya.proyecto041 Borramos el TextView que agrega automticamente el plug-in de Eclipse y difinimos el id del RelativeLayout con el valor: @+id/layout1:

Procedemos ahora a descargar una fuente del sitio Creamundo y copiamos el archivo de la fuente a la carpeta assets como se muestra:

Ahora codificamos la clase donde se encuentra toda la lgica:

package com.androidya.proyecto041; import import import import import import import import import import import android.app.Activity; android.content.Context; android.graphics.Canvas; android.graphics.Paint; android.graphics.Typeface; android.os.Bundle; android.view.Menu; android.view.View; android.view.Window; android.view.WindowManager; android.widget.RelativeLayout;

public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { requestWindowFeature(Window.FEATURE_NO_TITLE);

getWindow().setFlags(WindowManager.LayoutParams.F LAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); RelativeLayout layout1 = (RelativeLayout) findViewById(R.id.layout1); Lienzo fondo = new Lienzo(this); layout1.addView(fondo); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } class Lienzo extends View { public Lienzo(Context context) { super(context); } protected void onDraw(Canvas canvas) { canvas.drawRGB(255, 255, 255); Paint pincel1 = new Paint(); pincel1.setARGB(255, 0, 0, 0); pincel1.setTextSize(30);

Typeface face = Typeface.createFromAsset(getAssets(), "Action Man Shaded.ttf"); pincel1.setTypeface(face); canvas.drawText("Hola Mundo", 0, 120, pincel1); } } }
En el mtodo onDraw procedemos a crear una fuente llamando al mtodo createFromAsset e indicando el nombre del archivo que descargamos de internet (disponga en el segundo parmetro el nombre del archivo que eligi y descarg de internet):
Typeface face = Typeface.createFromAsset(getAssets(), "Action Man Shaded.ttf"); pincel1.setTypeface(face);

La interfaz del programa es:

Este proyecto lo puede descargar en un zip desde este enlace: proyecto041.zip