3. Objetivos
3
Arquitectura de las
aplicaciones
Conocer principales componentes
lógicos de una aplicación Android.
Integración & comunicación entre
componentes.
Analizar los diferentes tipos de
recursos estáticos android.
Identificar los elementos visuales de
una aplicación android.
Describir la funcionalidad de los
diferentes widget de un GUI.
Conocer las notificaciones, eventos,
menús y diálogos del GUI Android.
Establecer políticas de permisos y
recursos de seguridad a la hora de
desarrollar apps Android.
4. Arquitectura de las aplicaciones: Componentes de aplicación
Principales componentes para el desarrollo de
aplicaciones en Android:
4
6. Arquitectura Aplicaciones: AndroidManifest.xml
Describe los componentes de la
aplicación.
Se declaran permisos y
librerías necesarias para
ejecutar la aplicación.
Icono, min SDK, Metadatos
6
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="prueba.Android"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".HelloWord"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<uses-sdk android:minSdkVersion="7" />
</manifest>
7. Arquitectura de las aplicaciones: Componente Activity
7
Son las ventanas con las que interactúa el
usuario.
Es la unidad atómica de responsabilidad
Alta cohesión & bajo acoplamiento
Una aplicación Android puede contener varias
Activity, una de ellas marcada como principal.
Establecen el contenido visual con:
setContentView(…)
Heredan de la clase android.app.Activity
8. Arquitectura de las aplicaciones: Componente Activity II
8
package com.slashmobility.curso.android;
import android.app.Activity;
import android.os.Bundle;
public class HelloWorld extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
9. Ciclo de vida de la Activity
Cambio configuración->
Destruye Actividad
ANR si la Activity no
responde a un evento
en 5 segundos o
Utilizar handlers para
evitar ANR
9
Mensaje ANR
Estados de la Activity
10. Ciclo de vida de la Activity
public class HelloWorld extends
Activity {
@Override
protected void onCreate(Bundle
savedInstanceState) {
// TODO Auto-generated method stub
super.onCreate(savedInstanceState);
}
@Override
protected void onStart() {
// TODO Auto-generated method stub
super.onStart();
}
@Override
protected void onResume() {
// TODO Auto-generated method stub
super.onResume();
}
@Override
protected void onPause() {
// TODO Auto-generated method stub
super.onPause();
}
10
Estados de la
Activity
12. Intents: Definición
12
Mecanismo para el paso de mensajes, declara
la intención de realizar una acción.
Utilizados para iniciar Activities o comunicarlas
entre ellas.
Útiles para desacoplar componentes (no
necesitan conocer implementaciones).
Existen acciones nativas que pueden ser
lanzadas con los Intents (crean las Actividades
para realizar esas acciones).
13. Intents: Estructura
13
Contienen:
Action: La acción general a realizar, tal como
ACTION_VIEW, ACTION_EDIT...
Data: Los datos sobre los que la acción debe operar.
Estos se expresan en forma URI (Uniform Resource
Identifier)
Ejemplo de pares Action / Data:
ACTION_VIEW: content://contacts/people/1
ACTION_DIAL: tel://687123456
ACTION_DIAL: content://contacts/people/2
14. Intents: Atributos adicionales
Atributos adicionales:
Category: ofrece información adicional sobre el tipo
de componente que debe recoger el Intent.
Type: tipo MIME de los datos del Intent. No es
necesario por defecto.
Component: indica qué componente (clase)
especificado en AndroidManifest.xml realizará la
acción del Intent. Si se especifica, se entregará a
una instancia de esa clase, si no Android buscará el
componente que mejor considere.
Extras: información adicional (pares key-value).
14
15. Intents: Acciones nativas
ACTION_ANSWER: Abre una Actividad para gestionar llamadas entrantes.
ACTION_CALL: Inicia una llamada utilizando el número pasado en el URI.
ACTION_DELETE: Borra una entrada de datos especificados en el URI.
ACTION_DIAL: Aparece el dialer con el número especificado.
ACTION_EDIT: Invoca una actividad para editar la información del URI.
ACTION_INSERT: inserta nuevos items (por ejemplo, lista de contactos)
ACTION_PICK: recupera información de un item.
ACTION_SEARCH: Invoca una actividad para realizar búsquedas.
ACTION_SENDTO: envia un mensaje a un contacto.
ACTION_SEND: envía la información especificada en el URI.
ACTION_VIEW: petición para ver una información de la mejor manera
posible.
ACTION_WEB_SEARCH: realiza búsquedas Web de la información del
URI.
15
16. Intents: Uso en Activities
16
Lanzar una actividad
Context.startActivity(Intent)
Activity.startActivityForResult(Intent)
Uri uri = Uri.parse("http://www.google.com");
Intent intent = new
Intent(Intent.ACTION_VIEW,uri);
startActivity(intent);
17. Ejemplos y ejercicios: Activities-LaunchDemo
17
Ejemplo
Proyecto Launch: cómo
realizar una petición a
Android para realizar
algún tipo de acción.
En este ejemplo podemos
ver cómo se invoca una
Activity para abrir una
página Web.
18. Intents: Explícitos o Implicitos
18
En los Intents, se puede especificar el
destinatario o no:
Explícitos: Si se establece un destinatario (vía
setComponent(ComponentName) o
setClass(Context, Class)), se le envía directamente.
Implícitos: Si no hay destinatario, se debe incluir
suficiente información para que Android determine el
mejor componente candidato para ejecutar el Intent.
Android utiliza los Intent-filters para buscar el
mejor candidato
19. Intents: Ejemplos comunicación Activities
19
Iniciar actividad para recoger los contactos
Uri uri = Uri.parse(“content://contacts/people”);
Intent intent = new Intent(Intent.ACTION_PICK, uri);
startActivityForResult(intent, PICK_CONTACT_SUBACTIVITY);
...
public void onActivityResult(int requestCode, int resultCode,
Intent data) {
switch(resultCode)
{...}
}
Iniciar una sub-actividad y esperamos sus resultados.
Intent result = new Intent(null, data);
result.putExtra(IS_INPUT_CORRECT, inputCorrect);
if(TODO_OK)
setResult(RESULT_OK, result);
else
setResult(RESULT_CANCELED, null);
finish();
20. Ejemplos y ejercicios: Intent-LaunchClass
20
Ejemplo
Intent-LaunchClass: cómo se
puede invocar a una Activity
desde otra utilizando Intents.
En este ejemplo podemos ver
cómo se invoca una Activity de
manera simple con un botón,
que muestra una segunda
Activity con información en la
pantalla. Pulsando de nuevo el
botón se puede regresar a la
Activity anterior.
21. Arquitectura aplicaciones: Intent filters
21
La manera en que Android sabe como servir un
Intent implícito entre todas las aplicaciones
instaladas.
Componente que mejor pueda realizar esa acción.
Se registra declarativamente en <intent-filter>
AndroidManifest.xml
Tres elementos fundamentales para la
resolución:
action: nombre de la acción que puede
realizar
data: tipo MIME, no es obligatorio
category: especifica bajo que circunstancias
la acción puede ser ejecutada
24. Arquitectura de las aplicaciones: Broadcast Receiver
24
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
public class MyBroadcastReceiver extends BroadcastReceiver {
public void onReceive(Context context, Intent intent) {
//TODO: React to the Intent received.
}
}
Utilizados para recibir y actuar ante eventos/mensajes
en forma de Intents que genera Android o las apps.
Tu aplicación pueden indicar el deseo de ser
notificadas:
Programáticamente: Context.registerReceiver()
Declarativamente: <receiver> AndroidManifest.xml
Hereda de android.content.BroadcastReceiver
25. BroadcastReceivers - Usos
25
Ejemplos de uso de BroadcastReceiver:
Entrega Síncrona
Context.sendBroadcast(Intent)
Entrega Asíncrona
Context.sendOrderedBroadcast(Intent)
Ejemplos de eventos generados por Android:
android.intent.action.ACTION_BATTERY_LOW
android.intent.action.ACTION_HEADSET_PLUG
android.intent.action.BOOT_COMPLETED
android.provider.Telephony.SMS_RECEIVED
android.intent.action.GTALK_CONNECTED
android.net.wifi.WIFI_STATE_CHANGED
26. Arquitectura Aplicaciones: Broadcast & Intents
26
Intent intent = new Intent(NEW_INTENT);
intent.putExtra(“param1”, value1);
intent.putExtra(“param2”, value2);
intent.putExtra(“param3”, value3);
sendBroadcast(intent);
Lanzamiento de Broadcast Intent
Los Intents tienen la capacidad de enviar mensajes estructurados
Los Intents Broadcast se utilizan para notificar oyentes de acciones
determinadas o eventos
Android utiliza Broadcast Intents para difundir eventos de sistema
(bateria baja, llamada entrante...)
Se construye dentro de la aplicación de manera declarativa y se
utiliza el método sendBroadcast() para enviarlo.
Igual que en un Intent estándar, se fijan los parámetros action, data,
y category para que los posibles Broadcast Receivers determinen su
interés.
28. Ejemplos y ejercicios: BroadcastReceiver-Demo
28
Ejemplo
BroadcastReceiver-Demo: cómo
crear filtros para que un
BroadcastReceiver pueda recibir un
Intent y procesarlo según necesite.
En este ejemplo podemos ver cómo
la Activity principal crea un
Intent y lo envía modo broadcast
(multidifusión). Los componentes
“oyentes” ,en este caso un
BroadcastReceiver llamado
IncomingReceiver detectará ese
evento y mostrará un mensaje por
la salida estándar (en este caso
el fichero de log, al que se puede
acceder vía adb logcat)
29. Arquitectura de las aplicaciones: Content Provider
29
Único mecanismo para compartir datos entre
aplicaciones.
En android no hay área de datos comunes.
Permite desacoplar la capa de aplicación de la capa de datos
(data-source agnostic)
Heredar de ContentProvider e implementar una interfaz
para consultar y/o modificar los datos.
Nunca se trata con el ContentProvider siempre con el
ContentResolver.
Accesible utilizando una simple URI.
Recorrer los datos a través de un Cursor.
30. Arquitectura Aplicaciones: Proveedores nativos Android
30
Browser: permite leer o
modificar bookmarks,
historial del navegador o
búsquedas web.
CallLog: permite ver o
modificar el historial de
llamadas (entrantes o
salientes).
Contacts: Recupera,
modifica, o almacena
detalles de contactos.
MediaStore: acceso a los
recursos multimedia del
dispositivo (audio, video...)
Settings: acceso a las
preferencias del dispositivo.
32. Arquitectura Aplicaciones: Content Providers - consultas
32
Tres piezas para construir una consulta
URI del content provider.
Los nombres de los campos a recibir (Projections)
El tipo de datos de dichos campos
Dos métodos mismos parámetros
ContentResolver.query(…) : Cursor
Activity.managedquery(…): Cursor
Ejemplo Acceso a la agenda de Contactos
33. Arquitectura Aplicaciones: Content Providers - modificaciones
33
Los datos de un content provider se pueden:
Añadir nuevos registros y valores.
Actualizar valores de registros existentes.
El tipo de datos de dichos campos
Update:
getContentResolver().update(MyProvider.CONTENT_URI,
newValues, where, null);
Delete:
getContentResolver().delete(myRowUri, null, null);
Insert:
newValues.put(COLUMN_NAME, newValue);
Uri myRowUri =
getContentResolver().insert(MyProvider.CONTENT_URI,
newValues);
34. Ejemplos y ejercicios: ContentProvider-Queries
34
Ejemplo
ContentProvider-Queries:
cómo crear un
ContentProvider que
proporcione contenidos
predefinidos, creando
métodos par a la consulta y
actualización de los contenidos
del ContentProvider.
En este ejemplo podemos ver
cómo crear un
ContentProvider, listar una
lista de datos introducidos
por defecto en el proveedor,
y añadir nuevas entradas.
35. Arquitectura de las aplicaciones: Componente Service
35
No tienen UI y de ejecutan en el background de
manera indefinida. (XJ: Reproductor música)
Expone una interfaz para conectarse (Bind to)
Corren en el mismo thread principal pero tienen
más prioridad que la Activity.
Heredan de android.app.Service
Location Manager, Media Controller, Notification
Manager son ejemplos de Services.
36. Servicios & Comunicación & Intents
36
Ejemplos de uso de intents en servicios:
Context.startService(Intent) para iniciar un servicio.
Context.stopService(Intent): Detiene un servicio
StopSelf(): El servicio se detiene el mismo
Bind:
Comunicación síncrona.
Clase android.os.Binder
Método
public IBinder
onBind(Intent
intent)
37. Arquitectura Aplicaciones: Services: creación de servicios
37
Ejemplo de creación de un servicio:
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
public class MyService extends Service {
@Override
public void onCreate() {
// TODO: Actions to perform when service is created.
}
@Override
public IBinder onBind(Intent intent) {
// TODO: Replace with service binding implementation.
return null;
}
Actualizar archivo manifest:
<service android:enabled=”true”
android:name=”.MyService”></service>
38. Arquitectura Aplicaciones: Services - control de los servicios
38
Para iniciar un servicio:
startService(new Intent(MyService.MY_ACTION));
Para parar un servicio iniciado:
ComponentName service = startService(new Intent(this,
BaseballWatch.class));
// Stop a service using the service name.
stopService(new Intent(this, service.getClass()));
Para conectar con un servicio (bind()):
1.Crear una clase X que implemente ServiceConnection, con los métodos
onServiceConnected y onServiceDisconnected.
2.Crear una interfaz Y que hará de intermediaria entre la Activity y el
Service para comunicar.
3.En la clase Service, implementar el método onBind() para que devuelva
una instancia de la interfaz Y.
4.Para relacionarlo todo, en la Activity hacer un bindService(Service,
X), que relacionará la clase X con el Service. Al hacer esto, en el
método onServiceConnected, llegará la instancia de la clase Y que la
Activity podrá utilizar para invocar métodos.
39. Ejemplos y ejercicios
39
class com.slashmobility
Activ ity CounterConnection
- onServiceConnected(...)
- onServiceDisconnected(...)
«interface»
ServiceConnection
+ onServiceConnected(...)
+ onServiceDisconnected(...)
«interface»
ICounterService
+ getCounter(): int
DualServ ice
- binder: ICounterService
- onBind(...)
«interface»
Service
Service-CreateService: cómo crear un Service con la
funcionalidad mínima
En este ejemplo podemos ver cómo se invoca un servicio utilizando un
botón de Start y cómo se para con el botón de Stop.
Service-MusicDemo: cómo utilizar un Service para delegar
trabajo que debe ejecutarse en background:
Ejemplo de invocación de servicio que ejecuta un audio hasta que
finaliza.
Service-binding: cómo interactúa con el Service
Ejemplo para interactuar con el Service, mandando o recibiendo
información a través de una interfaz genérica.
42. Arquitectura de las aplicaciones: Resources
42
Los recursos (Resources) son
elementos externos que se quieren
incluir y referenciar en la aplicación.
Imágenes, videos, audio, textos, layouts,
Se incluyen declarativamente (/res)
acediendose @<tipo>/<nombre>
Programáticamente son accesibles
a través de la clase R (compilada
con aapt (Android Asset Packaging Tool))
R.resource_tipo.resource_nombre
43. Resources: Tipos de Recursos
43
Cada tipo de recurso en una
carpeta /res.
drawable: Imágenes, Iconos, …
layout: Layout para organizar views.
values:
string.xml: Cadenas de texto de la app.
colors.xml: Gama de colores de la app.
dimens.xml: Tamaño de las fuentes.
anim: Animaciones y efectos.
raw: Recursos rasos (audio, video).
menu: Menús y diálogos.
xml: Resto xml (Preferencias, app
widget, …)
44. Resources: Sufijos (Qualifiers)
44
Cada tipo de recurso puede tener su
propia configuración según contexto.
Se añade un sufijo /tiporecurso-xxx
L10N & I18N
Language: (-es, -en, -de, …)
Country Code: (-123)
Region: (-ca, -us, …)
Pantallas
Orientation: (-land, -port & -square)
Pixel density: (-hdpi, -mdpi & -ldpi)
Navigation: (D-pad, trackball & wheel)
Size: (small, normal & large)
Version: API (-v1, etc)
…
45. Ejemplos y ejercicios: 8- Resource-Images
45
Resources-Image: en este
ejemplo se muestra cómo
utilizar recursos tipo
imágenes en un linear
layout.
46. Ejemplos y ejercicios: 9 – Resources-XML
46
Resources-XML: en este
ejemplo se muestra cómo
utilizar los recursos de tipo
xml, situados en
/res/values/words.xml
Este ejemplo accede a la información de
los ficheros XML (/res/xml/words.xml) y
muestra una lista con los datos
clickables.
47. Arquitectura de las aplicaciones: Interfaces de usuario (UI)
47
En Android, las interfaces se construyen
utilizando los objetos View y ViewGroup
Las Views son el punto de interacción con
el usuario (setContentView() en Activity)
Las ViewGroup son una agrupación lógica
de elementos visuales (Views)
android.widget = subclases View con funcionalidad
48. Interfaces de usuario: Views
48
Unidad básica de componente de UI
Todas los controles visuales heredan
de la clase android.view.View
Ocupa un área rectangular en la
pantalla.
Son responsable de dibujarse:
Sus medidas, layout, como se pintan, …
También gestionan los eventos = interacciones
que reciben del usuario:
Cambio de focus, scrolling, clicks, gestos, ...
Se pueden crear por código (programáticamente)
o por XML (declarativamente)
49. Interfaces de usuario: Widget
49
Son Views ‘preconstruidas’ que vienen incluidas
en la plataforma Android.
¡NO confundir con App Widget!
Están incluidos en el paquete android.widget.
Son casi 50 clases y 30 interfaces
Button, TextView, EditText, ListView, CheckBox,
RadioButton, Gallery, Spinner …
AutoCompleteTextView, ImageSwitcher &
TextSwitcher.
Se pueden customizar y crear widget nuevos.
Extender un subclase de View.
Implementar algunos override methods.
onDraw(), onMeasure() & onKeyDown()
Listo para usar tu nuevo widget!
50. ¿Cómo Android pinta Views?
50
Cada ViewGroup responsable de pedir
a sus hijos que se pinten.
Cada View se pinta a través del método
draw().
El proceso de pintar layout consiste en:
measure(int, int): Cuanto de grande es
control.
layout(int, int, int, int): Cada padre es
responsable de posicionar a sus hijos en
base a las medidas anteriores.
Para lo anterior ‘padre’ e hijo se
comunican con dos clase
View.MeasureSpec : UNSPECIFIED,
EXACTLY & AT_MOST.
ViewGroup.LayoutParams : FILL_PARENT,
WRAP_CONTENT, <número exacto>…
51. Interfaces de usuario: Programáticamente
51
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
TextView myTextView = new
TextView(this);
myTextView.setText(“Hola Clase”);
setContentView(myTextView);
}
NO recomendable ya que:
Creación de vista programática nos
acoplamos a los detalles visuales del
código.
Deberíamos repetir código para L10N,
I18N, diferentes tamaños pantalla & pixel,
…
52. Interfaces de usuario: Declarativamente - Por XML
52
En el archivo /res/layout/main.xml:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"> <!-- crea un layout con
la distribución de los elementos visuales -->
<TextView android:id="@+id/myTestView"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:src="@drawable/jupiter"/> <!-- crea un widget TextView -->
</LinearLayout>
En el código de la Activity:
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main); //recurso main.xml
TextView myTextView =
(TextView)findViewById(R.id.myTextView);
myTextView.setText(“Hola clase”);
}
53. Ejemplos y ejercicios: Views-SimpleViews
53
Ejemplo
Views-SimpleViews: en este
ejemplo se puede ver cómo
se pueden crear Views,
cambiar sus atributos y
sobrescribir sus métodos
para añadir funcionalidad.
La Activity principal
AndroidViews crea a través del
menú de la aplicación (pulsando
el botón menú del dispositivo)
una serie de opciones que
invocarán otras Activities que
muestran distintas Views
(Button, CheckBox, EditText,
RadioGroup, Spinner…)
54. Interfaces de usuario: Layouts
54
Su objetivo es controlar la
posición de las Views hijas en
la pantalla.
Organizados jerárquicamente.
También conocidos como
Layout Managers.
Son extensiones de ViewGroup
Se pueden anidar, es decir,
incluir Layouts dentro de
Layouts
Android proporciona una serie
de Layouts por defecto.
55. Interfaces de usuario: Tipos Layouts
55
LinearLayout RelativeLayout AbsoluteLayout
FrameLayout: el más simple, añade cada View hija en la esquina
superior izquierda. Cada vez que se añade una, tapa la anterior,
diseñado para mostrar un único elemento.
LinearLayout: añade cada View hija en linea recta (horizontal o
vertical)
RelativeLayout: añade las Views unas en relación a otras.
TableLayout: añade las Views usando un grid (cuadrícula), a
través de filas y columnas. Es similar a las tablas HTML.
AbsoluteLayout: añade las vistas dando coordenadas absolutas.
56. Interfaces de usuario: ViewGroups
56
Objetos ViewGroup que albergan hijos View:
Algunos contienen su propia estructura gráfica (form UI)
Otros son estructuras ‘invisibles’ para gestionar el layout de sus hijos.
57. Interfaces de usuario: Layouts Atributos XML
57
ID:
(android:id="@+id/my_button“):
Identificador unívoco del
View.
Layout Parameters: android:layout_XXX):
Son heredables.
Varían según el tipo de layout
layout_width, layout_height: wrap_content | fill_parent
layout_position: Expresada en pixels, se recomienda
(dp)
size: Tamaño expresado en pares (height, width)
paddings margins.
58. Ejemplos y ejercicios: Layout
58
Layouts-Linear: en este ejemplo se muestra cómo
distribuir las vistas de una manera lineal.
La Activity principal LinearLayoutDemo muestra cómo se
pueden modificar las posiciones de las vistas en tiempo de
ejecución. En el archivo main.xml se han creado distintos
Layouts. Remarcar la utilización del atributo orientation.
Layouts-Relative: en este ejemplo se muestra cómo
distribuir las vistas de una manera relativa entre las
Views.
Analizar el archivo main.xml, donde se muestra cómo crear
tres vistas, relativas unas a otras.
Layouts-Scroll: distribución con Scroll de las vistas
En este ejemplo se puede ver un TableLayout scrollable con
Views simples.
Layouts-Table: ejemplo simple donde distribuir las
Views en forma de tabla
Analizar el archivo main.xml, donde se muestra cómo crear
distintas vistas en forma de tabla, similar a HTML.
59. Arquitectura de las aplicaciones: Notificaciones al usuario
59
Una vez añadido View/Widget a
nuestro UI, necesitamos conocer
como interaccionar/notificar al
usuario.
Algunas notificaciones requieren
respuesta del usuario, otras no.
Ejemplos: batería baja, confirmación
de recepción de un archivo, barras
de progreso, etc.
Para cada tipo de notificación se
requerirá una manera concreta de
informar al usuario: vibración,
iluminación LEDs
60. Arquitectura de las aplicaciones: Captura de eventos
60
Definiendo un Event Listener
Sobrescribiendo un Handler de un
evento concreto del View.
61. Arquitectura de las aplicaciones: Notificaciones al usuario
61
Toast:
Para breves mensajes
desde el background
Status Bar:
Para recordatorios persistentes
que requieren del usuario
Dialog:
Para notificaciones relacionadas
con la Activity
62. Ejemplos y ejercicios: Notifications-Demo
62
Ejemplo
Notifications-Demo:
en este ejemplo se
muestra algunos de
los distintos
mecanismos para
mostrar
notificaciones
La Activity principal
muestra una serie de
botones que invocan
distintos eventos de
notificación al usuario.
63. Interfaces de usuario: componentes compuestos (I)
63
Normalmente hacen referencia
a Views con funcionalidad
compleja añadida
Para crear componentes
compuestos, se pueden crear
Views y añadirle métodos para
la gestión de eventos,
componentes visuales, etc
Se pueden extender (heredar)
componentes de Android por
defecto, sobrescribiendo la
funcionalidad que se necesite
64. Interfaces de usuario: componentes compuestos (II)
64
TextView
EditText con un Button
ListView Spinner
66. Interfaces de usuario: AdapterView
66
Son View cuyos hijos están
determinados por un Adapter.
Encargados de rellenar datos
(binding) y gestionar selecciones
de usuario (handling).
Útiles cuando queremos mostrar
visualmente datos almacenados
View
AdapterView
Adapter
Datos
Button, ImageButton, EditText, …
ListView, GridView, Spinner, Gallery, ..
CursorAdapter, ListAdapter,
SpinnerAdapter,Content Provider, Cursor, String {}, File, URI
67. Ejemplos y ejercicios: Compound Views
67
Compound-Autocomplete: en este ejemplo se muestra como
tener un campo donde Android da sugerencias de posibles
palabras a rellenar.
La Activity principal muestra un campo de Autocomplete, con un
Adapter que hace de puente entre el campo y las posibles sugerencias.
Compound-Grid: en este ejemplo se una lista de Views
distribuidas en forma de grid en la pantalla
Se muestra cómo distribuir elementos de tipo View por la pantalla,
utilizando un Adapter que sobrescribe los métodos necesarios y
aplicando el Layout correspondiente.
Compound-List: ejemplo simple que visualiza una lista de Views.
Se muestra una lista simple aplicando Layouts utilizando un
ArrayAdapter.
Compound-Spinner: se muestra como realizar un Spinner con
Adapters
Se crea nuevamente un ArrayAdapter con la información, pero esta vez
la propia Spinner lo utiliza para formatear los elementos.
Compound-DatePicker: se muestra como utilizar los pickers de
fecha y hora
Se crea una Actividad que muestra los controles para modificar fecha y
hora.
68. Interfaces de usuario: Menus
68
Proporcionan interfaces
amigables que muestran la
funcionalidad de nuestra app.
Android facilita la creación de
estos menús
estandarizándolos.
También se pueden crear a
través de XML.
En /res directorio /menu
.xml con <menu> & <item>
MenuInflater.inflate(R.menu.x)
Tres tipos de menús de
aplicación.
69. Menus: Options Menu
69
Contiene un máximo de 6
elementos con iconos.
Si se necesitan más, se incluyen en el
menú extendido (aparece al pusar el
botón + )
El único que no soporta checkbox
ni radio-buttons.
La primera vez que se abra,
Android llamará al método
onCreateOptionsMenu() de la
Activity
Cuando el usuario presione una
opción del menú, se invocará el
método onOptionsItemSelected()
70. Menus: Options Menu (II)
70
Creación de Option Menu vía código:
/* Creates the menu items */
public boolean onCreateOptionsMenu(Menu menu) {
menu.add(0, MENU_NEW_GAME, 0, "New Game");
menu.add(0, MENU_QUIT, 0, "Quit");
return true;
}
/* Handles item selections */
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_NEW_GAME:
newGame();
return true;
case MENU_QUIT:
quit();
return true;
}
return false;
}
71. Ejemplos y ejercicios: Menu-OptionMenu
71
Ejemplo
Menu-OptionMenu: en este ejemplo
se muestra como crear un Option
Menu y interactuar con él.
La Activity principal
SimpleShowMenuDemo crea un botón
que al presionarlo muestra el Option
Menu de la aplicación. Como se ha
comentado, este menú también puede
ser accedido presionando el botón MENU
del dispositivo.
El Menu, está formado por varios
elementos textuales a los que se les
asigna una serie de identificadores. Al
seleccionar uno de los elementos del
menú, el método onOptionsItemSelected
recibirá el evento y podrá utilizar esos
identificadores para saber la opción
escogida.
72. Menus: Context Menu
72
Conceptualmente similar al
botón derecho del ratón en el
PC.
Presión sobre la vista unos dos
segundos.
Al aparecer, se invocará el
método onCreateContextMenu()
Al seleccionar, se invocará el
método onContextItemSelected()
Para asociar una View a este menu
registerForContextMenu (View view)
73. Menus: Context Menu (II)
73
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {
super.onCreateContextMenu(menu, v, menuInfo);
menu.add(0, EDIT_ID, 0, "Edit");
menu.add(0, DELETE_ID, 0, "Delete");
}
public boolean onContextItemSelected(MenuItem item) {
AdapterContextMenuInfo info = (AdapterContextMenuInfo)
item.getMenuInfo();
switch (item.getItemId()) {
case EDIT_ID:
editNote(info.id);
return true;
case DELETE_ID:
deleteNote(info.id);
return true;
default:
return super.onContextItemSelected(item);
}
}
Creación de Context Menu vía código:
74. Ejemplos y ejercicios: Menu-ContextMenu
74
Ejemplo
Menu-ContextMenu: se muestra
de qué manera utilizar los
ContextMenu, menús
dependientes de las vistas
sobre las que se presiona.
La Activity principal registra dos
Views (en este caso dos botones)
para que puedan mostrar
ContextMenus.
El método onCreateContextMenu de
la Activity se sobrescribe y se
invoca al crear un ContextMenu en
la Activity. En este caso, en función
de la View (Botón ) seleccionado,
se muestra un menú o otro, y al
seleccionar una de las opciones se
muestra una información por
pantalla.
75. Menus: Submenus
Se puede añadir dentro de cualquier menú, excepto en
otro submenú.
Ideal para categorizar funcionalidades de nuestra app.
Igual que en los Option Menu, al pulsar de invocará el
método onOptionsItemSelected()
75
76. Menus: Submenus (II)
76
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;
}
Creación de SubMenu vía código:
77. Ejemplos y ejercicios: Menu-SubMenu
77
Ejemplo
Menu-SubMenu: se muestra de
qué manera crear Submenus
dentro de los OptionMenu.
La Activity principal
SimpleShowMenuDemo crea un botón
que al presionarlo muestra el Option
Menu de la aplicación. Como se ha
comentado, este menú también puede
ser accedido presionando el botón
MENU del dispositivo.
En este caso, se puede comprobar
como al crear las opciones de menú
(método onCreateOptionsMenu) se
añaden las opciones de submenú.
78. Arquitectura de las aplicaciones: Seguridad y permisos
78
Seguridad basada en el Kernel de Linux, cada paquete tiene un
único userID y procesos en sandbox, por lo que no pueden ser
afectados entre sí
Los permisos son un mecanismo a nivel de aplicación, que
permiten el acceso a un recurso determinado (Red, envío de
SMS..)
Se pueden crear en AndroidManifest.xml
<permission
android:name=”com.paad.DETONATE_DEVICE”
android:protectionLevel=”dangerous”
android:label=”Self Destruct”
android:description=”@string/detonate_description”>
</permission>
Y se pueden asignar en el tag activity:
<activity
android:name=”.MyActivity”
android:label=”@string/app_name”
android:permission=”com.paad.DETONATE_DEVICE”>
</activity>
79. Ejemplos y ejercicios: Seguridad
79
Ejemplo
Aplicación de mail: configurar una cuenta de correo de
Android.
1. Ejecutar la aplicación Email del emulador y configurar una cuenta de correo
2. En la ruta /data/data/com.android.email/databases tenemos las bases de
datos relacionadas con el correo.
3. Si ejecutamos >sqlite3 database podemos conectarnos con las BD de la
aplicación.
4. Al ejecutar >.tables se pueden ver las listas de tablas de la BD.
5. Al ejecutar >select * from messages; se puede ver los mails de usuarios.
Esto es una infracción de seguridad, ya que deberían disponer de algún tipo
de encriptación.
80. Conclusiones
80
Arquitectura de las
aplicaciones
Conocer principales componentes
lógicos de una aplicación Android.
Integración & comunicación entre
componentes.
Analizar los diferentes tipos de
recursos estáticos android.
Identificar los elementos visuales de
una aplicación android.
Describir la funcionalidad de los
diferentes widget de un GUI.
Conocer las notificaciones, eventos,
menús y diálogos del GUI Android.
Establecer políticas de permisos y
recursos de seguridad a la hora de
desarrollar apps Android.
Interfaces GUI
[45..75]
Componentes
Lógicos [6..39]
Activities Intents
Int. Filters
Broadcast
Receiver
Content
Provider
Services
Views &
Widget
ViewGroup
& Layout
Menus
Notificaciones & Eventos
Compound View &
Adapters
Notes de l'éditeur
Tema 4 del curso, que nos llevará aprox 2 días.
Conocer los principales componentes lógicos
Analizar los controles graficos disponibles
Views, Widget, Layout, Menus, dialogos, …
Fastforwarr cómo se ejecutan las aplicaciones en Android:
1. Escribir en JAVA
2. generar el .class
3. generar el .dex
4. pasar al Runtime el .dex
5. en el Linux se creará un proceso de esa aplicación
Se van a explicar los componentes más importantes del framework
Ir comentando poco a poco cada bloque.
Toda app debe tener uno ubicado en la raíz pakage
Permite a Android conocer sus componentes y cómo activarlos.
Iconos, densidades, screen, sdk, caracteristicas hardware publicidad,
CASI TODO SE CONTROLA AQUÍ
- Instrumentation: Testing & Profiling
Referencias: documentos entregables: REF004 – AndroidManifest
Representa interacción gráfica con el usuario.
Un app = 1.apk = Proceso = Conjunto de activity = Tarea (DIBUJAR)
VENTANAS + COHESION + MAIN + setContentView + android.app.Activity
Heredamos de Activity
Recibimos el Bundle (Contenedor de Objetos) como parámetros
Establecemos el contenido de la vista (View) de la Actividad.
Estados principales: Create &gt; Start &gt; Resume &gt; * &gt; Pause &gt; Stop &gt; Destroy
* Activa: la actividad está en primer plano y tiene el focus (enfoque de usuario). Se encuentra en lo alto de la pila.
* En pausa: la actividad es visible, pero no tiene el focus. Ej: hay un diálogo sobre ella con el focus retenido.
* Detenida: La actividad está tapada por otra aplicación. Mantiene sus datos.
* Destruida: Una actividad detenida ha sido destruida para liberar memoria y ha perdido sus datos. Hay que recrearla completamente.
Las actividades son gestionadas en un pila: foreground = cabeza pila
onSaveInstanceState(Bundle) activity event vs SharedPreferences.
Cuidado con los cambios de configuración Resources.Configuration tales como orientación.
Cada método sobrescrito se corresponde con una transición de estado.
* Activa: la actividad está en primer plano y tiene el focus (enfoque de usuario). Se encuentra en lo alto de la pila.
* En pausa: la actividad es visible, pero no tiene el focus. Ej: hay un diálogo sobre ella con el focus retenido.
* Detenida: La actividad está tapada por otra aplicación. Mantiene sus datos.
* Destruida: Una actividad detenida ha sido destruida para liberar memoria y ha perdido sus datos. Hay que recrearla completamente.
Son el mecanismo de comunicación entre componentes.
Ideal para ‘moverse’ entre activities
Acciones Nativa: Intenciones conocidas de hacer algo
Action: Acción/Intención a realizar
Data: Datos que me permiten determinar quien lo va a hacer
Con estos datos Android conseguirá ‘afinar’ mas quien debe de hacer la Action
Ejemplo de comunicación entre activities.
Mostrar en este ejemplo que el setResult es para comunicar información resultado.
Sólo para Intents implícitos -&gt; Resuelven algo
Son instancias de la clase IntentFilter
Son conocidos de manera declarativa: &lt;intent Filter&gt; androidmanifest.xml
Debe cumplir ACTION + CATEGORY + DATA (mime)
Ver el AndroidManifest.xml de Activities-LaunchDemo
Ver el AndroidManifest.xml de BroadcastReceiver-Demo y comentar que se ejecuta la primera Actividad al tener el action y category main.
Ver el AndroidManifest.xml de Views-SimpleViews, ver que Android ejecutará una Action de tipo MAIN, con category LAUNCHER. Al haber varias, escoge la primera.
Gestionar los eventos de android y de las apps (incluso que no estén en ejecución)
Programática / declarativa
No suelen tener UI, lanzan alertas al usuario a través del NotificationManager
Registrarlo en Activity.onResume()unregister en Activity.onPause()
Comentar con calma, ir leyendo.
Mecanismo que tiene android para difundir eventos.
Se construyen de manera declarativa Context.sendBroadcast()
Resolución igual que los intent filter normales: ACTION + CATEGORY + DATA
Outcoming: Lanza action de tipo TEST
Incoming: BroadcastReceiver que escucha acciones de tipo TEST
Androidmanifest.xml: Están declarados tanto Outcoming como Incoming.
Único mecanismo para compartir datos entre app ya que no hay áreas comunes.
Los datos pueden estar en Files, SQLite,…, pero son propios de cada app.
Si quieres compartir datos o creas contentProvider o públicas en otro.
Las apps que quieren datos hablan con el ContentResolver.
Url, Columns, Where, WhereArgument, Order By
El cliente (Resolver) accede a traves de managedQuery()
El server (Provider) implementa el método Query()
- Comentar las cosas en el AndroidManifest
- Comentar que al arrancar la App se invoca el ContentProvider
- Comentar que la clase ConstantBrowser interactúa con el Provider
- Comentar punto de entrada: Clase ConstantBrowser.onCreate()
- Comentar la variable CONTENT_URI
- Comentar primera línea de onCreate() constantsCursor=managedQuery(Provider.Constants.CONTENT_URI..) es la que realiza el método query() del provider, que devuelve un apuntador (Cursor) a los contenidos.
getContentResolver().insert() getContentResolver().delete(), son los métodos para interactual con el --ContentProvider
- Dejar que el asistente interactúe 5 o 10 minutos con la app.
NO UI + Background + Indefinido + BIND TO Reproductor musical
Pueden actualizar Content Providers, lanzar Intents, notificaciones...
Aplicaciones que no necesitan interacción con el usuario son buenas candidatas a ser servicios.
Heredan de la clase android.app.Service y ejemplos = Managers…
DIBUJAR Leer números.
Comentar cómo están especificados los Services en el AndroidManifest.xml
* Comentar que el servicio de Music suena aunque salgamos de la app
* Ver los estados en el Log.d(..)
Dejar 5 o 10 minutos al alumno para que entienda el binder.
* Lo importante es entender los miembros binder (Server) y counterservice (Client) del aIDL
Aquello que no sea código.
La diferencia con los assest
* Son menos comunes que los resources (/res)
* Lo incluido en /res es accesible programáticamente (R.resource) ya que es compilado y los assets no.
* Los assest mantienen su estructura a pelo (RAW) y para ser accedido debes de utilizar el AssetManager y leer el bytestream.
Declarativamente: @&lt;tipo de recurso&gt;/&lt;nombre del recurso&gt;.
Para definirlo: @+&lt;tipo de recurso&gt;/&lt;nombre de recurso&gt;
Nombre en minúsculas & La extensión se ignora.
Mostrar cualquier proyecto la estructura de carpetas.
Cada tipo de recurso va en una carpeta específica
Utilizan sufijos para determinar qué recursos utilizar según contexto (tamaño de pantalla, idioma, orientación, etc.)
Mostrar ejemplo en eclipse.
Mirar AndroidManifest.xml
Mirar la carpeta recursos /drawable & /string
Mirar AndroidManifest.xml
Mirar la carpeta recursos /xml/word.xml
Ojo ViewGroup hereda a nivel programatico de View
Tipicas operaciones con Views
1- Establecer su propiedades
2- Coger el foco para responder a eventos
3- Establecer listener para reaccionar ante esos eventos
4- Ocultarlo o mostrarlo
Subclases View con funcionalidad
Debe de contener un root element.
Se pueden crear por XML o por código.
Se acceden igual que un recurso normal: R.layout.main_layout
(@) indicates that the XML parser should parse and expand the rest of the ID string (+) means that this is a new resource name that must be created in the R.java file)
Consejos para las hacer bien las pantallas
1. Usa wrap_content, fill_parent y dip unit to px in XML layout files
2. Evita AbsoluteLayout
3. No uses hard coded pixel values en tu código.
4. Usa density and/or resolution specific resources.
Forma de poder interactuar y notificarse con el usuario.
Definiendo un Event Listener (onClickListener(..), onKeyListener(..)
Sobreescribiendo un evento existente (onTouch..(), onKeyDown(..), onTrackballEvent(…)
*Toast:
Pop-up que aparece y desaparece, ideal para mensajes cortos.
*Status Bar:
Cuando el usuario tiene que realizar una acción. Ideal para notificar cuando un servicio está realizando una acción. Deben ser creadas siempre por servicios.
*Dialog:
Pequeña ventana que aparece delante de una Actividad.
Siempre asociado a una Actividad en su método onCreateDialog(int)
Ideal para notificaciones relacionadas con la aplicación (progreso, preguntas, …)
Tres tipos: DataPickers (Fecha / Hora), Progress & Alert (de 0..3 botones)
Adapter dice que información quiero y cómo la quiero
* Autocomplete: ArrayAdapter
* Grid: Fijarse que en FunnyAdapter
* List: ListAdapter con ArrayAdapter
* Spinner: ArrayAdapter
* DataPicker: No tiene adapter, control normal.
Declarativamente: Un menú está compuesto por &lt;item id=”...” title=”…”&gt;
Programáticamente: Menu.add(id, position, title)
Mostrar ejemplo rápido de option, p.e. en la Agenda
Unicos que se pueden poner iconos pero no radiobuttons ni checkbox.
Añadir iconos: menu.setIcon(R.drawable.menu_quit_icon);
El expanded-Menu (para cuando hay más de 6) no se puede incluir iconos
Cada vez que el menú se abre se llama a onPrepareOptionsMenu()
Comentar que ese código es de la Activity
Hacer el adb logcat
menu.add(0,1,0,&quot;Painting&quot;); primero es el groupId, segundo Id, tercero orden
onPrepareOptionsMenu() cierra el menú después de un tiempo.
Ejemplo de pulsar un contacto sobre la agenda
Se usa mucho también para los ítems de una ListView.
Para registrar una View a un ContextMenu: registerForContextMenu().
registerForContextMenu dice que esas vistas pueden ser “menuables”
Es un submenú otros menus. (options / context)
Ideal para típica barra de funcionalidades (Archivo, Editar, ….)
Referencias: documentos entregables: REF006 – Seguridad
Mostrar AndroidManifest.xml de BroadcastReceiver-demo
Para ver todos los permisos pakage: android.manifest.permission
Slashtest@hotmail.com / formacion1234
Lanzar un emulador (cambio de eclipse?) Con el emulador hay permisos de root