Your SlideShare is downloading. ×
Curso desarrollo en android
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Curso desarrollo en android

35,799
views

Published on

Curso de desarrollo Android para programadores que ya conozcan el lenguaje java y sepan mínimamente en que consiste la plataforma Androir

Curso de desarrollo Android para programadores que ya conozcan el lenguaje java y sepan mínimamente en que consiste la plataforma Androir

Published in: Technology, Art & Photos

30 Comments
118 Likes
Statistics
Notes
No Downloads
Views
Total Views
35,799
On Slideshare
0
From Embeds
0
Number of Embeds
18
Actions
Shares
0
Downloads
0
Comments
30
Likes
118
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Desarrollo en Android
  • 2. Índice
  • 3. Introducción a Android: un poco de historia
    • En junio de 2005 Google compra Android inc., compañía dedicada al desarrollo de aplicaciones sobre dispositivos móviles
    • 5 de noviembre de 2007, agrupación de más de 30 compañías (Motorola, HTC, T-Mobile...) en la Open Handset Alliance (OHA)
    • 23 de septiembre de 2008 aparece el HTC Dream, primer teléfono con Android.
    • En el pasado, los desarrolladores generaban código en C y C++ y necesitaban entender el hardware subyacente
    • JAVA: ejecutado en una máquina virtual
  • 4. Introducción a Android: un poco de historia (II) Primeros prototipos de Android:
  • 5. Índice
  • 6. Introducción a Android: qué es Android?
    • Conjunto de software que incluye sistema operativo, middleware y aplicaciones.
    • Su objetivo es abstraer el hardware y facilitar el desarrollo de nuevas aplicaciones.
    • SDK: soporte y API para desarrollo de aplicaciones Android.
    • No es:
    • Una implementación JAVA ME.
    • La respuesta de Google al IPhone.
  • 7. Introducción a Android: qué es Android? (II)
    • Características:
    • Navegador integrado, basado en WebKit
    • Gráficos optimizados con OpenGL ES 1.0
    • SQLite para el almacenamiento de datos estructurados (Bases de datos)
    • Soporte multimedia, tipo MPEG4, MP3, AMR, JPG, GIF...
    • Soporte telefonía GSM, depende del hardware del teléfono
    • Bluetooth, EDGE, 3G y WI-FI, depende del hardware del teléfono
    • Camara, GPS, Brújula, acelerómetro, depende del hardware del teléfono
    • Entorno de desarrollo: emulador, debugger, herramientas de profiling
  • 8. Índice
  • 9. Arquitectura del sistema
    • Linux Kernel
    • Android Runtime
    • Framework de aplicaciones
    • Capa de aplicaciones
    • Dalvik Virtual Machine
    • Librerías de Android
  • 10. Arquitectura del sistema (II)
  • 11. Arquitectura del sistema:Linux Kernel
    • Versión 2.6 del kernel de Linux
    • Android aprovecha la seguridad, gestión de memoria, gestión de procesos, red y modelo de drivers
    • Capa de abstracción entre el hardware y el software
  • 12. Arquitectura del sistema:Linux Kernel (II)
    • Versiones del Kernel por cada release:
    Versión Android Versión Linux Fecha release Android 1.5 (Cupcake) 2.6.27 30 abril de 2009 Android 1.6 (Donut) 2.6.29 15 septiembre de 2009 Android 2.0 (Eclair) 2.6.29 26 octubre de 2009 Android 2.2 (FroYo) 2.6.32 Mayo de 2010 ?
  • 13. Arquitectura del sistema:Android runtime
    • Utiliza el Kernel de Linux para la ejecución de aplicaciones, procesos y gestión de memoria.
    • Formado por un conjunto de librerías base, para ofrecer funcionalidad elemental y de bajo nivel, escritas en C y C++
    • Máquina virtual Dalvik, con código preparado teniendo en cuenta la duración de las baterías y la limitación de memoria.
  • 14. Arquitectura del sistema: Framework de aplicaciones
    • Proporciona una plataforma abierta para el desarrollo
    • El desarrollador puede acceder a los dispositivos, información de ubicación, ejecutar servicios, etc, a través del framework
    • Las aplicaciones del core utilizan este mismos framework
    • Views, Content Providers, Managers...
  • 15. Arquitectura del sistema: Capa de aplicaciones
    • En esta capa de ubicarán las aplicaciones desarrolladas por el desarrollador
    • Aplicaciones escritas en lenguaje JAVA
    • Aplicaciones incluidas por defecto:
      • Cliente email
      • Gestor SMS
      • Mapas
      • Navegador
      • Contactos
      • ...
  • 16. Arquitectura del sistema: Dalvik Virtual Machine
    • Ejecuta aplicaciones en formato .dex (Dalvik Executable)
    • Herramienta dx convierte .class en .dex
    • Usada en entornos con restricciones de memoria y procesador
    • Permite la ejecución de varias instancias a la vez
    • No es una JVM, no ejecuta bytecode
    • Clases de Java ME classes, AWT o Swing no están soportadas
  • 17. Arquitectura del sistema: Librerías Android (I)
    • android.util: paquete de utilidades del core, clases de bajo nivel
    • android.os: acceso a servicios básicos del sistema operativo:(mensajes, reloj...)
    • android.graphics: colores, dibujod de primitivas, ...
    • android.text: mostrar y parsear (transformar) cadenas de texto
    • android.database: gestión de las DBs, cursores, etc
    • android.content: servicios para el acceso a distintos tipos de recursos
    • android.view: clases para la gestión de las vistas
    • android.widget: artefactos nativos de Android: listas, botones ...
    • com.google.android.maps: acceso a controles nativos para mapas (MapView, Overlay...)
  • 18. Arquitectura del sistema: Librerías Android (II)
    • android.app: acceso al contexto de la aplicación, Actividades y API de servicios
    • android.provider: acceso a ciertos Content Providers
    • android.telephony: acceso a los dispositivos del telefono para comunicación (call, send SMS...)
    • android.location: servicios basados en localización
    • android.media: grabación y reproducción de audio, video, imagenes..
    • android.opengl: motor de renderización 3D
    • android.hardware: acceso a la cámara, acelerómetro, brújula...
    • Otras librerías: OpenGL, FreeType, SGL, libc, SQLite, SSL
  • 19. Índice
  • 20. Arquitectura de las aplicaciones Android: introducción
    • Ejemplo de código inicial
  • 21. Arquitectura de las aplicaciones: Componentes de aplicación
    • Activities: application presentation layer, the screen.
    • Services: The workers of the application.
    • Content providers: shareable data store, used to manage and share application databases.
    • Broadcast receivers: the consumers of the Broadcast Intents.
    • Intents: simple message-passing framework.
    • Notifications: user notifications framework.
  • 22.
    • Implementa la subclase android.app.Activity
    • Contiene una interfaz visual gráfica
    • Cada Activity debe tener una responsabilidad propia (alta cohesión, bajo acoplamiento)
    • Una aplicación Android puede contener varias Activity, una de ellas marcada como principal
    • Pueden usar componentes visuales, servicios, crear Intents, etc
    • Una Activity puede invocar a otra (subActivity)
    Arquitectura de las aplicaciones: Componente Activity
  • 23. Arquitectura de las aplicaciones: Componente Activity (II)
    • Una Activity puede invocar a otra (subActivity) de dos modos:
      • Fire and Forget: se crea la subActivity pero la Activity principal continúa su ejecución sin preocuparse del resultado. Para crearla: startActivity(...);
      • Async callback: se crea la subActivity y cuando finalice, invocará un método de regreso, onActivityResult(...), de la Activity principal con el resultado. Para crearla: startActivityForResult(...);
  • 24. Arquitectura de las aplicaciones: Componente Activity (III)
    • Ejemplo:
    • Activity :
    • 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) {...} }
    • Sub-Activity:
    • 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();
  • 25. Arquitectura de las aplicaciones: Activity Manager
    • Controla el ciclo de vida de las Activity y de la pila de Activities.
    • Monitoriza las Activity para detectar posibles ANR (Application Not Responding)
    • ANR si:
      • La Activity no responde a un evento en 5 segundos
      • BroadcastReceiver no finaliza en 10 segundos
    • Para evitar ANR, uso de Handlers
  • 26. Arquitectura de las aplicaciones: Activity Manager (II) Mensaje ANR:
  • 27. Arquitectura de las aplicaciones: Notification Manager
    • Clase utilizada para notificar al usuario que un evento ha sucedido en background (invisible, sin interfaz gráfica)
    • Tipos de notificaciones:
      • Icono persistente en la barra de estado del teléfono
      • Encendido y apagado del LED del dispositivo
      • Vibración, audio, iluminación
  • 28. Arquitectura de las aplicaciones: Resource Manager
    • Los recursos (Resources) son elementos externos que se quieren incluir y referenciar en la aplicación
    • Ejemplos: Imagenes, videos, audio, textos...
    • Android almacena los recursos en los directorios /res y /assets de la aplicación
    • Los recursos de /res son accesibles a través de la clase R (compilada por Android automáticamente) con R.carpeta.recurso
    • Soporte para i18n
  • 29. Arquitectura de las aplicaciones: Resource Manager Estructura típica:
  • 30. Arquitectura de las aplicaciones: Ciclo de vida de los componentes (Activity)
    • Actividad: contiene básicamente 3 estados
      • Activa: está en frente de la pantalla (tiene el foco). Se sitúa en el top de la pila
      • Pausada: visible pero sin el foco (hay otra activa)
      • Parada: no visible por el usuario. El sistema puede elegirla para eliminarla en caso de pocos recursos
    • Cada cambio de estado implica una transición que será notificada a través de los métodos a la Actividad
  • 31. Arquitectura de las aplicaciones: Ciclo de vida de los componentes (Activity)
    • Métodos principales de la Activity
      • void onCreate(): llamado al crearse la actividad o al restaurarse si estaba parada.
      • void onStart(): la actividad es visible al usuario
      • void onRestart(): igual que la anterior, pero la actividad viene del fondo de la pantalla
      • void onResume(): la actividad viene de estar parcialmente escondida a estar al frente
      • void onPause(): otra actividad se pone al frente, pero esta aún es visible
      • void onStop(): la actividad deja de ser visible para el usuario
      • void onDestroy(): llamado al cerrar la actividad
  • 32. Arquitectura de las aplicaciones: Ciclo de vida de los componentes (Activity)
  • 33.
    • Se pueden utilizar de dos maneras:
      • Context.startService(), se ejecuta el servicio en modo normal y se queda a la espera
      • Context.bindService(), un cliente (Activity, otro Service..) conecta con el servicio y si no está creado, lo crea
    • Si hay un cliente conectado al servicio, éste no puede ser parado hasta su desconexión
    Arquitectura de las aplicaciones: Ciclo de vida de los componentes (Service)
  • 34. Arquitectura de las aplicaciones: Ciclo de vida de los componentes (Service)
    • Métodos principales del Service:
      • void onCreate(): el servicio ha sido creado
      • void onStart(Intent intent): el servicio ha sido iniciado. El Intent contiene información adicional que puede requerir el servicio al crearse
      • void onDestroy(): finalización del servicio
    • Si el servicio permite conexiones:
      • IBinder onBind(Intent intent): cuando un cliente se conecta. Devuelve un canal de comunicaciones para interactuar.
      • boolean onUnbind(Intent intent): cuando un cliente se desconecta.
      • void onRebind(Intent intent): el cliente vuelve a conectarse después de desconectarse
  • 35. Ciclo de vida del Service (según creación)
  • 36. Arquitectura de las aplicaciones: Ciclo de vida de los componentes (Broadcast Receiver)
    • Tiene un punto de entrada principal, el método: void onReceive(Context curContext, Intent broadcastMsg)
    • El Broadcast Receiver se considera activo mientras está ejecutando ese método, cuando finaliza pasa a inactivo
    • Método onReceive debe consumir poco tiempo, si no el sistema lo marcará como inactivo.
    • Si se requiere mucho tiempo en procesar el método, se recomienda lanzar un Service que realice el trabajo
  • 37. Índice
  • 38. Primera aplicación
    • Ejemplo completo de cómo crear una aplicación Android: HelloWorld!
  • 39. Primera aplicación: emulador Android
    • El SDK contiene un emulador para testear las aplicaciones desarrolladas
    • Emula tanto hardware como software
    • El emulador soporta configuraciones AVD (Android Virtual Devices), para testear sobre distintas plataformas Android.
    • Tiene limitaciones: no puede enviar ni recibir llamadas ni simular la cámara.
  • 40. Primera aplicación: emulador Android (II) Imagen del emulador
  • 41. Primera aplicación: emulador Android (III)
    • Para iniciar el emulador:
      • emulator -avd <avd_name>: inicializa el emulador y carga una configuración AVD
    • Para finalizarlo, basta con cerrar la ventana
    • Se puede conectar vía consola textual, usando:
      • telnet localhost 5554 (puerto por defecto)
    • Desde la consola, se pueden simular distintos eventos de hardware (ejemplo: geo fix 41.1 12)
  • 42. Primera aplicación: DDMS
    • Siglas de Dalvik Debug Monitor Server
    • Incluido en el SDK
    • Proporciona información del estado de una instancia Android
    • Se conecta al ADB (Android Debugger) y monitoriza una instancia de máquina virtual
    • En IDE Eclipse se puede acceder de forma integrada
  • 43. Primera aplicación: DDMS (II)
  • 44. Primera aplicación: DDMS (III)
  • 45. Primera aplicación: configuración del SDK
    • Configurando el entorno
      • Descarga y instalación de eclipse
      • Descarga y instalación de Android SDK
      • Explorando Android SDK
  • 46. Primera aplicación: configurando el entorno
      • Descargar y instalar eclipse de: http://www.eclipse.org/
      • Descargar y instalar Android SDK de: http://developer.android.com/sdk/index.html (recomendado 1.6)
      • Explorar Android SDK
      • Descargar y instalar Android ADT plugin para Eclipse de: http://developer.android.com/sdk/eclipse-adt.html
  • 47. Primera aplicación AndroidManifest.xml
    • Cada aplicación debe tener un archivo AndroidManifest.xml en el directorio raíz
    • Da un nombre único a la aplicación, con formato package de Java (com.techmi.helloWorld ...)
    • Describe los componentes de la aplicación (Activities, Services, BroadcastReceivers y ContentProviders)
    • Se declaran permisos necesarios para ejecutar la aplicación
    • Librerías necesarias para la aplicación
    • etc
  • 48. Primera aplicación AndroidManifest.xml (II) <? xml version = &quot;1.0&quot; encoding = &quot;utf-8&quot; ?> < manifest xmlns:android = &quot;http://schemas.android.com/apk/res/android&quot; package = &quot;prueba.Android&quot; android:versionCode = &quot;1&quot; android:versionName = &quot;1.0&quot; > < application android:icon = &quot;@drawable/icon&quot; android:label = &quot;@string/app_name&quot; > < activity android:name = &quot;.HelloWord&quot; android:label = &quot;@string/app_name&quot; > < intent-filter > < action android:name = &quot;android.intent.action.MAIN&quot; /> < category android:name = &quot;android.intent.category.LAUNCHER&quot; /> </ intent-filter > </ activity > </ application > < uses-sdk android:minSdkVersion = &quot;7&quot; /> </ manifest >
  • 49. Primera aplicación: Hello Android! package com.android.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. */ public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); TextView tv = new TextView(this); tv.setText(&quot;Hello, Android&quot;); setContentView(tv); } }
  • 50. Primera aplicación: más ejemplos
    • Multi widget example
  • 51. Índice
  • 52. Interfaces de usuario
    • En Android, las interfaces se construyen utilizando los objetos View y ViewGroup
    • Las Views son el punto de interacción con el usuario
    • Las ViewGroup son una agrupación lógica de elementos visuales
    • Los widgets son subclases de la clase View, que ofrecen funcionalidad, como campos de texto y botones
    • Los layouts son subclases de ViewGroup, establecen de qué manera son repartidos los elementos visuales en la pantalla
  • 53. Interfaces de usuario (II)
    • Ya que los ViewGroup son contenedores de Views, se distribuyen formando jerarquías:
    • En la Activity principal, se puede añadir esta jerarquía visual utilizando el método: setContentView()
  • 54. Interfaces de usuario (III)
  • 55. Interfaces de usuario: Views
    • Unidad básica de componente de UI
    • Todas las clases visuales heredan de View
    • Ocupa un área rectangular en la pantalla y es responsable de dibujarse y gestionar los eventos
    • Se pueden crear por código o XML
    • Creación de vista por XML desacopla los detalles visuales del código
  • 56. Interfaces de usuario: Creación de vista por XML
    • En el código de la Activity, se crea el contenido a partir de un recurso XML:
    • public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main); //recurso main.xml, añade una vista con un widget TextView
    • ... TextView myTextView = (TextView)findViewById(R.id.myTextView); //Podemos acceder al TextView buscándolo por Id, ahora podemos trabajar con el
    • }
  • 57. Interfaces de usuario: Creación de vista por XML (II)
    • En el archivo /res/layout/main.xml:
    < LinearLayout xmlns:android = &quot;http://schemas.android.com/apk/res/android&quot; android:orientation = &quot;vertical&quot; android:layout_width = &quot;fill_parent&quot; android:layout_height = &quot;fill_parent&quot; > <!-- crea un layout con la distribución de los elementos visuales --> < TextView android:id = &quot;@+id/myTestView&quot; android:layout_width = &quot;fill_parent&quot; android:layout_height = &quot;fill_parent&quot; android:src = &quot;@drawable/jupiter&quot; /> <!-- crea un widet TextView --> </ LinearLayout >
  • 58. Interfaces de usuario: Creación de vista por código public void onCreate(Bundle icicle) { super.onCreate(icicle); TextView myTextView = new TextView(this); setContentView(myTextView); myTextView.setText(“Hello, Android”); }
  • 59. Interfaces de usuario: ViewGroups
    • Tipo de View especial, que puede contener otras Views
    • Clase base para los Layouts
    • Puede crear una jerarquía de objetos visuales
  • 60. Interfaces de usuario: Widgets
    • Normalmente hacen referencia a Views con funcionalidad compleja añadida
    • Para crear widgets, se pueden crear Views y añadirle métodos para la gestión de eventos, componentes visuales, etc
    • Se pueden extender (heredar) widgets de Android por defecto, sobreescribiendo la funcionalidad que se necesite
  • 61. Interfaces de usuario: Widgets toolbox
    • TextView: etiqueta de sólo lectura
    • EditText: campo de texto editable
    • ListView: crea y gestiona un grupo de Views para mostrar en forma de lista
    • Spinner: control compuesto, muestra un TextView y una ListView asociada para seleccinar un item.
    • Button: botón estándar
    • CheckBox: botón de dos estados (seleccionado o no)
    • RadioButton: conjunto agrupado, donde sólo uno puede ser seleccionado.
  • 62. Interfaces de usuario: Widgets toolbox (II) TextView EditText con un Button ListView Spinner
  • 63. Interfaces de usuario: Widgets toolbox (III) DatePicker TimePicker AutoComplete
  • 64. Interfaces de usuario: Layouts
    • También conocidos como Layout Managers
    • Son extensiones de ViewGroup
    • Su objetivo es controlar la posición de las Views hijas en la pantalla
    • Se pueden anidar, es decir, incluir Layouts dentro de Layouts
    • Android proporciona una serie de Layouts por defecto
  • 65. Interfaces de usuario: Layouts (II)
    • 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 relativamente unas 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
  • 66. Interfaces de usuario: Layouts (III) LinearLayout RelativeLayout AbsoluteLayout
  • 67. Interfaces de usuario: ejemplo
    • Ejemplo con distintos tipos de widgets visuales y layouts
  • 68. Interfaces de usuario: Adapters
    • Clases puente que enlazan los datos con Vistas
    • Se encargan de crear Views para visualizar los datos de una manera estructurada (p.e. un array transformarlo en una ListView)
    • Los Adapters se enlanzan a las vistas usando:
    • ArrayAdapter<String> myAdapterInstance; myAdapterInstance = new ArrayAdapter<String>(this,layoutID,myStringArray); myListView.setAdapter(myAdapterInstance);
    • Los más utilizados: ArrayAdapter y SimpleCursorAdapter
  • 69. Índice
  • 70. Eventos: Intents
    • Intent: usado como mecanismo para el paso de mensajes, declara la intención de realizar una acción
    • Utilizados para iniciar Activities o difundir mensajes.
    • Ú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)
  • 71. Eventos: Intents (II)
    • 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
  • 72. Eventos: Intents (III)
    • Ejemplos de uso:
      • Se pueden pasar como parámetro a Context.startActivity(Intent) o Activity.startActivityForResult(Intent) para lanzar una actividad
      • Context.startService(Intent) para iniciar un servicio
      • Context.sendBroadcast(Intent), Context.sendOrderedBroadcast(Intent), Context.sendStickyBroadast(Intent) entregarán el Intent a todos lo BroadcastReceivers necesarios
  • 73. Eventos: Intents (IV)
    • 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, con pares key-value
  • 74. Eventos: Intents (V)
    • En los Intents, se puede especificar el destinatario o no:
      • Si se establece un destinatario (vía setComponent(ComponentName)), se le envía directamente.
      • 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
  • 75. Intents: Acciones predeterminadas
    • 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.
  • 76. Eventos: Intent filters
    • La manera en que Android sabe como servir un Intent
    • Cada componente se registra en AndroidManifest.xml, y ahí debe establecer que acciones puede realizar.
    • Usados para registrar Activities, Services y Broadcast Receirves como siendo capaces de realizar una acción sobre un particular tipo de datos
    • Busca en todas las aplicaciones intaladas el componente que mejor pueda realizar esa acción
    • Tres elementos fundamentales para la resolución:
      • action: nombre de la acción que puede realizar
      • type: tipo MIME, no es obligatorio
      • category: especifica bajo que circunstancias la acción puede ser ejecutada
      • data: la información para realizar la acción
  • 77. Eventos: ejemplo de Intent Filter <? xml version = &quot;1.0&quot; encoding = &quot;utf-8&quot; ?> < manifest xmlns:android = &quot;http://schemas.android.com/apk/res/android&quot; package = &quot;prueba.Android&quot; android:versionCode = &quot;1&quot; android:versionName = &quot;1.0&quot; > < application android:icon = &quot;@drawable/icon&quot; android:label = &quot;@string/app_name&quot; > < activity android:name = &quot;.ApiDemos&quot; android:label = &quot;@string/app_name&quot; > < intent-filter > < action android:name = &quot;android.intent.action.MAIN&quot; /> < category android:name = &quot;android.intent.category.LAUNCHER&quot; /> </ intent-filter > </ activity > </ application > < uses-sdk android:minSdkVersion = &quot;7&quot; /> </ manifest >
  • 78. Eventos: Broadcast Intents
    • Los Intents tienen la capacidad de enviar mensajes estructurados
    • Broadcast Intents se utlizan para notificar oyentes de acciones determinadas o eventos
    • Android utiliza Broadcast Intents para difundir eventos de sistema (bateria baja, llamada entrante...)
  • 79. Eventos: Broadcast Intents (II)
    • Para difundir un Intent, se construye dentro de la aplicación 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
  • 80. Eventos: Broadcast Intents (III) Intent intent = new Intent(NEW_INTENT); intent.putExtra(“param1”, value1); intent.putExtra(“param2”, value2); intent.putExtra(“param3”, value3); sendBroadcast (intent);
  • 81. Eventos: Broadcast Receivers
    • Broadcast Receivers son utilizados para escuchar Broadcast Intents.
    • Para utilizarlos, necesitan ser registrados (via código o AndroidManifest.xml)
    • Se utilizan Intent Filters para especificar que Intents se están esperando
    • Para implementarlos, extender de BroadcastReceiver y sobreescribir el método onReceive:
    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. } }
  • 82. Eventos: ejemplos
    • Ejemplos de funcionamiento de Intents, Intent-filters y Broadcasting
  • 83. Índice
  • 84. Notificaciones al usuario
    • Algunos sucesos requieren ser notificados 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
  • 85. Notificaciones al usuario (II)
    • Toast Notification: mensaje tipo pop-up que aparece en la ventana. No bloquea la aplicación actual ni requiere ningún tipo de interacción por parte del usuario.
    • Status Bar Notification: añade un icono en la barra de estado y en la ventana de notificaciones. Cuando el usuario la selecciona, se puede lanzar un Intent.
    • Dialog Notification: aparece en frente de la Actividad actual, ganando el foco y permitiendo interacción con el usuario (ventanas tipo alert)
  • 86. Notificaciones al usuario (III) Toast notification Status Bar Notification Dialog Notification
  • 87. Índice
  • 88. Menus
    • Revelan la funcionalidad de la aplicación
    • Tres tipos de menús de aplicación:
      • Options Menu: aparece cuando se pulsa el botón MENU del dispositivo. Hay dos subtipos:
        • Icon Menu: un máximo de 6 items, es el que se muestra inicialmente.
        • Expanded Menu: lista vertical, aparece al pulsar + en el Icon Menu
      • Context Menu: lista flotante, aparece cuando se presiona durante unos segundos en una vista
      • Submenu: lista flotante, aparece cuando se presiona un item del Options Menu
  • 89. Menus: Options Menu
    • Contiene un máximo de 6 elementos
    • Si se necesitan más, se incluyen en el menú extendido (aparece al pusar el botón + )
    • El Expanded Menu se crea automáticamente
    • 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()
  • 90. Menus: Options Menu (II) /* Creates the menu items */ public boolean onCreateOptionsMenu(Menu menu ) { menu.add(0, MENU_NEW_GAME , 0, &quot;New Game&quot; ); menu.add(0, MENU_QUIT , 0, &quot;Quit&quot; ); 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 ; }
  • 91. Menus: Options Menu (III)
  • 92. Menus: Context Menu
    • Conceptualmente similar al botón contextual 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()
  • 93. Menus: Context Menu (II) public void onCreateContextMenu(ContextMenu menu , View v , ContextMenuInfo menuInfo ) { super .onCreateContextMenu(menu, v, menuInfo); menu.add(0, EDIT_ID , 0, &quot;Edit&quot; ); menu.add(0, DELETE_ID , 0, &quot;Delete&quot; ); } 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); } }
  • 94. Menus: Context Menu (III)
  • 95. Menus: Submenus
    • Se puede añadir dentro de cualquier menú, excepto de otro submenú
    • Útil cuando la aplicación tiene demasiada funcionalidad
    • Se añade a nivel de código desde el método onCreateOptionsMenu()
    • Igual que en los Option Menu, al pulsar de invocará el método onOptionsItemSelected()
  • 96. Menus: Submenus (II) public boolean onCreateOptionsMenu(Menu menu ) { boolean result = super .onCreateOptionsMenu(menu); SubMenu fileMenu = menu.addSubMenu( &quot;File&quot; ); SubMenu editMenu = menu.addSubMenu( &quot;Edit&quot; ); fileMenu.add( &quot;new&quot; ); fileMenu.add( &quot;open&quot; ); fileMenu.add( &quot;save&quot; ); editMenu.add( &quot;undo&quot; ); editMenu.add( &quot;redo&quot; ); return result; }
  • 97. Menus: Submenus (III)
  • 98. Índice
  • 99. Almacenamiento de datos
    • En aplicaciones típicas de escritorio, el sistema operativo ofrece el sistema de ficheros para compartir datos entre aplicaciones
    • En Android, los ficheros son privados por aplicación
    • Para compartir información, se utilizan los Content Providers
    • Para almacenar información hay tres sistemas:
      • Preferences (sistema de preferencias)
      • Archivos (sistema de archivos)
      • Database (bases de datos)
  • 100. Almacenamiento de datos (II)
    • Preferences
    • Local files
    • SQLite
  • 101. Almacenamiento de datos: Preferences
    • Técnica ágil para guardar datos simples de la aplicación
    • Los datos se almacenan en pares key/value
    • Usado típicamente para guardar las preferencias de la aplicación (fuentes, colores..)
    • Soporte para tipos primitivos (Boolean, float...)
    • Actividades tienen los métodos onSaveInstance() o onStop() para guardar los datos antes de acabar
  • 102. Almacenamiento de datos: Preferences (II) import android.app.Activity; import android.content.SharedPreferences; public class Calc extends Activity { public static final String PREFS_NAME = &quot;MyPrefsFile&quot; ; . . . @ Override protected void onCreate(Bundle state) { super .onCreate(state); . . . // Restore preferences SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0); boolean silent = settings.getBoolean( &quot;silentMode&quot; , false ); setSilent (silent); } @Override protected void onStop(){ super .onStop(); // Save user preferences. We need an Editor object to // make changes. All objects are from android.context.Context SharedPreferences settings = getSharedPreferences( PREFS_NAME , 0); SharedPreferences.Editor editor = settings.edit(); editor.putBoolean( &quot;silentMode&quot; , mSilentMode ); // Don't forget to commit your edits!!! editor.commit(); } }
  • 103. Almacenamiento de datos: ficheros locales
    • A veces es preferible mantener la información en ficheros
    • Por defecto, sólo la aplicación puede acceder a esos ficheros (permisos Unix)
    • Acceso similar a Java estándar, se deben crear inputs y outpus streams:
    String FILE_NAME = &quot;tempfile.tmp&quot; ; // Create a new output file stream that’s private to this application. FileOutputStream fos = openFileOutput(FILE_NAME, Context .MODE_PRIVATE); // Create a new file input stream. FileInputStream fis = openFileInput(FILE_NAME);
  • 104. Almacenamiento de datos: ficheros locales (II)
    • Sólo se soportan archivos creados en la misma carpeta que la aplicación
    • Las aplicaciones van a la ruta: /data/app (gratuitas)
    • y /data/app-private (de pago)
    • Para empaquetar ficheros estáticos con la aplicación, almacenarlos en /res/raw/myFile
  • 105. Almacenamiento de datos: SQLite
    • Cada base de datos es privada para la aplicación, pero pueden acceder todas las clases de esta
    • Android ofrece clases wrapper para almacenar la información en la base de datos (p.e. información de contactos)
    • Las bases de datos se almacenan en la carpeta /data/data/ nombre_package /databases
    • Para compartir la información utilizar ContentProviders
  • 106. Almacenamiento de datos: SQLite (II)
    • Base de datos Open Source
    • Cumplimenación de estándares de BDs
    • Ligera, no requiere excesivos recursos
    • Las querys (consultas) se devuelven como objetos Cursor, apuntando a la información
    • Utilizada en reproductores MP3, iPhone y iPods
    • Para información detallada: http://www.sqlite.org
  • 107. Almacenamiento de datos: SQLite Cursors
    • Estructura para recorrer y procesar consultas
    • Funciones principales para navegar en los resultados de una query:
      • moveToFirst: mueve el cursor a la primera fila de los registros
      • moveToNext: mueve el cursor a la siguiente fila de los registros
      • moveToPrevious: mueve el cursor a la fila anterior de los registros
      • getCount: devuelve el número de registros de la query
      • getColumnIndexOrThrow: devuelve un índice para la columna dada
      • getColumnName: dado un índice, devuelve el nombre de esa columna
      • getColumnNames: devuelve un array con los nombres de las columnas
      • moveToPosition: mueve el cursor al registro que hay en esa posición
      • getPosition: devuelve la posición actual del cursor
  • 108. Almacenamiento de datos: SQLite creación de tablas private static final String DATABASE_NAME = “myDatabase.db”; private static final String DATABASE_TABLE = “mainTable”; private static final String DATABASE_CREATE = “ create table “ + DATABASE_TABLE + “ ( _id integer primary key autoincrement,” + “column_one text not null );”; SQLiteDatabase myDatabase; private void createDatabase() { myDatabase = openOrCreateDatabase(DATABASE_NAME, Context.MODE_PRIVATE, null ); myDatabase.execSQL(DATABASE_CREATE); }
  • 109. Almacenamiento de datos: SQLite querys // Return all rows for columns one and three, no duplicates String[] result_columns = new String[] {KEY_ID, KEY_COL1, KEY_COL3}; Cursor allRows = myDatabase.query( true , DATABASE_TABLE, result_columns, null , null , null , null , null , null ); // Return all columns for rows where column 3 equals a set value // and the rows are ordered by column 5. String where = KEY_COL3 + “=” + requiredValue; String order = KEY_COL5; Cursor myResult = myDatabase.query(DATABASE_TABLE, null , where, null , null , null , order);
  • 110. Almacenamiento de datos: SQLite resultados int GOLD_HOARDED_COLUMN = 2; Cursor myGold = myDatabase.query(“GoldHoards”, null , null , null , null , null , null ); float totalHoard = 0f; // Make sure there is at least one row. if (myGold.moveToFirst()) { // Iterate over each cursor. do { float hoard = myGold.getFloat(GOLD_HOARDED_COLUMN); totalHoard += hoard; } while (myGold.moveToNext()); } float averageHoard = totalHoard / myGold.getCount();
  • 111. Almacenamiento de datos: SQLite Añadir un nuevo registro // Create a new row of values to insert. ContentValues newValues = new ContentValues(); // Assign values for each row. newValues.put(COLUMN_NAME, newValue); [ ... Repeat for each column ... ] // Insert the row into your table myDatabase.insert(DATABASE_TABLE, null , newValues);
  • 112. Almacenamiento de datos: SQLite Modificar un registro // Define the updated row content. ContentValues updatedValues = new ContentValues(); // Assign values for each row. updatedValues.put(COLUMN_NAME, newValue); [ ... Repeat for each column ... ] String where = KEY_ID + “=” + rowId; // Update the row with the specified index with the new values. myDatabase.update(DATABASE_TABLE, updatedValues, where, null );
  • 113. Almacenamiento de datos: SQLite borrado de registro myDatabase.delete(DATABASE_TABLE, KEY_ID + “=” + rowId, null );
  • 114. Índice
  • 115. Content Providers
    • Mecanismo genérico de interfaces para compartir datos entre aplicaciones
    • Permite desacoplar la capa de aplicación de la capa de datos (data-source agnostic)
    • Accesible utilizando una simple URI
    • Accesible a través de la clase ContentResolver
    • El contexto de la aplicación tiene un único ContentResolver, accesible via:
    • ContentResolver cr=getContentResolver();
    • ContentResolver es utilizado para transacciones y consultas a los Content Providers (método query() )
    • Como en las bases de datos, las consultas devuelven objetos Cursors, con los métodos comentados anteriormente
  • 116. Content Providers: consultas Para recuperar todos los registros: Cursor allRows = getContentResolver().query(MyProvider.CONTENT_URI, null, null, null, null); Para consultar todos los registros tales que la columna KEY_COL3 tiene un determinado valor, y ordenada por la columna KEY_COL5: String where = KEY_COL3 + “=” + requiredValue; String order = KEY_COL5; Cursor someRows = getContentResolver().query(MyProvider.CONTENT_URI, null, where, null,order);
  • 117. Content Providers: modificaciones Insert: newValues.put(COLUMN_NAME, newValue); Uri myRowUri = getContentResolver().insert(MyProvider.CONTENT_URI, newValues); Delete: getContentResolver().delete(myRowUri, null, null); Update: getContentResolver().update(MyProvider.CONTENT_URI, newValues, where, null);
  • 118. Content Providers: Proveedores nativos Android
    • 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
  • 119. Índice
  • 120. Services
    • Se ejecutan en el background ( no tienen UI).
    • Pueden actualizar Content Providers, lanzar Intents, notificaciones...
    • Tienen más prioridad que la Activity estándar
    • Aplicaciones que no necesitan interacción con el usuario son buenas candidatas a ser servicios
    • Location Manager, Media Controller, Notification Manager son ejemplos de Services.
  • 121. 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; } And update the manifest file with : <service android:enabled=”true” android:name=”.MyService”></service>
  • 122. Services: control de los servicios 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()));
  • 123. Índice
  • 124. Seguridad y permisos
    • 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 >