Android: Programación de dispositivos móviles a través de ejemplos
José Enrique Amaro Soriano
Android: Programación de dispositivos
móviles a través de ejemplos
José Enrique Amaro Soriano
Android: Programación de dispositivos móviles a través de ejemplos
Primera edición, 2012
© 2012 José Enrique Amaro Soriano
© MARCOMBO, S.A. 2012
Gran Via de les Corts Catalanes, 594
08007 Barcelona
www.marcombo.com
«Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra sólo puede ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley. Diríjase a CEDRO (Centro Español de Derechos Reprográficos, www.cedro.org) si necesita fotocopiar o escanear algún fragmento de esta obra».
ISBN: 978-84-267-1825-9
DL:
Impreso en XXXXXXX
Printed in Spain
A Cecilia, que aprendió a descargar del Android market antes que a leer
ÍNDICE GENERAL
1.INTRODUCCIÓN
1.1.Acerca de este libro
1.2.A quién va dirigido
1.3.Resumen de los contenidos
1.4.Requerimientos
1.5.Créditos y Agradecimientos
2.ESCRIBIR Y MANIPULAR TEXTO
2.1.Actividad básica: Hola Android
2.2.Color de fondo y formato del texto
2.3.Modificando el texto desde Java
2.4.Modificando el color desde Java
2.5.Añadir texto adicional con addView
2.6.Definir un método print()
2.7.Escribiendo resultados de operaciones
2.8.Ejemplo: una tabla del seno
2.9.Añadir texto con Append()
2.10.Extendiendo la pantalla con ScrollView
3.BOTONES
3.1.Definición de un botón en el layout
3.2.Caso de dos botones
3.3.Uso de Toast para mostrar un mensaje emergente
3.4.Cambiar el texto de un botón
3.5.Cambiar el color de los botones
3.6.Calculadora
4.INTRODUCCIÓN DE TEXTOS
4.1.TextField
4.2.OnKeyListener
4.3.Forma alternativa de implementar OnKeyListener
5.GUARDAR DATOS CON SharedPreferences
6.ACTIVIDADES
6.1.Uso de Intent para iniciar actividades
6.2.Pasar valores numéricos entre actividades
7.MANEJO DE FICHEROS
7.1.Escribir datos en un fichero en la tarjeta SD
7.2.Leer un fichero en el directorio res
8.GRÁFICOS
8.1.Dibujando en un Canvas
8.2.Formato del texto
8.3.Altura del canvas
8.4.Dimensiones del canvas
8.5.Formas geométricas
8.6.Curvas
8.7.Traslaciones y rotaciones
8.8.Texto siguiendo una curva
8.9.Caracteres Unicode
8.10.LayoutParams
9.GRÁFICOS INTERACTIVOS
9.1.Evento ACTION_DOWN
9.2.Evento ACTION_UP
9.3.Evento ACTION_MOVE
9.4.Dibujar en la pantalla
9.5.Mover objetos
10.IMÁGENES
10.1.Insertar una imagen en el layout
10.2.Controlando las imágenes en Java
10.3.Botones con imágenes
10.4.Insertar imágenes en un canvas
10.5.Ajustar imagen a las dimensiones de la pantalla
11.REPRODUCIR SONIDO
11.1.Uso de MediaPlayer
11.2.Reproducir efectos de sonido
12.APLICANDO TEMAS
12.1.Tema por defecto
12.2.Tema NoTitleBar
12.3.Tema Dialog
12.4.Tema Light
13.RECURSOS
13.1.El recurso string
13.2.El recurso color
13.3.Usando recursos en un Layout
14.HILOS Y CONTROLADORES
14.1.Ejecuciones en background con Thread
14.2.Diálogos de progreso
14.3.Interfaz Runnable
14.4.Notificaciones
15.ANIMACIONES
15.1.Movimiento uniforme. La bola botadora
15.2.Movimiento acelerado. La bola botadora II
15.3.Conservación de la energía
15.4.Simulación de caída con ligadura
APÉNDICE A
ELEMENTOS DE JAVA
A.1. Programa básico de Java con Android
A.2. Variables
A.3. Conversión de variables
A.4. Operaciones con variables
A.5. Funciones matemáticas
A.6. Bloque if-else
A.7. Bucles for
A.8. Bucle while
A.9. Bloques switch
A.10. Métodos
A.11. Clases y objetos
A.12. Sub-clases
A.13. Variables y métodos estáticos y finales
A.14. Arrays
A.15. Arrays 2D
A.16. Cadenas
A.17. Formato numérico
A.18. Manejo de Excepciones
A.19. Interfaces
A.20. Clases anónimas
A.21. Otras características de Java
A.21.1. Paquetes
A.21.2. Clases públicas
A.21.3. Privilegios de acceso de los métodos y variables
A.21.4. Clases y métodos abstractos
APÉNDICE B
HERRAMIENTAS DE DESARROLLO DE ANDROID
B.1. Eclipse
B.1.1. Problemas en la instalación
B.1.2. Importar una clase Java de otro proyecto
B.1.3. Importar un proyecto completo ya existente
B.2. Android Virtual Device (AVD)
B.3. Dalvik Debug Monitor Server (DDMS)
B.4. Instalar driver dispositivo Android de Samsung en Linux (Ubuntu Jaunty)
APÉNDICE C
APLICACIONES
C.1. Interacción neutrón-protón
C.2. Ajuste por mínimos cuadrados
C.3. Energía del Helio-4
BIBLIOGRAFÍA
1.INTRODUCCIÓN
1.1.Acerca de este libro
Aunque el sistema operativo Android tiene apenas unos años de vida, la librería Java de Android consiste ya en más de 150 paquetes (APIs), que contienen miles de clases, métodos, interfaces y constantes. Todas estas clases están documentadas en la página web de Android Developers. La vasta extensión del software de desarrollo de Android (SDK) puede resultar extremadamente abrumadora para el que se acerca por primera vez a este sistema, especialmente si también es nuevo en el lenguaje de programación Java. La bibliografía existente tiende a estar dirigida a profesionales y los pocos libros introductorios están enfocados a construir completas aplicaciones de telefonía, que por su extensión y complejidad contribuyen a incrementar la frustración del principiante. En muchos casos se requiere un conocimiento avanzado de Java. Los manuales de Android ilustran todo tipo de aplicaciones para controlar sensores, enviar SMS, utilizar el GPS, acceso a servicios de internet, juegos, telefonía, fotografía, video, música, etc. Pero en general se pasa por alto que los dispositivos Android son verdaderos ordenadores que pueden utilizarse también para cálculo numérico y aplicaciones científicas y técnicas, tanto para docencia como para uso profesional e investigación. Con Android es posible realizar aplicaciones de cálculo y literalmente llevárselas en el bolsillo.
En este libro pretendemos hacer un acercamiento distinto a Android. No introduciremos toda la artillería de Android necesaria para escribir complejas aplicaciones de calidad profesional para publicarlas en el mercado Android. Se trata de presentar en pocas páginas las herramientas necesarias para poder realizar en poco tiempo programas sencillos de computación para uso científico y técnico, aunque no se descartan otras aplicaciones en los estudios, en el trabajo, artísticas o, simplemente, para ocio o disfrute personal.
1.2.A quién va dirigido
Este libro está dirigido al principiante con escasos o nulos conocimientos de Java, que quiere escribir rápidamente programas para uso personal. En particular, podrán beneficiarse de este libro los estudiantes, profesores, científicos o profesionales de cualquier tipo, con conocimientos previos de algún lenguaje de programación, que pretendan utilizar sus dispositivos Android para ejecutar sus propias aplicaciones.
Siguiendo la filosofía de que un ejemplo vale más que mil palabras, introducimos los conceptos mediante ejemplos que consisten en pequeñas aplicaciones que ilustran algún aspecto concreto de Android. Todos los ejemplos se acompañan con capturas de la pantalla. El resultado es un acercamiento rápido y práctico al sistema.
1.3.Resumen de los contenidos
En las primeras noventa páginas (capítulos 2 a 8), se introducen los conceptos esenciales para escribir completas aplicaciones Android con funciones de entrada y salida de datos, lectura y escritura de ficheros, y herramientas gráficas, utilizando sólo un pequeño conjunto de clases y métodos de la librería de Android. A continuación, se introducen otras herramientas no esenciales, aunque igualmente asequibles, como gráficos interactivos (capítulo 9), manejo de imágenes (capítulo 10), sonido (capítulo 11), temas (capítulo 12) y recursos (capítulo 13). El capítulo 14 introduce ya conceptos más avanzados, incluyendo procesos, controladores, diálogos de progreso y notificaciones. Finalmente el capítulo 15 describe cómo realizar animaciones gráficas, con aplicación directa a simulaciones.
El libro se complementa con un apéndice de introducción al lenguaje de programación Java, usando exclusivamente Android (apéndice A). El lector que no conozca Java podrá adquirir las nociones básicas de este lenguaje estudiando el apéndice A, a la vez que avanza en el estudio del capítulo 2.
Aunque en este libro no se describe el software específico para desarrollo de Android (editores, compiladores, emuladores, etc), el apéndice B contiene algunas notas sobre el uso de estas herramientas, que pueden ser útiles en algún momento.
Finalmente, en el apéndice C aplicamos los conceptos y técnicas introducidas en este libro para realizar un programa completo de cálculo científico.
Algunos de los ejemplos de este libro pueden descargarse de la página web del autor:
http://www.ugr.es/~amaro/android
Estas aplicaciones podrán ser instaladas directamente en un dispositivo Android, o podrán ser examinadas y modificadas por el usuario, puesto que se proporciona su código fuente.
1.4.Requerimientos
Para poder seguir los ejemplos de este libro, el lector debe instalar el Android Software Development Kit (SDK) en su ordenador. Este software funciona con todos los sistemas operativos y se puede descargar gratuitamente de la página web de Android Developers:
http://developer.android.com/sdk/index.html
La instalación del Android SDK está perfectamente documentada siguiendo los links de dicha página, o directamente en:
http://developer.android.com/sdk/installing.html
En particular, puesto que Android utiliza Java, también será necesario instalar previamente el kit de desarrollo de Java, o JDK (Java Development Kit) de la página web de oracle:
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Se recomienda seguir los ejemplos de este libro usando el programa Eclipse. Eclipse es un entorno de desarrollo interactivo (IDE) que facilita el desarrollo de aplicaciones Java y Android. Permite editar, compilar, ejecutar y depurar las aplicaciones Android. Eclipse es gratuito y se descarga de la página de Eclipse Foundation:
http://www.eclipse.org
Además, Eclipse importa automáticamente los paquetes de Java necesarios para nuestra aplicación y permite corregir sobre la marcha errores de programación.
En la página de Android Developers se explica cómo crear una nueva aplicación de Android usando Eclipse. En particular, recomendamos encarecidamente, como primer paso para programar en Android, visitar primero la siguiente página, donde se documenta con todo detalle cómo crear la aplicación básica de Android hello-world:
http://developer.android.com/resources/tutorials/hello-world.html
Siguiendo todas las instrucciones indicadas en esta página, el lector será capaz de ejecutar, desde Eclipse, su primera aplicación de Android en el emulador, la cual será el punto de partida del capítulo 2.
1.5.Créditos y Agradecimientos
El material de este libro fue inicialmente concebido para un proyecto de innovación docente de la Universidad de Granada, dirigido por el autor en el Departamento de Física Atómica, Molecular y Nuclear.
Sus contenidos conforman también el material didáctico para un curso de la Escuela de Posgrado de la Universidad de Granada, titulado Desarrollo de Aplicaciones de Android para Científicos. El curso está dirigido a universitarios de las ramas de Ciencias, Ingenierías y Arquitectura y tiene una carga lectiva de 75 horas totales y 30 horas presenciales, correspondientes a 3 créditos ECTS.
Todos los programas y ejemplos son originales del autor. Todas las fotografías, excepto las indicadas, son propiedad del autor.
Las fotografías de los físicos Bohr, Plank, Pauli y Schrödinger utilizadas en el ejemplo 8.3 están en el dominio público y han sido descargadas de la Wikipedia, donde están almacenadas como archivos de Wikimedia Commons.
Todos los dibujos y gráficos son obra del autor.
Agradezco a Enrique Ruiz Arriola y Rodrigo Navarro su permiso para adaptar a Android y publicar en el Apéndice C el programa de ajuste de la interacción neutrón-protón y el cálculo de la energía del núcleo de helio-4. Dicho programa ha sido realizado en el ámbito del proyecto de investigación del Plan Nacional de I+D+i, del Ministerio de Ciencia e Innovación, titulado Dinámica de Sistemas Hadrónicos en Física Nuclear a Energías Intermedias.
Finalmente, agradezco a Miguel Ángel por haber convertido a Word todo el libro desde su formato original en LaTeX.
2.ESCRIBIR Y MANIPULAR TEXTO
2.1.Actividad básica: Hola Android
Comenzamos examinando el siguiente listado del programa por defecto generado por Eclipse al crear un nuevo proyecto android. Se trata de escribir el mensaje "Hola Android" en la pantalla. En este programa básico se define la clase Activity, que contiene el método onCreate() que se ejecuta cuando se crea la actividad (ver la sección A.1 en el apéndice para una explicación detallada de los elementos Java de esta actividad)
package prueba.android.hello;
import android.app.Activity;
public class Hello extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Lo que hace la última instrucción del programa anterior setcontentview(R.layout.main), es "inflar" la vista de la pantalla (o "layout"). Esta vista está definida en el fichero main.xml, al que hace referencia la variable R.layout.main.
<?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="Hola Android"
/>
</LinearLayout>
La cadena de texto que queremos escribir en la pantalla se define en este fichero xml mediante TextView android:text="Hola Android". El resultado de ejecutar este proyecto en el emulador de android (AVD) se muestra en la figura 2.1.
Figura 2.1. Hola Android.
2.2.Color de fondo y formato del texto
A partir del fichero main.xml del ejemplo anterior podemos añadir otras propiedades de formato para modificar la presentación y el formato del texto. Por ejemplo, podemos:
•Cambiar el color de fondo a blanco en lugar de negro añadiendo el modificador android:background = "#ffffff" a la etiqueta LinearLayout.,
•Cambiar el color del texto a negro añadiendo en TextView el modificador android:textColor = "#000000".
•Cambiar el tamaño del texto a 24 puntos con android:textSize = "24sp".
•Centrar el texto mediante android:layout_gravity = "center". Nótese que para que esto surta efecto debemos definir la anchura de TextView igual a la anchura del texto que contiene mediante android:layout_width = "wrap_content", ya que con fill_parent se considera el texto igual de ancho que el Layout, que a su vez es igual de ancho que la pantalla y no es posible el centrado.
Figura 2.2. Hola Android en negro sobre blanco.
Con todos estos cambios el fichero main.xml quedaría de la siguiente forma:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:background="#ffffff"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="wrap_content"
android:layout_gravity="center"
android:layout_height="wrap_content"
android:textColor="#000000"
android:textSize="24sp"
android:text="Negro sobre blanco Android"
/>
El resultado puede verse en la figura 2.2.
2.3.Modificando el texto desde java
La cadena de texto que se muestra en pantalla está definida en el fichero de layout main.xml. Podemos modificarla desde java. Para ello primero añadimos una etiqueta (o ID) al texto TextView en el archivo xml:
<TextView
android:id="@+id/myTextView"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:textColor="#000000"
android:textSize="20sp"
android:text="Hola Android"
/>
Aqui hemos añadido la linea android:id y el texto quedará identificado mediante la etiqueta myTextView. A continuación en la clase Activity del código java escribimos la siguiente instrucción que define un objeto TextView asociado a la id myTextView que hemos indicado en main.xml:
TextView myTextView=(TextView) findViewById(R.id.myTextView);
El método findViewById() aplicado a variable R.id.myTextView se encarga de localizar el bloque en main.xml asociado a TextView. A continuación, definimos otro texto con el método setText():
myTextView.setText(
"He modificado TextView con un nuevo texto" +
"usando jav\a");
El programa java quedaría así:
package prueba.android.hello;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class Hello extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
TextView myTextView=
(TextView) findViewById(R.id.myTextView);
myTextView.setText(
"He modificado TextView con un nuevo texto " +
"usando java");
}
}
Y el resultado se puede ver en la figura 2.3. setText() no modifica el texto que hay escrito en el fichero main.xml, sólo el que se muestra en la pantalla del teléfono.
Figura 2.3. Texto modificado con setText().
2.4.Modificando el color desde Java
También se pueden modificar otras propiedades del texto con java. Por ejemplo, setTextColor() para cambiar el color. Así, añadiendo la siguiente instrucción definiríamos el texto rojo:0
myTextView.setTextColor(Color.argb(255,255,0,0));
El método Color.argb(alpha,red,green,blue)construye el color asociado a las componentes de alpha (transparencia), rojo, verde y azul, que son números enteros entre 0 y 255. El resultado se ve en la figura 2.4.
Figura 2.4. Texto de color con setTextColor().
2.5.Añadir texto adicional con addView
Para añadir nuevo texto a un layout usamos el método LinearLayout. addView(TextView). Para ello debemos definir un nuevo objeto de tipo TextView mediante:
TextView tv=new TextView(this);
y sus propiedades, por ejemplo, color y tamaño:
tv.setTextColor(Color.argb(255,0,0,0));
tv.setTextSize(40);
y finalmente el texto a escribir:
tv.setText("añadiendo nuevo texto con addView");
Este objeto se debe añadir al layout que debemos definir previamente mediante:
LinearLayout ll =
(LinearLayout)findViewById(R.id.myLinearLayout);
ll.addView(tv);
donde findViewById(R.id.myLinearLayout) se refiere a la id del layout que habremos definido en el fichero main.xml:
<LinearLayout
......
android:id="@+id/myLinearLayout"
>
Figura 2.5. Añadiendo nuevo texto al layout.
El código completo para añadir un texto a un layout queda como sigue:
TextView tv=new TextView(this);
tv.setTextColor(Color.argb(255,0,0,0));
tv.setTextSize(40);
tv.setText("añadiendo nuevo texto con addView");
LinearLayout ll=
(LinearLayout)findViewById(R.id.myLinearLayout);
ll.addView(tv);
y el resultado puede verse en la figura 2.5.
2.6.Definir un método print()
El código del ejemplo anterior habrá que repetirlo cada vez que queramos añadir un nuevo texto al layout. Para simplificar la escritura podemos definir un método print(Layout,String)para añadir un texto a un layout. Esto nos permite ilustrar tambien el normal uso de Java en Android. Por ejemplo, añadimos el siguiente método a nuestra actividad:
public void print(LinearLayout ll, String texto){
TextView tv=new TextView(this);
tv.setTextColor(Color.argb(255,0,0,0));
tv.setTextSize(18);
tv.setText(texto);
ll.addView(tv);
}
de manera que para añadir un texto al layout nos basta llamar a este método:
LinearLayout ll =
(LinearLayout)findViewById(R.id.myLinearLayout);
print(ll,"Añadiendo texto al layout usando el método print()"
+" que hemos definido");
Además, podemos definir un método print()alternativo añadiendo parámetros para escribir el texto con un tamaño y un color dados:
public void print(LinearLayout ll, String texto,
int size, int r, int g, int b){
TextView tv=new TextView(this);
tv.setTextColor(Color.argb(255,r,g,b));
tv.setTextSize(size);
tv.setText(texto);
ll.addView(tv);
}
Ya podemos ejecutar este método cuanto queramos con distintos tamaños y colores, por ejemplo:
LinearLayout ll =
(LinearLayout)findViewById(R.id.myLinearLayout);
print(ll,"text size 18 red ",18,255,0,0);
print(ll,"text size 24 green ",24,0,255,0);
print(ll,"text size 28 blue ",28,0,0,255);
print(ll,"text size 32 amarillo ",32,255,255,0);
print(ll,"text size 28 magenta ",28,255,0,255);
print(ll,"text size 24 cyan ",24,0,255,255);
El resultado se muestra en la figura 2.6.
Figura 2.6. Resultado de escribir usando la función print().
2.7.Escribiendo resultados de operaciones
Utilizando setTex podemos escribir cualquier texto o el resultado de cualquier operación matemática, por ejemplo:
double a=2.25;
double b=1.25;
double c=a+b;
tv.setText("La suma de "+ a + " mas " + b + " es " + c );
Aunque setText admite sólo cadenas, estas se pueden concatenar con números usando el signo +. También podemos aprovechar la función print() definida en el ejemplo anterior. Aquí tenemos el programa Hello modificado para escribir el resultado de una operacion:
public class Hello extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
TextView myTextView =
(TextView)findViewById(R.id.myTextView);
myTextView.setText(
"Ejemplo de resultados de operaciones matemáticas" +
"usando java");
myTextView.setTextColor(Color.argb(255,255,0,0));
double a=2.25;
double b=1.25;
double c=a+b;
LinearLayout ll =
(LinearLayout)findViewById(R.id.myLinearLayout);
print(ll,
"La suma de "+ a + " mas " + b + " es " + c);
}
public void print(LinearLayout ll, String texto){
TextView tv=new TextView(this);
tv.setTextColor(Color.argb(255,0,0,0));
tv.setTextSize(18);
tv.setText(texto);
ll.addView(tv);
}
}
El resultado se puede ver en la figura 2.7.
Figura 2.7. Resultado de operaciones matemáticas.
2.8.Ejemplo: una tabla del seno
Otro ejemplo, en lugar de la simple suma anterior, escribamos una tabla de la función seno entre 0 y 1
LinearLayout ll=
(LinearLayout)findViewById(R.id.myLinearLayout);
print(ll,"\n Tabla de sin(x):\n");
for(int i=0;i<10;i++){
double x=i/10.0;
double sx=Math.sin(x);
print(ll, "sin( " + x + " ) = " + sx);
}
El resultado está en la figura 2.8. El símbolo \n indica nueva línea. Recordamos además en este ejemplo cómo se realiza un ciclo repetitivo en Java usando for().
Figura 2.8. Resultado de operaciones matemáticas. Tabla del seno.
2.9.Añadir texto con Append()
Se puede añadir texto a un objeto TextView usando el método append(). Por ejemplo:
public class HolaAndroid2 extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
View v=findViewById(R.id.myTextView);
TextView myTextView=(TextView) v;
myTextView.setText("Texto 1 definido con setText");
myTextView.append("\n Texto 2 con append");
myTextView.append("\n Texto 3 con append");
myTextView.append("\n Texto 4 con append");
}
}
El resultado se muestra en la figura 2.9.
Figura 2.9. Añadir texto a un textView con append().
2.10.Extendiendo la pantalla con ScrollView
Si vamos a escribir mucho texto en un Layout, llega un momento en que aquél se sale de la pantalla y ya no es posible verlo, aunque el texto en teoría está ahí (de forma virtual). Para remediar esto, se puede insertar el layout dentro de un ScrollView, que permite mover la vista hacia arriba o hacia abajo a lo largo del layout. Por ejemplo, la siguiente actividad escribe una tabla de la función seno con cien puntos, que llega a salirse de la pantalla:
public class HolaAndroid2 extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
View v=findViewById(R.id.myTextView);
TextView myTextView=(TextView) v;
for(double x=0; x<1; x=x+0.01){
double y=Math.sin(x);
myTextView.append("sin("+x+") = "+y+"\n");
}
}
Figura 2.10. Un ScrollView permite extender la vista y acceder a la
parte del texto oculta porque se sale de la pantalla.
Para verla completa basta modificar main.xml insertando el LinearLayout dentro de un ScrollView:
<?xml version="1.0" encoding="utf-8"?>
<ScrollView
xmlns:android="http://schemas.android.com/apk/res/android"
android:background="#ffffff"
android:layout_height="wrap_content"
android:id="@+id/scrollView1"
android:layout_width="fill_parent">
<LinearLayout
android:id="@+id/linearLayout1"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TextView
android:id="@+id/myTextView"
android:textColor="#000000"
android:textSize="12sp"
android:layout_gravity="center"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hola Android"
/>
</LinearLayout>
</ScrollView>
El resultado se muestra en la figura 2.10. La barra vertical de la derecha indica el sector que se está mostrando.
