FO - 4 - Introducción Android

Introducción a Android
1
Índice
Historia
¿Qué es Android?
Arquitectura del
sistema
Herramientas de
desarrollo
Componentes
Android
Modelos de Negocio
2
Objetivos
Componentes Android
3
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.
Arquitectura de las aplicaciones: Componentes de aplicación
4
Principales componentes para el desarrollo de
aplicaciones en Android:
5
Interfaces GUI
Notificaciones & Eventos
Compound View & Adapters
Menus
Componentes Lógicos
[6..39]
Activities
Intents
Int. Filters
Broadcast
Receiver
Content
Provider
Services
[40..44]
Views & Widget
[45..75]
ViewGroup &
Layout
Recursos
Seguridad & Permisos
[76..77]
Arquitectura de las aplicaciones: Componentes de aplicación
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
<?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>
6
Arquitectura de las aplicaciones: Componente Activity
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
7
Arquitectura de las aplicaciones: Componente Activity II
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);
}
}
8
Ciclo de vida de la Activity
Estados 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();
}
9
Ciclo de vida de la Activity
10
Intents: Definición
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).
11
Intents: Estructura
Contienen:
12
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
Intents: Atributos adicionales
Atributos
13
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
Type
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).
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.
14
Intents: Uso en Activities
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);
15
Arquitectura aplicaciones: Intent filters
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
16
Arquitectura de las aplicaciones: Intent filters
Intent
Intent
17
Ejemplo: Intent Filter
<?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=".ApiDemos"
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>
18
Arquitectura de las aplicaciones: Broadcast Receiver
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
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.
}
}
19
BroadcastReceivers - Usos
Ejemplos de uso de BroadcastReceiver:
Entrega Síncrona
Entrega Asíncrona
Context.sendOrderedBroadcast(Intent)
Ejemplos de eventos generados por Android:
20
Context.sendBroadcast(Intent)
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
Arquitectura Aplicaciones: Broadcast & Intents
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.
Lanzamiento de Broadcast Intent
Intent intent = new Intent(NEW_INTENT);
intent.putExtra(“param1”, value1);
intent.putExtra(“param2”, value2);
intent.putExtra(“param3”, value3);
sendBroadcast(intent);
21
Arquitectura de las aplicaciones: Broadcast Intents
Intent
Intents
22
Arquitectura de las aplicaciones: Content Provider
Único mecanismo para compartir datos entre
aplicaciones.
23
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.
Arquitectura Aplicaciones: Proveedores nativos Android
24
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
Arquitectura Aplicaciones: Interfaz de un contentProvider
25
Interfaz a implementar del Content Provider
Arquitectura de las aplicaciones: Componente Service
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.
26
Arquitectura Aplicaciones: Services: creación de servicios
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>
27
Arquitectura Aplicaciones: Ciclo de vida del Service (según creación)
28
Arquitectura Aplicaciones: Resumen de componentes
29
Arquitectura de las aplicaciones: Resources
Los recursos (Resources) son
elementos externos que se quieren
incluir y referenciar en la aplicación.
30
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
Resources: Tipos de Recursos
Cada tipo de recurso en una carpeta
/res.
drawable: Imágenes, Iconos, …
layout: Layout para organizar views.
values:
31
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, …)
Resources: Sufijos (Qualifiers)
Cada tipo de recurso puede tener su
propia configuración según contexto.
Se añade un sufijo /tiporecurso-xxx
L10N & I18N
Pantallas
32
Language: (-es, -en, -de, …)
Country Code: (-123)
Region: (-ca, -us, …)
Orientation: (-land, -port & -square)
Pixel density: (-hdpi, -mdpi & -ldpi)
Navigation: (D-pad, trackball & wheel)
Size: (small, normal & large)
Version: API (-v1, etc)
…
Arquitectura de las aplicaciones: Interfaces de usuario (UI)
33
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
Interfaces de usuario: Views
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:
34
Cambio de focus, scrolling, clicks, gestos, ...
Se pueden crear por código (programáticamente)
o por XML (declarativamente)
Interfaces de usuario: Widget
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
Se pueden customizar y crear widget nuevos.
35
Button, TextView, EditText, ListView, CheckBox,
RadioButton, Gallery, Spinner …
AutoCompleteTextView, ImageSwitcher &
TextSwitcher.
Extender un subclase de View.
Implementar algunos override methods.
onDraw(), onMeasure() & onKeyDown()
Listo para usar tu nuevo widget!
Interfaces de usuario: Programáticamente
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,
…
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
TextView myTextView = new TextView(this);
myTextView.setText(“Hola Clase”);
setContentView(myTextView);
}
36
Interfaces de usuario: Declarativamente - Por XML
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"> 
<TextView android:id="@+id/myTestView"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:src="@drawable/jupiter"/> 
</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”);
}
37
Interfaces de usuario: Layouts
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.
38
Interfaces de usuario: Tipos Layouts
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.
LinearLayout
39
RelativeLayout
AbsoluteLayout
Arquitectura de las aplicaciones: Notificaciones al usuario
40
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
Arquitectura de las aplicaciones: Notificaciones al usuario
Toast:
Para breves mensajes
desde el background
Status Bar:
Para recordatorios persistentes
que requieren del usuario
Dialog:
Para notificaciones relacionadas
con la Activity
41
Interfaces de usuario: componentes compuestos (I)
42
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
Interfaces de usuario: componentes compuestos (II)
TextView
EditText con un Button
43
ListView
Spinner
Interfaces de usuario: componentes compuestos (III)
DatePicker
44
TimePicker
AutoComplete
Interfaces de usuario: AdapterView
View
AdapterView
45
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
Button, ImageButton, EditText, …
ListView, GridView, Spinner, Gallery, ..
Adapter
CursorAdapter, ListAdapter, SpinnerAdapter,
Datos
Content Provider, Cursor, String {}, File, URI
Ejemplos y ejercicios: Compound Views
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.
46
Interfaces de usuario: Menus
47
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.
Menus: Options Menu
Contiene un máximo de 6
elementos con iconos.
48
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()
Menus: Options Menu (II)
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;
}
49
Menus: Context Menu
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)
50
Menus: Context Menu (II)
Creación de Context Menu vía código:
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);
}
}
51
Menus: Submenus
52
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()
Menus: Submenus (II)
Creación de SubMenu vía código:
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;
}
53
Conclusiones
Componentes Android
54
Notificaciones & Eventos
Compound View &
Adapters
Menus
Componentes
Lógicos [6..39]
Activities
Intents
Int. Filters
Broadcast
Receiver
Content
Provider
Services
[40..44]
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.
[45..75]
Views &
ViewGroup
Widget
& Layout
Recursos
Interfaces GUI
[76..77]
Conocer principales componentes
lógicos de una aplicación Android.
Integración & comunicación entre
componentes.
Seguridad & Permisos

Download Report