Capítulo 1 introducción a los servicios y aplicaciones móviles

Servicios móviles
Dpto. de Ingeniería de Telecomunicación
Área de Ingeniería Telemática
Universidad de Jaén
Escuela Politécnica Superior de Linares
Versión
2.0
Autor:
Juan Carlos Cuevas Martínez
Primeros pasos para la
programación de aplicaciones
en Android

Introducción a los servicios y aplicaciones
móviles Servicios Móviles
2
Versión 2.0
A. Conocer los orígenes y características más significativas de
Android.
B. Requerimientos mínimos del terminar para ejecutar
Android.
C. Conocer las diferentes versiones de Android.
D. Conocer la información disponible de Android.
E. Conocer los distintos métodos para almacenar datos de
manera persistente en Android.
F. Conocer la problemática del almacenamiento físico en
Android.
G. Conocer el uso de las bases de datos en Android.
H. Conocer las bases del manejo de gráficos en 2-D de
Android.

3
Versión 2.0
I. Conocer el manejo del audio básico.
J. Conocer los detalles de las clases de interfaz de
usuario de Android.
K. Diseñar interfaces de usuario usando XML o código
ejecutable implementar .
L. Manejar los eventos que genera el interfaz de usuario.
M. Crear menús de usuario.
N. Conocer los principios del diseño dinámico de
interfaces de usuario basado en Fragmentos.

4
Versión 2.0
1. Introducción a Android
1. Breve historia
2. Características
3. Plataformas
4. Arquitectura
5. Herramientas necesarias
6. Fuentes de información disponibles
2. Introducción a la programación en Android
1. Inicio con Android
2. Configuraciones: Crear un AVD
3. Crear HolaMundo
4. Tipos de aplicaciones Android
3. Actividades

5
Versión 2.0
4. Diseño de interfaces
1. Layouts
2. Controles básicos
3. Eventos
4. Menús
5. Barra de acción
6. Fragmentos

6
Versión 2.0
5. Almacenamiento de datos en Android
6. Almacenamiento basado en ficheros
1. Preferencias compartidas
2. Ficheros de datos
3. Ficheros de caché
7. Bases de datos

7
Versión 2.0
8. Gráficos 2-D
1. Canvas
2. Drawable
9. Animación de Drawables
1. Frame Animation
10. Animación de Vistas
1. Tween animation
11. Audio
1. PlayBack de audio y video
2. Captura de audio

8
Versión 2.0
1. Android Developers – Data Storage.
http://developer.android.com/guide/index.html
2. Android SQLite database and content provider –
tutorial. Based on Android 4.3. Autor: Lars Vogel,
Versión 4.9.
http://www.vogella.com/articles/AndroidSQLite/article.h
tml

9
Versión 2.0
1. Breve historia
2. Características
3. Plataformas
4. Arquitectura

10
Versión 2.0
 Android es un sistema operativo desarrollado
por Android Inc. basado en una versión
modificada del kernel de Linux, busca la
abstracción al HW.
 Android es mantenido como código abierto en el
Android Open Source Project encabezado por
Google.
 En su mayoría bajo licencia Apache Software
License, Version 2.0 ("Apache 2.0"). El símbolo de Android es el
robot, el cual puede ser
usado, reproducido y
modificado libremente en
publicaciones de marketing
con una correcta atribución
de autoría.

11
Versión 2.0
1. Breve historia
 Google compra el SO Android a Android Inc.
 Noviembre de 2007: primera SDK de Android.
 Diciembre de 2007: depuración de errores de la SDK.
 Agosto de 2008: anuncio de Android Market.
 Octubre de 2008: lanzamiento del primer móvil Android del mercado.
 Febrero de 2009: lanzamiento de la versión 1.1 de Android.
 Abril de 2009: lanzamiento de la versión 1.5 de Android (Cupcake).
 Septiembre de 2009: lanzamiento de la versión 1.6 de Android (Donut).
 Noviembre de 2009: lanzamiento de la versión 2.0/2.1 de Android
(Éclair).
 Junio de 2010: lanzamiento de la versión 2.2 de Android (Froyo).
 Diciembre de 2010: lanzamiento de la SDK versión 2.3 de Android y
lanzamiento de los primeros móviles (Gingebread). 2.3.3, Revision
2 (Julio 2011)

12
Versión 2.0
1. Breve historia
 Android 3.0 (HoneyComb Febrero 2011) API Level: 11
 Android 3.1 (Mayo 2011) API Level: 12
 Android 3.2 (Julio 2011) API Level: 13
 Android 4.0 (Ice Cream Sandwich, Octubre 2011) API
Level: 14
 Android 4.0.3 (Marzo 2012) API Level: 15
 Android 4.1.2 (JELLY_BEAN, Revisión 3 – Octubre 2012)
API Level: 16
 Android 4.2.2 (Revisión 2 – Febrero 2013) Level: 17
 Android 4.3.1 (Revisión 2 – Agosto 2013) Level: 18
 Android 4.4.2 (KitKat - Revisión 2 - Diciembre 2013)
Level: 19

13
Versión 2.0
1. Breve historia
 Android 4.4W.2. (Revisión 2 – octubre 2.014) Level: 20
 Android 5.0.1 (LOLLIPOP, Revisión 2 – diciembre 2.014 ) Level: 21
 Android 5.1.1 (Revisión 1 – Marzo 2015) Level: 22
 Android 6.0 (MARSHMALLOW, Agosto 2.015) Level: 23
 Android 7.0 (NOUGAT, Agosto 2.016) Level: 24
Logo de Android 5.0
(Lollipop)

14
Versión 2.0
1. Breve historia
 Aparición del soporte para dispositivos diferentes de móviles y
tabletas:
 Android WEAR.
 Android TV
 Android Auto

15
Versión 2.0
Worldwide Smartphone Sales to End Users by Operating System in 2Q16 (Thousands of Units)
1. Breve historia
Operating System 2Q16 Units 2Q16 Market
Share (%)
2Q15 Units 2Q15 Market
Share (%)
Android 296,912.8 86.2 271,647.0 82.2
iOS 44,395.0 12.9 48,085.5 14.6
Windows 1,971.0 0.6 8,198.2 2.5
Blackberry 400.4 0.1 1,153.2 0.3
Others 680.6 0.2 1,229.0 0.4
Total 344,359.7 100.0 330,312.9 100.0
Fuente: Gartner (Agosto 2016)
http://www.gartner.com/newsroom/id/3415117

16
Versión 2.0
2. Características
 La mayoría del código de Android es libre y abierto.
 Máquina virtual:
 Pre-Android 5.0: máquina virtual Dalvik, una máquina
virtual Java optimizada para dispositivos móviles.
 La máquina Dalvik fue actualizada a la máquina Android
runtime (ART) en la versión 5 (en la 4.4 de manera
experimental).
 Programas escritos en Java, lo que permite la
reutilización de aplicaciones ya programadas para otras
plataformas.

17
Versión 2.0
2. Características
 Navegador web integrado basado en el motor Chromium a
partir de la 4.4 (antes WebKit) de código libre.
 Gráficos optimizados: 2D con implementación propia y 3D
con OpenGL ES (hasta 3.2 y en Android 7 también Vulkan)
(aceleración por hardware opcional). La versión depende del
API de Android.
 Soporte multimedia para los formatos más comunes de
audio, video e imagen : MPEG4, H.264, MP3, AAC, AMR,
JPG, PNG, GIF.
 Almacenamiento de datos estructurados a través de SQLite
3.

18
Versión 2.0
2. Características
 Comunicaciones: Telefonía GSM, Bluetooth, EDGE, 3G, LTE y Wifi,
WifiDirect, Near Field Communication.
 Soporte para otros dispositivos: Cámara, GPS, brújula,
acelerómetro, pantallas táctiles.
 Aplicaciones en Google Play (inicialmente Android Market), donde
los desarrolladores pueden subir las aplicaciones.
 En Google Play, no sólo se distribuyen aplicaciones sino
Dispositivos, Libros, Revistas, Música y Películas.

19
Versión 2.0
3. Plataformas
 Conexión usuario-desarrollador: las plataformas Android
están asociadas a un nivel API.
 Nivel de API: Es el nivel de compatibilidad de la aplicación, y
si se usan la bibliotecas de compatibilidad, se pueden hacer
aplicaciones compatibles hacia atrás con seguridad.
 La manera de proporcionar compatibilidad hacia atrás de
nuevas características, como los fragmentos, es a través de
la biblioteca de funciones de apoyo (Support Library).
Ejemplos:
 v4 support: añade el soporte a los fragmentos para APIs
anteriores a la 11, entre otros aspectos.
 v7 appcompat : por ejemplo añade soporte a la barra de acción
(ActionBar) para APIs anteriores a la 11.

20
Versión 2.0
3. Plataformas
Versión de la plataforma API Level Versión de la plataforma API Level
Android 3.2 13 Android 4.0 14
Android 3.1.x 12 Android 4.0.3 15
Android 3.0.x 11 Android 4.1 16
Android 2.3.3, Android 2.3.4 10 Android 4.2 17
Android 2.3, Android 2.3.1, Android 2.3.2 9 Android 4.3 18
Android 2.0.1 6 Android 5.0.1 21
Android 2.0 5 Android 5.1.1 22
Android 1.1 2
Android 1.0 1

21
Versión 2.0
Estadísticas de tamaños de pantalla
3. Plataformas
Version Codename API
Distributio
n
2.2 Froyo 8 0.1%
2.3.3 - 2.3.7 Gingerbread 10 1.5%
4.0.3 - 4.0.4 Ice Cream Sandwich
15 1.4%
4.1.x Jelly Bean 16 5.6%
4.2.x 17 7.7%
4.3 18 2.3%
4.4 KitKat 19 27.7%
5.0 Lollipop 21 13.1%
5.1 22 21.9%
6.0 Marshmallow 23 18.7%
Fuente:
https://developer.android.com/about/dashboard
s/index.html
Data collected during a 7-day period ending
on September 5, 2016.
Any versions with less than 0.1%
distribution are not shown

22
Versión 2.0
Estadísticas de tamaños de pantalla
3. Plataformas
Fuente: https://developer.android.com/about/dashboards/index.html
ldpi mdpi tvdpi hdpi xhdpi xxhdpi Total
Small 1.6% 1.6%
Normal 3.5% 0.2% 39.5% 28.4% 15.5% 87.1%
Large 0.2% 4.1% 2.1% 0.5% 0.5% 7.4%
Xlarge 2.9% 0.3% 0.7% 3.9%
Total 1.8% 10.5% 2.3% 40.3% 29.6% 15.5%
Data collected during a 7-day
period ending on September
5, 2016.
Any versions with less than
0.1% distribution are not
shown

23
Versión 2.0
4. Arquitectura
 Los componentes del SO Android:
 Basado en la versión 2.6 del kernel de Linux
 Conjunto de librerías de que usa el SO.
 Runtime: Cada aplicación se ejecuta en su propio
proceso, una instancia de la maquina virtual
Dalvik/ART.
 Framework: Acceso completo a la API usada por las
aplicaciones base. Permite reutilización de capacidades
y componentes publicados.
 Aplicaciones: Escritas en Java. Algunas incluidas.
Otras disponibles en Google Play.

24
Versión 2.0
4. Arquitectura
 Los
desarrolladores
tienen acceso
completo a las
mismas APIs
usadas por las
aplicaciones del
núcleo.
 La arquitectura de
aplicación está
diseñada para
simplificar el
reusado de
componentes.

25
Versión 2.0
Framework
4. Arquitectura
 Cualquier aplicación
puede publicar sus
capacidades, y otras
aplicaciones pueden
usarlas (sujetas a las
medidas de seguridad
del framework).
 Este mecanismo
también permite que
otros componentes
sean reemplazados por
el usuario.

26
Versión 2.0
Framework
4. Arquitectura
 Por debajo de todas las aplicaciones existen un conjunto de
servicios y sistemas, entre los que se incluyen:
 Un rico y extensible conjunto de vistas, incluyendo listas, rejillas,
cajas de texto, botones, e incluso un navegador web embebible.
 Content Providers que permiten publicar datos para que otras
aplicaciones accedan a ellos.
 Un Resource Manager, que proporciona acceso a recursos fuera
del código como cadenas, imágenes, etc.
 Un Notification Manager que permite enviar alertas a la barra de
estado
 Un Activity Manager que maneja el ciclo de vida de las
aplicaciones y provee un pila de llamadas común para la
navegación entre aplicaciones (backstack).

27
Versión 2.0
 La forma más sencilla de desarrollar herramientas para Android es usando la
SDK de Android junto con Android Studio, ya sea en Windows, Mac OS, o
Linux.
 La SDK tiene los siguientes componentes (entre otros):
 SDK Tools (<sdk>/tools): Contiene las herramientas necesarias para la depuración y
prueba, además de otras utilidades necesarias para desarrollar aplicaciones. La más
útil y común es la utilidad abd (Android Debug Bridge).
 SDK Platform (<sdk>/platforms/<android-version>): Archivos android.jar para
construir la aplicación Android para cada versión disponible.
 Documentación (<sdk>/docs>: Es una copia offline de la última versión de la
documentación del API (JavaDocs).
 Proyectos de ejemplo (<sdk>/platforms/<android-version>/samples: Código
fuente de proyectos de ejemplo (ejemplo: ApiDemo), interesantes para empezar.
 usb-drivers: Directorio necesario para conectar el entorno de desarrollo con el
dispositivo Android.
 APIs de Google

28
Versión 2.0
 También es necesario para compilar y ejecutar la
Máquina Virtual: Dalvik VM o ART
 Una vez compilada la aplicación, la Android Developer
Tools permiten la aplicación en un paquete incluido en
el archivo:
androidManifest.xml
 SDK Manager: Permite mantener actualizada la SDK,
así como gestionar los paquetes que nos interesan.
 AVD Manager: Crea y mantiene los dispositivos
virtuales Android (AVDs)

29
Versión 2.0
 Android es una plataforma de relativa reciente creación, pero
de constante y rápido desarrollo. Por tanto, las fuente de
información disponibles son crecientes y cambiantes día a
día.
 Páginas soportadas/propiedad de Google:
o Página principal de desarrollo de Android:
http://developer.android.com/index.html
o Página oficial de Android: http://www.android.com/
o Android Source Project: http://source.android.com/index.html
o Google projects for Android: para añadir funciones a la SDK
como Google Maps, http://code.google.com/intl/es-ES/android/

30
Versión 2.0
 Otras páginas de la comunidad Android son:
o Android Developers: http://android-developers.blogspot.com/index.html
o Introduction to Android Development:
http://www.ibm.com/developerworks/opensource/library/os-android-devel/
o Android Wiki: http://en.androidwiki.com/wiki/Main_Page
o Android SO: http://en.wikipedia.org/wiki/Android_(operating_system)
 Página de Lars Vogel: http://www.vogella.com

31
Versión 2.0
Índice
2. Android Studio
3. Crear un programa “HolaMundo”
4. Tipos de aplicaciones Android

32
Versión 2.0
 Requisitos de
desarrollo:
 Entorno
de programación:
 Android Studio.
 SDK de Android
 Opcionales
 Herramientas gráficas
(Gimp por ejemplo)
 Herramientas de
control de versiones
(Git por ejemplo).

33
Versión 2.0
Instalación del SDK de Android
 Descargar Android Studio de la
pagina https://developer.android.com/develop/index.htm
l.
 Con las descarga e instalación de Android Studio se instala el
gestor de la SDK de Android: SDK Manager.
 Tener Java instalado en el ordenador, si no descargarlo
en http://www.oracle.com/technetwork/java/javase/down
loads/index-jsp-138363.html#javasejdk.
 Para el API 24 es obligatoria la versión 1.8 de Java SE.

34
Versión 2.0
Crear un AVD
2. Android Studio
 Desarrollo de aplicaciones para Android, tanto en móviles,
tablets, TV, Wear o gafas inteligentes.
 Compilador Gradle
 Creación de módulos dentro de un mismo proyecto.
 Distintas vistas de los proyectos.
 Gestión de dispositivos.
 Herramientas de desarrollo visual de interfaces avanzadas.
dependencies {
compile project(':my-library-module')
}

35
Versión 2.0
Crear un AVD
2. Android Studio
Para crear un
AVD:
En Android Studio,
seleccionar Tools>
Android >AVD
Manager
Create Virtual
Device

36
Versión 2.0
3. Crear un proyecto HolaMundo
En Android Studio seleccionar File>New> New project
Nombre del aplicación, dominio y ruta del proyecto
Elección de la API
Elección de la plantilla
Nombre de la acitivad y recurso para el diseño de pantalla

37
Versión 2.0

38
Versión 2.0

39
Versión 2.0
 Ante nosotros debería aparecer un código similar
siguiente en el fichero Java:
package com.example.helloandroid;
import android.app.Activity;
import android.os.Bundle;
public class HelloAndroid extends Activity {
/** Called when the activity is first created.*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}

40
Versión 2.0
 El programa por defecto está basado en la clase
Activity que se usa para ejecutar acciones, pero el
usuario solo interactúa con una a la vez.
 En el caso de estar empleando las bibliotecas de soporte
por compatibilidad la clase sería:
 android.support.v4.app.ActivityCompat (novedades después
de API 4)
 android.support.v13.app.ActivityCompat (novedades
después de API 13)
 El método onCreate es llamado por el sistema Android
cuando la aplicación empieza.

41
Versión 2.0
 Añadiendo las siguientes líneas en negrita usaremos
añadiremos un campo de texto:
package com.example.helloandroid;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class HelloAndroid extends Activity {
/** Called when the activity is first created.*/
@Override
TextView tv = new TextView(this);
tv.setText("Hello, Android");
setContentView(tv);
}
}

42
Versión 2.0
 Una interfaz de usuario de
Android está compuesta
de jerarquías de objetos de la
clase View.
 Cada uno de estos objetos es
una subclase de la clase View.
 Para mostrar textos no
editables se usaría TextView.
 Un contexto es una llamada al
sistema que provee servicios
como resolución de fuentes,
obtención de acceso a base de
datos y preferencias (setText
establece el contexto).
ViewGroup
ViewGroup
View View View
View View

43
Versión 2.0
Ejecutar
 Seleccionar Run > Run
 Se mostrará un cuadro de
diálogo para elegir un
emulador activo o móvil
conectado, o bien se permite
iniciar un nuevo emulador.
Emulador del Nexus
5X con Android 6.0

44
Versión 2.0
4. Tipos de aplicaciones
Los componentes o aplicaciones Android se clasifican
en:
 Activities: Aplicaciones con interfaz gráfica
 Services: Permiten la ejecución de código sin
necesidad de tener una interfaz gráfica. Aplican el
mismo concepto de los demonios de Linux
 Content providers: El administrador de información
persistente “Servidor de base de datos”, basado en
SQLite.
 Broadcast receivers: Aplicaciones que responden a
determinados eventos producidos por el sistema u otras
aplicaciones.

45
Versión 2.0
5. El fichero de manifiesto (AndroidManifest.xml)
 El fichero de manifiesto es donde el sistema comprueba
la existencia de un componente para poder así ser
iniciados.
 El fichero AndroidManifest.xml debe estar el directorio
raíz de la aplicación (donde están /src y /res).
https://developer.android.com/guide/topics/manifest/manif
est-intro.html

46
Versión 2.0
Elementos del AndroidManifiest.xml
 El nombre del paquete Java de la aplicación, el cual sirve como
identificador único de ésta.
 Los permisos de usuario que requiere la aplicación, tales como
el acceso a Internet o el acceso de lectura a los permisos de
usuario.
 Declarar el Nivel de API mínimo de la aplicación, basado en las
que la aplicación desea emplear.
 Declarar el hardware y el software que emplea la aplicación y
que son necesarios para su funcionamiento, como la cámara,
servicios bluetooth o pantalla multi-táctil.
 Cualquier API que se necesitan para enlazar (aparte de las del
framework Android) como Google Maps library.

47
Versión 2.0
Elementos del AndroidManifiest.xml
<?xml version="1.0" encoding="utf-
8"?>
<manifest>
<uses-permission />
<permission />
<permission-tree />
<permission-group />
<instrumentation />
<uses-sdk />
<uses-configuration />
<uses-feature />
<supports-screens />
<compatible-screens />
<supports-gl-texture />
<application>
<activity>
<intent-filter>
<action />
<category />
<data />
</intent-filter>
<meta-data />
</activity>
<activity-alias>
<intent-filter>...
</intent-filter>
<meta-data />
</activity-alias>
<service>
<intent-filter>...
</intent-filter>
<meta-data/>
</service>
<receiver>
<intent-filter>...
</intent-filter>
<meta-data />
</receiver>
<provider>
<grant-uri-permission />
<meta-data />
<path-permission />
</provider>
<uses-library />
</application>
</manifest>

48
Versión 2.0
Ejemplo de declaración de componentes
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
<application android:icon="@drawable/app_icon.png" ... >
<activity
android:name="com.example.project.ExampleActivity“
android:label="@string/example_label" ... >
</activity>
...
</application>
</manifest>

49
Versión 2.0
Ejemplo de declaración de un filtro para una aplicación de email
<manifest ... >
...
<application ... >
<activity android:name="com.example.project.ComposeEmailActivity">
<intent-filter>
<action android:name="android.intent.action.SEND" />
<data android:type="*/*" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</activity>
</application>
</manifest>

50
Versión 2.0
Ejemplo de permisos y características
<manifest ... >
<uses-feature android:name="android.hardware.camera.any"
android:required="true" />
<uses-sdk android:minSdkVersion="15" android:targetSdkVersion="24" />
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE"
android:maxSdkVersion="24" />
...
</manifest>
Establece la versión
máxima a la que
aplicar el permiso

51
Versión 2.0
Introducción
 Una actividad es sin duda el componente más habitual de las
aplicaciones para Android ya que es el que aporta el control de la
interfaz de usuario (UI).
 Un componente refleja una determinada actividad llevada
a cabo por una aplicación
 Lleva asociada típicamente una ventana o interfaz de usuario
 El aspecto gráfico forma parte del componente Activity a través de
vistas representadas por clases como ViewGroup, View y sus
derivadas.
 Este componente se implementa mediante la clase de mismo
nombre Activity.
 La mayoría de las aplicaciones permiten la ejecución de varias
acciones a través de la existencia de una o más pantallas.

52
Versión 2.0
Declaración de actividades
 Para poder pasar de una actividad a otra, y que la
aplicación la reconozca, debemos de declararla en el
AndroidManifiest.xml, si no se hace esto, cuando
invoquemos la otra actividad la aplicación dará un error
y no la mostrará.
<manifest ... >
<activity android:name=".Activity_2"></activity>
</manifest>

53
Versión 2.0
Actividad de inicio
 Para definir la actividad que se debe iniciar en una
aplicación se debe especificar en el fichero de
manifiesto:
<activity android:name=".MainActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>

54
Versión 2.0
Ciclo de vida de las actividades

55
Versión 2.0
Crear una nueva instancia de una actividad
 El sistema llama al método de la actividad.
 Debe incluir operaciones básicas de inicialización que se deben
hacer solamente una vez en la vida de la actividad.
 Después de se ejecutan y .
 Con , técnicamente la actividad se hace visible.
 El paso por los estados y es efímero, y solo se
interactúa con la aplicación en el estado .

56
Versión 2.0
Crear una nueva instancia de una actividad

57
Versión 2.0
Crear una nueva instancia de una actividad. Ejemplo
TextView mTextView;
@Override
public void onCreate( Bundle savedInstanceState){
setContentView(R.layout.main_activity);
mTextView = (TextView) findViewById(R.id.text_message);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
ActionBar actionBar = getActionBar();
actionBar.setHomeButtonEnabled(false);
}
}
Inicialización
condicionada a
la versión.
Android 2.0
(API level 5) y
superiores
Donde se
reciben los
datos
almacenados
tras un re-
creado de la
actividad

58
Versión 2.0
Destruir una actividad
 El sistema llama a método cuando va a eliminar
completamente la instancia de la actividad de la memoria.
 No es necesario implementar este método ya que la limpieza de
recursos se debe hacer prioritariamente en .
 En se deben eliminar tareas en segundo plano que se
crearan en el método u otros procesos de larga
duración que pueden consumir recursos y que podrían no ser
convenientemente eliminados.
 El método siempre lo llama el sistema después de
y salvo en una situación: cuando se ejecuta
dentro del método .

59
Versión 2.0
Pausar una actividad
 Cuando el sistema llama al método de una
actividad indica:
 La actividad es aún parcialmente visible pero el usuario la
está dejando.
 Pronto será llamado el método .

60
Versión 2.0
 Qué se debe hacer en el método :
 Parar operaciones que puedan consumir CPU como
animaciones.
 Almacenar los cambios no guardados, pero solamente si el
usuario espera volver a encontrarlos si vuelve a entrar en la
aplicación. Ejemplo: un borrador de un correo electrónico o un
documento a medio escribir.
 Liberar recursos de sistema como broadcast receivers, sensores
(como el GPS) o cualquier otro que puede afectar a la batería
mientras la aplicación no lo necesita.

61
Versión 2.0
 Qué NO se debería hacer en el método :
 Largas y costosas operaciones como almacenamiento en
bases de datos.
 Almacenar datos temporales de usuario en
almacenamiento persistente (salvo que sí fuera necesario
en la aplicación).
 Las operaciones en el método deben ser
simples, de manera que permitan un rápida transición
entre esa actividad y el siguiente paso del usuario.

62
Versión 2.0
Ejemplo método onPause()
@Override
public void onPause() {
super.onPause(); //Siempre llamar a este
//método de la superclase primero
// Liberar la cámara porque no se necesita
// y otras actividades podrán así usarla
if (mCamera != null) {
mCamera.release();
mCamera = null;
}
}

63
Versión 2.0
Retomando la actividad, onResume()
 El método se llama siempre que una
actividad vuelve al primer plano, incluso la primera vez
que se ejecuta.
 Se debe emplear para:
 Inicializar componentes que se liberan en .
 Realizar otros procesos de inicialización necesarios
cuando se vuelve del estado de pausa.

64
Versión 2.0
Retomando la actividad. Ejemplo
@Override
public void onResume() {
super.onResume(); //Siempre este método primero
// Obtener una instacia de la cámara
if (mCamera == null) {
initializeCamera(); // Médoto local de
// inicialización de la cámara
}
}

65
Versión 2.0
Parar y reiniciar una Actividad
 Se debe conseguir que tras parar y reiniciar una aplicación el usuario
tenga la sensación de que ésta siempre ha estado activa.

66
Versión 2.0
Parar y reiniciar una Actividad. Escenarios clave
 El usuario, a través de Aplicaciones
Recientes (AR) cambia a otra
aplicación, para más tarde volver a la
misma a través del icono en el menú
Home o del AR de nuevo.
 El usuario realiza una acción en la
aplicación que le hace cambiar a una
nueva actividad. La primera actividad
se para y la nueva se crea. Si el
usuario pulsa el botón de
Volver(Back) la primera actividad se
reinicia.
 El usuario recibe una llamada de
teléfono cuando está usando una
aplicación en su móvil.

67
Versión 2.0
Parar y reiniciar una Actividad. Métodos
 En el estado Parado (Stopped) el
interfaz de usuario (UI) no está
visible de ninguna manera.
 El sistema proporciona nos
métodos dentro del ciclo de vida:
 Método .
 Método : no hay una
guía concreta de qué poner en
este método, conviniendo que es
mejor realizar las tareas de reinicio
en onStart().
Como el sistema mantiene en
memoria a la actividad cuando se
para, es posible que no haga falta
implementar onStop() y onRestart() e
incluso onStart(). Para la mayoría de
actividades que son relativamente
simples basta con implementar
onPause() conforme se ha visto.

68
Versión 2.0
Parar una Actividad. onStop()
 La actividad ya no es visible.
 Se deben liberar todos los recursos que no se van a
utilizar mientras el usuario está sin usarlos.
 El sistema puede destruir la instancia de la actividad si
necesita recuperar memoria.
 En casos extremos el sistema puede simplemente matar
el proceso de la aplicación, por lo que no se llamaría a
onDestroy().

69
Versión 2.0
Recrear una actividad
 Existen pocos casos en los
que una actividad es
destruida:
 El usuario pulsa el botón volver
y se ejecuta el método
porque así se implementó.
 La actividad está en el estado
Parado y lleva mucho tiempo
en segundo plano, o el sistema
necesita más recursos y la
elimina.
El sistema estima que como la
aplicación ha terminado por su
propia iniciativa, no es necesario
guardar el estado
El sistema guarda el estado de la
aplicación en un objeto de tipo
ya que la aplicación fue
eliminada y podría volver a primer
plano por la actuación del usuario.

70
Versión 2.0
 El sistema guarda en el objeto
toda la información que
contenían elementos de la interfaz
de usuario, como los campos de
edición, y el implementador no
necesita tenerlos en cuenta.
 Para esto todas las vistas deben
tener un identificador único.
El sistema destruye y re-crea
una actividad cada vez que el
usuario gira la pantalla ya que
las dimensiones cambian y la
actividad puede necesitar
cargar nuevos recursos.

71
Versión 2.0

72
Versión 2.0
Recrear una actividad. Guardar el estado
static final String STATE_SCORE = "playerScore";
static final String STATE_LEVEL = "playerLevel";
...
@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
// Se guarda el estado de algunas variables de usuario
savedInstanceState.putInt(STATE_SCORE, mCurrentScore);
savedInstanceState.putInt(STATE_LEVEL, mCurrentLevel);
// Siempre se debe llamar a la superclase para
// guardar el estado de la jerarquía de vistas
super.onSaveInstanceState(savedInstanceState);
}

73
Versión 2.0
Recrear una actividad. Recuperar el estado I
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); // Siempre llamar a la
// superclase primero
// Se comprueba si se está recreando una instancia
// previamente destruida
if (savedInstanceState != null) {
// Restaurar los valores del estado guardado
mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
} else {
// Iniciar miembros con valores por defecto
// para una nueva instancia
}
...
}

74
Versión 2.0
Recrear una actividad. Recuperar el estado II
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
// Siempre se debe llamar a la superclase para
// restaurar la jerarquía de vistas
super.onRestoreInstanceState(savedInstanceState);
// Restaurar los valores del estado guardado
mCurrentScore = savedInstanceState.getInt(STATE_SCORE);
mCurrentLevel = savedInstanceState.getInt(STATE_LEVEL);
}

75
Versión 2.0
Comunicación entre actividades
 Este código sería la llamada desde la primera actividad, donde
ACTIVIDAD ACTUAL es la actividad donde nos encontramos
 ACTIVIDAD SIGUIENTE sería el nombre de la siguiente actividad
donde queremos ir.
 IDENTIFICADOR es el dato que queremos pasar desde
ACTIVIDAD ACTUAL a ACTIVIDAD SIGUIENTE.
 El código “id” es el nombre con el cual llamaremos en ACTIVIDAD
SIGUIENTE para recuperar el valor.
Intent intent = new Intent(ACTIVIDAD ACTUAL,
ACTIVIDAD SIGUIENTE );
intent.putExtra("id", IDENTIFICADOR);
startActivity(intent);

76
Versión 2.0
Comunicación
 Este código habría que ejecutarlo al inicio de la
segunda actividad, en el método por
ejemplo, y recoge los datos que le has enviado
anteriormente, en este caso al haber añadido un entero
hay que poner getInt().
Bundle bundle = getIntent().getExtras();
if(bundle!=null){
id = extras.getInt("id");
}

77
Versión 2.0
 En Android, la interfaz de usuario se
crea utilizando objetos y
.
 Hay muchos tipos de View y
ViewGroup, cada uno de los cuales es
descendiente de la clase View.
 Los y han de estar
contenidos en algún elemento.
 Estos elementos son los diseños o
planos , que contienen otros
elementos presentes en una vista.

78
Versión 2.0
 View: una estructura de datos que permite establecer el layout y el
contenido de la pantalla.
 Maneja las medidas, el diseño, los gráficos, el enfoque de los elemento,
el desplazamiento y las interacciones dentro de la pantalla en la que
reside.
 Funciona como base para artilugios o (conjunto de
subclases ya implementadas en Java que permiten mostrar elementos
de pantalla interactivos).
 ViewGroup: objetos cuya función es almacenar y manejar
conjuntos de objetos View y ViewGroup hijos.

79
Versión 2.0
Jerarquía de elementos
79
Este sería un ejemplo de la
jerarquía de elementos de
visualización en un layout
típico.
ViewGroup
View View ViewGroup
View
View

80
Versión 2.0
2. Layouts
 Los layouts son elementos no visuales destinados a
controlar la distribución, posición y dimensiones de los
controles que se insertan en su interior.
 Extienden a la clase base ViewGroup, como muchos
otros componentes contenedores
 Es capaz de contener a otros controles.

81
Versión 2.0
2. Layouts
 En Android, el diseño y la lógica de una pantalla están
separados en dos ficheros distintos.
 Un fichero donde tenemos el diseño puramente visual de la
pantalla, definido como fichero XML,
 Un fichero que contiene el código java que determina la lógica
de la pantalla, normalmente derivando de la clase Activity.

82
Versión 2.0
2. Layouts
Los principales tipos de Layout que se van a
estudiar en este apartado son:
 Linear Layout.
 Table Layout.
 Relative Layout.
 Frame Layout.

83
Versión 2.0
2. Layouts
 Existen otros tipos diferentes de layout, que no serán
vistos aquí, que permiten interfaces más ricos y
vistosos.
 Podrán ser encontrados en el material de referencia o en
la web, y
 Entre otros:
 View flipper
 View Switcher
 Coordinator Layout
 ConstraintLayout
 RecyclerView

84
Versión 2.0
LinearLayout
2. Layouts
 Es uno de los layout más simples que se pueden utilizar.
 Los elementos se irán colocando uno a continuación de otro. Se
puede indicar si la colocación lineal se hará de forma:
 Vertical
 u horizontal.
 En la propiedad “orientación” asume los valores horizontal o
vertical.

85
Versión 2.0
LinearLayout. Ejemplo
2. Layouts
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<Button android:text="Button01" android:id="@+id/Button01"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
</LinearLayout>

86
Versión 2.0
LinearLayout. Weight y Gravity
2. Layouts
 La propiedad weight permite asignar importancia a las vistas
contenidas en un layout para que el espacio libre se reparta
proporcionalmente al peso asignado a cada una.
 Así, en un linear layout con un botón con weight=1 y dos campos
de texto con weight=0, el botón se repartirá todo el espacio libre
restante.
 La propiedad gravity permite alinear la vista con respecto a su
contenedor
 Es básicamente un alineamiento: derecha, izquierda, arriba, abajo…

87
Versión 2.0
TableLayout
2. Layouts
 Es un modelo de organización basado en
Tablas.
 El diseño se organiza en filas y dentro de
cada fila se incluyen los elementos.
 No dibuja líneas de separación entre filas,
columnas o celdas.
 Puede haber celdas vacías, pero no se
pueden agrupar celdas como en las tablas
HTML.
 Cada fila de una tabla es una nueva vista
de la clase

88
Versión 2.0
TableLayout. TableRow
2. Layouts
 Pueden tener ninguna o más celdas.
 Cada celda es una vista de otro tipo, incluso un ViewGroup, como
un nuevo TableLayout.
 Las celdas se pueden ocultar (collapse), estirarse (stretch) para
que se repartan el espacio o encogerse (shrink) para que quepan
en la vista.
 android:collapseColumns = "1,3"
 android:stretchColumns = "1"
 android:shrinkColumns = "*"

89
Versión 2.0
Table layout. Ejemplo
2. Layouts
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="match_parent"
android:stretchColumns="1">
<TableRow>
<TextView
android:text="@string/table_layout_4_open"
android:padding="8dp" />
<TextView
android:text="@string/table_layout_4_open_shortcut"
android:gravity="right"
android:padding="8dp" />
</TableRow>
…
</TableLayout>

90
Versión 2.0
Relative layout
2. Layouts
 Es el mas flexible de todos. Los elementos se colocan relativos a
otro elemento o a otro layout.
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
<TextView
android:id="@+id/e19_title"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:text="@string/e19_title"/>
<Button
android:id="@+id/e19_connect"
android:layout_below="@+id/e19_title"
android:layout_centerHorizontal="true"
android:layout_marginTop="@dimen/activity_vertical_margin"
android:onClick="onConnect"
android:text="@string/e19_button_connect" />
</RelativeLayout>

91
Versión 2.0
Frame layout
2. Layouts
 Este layout consiste en un marco que ocupa toda la
pantalla y donde los controles se disponen a partir de la
esquina superior izquierda, hay que tener cuidado de
no dejar elementos ocultos por otros elementos.
 Se utiliza como base para otros layout complejos o
animados como los desplegables (Drawers)

92
Versión 2.0
 En las siguientes diapositivas vamos a hacer un repaso
de los diferentes controles que la plataforma de
desarrollo Android pone a nuestra disposición.
 Botones: Button, ToggleButton, ImageButton.
 ImageView.
 TextView.
 EditText.
 Interfaz Spanned.
 CheckBox.
 RadioButton.

93
Versión 2.0
Botón normal (Button)
 Un control de tipo Button es el botón más básico que podemos utilizar.
 Sus propiedades mas usuales:
 android:text para indicar el texto del botón.
 android:background, indicar el fondo.
 android:typeface, estilo de la fuente.
 android:textSize, tamaño de la fuente.
<Button android:id="@+id/BtnBoton1"
android:text="Púlsame"

94
Versión 2.0
Botón con estado (ToggleButton)
Este tipo de botón que puede permanecer en dos estados, pulsado
o no pulsado
 En vez de definir un sólo texto para el control definiremos dos,
dependiendo de su estado.
Así, podremos asignar las propiedades android:textOn y android:textoOff
para definir ambos textos.
<ToggleButton android:id="@+id/BtnBoton2"
android:textOn="ON"
android:textOff="OFF"

95
Versión 2.0
Botón de imagen (ToggleButton)
 Un ImageButton, con este control podremos definir una imagen a
mostrar en vez de un texto, para lo que deberemos asignar la
propiedad android:src.
 Normalmente asignaremos esta propiedad con el descriptor de algún
recurso que hayamos incluido en la carpeta /res/drawable.
<ImageButton android:id="@+id/BtnBoton3"
android:src="@drawable/ok" />

96
Versión 2.0
Botones. Eventos
 Aunque estos controles pueden lanzar muchos otros eventos, el más común de
todos ellos y el que querremos capturar en la mayoría de las ocasiones es el evento
onClick.
 Para definir la lógica de este evento tendremos que implementarla definiendo un
nuevo objeto View.OnClickListener() y asociándolo al botón mediante el método
setOnClickListener().
 La forma más habitual de hacer esto es la siguiente:
final Button btnBoton1 = (Button)findViewById(R.id.BtnBoton1);
btnBoton1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0){
lblMensaje.setText("Botón 1 pulsado!");
}});

97
Versión 2.0
Botones. Eventos
 En el caso de un botón de tipo ToggleButton suele ser de utilidad conocer en
qué estado ha quedado el botón tras ser pulsado, para lo que podemos utilizar
su método isChecked().
 En el siguiente ejemplo se comprueba el estado del botón tras ser pulsado y
se actúa según el resultado.
final ToggleButton btnBoton2 = ToggleButton)findViewById(R.id.BtnBoton2);
btnBoton2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0)
{
if(btnBoton2.isChecked()) lblMensaje.setText("Botón 2: ON");
else lblMensaje.setText("Botón 2: OFF");
} });

98
Versión 2.0
Control ImageView
 El control ImageView permite mostrar imágenes en la aplicación.
Las propiedades más interesante del control:
 android: src, se indica el origen de la imagen a mostrar. Lo normal será
indicar una imagen de la carpeta /res/drawable de nuestro proyecto.
 android:maxWidth, indica el ancho máximo.
 android:maxHeight, indica la altura máxima.
<ImageView android:id="@+id/ImgFoto"
android:src="@drawable/icon" />

99
Versión 2.0
Control TextView
 El control TextView, las etiquetas de texto, se utiliza para mostrar un
determinado texto al usuario.
 El control tiene las siguientes propiedades:
android:text, nos permite indicar el texto del control.
android:background, color de fondo.
android:textColor, color del texto.
android:textSize, tamaño de la fuente.
android:typeface, estilo del texto: negrita, cursiva, …
<TextView android:id="@+id/LblEtiqueta"
android:layout_width="fill_parent"
android:text="Escribe algo:"
android:background="#AA44FF"
android:typeface="monospace" />

100
Versión 2.0
Control EditText
 El control EditText es el componente de edición de texto que
proporciona la plataforma Android.
 Permite la introducción y edición de texto por parte del usuario.
 La propiedad más interesante a establecer, en tiempo de diseño,
es el texto a mostrar, atributo android:text.
<EditText android:id="@+id/TxtTexto"
android:layout_below="@id/LblEtiqueta" />

101
Versión 2.0
Interfaz Spanned
 Un objeto de tipo Spanned es como una cadena de caracteres en la que
podemos insertar otros objetos a modo de marcas o etiquetas (spans)
asociados a rangos de caracteres.
 De esta interfaz deriva la interfaz Spannable, que permite la modificación
de estas marcas.
 Existen muchos tipos de spans predefinidos en la plataforma Android que
podemos utilizar para dar formato al texto, entre ellos:
 TypefaceSpan, modifica el tipo de fuente.
 StyleSpan, modifica el estilo del texto (negrita, cursiva, …).
 ForegroudColorSpan, modifica el color del texto.
 AbsoluteSizeSpan, modifica el tamaño de fuente.

102
Versión 2.0
Interfaz Spanned
 Los controles EditText poseen este interfaz y permiten modificaciones de
este tipo.
 Sin embargo los controles TextView no poseen esta capacidad.
//Creamos un nuevo objeto de tipo Editable
Editable str = Editable.Factory.getInstance().newEditable("Esto es un simulacro.");
//Marcamos cono fuente negrita la palabra "simulacro"
str.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), 11, 19,
Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

103
Versión 2.0
Control CheckBox
 Un control CheckBox se suele utilizar para marcar o desmarcar
opciones en una aplicación. La forma de definirlo en nuestra
interfaz y los métodos disponibles para manipularlos desde nuestro
código son análogos a los ya comentados para el control
ToggleButton.
<CheckBox android:id="@+id/ChkMarcame"
android:text="Márcame!" />

104
Versión 2.0
Control CheckBox
 En el código de la aplicación podremos hacer uso de los métodos
isChecked() para conocer el estado del control, y
setChecked(estado) para establecer un estado concreto para el
control.
if (checkBox.isChecked())
{
checkBox.setChecked(false);
}

105
Versión 2.0
Control CheckBox
 En cuanto a los posibles eventos que puede lanzar este control, el más
interesante es el que informa de que ha cambiado el estado del control,
que recibe el nombre de onCheckedChanged.
 Un ejemplo de implementación:
final CheckBox cb = (CheckBox)findViewById(R.id.chkMarcame);
cb.setOnCheckedChangeListener(
new CheckBox.OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView,
boolean isChecked) {
if (isChecked) {
cb.setText("Checkbox marcado!");
}
else {
cb.setText("Checkbox desmarcado!");
}}});

106
Versión 2.0
Control RadioButton
 Un RadioButton es un grupo de opciones donde una, y sólo una, de ellas
debe estar marcada obligatoriamente, es decir, que si se marca una de
ellas se desmarcará automáticamente la que estuviera activa
anteriormente.
 Un grupo de botones RadioButton se define mediante un elemento
RadioGroup, que a su vez contendrá todos los elementos RadioButton
necesarios.
<RadioGroup android:id="@+id/gruporb"
android:orientation="vertical"
android:layout_height="fill_parent" >
<RadioButton android:id="@+id/radio1” android:text="Opción 1" />
<RadioButton android:id="@+id/radio2“ android:text="Opción 2" />
</RadioGroup>

107
Versión 2.0
Control RadioButton
 Una vez definida la interfaz podremos manipular el control
haciendo uso de los diferentes métodos del control RadioGroup,
los más importantes:
 check(id), para marcar una opción determinada mediante su ID.
 clearCheck(), para desmarcar todas las opciones.
 getCheckedRadioButtonId(), que devuelve el ID de la opción marcada.
final RadioGroup rg = (RadioGroup)findViewById(R.id.gruporb);
rg.clearCheck();
rg.check(R.id.radio1);
int idSeleccionado = rg.getCheckedRadioButtonId();

108
Versión 2.0
Control RadioButton
 En cuanto a los eventos lanzados, el más importante será el que informa
de los cambios en el elemento seleccionado, llamado onCheckedChange.
 Un ejemplo de lógica asociada al evento:
final RadioGroup rg = (RadioGroup)findViewById(R.id.gruporb);
rg.setOnCheckedChangeListener(
new RadioGroup.OnCheckedChangeListener() {
public void onCheckedChanged(RadioGroup group, int checkedId) {
lblMensaje.setText("ID opcion seleccionada: " + checkedid);
}
});

109
Versión 2.0
Controles de selección
 Al igual que en otros frameworks, Android dispone de
diversos controles que nos permiten seleccionar una
opción dentro de una lista de posibilidades.
 Spinner, listas desplegables.
 ListView, listas fijas.
 GridView, tablas.
 Gallery, controles específicos de la plataforma, galerías de
imágenes.

110
Versión 2.0
Adaptadores en Adroid (adapters)
 Un elemento importante y común a todos los controles de
selección, son los adaptadores.
 Un adaptador representa algo así como una interfaz común al modelo
de datos que existe por detrás de todos los controles de selección que
hemos comentado.
 Dicho de otra forma, todos los controles de selección accederán a los
datos que contienen a través de un adaptador.
 Además de proveer de datos a los controles visuales, el adaptador
también será responsable de generar, a partir de estos datos, las
vistas específicas que se mostrarán dentro del control de
selección.

111
Versión 2.0
Adaptadores en Adroid (adapters)
 Android proporciona de forma estándar varios tipos de adaptadores
sencillos que permiten manejar la información que muestran los controles
que derivan de AdapterView , tales como ListView, GridView, Spinner o
Gallery. Aunque podemos extender su funcionalidad fácilmente para
adaptarlos a nuestras necesidades. Los adaptadores más comunes son
los siguientes:
 ArrayAdapter, es el más sencillo, y provee de datos a un control de selección a
partir de un array de objetos de cualquier tipo.
 SimpleAdapter, se utiliza para mapear datos sobre los diferentes controles
definidos en un fichero XML de layout.
 SimpleCursorAdapter, se utiliza para mapear las columnas de un cursor sobre
los diferentes elementos visuales contenidos en el control de selección.

112
Versión 2.0
Adaptador ArrayAdapter
final String[] datos = new String[]{"Elem1","Elem2","Elem3","Elem4","Elem5"};
ArrayAdapter<String> adaptador =new
ArrayAdapter<String>(this,android.R.layout.simple_spinner_item, datos);
 La primera línea contiene la definición del array con los datos a mostrar.
 En la segunda línea se crea el adaptador, al que pasamos 3 parámetros:
 El contexto (this), que normalmente será una referencia a la actividad donde se crea el
adaptador.
 El ID (android.R.layout.simple_spinner_item), del layout sobre el que se mostrarán los datos
del control. En este caso le pasamos el ID de un layout predefinido en Android, pero
podríamos pasarle el ID de cualquier layout de nuestro proyecto.
 El array (datos) que contiene los datos a mostrar.
 Con esto ya tendríamos creado nuestro adaptador.

113
Versión 2.0
Control Spinner
 Las listas desplegables en Android se llaman Spinner.
 Funcionan de forma similar al de cualquier control de este tipo, el usuario
selecciona la lista, se muestra una especie de lista emergente con todas
las opciones disponibles y al seleccionarse una de ellas ésta queda fijada
en el control.
<Spinner android:id="@+id/CmbOpciones"

114
Versión 2.0
Control Spinner
 Para enlazar el adaptador, y por tanto los datos, a este control utilizaremos
el siguiente código java:
final Spinner cmbOpciones =
(Spinner)findViewById(R.id.CmbOpciones);
adaptador.setDropDownViewResource(
android.R.layout.simple_spinner_dropdown_item);
cmbOpciones.setAdapter(adaptador);

115
Versión 2.0
Control Spinner
 En cuanto a los eventos lanzados por el control Spinner, el más
utilizado será el generado al seleccionarse una opción de la lista
desplegable, onItemSelected.
 Para capturar este evento se procede de forma similar a lo ya visto
para otros controles, asignándole su controlador mediante el
método setOnItemSelectedListener():

116
Versión 2.0
Control Spinner
cmbOpciones.setOnItemSelectedListener(
new AdapterView.OnItemSelectedListener() {
public void onItemSelected(AdapterView<?> parent,
android.view.View v, int position, long id){
lblMensaje.setText("Seleccionado: " + datos[position]); }
public void onNothingSelected(AdapterView<?> parent) {
lblMensaje.setText(""); }
});
 Para este evento definimos dos métodos, (onItemSelected) que será
llamado cada vez que se seleccione una opción en la lista desplegable, y
el segundo (onNothingSelected) que se llamará cuando no haya ninguna
opción seleccionada.

117
Versión 2.0
Control ListView
 El control ListView muestra al usuario una lista de opciones seleccionables
directamente sobre el propio control. En caso de existir más opciones de las que se
pueden mostrar sobre el control se podrá hacer scroll sobre la lista para acceder al
resto de elementos.
<ListView android:id="@+id/LstOpciones"

118
Versión 2.0
Control ListView
 Para enlazar los datos con el control definiremos primero un array con nuestros
datos, crearemos posteriormente el adaptador de tipo ArrayAdapter y lo
asignaremos al control mediante el método setAdapter().
final String[] datos =
new String[]{"Elem1","Elem2","Elem3","Elem4","Elem5"};
ArrayAdapter<String> adaptador = new ArrayAdapter<String>(this,
android.R.layout.simple_list_item_1, datos);
ListView lstOpciones = (ListView)findViewById(R.id.LstOpciones);
lstOpciones.setAdapter(adaptador);

119
Versión 2.0
Control ListView
 Si quisiéramos realizar cualquier acción al pulsarse sobre un elemento de la lista
creada tendremos que implementar el evento onItemClick.
lstOpciones.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> a, View v, int position, long id) {
//Acciones necesarias al hacer click
}
});

120
Versión 2.0
Control GridView
 El control GridView de Android presenta un conjunto de opciones
seleccionables distribuidas de forma tabular, o dicho de otra forma,
divididas en filas y columnas. Dada la naturaleza del control las
propiedades más importantes:
 android:numColumns, indica el número de columnas de la tabla.
 android:columnWidth, indica el ancho de las columnas de la tabla.
 android:horizontalSpacing, indica el espacio horizontal entre celdas.
 android:verticalSpacing, indica el espacio vertical entre celdas.
 android:stretchMode, indica qué hacer con el espacio horizontal sobrante.
 Si se establece al valor “columnWidth” este espacio será absorbido a
partes iguales por las columnas de la tabla. Si por el contrario se establece
a “spacingWidth” será absorbido a partes iguales por los espacios entre
celdas.

121
Versión 2.0
Control GridView
 Ejemplo de definición de un GridView:
<GridView android:id="@+id/GridOpciones"
android:layout_height="fill_parent"
android:numColumns="auto_fit"
android:columnWidth="80dp"
android:horizontalSpacing="5dp"
android:verticalSpacing="10dp"
android:stretchMode="columnWidth" />

122
Versión 2.0
Control GridView
 La forma de asignar los datos desde el código de la aplicación es
análoga a la comentada para las listas desplegables o para las
listas estáticas:
 creamos un array genérico que contenga nuestros datos de prueba,
 declaramos un adaptador de tipo ArrayAdapter pasándole en este caso
un layout genérico (simple_list_item_1, compuesto por un simple
TextView) y asociamos el adaptador al control GridView mediante su
método setAdapter():

123
Versión 2.0
Control GridView
private String[] datos = new String[25];
//...
for(int i=1; i<=25; i++)
datos[i-1] = "Dato " + i;
ArrayAdapter<String> adaptador =
new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, datos);
final GridView grdOpciones = (GridView)findViewById(R.id.GridOpciones);
grdOpciones.setAdapter(adaptador);
 Por defecto, los datos del array se añadirán al control GridView ordenados por filas,
si no caben todos en la pantalla se podrá hacer scroll sobre la tabla.

124
Versión 2.0
Control GridView
 En cuanto a los eventos disponibles, el más interesante es el lanzado al
seleccionarse una celda determinada de la tabla: onItemSelected.
 Este evento podemos capturarlo de la misma forma que hacíamos para los otros
controles.
grdOpciones.setOnItemSelectedListener(
new AdapterView.OnItemSelectedListener() {
public void onItemSelected(AdapterView<?> parent,
android.view.View v, int position, long id) {
lblMensaje.setText("Seleccionado: " + datos[position]);
}
public void onNothingSelected(AdapterView<?> parent) {
lblMensaje.setText("");
}
});

125
Versión 2.0
4. Eventos
 En Android como en otros sistemas la interacción del usuario con el sistema es
modelada con eventos.
 Si una aplicación quiere enterarse y responder a una interacción del usuario ha de
añadir la lógica apropiada para detectar y procesar el evento.
 Un evento encapsula la información necesaria para que el manejador de la
aplicación pueda tratar esa entrada.
 Android trata los eventos mediante:
 Event Handler: maneja los eventos de entrada sin importar donde está el foco. No están
necesariamente asociados a una vista. Ej: pulsar el Botón atrás, tocar la pantalla. Distintos
ejemplos de eventos:
 onKeyUp: Se libera una tecla
 onKeyDown: Se pulsa una tecla
 onTouchEvent: Se toca la pantalla
 onTrackballEvent: Se aprieta/mueve el trackball
 onBackPressed: Se pulsa el botón atrás
 etc.

126
Versión 2.0
Event Listener
4. Eventos
 Event Listener: escuchan eventos generados por una View
o ViewGroup. Cada Event Listener tiene solo un método
callback, que será llamado por el framework Android cuando
el usuario interactúa con la vista. Ej.: onClick, onLongClick,
onFocusChanged.
 Un EventListener escucha eventos generados por una vista.
Previamente es necesario registrarlo mediante el método
setOnXXXListener apropiado.
 Ya se han definido varios ejemplos de manejo de eventos en
la exposición anterior de los distintos controles.

127
Versión 2.0
5. Menús
 Los menús son una parte importante de una aplicación que
proporciona una interfaz sencilla para que el usuario pueda
acceder a las distintas funciones de las aplicaciones.
 Android ofrece una interfaz de programación fácil para el desarrollo
de menús.
 Android ofrece tres tipos de menús:
 Options Menu, es el menú principal de un Activity, aparece cuando el usuario
pulsa la tecla Menú del dispositivo.
 Contex Menu, es un menú flotante que el usuario crea en una aplicación y que
es desplegado dentro de determinados contextos.
 Pop-up Menu, menús que aparecen cuando el usuario pulsa determinados
elementos de un menú.

128
Versión 2.0
Nota sobre el uso del botón Menú
5. Menús
 Desde la versión de Android 3.0 (API level 11), los
dispositivos que usen Android no se les exige que
proporcionen un botón exclusivo de Menú.
 Las aplicaciones migraron para proporcionar una barra de
acción para las acciones comunes de usuario en vez del
típico panel de menú de 6 elementos.
 Sin embargo, a pesar de que el diseño y la experiencia de
usuario cambiaron, la forma de definir las acciones y
opciones basadas en menús siguen siendo a través del API
de Menús.

129
Versión 2.0
Options menu
5. Menús
 El menú de opciones es donde se deben incluir las opciones básicas de
una aplicación y los elementos necesarios para la navegación.
 El usuario puede abrir el menú de opciones con la tecla de menú del dispositivo,
o a través de la barra de acción en versiones 3.0 o superiores.
 Se pueden definir menús de opciones tanto en una Activity como en un
Fragment.
 Si tanto la Activity como los fragmentos que la forman declaran un menú, todos
aparecerán, primero los de la Activity y luego los de los fragmentos en el orden
en el que se añadieron a la Activity.
 Si se quiere establecer un orden concreto para los elementos de un menú
se puede añadir la opción android:orderInCategory a los elementos
de un menú que se deseen.

130
Versión 2.0
Forma de aparición de los menús en la UI
5. Menús
 Si la aplicación ha sido desarrollada
para Android 2.3.x (API level 10) o
menor, el contenido del menú de
opciones aparecerá en la parte baja de
la pantalla cuando el usuario presione
el botón Menú.
 Android ubicará hasta un máximo de
seis elementos
 Si el menú tiene más elementos, se
mostrarán sólo cinco y el resto se
accederá en un menú adicional (overflow
menu) pulsando el botón “Más (More)”.

131
Versión 2.0
Forma de aparición de los menús en la UI
5. Menús
 Si la aplicación ha sido desarrollada para Android 3.0 (API level 11) y
superiores, los elementos del menú de opciones aparecerán en la
barra de acción.
 Por defecto, la aplicación coloca todos los elementos en el botón de
desbordamiento de acciones (action overflow – tres putitos verticales en la
parte derecha de la barra de acción).
 Se puede dar mayor facilidad de acceso a algunos de esos elementos a
través de la propiedad android:showAsAction="ifRoom“ en el
elemento <item> correspondiente.

132
Versión 2.0
Options menu
5. Menús
 Cuando el usuario abre el menú de opciones, por primera vez, Android
hace una llamada al método onCreateOptionsMenu() del Activity.
 Los Fragments tienen su propio onCreateOptionsMenu() que es el que
debe ser usado con el fin de mostrar su menú.
 Cuando se selecciona un elemento de menú, el sistema llama al método
onOptionsItemSelected().
 Este método pasa el MenuItem seleccionado. Se puede identificar el elemento
de menú seleccionado con la llamada a getItemId(), que devuelve el
identificador del elemento seleccionado.

133
Versión 2.0
Options menu
5. Menús
 Crear un menú de opciones desde un recurso XML
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.main_menu, menu);
return true;
}

134
Versión 2.0
Options menu. Ejemplo
5. Menús
<menu
xmlns:android="http://schemas.android.com/apk/res/android
">
<item android:id="@+id/menu_settings"
android:title="@string/menu_settings"
android:orderInCategory="100"/>
<item android:id="@+id/menu_help"
android:title="@string/menu_help"
android:orderInCategory="200"
android:icon="@drawable/ic_menu_help"/>
</menu>

135
Versión 2.0
Options menu
5. Menús
 Crear un menú con código fuente:
public boolean onCreateOptionsMenu(Menu menu)
{
menu.add(0,EDIT_CONTACT,0,"Edit Contact");
menu.add(0,DELETE_CONTACT,0,"Delete Contact");
menu.add(0,EXIT,0,"Exit");
return true;
}

136
Versión 2.0
Options menu – Manejar los eventos
5. Menús
public boolean onOptionsItemSelected (MenuItem item){
switch (item.getItemId()){
case EDIT_CONTACT:
/* Actions in case that Edid Contacts is pressed */
return true;
case DELETE_CONTACT :
/* Actions in case that Delete Contact is pressed */
return true;
}
}

137
Versión 2.0
Context menu
5. Menús
 Un menú contextual es conceptualmente similar al menú que aparece cuando se
pulsa "botón derecho del ratón“.
 Se debe usar un menú contextual para proporcionar acceso a las acciones que pertenecen a
un elemento específico en la interfaz de usuario.
 En Android, un menú contextual se muestra cuando el usuario realiza una "pulsación larga"
(mantener presionado) sobre un elemento de un menú.
 Se puede crear un menú contextual para cualquier View, aunque los menús
contextuales más a menudo se utilizan para los controles ListView.
 Cuando se esté desarrollando para Android 3.0 (API level 11) o superior se debe
usar el modo de acción contextual para para permitir las acciones en el contenido
seleccionado. Este modo muestra las acciones disponibles que afectan al contenido
seleccionado en una barra en la parte superior de la pantalla, permitiendo además
la selección de múltiples elementos.

138
Versión 2.0
Context menu
5. Menús
 Para que un elemento pueda ofrecer un menú contextual:
1. Se debe "registrar" el elemento mediante una llamada a registerForContextMenu()
y pasar el elemento que deseamos registrar. Una vez registrado, cuando recibe una
pulsación larga se muestra un menú contextual. Ejemplo:
registerForContextMenu(getListView());
2. Creamos el menú contextual.
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenu.ContextMenuInfo menuInfo){
super.onCreateContextMenu(menu, v, menuInfo);
menu.add(0, DELETE_ID, 0, R.string.menu_delete);
}

139
Versión 2.0
Context menu
5. Menús
3. Capturamos la pulsación.
@Override
public boolean onContextItemSelected(MenuItem item) {
switch(item.getItemId()){
case DELETE_ID:
AdapterContextMenuInfo info = (AdapterContextMenuInfo)
item.getMenuInfo();
mDbHelper.deleteNote(info.id);
fillData();
return true; }
return super.onContextItemSelected(item);
}

140
Versión 2.0
Pop-up menu
5. Menús
 Un pop-up menu es un menú que el usuario puede abrir mediante la
selección de un elemento en otro menú.
 Se puede agregar un submenú a cualquier menú (con excepción de un
submenú). Los submenús son útiles cuando la aplicación tiene muchas
funciones que pueden ser organizados en temas.
 Cuando se selecciona un elemento de un submenú, el menú principal
recibe el evento del elemento seleccionado.
 Por ejemplo, si el menú principal es un menú de opciones, el
onOptionsItemSelected() es llamado cuando un elemento de submenú se
selecciona.

141
Versión 2.0
Pop-up menu
5. Menús
public boolean onCreateOptionsMenu(Menu menu) {
boolean result = super.onCreateOptionsMenu(menu);
SubMenu fileMenu = menu.addSubMenu("File");
SubMenu editMenu = menu.addSubMenu("Edit");
fileMenu.add("new");
fileMenu.add("open");
fileMenu.add("save");
editMenu.add("undo");
editMenu.add("redo");
return result;
}

142
Versión 2.0
6. Barra de acción
 La Barra de acción o ActionBar, es una característica de la ventana que
identifica donde está el usuario además de proporcionar acciones y modos de
navegación al usuario.
 La adaptación a los diferentes tipo de ventana la proporciona el sistema.
 Funciones clave:
 Espacio dedicado para identificar una aplicación e indicar la localización del usuario dentro
de la aplicación.
 Hace más visibles y accesibles acciones importantes como por ejemplo los botones de
búsqueda.
 Soporta de manera consistente la navegación e intercambio de vistas dentro de una
aplicación a través de pestañas o listas desplegables.
1: Icono de la aplicación.
2: Control de vistas
3: Botones de acción
4: Botón de desbordamiento
de acciones

143
Versión 2.0
6. Barra de acción
 El API a partir del cual fue añadida la barra de acción fue en la versión
Android 3.0 (API level 11).
 Está disponible a través de la Support Library para hacerla compatible desde
la versión Android 2.1 (API level 7).
 Uso de la barra de acción en aplicaciones Android 3.0 o superiores:
 Basta con usar el tema Holo ( o cualquiera de sus descendientes), el cual es el tema
por defecto1.
 Llamar a requestFeature(FEATURE_ACTION_BAR).
 Declararla en un nuevo tema a través de la propiedad windowActionBar.
 Si no se quiere barra de acción en una activity se puede hacer a través del tema:
Theme.Holo.NoActionBar.
 Ocultar/mostrar la barra de acción: El método getActionBar() devuelve una
instancia a la barra (Clase ActionBar) y entonces se pueden usar los métodos
hide(), para ocultarla, o show() para mostrarla.
1. Como es el tema por defecto, si se los atributos targetSdkVersion o
minSdkVersion se establecen a «11» o un valor superior.

144
Versión 2.0
Añadir la barra de acción en aplicaciones usando la Support Library
6. Barra de acción
 Configurar la biblioteca appcompat v7.
 Crear una activity derivando de la clase:
 android.support.v7.app.AppCompatActivity (Actualizado en la V22.1, antes
era ActionBarActivity) .
 Añadir o extender el tema: Theme.AppCompat
 Ocultar/mostrar la barra de acción: El método getSupportActionBar()
devuelve una instancia a la barra (Clase ActionBar) y entonces se pueden usar
los métodos hide(), para ocultarla, o show() para mostrarla.
<activity
android:theme="@style/Theme.AppCompat.Light«
... >

145
Versión 2.0
Otros aspectos de la barra de acción
6. Barra de acción
 Consideraciones sobre la ocultación y muestra de la barra de acción:
 Cada vez que se oculte o muestre la barra de acción la actividad se tiene que recomponer y
distribuir el espacio para el layout y la ausencia o presencia de la barra de acción.
 La barra de acción se puede configurar para que se superponga al layout (overlay) a través
del atributo de la actividad windowActionBarOverlay puesto a true.
 Usar un logo en vez del icono.
 La barra de acción usa normalmente el icono definido en el atributo icon de
<application> o <activity>, pero puede usar igualmente un logo, estableciendo el
deseado en las partes anteriores.
 Un logo normalmente es más ancho y debe evitar texto innecesario, pero está liberado de
las proporciones cuadradas de los iconos.

146
Versión 2.0
Añadir elementos de acción
6. Barra de acción
 El espacio disponible se rellena con los elementos definidos en un recurso
menú a través de la llamada al método onCreateOptionsMenu(). Al
igual que se vio para los menús.
 Aquellos botones u opciones que no dispongan de espacio suficiente
podrán ser accedidos por el botón de desbordamiento.
 Para mostrar el texto aun teniendo icono: <item
yourapp:showAsAction="ifRoom|withText" ... />
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:yourapp="http://schemas.android.com/apk/res-auto" >
<item android:id="@+id/action_search"
android:icon="@drawable/ic_action_search"
android:title="@string/action_search"
yourapp:showAsAction="ifRoom" />
...
</menu>
Para la Support API

147
Versión 2.0
Cambiar a ToolBar
6. Barra de acción
 La barra de acción presenta problemas en cuanto a su aspecto en
distintas versiones, incluso con la biblioteca de soporte.
 No soporta Material Design a menos que se cree un proyecto
Android 5 o superior.
 Por eso se creó la ToolBar:
 Soporte completo desde API 7
 Soporte a Material Design.
 Misma experiencia de uso en diferentes versiones.

148
Versión 2.0
Usar una ToolBar en vez de la barra de acción
6. Barra de acción
1. Usar la biblioteca de soporte v7 appcompat.
2. Emplear la actividad herede de AppCompatActivity.
3. Usar un tema que no muestre la barra de acción para impedir su
uso de forma nativa:
<application
android:theme="@style/Theme.AppCompat.Light.NoActionBar"/>

149
Versión 2.0
6. Barra de acción
4. Añadir la ToolBar al layout de la actividad
<android.support.v7.widget.Toolbar
android:id="@+id/my_toolbar"
android:layout_height="?attr/actionBarSize"
android:background="?attr/colorPrimary"
android:elevation="4dp"
android:theme="@style/ThemeOverlay.AppCompat.ActionBar"
app:popupTheme="@style/ThemeOverlay.AppCompat.Light"/>

150
Versión 2.0
6. Barra de acción
5. Establecer la toolbat como barra de aplicación en el método
onCreate() de la actividad con setSupportActionBar().
@Override
protected void onCreate(Bundle savedInstanceState) {
setContentView(R.layout.activity_my);
Toolbar myToolbar = (Toolbar) findViewById(R.id.my_toolbar);
setSupportActionBar(myToolbar);
}

151
Versión 2.0
7. Fragmentos
 Los Fragmentos ( ) permiten crear aplicaciones multi-
panel que gestionen el espacio disponible en pantalla de manera
automática.
 Así pues, con la clase se pueden crear como
aplicaciones anidadas con su propio layout y ciclo de vida.
 Un fragmento tiene su propio layout y puede diseñarse en conjunto
con otros fragmentos dentro de una Activity para controlar la forma
en que se muestran, pero si hay espacio disponible se mostrarán
varios fragmentos a la vez.

152
Versión 2.0
7. Fragmentos
 Fueron introducidos para dar cobertura a los tablets con
Android Honeycomb (febrero de 2011, Android 3.0 API
level 11)
 Pero gracias a la Android Support Library se pueden
usar desde Android 1.6 (API level 4).
 Para usarla mirar en:
http://developer.android.com/training/basics/fragments/su
pport-lib.html

153
Versión 2.0
7. Fragmentos
 Un Fragment puede verse como un módulo o sub-actividad de una Activity
con su propio ciclo de vida y eventos de entrada que puede ser activada o
desactivada cuando se necesita.
 Aspectos a tener en cuenta:
 Un Fragment siempre debe estar incluido en una Activity.
 Cada fragmento en una Activity está afectado por el ciclo de vida de esta, así si
es pausada o destruida, todos los fragmentos también lo son.
 Sin embargo, cuando la Activity está en ejecución (estado resumed) cada
fragmento puede ser manipulado separadamente, de manera que se puede
añadir o eliminar.
 Las operaciones sobre los fragmentos pueden añadirse a la back stack que es
manejada por la Activity para poder navegar por los estados pasados de los
fragmentos.
Back stack: pila que se gestiona para almacenar las
llamadas a actividades o fragmentos y que es accedida cada
vez que se presiona el botón back de un dispositivo.

154
Versión 2.0
Añadir fragmentos a una actividad
7. Fragmentos
 Cuando un fragmento es parte del layout de una Activiy el forma
parte de un ViewGroup dentro de la jerarquía de vistas de la
Activity.
 Un fragmento puede ser añadido al layout de un Activity de dos
formas:
 Directamente en el código XML del layout de la Activity a través
de la marca <fragment>
 Desde el código de la actividad en tiempo de ejecución.
 Un fragmento no necesita tener interfaz de usuario, pudiendo
actuar de manera invisible para llevar a cabo tareas que no
necesiten interacción visual.

155
Versión 2.0
Crear un fragmento
7. Fragmentos
 Para crear un fragmento se debe crear un subclase de
Fragment (o una subclase que ya exista).
 La clase Fragment tiene un aspecto similar a una Activity ya
que contiene métodos de llamada similares, tales como
onCreate(), onStart(), onPause() y onStop().
 Nota: Es posible reutilizar el código de actividades existentes
en fragmentos simplemente moviendo el código a los
métodos de llamada correspondientes del fragmento.

156
Versión 2.0
Ciclo de vida de un fragmento
7. Fragmentos
 Los siguientes métodos deberían ser siempre implementados en un fragmento:
 onCreate(): El sistema llama a este método al crear el fragmento. En su
implementación se deben inicializar componentes esenciales del fragmento
que se quieran retener cuando éste se pause o se para y más tarde
activado (resumed).
 onCreateView(): El sistema llama este método cuando se necesita dibujar
la interfaz de usuario del fragmento la primera vez. Este método debe
devolver un objeto de la clase View que sea la raíz del layout del
fragmento. Se puede devolver null para indicar que el fragmento no tiene
interfaz de usuario.
 onPause(): El sistema llama a este método como primer síntoma de que el
usuario está dejando el fragmento, lo cual no implica que siempre el
fragmento sea destruido. En este método se deben guardar todos aquellos
datos que deban ser persistentes durante la sesión de trabajo del usuario
debido a que el usuario puede no volver.

157
Versión 2.0
Ciclo de vida de un
fragmento
7. Fragmentos

158
Versión 2.0
Subclases de Fragment
7. Fragmentos
 Existen algunas subclases de la clase Fragment que añaden funcionalidades útiles
que pueden ser interesantes para hacer una implementación más rápida y
consistente.
 DialogFragment: Muestra un cuadro de diálogo flotante. Usar esta clase puede ser
una buena alternativa a los métodos normales de creación de cuadros de diálogos
debido a que un DialogFragment puede ser incorporado a la pila de llamadas
(back stack) de una Activity permitiendo al usuario volver a él si fuera necesario.
 ListFragment: Muestra una lista de objetos gestionada por un adaptador (tal como
un SimpleCursorAdapter), similar a un ListActivity. Este tipo de fragmentos
proporcionan varios métodos para gestionar la lista tales como onListItemClick()
para controlar los eventos de pulsación.
 PreferenceFragment: Muestra la jerarquía de Preferencias como una lista similar
a un PreferenceActivity. Es útil a la hora de crear un activity de configuración a
una aplicación.

159
Versión 2.0
Añadir fragmentos a una Activity a través de su layout
7. Fragmentos
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
<fragment android:name="com.example.news.ArticleListFragment"
android:id="@+id/list"
android:layout_weight="1"
android:layout_width="0dp"
android:layout_height="match_parent" />
<fragment android:name="com.example.news.ArticleReaderFragment"
android:id="@+id/viewer"
android:layout_weight="2"
android:layout_width="0dp"
</LinearLayout>
Fichero de layout
de la Activity
Fragmento 1
Fragmento 2

160
Versión 2.0
7. Fragmentos
 El atributo android:name debe contener el nombre de la clase que instanciará
el fragmento.
 Cuando el sistema crea el layout de la Activity, cada fragmento que se ha
especificado en el layout se instancia y llama el método onCreateView() para
obtener el elemento View que devuelve dicho método directamente en el lugar
especificado por en elemento <fragment>
 Cada fragmento requiere un identificador único para que el sistema pueda
restaurarlo si la actividad reinicia o para hacer transacciones con él. Esto se
puede hacer:
 A través de android:id.
 O de un android:tag con una cadena única.
 Si no se proporciona ninguno de los anteriores el sistema usa el ID de la
vista contenedora.

161
Versión 2.0
7. Fragmentos
 Código en un fragmento que carga un layout desde un XML
public static class ExampleFragment extends Fragment{
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup
container, Bundle savedInstanceState){
// Inflate the layout for this fragment return
inflater.inflate(R.layout.example_fragment, container,
false);
}
}

162
Versión 2.0
Añadir fragmentos a una Activity a través del código
7. Fragmentos
 Mientras una activity esté en ejecución, se puede añadir un fragmento a un
ViewGroup existente.
 Para poder hacer transacciones en una activity, tales como añadir, eliminar
o reemplazar un fragmento, se debe usar el API disponible con
FragmentTransaction.
FragmentManager fragmentManager = getFragmentManager()
FragmentTransaction fragmentTransaction =
fragmentManager.beginTransaction();

163
Versión 2.0
Añadir fragmentos a una Activity a través del código
7. Fragmentos
 A continuación se puede añadir un fragmento de la siguiente manera:
ExampleFragment fragment = new ExampleFragment();
fragmentTransaction.add(R.id.fragment_container, fragment);
fragmentTransaction.commit();
 El primer parámetro del método add es el ID del ViewGroup y el segundo
el fragmento a añadir.
 También podremos eliminarlos con remove() y reemplazar con replace().
 Para que la transacción se lleva a cabo es necesario la ejecución de
commit().

164
Versión 2.0
Crear fragmentos directamente en el código de una Activity
7. Fragmentos
 Los fragmentos deben tener un contenedor de tipo View disponible antes
de su creación (puede ser un simple FrameLayout vacío):
<FrameLayout
xmlns:android=http://schemas.android.com/apk/res/android
android:id="@+id/fragment_container"
 Y dentro de la aplicación llamar a getSupportFragmentManager() para
obtener un FragmentManager si se usa las Support Library APIs.
 Usar el método beginTransaction() para crear una FragmentTransaction
 Después llamar al método add().

165
Versión 2.0
Crear fragmentos directamente en el código de una Activity
7. Fragmentos
super.onCreate(savedInstanceState); setContentView(R.layout.news_articles);
if (findViewById(R.id.fragment_container) != null) {
if (savedInstanceState != null) { return; }
firstFragment = new HeadlinesFragment();
firstFragment.setArguments(getIntent().getExtras());
getSupportFragmentManager().beginTransaction().add(R.i
d.fragment_container, firstFragment).commit();
}}

166
Versión 2.0
Gestionar fragmentos
7. Fragmentos
 Para gestionar otros aspectos de los fragmentos, a parte de
añadir/eliminar/reemplazar se usa también FragmentManager.
 Para obtenerlo llamar getFragmentManager() desde la activity
 Otras operaciones que se pueden hacer son:
 Obtener los fragmentos que existen en una activity con findFragmentById(), para
los que tienen un ID en el layout de la activity o findFragmentByTag() para los
que no proporcionan un UI.
 Sacar fragmentos de la back stack con popBackStack(), de esta manera se
simula la pulsación del botón Back por el usuario.
 Registrar un listener para los cambios en la back stack
con addOnBackStackChangedListener().

167
Versión 2.0
Gestión de fragmentos. Orientación
7. Fragmentos
if (this.getResources().getConfiguration().orientation ==
Configuration.ORIENTATION_PORTRAIT) {
// PORTRAIT ORIENTATION
setupPortraitView();
} else {
// LANDSCAPE ORIENTATION
setupLandscapeView();
}

168
Versión 2.0
Comunicación Fagment-Activity
7. Fragmentos
 Un fragmento está ligado directamente a la activity que lo contiene,
pudiendo acceder a esta a través del método getActivity().
View listView = getActivity().findViewById(R.id.list);
 A su vez, la activity puede usar métodos del fragmento a través de
FragmentManager, usando findFragmentById() o findFragmentByTag().
Fragment1 fragment = (Fragment1)
getFragmentManager().findFragmentById(R.id.example
_fragment);

169
Versión 2.0
Crear eventos de notificación para la activity
7. Fragmentos
 Un fragmento puede enviar notificaciones al Activity que lo contiene a
través de la implementación de un interfaz común:
 La Activity deberá luego implementar dicho interface y los métodos en él
declarados.
public static class FragmentA extends ListFragment{
...
// Container Activity must implement this interface
public interface OnArticleSelectedListener{
public void onArticleSelected(Uri articleUri);
}
...
}

170
Versión 2.0
7. Fragmentos
 Para asegurar que la activity padre implementa el interfaz se debe
hacer una comprobación en el método onAttach() del fragmento,
haciendo un casting a la activity llamante:
public static class FragmentA extends ListFragment {
OnArticleSelectedListener mListener;
...
@Override public void onAttach(Activity activity) {
super.onAttach(activity);
try {
mListener = (OnArticleSelectedListener) activity;
} catch (ClassCastException e) {
throw new ClassCastException(activity.toString() + " must implement
OnArticleSelectedListener"); }
}
...
}

171
Versión 2.0
7. Fragmentos
 Posteriormente, si no hay excepción, el fragmento puede usar su interfaz
para enviar eventos a la activity:
public static class FragmentA extends ListFragment {
OnArticleSelectedListener mListener;
...
@Override public void
onListItemClick(ListView l, View v, int position, long id) {
…
// Send the event and Uri to the host activity
mListener.onArticleSelected(noteUri);
}
... }

172
Versión 2.0
Fragmentos y la barra de acción
7. Fragmentos
 Un fragmento puede contribuir con elementos a la barra de acción
(o menú) implementando el método onCreateOptionsMenu().
 Para que un fragmento reciba la notificación para crear un menú y se
llame el método onCreateOptionsMenu() debe llamar a
setHasOptionsMenu().
 Los elementos añadidos por el fragmento, cuando son seleccionados
hacen que se llame al método onOptionsItemSelected() del mismo.
 La Activity será la primera en recibir el evento de la pulsación, y si esta no
lo procesa, entonces pasará al fragmento.

173
Versión 2.0
Fragmentos y la barra de acción
7. Fragmentos
 También se puede registrar una vista del layout del fragmento para tener
un menú contextual llamando a registerForContextMenu().
 Cuando el usuario abre el menú el fragmento recive una llamada a
onCreateContextMenu().
 Cuando el usuario selecciona un elemento el fragmento recibe una llamada a
onContextItemSelected().

174
Versión 2.0
 Android proporciona diversas opciones para grabar los datos
de una aplicación de manera persistente.
 La solución a elegir depende de las necesidades específicas
de la aplicación, así como de las del diseñador. Elecciones
típicas son por ejemplo:
 Si la información será privada a la aplicación o visible a otras (e
incluso al usuario).
 Cuanto espacio se requerirá.
 Etc.
 El tipo de almacenamiento se puede dividir en
, y a
a través de la red. De entre una de estas propiedades se
verán las distintas soluciones implementadas en Android.
 Incluso la nueva permite la sincronización de
datos en la nube.

175
Versión 2.0
Tipos de almacenamiento
 Basadas en ficheros:
 Preferencias Compartidas ( ): Almacenan datos privados en
un formato de pares de clave y valor.
 Almacenamiento interno: Almacena ficheros privados en la memoria no volátil
del dispositivo.
 Almacenamiento externo: Almacenar ficheros en un dispositivo externo
compartido, de manera pública, y que puede no estar siempre disponible.
 Bases de datos
 Bases de Datos SQLite: Es la manera de almacenar datos de manera
estructurada en una base de datos privada a la aplicación.
 A través de la red: Con una conexión de red podremos guardar la
información remotamente en cualquier servidor con este servicio, como
por ejemplo un servidor FTP.

176
Versión 2.0
Tipos de almacenamiento
 Android proporciona una manera de exponer los datos privados de una
aplicación para que puedan ser accedidos por cualquier otra aplicación a
través de content providers.
 Un content provider es un componente opcional que proporciona
acceso de lectura/escritura a los datos de una aplicación, sujeto siempre a
las restricciones que se hayan querido imponer.

177
Versión 2.0
Preferencias compartidas (Shared preferences)
 La clase SharedPreferences proporciona el marco general que
permite el almacenar y recuperar pares de valores persistentes a
través de claves concretas de tipos de datos primitivos (boolean,
float, int, long y String). Estos valores persistirán entre distintas
sesiones de usuario, incluso si la aplicación es eliminada de
memoria.
 Para obtener un objeto de la clases SharedPreferences se puede
usar uno de estos dos métodos:
 getSharedPreferences() - Esta función se usa si se necesitan varios
ficheros de preferencias identificados por un nombre, el cual se
especifica en el primer parámetro.
 getPreferences() - Si tan sólo se necesita un fichero de preferencias
para una Activity este es el método a usar. Debido a que tan sólo
habrá un fichero, no es necesario proporcionarle el nombre.

178
Versión 2.0
Para escribir valores
 Llamar al método edit() para obtener un
SharedPreferences.Editor.
 Añadir valores con métodos tales como
putBoolean() o putString().
 Confirmar los nuevos valores con la llamada al
método commit().

179
Versión 2.0
 Use los métodos de SharedPreferences tales como
getBoolean() o getString().
Para leer valores

180
Versión 2.0
Ejemplo
@Override
protected void onCreate(Bundle state){
super.onCreate(state);
. . .
// Restore preferences
SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
boolean silent = settings.getBoolean("silentMode", false);
setSilent(silent);
}
@Override
protected void onStop(){
super.onStop();
SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean("silentMode", mSilentMode);
// Commit the edits!
editor.commit();
}
Al
crear/iniciar
Al salir

181
Versión 2.0
public interface SharedPreferences
Valor devuelto Método
abstract Map<String, ?> getAll()Retrieve all values from the preferences.
abstract boolean getBoolean(String key, boolean defValue)
abstract float getFloat(String key, float defValue)
abstract int getInt(String key, int defValue)
abstract long getLong(String key, long defValue)
abstract String getString(String key, String defValue)
abstract Set<String> getStringSet(String key, Set<String>
Métodos públicos

182
Versión 2.0
public static interface SharedPreferences.Editor
Métodos públicos
abstract void apply()Commit your preferences changes back
from this Editor to the SharedPreferences object it
is editing.
abstract SharedPreferences.Editor clear()Mark in the editor to remove all values from
the preferences.
abstract boolean commit()Commit your preferences changes back
from this Editor to the SharedPreferences object it
is editing.
abstract SharedPreferences.Editor putBoolean(String key, boolean value)Set a
boolean value in the preferences editor, to be
written back once commit() or apply() are called.

183
Versión 2.0
public static interface SharedPreferences.Editor
Métodos públicos
abstract SharedPreferences.Editor putFloat(String key, float
abstract SharedPreferences.Editor putInt(String key, int value)
abstract SharedPreferences.Editor putLong(String key, long value)
abstract SharedPreferences.Editor putString(String key, String value)
abstract SharedPreferences.Editor putStringSet(String key, Set<String> values)
abstract SharedPreferences.Editor remove(String key)Mark in the editor that a
preference value should be removed, which will
be done in the actual preferences
once commit() is called.

184
Versión 2.0
 Las preferencias compartidas no son estrictamente la
manera de almacenar las preferencias de usuario de
una aplicación, tales como el tono de llamada elegido o
la imagen de fondo.
 Para crear preferencias de usuario es a través de
PreferenceActivity, la cual proporciona una plataforma
para una Activity para crear preferencias de usuario, las
cuales serán automáticamente persistentes usando
preferencias compartidas.

185
Versión 2.0
Ficheros privados
Almacenamiento interno
 Se pueden grabar ficheros directamente en los
dispositivos de almacenamiento de que disponga el
dispositivo.
 Por defecto, todos estos ficheros serán privados y tan
sólo accesibles por la aplicación que los creó, no pudiendo
ser leídos por otras aplicaciones, ni por el usuario.
 Además, estos ficheros serán eliminados si el usuario
desinstala la aplicación.

186
Versión 2.0
Ficheros privados
 Para crear y escribir en un fichero privado es tan sencillo como lo siguiente:
 Llamar a openFileOutput() con el nombre del fichero y el modo de operación.
Esto devolverá un FileOutputStream.
 Escribir en él con write().
 Y cerrar lo con close().
 Para leer de un fichero privado:
 Llamar a openFileInput() con el nombre del fichero a leer. Esto devolverá un
FileInputStream.
 Leer bytes del fichero usando read().
 Y cerrarlo después con close().

187
Versión 2.0
try {
FileOutputStream os = openFileOutput(filename, MODE_PRIVATE
| MODE_APPEND);
DataOutputStream dos = new DataOutputStream(os);
dos.writeUTF(texto);
dos.writeInt(n);
dos.flush();
dos.close();
os.close();
} catch (IOException ex) {…}
Ficheros privados. Ejemplo: Grabar datos

188
Versión 2.0
try {
FileInputStream os = openFileInput(filename);
DataInputStream dos = new DataInputStream(os);
int n = dos.available();
texto = "Leidos (" + n + " bytes)rn";
while (dos.available() > 0) {
texto = texto + " clave: " + dos.readUTF() + " valor:"+ dos.readInt() + "rn";
}
resultado.setText(texto);
dos.close();
os.close();
} catch (IOException ex) {…}
Ficheros privados. Ejemplo: Leer datos

189
Versión 2.0
 Si se quiere tener un fichero no modificable en una aplicación en tiempo
de compilación, se puede grabar en la carpeta del proyecto res/raw/.
 Este fichero se puede abrir con openRawResource(), pasándole el
identificador de recurso R.raw.<filename>. Este método devuelve un
InputStream que se puede usar para leer del fichero (el fichero original no
se puede modificar)
Ficheros privados: Ficheros como recursos

190
Versión 2.0
 MODE_PRIVATE creará el fichero o reemplazará uno del mismo
nombre.
 Otros modos disponibles son:
 MODE_APPEND,
 MODE_WORLD_READABLE
 MODE_WORLD_WRITEABLE.
Ficheros privados. Ejemplos
String FILENAME = "hello_file";
String string = "hello world!";
FileOutputStream fos = openFileOutput(FILENAME,
Context.MODE_PRIVATE);
fos.write(string.getBytes());
fos.close();

191
Versión 2.0
Ficheros de caché
 Si los ficheros tan sólo se necesitan durante un periodo de
tiempo limitado se deben usar ficheros de caché.
 Se obtiene acceso a ellos con la llamada getCacheDir() que
devuelve un File que representa el directorio interno donde
una aplicación debe guardar sus ficheros temporales de
caché.
 Estos ficheros pueden ser eliminados para recuperar espacio
cuando un dispositivo Android le queda poca capacidad de
almacenamiento interno.

192
Versión 2.0
Ficheros de caché
 No se debe delegar en el sistema para que estos
ficheros sean eliminados, por lo que deben ser
gestionados por la aplicación y mantener el espacio
ocupado dentro de unos límites razonables, como por
ejemplo 1 Mbyte.
 Cuando el usuario desinstala la aplicación estos
ficheros de caché son borrados, al igual que los
ficheros privados.

193
Versión 2.0
Ficheros de caché
 Para crear un nuevo archivo basta con usar la instancia
a File devuelta getCacheDir() y llamar a los métodos:
public static File createTempFile (String prefix,
String suffix,
File directory)
public static File createTempFile (String prefix,
String suffix)

194
Versión 2.0
Disponibles en la clase .
public abstract class Context extends Object
 getFilesDir(): Obtiene la ruta absoluta al directorio del sistema
de archivos donde los ficheros internos de una aplicación serán
almacenados.
 getDir(): Crea (o abre un directorio existente) dentro del espacio
de almacenamiento interno de una aplicación.
 deleteFile(): Borra un fichero del almacenamiento interno.
 fileList(): Devuelve un array de ficheros que almacena
actualmente una aplicación.
Métodos útiles

195
Versión 2.0
Almacenamiento externo
 Cada dispositivo compatible con Android soporta algún
formato de almacenamiento externo compartido, que puede
ser usado para almacenar ficheros.
 Este dispositivo de almacenamiento puede ser una tarjeta SD o
dispositivos internos no removibles.
 Los archivos grabados en el dispositivo de almacenamiento
externo pueden ser accedidos por cualquier aplicación.
 Además, pueden ser modificados por el usuario cuando este
habilita el acceso de transferencia masivo a través de USB al
conectarlo a un ordenador.

196
Versión 2.0
 Los ficheros externos desaparecen cuando el
usuario monta el almacenamiento externo en un
ordenador o lo quita del dispositivo Android
 No hay medidas de seguridad especiales para los
ficheros en el almacenamiento externo, ya que
como se ha comentado, cualquier aplicación o
usuario puede leerlos, modificarlos, o incluso
eliminarlos.
 Para evitar que el escáner de medios de Android
incluya ficheros de una aplicación en la Galería o
en la Música se puede poner un fichero vacío
denominado .
Precauciones con el almacenamiento externo

197
Versión 2.0
 Para que una aplicación pueda usar el almacenamiento externo debe
incluir ciertos permisos en su AndroidManifiest.xml:
 Leer: android.permission.READ_EXTERNAL_STORAGE
 Escribir: android.permission.WRITE_EXTERNAL_STORAGE (lleva implícita
la lectura)
<manifest...>
...
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
...
</manifest>
 Nota: desde Android 4.4, estos permisos no son requeridos si los
ficheros son privadas a la aplicación.
Obtener permiso para acceder al almacenamiento externo

198
Versión 2.0
 Antes de realizar cualquier tarea con el almacenamiento externo,
se debe llamar al método estático
getExternalStorageState() de la clase Environment para
comprobar si el dispositivo está disponible. Este método devuelve
diversos valores en función del estado del soporte de
almacenamiento, pudiendo usarlo tan sólo para leer o escribir si el
valor Environment.MEDIA_MOUNTED, y tan sólo leer si el valor
es Environment.MEDIA_MOUNTED_READ_ONLY. Otros valores
aparecen a continuación.
Comprobar la existencia de un medio de almacenamiento

199
Versión 2.0
Constante Clase Environment
String MEDIA_BAD_REMOVAL El dispositivo fue removido antes de
ser desmontado
String MEDIA_CHECKING El medio se está comprobando
String MEDIA_MOUNTED El medio está montado y disponible
para leer/escribir
String MEDIA_MOUNTED_READ_ONLY El medio está montado pero en un
punto de solo lectura
String MEDIA_NOFS El medio está en blanco o tiene un
sistema de archivos incorrecto

200
Versión 2.0
Constante Clase Environment
String MEDIA_REMOVED No hay medio
String MEDIA_SHARED El medio está presente pero no está
montado y compartido por USB
String MEDIA_UNMOUNTABLE El medio no puede ser montado
String MEDIA_UNMOUNTED El medio está presente pero no
montado

201
Versión 2.0
boolean mExternalStorageAvailable = false;
boolean mExternalStorageWriteable = false;
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)){
// We can read and write the media
mExternalStorageAvailable = mExternalStorageWriteable = true;
} else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)){
// We can only read the media
mExternalStorageAvailable = true;
mExternalStorageWriteable = false;
} else {
// Something else is wrong. It may be one of many other states, but all we need
// to know is we can neither read nor write
mExternalStorageAvailable = mExternalStorageWriteable = false;
}
Comprobar la existencia de un medio de almacenamiento. Ejemplo

202
Versión 2.0
 Se debe usar getExternalFilesDir() para obtener un File que representa el
directorio del almacenamiento externo donde la aplicación debería
almacenar los ficheros.
 El parámetro de este método especifica el tipo de subdirectorio que se quiere,
tales como DIRECTORY_MUSIC o DIRECTORY_RINGTONES. Este método
creará el directorio apropiado si es necesario. Especificando el tipo de directorio
se asegura que el escáner de medios de Android clasificará apropiadamente los
archivos en el sistema (por ejemplo los tonos de llamada serán tonos de llamada
y no música).
 Si se pasa null, se obtiene el directorio raíz del directorio de la aplicación.
API 8 o superior. Acceder a ficheros en el almacenamiento externo.

203
Versión 2.0
 Si el usuario desinstala la aplicación,
los directorios creados por este medio y
todo su contenido serán borrados.
 No se deben utilizar para almacenar
ficheros que el usuario podría querer
acceder desde otras aplicaciones, como
fotografías, música, etc.
API 8 o superior. Acceder a ficheros en el almacenamiento externo.

204
Versión 2.0
 Se debe usar getExternalStorageDirectory() para abrir un File que
represente la raíz del almacenamiento externo. Los datos deben ser
escritos en el siguiente directorio:
/Android/data/<package_name>/files/
 Donde <package_name> es el nombre del paquete en el estilo de Java,
tal como "com.example.android.app".
 Si el usuario está ejecutando un API nivel 8 o superior y desinstala la
aplicación, el directorio y todo su contenido será eliminado.
API 7 o inferior. Acceder a ficheros en el almacenamiento externo.

205
Versión 2.0
 Environment.getExternalStor
agePublicDirectory(String
type): devuelve el directorio raíz del
almacenamiento externo de un
determinado tipo.
 El usuario tendrá aquí sus ficheros,
por lo que se deben tratar con
cuidado y evitar borrados o
reemplazos accidentales.
 En dispositivos con varios usuarios
cada uno tiene un espacio separado
en el almacenamiento externo.
Directorio público de almacenamiento compartido
Tipos (no debería ser null)
DIRECTORY_MUSIC
DIRECTORY_PODCASTS
DIRECTORY_RINGTONES
DIRECTORY_ALARMS
DIRECTORY_NOTIFICATIONS
DIRECTORY_PICTURES
DIRECTORY_MOVIES
DIRECTORY_DOWNLOADS
DIRECTORY_DCIM

206
Versión 2.0
Directorio público de almacenamiento compartido
File path = Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES);
File file = new File(path, "DemoPicture.jpg");
try {
// Comprobar que el directorio aún existe.
path.mkdirs();
InputStream is = new FileInputStream(file);
OutputStream os = new FileOutputStream(file);
…
} catch (IOException e) {
…
}

207
Versión 2.0
 Para conseguir que un archivo recién creado esté rápidamente disponible
al usuario se puede llamar al gestor de medios.
MediaScannerConnection.scanFile(this,
new String[] { file.toString() }, null,
new MediaScannerConnection.OnScanCompletedListener(){
public void onScanCompleted(String path, Uri uri)
Log.i("ExternalStorage", "Scanned " + path + ":");
Log.i("ExternalStorage", "-> uri=" + uri);
}
});
Gestor de medios - MediaManager

208
Versión 2.0
 Android proporciona acceso a bases de datos a través
de SQLite.
 Cualquier clase de la aplicación podrá acceder a una
bases de datos creada por la misma, pero ninguna otra
aplicación tendrá acceso.
 Android no impone ninguna limitación adicional más allá
de lo dispuesto por SQLite.
 Recomendaciones:
 Incluir un identificador único autoincrementado (ID). No es
obligatorio para las bases de datos privadas, pero es
obligatorio para los Content provider

209
Versión 2.0
 Diseñado para ser simple, de administrar, operar,
introducir en programas, de mantener y personalizar.
 SQLite está pensado para sustituir a fopen(), no a
Oracle.
 Diseñada para ocupar un solo fichero en el sistema de
archivos.
 Alta concurrencia: SQLite soporte cualquier número de
lectores a la vez, pero solamente un escritor.
Bases de datos SQLite

210
Versión 2.0
 Transacciones atómicas, consistentes, aisladas y duraderas
(en inglés ACID).
 No se necesita configuración ni administración.
 Implementa casi al completo SQL92 (las características
omitidas aparecen en www.sqlite.org/omitted.html).
 Permite bases de datos de terabytes y cadenas o
BLOBs(Binary Large Objets) de gigabytes.
 Ligero, rápido y API sencilla, escrita en ANSI-C, libre, auto-
contenida y multi-plataforma.
 Proporciona una interfaz de línea de comandos que permite
gestionar las bases de datos.
Características

211
Versión 2.0
 Para el formateo de ficheros específicos de
aplicaciones.
 Para aplicaciones y dispositivos empotrados.
 Páginas web.
 Reemplazo de ficheros ad-hoc de aplicaciones.
 Gestión de bases de datos temporales internas.
Entre otras…
Usos apropiados de SQLite

212
Versión 2.0
 Aplicaciones cliente/servidor.
 Sitios web con gran volumen de accesos, una base de
datos basada en cliente/servidor en una máquina
diferente puede ayudar.
 Contenidos muy grandes: SQLite está limitada a 140
terabytes. Al almacenarse en un solo fichero, podría
estar limitado por el sistema operativo.
Situaciones en las que SQLite no es apropiado

213
Versión 2.0
 NULL. Valor nulo (NULL).
 INTEGER. Entero con signo almacenado en 1, 2, 3, 4,
6, u 8 bytes, dependiendo de la magnitud del valor.
 REAL. Punto flotante almacenado según el formato de
8-bytes del IEEE.
 TEXT. Cadena de texto almacenada codificada en
UTF-8, UTF-16BE o UTF-16LE.
 BLOB. Objeto binario grande, almacenado tal cual se
ha escrito.
Tipos de datos

214
Versión 2.0
 Android proporciona acceso a bases de datos a través
de SQLite.
 Cualquier clase de la aplicación podrá acceder a una
bases de datos creada por la misma, pero ninguna otra
aplicación tendrá acceso.
 Dado que se administran como un fichero, su acceso
puede ser lento y se recomienda realizar las
operaciones con ellas de manera asíncrona.
 El paquete android.database.sqlite contiene todas las
clases para manejo de bases de datos SQLite.
Creación y manejo de una base de datos

215
Versión 2.0
 La manera que se recomienda crear una base de datos
es a través de la creación de una clase que herede de
SQLiteOpenHelper, codificando su método onCreate.

216
Versión 2.0
public class RecordsSQLiteHelper extends SQLiteOpenHelper{
private static final String DATABASE_NAME = "recordslist";
private static final int DATABASE_VERSION = 1;
public static final String TABLA_RECORDS = "records";
public static final String COLUMNA_ID = "_id";
public static final String COLUMNA_ETIQUETA = "label";
public static final String COLUMNA_VALOR = "value";
private static final String DATABASE_CREATE = "create table "
+ TABLA_RECORDS + "(" + COLUMNA_ID
+ " integer primary key autoincrement, " + COLUMNA_ETIQUETA
+ " text not null, " + COLUMNA_VALOR + " integer nor null);";
…
}
Ejemplo de creación de una base de datos
Sentencia
en SQL

217
Versión 2.0
public class RecordsSQLiteHelper extends SQLiteOpenHelper{
…
public RecordsSQLiteHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase database) {
database.execSQL(DATABASE_CREATE);
}
…
}
Ejemplo de creación de una base de datos
Creación de la
base de datos

218
Versión 2.0
 Cuando el código de versión se incrementa en el código
de una aplicación se llama el método onUpgrade().
 En este método se pueden borrar o alterar el esquema
de la base de datos para que más tarde sea creada en
onCreate().
 Para mantener una implementación limpia se
recomienda crear una clase por cada tabla.
Actualizar una base de datos

219
Versión 2.0
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(RecordsSQLiteHelper.class.getName(),"Upgrading database from
version " + oldVersion + " to "+ newVersion + ", which will destroy all
old data");
db.execSQL("DROP TABLE IF EXISTS " + TABLA_RECORDS);
onCreate(db);
}
Ejemplo de actualización de una base de datos

220
Versión 2.0
 La clase SQLiteOpenHelper proporciona los métodos
getReadableDatabase() y getWriteableDatabase() que permiten
el acceso a un objeto SQLiteDatabase para realizar operaciones
de lectura y escritura.
 getWriteableDatabase() devuelve un objeto SQLiteDatabase que
permite tanto operaciones de lectura como de escritura.
 getReadableDatabase() devuelve el mismo objeto que el método
anterior salvo situaciones, como la falta de espacio de
almacenamiento, en la que devuelve un objeto que no tiene
permitidas las operaciones de escritura.
 Nota: Ambos métodos pueden tardar mucho tiempo para
completarse, por lo que se recomienda no ejecutarlos en la hebra
de ejecución principal.
Leer o escribir de una base de datos

221
Versión 2.0
 Es la clase que proporciona Android para trabajar con las bases de
datos SQLite. Concretamente proporciona los métodos:
 insert().
 update().
 delete().
 execSQL() que permite la ejecución de sentencias SQL directamente.
 La clase ContentValues permite definir pares de clave/valor.
 La clave representará el identificador de columna y el valor el contenido del
registro almacenado en esa columna.
 ContentValues se puede usar en inserciones y actualizaciones de entradas
de una base de datos.
Clase SQLiteDatabase

222
Versión 2.0
 Las peticiones pueden ser creadas a través de los
métodos rawQuery() y query() o a través de la
clase SQLiteQueryBuilder.
 rawQuery(): acepta directamente como entrada una
sentencia select de SQL.
 query(): proporciona una interfaz estructurada para
especificar peticiones SQL.
 SQLiteQueryBuilder: es una clase muy recomendable, ya
que ayuda a la construcción de peticiones SQL.
Clase SQLiteDatabase. Peticiones (queries)

223
Versión 2.0
 Ejemplo de rawQuery()
Cursor cursor = getReadableDatabase().
rawQuery("select * from usarios where _id = ?",
new String[] { id });

224
Versión 2.0
 Ejemplo de query()
return database.query(DATABASE_TABLE,
new String[] { KEY_ROWID, KEY_CATEGORY,
KEY_SUMMARY, KEY_DESCRIPTION },
null, null, null, null, null);

225
Versión 2.0
Clase SQLiteDatabase. Método query
 El método query tiene cuatro prototipos:
Cursor query(String table, String[] columns, String selection, String[] selectionArgs,
String groupBy, String having, String orderBy, String limit)
Cursor query(boolean
distinct, String table, String[] columns, String selection, String[] selectionArgs, String
groupBy, String having, String orderBy, String limit, CancellationSignal cancellation
Signal)
Cursor query(String table, String[] columns, String selection, String[] selectionArgs,
String groupBy, String having, String orderBy)
Cursor query(boolean
distinct, String table, String[] columns, String selection, String[] selectionArgs, String
groupBy, String having, String orderBy, String limit)

226
Versión 2.0
 Cuando se está implementando una aplicación donde se quieren realizar
un dibujo especializado y/o controlar una animación, se debe realizar a
través de un Canvas.
 Un canvas (lienzo) funciona como interfaz de la superficie sobre la que los
gráficos serán dibujados, recibiendo todas las llamadas de métodos de
dibujo.
 A través de Canvas, el dibujo es realizado realmente sobre un Bitmap
subyacente, el cual es colocado en la ventana.
Canvas

227
Versión 2.0
 Todo el proceso de dibujo se realizará en la llamada al método de
callback onDraw(), donde el Canvas se proporciona para su modificación
y/o actualización a través de llamadas a métodos de dibujo sobre él.
 También se puede adquirir un Canvas a través de la llamada al método
SurfaceHolder.lockCanvas(), cuando se esté usando un objeto
SurfaceView.
 Sin embargo si se necesita crear un nuevo Canvas, se debe definir el
Bitmap sobre el cual se realizará realmente el dibujo. El Bitmap siempre es
requerido para un Canvas.
Canvas

228
Versión 2.0
 Se puede crear un nuevo Canvas de la siguiente manera:
Bitmap b =
Bitmap.createBitmap(100,100,Bitmap.Config.ARGB_8888
);
Canvas c = new Canvas(b);
 Ahora el Canvas puede dibujar sobre el Bitmap previamente definido. Una
vez terminado el dibujo sobre el Canvas, se puede llevar el Bitmap a otro
Canvas a través de métodos como Canvas.drawBitmap(Bitmap,...). Se
recomienda que se dibujen el gráfico definitivo a través de un Canvas
conseguido a través de métodos como View.onDraw() o
SurfaceHolder.lockCanvas().
Canvas. Ejemplo de creación

229
Versión 2.0
 La clase Canvas tienes su propio conjunto de métodos de dibujo tales
como: drawBitmap(...), drawRect(...), drawText(...), y otros muchos.
 Otras clases que se pueden usar también proporcionan métodos de
dibujo, como los objetos Drawable que se pueden poner en un Canvas. La
clase Drawable tiene sus propios métodos draw() que toman el Canvas
que los incorpora como argumento.
Canvas. Ejemplo de creación

230
Versión 2.0
 Android ofrece una biblioteca de gráficos 2D personalizados para dibujar y
animar formas e imágenes.
 Los paquetes android.graphics.drawable y android.view.animation es
donde se encuentran las clases más comunes utilizadas para el dibujo y la
animación en dos dimensiones.
 Vamos ver el uso del objeto Drawable para dibujar gráficos, así cómo
utilizar un par de subclases de la clase Drawable y cómo crear
animaciones que permitan mover, estirar y rotar un gráfico o animación de
una serie de gráficos
Drawables

231
Versión 2.0
 Drawable es una abstracción general de "algo que se puede
elaborar“.
 La clase Drawable se extiende para definir una variedad de tipos
específicos de gráficos, incluyendo BitmapDrawable,
ShapeDrawable, PictureDrawable, LayerDrawable y otros más.
 Por supuesto, también puede ampliarse para definir sus propios
objetos personalizados.
 Hay tres maneras de definir y crear instancias de Drawable:
 El uso de una imagen guardada en los recursos del proyecto,
 Mediante un archivo XML que define las propiedades del Drawable.
 Con los constructores de clase normal.
Drawables

232
Versión 2.0
 Una forma sencilla de añadir gráficos es por referencia a un archivo de
imagen de los recursos del proyecto.
 Los tipos de archivo admitidos son:
 PNG (preferido), JPG (aceptable) y GIF (desaconsejado).
 Esta técnica es la aconsejable para los iconos de aplicaciones, logotipos u otros
gráficos, como los utilizados en un juego.
 Para utilizar un recurso de imagen, sólo tiene que añadir el archivo al
directorio res/drawable/ del proyecto. Desde allí, puede hacer referencia a
ella desde el código o el diseño de XML.
 El código siguiente muestra cómo construir un ImageView que utiliza una
imagen de recursos del proyecto.
Drawables
Creación de gráficos a partir de una imagen

233
Versión 2.0
LinearLayout mLinearLayout;
protected void onCreate(Bundle savedInstanceState){
//Create a LinearLayout in which to add the ImageView
mLinearLayout = new LinearLayout(this);
//Instantiate an ImageView and define its properties
ImageView i = new ImageView(this);
i.setImageResource(R.drawable.my_image);
i.setAdjustViewBounds(true);
i.setLayoutParams(new Gallery.LayoutParams(LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT));
//Add the ImageView to the layout
// and set the layout as the content view
mLinearLayout.addView(i);
setContentView(mLinearLayout);
}
Drawables
Creación de gráficos a partir de una imagen. Ejemplo
<ImageView
android:tint="#55ff0000"
android:src="@drawable/my_image"/>

234
Versión 2.0
Creación de gráficos mediante XML
Drawables
 Si sabemos que las propiedades de los gráficos pueden cambiar durante
el diseño de la aplicación, es conveniente la definición del objeto mediante
XML, lo que nos permitirá cambiar sus propiedades cada vez que se
instancie.
 Definido el objeto en XML, se guarda el archivo en el directorio
res/drawable del proyecto. Se crea una instancia del objeto mediante una
llamada a Resources.getDrawable() y le pasamos el identificador de
recurso del archivo XML.

235
Versión 2.0
 Se pueden definir mapas de bits que
estén referenciados en XML para
aportar características adicionales,
como el entrelazado (dither) y el
replicado (tiling).
 También permite filtrado cuando la
imagen está deformada.
 El recurso será gestionado con la
clase BitmapDrawable.
 Referencia en Java:
R.drawable.filename
 Referencia en XML:
@[package:]drawable/filename
Drawables
XML Bitmap
Dithering Tiling

237
Versión 2.0
 Un gráfico NinePatchDrawable es una imagen de mapa de bits elástico,
que Android cambiará automáticamente de tamaño para acomodar el
contenido de la vista en la que la han colocado como fondo.
 Un ejemplo de uso de un NinePatch son los fondos utilizados de forma
estándar en los botones de Android, los botones deben estirarse para
acomodar cadenas de longitudes diferentes.
 También se puede definir en un XML:
<nine-patch xmlns:android="http://schemas.android.com/apk/res/android"
android:src="@[package:]drawable/drawable_resource"
android:dither=["true" | "false"] />
Drawables
Nine-patch

238
Versión 2.0
 Un NinePatch es una
imagen PNG estándar que
incluye un borde adicional
de 1 píxel de ancho.
 Se deben guardar con la
extensión 0.9.png, y se
guarda en el directorio
res/drawable/ del proyecto.
Drawables
Crear un Nine-patch

239
Versión 2.0
 La línea de borde se utiliza para definir el área que debe definir la
imagen. Se indica una sección extensible por una (o más) de
líneas negras de 1 píxel de ancho en la parte izquierda y borde
superior.
 Opcionalmente de pueden definir dos líneas a la derecha y debajo
del Nine-path, para definir un área efectiva de dibujo, de forma que
si queremos meter un texto dentro de este área, se ajustará a la
misma, si no existen estas líneas el dibujo se extiende hasta
ajustare al texto.
Drawables
Crear un Nine-patch

240
Versión 2.0
 Cuando se quiere dibujar un gráfico en 2D dinámicamente, el objeto
ShapeDrawable es el más indicado.
 Un ShapeDrawable es una extensión de Drawable, puede utilizarse en
lugar de Drawable, por ejemplo para el fondo de una pantalla, con la
opción setBackgroundDrawable().
 La clase ShapeDrawable (al igual que muchos otros tipos Drawable en el
paquete android.graphics.drawable) permite definir sus propiedades con
los métodos públicos.
 También puede definir las formas Drawable utilizando XML.
Drawables
Shape Drawable

241
Versión 2.0
<shape xmlns:android=http://schemas.android.com/apk/res/android
android:shape=["rectangle" | "oval" | "line" | "ring"] >
<corners
android:radius="integer"
android:topLeftRadius="integer"
android:topRightRadius="integer"
android:bottomLeftRadius="integer"
android:bottomRightRadius="integer" />
…
Drawables
Shape Drawable. Definición

242
Versión 2.0
<gradient
android:angle="integer"
android:centerX="integer"
android:centerY="integer"
android:centerColor="integer"
android:endColor="color"
android:gradientRadius="integer"
android:startColor="color"
android:type=["linear" | "radial" | "sweep"]
android:useLevel=["true" | "false"] />
Drawables

243
Versión 2.0
<padding
android:left="integer"
android:top="integer"
android:right="integer"
android:bottom="integer" />
<size
android:width="integer"
android:height="integer" />
Drawables
<solid android:color="color" />
<stroke
android:width="integer"
android:color="color"
android:dashWidth="integer"
android:dashGap="integer" />
</shape>

244
Versión 2.0
Drawables
Shape Drawable. Ejemplo
<?xml version="1.0" encoding="UTF-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
android:shape="rectangle">
<stroke
android:width="2dp"
android:color="#FFFFFFFF" />
<gradient
android:endColor="#DDBBBBBB"
android:startColor="#DD777777" android:angle="90" />
<corners
android:bottomRightRadius="7dp"
android:bottomLeftRadius="7dp"
android:topLeftRadius="7dp"
android:topRightRadius="7dp" />
</shape>

245
Versión 2.0
 Un StateListDrawable es un drawable que permite usar imágenes
diferentes para un mismo gráfico en función del estado del mismo.
 Definición:
< selector xmlns:android="http://schemas.android.com/apk/res/android"
android:constantSize=["true" | "false"]
android:dither=["true" | "false"]
android:variablePadding=["true" | "false"] >
<item>…</item>
<item>…</item>
</selector >
Drawables
StateList Drawable

246
Versión 2.0
<item
android:drawable="@[package:]drawable/drawable_resource"
android:state_pressed=["true" | "false"]
android:state_focused=["true" | "false"]
android:state_hovered=["true" | "false"]
android:state_selected=["true" | "false"]
android:state_checkable=["true" | "false"]
android:state_checked=["true" | "false"]
android:state_enabled=["true" | "false"]
android:state_activated=["true" | "false"]
android:state_window_focused=["true" | "false"] />
Drawables
StateList Drawable (items)

247
Versión 2.0
Otros tipos de Drawables
 Layer List: un Drawable que gestiona un array de otros Drawables.
 Estos Drawables son dibujados en el orden del array, siendo el que tiene el índice
mayor el que se dibuja encima de los demás.
 Crea un objeto LayerDrawable.
 Level List: Es un fichero XML que define una serie de Drawables que
pueden ser mostrados alternativamente a través de la asignación de un
valor numérico o «nivel» .
 El Drawable a mostrar será aquel que coincida con un nivel mayor o igual al
establecido.
 Crea un objeto LevelListDrawable. Se puede establecer el nivel con setLevel()
de Drawable o setImageLevel() de ImageView.

248
Versión 2.0
Otros tipos de Drawables
 Inset Drawable: Es un fichero XML que define un drawable que incrusta
otro drawable a una distancia especificadas.
 Útil para vistas que necesitan un fondo más pequeño que sus dimensiones
actuales.
 Clip Drawable: Es un fichero XML que define un drawable que es un
recorte de otro basándose en el nivel actual de ese Drawable
(Drawable.setLevel(), valor máximo 10000, la imagen no está recortada,
nivel 0 totalmente recortada).
 Crea un ClipDrawable.
 Scale Drawable: Un XML que cambia la escala de un drawable en función
de su nivel actual.
 Crea un ScaleDrawable.

249
Versión 2.0
 Esta es una animación tradicional .
 Se que crea con una secuencia de imágenes diferentes y se reproducen
en orden como un rollo de película.
 La clase AnimationDrawable es la base de Frame Animation.
 Se pueden definir el frame de animación mediante código usando la clase
AnimationDrawable, pero es mas simple definirlas en un fichero XML y
almacenarlo en el directorio res/drawable del proyecto.
 El archivo XML se compone de un elemento <animation-list> como el
nodo raíz y una serie de nodos hijos <item> que cada uno define un frame:
una imagen para el frame.
Frame Animation

250
Versión 2.0
Ejemplo. Archivo XML para una animación fotograma por fotograma
Frame Animation
<animation-list xmlns:android="http://schemas.android.com/apk/res/android"
android:oneshot="true">
<item android:drawable="@drawable/rocket_thrust1" android:duration="200"
/>
/>
/>
</animation-list>

251
Versión 2.0
 A la Activity se le añade una animación a un objeto ImageView (archivo
XML rocket_thrust.xml)
AnimationDrawable rocketAnimation;
setContentView(R.layout.main);
ImageView rocketImage = (ImageView) findViewById(R.id.rocket_image);
rocketImage.setBackgroundResource(R.drawable.rocket_thrust);
rocketAnimation = (AnimationDrawable) rocketImage.getBackground();
}
Frame Animation
Ejemplo de Activity al que se le añade una animación

252
Versión 2.0
public boolean onTouchEvent(MotionEvent event) {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
rocketAnimation.start();
return true;
}
return super.onTouchEvent(event);
}
Frame Animation
Ejemplo. Continua

253
Versión 2.0
 No se puede llamar al método start() del AnimationDrawable dentro del
método onCreate() de la Activity, ya que el AnimationDrawable no está
completamente adjuntado a la ventana.
 La animación se podrá iniciar a través de cualquier acción del usuario
posteriormente.
 Si se quiere iniciar la animación automáticamente al inicio de la Activity se
debe hacer en el método onWindowFocusChanged() de la Activity, el
cual se llama cuando Android otorga el foco a su ventana.
Frame Animation
Nota sobre la implementación

254
Versión 2.0
 Con las transiciones TransitionDrawable se pueden generar efectos de
transición entre dos imágenes, pero tan solo dos.
 Definición XML:
<transition xmlns:android="http://schemas.android.com/apk/res/android”>
<item android:drawable="@[package:]drawable/drawable_resource"
android:id="@[+][package:]id/resource_name"
android:top="dimension"
android:right="dimension"
android:bottom="dimension"
android:left="dimension" />
</transition>
Transiciones
Creación de transiciones mediante XML

255
Versión 2.0
 res/drawable/transition.xml
<transition xmlns:android="http://schemas.android.com/apk/res/android">
<item android:drawable="@drawable/image_expand“ />
<item android:drawable="@drawable/image_collapse“ />
</transition>
 Se aplica este drawable a un ImageButton
<ImageButton
android:id="@+id/button"
android:layout_height="wrap_content" android:layout_width="wrap_content"
android:src="@drawable/transition" />
Transiciones
Creación de transiciones mediante XML. Ejemplo

256
Versión 2.0
 Se instancia el TransitionDrawable y se configura como el
contenido de un ImageView.
ImageButton button = (ImageButton) findViewById(R.id.button);
TransitionDrawable drawable = (TransitionDrawable) button.getDrawable();
drawable.startTransition(500);//tiempo en milisegundos
Transiciones
Creación de transiciones mediante XML

257
Versión 2.0
 Una Tween Animation puede realizar una serie de
transformaciones simples (posición, tamaño, rotación y
transparencia) sobre el contenido de un objeto View.
 El animation_package ofrece todas las clases que se utilizan en
un Tween Animation.
Tween Animation
Por ejemplo en un objeto TextView, se puede
mover, rotar, ampliar o reducir el tamaño del texto,
si tiene una imagen de fondo, la imagen se
modificará con el texto.

258
Versión 2.0
 La definición de instrucciones de animación, como los layout, es
más recomendable que se incluyan en ficheros XML, que en
instrucciones de Android, pues son más fáciles de leer, reutilizar e
intercambiar.
 El fichero XML de animación es almacenado en el directorio
res/anim del proyecto.
 El archivo XML debe tener un único elemento raíz, este será un
solo elemento <alpha>, <scale>, <translate>, <rotate>, o el
elemento <set> que contiene grupos de estos elementos (pueden
incluir otro <set>).
 Por defecto, todas las instrucciones de animación se aplican
simultáneamente.
Tween Animation

259
Versión 2.0
<set android:shareInterpolator="false">
<scale
android:interpolator="@android:anim/accelerate_decelerate_interpolator"
android:fromXScale="1.0"
android:toXScale="1.4"
android:fromYScale="1.0"
android:toYScale="0.6"
android:pivotX="50%"
android:pivotY="50%"
android:fillAfter="false"
android:duration="700" />
Tween Animation
Ejemplo: Ensancha, gira y rota simultáneamente una vista

260
Versión 2.0
…
<set
android:interpolator="@android:anim/
decelerate_interpolator">
<scale
android:fromXScale="1.4"
android:toXScale="0.0"
android:fromYScale="0.6"
android:pivotX="50%”
android:startOffset="700"
android:duration="400"
android:fillBefore="false"/>
Tween Animation
…
<rotate
android:fromDegrees="0"
android:toDegrees="-45"
android:pivotX="50%"
android:startOffset="700"
android:duration="400" />
</set>
</set>

261
Versión 2.0
 Para aplicar la animación se ejecuta el siguiente código java.
Tween Animation
ImageView spaceship = (ImageView) findViewById(R.id.spaceshipImage);
Animation hyperspaceJumpAnimation =
AnimationUtils.loadAnimation(this, R.anim.hyperspace_jump);
spaceship.startAnimation(hyperspaceJumpAnimation);

262
Versión 2.0
 Android permite reproducir audio y video de varios tipos de fuentes
de datos.
 Puede reproducir audio o vídeo de los archivos multimedia
almacenados en los fuentes de la aplicación (archivos raw)
 A partir de archivos del sistema.
 O de una secuencia de datos a través de una conexión de red.
 Para reproducir contenido multimedia (audio o vídeo) se usa la
clase MediaPlayer.
 La plataforma también permite grabar audio y vídeo cuando sea
soportado por el hardware del dispositivo.
 Para grabar audio o vídeo se utiliza la clase MediaRecorder.

263
Versión 2.0
SoundPool
PlayBack de audio
 Para la reproducción de audio también se usa la clase SoundPool.
 Solo es posible reproducir en los dispositivos de salida estándar: altavoz o
auriculares Bluetooth.
 Se emplea para audio de baja latencia.
 No es posible reproducir archivos de sonido mientras se mantiene una
conversación de audio.

264
Versión 2.0
SoundPool. Ejemplo – Inicialización de sonidos
PlayBack de audio
public static void initSounds(Context context) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
AudioAttributes audioAttrib = new AudioAttributes.Builder()
.setUsage(AudioAttributes.USAGE_GAME)
.setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
.build();
mSoundPool = new SoundPool.Builder().setAudioAttributes(audioAttrib).setMaxStreams(2).build();
}
else {
mSoundPool = new SoundPool(2, AudioManager.STREAM_MUSIC, 0);
}
mSoundPoolMap = new HashMap<Integer,Integer>(3);
mSoundPoolMap.put(S1, mSoundPool.load(context, R.raw.s1, 1));
}

265
Versión 2.0
SoundPool. Ejemplo – Reproducción de un sonido del “pool”
PlayBack de audio
public static void playSound(Context context, int soundID) {
if (mSoundPool == null || mSoundPoolMap == null) {
initSounds(context);
}
float volume = 1.0f;// whatever in the range = 0.0 to 1.0
// play sound with same right and left volume, with a priority of 1,
// zero repeats (i.e play once), and a playback rate of 1f
mSoundPool.play((Integer) mSoundPoolMap.get(soundID), volume, volume, 0, 0, 1f);
}
final int play(int soundID, float leftVolume, float rightVolume, int priority, int
loop, float rate)
Play a sound from a sound ID.

266
Versión 2.0
SoundPool. Método play()
PlayBack de audio
final int play (int soundID, float leftVolume, float
rightVolume, int priority, int loop, float rate)
 Con este método se reproduce un sonido con un
identificador concreto.
soundID int un soundID devuelto por la función load()
leftVolume float volumen del lado izquierdo (rango= 0.0 a 1.0)
rightVolume float volumen del lado derecho (rango = 0.0 a 1.0)
priority int prioridad del stream (0 = prioridad más baja)
loop int veces a repetir (0 = sin bucle, -1 = bucle infinito)
rate float velocidad de reproducción (1.0 = normal, rango de 0.5 a 2.0)

267
Versión 2.0
 Nos permite reproducir, sobre todo, sonido dentro de la aplicaciones. Para hacer
esto:
 Poner el archivo de sonido en el directorio res/raw del proyecto.
 Crear una instancia de MediaPlayer y hacer referencia a ese recurso usando
MediaPlayer.create y luego llamar a start() en la instancia:
MediaPlayer mp = MediaPlayer.create(context, R.raw.sound_file_1);
mp.start();
 Para hacer uso de las distintas funciones de reproducción se puede llamar los
distintos métodos de MediaPlayer: stop(), reset(), pause(), etc.
PlayBack de audio
Reproducción desde archivos raw

268
Versión 2.0
 Se pueden reproducir archivos desde el sistema de ficheros o desde una
URL. Para hacer esto:
 Crear una instancia de MediaPlayer.
 Llamar a setDataSource con la cadena que contenga el path o url donde se
encuentra el archivo para reproducir.
 Llamar a prepare() y despues start() de la instancia.
MediaPlayer mp = new MediaPlayer();
mp.setDataSource(PATH_TO_FILE);
mp.prepare();
mp.start();
 El resto de funciones es igual que para la reproducción de archivos raw.
PlayBack de audio
Reproducción desde archivo o stream

269
Versión 2.0
 Para capturar audio desde el dispositivo se necesitan estos pasos:
1. Crear una instancia de android.media.MediaRecorder.
2. Crear una nueva instancia de android.content.ContentValues y poner
algunas de las propiedades estándar, como TÍTULO, TIMESTAMP, y
todos los importantes MIME_TYPE.
3. Definir la ruta del archivo de datos (se puede usar
android.content.ContentResolver para crear una entrada en la base de
datos de contenido y conseguir que se asigne automáticamente una
ruta que se pueda utilizar).
4. Ajustar la fuente de audio mediante MediaRecorder.setAudioSource().
5. Formatear el archivo de salida utilizando
MediaRecorder.setOutputFormat().
Captura de audio

270
Versión 2.0
 Para capturar audio desde el dispositivo se
necesitan estos pasos:
6. Ajuste el codificador de audio con
MediaRecorder.setAudioEncoder().
7. Llamar a prepare() en la instancia MediaRecorder.
8. Para iniciar la captura de audio llamar a start().
9. Para detener la captura de audio, llamar a stop().
10.Al terminar liberar la instancia llamando a release().
Captura de audio

271
Versión 2.0
 El siguiente ejemplo ilustra cómo configurar la captura de audio.
// could use setPreviewDisplay() to display a preview to suitable View here
recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
recorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AMR_NB);
recorder.setOutputFile(path);
recorder.prepare();
recorder.start();
 Para parar la grabación:
recorder.stop();
recorder.release();
Captura de audio

Capítulo 1 introducción a los servicios y aplicaciones móviles

Más contenido relacionado

Destacado

Similar a Capítulo 1 introducción a los servicios y aplicaciones móviles

Último

Capítulo 1 introducción a los servicios y aplicaciones móviles