Documente Academic
Documente Profesional
Documente Cultură
APLICACIONES
MÓVILES I
DESARROLLO DE APLICACIONES MÓVILES I 2
Índice
Presentación 05
Red de contenidos 07
UNIDAD 1. ANDROID: INTRODUCCIÓN A LA PLATAFORMA 09
1.1 Plataforma Android 09
1.1.1 Introducción a Android, versiones 11
1.1.2 Características y Arquitectura Android. 13
1.1.3 Máquina virtual Dalvik Virtual Machine y ART 15
1.1.4 Open Handset Alliance 17
1.1.5 Creación de emuladores 17
UNIDAD 6. SERVICIOS
6.1 Creando y administrando Servicios
6.1.1 Qué es un servicio, 145
6.1.2 Intent Service, Bound Service. 147
6.1.3 Configurar el archivo de manifiesto. 148
6.1.4 Iniciar/Configurar servicios 149
Presentación
El Taller de Desarrollo de Aplicaciones Móviles I es un curso que pertenece a la
línea de programación y desarrollo de aplicaciones siendo un curso de
especialidad sólo en la carrera de Computación e Informática. Permite al alumno
iniciarse en la programación de dispositivos móviles bajo el entorno Android studio
que ha sido optimizado para dispositivos móviles con sistema operativo Android.
Red de contenidos
Persistencia
de datos en Servicios
Android
UNIDAD
1
Introducción a la plataforma
LOGRO DE LA UNIDAD DE APRENDIZAJE
Al término de la unidad, el alumno elabora aplicaciones haciendo uso del
entorno de desarrollo Android Studio.
TEMARIO
ACTIVIDADES PROPUESTAS
Android es un sistema operativo móvil basado en el kernel 2.6 de Linux Android fue
desarrollado para dispositivos móviles, tabletas,
relojes, televisores automóviles, actualmente es uno
de los sistemas operativos más utilizados en el
planeta. Inicialmente fue desarrollado por Andy Rubin
figura 1, quien funda la compañía Android inc en
estados unidos en Palo anto, posterior a ello google
adquiere completamente la compañía en el año 2005
posterior a ello se crea en grupo de empresas
asociadas que patrocina androi como plataforma libre
para dispositivos móviles y otros.
Android esta basado en capas que permiten administrar las funciones básicas de
cualquier equipo movil, en primer lugar tiene aplicaciones estándares como
administrador de contactos, administrador de aplicaciones administrador de drivers,
administrador de mensajes, administrador de archivos, álbum de fotos, administrador
de llamadas configuración todo controlado tu cuenta de gmail google para cualquier
instalación de aplicación se debe realizar por medio de google play. Debajo de ello se
encuentra las librerías nativas para acceso a bases de datos, administración de
recursos, drivers de audio, administrador de sistema, webkit naegador web nativo, etc.
Por el lado de la maquina virtual se encuentra Virtual Dalvik y Art que es una de las
mejoras que fueron creados en octubre del año 2014, después de ello se tiene el
kernel del sistema operativo tal como se puede apreciar en el grafico que se presenta
a continuación.
Por otro lado cualquier aplicación se debe instalar por medio de google play, sin
embargo se puede instalar una aplicación configurando instalar aplicaciones de
fuentes no seguras por otro lado la plataforma Android tiene una gran cantidad de
aplicaciones con mas de 700 mil aplicaciones que se pueden descargar muchos de
ellos gratuitos
Competidores comunes
Apple
o iPhone OS
RIM
o Blackberry
Microsoft
o Windows Mobile 6.5 Phone 7 Series
Symbian Foundation
o Symbian OS
Palm
o WebOS
A menudo Dalvik es nombrada como una máquina virtual Java, pero esto no es
estrictamente correcto, ya que el bytecode con el que opera no es Java
Esta maquina virtual permite que las aplicaciones se compilen en código nativo, lo cual
ayuda a que las aplicaciones se carguen más rápido y que traiga el soporte de
procesadores de 64 bits. Google dice que con ART se estima que el desempeño
mejore cuatro veces.
Fuente: http://www.cnet.com/es/analisis/google-android-5-0-lollipop/
Android Studio, es el IDE (Entorno de desarrollo integrado) que utilizaremos para crear
nuestras aplicaciones es un ide mejorado al que se tenia de eclipse, esta basado en
IntelliJ IDEA de JetBrains para facilitar la generación de código para los
desarrolladores de android esta disponible para plataforma windows, MAC O/S y linux.
Donde
A: Archivos del proyecto
B: Diseño de pantalla en XML
C: Vistas de Text (XML) y Design (Diseño).
Donde:
A: Cuadro de controles
B: Diseño de pantalla (Layout)
C: Vista esquema de controles
D: Vista propiedades de controles.
Hasta aquí nos quedamos con el ejercicio de crear la primera aplicación en Android
studio (Semana 01 Controles), a continuación vamos a revisar los principales controles
y sus propiedades para completar el desarrollo de nuestra primera aplicación.
Los controles más básicos que tenemos en Android son sin duda Button, EditText y
textview los cuales nos permitirán crear una aplicación básica como por ejemplo un
login o un mantenimiento de datos en esta primera parte vamos a revisar en forma
preliminar los controles básicos que se muestra lo siguiente:
EditText.- es un control que permite ingresar datos esta sujeto a aplicarle estilos
(Patrones) para mejorar el uso del mismo.
Para más detalles de los atributos y/o métodos puedes vistar la página oficial de
Android ingresando
http://developer.android.com/reference/android/widget/EditText.html
Button.- Botones de acción permite involucrar eventos comunes como click con el fin
de que el usuario pueda realizar una tarea.
Para más detalles de los atributos y/o métodos puedes vistar la página oficial de
Android ingresando
http://developer.android.com/reference/android/widget/Button.html
1
1
2
2
2
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MainActivity">
<LinearLayout
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_alignParentTop="true"
android:layout_alignParentStart="true">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="Control de acceso"
android:id="@+id/textView" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Usuario"
android:id="@+id/textView2" />
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:ems="10"
android:id="@+id/edtusuario" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Contraseña"
android:id="@+id/textView3" />
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:inputType="textPassword"
android:ems="10"
android:id="@+id/edtcontrasenia" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Aceptar"
android:id="@+id/BtnAceptar" />
<Button
style="?android:attr/buttonStyleSmall"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Cancelar"
android:id="@+id/btnCancelar" />
</LinearLayout>
</RelativeLayout>
La depuración es una facilidad del IDE de Android studio con el objetivo de hacer
seguimeinto al código fuente y verificar algún error no esperado, limpiar el programa,
etc. Según Wikipedia la definición de deúración de programas es el proceso de
identificar y corregir errores de programación. En inglés se le conoce como debugging,
es que se asemeja a la eliminación de bichos (bugs), manera en que se conoce
informalmente a los errores de programación. Se dice que el término bugproviene de
la época de los ordenadores de válvula termoiónica, en los cuales los problemas se
generaban por los insectos que eran atraídos por las luces y estropeaban el equipo.
Resumen
1. El sistema operativo Android esta basado en el nucleo del sistema operativo
Android 2.6 y su creador es Andy Ruby.
2. Android es uno de los mejores sistemas operativos para dispositivos móviles por
excelencia.
Puede revisar los siguientes enlaces para ampliar los conceptos vistos en esta unidad:
UNIDAD
2
ANDROID: COMPONENTES
LOGRO DE LA UNIDAD DE APRENDIZAJE
Al término de la unidad, el alumno elabora aplicaciones que integran Activities,
componentes visuales, Intents y recursos externos pertenecientes a la
plataforma Android.
TEMARIO
ACTIVIDADES PROPUESTAS
Al cambiar la vista, los mismos archivos se presentan de otra manera como se observa en
la siguiente figura:
Carpeta /app/src/main/java
Esta carpeta contendrá todo el código fuente de la aplicación, clases auxiliares, etc.
Inicialmente, Android Studio creará por nosotros el código básico de la pantalla
(actividad o activity) principal de la aplicación, que recordemos que en nuestro caso
era MainActivity, y siempre bajo la estructura del paquete java definido durante la creación
del proyecto.
Carpeta /app/src/main/res/
Contiene todos los ficheros de recursos necesarios para el proyecto: imágenes, layouts,
cadenas de texto, etc. Los diferentes tipos de recursos se pueden distribuir entre las
siguientes subcarpetas:
No todas estas carpetas tienen por qué aparecer en cada proyecto Android, tan sólo las
que se necesiten. Iremos viendo durante el curso qué tipo de elementos se pueden incluir
en cada una de ellas y cómo se utilizan.
Como ejemplo, para un proyecto nuevo Android como el que hemos creado, tendremos
por defecto los siguientes recursos para la aplicación:
Carpeta Descripción
Contiene las imágenes [y otros elementos gráficos] usados en por la
aplicación. Para poder definir diferentes recursos dependiendo de la
resolución y densidad de la pantalla del dispositivo se suele dividir en varias
subcarpetas:
/drawable (recursos independientes de la densidad)
/res/drawable/ /drawable-ldpi (densidad baja)
/drawable-mdpi (densidad media)
/drawable-hdpi (densidad alta)
/drawable-xhdpi (densidad muy alta)
/drawable-xxhdpi (densidad muy muy alta :)
Contiene los ficheros de definición XML de las diferentes pantallas de la
interfaz gráfica. Para definir distintos layouts dependiendo de la orientación
/res/layout/ del dispositivo se puede dividir también en subcarpetas:
/layout (vertical)
/layout-land (horizontal)
/res/anim/
Contienen la definición de las animaciones utilizadas por la aplicación.
/res/animator/
/res/color/ Contiene ficheros XML de definición de colores según estado.
/res/menu/ Contiene la definición XML de los menús de la aplicación.
/res/xml/ Contiene otros ficheros XML de datos utilizados por la aplicación.
Contiene recursos adicionales, normalmente en formato distinto a XML,
/res/raw/
que no se incluyan en el resto de carpetas de recursos.
Contiene otros ficheros XML de recursos de la aplicación, como por
/res/values/ ejemplo cadenas de texto (strings.xml), estilos (styles.xml), colores
(colors.xml), arrays de valores (arrays.xml), tamaños (dimens.xml), etc.
Como se puede observar, existen algunas carpetas en cuyo nombre se incluye un sufijo
adicional, como por ejemplo “values-w820dp”. Estos, y otros sufijos, se emplean para
definir recursos independientes para determinados dispositivos según sus características.
De esta forma, por ejemplo, los recursos incluidos en la carpeta “values-w820dp” se
aplicarían sólo a pantallas con más de 820dp de ancho, o los incluidos en una carpeta
llamada “values-v11” se aplicarían tan sólo a dispositivos cuya versión de Android sea la
3.0 (API 11) o superior. Al igual que los sufijos “-w” y “–v” existen otros muchos para
referirse a otras características del terminal, puede consultarse la lista completa en
la siguiente url:
http://developer.android.com/guide/topics/resources/providing-resources.html
Otro de los recursos creados por defecto cabe destacar los layouts, en nuestro caso sólo
tendremos por ahora el llamado “activity_main.xml”, que contienen la definición de la
interfaz gráfica de la pantalla principal de la aplicación. Si hacemos doble clic sobre este
fichero Android Studio nos mostrará esta interfaz en su editor gráfico, y como podremos
comprobar, en principio contiene tan los controles que agregamos en el primer ejercicio
Pulsando sobre las pestañas inferiores “Design” y “Text” podremos alternar entre el editor
gráfico (tipo arrastrar-y-soltar), mostrado en la imagen anterior, y el editor XML que se
muestra en la imagen siguiente:
Durante el curso ustilizaremos ambos casos, el más efectivo es vía código XML, ya que a
veces el diseñador puede tener complicaciones o demorar dependiendo de la complejidad
de del diseño de pantalla.
Fichero /app/src/main/AndroidManifest.xml
Fichero /app/build.gradle
Contiene información necesaria para la compilación del proyecto, por ejemplo la versión
del SDK de Android utilizada para compilar, la mínima versión de Android que soportará la
aplicación, referencias a las librerías externas utilizadas, etc. Más adelante veremos
también más detalles de este fichero.
Carpeta /app/libs
Puede contener las librerías javas externas (ficheros .jar) que utilice nuestra aplicación.
Normalmente haremos referencia a dichas librería en el fichero build.gradle descrito en el
punto anterior, de forma que entren en el proceso de compilación de nuestra aplicación.
Veremos algún ejemplo más adelante.
Carpeta /app/build/
Contiene una serie de elementos de código generados automáticamente al compilar el
proyecto. Cada vez que compilamos nuestro proyecto, la maquinaria de compilación de
Android genera por nosotros una serie de ficheros fuente java dirigidos, entre otras
muchas cosas, al control de los recursos de la aplicación.Importante: dado que estos
ficheros se generan automáticamente tras cada compilación del proyecto es importante
que no se modifiquen manualmente bajo ninguna circunstancia.
A destacar sobre todo el fichero que aparece desplegado en la imagen anterior, llamado
“R.java”, donde se define la clase R. Esta clase R contendrá en todo momento una serie
de constantes con los identificadores (ID) de todos los recursos de la aplicación incluidos
en la carpeta /app/src/main/res/, de forma que podamos acceder fácilmente a estos
recursos desde nuestro código a través de dicho dato. Así, por ejemplo, la
Vista Android
El siguiente grafico presenta un proyecto creado en Android studio en la vista
Android
¿Que es un Gradle?
Estas son algunas de sus características que hicieron elegir Gradle al equipo de
Android:
Cada archivo describe un layout (una pantalla) y cada layout a su vez puede contener
otros elementos (vistas o controles). Para gestionar la interfaz de usuario, Android
introduce las siguientes terminos:
View
Una view es un objeto cuya clase es android.view.View. Es una estructura de datos
cuyas propiedades contienen los datos de la capa, la información específica del área
rectangular de la pantalla y permite establecer el layout. Una view tiene: layout,
drawing, focus change, scrolling, etc.
La clase view es útil como clase base para los widgets, que son unas subclases ya
implementadas que dibujan los elementos en la pantalla. Los widgets contienen sus
propias medidas, pero puedes usarlas para construir tu interfaz más rápidamente. La
lista de widgets que puedes utilizar incluye Text, EditText, InputMethod,
MovementMethod, Button, RadioButton, CheckBox, y ScrollView.
Viewgroups
Un viewgroup es un objeto de la clase android.view.Viewgroup, como su propio
nombre indica, un viewgroup es un objeto especial de view cuya function es contener y
controlar la lista de views y de otros viewgroups. Los viewgroups te permiten añadir
estructuras a la interfaz y acumular complejos elementos en la pantalla que son
diseccionados por una sola entidad.
La clase viewgroup es útil como base de la clase layouts, que son subclases
implementadas que proveen los tipos más comunes de los layouts de pantalla. Los
layouts proporcionan una manera de construir una estructura para una lista de views.
Los views y viewgroups deben estar contenidos en los layouts, los cuales contienen
otros elementos presentes en una vista. Dentro de cada layout podemos poner todos
los elementos necesarios, incluidos otros layouts. Así conseguiremos estructurar la
pantalla de la manera deseada. Existen una gran variedad de layouts, en función de su
posicionamiento en la pantalla y se describen a continuación algunos de ellos:
FrameLayout
Éste es el más simple de todos los layouts de Android. Un FrameLayout coloca todos
sus controles hijos alineados con su esquina superior izquierda, de forma que cada
control quedará oculto por el control siguiente (a menos que éste último tenga
transparencia). Por ello, suele utilizarse para mostrar un único control en su interior, a
modo de contenedor (placeholder) sencillo para un sólo elemento sustituible, por
ejemplo una imagen.
Ejemplo:
<FrameLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<EditText android:id="@+id/TxtNombre"
android:layout_width="fill_parent"
android:layout_height="fill_parent" />
</FrameLayout>
LinearLayout
El siguiente layout Android en cuanto a nivel de complejidad es el LinearLayout. Este
layout apila uno tras otro todos sus elementos hijos de forma horizontal o vertical
según se establezca su propiedad android:orientation. Al igual que en un
FrameLayout, los elementos contenidos en un LinearLayout pueden establecer sus
propiedades android:layout_width y android:layout_height para determinar sus
dimensiones dentro del layout. Pero en el caso de un LinearLayout, tendremos otro
parámetro con el que jugar, la propiedad android:layout_weight.
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical">
<EditText android:id="@+id/TxtNombre"
android:layout_width="fill_parent"
android:layout_height="fill_parent" />
<Button android:id="@+id/BtnAceptar"
android:layout_width="wrap_content"
android:layout_height="fill_parent" />
</LinearLayout>
Esta propiedad nos va a permitir dar a los elementos contenidos en el layout unas
dimensiones proporcionales entre ellas. Esto es más dificil de explicar que de
comprender con un ejemplo. Si incluimos en un LinearLayout vertical dos cuadros de
texto (EditText) y a uno de ellos le establecemos un layout_weight=”1″ y al otro un
layout_weight=”2″ conseguiremos como efecto que toda la superficie del layout quede
ocupada por los dos cuadros de texto y que además el segundo sea el doble (relación
entre sus propiedades weight) de alto que el primero.
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical">
<EditText android:id="@+id/TxtDato1"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_weight="1" />
<EditText android:id="@+id/TxtDato2"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:layout_weight="2" />
</LinearLayout>
A pesar de la simplicidad aparente de este layout resulta ser lo suficiente versátil como
para sernos de utilidad en muchas ocasiones.
TableLayout
Un TableLayout permite distribuir sus elementos hijos de forma tabular, definiendo las
filas y columnas necesarias, y la posición de cada componente dentro de la tabla.
La estructura de la tabla se define de forma similar a como se hace en HTML, es decir,
indicando las filas que compondrán la tabla (objetos TableRow), y dentro de cada fila
las columnas necesarias, con la salvedad de que no existe ningún objeto especial para
definir una columna (algo así como un TableColumn) sino que directamente
insertaremos los controles necesarios dentro del TableRow y cada componente
insertado (que puede ser un control sencillo o incluso otro ViewGroup) corresponderá
a una columna de la tabla. De esta forma, el número final de filas de la tabla se
corresponderá con el número de elementos TableRowinsertados, y el número total de
columnas quedará determinado por el número de componentes de la fila que más
componentes contenga.
Por norma general, el ancho de cada columna se corresponderá con el ancho del
mayor componente de dicha columna, pero existen una serie de propiedades que nos
ayudarán a modificar este comportamiento:
Todas estas propiedades del TableLayout pueden recibir una lista de índices de
columnas separados por comas (ejemplo: android:stretchColumns=”1,2,3″) o un
asterisco para indicar que debe aplicar a todas las columnas (ejemplo:
android:stretchColumns=”*”).
<TableLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:stretchColumns="1" >
<TableRow>
<TextView android:text="Celda 1.1" />
<TextView android:text="Celda 1.2" />
</TableRow>
<TableRow>
<TextView android:text="Celda 2.1" />
<TextView android:text="Celda 2.2" />
</TableRow>
<TableRow>
<TextView android:text="Celda 3"
android:layout_span="2" />
</TableRow>
</TableLayout>
RelativeLayout
El último tipo de layout que vamos a ver es el RelativeLayout. Este layout permite
especificar la posición de cada elemento de forma relativa a su elemento padre o a
cualquier otro elemento incluido en el propio layout. De esta forma, al incluir un nuevo
elemento X podremos indicar por ejemplo que debe colocarse debajo del elemento Y y
alineado a la derecha del layout padre. Veamos esto en el ejemplo siguiente:
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android
android:layout_width="fill_parent"
android:layout_height="fill_parent" >
<EditText android:id="@+id/TxtNombre"
android:layout_width="fill_parent"
android:layout_height="wrap_content" />
<Button android:id="@+id/BtnAceptar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@id/TxtNombre"
android:layout_alignParentRight="true" />
</RelativeLayout>
android:layout_above.
android:layout_below.
android:layout_toLeftOf.
android:layout_toRightOf.
android:layout_alignLeft.
android:layout_alignRight.
android:layout_alignTop.
android:layout_alignBottom.
android:layout_alignBaseline.
Posición relativa al layout padre:
android:layout_alignParentLeft.
android:layout_alignParentRight.
android:layout_alignParentTop.
android:layout_alignParentBottom.
android:layout_centerHorizontal.
android:layout_centerVertical.
android:layout_centerInParent.
Otros elementos comunes que extienden a ViewGroup, como por ejemplo las vistas de
tipo lista (ListView), de tipo grid (GridView), y en pestañas (TabHost/TabWidget).
Widgets
Un widget es el conjunto de componentes visuales que permite crear las aplicaciones
en Android. Entre dichos compoenentes tenemos Button, TextView, EditText. El
package donde se importa todos los controles es android.widget.
Botones (Button)
Propiedades
android:id
Esto ya lo vimos en el tema anterior, esta propiedad es el ID del control, con el
que podremos identificarlo de forma única más tarde en nuestro código. Vemos
que el identificador lo escribimos precedido de “@+id/”. Esto tendrá como
efecto que al compilarse el proyecto se genere automáticamente una nueva
constante en la clase R para dicho control.
android:text.
Texto del control. En Android, el texto de un control se puede especificar
directamente, o bien utilizar alguna de las cadenas de texto definidas en los
recursos del proyecto (fichero strings.xml), en cuyo caso indicaremos su
identificador precedido del prefijo “@string/”.
android:layout_height y android:layout_width
Dimensiones del control con respecto al layout que lo contiene. Esta propiedad
tomará normalmente los valores “wrap_content” para indicar que las
dimensiones del control se ajustarán al contenido del mismo, o bien “fill_parent”
para indicar que el ancho o el alto del control se ajustarán al ancho o alto del
layout contenedor respectivamente.
android:layout_margin
Este parametro indica el espacio entre el control (en este caso botón) y su
padre en este caso el Layout.
android:padding
Este parámetro indica el espacio entre Texto o Imágenes que pongamos dentro
del control (en este caso el botón) y el propio control.
android:gravity
Esta es la gravedad del control, la verdad es que es una forma original de
poner la alineación, si entre las comillas de este parámetro pulsamos la famosa
combinación de teclas Control+Espacio, eclipse nos dará todos los parámetros
que podemos usar aquí, si ponemos solo "center" se centrara su contenido
tanto vertical como horizontal.
android:drawable
Con este parámetro pondremos una imagen al botón, que no es lo mismo que
el ImageButton, que todo el botón es en si una imagen, con esto ponemos una
especie de icono dentro del botón, por ejemplo si queremos poner el tipoco
Play, Stop las flechas de avance o retroceso... existen variantes de este
parámetro para poner la imagen a la derecha o izquierda, arriba o abajo.
android:Text
Con este parametro definimos el texto del botón, podemos usar un recurso R
usando "@String/texto o directamente un texto entre comillas.
android:TextSize
Indicamos un tamaño, si no ponemos esto, se selecciona un tamaño por
defecto standard, si te parece grando o pequeño ve probando usando la unidad
dp que vimos en el tema anterior.
android:backgroud
Con este parámetro definimos el color de fondo del Boton.
android:OnClick
Esta es una propiedad que nos ayuda con el Listener, al final de la lección
hablo de esto, que es la parte Java del Boton, esto nos facilita la vida, lo malo
es que solo se puede utilizar a partir de la API 6 de Android, no creo que vallas
a hacer un proyecto con esta API yo uso esta opción, es menos lioso.
EditText
EditText (caja de edición de texto) es un cuadro de texto para ingresar datos en
Android este controlt tiene patrones definidos para permitir el ingreso de información
correcta según el tipo de ingreso definido.
android:hint. Con este parámetro pondremos un texto por defecto mientras el campo
este vacío, es decir, el lo que ve el usuario antes de que el escriba nada.
android:inputType. Con este parámetro indicamos el tipo de teclado que quieres que
aparezca cuando pulsas sobre el campo, si por ejemplo solo vamos a introducir
números, se puede indicar que aparezca un teclado numérico. Como siempre cuando
te coloques entre las comillas pulsa Control+Espacio para ver las opciones que
puedes poner para este parámetro.
Actitivity (Actividad)
Un Activity (actividad) es una clase que permite manejar los eventos de cualquier
aplicación desarrollada en Android, esta diseñada para controlar toda la funcionalidad
de cualquier aplicación, Podemos decir que todas las pantallas de una aplicación son
una “activity”. Más adelante vamos a ver que existen algunas variaciones, por ejemplo,
que si una aplicación tiene cinco pantallas, tiene 5 “Actividades” o activities.
Las activities están conformadas por dos partes: la parte lógica y la parte gráfica. La
parte lógica es una archivo .java que es la clase que se crea para poder manipular,
interactuar y colocar el código de esa actividad. Toda actividad debe tener asociado
una pantalla La parte gráfica es un XML que tiene todos los elementos que estamos
viendo de una pantalla declarados con etiquetas parecidas a las del HTML, es decir,
que el diseño de una aplicación en Android se hace similar a una página web; XML es
un primo de HTML.
Resumiendo, una actividad está conformada por la parte lógica (un archivo Java) y la
parte gráfica (un archivo XML). Profundizando más en el tema, ya sabemos que
tenemos un archivo .java, esto quiere decir que tenemos una clase principal, al ser una
actividad extiende de la clase Activity (por eso el nombre) que nos proporciona Android
para crear actividades con sus métodos asignados.
Que es la que hace el trabajo de enlazar la parte lógica con la parte gráfica. El archivo
XML que va a mostrarse cuando se mande a llamar la clase "MainActivity" es el
archivo XML llamado "activity_main".
Para cerrar la explicación: si yo creo una actividad nueva y la llamo
"VentanaPrinicipal", debo hacer que herede de activity si quiero que funcione como
actividad y para decirle que el archivo XML que va a mostrar sea el
"ventanaprincipal.xml" o "pepito.xml". La línea que dice "SetContentView" debe llevar
dentro algo parecido a esto: "setContentView"(R.layout.ventanaprincipal).
Más adelante vamos a ver como agregar una actividad nueva, ya que además de esto
necesitamos hacer otras cosas en el proyecto. Espero por ahora que quede claro el
término de Activity que vamos a estar utilizando.
Es muy importante tener en cuenta este diagrama ya que cuando estamos desarrollando una
aplicación Android, todas las aplicaciones cumplen con este ciclo de vida y dependiendo de la
aplicación debemos manejar estos ciclos de vida para gestión nuestra aplicación y los recursos
que maneja. Por ejemplo cuando una aplicación cambia de orientación de vertical a horizontal
se inicia con el método onResume. A continuación de describe cada uno de los eventos del
ciclo de vida de un activity
Android usa los intent como mecanismo para invocar componentes, los intents son
bastante fáciles de comprender. Básicamente nos permiten llamar a aplicaciones
externas a la nuestra, lanzar eventos a los que otras aplicaciones puedan responder,
lanzar alarmas etc.
activity.startActivity(intent);
}
public static void AbrirVentanaLlamada(Activity activity){
Intent intent = new Intent(Intent.ACTION_DIAL);
activity.startActivity(intent);
}
El objetivo de soportar múltiples pantallas es crear una aplicación que pueda funcionar
correctamente y se vea bien en cualquiera de las configuraciones de pantalla generalizadas
compatibles con Android. En las secciones anteriores de este documento proporcionan
información acerca de cómo Android se adapta a su aplicación a las configuraciones de
pantalla y cómo se puede personalizar el aspecto de su aplicación en diferentes
3. No utilice AbsoluteLayout
A diferencia de los widgets de otros diseños, AbsoluteLayout refuerza el uso de posiciones fijas
para exponer sus vistas, lo que pueden llevar fácilmente a que las interfaces de usuario no
funcionen bien en pantallas diferentes. Debido a esto, AbsoluteLayout está desfasada y en
Android 1.5 (Nivel API 3).
En su lugar, debe utilizar RelativeLayout , que utiliza posicionamiento relativo. Por ejemplo,
puede especificar que un widget de botón debe aparecer "a la derecha de" un widget de texto.
Antes de publicar su aplicación, usted debe probarlo a fondo en todos los tamaños de
pantalla admitidos y densidades. El SDK de Android incluye un emulador que puede
utilizar, que replican los tamaños y densidades de configuraciones de pantalla
comunes en los que su aplicación es probable que se ejecute. También se puede
modificar el tamaño predeterminado, la densidad y resolución del emulador para
reproducir las características de cualquier pantalla específica. El uso del emulador y
las configuraciones personalizadas adicionales le permite probar cualquier
configuración de pantalla posible, por lo que no tiene que comprar varios dispositivos
sólo para poner a prueba el soporte de su solicitud de pantalla.
Para configurar un entorno de prueba debe crear una serie de AVDS (Android Virtual
Devices), utilizando el emulador y configuraciones de pantalla que emulan los tamaños
de pantalla y densidades que desean. Para ello, puede utilizar el Administrador de
AVD para crear las AVDS y lanzarlos con una interfaz gráfica.
La orientación, se puede configurar dentro por medio de código XML como se aprecia
en la siguiente imagen
Existe la posibilidad de evitar este comportamiento por defecto de Android frente a los
cambios dinámicos de configuración, simplemente añadiendo en el Manifest a la
activity la opción
android:configChanges="orientation|keyboardHidden"
Importante! Para que esta técnica funcione si usamos para nuestra app un target
superior a Gingerbread (API 10) , solo funciona en las versiones superiores :
android:configChanges="orientation|keyboardHidden|screenSize"
Diálogos Y Notificaciones
Entre los mensajes más comunes que tenemos tres tipos de notificaciones:
Notificaciones Toast.
Notificaciones en la barra de estado.
Ventanas de diálogo.
Notificaciones Toast
ellas. Debido a que un Toast se crea mediante un servicio en segundo plano, puede
aparecer aunque la aplicación no esté visible.
A lo largo de todas las entradas sobre Android, se ha usado mucho este típo de
notificaciones:
Sintaxis
Toast.makeText(context, text, duration).show();
Duration: es el tiempo de duración puede asumir dos posibles valores tiempo corto o largo,
para ello podemos usar, una de las dos constantes predefinidas, Toast.LENGTH_SHORT ó
Toast.LENGTH_LONG en este caso, vamos a crear un layout personalizado para mostrar el
Toast:
<imageview android:layout_width="48px"
android:layout_height="48px"
android:src="@drawable/ok"
android:padding="5dip"
android:id="@+id/ok"/>
<textview android:id="@+id/textview"
android:layout_width="wrap_content"
android:layout_height="fill_parent"
android:text="Toast con layout personalizado"
android:textColor="#fff"
android:gravity="center_vertical|center_horizontal"/>
</linearlayout>
NotificationManager mNotificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
//Agregando sonido
notification.defaults |= Notification.DEFAULT_SOUND;
//Agregando vibración
notification.defaults |= Notification.DEFAULT_VIBRATE;
mNotificationManager.notify(HELLO_ID, notification);
El resultado es el siguiente:
Al igual que los Toast, se puede crear un layout personalizado, para más
información visita:
http://developer.android.com/guide/topics/ui/notifiers/notifications.html
Diálogos
Los cuadros de dialogo personalizado permiten realizar operaciones como
confirmación o ingresar algún dato en una ventana de dialogo existen varios tipos
entre ellos tenemos:
AlertDialog
ProgressDialog
DatePickerDialog
TimePickerDialog
Ejemplo de AlertDialog
Mostrar una ventana de dialogo que preguntará si queremos salir de la aplicación
AlertDialog.Builder dialog = new AlertDialog.Builder(this);
dialog.setMessage("¿Salir?");
dialog.setCancelable(false);
dialog.setPositiveButton("Si", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
NotificacionesActivity.this.finish();
}
});
dialog.setNegativeButton("No", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.cancel();
}
});
dialog.show();
Ejemplo es ProgressDialog
Cuadro de dialogo que nunca termina.
ProgressDialog.show(
NotificacionesActivity.this
,"ProgressDialog"
,"Ejemplo diálogo de progreso"
,true
,true);
Diseño diálogos
La clase principal que se usa para crear diálogos es la clase Dialog, pero no se
recomienda usar de manera directa dicha clase. Lo recomendable es usar una de las
siguientes subclases:
AlertDialog: Un diálogo que puede mostrar un título, un máximo de tres botones, una
lista de items o un layout personalizado.
DatePickerDialog o TimePickerDialog: Un diálogo con una interfaz predefinida que
permite al usuario seleccionar una fecha o una hora.
proporciona todos los controles que necesitamos para crear un diálogo y modificar su
apariencia. La clase DialogFragment fue introducida en Android 3.0 (API 11), si usas
una versión más antigua, podrás usar la clase DialogFragment, para ver más detalles
ingresar al siguiente link: http://developer.android.com/tools/support-library/index.html
El código es el siguiente:
La funcionalidad en ejecución
MENÚS
Los menús en las aplicaciones son algo que encontramos frecuentemente, de hecho,
casi todos los terminales Android tienen un botón específico para desplegarlos.
Se dispone de distintos tipo de menús:
Options Menu
El menú típico, que se despliega al pulsar la tecla menú, que se divide en dos grupos:
Icon menú
Muestra un menú con iconos, 6 elementos como máximo.
Expanded Menu
Se usa cuando hay más de 6 elementos, mostrando un elemento con la palabra ‘Más’.
Options Menu
Lo más simple y sencillo es definir los menús en XML, colocado en ./res/menu, para
este ejemplo se ha definido el siguiente menu, que contiene dos elementos, un Acerca
de y un Salir:
< ?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/AcercaDe"
android:icon="@drawable/AcercaDe"
android:title="Acerca de la aplicación">
<menu xmlns:android="http://schemas.android.com/apk/res/android">
<item android:id="@+id/submenu"
android:title="Submenú de Salir"/>
</menu>
</item>
<item android:id="@+id/BtnSalir"
android:title="Salir"
android:icon="@drawable/BtnSalir"/>
</menu>
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.ejemplo_menu, menu);
return true;
}
Ahora, tenemos que responder a las acciones del usuario cuando pulse algún
elemento de nuestro menú, para ello vamos a sobreescribir el
método onOptionsItemSelected()
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.AcercaDe:
Toast.makeText(
MenusActivity.this
,"Ejemplo Menú"
,Toast.LENGTH_LONG)
.show();
return true;
case R.id.quit:
finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
Context Menu
Los menús contextuales son similares a los menús mostrados al hacer click con el
botón derecho de un ratón en un PC, para crearlos, debemos sobreescribir el
método onCreateContextMenu(), donde inflaremos el archivo xml.
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {
super.onCreateContextMenu(menu, v, menuInfo);
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.ejemplo_menu, menu);
}
Al igual que en los options menu, tenemos que responder a las acciones del usuario:
@Override
public boolean onContextItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.AcercaDe:
Toast.makeText(
MenusActivity.this
,"Ejemplo Menús App"
,Toast.LENGTH_LONG)
.show();
return true;
case R.id.Salir:
finish();
return true;
default:
return super.onOptionsItemSelected(item);
}
}
Pero este menú contextual no se va a mostrar, ya que tenemos que asociarlo para que
se lanze al realizar una pulsación prolongada sobre una view, en este caso un botón:
final Button boton = (Button) findViewById(R.id.button1);
registerForContextMenu(boton);
UNIDAD
3
PERSISTENCIA DE DATOS EN
ANDROID
LOGRO DE LA UNIDAD DE APRENDIZAJE
Al término de la unidad, el alumno elabora aplicaciones que manejan recursos,
archivos XML, y manejan bases de datos SQLite.
TEMARIO
Android al igual que otros sistemas operativos maneja un sistema de archivos basado
en el nucleo del sistema operativo base Linux 2.6, por ello para acceder a los archivos
y/o recursos del sistema operativo se debe indicar los permisos que debe tener la
aplicación, además de ello se debe especificar eel espacio de almacenamiento que se
tendrá en la aplicación cuando se crea una maquina virtual en los dispositivos de
prueba. A continuación se presenta un ejemplo de configuración de espacio de
almacenamiento que se debe realizar al momento de configurar la maquina virtual.
Memoria Interna
Android permite leer y escribir datos en ficheros de la memoria interna a través de los
métodos habituales para trabajar con ficheros en Java. También nos permite hacer
uso del directorio de cache para tales usos, pero hay que ser precavidos ya que la
chache tendremos que manejarla nosotros y abusar mucho de este directorio puede
ralentizar nuestra aplicación.
Memoria Externa
Casi todos los dispositivos Android soportan el uso de memoria externa ya sea en
forma de tarjeta SD o no. Hay que tener en cuenta que cualquier archivo en esta
memoria es accesible a todo el mundo, es decir, cualquier aplicación puede leer y
escribir ahí. Al contrario que la memoria interna, en la memoria externa necesitamos
solicitar permisos en el Manifest para tener acceso a ella.
Entre las clases más conocidas para manejar archivos tenemos las siguientes clases:
• Para almacenar información en archivos android presenta varias opciones
entre ellos tenemos:
Shared Preferences Almacenar datos primitivos privadas en pares clave-valor
Internal Storage Guarde los datos privados en la memoria del dispositivo.
External Storage Guarde los datos públicos sobre el almacenamiento externo
compartido.
SQLite Databases Guarde los datos estructurados en una base de datos
privada.
Network Connection Almacenar datos en la web con su propio servidor de
red,
Content Provider Repositorio compartido globalmente compartida por todas
las aplicaciones.
Para tener acceso a leer y escribir archivos debemos asignar los permisos en el
archivo de manifiesto como por ejemplo se presenta en el siguiente grafico:
Shared Preferences
getPreferences( )
Desde dentro de su actividad, a las preferencias específicas de la actividad de
acceso
getSharedPreferences( )
Desde dentro de su actividad para acceder a las preferencias a nivel de
aplicación
getDefaultSharedPreferences( )
En PreferencesManager, para obtener las preferencias compartidas que
funcionan en concierto con el marco de la preferencia general de Android
Creando carpetas
El siguiente ejemplo muestra como crear una carpeta llamada miBkApp en la carpeta
de almacenamiento externo
Para el siguiente ejemplo vamos a continuar con nuestro proyecto inicial creado, para
ello vamos a agregar un botón nuevo que tenga de titulo grabar archivo y de nombre
tendrá BtnGrabarArchivo
Environment
Representa las variables del entorno, tiene propiedes comunes para toda la aplicación
Tiene propiedades comunes que utilizaremos para tener las rutas hacia a la carpeta de
nuestro celular, carpeta de imágenes, recursos, carpeta de SD externo o la carpeta
Root del sistema operativo entre otros.
El siguiente grafico muestra los atributos más comunes de esta clase.
Public Metodo/Función
Methods
getDataDirectory()
static File Recupera la carpeta de datos del usuaurio activo.
getDownloadCacheDirectory()
static File Recupera la carpeta de descargas.
getExternalStorageDirectory()
Recupera el nombre y ruta de la carpeta de la tarjeta SD
Get a top-level public external storage directory for placing files of a
static File particular type.
getExternalStorageState(File path)
Devuelve el estado actual del dispositivo de almacenamiento que
static String proporciona la ruta indicada.
getExternalStorageState()
Devuelve el estado actual del dispositivo de almacenamiento primario
static String "externa".
static isExternalStorageEmulated()
boolean Indica si el dispositivo de almacenamiento " externa" primaria es
emulado.
Esta clase adaptador es una clase que se debe cargar a nivel del Mainactivity para
poderlo utilizar para cargar el listview
Para profundizar este tema lo veremos después de ver SQLite que se vera en el
siguiente tema.
Introducción a SQLite
Caracteristicas principales
"/data/data/packake/nombrebasedatos.db"
String StrRutaBaseDatos="/data/data/sise.app.BaseDatos/Contacto.db";
SQLiteDatabaseodb=SQLiteDatabase.openDatabase(StrRutaBaseDatos,
null,SQLiteDatabase.CREATE_IF_NECESSARY);
Tipos de datos
Integer
Valor entero, almacena1, 2, 3, 4, 6, o 8 bytes dependede la magnituddel campo.
Real
Valoresnúmericosdecimales8-byte punto flotante.
Text
Se almacenacadena en código (UTF-8, UTF-16BE or UTF-16LE).
Para más detalles y otros tipos de datos puedes ir al portal oficional de tipos de datos:
http://www.sqlite.org/datatype3.html
Metodos principales
execSQL
Ejecuta un sentencia sql de creación de datos create, drop, etc.
Ejemplo:
Otros Ejemplos:
Importante!
RawQuery(SentenciaSQL, ParametrosArreglo)
Esta función permite recuperar un cursor (tabla) con el fin de cargar los datos en un
adaptador para presentarlo en un contenedor como un listview
Ejemplo
Ejemplo de rwaquery:
La clase ContentValues
Ejemplo: Clase especial de tipo campo valor de valores únicos controlados por índice
útil para hacer uso de insertar y/o actualizar los registros en la base de datos.
Sintaxis
ContentValues oRegistro=new ContentValues();
Ejecuta la sentencia SQL insert para agregar un nuevo registro en la base de datos
Sintaxis
insert(table, nullColumnHack, values)
Donde:
Table.- Nombre de tabla
nullColumnHack.- indica que campos tienen soporte a nulos
Values.- Lista de campos con valores a insertar
Ejemplo:
Sintaxis
update(table, values, whereClause, whereArgs)
Donde:
Table.- Nombre de tabla
Values.- Lista de campos con valores a insertar
Ejemplo:
Sintaxis
delete(table, whereClause, whereArgs)
Donde:
Table.- Nombre de tabla
whereClause.- Parámetros para actualizar e registro en modificación
whereArgs.- Valores par los campos de parámetros
Ejemplo:
La clase Cursor
Ejemplo:
Metodos
getColumnCount().- Permite saber el número de columnas que tiene la(s) tablas
consultada(s).
close().- Permite cerrar el cursor que se encuentra abierto.
getColumnName(columnIndex).- permite leer el nombre de una columna a partir del
índice
getCount().- permite leer el número de registros existentes en el cursor.
Para aquellos que no estén familiarizados con el MVC, éste es un patrón que divide la
aplicación en tres niveles distintos, interfaz gráfica (Vista), tratamiento de datos
(Modelo) lógica de negocio (Controlador). Esto se hace para permitir una mayor
portabilidad de una aplicación, e incluso facilitar su mantenimiento. Por ejemplo si
deseamos modificar la interfaz de la aplicación es decir solo pantallas sólo
prestaremos atención a la capa de la Vista, y si queremos modificar de sistema de
almacenamiento de datos sólo tendremos que prestar atención a la capa del Modelo, y
si lo que queremos es portar la aplicación a otra plataforma lo que haremos será
modificar la capa del Controlador, al igual que si queremos modificar el código para
optimizar rendimiento.
Interfaz Grafica
(Vista(
Activity
Controlador
Aplication
Controlador
SQLite
Modelo
Debemos crear una nueva clase. Le damos al botón derecho sobre el Package que
tenemos en la estructura de nuestro proyecto, New->Class y le damos un nombre a
nuestra nueva clase que haga referencia a su función. Es una buena práctica crear
diferentes packages para los distintos tipos de clases que vayamos a crear, por
ejemplo un package para las Activities, otro package.modelo para las clases que
representen los datos que necesitemos manejar (por ejemplo una clase Auto), etc.
Una vez que tenemos la clase creada, le diremos que extienda de Application:
Se debe realizar este paso para configurar que nuestra nueva clase será la que llama
a todos los activitys a a partir de ahora
en nuestra clase vamos a tener que hacer una conversión al tipo de la clase que
nosotros hemos definido como Application, y a partir de ahí podremos hacer la llamada
a los métodos que contenga la clase. Para que quede más claro un ejemplo sería:
((MyApplication)getApplication()).metodoDeNuestraClaseApplication();
// Llamada desde la Activity al método de Application
((MyApplication)getApplication()).getNombre()
UNIDAD
4
NETWORKING EN ANDROID
LOGRO DE LA UNIDAD DE APRENDIZAJE
Al término de la unidad, el alumno elabora aplicaciones que se conectan a la
web utilizando http y consumen servicios web.
TEMARIO
Servicios web
Los servicios web permiten integrar aplicaciones de distintas plataformas como puede
ser la plataforma Java con la plataforma .net o viceversa, estos fueron creados con el
fin de ampliar la posibilidad de distribuir información mediante la web. Según la W3c lo
defie como “Un Servicio Web (Web Service [WS]) es una aplicaci´on software
identificada por un URI (Uniform Resource Identifier), cuyas interfaces se pueden
definir, describir y descubrir mediante documentos XML. Los Servicios Web hacen
posible la interacción entre ”agentes” software (aplicaciones) utilizando mensajes XML
intercambiados mediante protocolos de Internet.”
Según el ejemplo del gráfico, un usuario (que juega el papel de cliente dentro de
los Servicios Web), a través de una aplicación, solicita información sobre un
viaje que desea realizar haciendo una petición a una agencia de viajes que
ofrece sus servicios a través de Internet. La agencia de viajes ofrecerá a su
cliente (usuario) la información requerida. Para proporcionar al cliente la
información que necesita, esta agencia de viajes solicita a su vez información a
otros recursos (otros Servicios Web) en relación con el hotel y la compañía
aérea. La agencia de viajes obtendrá información de estos recursos, lo que la
convierte a su vez en cliente de esos otros Servicios Web que le van a
proporcionar la información solicitada sobre el hotel y la línea aérea. Por último,
el usuario realizará el pago del viaje a través de la agencia de viajes que servirá
de intermediario entre el usuario y el servicio Web que gestionará el pago.
En todo este proceso intervienen una serie de tecnologías que hacen posible
esta circulación de información. Por un lado, estaría SOAP (Protocolo Simple de
Acceso a Objetos). Se trata de un protocolo basado en XML, que permite la
interacción entre varios dispositivos y que tiene la capacidad de transmitir
información compleja. Los datos pueden ser transmitidos a través
de HTTP ,SMTP , etc. SOAP especifica el formato de los mensajes. El mensaje
SOAP está compuesto por un envelope (sobre), cuya estructura está formada
por los siguientes elementos: header (cabecera) y body (cuerpo).
Fuente: http://www.w3c.es/Divulgacion/GuiasBreves/ServiciosWeb
Por otro lado, WSDL (Lenguaje de Descripción de Servicios Web), permite que
un servicio y un cliente establezcan un acuerdo en lo que se refiere a los
detalles de transporte de mensajes y su contenido, a través de un documento
procesable por dispositivos. WSDL representa una especie de contrato entre el
proveedor y el que solicita. WSDL especifica la sintaxis y los mecanismos de
intercambio de mensajes.
Ejemplos
<env:Header>
<m:reserva xmlns:m="http://empresaviajes.ejemplo.org/reserva"
env:role="http://www.w3.org/2003/05/soap-envelope/role/next"
env:mustUnderstand="true">
<m:referencia>
uuid:093a2da1-q345-739r-ba5d-pqff98fe8j7d
</m:referencia>
<m:fechaYHora>2001-11-29T13:20:00.000-
05:00</m:fechaYHora>
</m:reserva>
<n:pasajero xmlns:n="http://miempresa.ejemplo.com/empleados"
env:role="http://www.w3.org/2003/05/soap-envelope/role/next"
env:mustUnderstand="true">
<n:nombre>Pepe Ejemplo</n:nombre>
</n:pasajero>
</env:Header>
<env:Body>
<p:itinerario
xmlns:p="http://empresaviajes.ejemplo.org/reserva/viaje">
<p:ida>
<p:salida>Nueva York</p:salida>
<p:llegada>Los Angeles</p:llegada>
<p:fechaSalida>2001-12-14</p:fechasalida>
<p:horaSalida>última hora de la tarde</p:horaSalida>
<p:preferenciaAsiento>pasillo</p:preferenciaAsiento>
</p:ida>
<p:vuelta>
<p:salida>Los Angeles</p:salida>
<p:llegada>Nueva York</p:llegada>
<p:fechaSalida>2001-12-20</p:fechaSalida>
<p:horaSalida>media-mañana</p:horaSalida>
<p:preferenciaAsiento/>
</p:vuelta>
</p:itinerario>
<q:alojamiento
xmlns:q="http://empresaviajes.example.org/reserva/hoteles">
<q:preferencia>ninguna</q:preferencia>
</q:alojamiento>
</env:Body>
</env:Envelope>
Caso:
Crear un web Service usando visual studio 2010
Donde:
(1) Al dar click e ServiceDescriptión
Muestra la definición de servicio como métodos y funcionalidades como
métodos públicos parámetros y tipos de datos
</s:element>
</s:schema>
</wsdl:types>
Usando Protocolo SOAP 1.2 el mismo escenario indicado, sin embargo es para
soporte a plataformas complejas como WCF (Windows comuication fudation)
Una vez descargado ponerlo en una carpeta con ruta corta como C:\AndroidDll
addProperty
Propiedad de SoapObject para agregar parámetros
oRequest.addProperty("pNumero1",1);
oRequest.addProperty("pNumero2",2);
SoapSerializationEnvelope
Permite inicializar el enlace de datos con el web service, serializar los datos para
iniciar comunicación.
SoapSerializationEnvelope oSerializador=new
SoapSerializationEnvelope(SoapEnvelope.VER11);
oSerializador.setOutputSoapObject(oRequest);
oSerializador.dotNet=true;
HttpTransportSE
Permite realizar la llamada al servicio web utilizando la url y el objetito de serialización
HttpTransportSE oEjecutarWebService=new
HttpTransportSE(“http://planificador.nisabusiness.com/operaciones.asmx”);
oEjecutarWebService.call(“http://tempuri.org/Sumar”, oSerializador);
SoapObject Resultado=(SoapObject)oSerializador.bodyIn;
StrResultado=Resultado.getProperty(0).toString(); //Permite recuperar el dato.
Posteriormente se debe seguir los pasos que se indica e la numeración para agregar
la referencia en el APK
Thread (Hilo).- Clase que permite ejecutar algún proceso en segundo plano.
Thread Ejemplo
Donde:
1.- es el diseño de la pantalla
2.- las variables a nivel de activity
3.- código del método principal del thead
Objetivo
Crear un web Service que permita realizar operaciones de suma y que retore el
resultado.
Activity en Blanco
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:id="@+id/LinearLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity">
<TableRow
android:id="@+id/tableRow1"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<TextView
android:id="@+id/textView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/lbltitulo"
android:textAppearance="?android:attr/textAppearanceLarge" />
</TableRow>
<TableRow
android:id="@+id/tableRow2"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<TextView
android:id="@+id/textView2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/lblTitulonumero1" />
<EditText
android:id="@+id/edtnumero1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:ems="10" >
<requestFocus />
</EditText>
</TableRow>
<TableRow
android:id="@+id/tableRow3"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<TextView
android:id="@+id/textView3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/lbltitulonumero2" />
<EditText
android:id="@+id/edtnumero2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:ems="10" />
</TableRow>
<TableRow
android:id="@+id/tableRow4"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<TextView
android:id="@+id/textView4"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/lbltituloresultado" />
<TextView
android:id="@+id/tvresutado"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/lbltituloresultadofinal"
android:textAppearance="?android:attr/textAppearanceMedium" />
</TableRow>
<TableRow
android:id="@+id/tableRow5"
android:layout_width="match_parent"
android:layout_height="wrap_content" >
<Button
android:id="@+id/btncalcular"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/lblbtntituloboton" />
<Button
android:id="@+id/btncancelar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/btntitulocancelar" />
</TableRow>
</LinearLayout>
Código fuente
Código para el eveto click del botón de comando calcular
package solucionesmoviles.myapplication;
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
EditText oedtnumero1=null;
EditText oedtnumero2=null;
TextView oTvResultado=null;
Button obtnSumar=null;
Button obtnCancelar=null;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
obtnSumar=(Button)findViewById(R.id.btncalcular);
obtnSumar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Thread oHilo=new Thread()
{
String StrResultado="";
public void run()
{
oedtnumero1=(EditText)findViewById(R.id.edtnumero1);
oedtnumero2=(EditText)findViewById(R.id.edtnumero2);
SoapObject oRequest=new SoapObject(NAMESPACE, NOMBRE_METODO);
oRequest.addProperty("pNumero1",Integer.valueOf(oedtnumero1.getText().toString()));
oRequest.addProperty("pNumero2",Integer.valueOf(oedtnumero2.getText().toString()));
SoapSerializationEnvelope oSerializador=new
SoapSerializationEnvelope(SoapEnvelope.VER11);
oSerializador.setOutputSoapObject(oRequest);
oSerializador.dotNet=true;
HttpTransportSE oEjecutarWebService=new HttpTransportSE(URL);
try
{
oEjecutarWebService.call(SOAP_ACTION, oSerializador);
SoapObject Resultado=(SoapObject)oSerializador.bodyIn;
StrResultado=Resultado.getProperty(0).toString();
}
catch(Exception ex)
{
StrResultado=ex.toString();
}
runOnUiThread(new Runnable()
{
public void run()
{
oTvResultado=(TextView)findViewById(R.id.tvresutado);
oTvResultado.setText(StrResultado);
Toast.makeText(getBaseContext(), StrResultado,
Toast.LENGTH_LONG).show();
}
});
}
};
oHilo.start();
}
});
obtnCancelar=(Button)findViewById(R.id.btncancelar);
obtnCancelar.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
finish();
}
});
//getActivity().onBackPressed();
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
UNIDAD
5
Servicios basados en localización
LOGRO DE LA UNIDAD DE APRENDIZAJE
Al término de la unidad, el alumno elabora aplicaciones que permitan el uso del
servicio basado en localización utilizando Google Maps.
TEMARIO
Que es un fragment
Imagen 51
Fuente: http://jarroba.com/
Ciclo de vida
Al igual que las activity un fragmento tiene un cliclo de vida muy parecido, que el
fragmento depende completamente del activity además de tener características
adcionales que es muy utilizado en tiempo de ejecución para alterralos.
Lista de eventos invocados en el ciclo de vida de un fragment
onPause Al igual que las actividades, onPause se ejecuta cuando se detecta que el
usuario dirigió el foco por fuera del fragmento.
Código de ejemplo:
Esta clase es la encargada de inflar el código Java a través del método inflate(). Este
recibe como parámetros el recurso xml del layout, el contenedor(en este caso el view
de la actividad anfitriona) donde será insertado y una bandera indicando si el view que se
producirá debe incorporarse al contenedor.
Una vez creada la clase y el layout que representa nuestro fragmento debemos añadirlo a
la actividad. Existen dos formas para realizar este proceso.
Veamos un ejemplo:
Esta interfaz de usuario tiene que estar en un archivo XML, para ello debes estar en la
vista app ira la carpeta es y layout nuevo y lyout resource file como se muestra en el
siguiente grafico
android:text="Buscar"
android:layout_below="@+id/skbBarraBusqueda"
android:layout_alignStart="@+id/edtBuscar" />
<EditText
android:id="@+id/edtBuscar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:layout_marginTop="16dp"
android:ems="10"
android:inputType="text" >
<requestFocus />
</EditText>
<SeekBar
android:id="@+id/skbBarraBusqueda"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_below="@+id/edtBuscar"
android:layout_marginTop="14dp" />
</RelativeLayout>
package com.appmovil.fragmentexample;
Por el momento, los únicos cambios en esta clase son para añadir algunas directivas
de importación y reemplazar el método onCreateView () para asegurarse de que el
archivo de diseño se infla y se visualiza cuando se utiliza el fragmento dentro de una
actividad. La declaración de la clase también debe indicar que la clase amplía la clase
Fragmento Android:
package com.appmovil.fragmentexample;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
@Override
public view onCreateView (LayoutInflater inflado,
Contenedor ViewGroup, Bulto
savedInstanceState) {
contenedor, false);
vista regresar;
}
}
LocationManager locManager =
(LocationManager)getSystemService(LOCATION_SERVICE);
List<String> listaProviders = locManager.getAllProviders();
Address
Una clase que representa una dirección, es decir , un conjunto de cadenas que
describen una ubicación.
Criteria
Una clase con indicación de los criterios de aplicación para la selección de un
proveedor de ubicación.
Geocoder
Una clase para el manejo de la geocodificación.
GpsSatellite
Esta clase representa el estado actual de un satélite GPS.
GpsStatus
Esta clase representa el estado actual del motor GPS.
Location
Google Maps
Google Maps es un servidor de aplicaciones de mapas en la web que pertenece a
Google. Ofrece imágenes de mapas desplazables, así como fotografías por satélite del
mundo e incluso la ruta entre diferentes ubicaciones o imágenes a pie de calle Google
Street View. Desde el 6 de octubre de 2005, Google Maps es parte de Google Local.
Existe una variante a nivel entorno de escritorio llamada Google Earth que ofrece
Google también de forma gratuita. En 2014, los documentos filtrados por Edward
Snowden revelaron que Google Maps es parte y víctima del entramado de vigilancia
mundial operado por varias agencias de inteligencia occidentales y empresas
tecnológicas.
Imagen 215
Fuente: http://www.elandroidelibre.com/wp-content/uploads/2011/05/google-maps-navigation.jpg
Para habilitar las apis de google Maps se debe ingresar a la siguiente dirección:
1
Cfr: http://es.wikipedia.org/wiki/Google_Apps
Modificar el glandle como se muestra para agregar las referencias a google play
services
Posterior a ello se debe crear las llaves digitales para firmar la aplicación con los
siguientes comandos como se indica:
<meta-data android:name="com.google.android.gms.version"
android:value="@integer/google_play_services_version" />
<meta-data
android:name="com.google.android.maps.v2.API_KEY"
android:value="AIzaSyB9oARLFPe4wRGyeuWJq0IqZ0g84TjmjVI" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission
android:name="com.google.android.providers.gsf.permission.READ_GSERVICES" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
import com.google.android.gms.maps.*;
public class MainActivity extends Activity {
private void createMapView(){
try {
if(null == googleMap){
googleMap = ((MapFragment)
getFragmentManager().findFragmentById(
R.id.mapView)).getMap();
if(null == googleMap) {
Toast.makeText(getApplicationContext(),
"Error creating map",Toast.LENGTH_SHORT).show();
}
}
} catch (NullPointerException exception){
Log.e("mapasApp", exception.toString());
}
}
import com.google.android.gms.maps.model.LatLng;
import com.google.android.gms.maps.model.MarkerOptions;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
createMapView();
addMarker();
}
UNIDAD
6
Servicios
LOGRO DE LA UNIDAD DE APRENDIZAJE
Al término de la unidad, el alumno elabora aplicaciones desatendidas basadas
en servicios que permitan realizar operaciones como descarga de archivos
grandes, monitorear usuarios basado en geolocalización.
TEMARIO
Los servicios son componentes sin interfaz gráfica que se ejecutan en segundo plano.
En concepto, son exactamente iguales a los servicios presentes en cualquier otro
sistema operativo como por ejemplo Windows los servicios de Windows update, o el
servicio de actualización de la hora de windows. Los servicios pueden realizar
cualquier tipo de acciones, por ejemplo actualizar datos, lanzar notificaciones, o
incluso mostrar elementos visuales como por ejemplo Activities si se necesita en algún
momento la interacción con del usuario. La plataforma de Android tiene una gran
variedad de servicios que ofrece como por ejemplo los alertas cuando la batería esta
baja o por ejemplo cuando llega un mensae de texto o alertas para aceder a dichos
servicios se puede realizar con la clase Manager. De esta manera, en nuestras
actividades podremos accesar a estos servicios a través del
método getSystemService().
Por otro lado, si necesitamos utilizar servicios propios, estos deben ir declarados
en el archivo AndroidManifest.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:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="Servicio de reproducción de música"/>
<Button android:id="@+id/boton_arrancar"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Arrancar servicio"/>
<Button android:id="@+id/boton_detener"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Detener servicio"/>
</LinearLayout>
package solucionesmoviles.serviciomusica;
import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.os.IBinder;
import android.widget.Toast;
/**
* Created by peextssolis on 06/03/2015.
*/
public class ServicioMusica extends Service {
MediaPlayer reproductorMusica;
@Override
public void onCreate() {
Toast.makeText(this, "Servicio iniciado",
Toast.LENGTH_SHORT).show();
reproductorMusica = MediaPlayer.create(this, R.raw.audio);
}
@Override
public int onStartCommand(Intent intenc, int flags, int idArranque) {
Toast.makeText(this,"Servicio arrancado "+ idArranque,
Toast.LENGTH_SHORT).show();
reproductorMusica.start();
return START_STICKY;
}
@Override
public void onDestroy() {
Toast.makeText(this,"Servicio detenido",
Toast.LENGTH_SHORT).show();
reproductorMusica.stop();
}
@Override
public IBinder onBind(Intent intencion) {
return null;
}
}
6. Ahora debes crear una nueva carpeta con nombre raw dentro de la carpeta res.
Arrastra a su interior el ficheroaudio.mp3.
UNIDAD
7
Multimedia y publicación
LOGRO DE LA UNIDAD DE APRENDIZAJE
Al término de la unidad, el alumno elabora aplicaciones que permitan el uso del
video y de sus dispositivos visuales y las publicará en GooglePlay.
TEMARIO
Multimedia
AAC LC/LTP
HE-AACv1 (AAC+)
HE-AACv2 (Enhanced ACC+)
AMR-NB
AMR-WB
FLAC
MP3
MIDI
Ogg Vorbis
PCM/Wave
Reproducción de audio
La reproducción de contenido multimedia se lleva a cabo por medio de la clase
MediaPlayer. Dicha clase nos permite la reproducción de archivos multimedia
almacenados como recursos de la aplicación, en ficheros locales, en proveedores de
contenido, o servidos por medio de streaming a partir de una URL. En todos los casos,
como desarrolladores, la clase MediaPlayer nos permitirá abstraernos del formato así
como del origen del fichero a reproducir. Incluir un fichero de audio en los recursos de
la aplicación para poder ser reproducido durante su ejecución es muy sencillo.
Simplemente creamos una carpeta raw dentro de la carpeta res, y almacenamos en
ella sin comprimir el fichero o ficheros que deseamos reproducir. A partir de ese
momento el fichero se identificará dentro del código como R.raw.nombre_Archivo.
Para reproducir un fichero de audio tendremos que seguir una secuencia de pasos.
Tenemos dos opciones. La primera de ellas consiste en crear una instancia de la clase
MediaPlayer por medio del método create(). En este caso se deberá pasar como
parámetro, además del contexto de la aplicación, el identificador del recurso, tal como
se puede ver en el siguiente ejemplo:
Dentro del código Java podremos acceder a dicho elemento de la manera habitual, es decir,
mediante el método findViewById(). Una vez hecho esto, asignaremos una fuente que se
corresponderá con el contenido multimedia a reproducir. El control VideoView se encargará de
la inicialización del objeto MediaPlayer. Para asignar un video a reproducir podemos utilizar
cualquiera de estos dos métodos:
Una vez inicializado el control se puede controlar la reproducción con los métodos:
start()
stopPlayback()
pause()
seekTo()
En esta sección veremos en último lugar, tal como se ha indicado anteriormente, la manera de
añadir archivos a la tarjeta de memoria de nuestro dispositivo virtual, de tal forma que podamos
almacenar clips de vídeo y resolver los ejercicios propuestos para la sesión. Se deben seguir
los siguientes pasos:
En primer lugar el emulador debe encontrarse en funcionamiento, y por supuesto, el dispositivo
emulado debe hacer uso de una tarjeta SD.
Drawables
Se refiere a todo aquello que se puede dibujar. Es la clase de la cual heredan una variedad de
tipos de gráficos, incluyendo BitmapDrawable, ShapeDrawable, PictureDrawable,
LayerDrawable y otros. Hay tres maneras distintas de instanciar una clase Drawable.
Utilizar una imagen almacenada en el directorio de recursos de nuestro proyecto.
Utilizar un XML que define las propiedades del objeto para luego poder
recuperarlo mediante getDrawable() y el ID que se le asignó en el XML.
o Utilizando los constructores propios de la clase.
Lxas librerías android.graphics.drawable y android.view.animation son proporcionadas por
Android para dibujar y animar imágenes y formas 2D.
ShapeDrawable
Se utiliza para realizar realizar gráficos simples en 2D y aplicarles estilos directamente
Desde el código de nuestra aplicación.
Al ser una clase que hereda de Drawable, se puede utilizar en el mismo contexto que ésta. Se
pueden realizar por lo tanto clases View que dibujen formas personalizadas gracias al métdo
onDraw() que incluye la clase ShapeDrawable.
Publicación de software
Una vez publicado la aplicación la licencia se valida con la librería de google play
cliente y este se comunica con el servidor de google
Prepara tu APK
Cuando estés listo para realizar cambios en el APK, asegúrate de actualizar
también el Código de versión de la aplicación para que los usuarios existentes
reciban la actualización.
El nombre de paquete del archivo APK actualizado debe ser el mismo que el
de la versión actual.
La firma del archivo APK actualizado debe coincidir con la firma de la versión actual.
Para comprobar que el archivo APK utiliza la misma certificación que la versión
anterior, puedes ejecutar el siguiente comando en ambos archivos APK y comparar los
resultados:
Si los resultados son idénticos, significa que estás utilizando la misma clave y que
puedes continuar. Si los resultados son diferentes, tendrás que volver a firmar el
archivo APK con la clave correcta.
Publicar Aplicaciones
1. Ingresar a tu cuenta de Gmail
2. Ingresar a la consola de publicaciones de google play
https://play.google.com/apps/publish/
1. Agregar un nombre
2. Dar click en Preparar Ficha de play store
https://play.google.com/apps/publish/
Básica
GARGENTA, Marko
2011 Learning Android (245 pages)
United States of America: O’Reilly Media, Inc.
HODSON, Ryan
2014 Android Programming Succinctle.
United States of America: Syncfusion Inc.
THOMAS, Erl
2010 Service Oriented Architecture: A field Guide to integrating XML and Web
Services.
United States of America Canada: Prentice Hall
SMYTH, Neil
2014 Android 4.4 App Development Essentials (47 pages). Lean Publishing
Bibliografía Electrónica
ANDROID Developer
2014 Sitio web oficial de desarrollo Android. (Consulta: 27 de Diciembre
2014)(http://developer.android.com/index.html)
LÓPEZ, Victoria
2010 Introducción a Android (117 páginas). (Consulta: 25 de enero 2015)
España: Grupo Tecnología CM (Universidad Complutense de Madrid)
Recuperado de:
http://pendientedemigracion.ucm.es/info/tecnomovil/documentos/android.pdf
Complementaría
GARGENTA, Marco
2011 Learning Android Building applications for be Android Market.
United States of America: O’Reilly Media, Inc