• Save

Loading…

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

Like this presentation? Why not share!

Like this? Share it with your network

Share

Desarrollo android - 4 - arquitectura de aplicación

on

  • 19,457 views

Curso desarrollo apps Android - Capitulo 4 Arquitectura aplicacion

Curso desarrollo apps Android - Capitulo 4 Arquitectura aplicacion

Statistics

Views

Total Views
19,457
Views on SlideShare
17,981
Embed Views
1,476

Actions

Likes
20
Downloads
0
Comments
3

3 Embeds 1,476

http://techmi.es 1468
http://www.ggi-nemesis.com 4
http://ggi-nemesis.com 4

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • 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 > Start > Resume > * > Pause > Stop > 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 -> Resuelven algo Son instancias de la clase IntentFilter Son conocidos de manera declarativa: 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: @/. Para definirlo: @+/ 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 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,"Painting"); 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

Desarrollo android - 4 - arquitectura de aplicación Presentation Transcript

  • 1. Desarrollo de aplicaciones móviles en Android
  • 2. Índice
    • Historia
    • ¿Qué es Android?
    • Arquitectura del sistema
    • Entorno de desarrollo
    • Arquitectura de las aplicaciones
    • Almacenamiento de datos
    • Multimedia
    • Práctica final
    • Presentación
  • 3. Objetivos
    • 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:
  • 5. Arquitectura de las aplicaciones: Componentes de aplicación 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
  • 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
    <? 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 >
  • 7. 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
  • 8. 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 );
    • }
    • }
  • 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
    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();
      • }
    Estados de la Activity
  • 11. Ciclo de vida de la Activity
  • 12. 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).
  • 13. Intents: Estructura
    • 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 ).
  • 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.
  • 16. Intents: Uso en Activities
      • Lanzar una actividad
        • Context.startActivity(Intent)
        • Activity.startActivityForResult(Intent)
    Uri uri = Uri. parse( &quot;http://www.google.com&quot; ); Intent intent = new Intent(Intent. ACTION_VIEW ,uri); startActivity(intent);
  • 17. Ejemplos y ejercicios: Activities-LaunchDemo
    • 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
    • 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
    • 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
    • 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
    • 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
  • 22. Arquitectura de las aplicaciones: Intent filters Intent Intent
  • 23. Ejemplo: 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 >
  • 24. 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.
      • }
    • }
  • 25. BroadcastReceivers - Usos
    • 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
    • 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.
    Intent intent = new Intent(NEW_INTENT); intent.putExtra(“param1”, value1); intent.putExtra(“param2”, value2); intent.putExtra(“param3”, value3); sendBroadcast (intent); Lanzamiento de Broadcast Intent
  • 27. Arquitectura de las aplicaciones: Broadcast Intents Intent Intents
  • 28. Ejemplos y ejercicios: BroadcastReceiver-Demo
    • 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
    • Ú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
    • 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.
  • 31. Arquitectura Aplicaciones : Interfaz de un contentProvider
    • Interfaz a implementar del Content Provider
  • 32. Arquitectura Aplicaciones: Content Providers - consultas
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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() ):
    • Crear una clase X que implemente ServiceConnection , con los métodos onServiceConnected y onServiceDisconnected.
    • Crear una interfaz Y que hará de intermediaria entre la Activity y el Service para comunicar.
    • En la clase Service, implementar el método onBind() para que devuelva una instancia de la interfaz Y.
    • 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
    • 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.
  • 40. Arquitectura Aplicaciones: Ciclo de vida del Service (según creación)
  • 41. Arquitectura Aplicaciones: Resumen de componentes
  • 42. Arquitectura de las aplicaciones: Resources
    • 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
    • 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)
    • 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
    • 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
    • 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)
    • 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
    • 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
    • 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?
    • 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 : F ILL_PARENT, WRAP_CONTENT, <número exacto>…
  • 51. Interfaces de usuario: Programáticamente 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 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”); } 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 widget TextView --> </ LinearLayout >
  • 53. Ejemplos y ejercicios: Views-SimpleViews
    • 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
    • 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
    • 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 RelativeLayout AbsoluteLayout
  • 56. Interfaces de usuario: ViewGroups
    • 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
    • ID : ( android:id=&quot;@+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
    • 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
    • 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
    • Definiendo un Event Listener
    • Sobrescribiendo un Handler de un evento concreto del View .
  • 61. Arquitectura de las aplicaciones: Notificaciones al usuario Toast : Para breves mensajes desde el background Status Ba r: Para recordatorios persistentes que requieren del usuario Dialog : Para notificaciones relacionadas con la Activity
  • 62. Ejemplos y ejercicios: Notifications-Demo
    • 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)
    • 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) TextView EditText con un Button ListView Spinner
  • 65. Interfaces de usuario: componentes compuestos (III) DatePicker TimePicker AutoComplete
  • 66. Interfaces de usuario: AdapterView
    • 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
    • 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
    • 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
    • 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)
    • 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, &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 ; }
  • 71. Ejemplos y ejercicios: Menu-OptionMenu
    • 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
    • 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)
    • 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, &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);
      • }
    • }
  • 74. Ejemplos y ejercicios: Menu-ContextMenu
    • 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()
  • 76. 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( &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;
    • }
  • 77. Ejemplos y ejercicios: Menu-SubMenu
    • 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
    • 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
    • Ejemplo
    • Aplicación de mail: configurar una cuenta de correo de Android .
    • Ejecutar la aplicación Email del emulador y configurar una cuenta de correo
    • En la ruta /data/data/com.android.email/databases tenemos las bases de datos relacionadas con el correo.
    • Si ejecutamos >sqlite3 database podemos conectarnos con las BD de la aplicación.
    • Al ejecutar >.tables se pueden ver las listas de tablas de la BD.
    • 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
    • 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