Curso desarrollo en android

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

Introducción a Android: un poco de historia (II) Primeros prototipos de Android:

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.

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

Arquitectura del sistema Linux Kernel Android Runtime Framework de aplicaciones Capa de aplicaciones Dalvik Virtual Machine Librerías de Android

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

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 ?

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.

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...

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 ...

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

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...)

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

Arquitectura de las aplicaciones Android: introducción Ejemplo de código inicial

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.

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

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(...);

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();

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

Arquitectura de las aplicaciones: Activity Manager (II) Mensaje ANR:

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

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

Arquitectura de las aplicaciones: Resource Manager Estructura típica:

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

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

Arquitectura de las aplicaciones: Ciclo de vida de los componentes (Activity)

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)

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

Ciclo de vida del Service (según creación)

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

Primera aplicación Ejemplo completo de cómo crear una aplicación Android: HelloWorld!

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.

Primera aplicación: emulador Android (II) Imagen del emulador

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)

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

Primera aplicación: DDMS (II)

Primera aplicación: DDMS (III)

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

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

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

Primera aplicación AndroidManifest.xml (II) <? 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 >

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("Hello, Android"); setContentView(tv); } }

Primera aplicación: más ejemplos Multi widget example

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

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()

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

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 }

Interfaces de usuario: Creación de vista por XML (II) 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 >

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”); }

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

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

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.

Interfaces de usuario: Widgets toolbox (II) TextView EditText con un Button ListView Spinner

Interfaces de usuario: Widgets toolbox (III) DatePicker TimePicker AutoComplete

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

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

Interfaces de usuario: Layouts (III) LinearLayout RelativeLayout AbsoluteLayout

Interfaces de usuario: ejemplo Ejemplo con distintos tipos de widgets visuales y layouts

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

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)

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

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

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

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

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.

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

Eventos: ejemplo de 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 >

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...)

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

Eventos: Broadcast Intents (III) Intent intent = new Intent(NEW_INTENT); intent.putExtra(“param1”, value1); intent.putExtra(“param2”, value2); intent.putExtra(“param3”, value3); sendBroadcast (intent);

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. } }

Eventos: ejemplos Ejemplos de funcionamiento de Intents, Intent-filters y Broadcasting

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

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)

Notificaciones al usuario (III) Toast notification Status Bar Notification Dialog Notification

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

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()

Menus: Options Menu (II) /* 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 ; }

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()

Menus: Context Menu (II) 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); } }

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()

Menus: Submenus (II) 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; }

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)

Almacenamiento de datos (II) Preferences Local files SQLite

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

Almacenamiento de datos: Preferences (II) import android.app.Activity; import android.content.SharedPreferences; public class Calc extends Activity { public static final String PREFS_NAME = "MyPrefsFile" ; . . . @ Override protected void onCreate(Bundle state) { super .onCreate(state); . . . // Restore preferences SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0); boolean silent = settings.getBoolean( "silentMode" , false ); setSilent (silent); } @Override protected void onStop(){ super .onStop(); // 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( "silentMode" , mSilentMode ); // Don't forget to commit your edits!!! editor.commit(); } }

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 = "tempfile.tmp" ; // 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);

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

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

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

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

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); }

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);

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();

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);

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 );

Almacenamiento de datos: SQLite borrado de registro myDatabase.delete(DATABASE_TABLE, KEY_ID + “=” + rowId, null );

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

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);

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);

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

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.

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>

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()));

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 >

Curso desarrollo en android

Más contenido relacionado

La actualidad más candente (20)

Similar a Curso desarrollo en android (20)

Más de Emilio Aviles Avila (20)

Último (20)

Curso desarrollo en android