Miguel Rebaza at PIEERSesta recontra bueanazo @Emilio Aviles Avila muy buen material, nose si lo puedes compartir seria de gran ayuda para hacer mi tesis gracias de todos modos miguelito15tk@hotmail.com5 months ago
Are you sure you want to
julissa2buen tutorial podria enviarmelo porfavor estaria muy agradecida julissa.c91@gmail.com6 months ago
Chedraui at Chedrauibuen tutorial saludos, le agradeciria que me lo comparta a iscjavier_eantony@hotmail.com11 months ago
Are you sure you want to
Tulio Enrique Leon AyalaME GUSTARIA EL MATERIAL DEL CURSO EN DESARROLLO ANDROID ME LO PUEDEN ENVIAR A MI CORREO ES PARA MI QUIERO APRENDER JUNIOELPAPI_15@HOTMAIL.COM1 year ago
Curso desarrollo en androidPresentation Transcript
Desarrollo en Android
Índice
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:
Índice
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
Índice
Arquitectura del sistema
Linux Kernel
Android Runtime
Framework de aplicaciones
Capa de aplicaciones
Dalvik Virtual Machine
Librerías de Android
Arquitectura del sistema (II)
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
Índice
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
Índice
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
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
Índice
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 (III)
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" > <!-- crea un layout con la distribución de los elementos visuales --> < TextView android:id = "@+id/myTestView" android:layout_width = "fill_parent" android:layout_height = "fill_parent" android:src = "@drawable/jupiter" /> <!-- crea un widet TextView --> </ 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
Índice
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
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
Índice
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
Índice
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: Options Menu (III)
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: Context Menu (III)
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; }
Menus: Submenus (III)
Índice
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 );
Índice
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);
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
Índice
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()));
Índice
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 >
simpleplan11
1–10 of 22 previous next Post a comment
1–10 of 22 previous next