TOMO I - Repositorio CISC - Universidad de Guayaquil

Transcripción

TOMO I
Línea de Investigación
Redes y Sistema Operativo
Nombre del egresado
Antonio Nicolás Rodríguez Andrade
Nombre del Tema
Evaluación de la plataforma Android para dispositivos móviles
Número de Proyecto
9
Nombre del Tutor
Ing. David Benavides
i
UNIVERSIDAD DE GUAYAQUIL
FACULTAD DE CIENCIAS MATEMATICAS Y FISICAS
CARRERA DE INGENIERIA EN SISTEMAS
COMPUTACIONALES
EVALUACIÓN DE LA PLATAFORMA ANDROID PARA
DISPOSITIVOS MÓVILES
TESIS DE GRADO
Previa a la obtención del Título de:
INGENIERO EN SISTEMAS COMPUTACIONALES
ANTONIO NICOLAS RODRIGUEZ ANDRADE
TUTOR: ING. DAVID BENAVIDES
GUAYAQUIL – ECUADOR
2010
ii
Guayaquil, 11 de octubre del 2010
APROBACION DEL TUTOR
En mi calidad de Tutor del trabajo de investigación, “Evaluación de la plataforma
Android
para
dispositivos
móviles”
elaborado
por
el
Sr.
Antonio Nicolás Rodríguez Andrade, egresado de la Carrera de Ingeniería en
Sistemas Computacionales, Facultad de Ciencias Matemáticas y Físicas de la
Universidad de Guayaquil, previo a la obtención del Título de Ingeniero en Sistemas,
me permito declarar que luego de haber orientado, estudiado y revisado, la Apruebo
en todas sus partes.
Atentamente
………………………………….
Ing. David Benavides
TUTOR
iii
DEDICATORIA
El presente trabajo de tesis se lo dedico a
mi familia, quienes son partícipes de este
logro, gracias a ellos el concluir mi carrera
universitaria es una realidad.
iv
AGRADECIMIENTO
Quiero comenzar dando gracias a Dios por
permitirme vivir y tener una familia única y
maravillosa.
Gracias a mis padres por darme el regalo de
la vida y por estar siempre conmigo. A mi
padre porque además de darme su amor y
sus consejo me apoyó con los recursos
monetarios para llegar a esta instancia. A mi
madre, por todo su amor y comprensión, la
persona en que me he convertido es un
reflejo de sus enseñanzas. A mi hermana
Evelyn, por preocuparse por mí, a mi
abuelito Antonio por todo lo que ha hecho
por la familia.
Gracias a mis profesores por transmitirme
sus conocimientos y permitirme realizar
como profesional. A mi tutor de tesis, el Ing.
David Benavides, por guiarme en este
proceso.
Gracias a Verónica por su amor y su
compañía, a todos los buenos amigos que
hice en las aulas, muchas gracias por estar
conmigo durante todo este tiempo en los que
hemos vivido momentosfelices y tristes.
v
TRIBUNAL DE GRADO
Ing. Fernando Abad Montero
Ing. Juan Chanabá Alcócer
DECANO DE LA FACULTAD
DIRECTOR
CIENCIAS MATEMATICAS Y FISICAS
Ing. Luis Choez Acosta
MIEMBRO DEL TRIBUNAL
Ing. Jorge Medina
MIEMBRO DEL TRIBUNAL
Ing. David Benavides López
AB. José Júpiter Wiles
MIEMBRO DEL TRIBUNAL (TUTOR)
SECRETARIO
vi
COMPUTACIONALES
EVALUACIÓN
DE LA PLATAFORMA
ANDROID PARA DISPOSITIVOS MÓVILES
Proyecto de trabajo de grado que se presenta como requisito para optar por el título de
INGENIERO en Sistemas Computacionales
Autor/a:
C.I.
Tutor:
Guayaquil, octubre del 2010
vii
CERTIFICADO DE ACEPTACIÓN DEL TUTOR
En mi calidad de Tutor del Primer Curso de Fin de Carrera, nombrado por el
Departamento de Graduación y la Dirección de la Carrera de Ingeniería en Sistemas
Computacionales de la Universidad de Guayaquil,
CERTIFICO:
Que he analizado el Proyecto de Grado presentado por el/la egresado(a)
Rodríguez Andrade Antonio Nicolás, como requisito previo para optar por el título de
Ingeniero cuyo problema es:“Evaluación de la plataforma Android para dispositivos
móviles”considero aprobado el trabajo en su totalidad.
Presentado por:
Rodríguez Andrade Antonio Nicolás
Cédula de ciudadanía N°
Tutor: Ing. David Benavides
Guayaquil, octubre del 2010
viii
ÍNDICE GENERAL
CARATULA .................................................................................................................................. i
DEDICATORIA ............................................................................................................................ iii
AGRADECIMIENTO .................................................................................................................... iv
UNIVERSIDAD DE GUAYAQUIL .................................................................................................. vi
CERTIFICADO DE ACEPTACIÓN DEL TUTOR.............................................................................. vii
ÍNDICE GENERAL ..................................................................................................................... viii
ÍNDICE DE CUADROS ............................................................................................................... xiv
ÍNDICE DE GRÁFICOS ................................................................................................................ xv
UNIVERSIDAD DE GUAYAQUIL ................................................................................................ xix
UNIVERSIDAD DE GUAYAQUIL ................................................................................................. xx
INTRODUCCIÓN......................................................................................................................... 1
CAPÍTULO I ................................................................................................................................ 1
El PROBLEMA ............................................................................................................................ 1
1.1UBICACIÓN DEL PROBLEMA EN UN CONTEXTO .............................................................. 1
1.2SITUACIÓN CONFLICTO NUDOS CRÍTICOS ....................................................................... 4
1.3CAUSAS Y CONSECUENCIAS DEL PROBLEMA ................................................................... 6
1.4DELIMITACIÓN DEL PROBLEMA ....................................................................................... 7
1.5FORMULACION DEL PROBLEMA ...................................................................................... 8
1.6EVALUACIÓN DEL PROBLEMA ........................................................................................ 10
1.7OBJETIVOS ...................................................................................................................... 12
1.7.1 OBJETIVO GENERAL................................................................................................ 12
1.7.2 OBJETIVOS ESPECÍFICOS......................................................................................... 12
1.8 ALCANCES...................................................................................................................... 14
1.8.1 ALCANCES ADICIONALES ........................................................................................ 18
1.9JUSTIFICACIÓN E IMPORTANCIA .................................................................................... 22
CAPITULO II ............................................................................................................................. 25
MARCO TEÓRICO ................................................................................................................ 25
2.1ANTECEDENTES DEL ESTUDIO........................................................................................ 25
ix
2.2 FUNDAMENTACION TEORICA ....................................................................................... 26
2.2.1 Dispositivo móvil .................................................................................................... 26
2.2.1.1 Tipos de dispositivos móviles .......................................................................... 26
2.2.1.2Categoría de dispositivos móviles .................................................................... 27
2.2.2Historia de los teléfonos celulares .......................................................................... 28
2.2.3 El papel de los teléfonos celulares en la computación ubicua .............................. 31
2.2.4 Introducción a la plataforma Android ................................................................... 32
2.2.4.1 Un poco de historia ......................................................................................... 32
2.2.4.2 ¿Qué es Android? ............................................................................................ 33
2.2.4.3 Versiones de la Plataforma ............................................................................. 33
2.2.4.4Licencias ........................................................................................................... 36
2.2.4.5Características distintivas ................................................................................ 38
2.2.4.6Arquitectura ..................................................................................................... 39
2.2.4.6.1 Aplicaciones ............................................................................................. 40
2.2.4.6.2 Framework de Aplicación......................................................................... 41
2.2.4.6.3 Librerías.................................................................................................... 42
2.2.4.6.4 Entorno de Ejecución (Runtime) .............................................................. 43
2.2.4.6.5 Kernel ....................................................................................................... 45
2.2.4.7Configuración del entorno de desarrollo de Android ...................................... 45
2.2.4.7.1 SDK (Software Development Kit) ............................................................. 46
2.2.4.7.2 API ............................................................................................................ 46
2.2.4.7.3 Instalación del plug-in ADTpara Eclipse Galileo ....................................... 47
2.2.4.7.4 Explorando las funcionalidades del IDE ................................................... 50
2.2.4.7.4.1 Perspectiva Java ................................................................................ 51
2.2.4.7.4.2 Perspectiva DDMS ............................................................................ 53
2.2.4.7.4.3La primera aplicación con Android: “Hola Mundo” ........................... 56
2.2.4.8Aplicaciones en Android .................................................................................. 60
2.2.4.8.1Consideraciones al desarrollar aplicaciones para dispositivos móviles.... 60
2.2.4.8.2 Componentes principales de una aplicación en Android ....................... 61
2.2.4.8.3Tipos de Aplicaciones en Android ............................................................. 62
x
2.2.4.8.4 Archivo de Configuración AndroidManifest.xml ...................................... 63
2.2.4.8.4.1 Estructura .......................................................................................... 63
2.2.4.8.4.2 Descripción de los elementos ........................................................... 64
2.2.4.8.5Actividad ................................................................................................... 70
2.2.4.8.5.1 Ciclo de Vida...................................................................................... 70
2.2.4.8.5.2 Creación de una Actividad ................................................................ 72
2.2.4.8.5.3 Iniciar una actividad ......................................................................... 73
2.2.4.8.5.4 Ejemplo de actividad incluido en el proyecto ................................... 74
2.2.4.8.5.5Clases de Actividad ............................................................................ 76
2.2.4.8.6Interfaces de Usuario (GUI’s) .................................................................... 77
2.2.4.8.6.1 Ejemplo de vistas incluido en el proyecto........................................ 80
2.2.4.8.7Ordenando el contenido de los Layouts ................................................... 83
2.2.4.8.7.1AbsoluteLayout .................................................................................. 83
2.2.4.8.7.1.1 Ejemplo del contenedor AbsoluteLayout .................................. 84
2.2.4.8.7.2FrameLayout ...................................................................................... 85
2.2.4.8.7.2.1Ejemplo del contenedor FrameLayout ....................................... 85
2.2.4.8.7.3LinearLayout ...................................................................................... 87
2.2.4.8.7.3.1 Ejemplo del contenedor LinearLayout ....................................... 87
2.1.4.8.7.4Relative Layout................................................................................... 88
2.2.4.8.7.4.1 Ejemplo del contenedor RelativeLayout .................................... 91
2.2.4.8.7.5 TableLayout ....................................................................................... 92
2.2.4.8.7.5.1 Ejemplo del contenedor TableLayout ........................................ 93
2.2.4.8.7.6Gallery (Layout tipo galería)............................................................... 94
2.2.4.8.7.6.1 Ejemplo del contenedor Gallery ................................................ 94
2.2.4.8.8Elementos GUI más utilizados .................................................................. 97
2.2.4.8.8.1 Ejemplo de elementos GUI más utilizados ....................................... 97
2.2.4.8.9Menús ..................................................................................................... 102
2.2.4.8.9.1 Ejemplos de Menús incluidos en el proyecto ................................ 103
2.2.4.8.9.1.1 Menú de Opciones ................................................................... 103
2.2.4.8.9.1.2 Menú Contextual ..................................................................... 104
xi
2.2.4.8.9.1.3 SubMenú ................................................................................. 107
2.2.4.8.9.1.4 Menú de opciones a través de un archivo XML ...................... 109
2.2.4.8.10Proveedor de Contenido (Content Provider) ........................................ 110
2.2.4.8.10.1 Ejemplo de proveedor de contenido incluido en el proyecto ..... 111
2.2.4.8.11Intentos (Intents) .................................................................................. 114
2.2.4.8.11.1 Ejemplos de intento incluido en el proyecto ............................... 115
2.2.4.8.12Adaptadores (Adapters)........................................................................ 117
2.2.4.8.13Base de Datos SQLite ............................................................................ 118
2.2.4.8.14BroadcastReciever ................................................................................ 121
2.2.4.8.14.1 Ejemplo del BroadcastReciever incluido en el proyecto............... 121
2.2.4.8.15Servicios ................................................................................................ 123
2.1.4.8.15.1 Ejemplo de servicio incluido en el proyecto ................................. 124
2.2.4.8.16Hilo (Thread) ......................................................................................... 127
2.2.4.8.16.1 Ejemplo de hilo incluido en el proyecto ....................................... 128
2.2.4.8.17Archivos (File)........................................................................................ 130
2.2.4.8.17.1 Ejemplo de archivos incluido en el proyecto ................................ 130
2.2.4.8.18Navegador WebKit ................................................................................ 134
2.2.4.8.18.1 Ejemplo del navegador WebKit incluido en el proyecto .............. 135
2.2.4.8.19Multimedia............................................................................................ 138
2.2.4.8.19.1 MediaPlayer .................................................................................. 140
2.2.4.8.19.1.1 Reproducción de archivos de audio ....................................... 140
2.2.4.8.19.1.2Reproducción de archivos de video ........................................ 140
2.2.4.8.19.1.3 Grabación de audio y video ................................................... 141
2.2.4.8.19.2Ejemplo incluido en el proyecto .................................................... 142
2.2.4.8.20Notificaciones ....................................................................................... 145
2.2.4.8.21Google Maps ......................................................................................... 147
2.2.4.8.22Opciones avanzadas de Android ........................................................... 149
2.2.4.8.22.1 Acceso al Hardware...................................................................... 149
2.3 FUNDAMENTACIÓN LEGAL ......................................................................................... 152
xii
2.3.1Constitución del Ecuador, Título VII, Capítulo Primero, Sección primera (Educación)
...................................................................................................................................... 152
2.3.2Constitución del Ecuador, Título VII, Capítulo Primero, Sección octava............... 152
2.4 HIPÓTESIS A CONTESTARSE ........................................................................................ 153
2.5 VARIABLES DE LA INVESTIGACIÓN .............................................................................. 154
2.5.1 Análisiscomparativo de Android, Symbian OS y Windows Mobile ...................... 154
2.5.1.1 Criterios básicos ............................................................................................ 155
2.5.1.2Criterios principales ....................................................................................... 156
2.5.1.3Criterios técnicos ........................................................................................... 158
2.5.1.4 Criterios de Interfaz de usuario................................................................... 159
2.5.2 Comparativa de los SDKs de Android y Symbian OS ........................................... 159
CAPITULO III .......................................................................................................................... 161
3.1 MODALIDAD DE LA INVESTIGACIÓN ........................................................................... 161
3.1.1TIPO DE INVESTIGACIÓN ....................................................................................... 161
3.2 POBLACIÓN Y MUESTRA ............................................................................................. 162
3.3 OPERACIONALIZACIÓN DE VARIABLES........................................................................ 164
3.4INSTRUMENTOS DE RECOLECCIÓN DE DATOS ............................................................ 165
3.5PROCEDIMIENTOS DE LA INVESTIGACIÓN ................................................................... 166
3.6RECOLECCIÓN DE LA INFORMACIÓN ........................................................................... 167
3.7PROCESAMIENTO Y ANÁLISIS....................................................................................... 167
3.8RESULTADO DE LA ENCUESTA REALIZADA................................................................... 168
3.9ANÁLISIS COMPARATIVO DEL SISTEMA OPERATIVO ANDROID, SYMBIAN OS Y
WINDOWS MOBILE ........................................................................................................... 173
3.9.1 Criterios básicos ................................................................................................... 173
3.9.1.1 Comparativa de los merados de aplicaciones móviles ................................. 173
3.9.2 Criterios principales ............................................................................................. 180
3.9.3 Clasificación basada en otros criterios ................................................................. 189
3.9.3.1 Criterios técnicos........................................................................................... 189
3.9.3.2 Criterios de interfaz de usuario..................................................................... 189
3.10LISTADO DE PERSONAS: APLICACIÓN IMPLEMENTADA UTILIZANDO EL SDK DE
ANDROID Y EL SDK DE SYMBIAN OS ................................................................................. 192
xiii
CAPÍTULO IV .......................................................................................................................... 217
4.1 CRONOGRAMA............................................................................................................ 217
4.2 PRESUPUESTO ............................................................................................................. 223
CAPÍTULO V ........................................................................................................................... 224
5.1 CONCLUSIONES Y RECOMENDACIONES...................................................................... 224
5.1.1 CONCLUSIONES .................................................................................................... 224
5.1.2 RECOMENDACIONES ............................................................................................ 229
xiv
ÍNDICE DE CUADROS
CUADRO NO. 1 .......................................................................................................................... 5
ESTADÍSTICA DE VENTA DE DISPOSITIVOS ANDROID ............................................................... 5
CUADRO NO. 2 ........................................................................................................................ 33
VERSIONES DE LA PLATAFORMA............................................................................................. 33
CUADRO NO. 3 ........................................................................................................................ 46
HERRAMIENTAS PARA EL DESARROLLO DE APLICACIONES .................................................... 46
CUADRO NO. 4 ........................................................................................................................ 57
RELACIÓN DE LAS VERSIONES DE ANDROID Y EL NIVEL DEL API ............................................ 57
CUADRO NO. 5 ...................................................................................................................... 139
FORMATOS MULTIMEDIA SOPORTADOS EN LA PLATAFORMA ............................................ 139
CUADRO No. 6 ....................................................................................................................... 164
MATRIZ DE OPERACIONALIZACIÓN DE VARIABLES ............................................................... 164
CUADRO NO. 7 ...................................................................................................................... 175
CARACTERÍSTICAS PRINCIPALES DE CADA TIENDA ............................................................... 175
CUADRO NO. 8 ...................................................................................................................... 175
MODELO DE INGRESOS MONETARIOS DE CADA TIENDA ..................................................... 175
CUADRO NO. 9 ...................................................................................................................... 176
VENTAS DE TELÉFONOS INTELIGENTES POR SISTEMA OPERATIVO (EN MILES) ................... 176
CUADRO NO. 10 .................................................................................................................... 190
RESULTADO COMPARATIVA CRITERIOS PRINCIPALES .......................................................... 190
CUADRO NO. 11 .................................................................................................................... 194
REQUERIMIENTOS MÍNIMOS DE HARDWARE PARA INSTALAR LOS SDK.............................. 194
CUADRO NO. 12 .................................................................................................................... 194
REQUERIMIENTOS MÍNIMOS DE SOFTWARE PARA INSTALAR LOS SDK ............................... 194
xv
ÍNDICE DE GRÁFICOS
GRÁFICO NO. 1 ........................................................................................................................ 23
LAS TELECOMUNICACIONES EN EL PAÍS ................................................................................. 23
GRÁFICO NO. 2 ........................................................................................................................ 30
EVOLUCIÓN DE LOS TELÉFONOS CELULARES.......................................................................... 30
GRÁFICO NO. 3 ........................................................................................................................ 39
ARQUITECTURA DE LA PLATAFORMA ANDROID..................................................................... 39
GRÁFICO NO. 4 ........................................................................................................................ 50
ESQUEMA DEL ENTORNO DE DESARROLLO ............................................................................ 50
GRÁFICO NO. 5 ........................................................................................................................ 51
PERSPECTIVA JAVA .................................................................................................................. 51
GRÁFICO NO. 6 ........................................................................................................................ 52
VISTA JAVADOC ....................................................................................................................... 52
GRÁFICO NO. 7 ........................................................................................................................ 53
PERSPECTIVA DDMS ................................................................................................................ 53
GRÁFICO NO. 8 ........................................................................................................................ 56
VENTANA PARA LA CREACIÓN DE UN NUEVO PROYECTO...................................................... 56
GRÁFICO NO. 9 ........................................................................................................................ 59
APLICACIÓN HOLAMUNDO ..................................................................................................... 59
GRÁFICO NO.10 ....................................................................................................................... 72
CICLO DE VIDA DE UNA ACTIVIDAD ........................................................................................ 72
GRÁFICO NO. 11 ...................................................................................................................... 76
EJEMPLO DE ACTIVIDAD ......................................................................................................... 76
GRÁFICO NO. 12 ...................................................................................................................... 78
DIAGRAMA DE CLASES DEL API VIEW DE ANDROID ............................................................... 78
GRÁFICO NO. 13 ...................................................................................................................... 82
GUI GENERADA A TRAVÉS DE CÓDIGO JAVA .......................................................................... 82
GRÁFICO NO. 14 ...................................................................................................................... 83
xvi
GUI GENERADA A TRAVÉS DE UN ARCHIVO XML ................................................................... 83
GRÁFICO NO. 15 ...................................................................................................................... 85
ESQUEMA ABSOLUTELAYOUT ................................................................................................. 85
GRÁFICO NO. 16 ...................................................................................................................... 86
ESQUEMA FRAMELAYOUT ...................................................................................................... 86
GRÁFICO NO. 17 ...................................................................................................................... 88
ESQUEMA LINEARLAYOUT ...................................................................................................... 88
GRÁFICO NO. 18 ...................................................................................................................... 92
ESQUEMA RELATIVELAYOUT................................................................................................... 92
GRÁFICO NO. 19 ...................................................................................................................... 94
ESQUEMA TABLELAYOUT ........................................................................................................ 94
GRÁFICO NO. 20 ...................................................................................................................... 96
ESQUEMA GALLERY................................................................................................................. 96
GRÁFICO NO. 21 .................................................................................................................... 100
ELEMENTOS MÁS USADOS EN LA CREACIÓN DE INTERFACES.............................................. 100
GRÁFICO NO. 22 .................................................................................................................... 101
WIDGETS PARA LA VISUALIZACIÓN DE RELOJES ................................................................... 101
GRÁFICO NO. 23 .................................................................................................................... 104
MENÚ DE OPCIONES ............................................................................................................. 104
GRÁFICO. 24 .......................................................................................................................... 106
MENÚ CONTEXTUAL ............................................................................................................. 106
GRÁFICO NO. 25 .................................................................................................................... 108
SUBMENÚ ............................................................................................................................. 108
GRÁFICO NO. 26 .................................................................................................................... 114
PROVEEDOR DE CONTENIDOS: LLAMADAS RECIENTES ........................................................ 114
GRÁFICO NO. 27 .................................................................................................................... 117
INTENTO: REALIZAR UNA LLAMADA TELEFÉNICA ................................................................. 117
GRÁFICO NO. 28 .................................................................................................................... 122
RECEPTOR DE DIFUSIÓN ....................................................................................................... 122
GRÁFICO NO. 29 .................................................................................................................... 127
xvii
SERVICIO ............................................................................................................................... 127
GRÁFICO NO.30 ..................................................................................................................... 130
HILO (THREAD) ...................................................................................................................... 130
GRÁFICO NO. 31 .................................................................................................................... 134
NAVEGADOR DE ARCHIVOS .................................................................................................. 134
GRÁFICO NO. 32 .................................................................................................................... 137
NAVEGADOR WEBKIT ............................................................................................................ 137
GRÁFICO NO. 33 .................................................................................................................... 145
REPRODUCCIÓN DE VIDEO ................................................................................................... 145
GRÁFICO NO. 34 .................................................................................................................... 147
NOTIFICACIÓN DE FINALIZACIÓN DE REPRODUCCIÓN DEL VIDEO ....................................... 147
GRÁFICO NO. 35 .................................................................................................................... 169
ENCUESTA: PLATAFORMAS OBJETIVO PARA EL DESARROLLO DE APLICACIONES................ 169
GRÁFICO NO. 36 .................................................................................................................... 170
ENCUESTA: NIVEL DE CONOCIMIENTO SOBRE ANDROID ..................................................... 170
GRÁFICO NO. 37 .................................................................................................................... 171
ENCUESTA: ORDEN DE IMPORTANCIA DE LAS CARACTERÍSTICAS QUE DEBE POSEER UNA
PLATAFORMA PARA TELÉFONOS INTELIGENTES .................................................................. 171
GRÁFICO NO. 38 .................................................................................................................... 177
PROPORCIÓN DE APLICACIONES PAGADAS VS LAS GRATUITAS ........................................... 177
GRÁFICO NO. 39 .................................................................................................................... 178
PRECIO PROMEDIO DE LAS APLICACIONES ........................................................................... 178
GRÁFICO NO. 40 .................................................................................................................... 197
ANDROID: PANTALLA INICIAL ............................................................................................... 197
GRÁFICO NO. 41 .................................................................................................................... 197
SYMBIAN OS: PANTALLA INICIAL.......................................................................................... 197
GRÁFICO NO. 42 .................................................................................................................... 198
ANDROID: MENÚ DE OPCIONES ........................................................................................... 198
GRÁFICO NO. 43 .................................................................................................................... 198
SYMBIAN OS: MENÚ DE OPCIONES ..................................................................................... 198
xviii
GRÁFICO NO. 44 .................................................................................................................... 198
ANDROID: AGREGAR PERSONA............................................................................................. 198
GRÁFICO NO. 45 .................................................................................................................... 198
SYMBIAN OS: AGREGAR PERSONA....................................................................................... 198
GRÁFICO NO. 46 .................................................................................................................... 199
ANDROID: CUADRO DE DIÁLOGO ......................................................................................... 199
GRÁFICO NO. 47 .................................................................................................................... 199
SYMBIAN OS: CUADRO DE DIÁLOGO ................................................................................... 199
GRÁFICO NO. 48 .................................................................................................................... 200
ANDROID: MOSTRAR DATOS ................................................................................................ 200
GRÁFICO NO. 49 .................................................................................................................... 200
SYMBIAN OS: MOSTRAR DATOS .......................................................................................... 200
GRÁFICO NO. 50 .................................................................................................................... 202
CICLO DE VIDA DE UNA APLICACIÓN EN SYMBIAN ............................................................... 202
xix
COMPUTACIONALES
EVALUACIÓN
DE LA PLATAFORMA
ANDROID PARA DISPOSITIVOS MÓVILES
Autor: Antonio Rodríguez
Turtor: Ing. David Benavides
RESUMEN
Android es una plataforma para dispositivos móviles que se caracteriza por ser
abierta, completa y libre con el potencial para liderar en el mercado de los teléfonos
inteligentes. El objetivo principal del presente trabajo es evaluar sus características,
compararla con plataformas que operan en el mismo segmento y demostrar sus
funcionalidades. Como parte del contenido Ud. podrá encontrar una guía para
desarrollar aplicaciones para Android, conocer sobre sus principales componentes:
Actividades, Servicios, Intentos, Adaptadores y Receptores de Difusión. Visualizar
un estudio comparativo frente a otros sistemas operativos móviles así como
aplicaciones útiles como monitorear la ubicación de las personas desde un sitio web.
Concluir indicando que cada vez son más los tipos de equipos de los que Android
forma parte, lo que permite creer que esta plataforma puede ser la base para crear un
entorno en donde las personas puedan vivir interactuando con la tecnología sin notar
su presencia.
xx
COMPUTACIONALES
EVALUACIÓNDE LA PLATAFORMAANDROID PARA
DISPOSITIVOS MÓVILES
ABSTRACT
Android is a platform for mobile devices that is characterized by be open, complete
and free with the potential to lead in the smart phone market. The main objective of
this study is to evaluate its characteristics, compare it with platforms operating in the
same segment and demonstrate Android capabilities. As part of the content you can
find a guide to develop applications for Android, learn about its major components:
Activities, Services, Intents, Adapters and Broadcast Receivers. Show a comparative
study against other mobile operating systems and applications useful to monitor the
location of people from a website. Concludes that Android is part of more and more
types of equipment, which allows you to believe that this platform can be the basis
for creating an environment where people can live interacting with the technology
without noticing their presence.
1
INTRODUCCIÓN
En la última década la evolución de la tecnología ha dado un salto inesperado, la
necesidad de las personas por mejorar la comunicación y el intercambio de
información que comenzó con los inventos revolucionarios de la computadora
personal y la Internet, actualmente se traduce en términos de telefonía celular.
Según el informe de prensa de la consultora Analysys Mason 1del mes de abril del
2010, se prevé que para el año 2014 existirán 1.7 billones de teléfonos inteligentes en
el mundo. Considerando los resultados de este estudio uno debe formularse una
pregunta muy interesante ¿Cómo sacar provecho de esta tendencia?
Google, quien para mantener y aumentar su relevancia en el futuro decidió
incursionar en el mercado del Internet móvil nos proporciona la respuesta: Android,
una plataforma de software abierta para que nosotros, los desarrolladores de
aplicaciones podamos beneficiarnos evitando esas barreras artificiales que en otras
plataformas no nos permitían tomar todas las ventajas del acceso al hardware del
equipo, con el extra de poder lucrarnos distribuyéndolas en el market (mercado en
1
Analysys Mason es una empresa asesora en telecomunicaciones, tecnología y medios de
comunicación.
Fuente:
http://www.analysysmason.com/Research/Content/ViewPoints\RDMY0smartphones-forecast-OS-Apr2010
2
línea) que la misma empresa mantiene con el objetivo de aumentar las ventas y la
popularidad de su reciente producto.
CAPÍTULO I
El PROBLEMA
“EVALUACIÓN DE LA PLATAFORMA ANDROID PARA
DISPOSITIVOS MÓVILES”
1.1UBICACIÓN DEL PROBLEMA EN UN CONTEXTO
Dentro de los dispositivos móviles, los smartphones2o teléfonos inteligentes forman
parte de la revolución tecnológica más silenciosa que ha ocurrido en el mundo, estos
equipos que originalmente formaban parte de las herramientas de trabajo de los
ejecutivos hoy en día son una opción popular para cualquier consumidor.
Android es una tecnología prometedora, tanto para los usuarios de teléfonos celulares
inteligentes así como para las personas interesadas en hacer negocios y desarrollar
aplicaciones sobre ella. El problema central del presente trabajo es realizar un estudio
sobre esta plataforma, determinar cuáles son las ventajas y desventajas que posee
frente a Symbian OS y Windows Mobile, plataformas que operan en el mismo
mercado, y como pueden beneficiarse los usuarios ya antes mencionados. Además de
servir como un documento guía para los desarrolladores, principalmente
ecuatorianos, ya que el material de consulta existente en español es aun limitado.
2
Ver su definición en el Anexo 1: Glosario
4
Con un número elevado de empresas y sus tecnologías compitiendo en el medio se
podría pensar que los ganadores son los consumidores; sin embargo, los más
beneficiados somos los desarrolladores de aplicaciones que tenemos un mundo de
oportunidades, escoger la plataforma sobre la cual desarrollar y obtener mayores
beneficios puede resultar hasta cierto punto complicado, a lo largo de este documento
se expondrá porque Android constituye una de las mejores opciones.
1.2SITUACIÓN CONFLICTO NUDOS CRÍTICOS
Lo primero que se debe de especificar cuando se trata de evaluar dispositivos
móvileses que existen diferentes visiones de acuerdo al tipo de persona interesada,
pudiendo ser esta la empresa fabricante del equipo y de los accesorios, los
desarrolladores de aplicaciones o los usuarios finales que hacen uso de los mismos.
Android es una tecnología reciente pero con un futuro prometedor, como se puede
apreciar en el siguiente cuadro estadístico publicado en la nota de prensa del mes de
febrero del 2010 por parte de la empresa Gartner3,del año 2008 al 2009 el porcentaje
de participación de Android en el mercado mundial de los dispositivos móviles se
incrementó un 3.5% y se estima que para el año 2012 ocupe el segundo lugar en la
lista de aceptación por parte de los usuarios finales.
3
Gartner es una empresa asesora en telecomunicaciones, tecnología y medios de comunicación.
Fuente: http://www.gartner.com/it/page.jsp?id=1306513
5
CUADRO NO. 1
ESTADÍSTICA DE VENTA DE DISPOSITIVOS ANDROID
Compañía
Symbian
Research In Motion
iPhone OS
Microsoft Windows Mobile
Linux
Android
WebOS
Other OSs
Total
2008
Unidades
%
Vendidas Mercado
72,933.5
52.4
23,149.0
16.6
11,417.5
8.2
16,498.1
11.8
10,622.4
7.6
640.5
0.5
NA
NA
4,026.9
2.9
139,287.9
100.0
2009
Unidades
%
Vendidas Mercado
80,878.6
46.9
34,346.6
19.9
24,889.8
14.4
15,027.6
8.7
8,126.5
4.7
6,798.4
3.9
1,193.2
0.7
1,112.4
0.6
172,373.1
100.0
Elaboración: Antonio Rodríguez Andrade
Fuente: Gartner
En este documentose expondrá información relevante que permita al lector conocer la
plataforma, visualizar de manera breve pero concisa sus prestaciones, qué factores
hacen que se distinga de las demás, y si en definitiva se convertirá en la favorita de
los desarrolladores, lo
que consecuentemente se traduce a los otros tipos de
interesados ya antes mencionados.
6
1.3CAUSAS Y CONSECUENCIAS DEL PROBLEMA
Andy Rubin, vicepresidente de ingeniería en Googley supervisor del proyecto
Android, la describe como:
La primera plataforma verdaderamente abierta y completa para
dispositivos móviles, dotada de todo el software para ejecutar enel
teléfono móvil, pero sin los obstáculos de propiedad que han
obstaculizado la innovación de la tecnología móvil4.
Al ser una carrera tecnológica no nos podemos quedar atrás en la tecnología, con la
proliferación dela Internet y la comunicación inalámbrica se abren nuevos horizontes
y oportunidades, Android constituye una de ellas.Uno de los grandes inconvenientes a
la hora de desarrollar aplicaciones para dispositivos móviles es el hecho de las
empresas propietarias del sistema operativo no proporcionan el mismo trato tanto
para las aplicaciones nativas así como las realizadas por terceros, además de bloquear
el acceso al hardware del equipo. Esta situación puede resultar frustrante para los
desarrolladores. Sin embargo, Android rompe estas barreras y proporciona un entorno
de desarrollo con igualdad de condiciones para todos los desarrolladores.
4
Texto extraído y traducido al español el 4 de abril del 2010, la versión original se encuentra en el
idioma inglés y puede ser visualizada en http://googleblog.blogspot.com/2007/11/wheres-mygphone.html.
7
1.4DELIMITACIÓN DEL PROBLEMA
El estudio se desarrolla dentro del campo de la tecnología de los dispositivos móviles,
específicamente en el área de los teléfonos inteligentes. El aspecto central es evaluar
Android. Para el desarrollo de los ejemplos demostrativos incluidos en el presente
estudio se utiliza la versión 1.6 de Android, Donut, esto significa que las aplicaciones
podrán ejecutarse en cualquier dispositivo que posea esta versión o cualquier versión
superior sin presentar ningún inconveniente, es importante mencionar que el idioma
de las mismas en cualquier región donde se utilicen será el español, sin embargo
Android posee el mecanismo para permitir la internacionalización del software
desarrollado sobre ella, este tema está fuera del alcance de este documento, pero
podrá
encontrar
buenas
referencias
en
el
siguiente
enlace:
http://developer.android.com/guide/topics/resources/localization.html.
Actualmente los teléfonos celulares son un elemento indispensables para las personas,
muchas de sus tareas diarias requieren de las prestaciones que estos dispositivos
proporcionan. La lucha de las grandes compañías por ocupar mayor volumen de
usuarios en el mercado de los teléfonos inteligentes permite que con mayor frecuencia
y menor tiempo aparezcan nuevas tecnologías o se mejoren las que existen. Android
es una plataforma avalada principalmente por Google y que en el corto tiempo que
tiene en el medio ha logrado alcanzar un porcentaje importante en los mercados de los
países en que ya se encuentra disponible.
8
El estudio de Android se basará en documentar sus componentes, los fundamentos
para el desarrollo de aplicaciones, así como compararlo con los sistemas operativos
Symbian OS y Windows Mobile. Todas las aplicaciones desarrolladas durante el
presente estudio podrán ser ejecutadas en el emulador incorporado en su SDK5con la
finalidad de que los interesados puedan evaluar de manera visual su comportamiento
y las bondades que nos proporciona.
1.5FORMULACION DEL PROBLEMA
¿Es Android el futuro de la computación móvil y la oportunidad que esperaban los
desarrolladores ecuatorianos para explotar sus aplicaciones?Uno de los mayores
inconvenientes de las plataformas para dispositivos móviles es que las empresas
dueñas de la tecnología restringen el acceso al hardware para las aplicaciones
desarrolladas por terceros, además de limitar los equipos sobre los cuales se pueden
ejecutar los sistemas operativos que forman parte de estas plataformas. Google ha
demostrado que tener dispositivos disponibles para diferentes compañías hace la
diferencia entre un buen desempeño y la dominación absoluta. El hecho de que la
plataforma Android sea de código abierto y que se ejecuta en múltiples dispositivos
en múltiples redes de operadores le han permitido ganar una cuota de mercado más
rápido en comparación con una plataforma con una única compañía como el iPhone
OS.
5
9
Los aspectos destacados del estudio son considerados a una perspectiva a corto plazo,
la llegada de Android al Ecuador ya es una realidad, se espera que durante la etapa de
masificación de los usuarios de esta tecnología los desarrolladores ecuatorianos
puedan hacer uso de este estudio para obtener réditos.
Para responder a la pregunta inicial se realizará una breve comparativa de Android
frente a otras plataformas, los criterios a evaluar corresponden a: criterios básicos,
principales, técnicos y de interfaz de usuario, que se detallan en el Capítulo 3 del
documento en cuestión. A nivel de los desarrolladores, que es en donde se pone
mayor énfasis, se desarrollará una pequeña aplicación para Android y Symbian OS,
con el propósito de comparar los procesos en cada plataforma, orientados a evaluar
SDK’s, ciclos de vida de las aplicaciones, cómo se manejan los eventos y los
mecanismos que se utilizan para el almacenamiento de la información.
Adicionalmente se documentarán las características y los beneficios de desarrollar
sobre esta plataforma, sustentándose en ejemplos prácticos que se pueden probar en el
emulador incluido en su SDK.
10
1.6EVALUACIÓN DEL PROBLEMA
Los aspectos generales de evaluación son:
Delimitado.-El estudio está orientado a demostrar las prestaciones de la plataforma
con el objetivo de que los desarrolladores ecuatorianos lo utilicen como medio de
consulta. En lo que respecta al sistema operativo incluido en la pila de software se
realizará una comparativa contrastándolo con los sistemas operativos móviles
Symbian OS y Windows Mobile.También se comparará el ciclo de vida y los
procesos involucrados en el desarrollo de programas tanto para Android como para
Symbian OS.
Evidente.-Los resultados del estudio podrán ser visibles a lo largo del documento, se
utilizarán cuadros estadísticos cuando sea relevante y se documentarán las
demostraciones prácticas para facilitar la comprensión de los temas tratados.
Concreto: Los temas expuestos se abordarán directamente con el propósito de
facilitar la comprensión del lector, el contenido del estudio requiere tener
fundamentos de programación para su total entendimiento ya que está dirigido
principalmente para desarrolladores.
11
Factible.-El alcance del proyecto esta ajustado para ser realizado en el corto tiempo
que se ha proporcionado para el desarrollo del mismo. En la sección 1.7 y 1.8 de este
capítulo se detallan los objetivos, las tareas y el alcance del presente trabajo.
Además, el SDK de Android proporciona un emulador que permite simular el
comportamiento de las aplicaciones que se van a ejecutar sobre los dispositivos con el
fin de que cualquier persona interesada en la tecnología pueda hacer pruebas con ella.
Identifica los productos esperados.- El resultado del estudio busca demostrar de
manera objetiva las capacidades de Android, contrastarlo con otras plataformas que
compiten en el mismo mercado,además de presentar aplicaciones que sustenten la
investigación.
Original:En un futuro no muy lejano, las necesidades de independencia de los
usuarios del cableado se van a hacer realidad y serán los dispositivos móviles los
preferidos de los usuarios para realizar los procesamientos de datos en sus tareas
cotidianas. Basado en este contexto, el estudio es original en nuestro país, ya que se
realizará sobre una tecnología joven,como precedente, en el Ecuador recientemente
hicieron su arribo los primeros teléfonosAndroid, el viernes 25 de junio del 20106.
6
Fuente: http://www.eluniverso.com/2010/06/25/1/1431/primer-telefono-sistema-operativo-androidecuador.html
12
1.7OBJETIVOS
1.7.1 OBJETIVO GENERAL
Evaluar las características de la plataforma Android y las facilidades que proporciona
a los desarrolladores en la creación de aplicaciones para teléfonos celulares
inteligentes haciendo uso de un API7y un entorno de desarrollo robusto.
1.7.2 OBJETIVOS ESPECÍFICOS
Para la consecución del objetivo general será necesario:
Explorar el SDK de Android y su integración con Eclipse como IDE8de
desarrollo.
Desarrollar una guía de introducción para la creación de aplicaciones sobre
esta plataforma con el propósito de que el lector del presente trabajo de Tesis
tenga una base de referencia.
Efectuar un estudio comparativo de Android frente a dossistemas operativos
para teléfonos inteligentes que operan en el mismo mercado objetivo:Symbian
OS y Windows Mobile, el primero de ellos un sistema operativo que al igual
7
8
13
que Android es de código abierto, líder en ventas mundiales, como lo indica la
empresa Gartner en su reporte del mes de mayo del 2010 y lo reafirma la
empresa Canalys9en su reporte del mes de de agosto del mismo año, el
segundo un sistema operativo que a diferencia de Android es propietario de
Microsoft, y que estádiseñado para ser algo similar a
las versiones de
escritorio.
Implementar una pequeña aplicación para los sistemas operativos Symbian OS
y Android con el propósito de comparar:
 SDK’s
 Ciclo de vida de las aplicaciones
 Librerías
 Almacenamiento persistente de datos
 Manejo de eventos
Programas demostrativos:
 Desarrollar una aplicación que indique la posición en donde se encuentra
el dueño del equipo haciendo uso de GoogleMaps y la opción del GPS.
 Desarrollar una aplicación que permita visualizar una lista de los lugares
(ciudades) en donde han ocurrido terremotos en el último día. A su vez
tener corriendo un servicio que permita notificar al usuario que ha
9
Canalys es una empresa independiente centrada en tecnología, que ofrece inteligencia de negocios,
análisis y consulta estratégica sobre tendencias en un amplio rango de mercados de tecnología
14
ocurrido uno de estos eventos, la acción para notificarlo puede ser mostrar
una ventana de notificación.
Para realizar esta acción se utilizará como fuente para obtener los datos
la
página
web:http://earthquak.usgs.gov/eqcenter/catalogs/1day-
M2.5.xml.
 Realizar un velocímetro, una aplicación que permitirá visualizar el cambio
de velocidad de la persona haciendo uso del GPS incluido en el hardware
del equipo y basándose en la distancia recorrida durante lapsos de tiempo.
1.8 ALCANCES
El presente documento detalla el proceso para configurar Eclipse Galileo como el
entorno de desarrollo de Android, así como una breve descripción de las
funcionalidades que nos proporciona el IDE a nosotros los desarrolladores de
software para la creación de aplicaciones en esta plataforma.
La guía de referencia para el desarrollo de aplicaciones de Android explicará a
manera de introducción los siguientes temas:
 El uso y configuración de los componentes fundamentales para el
desarrollo de una aplicación en Android.
15
 El tratamiento de GUIs10, proveedores de contenidos, adaptadores,
intentos, notificaciones, SQLite y multimedia, desarrollando pequeñas
aplicaciones demostrativas para los tópicos previamente mencionados.
 Interacción con el API de Google, GoogleMaps.
 Las opciones avanzadas: Acceso al hardware del equipo y accesos al
kernel11.
El estudio comparativo de Android frente a los sistemas operativos Symbian OS y
Windows Mobile se realizará en base a los siguientes criterios:
Criterios básicos: mercado disponible a nivel de: usuario final, desarrolladores
y empresas desarrolladoras de equipos, basándose en datos estadísticos a nivel
mundial.
Criterios principales: portabilidad, confiabilidad, conectividad, tamaño del
kernel, seguridad y características que lo distinguen de los demás.
Criterios técnicos: administración de energía y capacidad multitarea.
Criterios de interfaz de usuario: personalización y diseño.
La aplicación “Listado de Personas” que se desarrollará tanto para Android y
Symbian OS deberá:
10
11
16
Permitir el ingreso de información de la persona: nombre, apellido, cédula,
teléfono y dirección.
Almacenar la información utilizando el mecanismo que proporciona el
sistema operativo para el almacenamiento persistente de datos.
Listar las personas que están almacenadas en el sistema en la pantalla
principal.
Eliminar registros de las personas.
Aplicaciones demostrativas
Antes de detallar las funcionalidades de las aplicaciones es importante recalcar que
las mismas serán desarrolladas sobre la versión 1.6 de la plataforma.
Aplicación “Localización GPS”
La presente aplicación deberá:
Obtener las coordenadas del GPS del equipo.
Actualizar la información de manera automática cuando la persona se
desplace 10 metros de la última coordenada geográfica leída.
Presentar la ubicación al usuario del equipo de manera narrativa y a su vez
en el mapa provisto por el API de Google Maps.
17
Aplicación “Visualizador de Terremotos”
Ejecutarse de manera automática cuando el sistema operativo termina de
bootear.
Acceder
a
la
página
http://earthquake.usgs.gov/earthquakes/catalogs/1day-M2.5.xml
web
para
extraer la información de los terremotos que han ocurrido durante el
último día.
Permitir que el usuario escoja la frecuencia con que la aplicación se
conecta al sitio para extraer la información así como la magnitud de los
terremotos que se presentarán en pantalla.
Formatear la información de la página para presentar los terremotos.
Mostrar en el mapa provisto por el API de Google Maps la ubicación
donde ocurrió el terremoto. Además de tener la opción de visualizar en el
mapa la ubicación de todos los terremotos de manera global.
Notificar al usuario de manera automática cuando un nuevo siniestro ha
ocurrido.
Aplicación “Velocímetro”
18
Calcular la velocidad con que el usuario se desplaza mediante los valores
que proporciona el GPS del equipo y el tiempo que se demora en llegar
desde el punto de partida hasta el punto de llegada.
1.8.1 ALCANCES ADICIONALES
Como un adicional del presente trabajo de tesis se desarrollarán las siguientes
aplicaciones:
Aplicación “Localizador Teléfono”
“Localizador Teléfono” es una aplicación que permite al usuario del equipo
solicitar a través de un mensaje SMS12la ubicación del dispositivo, el propósito es
el de tener un mecanismo para encontrar el equipo cuando se lo ha dejado
olvidado
o
cuando
se
ha
perdido,
siempre
y
cuando
esté
encendido.Adicionalmente si alguien llegase a cambiar la simcard del teléfono se
enviara de manera automática un mensaje al correo electrónico previamente
definido por el usuario indicando el suceso y el número de la nueva simcard. La
presente aplicación deberá:
12
19
Permitir que el usuario ingrese la contraseña o clave que la aplicación
buscará en los mensajes SMS entrantes.
Encriptar la contraseña con el algoritmo MD5.
Permitir que el usuario ingrese los datos del correo electrónico al que se
enviarán los mensajes informativos.
Permitir que el usuario establezca las preferencias para el envío de la
ubicación del equipo de manera automática (en background), puede ser a
través de un mensaje SMS al número de celular desde el cual se solicitó la
ubicación o al correo electrónico que previamente debió ser ingresado.
Almacenar
las
preferencias
utilizando
SharedPreferences
como
mecanismo para el almacenamiento persistente de datos.
Buscar en los mensajes SMS entrantes si se encuentra la clave para el
envío de la ubicación.
Enviar un correo electrónico de manera automática cuando se cambie la
simcard del equipo al correo definido por el usuario indicando este suceso
y el número de la nueva simcard ingresada.
Aplicación GPSFinder
La aplicación GPSFinder permite consultar la ubicación del equipo y por ende de
su portador desde el sitio web http://www.gpsfinder.zobyhost.com/Tesis/,
haciendo uso del API de Google Maps. Está compuesta por un aplicativo que se
20
ejecuta en los celulares Android y que proporciona las coordenadas de su
ubicación, además del sitio web en el que se encuentran los mantenedores de la
aplicación y la página de consulta.
El aplicativo “GPSFinderClient” que se instalará en los celulares Android deberá:
Ejecutarse de manera automática cuando el sistema operativo termina
de bootear.
Detener los servicios que se están ejecutando cuando se pierde la
conexión con la Internet y reanudar su ejecución cuando se
restablezca.
Conectarse al sitio web para el envío de las coordenadas con la
frecuencia de tiempo establecida en el sitio web.
Leer los parámetros de configuración del sitio web y actualizar los
hilos con los nuevos valores.
Presentar el estado de los servicios y del GPS al usuario portador del
equipo a través de una pantalla informativa.
El sitio web deberá:
Permitir actualizar los valores de los parámetros de configuración que
lee el aplicativo cliente instalado en los celulares Android.
21
Permitir el ingreso, modificación y eliminación de los usuarios
portadores de los teléfonos Android.
Permitir el ingreso, modificación y eliminación de los dispositivos que
serán contemplados por el sistema.
Permitir consultar la ubicación y el recorrido de los portadores de los
equipos por rango de fechas en el mapa provisto por el API de Google
Maps.
22
1.9JUSTIFICACIÓN E IMPORTANCIA
Según datos de la Secretaría Nacional de Telecomunicaciones (SENATEL) internet y
el uso de celulares se presentan como los dos rubros de mayor crecimiento
tecnológico en el Ecuador en los últimos tres años13.
En lo que a telefonía móvil se refiere, los datos son contundentes. Si en 2001 había
una densidad del 7%, en la actualidad esta llega al 89%, con algo más de 12.1
millones de líneas activas. Tan bien le ha ido a este sector que, comparando la
densidad de cobertura en el país, el Ecuador se encuentra a la par que Colombia (88%
de densidad) y Chile (86%) y muy por encima del Brasil (76%), Perú (69%) y Bolivia
(43%).
Adicionalmente, de acuerdo al resultado obtenido por el INEC (Instituto de
Estadísticas y Censos del Ecuador) tras su última encuesta de Tecnologías de la
Información y Comunicaciones TIC´S14realizado en diciembre de 2009 a 21.768
hogares ecuatorianos, a personas de cinco años en adelante, las conclusiones
obtenidas por la SENATEL se reafirman.
13
El
documento
puede
ser
leído
en
su
totalidad
en
la
página:
http://www.conatel.gov.ec/site_conatel/index.php?option=com_content&view=article&id=595:celular
es-e-internet-en-una-carrera-sin-trabas-en-ecuador&catid=46:noticias-articulos&Itemid=184
14
El
estudio
completo
se
puede
descargar
de
la
página:
http://www.inec.gov.ec/c/document_library/get_file?folderId=954942&name=DLFE-34202.pdf
23
GRÁFICO NO. 1
LAS TELECOMUNICACIONES EN EL PAÍS
Elaboración: Tomado de la fuente
Fuente: INEC
Análisis: Según esta encuesta, el uso del celular en el Ecuador subió 3.8 puntos más en
comparación a los datos de 2008, cuando se registró un uso de 69,9%.
En la publicación del 25 de enero del 2010, la empresa IDC15,cuyas siglas significan
International Data Corporation, determina que Android experimentará el crecimiento
más rápido de cualquier sistema operativo móvil. A partir de una base muy pequeña
de sólo 690.000 unidades en 2008, Android alcanzará 68millones de unidades
vendidas en el 2013, lo que constituye una tasa compuesta de crecimiento anual del
150.4%.
En el presente estudio se demuestra cómo obtener las coordenadas geográficas que
nos proporciona el GPS de los equipos, como enviar información a un sitio web,
utilizar Google Maps en Android, responder ante eventos que ocurren en el
15
IDC es un proveedor mundial de inteligencia de mercado, servicios de consultoría y eventos para la
tecnología de la información, telecomunicaciones y tecnología de consumo.
Fuente:
http://www.idc.com/getdoc.jsp?containerId=prUS22176610.
24
equipo,todo con la finalidad de que el lector amplíe sus horizontes, las oportunidades
de negocio existen, el precio promedio de las aplicaciones que se ofrecen en el market
de Android es de $3.50, pero el mercado más prometedor es el de lasgrandes
empresas, un ejemplo del uso de equipos con Android sería el monitorear el recorrido
de sus agentes o abaratar costos de comunicación mediante la tecnología PUSH16
incluida en la versión 2.2 de la plataforma.
Basado en las premisas anteriores, al ser un proyecto nuevo y con un futuro
prometedor, a corto o mediano plazo, cuando esta tecnología tenga acogida en nuestro
medio, las empresas ecuatorianas de desarrollo de aplicaciones para dispositivos
móviles tendránla necesidad de capacitar o contratar gente con conocimientos sobre
Android para obtener una cuota del mercado. La importancia de este estudio radica en
explorar la plataforma y establecer una referencia de su potencial.
16
Estilo de comunicaciones sobre Internet donde la petición de una transacción se origina en el
servidor. Fuente: http://es.wikipedia.org/wiki/Tecnolog%C3%ADa_Push
CAPITULO II
MARCO TEÓRICO
2.1ANTECEDENTES DEL ESTUDIO
Google anunció la plataforma
Android y la liberación de su primer equipo de
desarrollo de software en noviembre del 2007 y el primer dispositivo que lo
ejecutaba, el G1, en octubre del 2008. Como se puede observar este producto es
relativamente joven y la cantidad de información en español aun es un poco limitada.
En la publicación realizada por Dot Com Infoway de novimbre del 2009, “Android
by 2012, A study on present and future of Google's Android” se realiza una breve
narrativa sobre la situación actual de la plataforma y las predicciones que en base a
proyecciones estadísticas posicionan a Android en segundo lugar de preferencia en el
mercado de los dispositivos inteligentes por detrás de Symbian para el año 2012.
El documento “A Spectrum White Paper: Thoughts on Google Android” publicado
por la empresa Spectrum Data Technologies en febrero del año 2008 describe de
manera detallada la arquitectura de Android y sirve como base para este documento
cuando se hace referencia al mismo tópico.
26
Adicionalmente, el estudio también se fundamenta en la información que se encuentra
disponible en la Internet y en una serie de libros de los cuales se hace referencia en la
sección bibliográfica.
2.2 FUNDAMENTACION TEORICA
2.2.1 Dispositivo móvil
Los dispositivos móviles son micro-ordenadores lo suficientemente ligeros para que
una persona los puedan transportar, con conexión intermitente o permanente a una red
y que necesitan de la capacidad de una batería para funcionar de manera autónoma.
También se los conoce como computadoras de mano.
2.2.1.1 Tipos de dispositivos móviles
Teléfonos celulares.- equipos inalámbricos electrónicos que tienen como
función primordial recibir y realizar llamadas, pero que también permiten
enviar y recibir mensajes, reproducir archivos multimedia, navegación por
Internet, etc.
PDAs.-su nombre proviene del acrónimo en inglés Personal Digital Assistant
que significa asistente personal digital, son organizadores electrónicos cuyas
funcionalidades incluyen agenda, calendario, gestión de contactos,creación de
27
documentos, juegos, correo electrónico, navegación por Internet, reproducción
de archivos multimedia, etc. La línea que los separa de los teléfonos celulares
es cada vez másdifusa.
Consolas.- estos dispositivos están orientados al entretenimiento, diseñados
con el propósito de permitir que los usuarios puedan jugar. Integran ciertas
funcionalidades de un PDA, como agenda, calendario, conexión a Internet y
reproducción de archivos multimedia. Como ejemplos se pueden mencionar la
Nintendo DSi y el PlayStation Portable (PSP) de Sony.
2.2.1.2Categoría de dispositivos móviles
Debido a la gran diversidad de equipos y a las prestaciones que proporciona, en el
año 2005,T38 y DuPont Global Mobility InnovationTeam propusieron los siguientes
estándares de dispositivos móviles:
Dispositivo Móvil de Datos Limitados: dispositivos que tienen una pantalla
pequeña, principalmente basada en pantalla de tipo texto con servicios de
datos generalmente limitados a SMS y acceso WAP17.
Dispositivo Móvil de Datos Básicos: dispositivos que tienen una pantalla de
mediano tamaño, que utilizan menús o navegación basada en íconos por
medio de una rueda o cursor, y que ofrecen acceso a e-mails, lista de
direcciones, SMS y un navegador web básico.
17
28
Dispositivo Móvil de Datos Mejorados: dispositivos que tienen pantallas
medianas a grandes, que están por encima de los 240 x 120 pixeles,
navegación de tipo stylus, y que además de proporcionar las mismas
características que el Dispositivo Móvil de Datos Básicos posee aplicaciones
nativas como aplicaciones de Microsoft Office Mobile
y aplicaciones
corporativas usuales, en versión móvil, como SAP18, portales intranet, etc.
2.2.2Historia de los teléfonos celulares
Basado en los artículos publicados en los sitioshttp://www.historyofcellphones.net,
http://cellphones.org/cell-phone-history.html
y
http://www.android.com
a
continuación se lista de manera cronológica y resumida la historia de los teléfonos
celulares:
El primer móvil que apareció en el mercado fue el MTA Phone fabricado por
Ericsson en el año de 1956, el mismo que tuvo un total de 125 usuarios entre
Estocolmo y Gotemburgo, Suecia. Debido a su peso, 40 kilogramos, estos aparatos
debían integrarse a un vehículo.
En 1973, Motorola presentó un prototipo del primer teléfono celular portátil del
mundo, diseñado por Martin Cooper, conocido como el “padre de la tecnología
18
29
celular”. Aquel teléfono media cerca de 30 centímetros de largo y pesaba casi 800
gramos. Fue lanzado al mercado en 1983 con el nombre de Motorola DynaTAC
8000X, tenía un costo de 3995 dólares, contaba con memoria para almacenar 30
números de teléfono y su batería proporcionaba solamente una hora de tiempo de
conversación.
Unos años después, en 1984, Nokia comercializó el Mobira Talkman que añadía un
maletín que le proporcionaba varias horas de autonomía, aunque su peso era de unos
10 kg.
En 1993 IBM y BellSouth introducen el Simon Personal Communicator, primer
teléfono móvil en contar con funciones de PDA. Era un teléfono paginador,
calculadora, libreta de direcciones, fax y dispositivo de correo electrónico, todo en un
mismo paquete. Pesaba alrededor de 500 gramos y su precio era de 900 dólares.
Luego en 1996 Motorola lanza al mercado su terminal StarTAC, el primer móvil en
formato clamshell, que se doblaba por la mitad, haciendo del mismo un teléfono
realmente compacto para ser transportado.
El Kyocera QCP6035 es considerado el precursor de los teléfonos inteligentes, fue un
impacto en el mercado a principios del 2001, costaba entre 400 y 500 dólares y fue el
30
primer teléfono basado en Palm OS. Poseía una modesta memoria de 8 Mb y una
pantalla monocromática.
En el 2004, el MotorolaRAZR V3 reaparece con un diseño ultradelgado y apariencia
metálica, dispositivo que hizo popular el uso de los teléfonos móviles entre todo tipo
de consumidor. Posteriormente, el 9 de enero de 2007 Apple presentó al mundo lo
que llamaron la reinvención del teléfono, el iPhone. Un dispositivo con un diseño
innovador, contaba con una pantalla sensible al tacto (touch-sensitive screen).
En octubre del 2008, Google introduce al mercado el dispositivo móvil G1, mismo
que estaba dotado del sistema operativo Android, desde su liberación inicial hasta la
actualidad se han liberado seis actualizaciones al sistema, siendo la última “Froyo”, la
cual incrementa de manera general el sistema, la memoria y el rendimiento, Nexus
One de HTC es uno de los teléfonos dotados con esta versión.
GRÁFICO NO. 2
EVOLUCIÓN DE LOS TELÉFONOS CELULARES
Elaboración: Antonio Rodríguez
Fuente:
http://www.webdesignerdepot.com/2009/05/the-evolution-of-cell-phone-design-between1983-2009
Análisis: En la gráfica se presentan las mejoras en el diseño físico de los teléfonos celulares con el
paso del tiempo
31
2.2.3 El papel de los teléfonos celulares en la computación ubicua
La computación ubicua es un cambio de paradigma donde la tecnología se vuelve
prácticamente invisible en nuestras vidas. De manera técnica, se define como un
modelo de interacción en el que el procesamiento de la información se integra a los
objetos cotidianos que son parte de nuestras actividades diarias.El ejemplo más
visible de este modelo lo constituyen los teléfonos celulares.
De acuerdo al pensamiento de Andy Rubin publicado en el blog oficial de Google,
http://googleblog.blogspot.com/2008/09/future-of-mobile.html, el futuro de los
dispositivos móviles está orientado a:
Alertas inteligentes.- basado en los sensores que poseen, los dispositivos serán
consientes de las situaciones que ocurren alrededor de las personas y les
notificará si alguna de ellas o todas requieren de su atención.
Realidad aumentada.- añadirán información virtual a la información física ya
existente con el propósito de proporcionar información que le puede ser útil
al usuario en la toma de decisiones.
Herramienta para el desarrollo.- debido a su gran crecimiento y a la expansión
de la cobertura de operadoras, los teléfonos colaborarán aun más en el eje
económico.
32
2.2.4 Introducción a la plataforma Android
2.2.4.1 Un poco de historia
Android Inc. era una pequeña compañía con sede en Palo Alto, California-Estados
Unidos, la cual trabajaba en el desarrollo de un sistema operativo para dispositivos
móviles basado en Linux, principalmente para ser utilizado en teléfonos celulares.
Google, el mayor motor de búsquedas de la Internet, cuya misión es la de organizar la
información del mundo, se ha enfocado continuamente en la innovación, y debido al
rápido crecimiento del mercado de celulares inteligentes, en julio del 2005 adquirió
Android Inc. e incorporó a su equipo de trabajo a los co-fundadores de la recién
adquirida compañía, Rich Miner, co-fundador de Wildfire Communications, Andy
Rubin, co-fundador de Danger (una compañía de servicio de software), Chris White,
un ingeniero de WebTV y
Nick Sears, quien fue vice presidente de T-
Mobile.Finalmente el 5 de noviembre del 2007 la Open Handset Alliance (OHA), un
consorcio de 34 empresas de tecnología (hasta ese instante) entre las que se
encuentran Google, HTC, Motorola, Intel, Qualcomm, Sprint Nextel, T-Mobile y
NVIDIA, fue fundada con el propósito de mejorar esta plataforma tecnológica y
brindar mejor experiencia a los usuarios de dispositivos móviles.
33
2.2.4.2 ¿Qué es Android?
Android es un entorno de software integrado para dispositivos móviles que incluye un
sistema operativo, un middleware y un conjunto de aplicaciones bases. Es la primera
plataforma móvil de código abierto que tiene el potencial de lograr avances
significativos en muchos mercados.
En su página oficial, la Open Handset Alliance indica que “Android fue diseñada
desde cero con el objetivo explícito de ser la primera plataforma abierta,
completa y libre creada específicamente para dispositivos móviles”19.
2.2.4.3 Versiones de la Plataforma
CUADRO NO. 2
VERSIONES DE LA PLATAFORMA
1,1
1,5
(Cupcake)
Basado en
Linux
Kernel
2.6.27
19
Fecha de lanzamiento 09 de febrero 2009
El 30 de abril de 2009, la actualización oficial 1.5 (Cupcake) para
Android fue lanzada. Esta versión incluía nuevas características y
actualizaciones de la interfaz de usuario:

Capacidad para grabar y ver videos en el modo cámara de vídeo.

Subir videos a YouTube y fotos a Picasa directamente desde el
teléfono.
Texto
extraído
y
traducido
el
15
http://www.openhandsetalliance.com/oha_overview.html
de
abril
del
2010
desde
34

Bluetooth A2DP20y AVRCP21de apoyo.

Capacidad para conectarse automáticamente a un auricular Bluetooth
a una distancia determinada.

Nuevos widgets y carpetas que pueden llenar las pantallas de Inicio

Transiciones de pantallas animadas.
El 15 de septiembre de 2009, el SDK 1.6 (Donut) fue liberado, esta
actualización incluía:

Experiencia mejorada del Market de Android.

Cámara integrada, cámara de vídeo y la interfaz galería.
Actualización de Búsqueda mediante voz, con una respuesta más
rápida y mayor integración con las aplicaciones nativas, incluyendo

1,6
(Donut)
Basado en
Linux
Kernel 
2.6.29
la capacidad de marcar los contactos.
Mejoras en la experiencia de búsqueda para permitir la búsqueda de
marcadores, historial, contactos y la web desde la pantalla de inicio.

Soporte tecnológico para CDMA / EVDO, 802.1x , VPN , y el motor
text-to-speech actualizado.

Soporte para resoluciones de pantalla WVGA.

Introducción de la herramienta de desarrollo GestureBuilder.
El 26 de octubre de 2009, el SDK 2.0 (Eclair) fue liberado. Los cambios
introducidos fueron los siguientes:

2.0/2.1 
(Eclair)
Basado en
Linux 
Kernel 
2.6.29
20
Velocidad del hardware optimizada.
Soporte para un número mayor de tamaños de pantalla y
resoluciones.
Renovación de la interfaz de usuario.
Nueva interfaz de usuario del navegador y soporte para HTML5.

Nueva lista de contactos.

Mejor relación blanco-negro para los fondos.

Mejora de Google Maps 3.1.2.

Soporte para Microsoft Exchange.
21
35

Soporte de flash para la cámara.

Zoom digital.

Clase MotionEvent mejorada para realizar un seguimiento a toques
múltiples.

Mejora de teclado virtual.

Bluetooth 2.1.

Fondos de pantalla en vivo (Live Wallpapers).
El SDK 2.0.1 fue lanzado el 3 de diciembre de 2009.
EL SDK 2.1 fue lanzado el 12 enero de 2010.
El 20 de mayo de 2010, el SDK 2.2 (Froyo) fue liberado. Los cambios
incluyen:

Optimización del rendimiento, memoria y velocidad del sistema
operativo.

Velocidad de las aplicaciones adicionales mejoradas gracias a la
implementación de JIT.

Integración del motor JavaScript V8 de Chrome con la aplicación
del navegador.
2,2
(Froyo) 
Basado en
Linux
Kernel

2.6.32
Mejoras del soporte técnico de Microsoft Exchange (políticas de
seguridad, auto-descubrimiento, GAL de búsqueda, sincronización
del calendario, borrado remoto).
Opción para deshabilitar el acceso a datos sobre la red.

Rápido intercambio entre múltiples idiomas de teclado y sus
diccionarios.

Marcación por voz y uso compartido de contactos a través de
Bluetooth.

Apoyo para las contraseñas numéricas y alfanuméricas.

Soporte a los archivos subidos en la aplicación del navegador.

Soporte para la instalación de aplicaciones a la memoria expandible

Adobe Flash 10.1.
Elaboración: Traducido del cuadro original de la fuente
Fuente: http://en.wikipedia.org/wiki/Android_(operating_system)
36
2.2.4.4Licencias
Una licencia de software es un contrato entre el licenciante y el licenciatario del
programa informático para utilizar el software cumpliendo una serie de términos y
condiciones establecidas dentro de sus cláusulas. Las licencias se clasifican en base a
dos criterios:
Según los derechos que cada autor se reserva sobre su obra
 Licencia de software de código abierto permisiva.- Se puede crear una
obra derivada sin que ésta tenga obligación de protección alguna como
la ASL(Apache Software License).
 Licencia de software de código abierto robustas
o Licencias de software de código abierto robustas fuertes.obliga a que las obras derivadas o modificaciones que se
realicen al software original se deban licenciar bajo los mismos
términos y condiciones de la licencia original, dentro de esta
clasificación se encuentra la GPL (General Public License) y la
(EPL) Eclipse Public License, esta última utilizada en Symbian
OS.
o Licencias de software de código abierto robustas débiles.obliga a que las modificaciones que se realicen al software
original se deban licenciar bajo los mismos términos y
condiciones de la licencia original, pero que las obras
37
derivadas que se puedan realizar de él puedan ser licenciadas
bajo otros términos y condiciones distintas.
 Licencia de software de código cerrado.- los propietarios establecen
los derechos de uso, distribución, redistribución, copia, modificación,
cesión y en general cualquier otra consideración que se estime
necesaria
 Software de dominio público.- Se permite uso, copia, modificación o
redistribución con o sin fines de lucro
Según su destinatario
 Licencia de Usuario Final.- EULA (End User License Agreement) por
sus siglas en inglés, licencia por la cual el uso de un producto sólo está
permitido para un único usuario, Windows Mobile hace uso de esta
licencia.
 Licencia de distribuidores.- le asigna derechos restringidos a un
comerciante de tipo comisionario para que venda el producto
(software) dando una remesa o comisión al fabricante.
Android está liberada bajo dos licencias diferentes de código abierto. El kernel Linux
versión 2.6 está publicado bajo la licencia GPL,como exige la concesión de kernel
del sistema operativo de código abierto.En cuanto a la plataforma Android, excepto el
núcleo, tiene licencia Apache (ASL).
38
2.2.4.5Características distintivas
Conforme se establece en el libro Beginning Android 2 de Mark L. Murphy, Android
se caracteriza por poseer:
Aplicaciones con Google Maps.- a pesar de que Google Maps es un producto
popular entre los dispositivos móviles, en Android es un componente atómico
y reusable para el desarrollo de aplicaciones.
Servicios en segundo plano.- Android permite crear aplicaciones que utilizan
un modelo basado en eventos, ejecutándose de manera silenciosa mientras
otras aplicaciones están siendo utilizadas, de tal manera que reaccionan sólo
cuando ocurre un evento específico como una llamada, la recepción de un
mensaje, etc.
Datos compartidos y comunicación entre procesos.- usando Intents
(Intentos) y Content Providers (Proveedores de Contenido) Android permite a
sus aplicaciones intercambiar mensajes, y compartir información. Por
seguridad y para mitigar cualquier riesgo, la información y los archivos son
privados para cada aplicación a menos que sea explícitamente compartida
mediante un mecanismo de seguridad basado en permisos.
Aplicaciones creadas por igual.-la característica más importante que tiene
Android, es la de no hacer ninguna diferencia entre las aplicaciones nativas y
aquellas desarrolladas por terceros, lo que le permite a los usuarios cambiar la
39
apariencia de sus equipos pudiendo incluso reemplazar todas las aplicaciones
nativas. Los accesos a los componentes de hardware no están restringidos.
2.2.4.6Arquitectura
GRÁFICO NO. 3
ARQUITECTURA DE LA PLATAFORMA ANDROID
Aplicaciones
Aplicaciones
Nativas
Aplicaciones de
Terceros
Aplicaciones de
Desarrolladores
Framework de Aplicación
LBS
Proveedores
de Contenido
Administrador
de Ventana
Administrador
de Actividades
Telefonía
P2P/XMPP
Notificaciones
Vistas
Administrador
de Paquetes
Administrador
de Recursos
Entorno de Ejecución
Librerías
Gráficos
Media
SSL & Webkit
Librerías
Android
libC
Sqlite
Administrador
de Superficie
Máquina
Virtual Dalvik
Kernel Linux
Drivers del
Hardware
Administración de
Memoria
Administración de
Procesos
Administración de
Poder
Elaboración: Traducido del cuadro original de la fuente
Fuente: http://developer.android.com/guide/basics/what-is-android.html
Análisis: La arquitectura de Android representauna pila de componentes, en el gráfico se muestran los
diferentes elementos que forman parte de cada una de las capas en que esta pila se divide.
40
2.2.4.6.1 Aplicaciones
En la capa superior de la arquitectura se encuentran las aplicaciones que se ejecutan
sobre el sistema operativo incluido en la plataforma. Estas aplicaciones pueden ser:
Aplicaciones nativas.-aquellas que vienen incorporadas en los equipos por
defecto. El siguiente listado muestra las aplicaciones nativas que posee todo
teléfono celular Android:
Cliente e-mail
Aplicativo de administración de SMS
Aplicativo PIM22 (Personal Information Management) que incluye lista de
contactos y calendario para la administración de la información personal
Navegador basado en WebKit
Reproductor de música y gestor de imágenes
Aplicativo para grabación de video
Calculadora
Alarma reloj
Aplicaciones desarrolladas por terceros.-generalmente empresas grandes
que crean aplicativospara la plataforma, como Facebook.
Aplicaciones creadas por desarrolladores independientes.
22
41
2.2.4.6.2 Framework de Aplicación
Proporciona las clases necesarias para el desarrollo de aplicaciones, así como una
abstracción genérica para el acceso al hardware. Adicionalmente administra la
interfaz de usuario y de aplicación.
LBS (Location Based Services).- estructura de soporte que las aplicaciones
pueden utilizar para determinar la ubicación del dispositivo y registrarse para
recibir actualizaciones.
Proveedor de Contenido (Content Providers).- componente que permiten
almacenar yrecuperar datosy hacerlosaccesiblea todas lasaplicaciones.
Administrador de Ventana (Window Manager).- componente encargado de
la gestión de la ventana.
Administrador de Actividades (Activity Manager).- encargado de
gestionarelciclo de vidade las aplicaciones.
Administrador de Paquetes (Package Manager).-permite gestionar los
paquetes de aplicación que se encuentran instalados en el equipo.
Telefonía.-proporciona las clases para el monitoreo de la información del
teléfono, como el tipo de red y el estado de la conexión.
P2P/XMPP.-API que permite utilizar servicios de comunicación punto a
punto (peer to peer) haciendo uso de una versión especializada del protocolo
XMPP (Extensible Messaging and Presence Protocol).
42
Administrador de Notificaciones (Notification Manager).-permite atodas
las aplicacionesmostraralertaspersonalizadasenlabarrade estado.
Vistas (Views).- Unamplio conjuntode elementosque se puedenutilizarpara
crear
una
aplicación,
incluidas
laslistas,
cajas
detexto,botones,
e
inclusounnavegadorwebembebido.
Administrador de recursos (Resource Manager).- permite el acceso a los
recursos que no son código,estos recursos pueden ser cadenas, gráficos y
archivos de diseño.
2.2.4.6.3 Librerías
Ejecutándose sobre el kernel se encuentran diversas librerías que pueden ser
utilizadas para la creación de aplicaciones.
Librerías para gráficos, que incluyen SGL y OpenGL para gráficos 2D Y 3D
respectivamente
Librería multimedia para la reproducción de medios de audio y vídeo
WebKit y SSL23para el navegador web integrado y la seguridad en Internet,
esta última escrita en C/C++
Libc escrita en C/C++
Librería SQLite para la utilización de base de datos
Administrador de superficie encargado de la gestión de la pantalla
23
43
2.2.4.6.4 Entorno de Ejecución (Runtime)
Es el motor de ejecución de las aplicaciones. Está compuesto por:
Librerías Android.- incluyen las librerías principales de Java, así como las
librerías específicas de Android.
Principales librerías de Java utilizadas en Android
java.lang.- clases fundamentales para el diseño del lenguaje de
programación Java
java.io.- capacidades de entrada y salida
java.net.- conexiones de red
java.util .- utilidades
java.text.- utilidades para el manejo de texto
java.math.- clases matemáticas y de manipulación de números
javax.net.- clases para el manejo de red
javax.security.- clases relacionadas a la seguridad
javax.xml.- clases para manejo de XML24basado en DOM
org.apache.- clases relacionadas con HTTP
org.xml.- clases para el manejo de XML basado en SAX
Librerías propias de Android
android.app.- modelo de acceso a las aplicaciones de Androi
android.content.-acceso y publicación de los datos en Android
24
44
android.net.- contiene la clase Uri, utilizada para acceder a contenidos
diversos
android.graphics.- gráficos primitivos
android.opengl.- clases OpenGL
android.os.- acceso al sistema operativo en el ambiente de desarrollo
de Android
android.provider.- clases para la administración de los proveedores
de contenido
android.telephony.- acceso a las capacidades telefónicas
android.text.- diseño de texto
android.util.- utilidades
android.view.- elementos UI
android.webkit.- funcionalidad del navegador
android.widget.- más elementos UI
Máquina Virtual Dalvik.- máquina virtual basada en registros que se ha
optimizado para garantizar que un dispositivo pueda ejecutar varias instancias
simultáneamente y de manera eficiente.
45
2.2.4.6.5 Kernel
El núcleo del sistema operativo, se encarga de administrar los servicios básicos,
incluidos
los
controladores
de
hardware,
proceso,
gestión
de
memoria,
seguridad, red y administración de energía. También proporciona una capa de
abstracción entre el hardware y el resto de la pila.
2.2.4.7Configuración del entorno de desarrollo de Android
Al igual que la mayoría de las aplicaciones para teléfonos celulares, las aplicaciones
de Android son desarrolladas en un ambiente cliente-objetivo (host-target). Es decir
que se desarrollan en una computadora en donde los recursos son abundantes, para
luego ser probadas en el dispositivo físico o en el emulador incluido en el SDK.
La primera consideración a la hora de desarrollar las aplicaciones son los sistemas
operativos sobre los cuales se puede instalar y ejecutar el SDK(esta información fue
extraída del sitiohttp://developer.android.com/sdk/requirements.html):
Windows XP (32-bit) o Vista (32- or 64-bit)
Mac OS X 10.5.8 (Sólo chips Intel)
Linux (probado en la versión Linux Ubuntu Hardy Heron)
46
Independientemente de cualquiera de los sistemas operativos listados en el párrafo
anterior, generalmente se necesitarán las siguientes herramientas:
CUADRO NO. 3
HERRAMIENTAS PARA EL DESARROLLO DE APLICACIONES
Herramienta
URL de descarga
Eclipse 3.4 (Ganymede) o 3.5 (Galileo)
http://www.eclipse.org/downloads
Java Development Kit (JDK)
http://java.sun.com/javase/downloads/index.jsp
Android Software Developer Kit
(SDK)
Android Developer Tool (ADT)
http://developer.android.com/sdk/index.html
http://developer.android.com/sdk/eclipse-adt.html
Fuente: http://developer.android.com/sdk/requirements.html
2.2.4.7.1 SDK (Software Development Kit)
El
SDK
de
Android
es
distribuido
a
través
de
la
página
http://developer.android.com/sdk/index.html, se presenta como un archivo ZIP que
contiene las bibliotecas, herramientas de desarrollo, documentación de la plataforma
yvarias aplicaciones demostrativas.
2.2.4.7.2 API
Incluye las librerías Java y las propias de Android, mismas que fueron descritas
anteriormente en el numeral 2.2.4.6.4, “Entorno de Ejecución”.
47
2.2.4.7.3 Instalación del plug-in ADTpara Eclipse Galileo
El plug-in ADT (Android Development Tool) es el componente que permite agregar
las extensiones necesarias a Eclipse para su integración con las herramientas de
desarrollo de Android. Las instrucciones mostradas a continuación presentan las
opciones en inglés, considero que siempre se obtiene mayor beneficio utilizando las
herramientas en su lenguaje de origen. Sin embargo, las personas que deseen cambiar
el idioma al español pueden descargar un plug-in con este propósito.
1. Iniciar Eclipse
2. En la barra de menú seleccionar “Help → Install New Software”
3. En la nueva ventana que se presenta, al dar clic en “Add” aparecerá el cuadro
de diálogo “Add Site”, en donde se debe ingresar un nombre de referencia
para el plug-in y el URL para descargar la actualización: https://dlssl.google.com/android/eclipse. Dar click en “OK”
4. El nuevo sitio deberá aparecer en la lista de sitios del cuadro de dialogo de
instalación. Al dar clic en siguiente Eclipse comenzará a buscar el plug-in
ADT, una vez que haya finalizado mostrará las opciones disponibles para ser
instaladas.
5. En este momento se deberá seleccionar el nodo raíz de la lista y dar clic en
“next”
48
6. Inmediatamente Eclipse descargará el plug-in. Una vez finalizado se debe
asegurar que tanto las opciones de “Android DDMS” y “Android Developer
Tools” estén seleccionadas. Proceder a dar clic en “Next”
7. Leer el contenido de la licencia que aparecerá en la ventana que se presenta,
dar click en “Accept terms of the license agreement”, clic en “Next.”y clic en
“Finish.”
8. Reiniciar Eclipse
9. Después de reiniciado el IDE se deberá indicar la ruta en donde se encuentra
localizado el SDK descomprimido. En la barra de menú seleccionar
“Window → Preferences.”
En el cuadro de Preferences seleccionar
“Android” en la columna izquierda.
10. Finalmente dar click en el botón “Browse” para buscar la ruta en donde se
instaló el SDK, dar click en “Apply,” y finalmente en “OK
En caso de no contar con una conexión a Internet para realizar la instalación en línea
se puede realizar la descarga del plug-in como un archivo con extensión zip desde el
URL http://developer.android.com/sdk/eclipse-adt.html. Los pasos a seguir para
integrarlo con el IDE son similares a los descritos anteriormente, la única diferencia
radica en el paso número 3:
Cuando se abre el cuadro de dialogo “Add Site”, dar clic en “Archive” para proceder
a buscar y seleccionar el plug-in en nuestro directorio de archivos.
49
A continuación se enumeran las características que incorpora el plug-in ADT a
Eclipse:
Un asistente de proyectos de Android que simplifica la creación de nuevos
proyectos e incluye una plantilla básica para la aplicación.
Editores para ayudar a crear, editar y validar los archivos xml.
Construcción automática de proyectos, conversión a los ejecutables de
Android (.dex), empaquetamiento (.apk) e instalación de los proyectos sobre
la máquina virtual Dalvik.
El emulador de Android, el cual permite la manipulación de la apariencia, la
configuración de conexión de red,y la capacidad para simular las llamadas
entrantes y mensajes SMS.
El Dalvik Debug Monitoring Service (DDMS), que traducido al español
significa Servicio de monitoreo de depuración Dalvik, el cual permite realizar
operaciones de depuración del código.
Acceso al dispositivo o al sistema de archivos del emulador, lo que le permite
navegar por el árbol de carpetas y transferencia de archivos.
Depuración en tiempo de ejecución, para establecer puntos de interrupción y
una vista de las llamadas a la pila.
Toda la bitácora Android/Dalvik y las salidas por consola
50
El Gráfico No. 4 resume los componentes que conforman el entorno de desarrollo de
Android.
GRÁFICO NO. 4
ESQUEMA DEL ENTORNO DE DESARROLLO
Eclipse IDE
Herramientas por Línea de Comandos
Transferencia de Archivos
Simulador de GPS
Codificación
Depuración
ADT
SDK
Configuración del perfil del
emulador
Lanzamiento del emulador
Vista de procesos y del sistema de
archivos
Vista de Log
Emulador
Múltiples skins
Opciones de Conectividad de Red
Integración con Eclipse vía AVT
Equipo Android
Dispositivo físico Real
Documentación SDK
Fuente: Libro Unlocking Android A Developer’s Guide, de Ableson Frank, Collins Charlie, Sen Robi
(2009), pag. 35,
Análisis:Como se puede apreciar en la imágene el IDE Eclipse se encuentra fuertemente integrado con
el SDK de Android, permitiendo interactuar con todas las bondades de este último
2.2.4.7.4 Explorando las funcionalidades del IDE
Una vez que se ha configurado el entorno de desarrollo, el siguiente paso es entender
las funcionalidades que proporciona el mismo:
51
2.2.4.7.4.1 Perspectiva Java
Esta perspectiva proporciona un número conveniente de vistas para el desarrollo de
aplicaciones. En la parte izquierda se encuentra el explorador de paquetes que permite
visualizar una lista de todos los proyectos y sus estructuras.
GRÁFICO NO. 5
PERSPECTIVA JAVA
Fuente: Pantalla capturada del IDE
Análisis:La perspectiva Java es un contenedor de vistas que proporciona Eclipse para realizar la
codificación de las aplicaciones.
En el centro de la pantalla se encuentra el editor de código Java, cada vez que se
guarda el archivo, este
es compilado de manera automática por la herramienta
52
JDT25(Java Developer Tools). En el caso de que un error existiese, este se presentará
en la vista “Problems” ubicada en la parte inferior del editor.
Otra vista de gran ayuda la constituye “JavaDoc”, la cual provee de toda la
documentación disponible acerca de la clase o método seleccionado.
GRÁFICO NO. 6
VISTA JAVADOC
Análisis: La vista JavaDoc proporciona información relativa a la clase o método seleccionado en el
editor de código.
25
53
2.2.4.7.4.2 Perspectiva DDMS
Las perspectivas de uso más frecuente se muestranen la esquina superior derecha de
la ventana de Eclipse. Para cambiar de perspectiva se lo puede realizar dando clic a
la opción deseada, en caso de que no se presente se debe seleccionar el icono con un
signo +
con el propósito de que se despliegue una ventana con el listado de
perspectivas posibles.
GRÁFICO NO. 7
PERSPECTIVA DDMS
Análisis: La perspectiva DDMS es un contenedor de vistas que proporciona Eclipse para facilitar la
depuración de las aplicaciones.
54
La perspectiva DDMS (Dalvik Debug Monitor Service) es una herramienta
robustapara la depuración de las aplicaciones que le permite al desarrollador conocer
los procesos activos, ver la pila, observar y pausar los hilos activos y explorar el
sistema de archivo de cada uno de los dispositivos conectados. Tiene cuatro paneles
por defecto, iniciando desde la parte superior izquierda y desplazando la mirada de
izquierda a derecha hacia abajo tenemos:
Devices (Dispositivos).- Muestra el listado de los dispositivos conectados a
eclipse. El emulador por defecto está identificado con su número de puerto, el
5554.
Threads/Heap/Allocation
Tracker/File
Explorer
(Hilos/Montículo/Seguidor de Asignación/Explorador de Archivos).-como
se puede apreciar en el Gráfico No. 7en esta vista existen 4 pestañas:
Hilos.- lista de hilos que se ejecutan en el proceso de la máquina
virtual de destino
Montículo.- muestra estadísticas del montículoactualizado durante la
recolección de basura
Seguidor de Asignación.- en esta vista se puede realizar un
seguimiento de la asignación de memoria de cada máquina virtual
Explorador de Archivos.- permite manipular los directorios incluidos
en el emulador
55
Emulator Control (Controlador del emulador).- Controles que permiten
simular estados del equipo y también de las actividades. Proporciona:
Estado de la telefonía.- permite cambiar el estado de voz del teléfono y
de planes de datos (casa, móvil, búsqueda, etc.) además de simular
diferentes tipos de velocidad y latencia de red (GPRS, EDGE, UMTS,
etc.).
Acciones de telefonía.- permite simular la realización y recepción de
llamadas, así como el envío y recepción de mensajes.
Ubicación.- permite el envióde datos para la simulación de ubicación
hacia el emulador, de modo que sea posible realizar operaciones de
localización como GPS.
Logcat.- Vista que presenta los registros de los sucesos que han ocurrido
durante la ejecución de la aplicación, e incluso desde antes. Permite realizar
filtros de la información. Las opciones disponibles son:
V (Verbose).- Detallado, el archivo muestra todo.
D (Debug).- Depuración, muestra los mensajes de depuración,
información, advertencia y de error.
I (Information).- Información, muestra los mensajes la información,
advertencia y mensajes de error.
W (Warning).- Advertencia, muestra los mensajes de advertencia y de
error.
E (Error).- Sólo muestra los mensajes de error.
56
2.2.4.7.4.3La primera aplicación con Android: “Hola Mundo”
La primera acción a realizar consiste en crear un nuevo proyecto, para esto se debe
dar clic en “File”, luego clic en “New Proyect”, dentro de la carpeta “Android”
seleccionar “Android Proyect”, lo que hará que se levante la ventana de
configuración.
GRÁFICO NO. 8
VENTANA PARA LA CREACIÓN DE UN NUEVO PROYECTO
Análisis:Ventana de configuiración de parámetros globales del proyecto
57
Aquí se deberá definir el nombre del proyecto, el SDK que se va a utilizar para
construir la aplicación, el nombre de la aplicación, a que paquete pertenece, el
nombre de la actividad y la mínima versión del SDK que podría ejecutar la
aplicación.
Es importante mencionar que la mínima versión del SDK representa el nivel del API,
que es un número entero que identifica de manera única la versión del
framework26incluida en la plataforma. A continuación se presenta un cuadro con estas
relaciones:
CUADRO NO. 4
RELACIÓN DE LAS VERSIONES DE ANDROID Y EL NIVEL DEL API
Versión de laPlataforma
Nivel del API
Android 2.2
8
Android 2.1
7
Android 2.0.1
6
Android 2.0
5
Android 1.6
4
Android 1.5
3
Android 1.1
2
Android 1.0
1
Fuente: http://developer.android.com/guide/appendix/api-levels.html
26
58
Para ejecutar la aplicación se debe crear una configuración de lanzamiento, los pasos
necesarios se listan a continuación:
1. Seleccionar “Run Configurations” o “ Debug Configurations” del menu
“Run”
2. Dar clic derecho sobre
“Android Application” en la lista de tipos de
proyectos ubicada en el lado izquierdo de la ventana y seleccionar “New”
3. Escribir un nombre para la configuración
4. Seleccionar las opciones iniciales, en la pestaña “Android” escoger el
proyecto y la actividad a ejecutarse, en la pestaña “Target” seleccionar el
equipo virtual(AVD) sobre el cual se ejecuta el emulador y la aplicación, en
esta
pestaña también se pueden configurar ciertos parámetros como la
latencia de la red y comandos que se le pueden transferir al emulador
El AVD (Android Virtual Device) es una configuración del emulador que
permite un mejor modelo de un celular real. Entre los beneficios que
proporciona tenemos:
Un perfil de hardware.- establecer opciones para definir las
características de hardware del dispositivo virtual. Por ejemplo, puede
definir si el dispositivo tiene una cámara, si utiliza un teclado
QWERTY27físico, la cantidad de memoria, y así sucesivamente.
27
59
Una asignación a una imagen del sistema.- definir qué versión de la
plataforma Android se ejecutará en el dispositivo virtual.
También se pueden especificar otras opciones del emulador, lo que le
permite controlar las dimensiones de pantalla, apariencia, emulación
de tarjetas SD, etc.
Finalmente al seleccionar el botón “Run” se mostrará la aplicación cargada en el
AVD.
GRÁFICO NO. 9
APLICACIÓN HOLAMUNDO
Análisis: Interfaz gráfica resultado de ejecutar la aplicación HolaMundo
60
2.2.4.8Aplicaciones en Android
2.2.4.8.1Consideraciones al desarrollar aplicaciones para dispositivos móviles
Existen una serie de factores que se deben considerar a la hora de escribir programas
para dispositivos móviles, la mayoría de ellas son consideraciones
de hardware
impuestas por el diseño.
En comparación con las computadoras de escritorio, laptops o netbooks, los
dispositivos móviles tienen de manera relativa:
 Bajo poder de procesamiento
 Memoria RAM limitada
 Capacidad de almacenamiento persistente limitada
 Vida limitada de la batería
 Pantallas con resoluciones pequeñas
 Costos de transferencia de datos elevada
 Transferencia de datos más lenta con mayor latencia
 Menor número de conexiones de datos fiables
61
2.2.4.8.2 Componentes principales de una aplicación en Android
Como
se
indica
en
el
sitio
oficial
de
Android,
http://developer.android.com/guide/topics/fundamentals.html, y se reafirma en el
libro Beginning Android 2 de Mark L. Murphy,los componentes principales que
conforman una aplicación en Android son:
Activities (Actividades).-haciendo una analogía con las aplicaciones de
escritorio una actividad es como una ventana, en Android pueden existir
aplicaciones sin interfaces de usuario, pero cuando la tengan siempre existirá
una actividad.
Descritas de manera más técnica, son piezas de código ejecutables que pueden
ir y venir en el tiempo, instanciadas por el usuario o el sistema operativo y que
se mantendrán ejecutando mientras sean necesitadas.
Content Providers (Proveedores de Contenido).-componentes que permiten
intercambiar datos entre aplicaciones.
Services (Servicios).-a diferencia de las actividades y de los proveedores de
contenido que pueden ser detenidos en cualquier momento, los servicios son
componentes diseñados para ejecutarse independientemente de una actividad,
62
por esta razón no poseen una interfaz de usuario. Ejemplos de acciones para
los cuales son utilizados: Actualizaciones de contenido RSS, ejecución de
música en segundo plano.
Intents (Intentos).-los intentos son mensajes que permiten notificar a las
aplicaciones de que algún evento ha ocurrido. Estos eventos pueden ser
cambios en los estados del hardware (Una memoria SD ha sido insertada), de
arribo de información (Llegada de un SMS), eventos de aplicación, entre
otros.
2.2.4.8.3Tipos de Aplicaciones en Android
Primer Plano.- aplicación que es útil cuando esta ejecutándose en primer
plano, y que se suspende cuando no está visible.
Segundo Plano.- aplicación que permite una interacción limitada con el
usuario, pasa la mayor parte del tiempo oculta.
Intermitente.- es la combinación de las anteriores, pasa la mayor parte del
tiempo ejecutándose de manera invisible al usuario, con el que interactúa para
notificarle algún suceso.
63
2.2.4.8.4 Archivo de Configuración AndroidManifest.xml
EL AndroidManifest.xml es un archivo ubicado en la el nodo raíz de la jerarquía del
proyecto, en el cual se almacenan configuraciones globales. Contiene información
necesaria que el sistema debe conocer antes y durante la ejecución de una aplicación.
2.2.4.8.4.1 Estructura
A continuación se presentan todos los nodos que se pueden declarar cuando se crea
una aplicación:
<?xml version="1.0" encoding="utf-8"?>
<manifest>
<uses-permission />
<permission />
<permission-tree />
<permission-group />
<instrumentation />
<uses-sdk />
<uses-configuration />
<uses-feature />
<supports-screens />
<application>
<activity>
<intent-filter>
<action />
<category />
<data />
</intent-filter>
<meta-data />
</activity>
64
<activity-alias>
<intent-filter> . . . </intent-filter>
<meta-data />
</activity-alias>
<service>
<meta-data/>
</service>
<receiver>
<meta-data />
</receiver>
<provider>
<grant-uri-permission />
<meta-data />
</provider>
<uses-library />
</application>
</manifest>
2.2.4.8.4.2 Descripción de los elementos
<uses-permission>.- permite declarar los permisos que uno considera necesarios para
que funcione la aplicación. Forman parte del modelo de seguridad de Android. El
siguiente ejemplo muestra la sentencia que se debe declarar para permitir a la
aplicación el accesoa Internet.
<uses-permission android:name=”android.permission.INTERNET”>
65
<permission>.- en aplicaciones realizadas por terceros especifica si se restringe o
permite el acceso a componentes de la aplicación.
<permission-tree>.- declara el nombre base de un árbol de permisos. La aplicación
toma la propiedad de todos los nombres en el árbol. Se pueden añadir dinámicamente
nuevos permisos para el árbol llamando el método PackageManager.addPermission.
<permission-group>.- declara un nombre para una agrupación lógica de permisos
relacionados.
<instrumentation>.- proporciona un marco de trabajo para realizar pruebas de los
componentes de la aplicación en tiempo de ejecución.
<instrumentation android:label="Mi Test"
android:name=".TestClass"
android:targetPackage="com.android.Package">
</instrumentation>
<uses-sdk>.- este nodo permite definir la versión mínima, máxima y con la cual se
desarrolló la aplicación. El objetivo es permitirle al sistema conocer que versión del
SDK debe de existir en el equipo para que se pueda ejecutar la aplicación sin ningún
inconveniente. Los números asociados a cada atributo corresponden al nivel del API
(Tópico discutido anteriormente).
<uses-sdk
android:minSdkVersion="4"
android:targetSdkVersion="5">
android:maxSDKVersion=”5”
</uses-sdk>
66
<uses_configuration>.-se utiliza para especificar las combinaciones de mecanismos
de entrada soportados por la aplicación. Estos pueden ser:
reqFiveWayNav.-
permiteespecificar si se necesita un dispositivo
de entrada que puede moverse arriba, abajo, izquierda, derecha y
hacer clic en la selección actual.
reqHardKeyboard.- permite especificar si la aplicación requiere un
teclado físico (hardware).
reqNavigation.- permite especificar el tipo de navegación, los valores
posibles son:nonav(sin navegación), Dpad, trackball, wheel (rueda), o
undefined (no definido).
reqKeyboardType.- permite indicar el tipo de teclado presente en el
dispositivo, los valores posibles son: nokeys, qwerty, twelvekey, o
undefined (indefinido).
reqTouchScreen.- permite especificar cómo el usuario interactuará
con la pantalla táctil, los valores posibles son: notouch(sin pantalla
táctil), stylus, finger, o undefined.
<uses-feature>.- permite especificar una característica utilizada por la aplicación.
<supports-screens>.- en este elemento se pueden especificar las dimensiones de la
pantalla que soporta la aplicación. De manera predeterminada una aplicación
67
moderna (utilizando la API de nivel 4 o superior) es compatible con todos los
tamaños de pantalla, a diferencia de aplicaciones más antiguas que sólo admiten el
tamaño "normal" de pantalla.
<application>.- este elemento contiene subelementos que permiten declarar cada uno
de los componentes de la aplicación y tiene atributos que puede afectar a todos los
componentes. Entre los principales atributos y los más usados tenemos:
android:icon.-permite especificar el ícono para la aplicación como un todo.
android:label.- permite definir una etiqueta para la aplicación como un todo
que puede ser visualizada por el usuario, también constituye la etiqueta por
defecto para cada uno de los componentes de la aplicación en caso de que en
ellos no se defina una etiqueta.
<activity>.- permite declarar una actividad, la cual implementa parte de la interfaz de
usuario. Todas las actividades a ser utilizadas en la aplicación deberán ser declaradas
en este archivo para que sean visibles por el sistema. Al igual que en el nodo
“application” los atributos más usados son icon y label, con la diferencia que para
este caso son locales a la actividad.
68
<service>.- permite declarar un servicio como uno de los componentes de la
aplicación. A diferencia de las actividades, los servicios no poseen una interfaz de
usuario visual.
<receiver>.- permite declarar un receiver (receptor) como uno de los componentes
de la aplicación. Los BroadcastReceiver les permiten a las aplicaciones responder a
llamadas que se emiten por el sistema o por otras aplicaciones.
<provider>.- permite declarar un proveedor de contenido (ContentProvider) que
como su nombre indica proporciona acceso estructurado a datos manejados por la
aplicación. Contiene dos subelementos: meta-data y grant-uri-permission, este último
permite especificar a qué conjunto de información se le permite el acceso a los
proveedores de contenido.
<uses-library>.- permite especificar una librería compartida que requiere ser
vinculada a la aplicación. Este elemento le indica al sistema que incluya el código de
la librería para el paquete.
<intent-filter>.- especifica los tipos de intentos (intents) a los cuales una actividad,
servicio o receptor de difusión puede responder. Este elemento puede especificar
obtener a su vez los siguientes subelementos:
<action>
69
<category>
<data>
<meta-data>.- en este elemento se puede definir un par nombre-valor que pueden ser
suministrados al componente principal.
A continuación se presenta el archivo AndroidManifest.xml que se generó al crear la
aplicación HolaMundo:
<?xmlversion="1.0"encoding="utf-8"?>
<manifestxmlns:android="http://schemas.android.com/apk/res/android"
package="android.com.HolaMundo"
android:versionCode="1"
android:versionName="1.0">
<applicationandroid:icon="@drawable/icon"android:label="@string/app_name">
<activityandroid:name=".HolaMundo"
android:label="@string/app_name">
<intent-filter>
<actionandroid:name="android.intent.action.MAIN"/>
<categoryandroid:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
</application>
</manifest>
70
2.2.4.8.5Actividad
2.2.4.8.5.1 Ciclo de Vida
En Android las actividades son administradas bajo el esquema de pila, es decir, que
cuando una nueva actividad es instanciada pasa a la cima de la pila y se convierte en
la actividad en ejecución, mientras que la actividad que estaba ejecutándose
previamente se ubica atrás en la pila y permanece allí hasta que la nueva actividad
finalice.Una actividad tiene generalmente cuatro estados:
Activa.-cuando la actividad es visible y está interactuando con el usuario, el
sistema se encargará de mantenerla en ejecución llegando inclusive a asesinar
actividades ubicadas posteriormente en la pila si es necesario. Cuando una
nueva actividad es instanciada, esta cambia de estado a pausada.
Pausada.-en ciertas ocasiones cuando una actividad es visible pero no tiene el
foco está en estado de pausada. En este estado la actividad es tratada por el
sistema como si fuese activa pero no recibe ingresos del usuario. Cuando una
actividad ya no está visible cambia al estado de detenida.
Detenida.-en este estado la actividad aún continúa en memoria manteniendo
toda su información pero se convierte en una candidata a ser eliminada cuando
el sistema requiera recursos. Una vez que la actividad se cierra pasa al estado
de inactiva.
71
Inactiva.-después que una actividad ha sido asesinada y antes de ser ejecutada
se encuentra en este estado.
El ciclo de vida de una actividad en Android puede ser descrito a través de los
métodos que se pueden ejecutar durante los diferentes estados:
void onCreate(Bundle savedInstanceState)
void onStart()
void onRestart()
void onResume()
void onPause()
void onStop()
void onDestroy()
Como se puede visualizar en la lista previa, el ciclo entero de la actividad va desde
que se hace la llamada al método onCreate() hasta cuando se ejecuta el método
onDestroy(). Sin embargo este ciclo se puede dividir en dos partes, el tiempo de vida
visible y el tiempo de vida en primer plano.
72
GRÁFICO NO.10
CICLO DE VIDA DE UNA ACTIVIDAD
Activity
onCreate
Activity
onRestore
Activity
onResume
Activity
onStart
Activity
onSave
InstanceState
Activity
onPause
Activity
onStop
Activity
onDestroy
Activity
onReset
Ciclo de Vida Activo
Ciclo de Vida Visible
Ciclo de Vida Completo
Fuente:http://www.slideshare.net/peterbuck/microsoft-powerpoint-androidchapter03lifecycle
Análisis:El ciclo de vida completo de una actividad se inicia con el método onCreate, endonde se
realizan las configuraciones globales y finaliza con el método onDestroy, en el que se liberan los
recursos. Durante el ciclo de vida visible el usuario puede ver la actividad en pantalla.
2.2.4.8.5.2 Creación de una Actividad
Para crear una Actividad en Android se recomienda realizar tres pasos: crear la clase
en java que contendrá la interfaz de usuario derivando de la clase Activity, crear la
GUI en un archivo con extensión xml (También se lo puede hacer de manera
programática)
y
finalmente
especificar
en
el
archivo
de
configuración
AndroidManifest.xml la nueva actividad a ser utilizada. A continuación se presenta el
código java de la aplicación HolaMundo:
package android.com.HolaMundo;
import android.app.Activity;  Importando la clase Activity
import android.os.Bundle;
public class HolaMundo extends Activity Derivando de la clase Activity
{
73
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main); Definiendo la interfaz de usuario
}
}
2.2.4.8.5.3 Iniciar una actividad
Para iniciar una actividad en Android se utiliza el método startActivity(Intent).
Adelantándonos un poco, un Intent (intento) es un mecanismo que se utiliza para
intercambiar mensajes dentro de la aplicación o entre aplicaciones.
Intent a = new Intent();  Creamos un objeto de la clase Intnet
a.setClassName("android.com.AbsoluteLayout","android.com.AbsoluteLayou
t.AbsoluteLayout");  Definimos la actividad y el paquete en que se
encuentra
startActivity(a);  Iniciamos la actividad
En ocasiones se requiere un resultado cuando la actividad finaliza, para obtenerlo se
debe implementar el método startActivityForResult(Intent,int), en el que se aumenta
un nuevo parámetro, int para el ejemplo, que identifica la llamada.
startActivityForResult(
new
Intent(Intent.ACTION_PICK,
new
Uri("content://contacts")),OBTENER_CONTACTO);
El resultado se lo puede manipular a través del método onActivityResult(int, int,
Intent).
74
2.2.4.8.5.4 Ejemplo de actividad incluido en el proyecto
El ejemplo consiste en una aplicación que presenta al usuario una pantalla en la que
se deben ingresar coordenadas, cuando se presiona el botón aceptar se invoca una
nueva actividad que gestiona el pedido de la original y muestra en el mapa el lugar
que corresponde a las coordenadas.
Archivo XML: actividad_layout.xml
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TableLayout
android:layout_height="wrap_content"
android:stretchColumns="1,2"
>
<TableRow>
<TextView
android:layout_width="wrap_content"
android:paddingLeft="2dip"
android:paddingRight="4dip"
android:text="Localización:"
/>
<EditTextandroid:id="@+id/latitud"
android:cursorVisible="true"
android:editable="true"
android:singleLine="true"
android:layout_weight="1"
/>
<EditTextandroid:id="@+id/longitud"
android:cursorVisible="true"
android:editable="true"
android:layout_weight="1"
75
/>
</TableRow>
</TableLayout>
<Buttonandroid:id="@+id/btn_mapa"
android:text="Aceptar"
/>
</LinearLayout>
Clase Java: EjemploActividad.java
package android.com.proyecto.componentes;
import android.com.proyecto.R;
import android.app.Activity;
import android.content.Intent;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.net.Uri;
publicclass EjemploActividad extends Activity {
//Declaración de Variables
private EditText et_latitud;
private EditText et_longitud;
private Button btn_mapa;
privatedoubleld_latitud;
privatedoubleld_longitud;
@Override
publicvoid onCreate(Bundle savedInstanceState)
{
setContentView(R.layout.actividad_layout);
//Atachando los widgets definidos en en el archivo XML para utilizarlos en el
programa
et_latitud=(EditText)findViewById(R.id.latitud);
et_longitud=(EditText)findViewById(R.id.longitud);
btn_mapa=(Button)findViewById(R.id.btn_mapa);
//Estableciendo un Listener para el botón con el propósito de responder cuando el
usuariogenere el evento de dar un clic en el mismo
btn_mapa.setOnClickListener(new View.OnClickListener() {
@Override
publicvoid onClick(View v) {
ld_latitud=Double.parseDouble(et_latitud.getText().toString());
ld_longitud=Double.parseDouble(et_longitud.getText().toString());
Uri uri=Uri.parse("geo:" + ld_latitud+","+ld_longitud+"?z=5");
76
startActivity(new Intent(Intent.ACTION_VIEW,uri)); //Iniciando
una actividad}
GRÁFICO NO. 11
EJEMPLO DE ACTIVIDAD
Análisis: La aplicación recibe coordenadas de ubicación y al dar clic en aceptar se presenta en el
mapa
2.2.4.8.5.5Clases de Actividad
Primero hay que aclarar la ambigüedad que puede originar el título de esta sección, al
hablar de las clases de actividad se hace referencia a las clases incluidas en el SDK de
Android para definir actividades y que envuelven el uso de widgetspara el diseño de
GUIs. Entre las clases más usuales se incluye:
77
MapActivity.- encapsula el manejo de los recursos necesarios para la gestión
de la vista de mapas.28
ListView.- clase envoltoria para actividades que permiten enlazar vistas tipo
lista con un conjunto de datos, así como el manejo de los eventos originados
por la selección de alguno de los elementos de la lista.
ExpandableListActivity.- similar a ListView pero da soporte a listas
expandibles.
ActivityGroup.- permite integrar múltiples actividades en una sola pantalla.
2.2.4.8.6Interfaces de Usuario (GUI’s)
Como ya se ha indicado anteriormente una Actividad contiene vistas, que son objetos
que representan elementos en la pantalla y que permiten la interacción con el usuario.
Cada pantalla en Android contiene un árbol jerárquico de objetos derivados de la
clase View, que tienen diferentes formas y cualidades y que se muestran en el Gráfico
No. 12 para una mayor comprensión del lector.
28
78
GRÁFICO NO. 12
DIAGRAMA DE CLASES DEL API VIEW DE ANDROID
Fuente:Libro Unlocking Android A Developer’s Guide, de Ableson Frank, Collins Charlie, Sen Robi
(2009), pag. 71
Análisis:Diagrama que muestra de manera jerárquica la mayoría de las clases derivadas de View
79
Una de las características de Android es que permite definir estos elementos de
manera programática mediante el lenguaje Java o hacerlo a través de archivos XML
en los que se establecen los widgets y sus relaciones.
Android considera los layouts basados en XML como recursos, y son almacenados en
el directorio res del proyecto. Cada archivo XML contiene un árbol de elementos en
los que se especifican sus atributos y su diseño. Estos elementos o nodos poseen el
mismo nombre que la clase en java que permite su creación, así el elemento
<TextView> está definiendo un objeto de la clase del mismo nombre.
La herramienta appt incluida en el SDK se encarga de generar el archivo R.java que
permite invocar y utilizar estos elementos en la codificación de la aplicación.
Cabe en este instante la pregunta ¿Por qué usar un archivo XML para definir los
elementos de mi GUI si se lo puede hacer mediante código? La respuesta es que
ayuda en la creación de herramientas para la definición de vistas, es más sencillo la
lectura de las especificaciones de los elementos en un archivo estructurado en formato
XML para su edición que tratar de hacerlo en el lenguaje de programación.
Incluso, es cada vez más común encontrar herramientas que definen los elementos de
sus GUIs en formato XML, tal como lo hacen XAML de Microsoft, Flex de Adobe y
XUL de Mozilla.
80
2.2.4.8.6.1 Ejemplo de vistas incluido en el proyecto
Con el propósito de demostrar que la creación de la interfaz de usuario de cualquier
aplicación en Android se puede hacer netamente con código Java o utilizando un
archivo XML se ha desarrollado un programa que muestra la hora del sistema para
cada uno de los esquemas.
Archivo XML: widget_xml_layout.xml
android:background="@color/gray"
>
<TextView
android:id="@+id/myTextView"  Identificador del elemento
android:text="@string/texto_inicial"
android:textColor="@color/black"
android:gravity="center_horizontal"
/>
<Button
android:id="@+id/myButton"
android:layout_gravity="center_horizontal"
/>
</LinearLayout>
Clase Java: Widget_Java
package android.com.proyecto;
import java.util.Date;
81
import android.graphics.Color;
import android.view.Gravity;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.LinearLayout.LayoutParams;
import android.widget.TextView;
publicclass Widget_Java extends Activity {
//Declaración de Variables
private LinearLayout myLayout;
private TextView myTextView;
private Button myButton;
@Override
publicvoid onCreate(Bundle savedInstanceState) {
//Creación del objeto Layout (contenedor) y definición de sus propiedades
myLayout=new LinearLayout(this);
myLayout.setOrientation(LinearLayout.VERTICAL);
myLayout.setBackgroundColor(Color.LTGRAY);
myLayout.setLayoutParams(new
LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,ViewGroup.LayoutParams.FILL_PARENT)
);
myLayout.setHorizontalGravity(Gravity.CENTER);
//Creación del objeto TextView y definición de sus propiedades
myTextView=new TextView(this);
myTextView.setLayoutParams(new
LayoutParams(ViewGroup.LayoutParams.FILL_PARENT,ViewGroup.LayoutParams.WRAP_CONTE
NT));
myTextView.setText("De click para mostrar la hora");
myTextView.setTextColor(Color.BLACK);
myTextView.setGravity(Gravity.CENTER_HORIZONTAL);
myLayout.addView(myTextView);
//Creación del objeto Button y definición de sus propiedades
myButton=new Button(this);
myButton.setText("Aceptar");
myButton.setLayoutParams(new
LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,ViewGroup.LayoutParams.WRAP_CON
TENT));
myLayout.addView(myButton);
myButton.setOnClickListener(new View.OnClickListener()
{
@Override
myTextView.setText(new Date().toString());
}
});
setContentView(myLayout);
82
}}
Clase Java: Widget_XML
import java.util.Date;
publicclass Widget_XML extends Activity{
@Override
{
setContentView(R.layout.widget_xml_layout);
myTextView=(TextView)findViewById(R.id.myTextView);
myButton=(Button)findViewById(R.id.myButton);
{
@Override
myTextView.setText(new Date().toString());
}
});}}
Salida por pantalla
GRÁFICO NO. 13
GUI GENERADA A TRAVÉS DE CÓDIGO JAVA
Análisis: Aplicación que muestra la hora del sistema y cuya interfaz gráfica se creó de manera
programática en Java.
83
GRÁFICO NO. 14
GUI GENERADA A TRAVÉS DE UN ARCHIVO XML
Análisis: Aplicación que muestra la hora del sistema y cuya interfaz gráfica se generó a través de un
archivo xml.
2.2.4.8.7Ordenando el contenido de los Layouts
2.2.4.8.7.1AbsoluteLayout
AbsoluteLayout se basa en la sencilla idea de colocar cada uno de los controles en
una posición absoluta, en la que se especifican las coordenadas X y Y en la pantalla
para cada control. Esto no es recomendable para el desarrollo de la interfaz de usuario
(AbsoluteLayout de hecho, es actualmente obsoleto), ya que definir de esta manera la
posición hace que sea poco flexible. Por ejemplo, si se desea agregar un nuevo
elemento se debe de modificar la posición de los que ya existen.
84
2.2.4.8.7.1.1 Ejemplo del contenedor AbsoluteLayout
Archivo XML: absolute_layout.xml
<AbsoluteLayoutandroid:id="@+id/AbsoluteLayout01"android:layout_width="wrap_content"android:
layout_height="wrap_content"xmlns:android="http://schemas.android.com/apk/res/android">
<TextView
android:id="@+id/txtUsuario"
android:layout_x="60px"
android:layout_y="40px"
android:text="Usuario"
/>
<EditText
android:id="@+id/edtUsuario"
android:width="100px"
/>
<TextView
android:id="@+id/txtContrasenia"
android:text="Contraseña"
/>
<EditText
/>
<Button
/>
</AbsoluteLayout>
85
Salida por pantalla
GRÁFICO NO. 15
ESQUEMA ABSOLUTELAYOUT
Análisis: El contenedor AbsoluteLayout coloca los elementos en pantalla en las coordenadas que se
especifican.
2.2.4.8.7.2FrameLayout
FrameLayout está diseñada para mostrar un solo elemento a la vez. Usted puede tener
varios elementos dentro de un FrameLayout pero cada elemento se coloca en la parte
superior izquierda de la pantalla, superponiéndose al definido anteriormente. A
continuación se muestra un layout en el que se define una imagen y una etiqueta:
2.2.4.8.7.2.1Ejemplo del contenedor FrameLayout
Archivo XML: frame_layout.xml
<FrameLayoutxmlns:android="http://schemas.android.com/apk/res/android"
86
>
<ImageView
android:src="@drawable/logo"
android:scaleType="fitCenter"
android:id="@+id/myView"
/>
<TextView
android:id="@+id/edtText"
android:textSize="24px"
android:textColor="#000000"
android:text="Android Rules"
android:gravity="center"
/>
</FrameLayout>
Salida por pantalla:
GRÁFICO NO. 16
ESQUEMA FRAMELAYOUT
Análisis: El contenedor FrameLayout coloca los elementos en pantalla pero superponiendo uno
encima de otro desde la esquina superior izquierda.
87
2.2.4.8.7.3LinearLayout
Como su nombre lo indica un LinearLayout organiza los elementos que contiene a lo
largo de una sola línea. Se puede indicar la dirección de esta línea mediante el
atributo “orientation” del nodo raíz.
2.2.4.8.7.3.1 Ejemplo del contenedor LinearLayout
Archivo XML: linear_layout.xml
android:orientation="vertical"  Propiedad que indica la orientación
android:layout_height="fill_parent">
<TextView
/>
<EditText
android:width="100px"/>
<TextView
android:text="Contraseña"/>
<EditText
android:id="@+id/edtContrasenia"
android:width="100px"/>
<Button
android:id="@+id/btnAceptar"
88
android:text="Aceptar"/>
</LinearLayout>
Salida por pantalla
GRÁFICO NO. 17
ESQUEMA LINEARLAYOUT
Análisis: El contenedor LinearLayout coloca los elementos uno tras de otro de manera vertical u
horizontal, en el ejemplo se puede apreciar que la orientación que se utilizó es la primera.
2.1.4.8.7.4Relative Layout
RelativeLayout muestra sus elementos basados en la relación que existe entre ellos y
el contenedor. Este posiblemente es el diseño más complicado y se requieren varias
propiedades para obtener el resultado deseado.
En relación con el contenedor:

android:layout_alignParentBottom.- coloca la parte inferior del elemento en la
parte inferior del contenedor.
89

android:layout_alignParentLeft.- coloca la parte izquierda del elemento en la
parte izquierda del contenedor.

android:layout_alignParentRight.- coloca la parte derecha del elemento en la
parte derecha del contenedor.

android:layout_alignParentTop.- coloca el elemento en la parte superior del
contenedor.

android:layout_centerHorizontal.- centra el elemento de manera horizontal
dentro del elemento que lo contiene.

android:layout_centerInParent – centra el elemento de manera horizontal y
vertical dentro del elemento que lo contiene.

android:layout_centerVertical – centra el elemento verticalmente dentro del
elemento que lo contiene.
En relación con otros elementos:
Estas propiedades permiten establecer la ubicación del elemento de manera relativa
en la pantalla basándose en la posición de los otros elementos. En este esquema cada
elemento debe contener un identificador para poder hacer referencia de él.

android:layout_above.- coloca el elemento por encima del elemento
especificado.


android:layout_below.- coloca el elemento debajo del elemento especificado
android:layout_toLeftOf.- coloca el elemento a la izquierda del elemento
especificado.
90

android:layout_toRightOf.- coloca el elemento hacia la derecha del elemento
especificado.
Alineación con respecto otros elementos:
Estas propiedades le permiten especificar cómo los elementos están alineados en
relación con otros elementos.

android: layout_alignBaseline.- alinea la línea de base del elemento nuevo con
la línea base del elemento especificado.

android: layout_alignBottom.- alinea la parte inferior del nuevo elemento con
la parte inferior del elemento especificado.

android: layout_alignLeft.- alinea el borde izquierdo del nuevo elemento con
el borde izquierdo del elemento especificado.

android: layout_alignRight.- alinea el borde derecho del nuevo elemento con
el borde derecho del elemento especificado.

android: layout_alignTop.- alinea la parte superior del nuevo elemento con el
elemento especificado.
91
2.2.4.8.7.4.1 Ejemplo del contenedor RelativeLayout
Archivo XML: relative_layout.xml
<RelativeLayoutxmlns:android="http://schemas.android.com/apk/res/android"
<TextView
android:text="Usuario
"
android:layout_height="wrap_content"/>
<EditText
android:id="@+id/editUsuario"
android:layout_toRightOf="@id/txtUsuario"/>
<EditText
android:id="@+id/editContrasenia"
android:layout_below="@id/editUsuario"
android:layout_alignLeft="@id/editUsuario"/>
<TextView
android:layout_toLeftOf="@id/editContrasenia"
android:layout_alignLeft="@id/txtUsuario"
android:layout_alignTop="@id/editContrasenia"/>
<Button
android:id="@+id/backbutton"
android:text="Back"
android:layout_below="@id/editContrasenia"/>
</RelativeLayout>
92
GRÁFICO NO. 18
ESQUEMA RELATIVELAYOUT
Análisis: El contenedor RelativeLayout presenta la ubicación de un elemento en pantalla en función de
los otros elementos.
2.2.4.8.7.5 TableLayout
TableLayout organiza el contenido en filas y columnas. Las filas son definidas en el
esquema XML, y las columnas de forma automática por Android. Esto se hace
mediante la creación de al menos una columna para cada elemento. Así, por ejemplo,
si usted define una fila con dos elementos y una fila con cuatro elementos, entonces
tendría un diseño con dos filas y cuatro columnas.
Se puede especificar que un elemento debe ocupar más de una columna utilizando
android: layout_span. Esto puede aumentar el recuento total de la columna, así que si
tenemos una fila con dos elementos y cada elemento tiene android: layout_span = "3",
entonces usted tendrá por lo menos seis columnas de la tabla.
93
2.2.4.8.7.5.1 Ejemplo del contenedor TableLayout
Archivo XML: table_layout.xml
<TableLayoutxmlns:android="http://schemas.android.com/apk/res/android"
>
<TableRow>
<TextView
android:layout_column="1"
/>
<EditText
/>
</TableRow>
<TableRow>
<TextView
android:layout_column="1"
/>
<EditText
/>
</TableRow>
<TableRowandroid:gravity="center">
<Button
/>
</TableRow>
</TableLayout>
94
Salida por pantalla
GRÁFICO NO. 19
ESQUEMA TABLELAYOUT
Análisis: El contenedor TableLayout divide la superficie en filas y columnas, el desarrollador puede
ubicar los elementos en las celdas que se forman de la intersección
2.2.4.8.7.6Gallery (Layout tipo galería)
Contenedor utilizado para mostrar una lista de objetos desplazables de manera
horizontal.
2.2.4.8.7.6.1 Ejemplo del contenedor Gallery
Clase Java: GalleryAdapter
package android.com.proyecto.layouts;
import android.content.Context;
import android.content.res.TypedArray;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
95
import android.widget.Gallery;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;
publicclass GalleryAdapter extends BaseAdapter{
private Context myContext;
intmGalleryItemBackground;
private Integer[] myImages={R.drawable.hulk,
R.drawable.ironman,
R.drawable.thor,
R.drawable.captain_america};
public GalleryAdapter(Context c)
{
myContext=c;
TypedArray a =c.obtainStyledAttributes(R.styleable.Gallery1);
mGalleryItemBackground = a.getResourceId(
R.styleable.Gallery1_android_galleryItemBackground, 0);
a.recycle();
}
@Override
publicint getCount() {
returnmyImages.length;
}
@Override
public Object getItem(int position) {
return position;
}
@Override
publiclong getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ImageView i=new ImageView(myContext);
i.setImageResource(this.myImages[position]);
i.setLayoutParams(new Gallery.LayoutParams(180, 180));
i.setScaleType(ScaleType.FIT_XY);
i.setBackgroundResource(mGalleryItemBackground);
return i;
}
}
96
Clase Java: GallerySample
package android.com.proyecto.layouts;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.Gallery;
import android.widget.Toast;
publicclass GallerySample extends Activity {
private Gallery myGallery;
@Override
setContentView(R.layout.gallery);
myGallery=(Gallery)findViewById(R.id.myGallery);
myGallery.setAdapter(new GalleryAdapter(this));
myGallery.setOnItemClickListener(new OnItemClickListener() {
publicvoid onItemClick(AdapterView parent, View v, int position, long id) {
Toast.makeText(GallerySample.this, "" + position, Toast.LENGTH_SHORT).show();
}
});}}
Salida por pantalla
GRÁFICO NO. 20
ESQUEMA GALLERY
Análisis: El contenedor Gallery se utiliza para mostrar elementos a manera de lista desplazable,
siempre centrando el elemento visible al ancho de la pantalla.
97
2.2.4.8.8Elementos GUI más utilizados
Los elementos que conforman la interfaz de usuario se denominan widgets, que no
son otra cosa que objetos derivados de la clase View y que sirven como interfaz para
la interacción con el usuario. Entre los widgets más comunes tenemos: TextView,
EditText, Button, RadioButton, Checkbox, AnalogClock y DigitClock.
2.2.4.8.8.1 Ejemplo de elementos GUI más utilizados
Para la demostración de cómo se visualizan los controles que se utilizan más a
menudo en la creación de interfaces gráficas se creó la aplicación Allwidgets,
adicionalmente para demostrar cómo se visualizan los componentes que proporcionan
la funcionalidad de relojes se creó la segunda aplicación.
Archivo XML: all_widgets.xml
>
<TextView
android:id="@+id/myTextView"
android:text="Esto es un label"
/>
<EditText
android:id="@+id/myEditText"
android:layout_height="60px"
android:text="Esto es una caja de texto"
98
/>
<Button
android:id="@+id/myButton"
android:text="Botón"
/>
<CheckBox
android:id="@+id/myCheck"
android:text="Checkbox no seleccionada!"/>
<RadioGroup
android:id="@+id/myGroup"
<RadioButtonandroid:id="@+id/radio1"
android:text="Opcion1"
android:checked="true"/>
android:text="Opcion2"/>
android:text="Opcion3"/>
</RadioGroup>
</LinearLayout>
Clase Java: AllWidgets
package android.com.proyecto.widgets;
import android.view.Gravity;
import android.widget.CheckBox;
import android.widget.CompoundButton;
import android.widget.RadioGroup;
99
import android.widget.CompoundButton.OnCheckedChangeListener;
publicclass AllWidgets extends Activity{
private EditText myEditText;
private CheckBox myCheck;
private RadioGroup myRadio;
@Override
{
setContentView(R.layout.all_widgets);
myTextView=(TextView)findViewById(R.id.myTextView);
myEditText=(EditText)findViewById(R.id.myEditText);
myButton=(Button)findViewById(R.id.myButton);
myCheck=(CheckBox)findViewById(R.id.myCheck);
myRadio=(RadioGroup)findViewById(R.id.myGroup);
{
@Override
myEditText.setText("");
}
});
myCheck.setOnCheckedChangeListener(new OnCheckedChangeListener()
{
@Override
publicvoid onCheckedChanged(CompoundButton buttonView,
boolean isChecked) {
if(isChecked)
myCheck.setText("Checkbox seleccionada!");
else
myCheck.setText("Checkbox no seleccionada");
}
});
myRadio.setOnCheckedChangeListener(new
RadioGroup.OnCheckedChangeListener() {
@Override
publicvoid onCheckedChanged(RadioGroup group, int checkedId) {
switch(checkedId)
{
case R.id.radio1:
Toast.makeText(getApplicationContext(),"Opcion1
seleccionada",Toast.LENGTH_SHORT).show();
break;
case R.id.radio2:
100
break;
case R.id.radio3:
break;}}});}}
Salida por pantalla
GRÁFICO NO. 21
ELEMENTOS MÁS USADOS EN LA CREACIÓN DE INTERFACES
Análisis:La pantalla muestra la apariencia que tienen los controles típicos que se utilizan en una
aplicación para permitir la interacción con el usuario
Archivo XML: clocks.xml
101
<TextView
android:text="Reloj Analógico"
android:gravity="center_horizontal"/>
<AnalogClockandroid:id="@+id/analog"
android:layout_centerHorizontal="true"/>
<TextView
android:text="Reloj Digital"
android:gravity="center_horizontal"/>
<DigitalClockandroid:id="@+id/digital"
android:layout_below="@id/analog"/>
</LinearLayout>
GRÁFICO NO. 22
WIDGETS PARA LA VISUALIZACIÓN DE RELOJES
Análisis: En Android los desarrolladores pueden utilizar vistas que proporcionan la funcionalidad de
un reloj, sea analógico o digital. La imagen muestra sus apariencias.
102
2.2.4.8.9Menús
Las aplicaciones en Android soportan 3 tipos de menús:
Menú de opciones.- Se activa pulsando la tecla Menu del dispositivo y funciona en
dos modos: ícono y ampliado. El modo ícono presenta en pantalla una cuadrícula de
botones de hasta seis opciones del menú, en caso de contener más opciones, el sexto
botón mostrará un signo más (+) que al ser pulsado abre el modo ampliado.
Menú contextual.- Se activa seleccionando de manera sostenida el elemento. Es
similar al menú de opciones con la diferencia de cómo se llenan las opciones y cómo
se informa la opción seleccionada.
Submenú.- Un submenú se utiliza para agrupar elementos de un menú, sea este un
menú de opciones o un menú contextual.
Adicionalmente se puede crear cualquiera de los menús a través de archivos XML e
invocarlos en la programación mediante la creación de un objeto de la clase
MenuInflater.
103
2.2.4.8.9.1 Ejemplos de Menús incluidos en el proyecto
2.2.4.8.9.1.1 Menú de Opciones
Clase de Java: Option_Menu.java
package android.com.proyecto.menues;
import android.view.Menu;
import android.view.MenuItem;
import com.google.android.maps.MapActivity;
import com.google.android.maps.MapController;
import com.google.android.maps.MapView;
publicclass Option_Menu extends MapActivity {
private MapView mapView;
private MapController mapController;
privatestaticfinalintMENU_AUMENTAR=0;
privatestaticfinalintMENU_DISMINUIR=1;
@Override
setContentView(R.layout.menues);
mapView=(MapView)findViewById(R.id.mapView);
mapController=mapView.getController();
registerForContextMenu(mapView);
}
//Método utilizado para indicar al servidor si se está mostrando algún tipo deinformación de
rutas en el mapa
protectedboolean isRouteDisplayed() {
returnfalse;
}
//Método que permite crear los elementos que se muestran en el menú
publicboolean onCreateOptionsMenu(Menu menu) {
menu.add(0, MENU_AUMENTAR, 0, "Aumentar").setIcon(R.drawable.zoom_in);
menu.add(0, MENU_DISMINUIR, 0, "Disminuir").setIcon(R.drawable.zoom_out);
returntrue;
}
//Método que permite definir las acciones cuando se selecciona un elemento
publicboolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
caseMENU_AUMENTAR:
mapController.zoomIn();
return(true);
104
caseMENU_DISMINUIR:
mapController.zoomOut();
return(true);
}
returnfalse;}}
Salida por pantalla
GRÁFICO NO. 23
MENÚ DE OPCIONES
Análisis: En este gráfico se aprecia como se presenta un menú de opciones en Android, se han
definido dos elementos en el menú, que representan las opciones aumentar y disminuir el zoom del
mapa
2.2.4.8.9.1.2 Menú Contextual
Clase de Java: Context_Menu.java
import java.util.ArrayList;
105
import android.view.ContextMenu;
import android.view.ContextMenu.ContextMenuInfo;
import android.view.View.OnCreateContextMenuListener;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.AdapterView.AdapterContextMenuInfo;
publicclass Context_Menu extends Activity{
private ArrayList<Persona>personas=new ArrayList<Persona>();
privatestaticfinalintMENU_ELIMINAR_PERSONA=0;
private ListView myListView;
@Override
setContentView(R.layout.context_menues);
personas.add(new Persona("Antonio Rodríguez","042025455"));
personas.add(new Persona("Carlos Gutierrez","042698565"));
personas.add(new Persona("Carla Sanchez","042896542"));
myListView=(ListView)findViewById(R.id.contex_menu_list);
inicializarListView();
}
//Método que se utiliza para llenar los elementos que se //presentan en la lista
privatevoid refrescarListItems()
{
myListView.setAdapter(new
ArrayAdapter<Persona>(this,R.layout.context_menu_item,personas));
}
privatevoid inicializarListView() {
refrescarListItems();
myListView.setOnCreateContextMenuListener(new OnCreateContextMenuListener()
{
//Método que permite crear los elementos del menú contextual
@Override
publicvoid onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {
menu.setHeaderTitle("ContextMenu");
menu.add(0, MENU_ELIMINAR_PERSONA,0, "Eliminar esta persona!");
}
});
}
//Método que permite definir las acciones cuando se seleccione un elemento del menú
publicboolean onContextItemSelected(MenuItem item) {
AdapterContextMenuInfo menuInfo = (AdapterContextMenuInfo) item.getMenuInfo();
106
caseMENU_ELIMINAR_PERSONA:
Persona _persona = (Persona) myListView.getAdapter().getItem(menuInfo.position);
personas.remove(_persona);
refrescarListItems();
returntrue;
}
returnfalse;}
//Clase que abstrae las características de la persona
privateclass Persona
{
private String nombre;
private String telefono;
public Persona(String nombre, String telefono)
{
this.nombre = nombre;
this.telefono = telefono;
}
public String toString() {
returnnombre + " " + telefono;}
publicboolean equals(Object o) {
return o instanceof Persona && ((Persona) o).nombre.compareTo(nombre) == 0;
}}}
Salida por pantalla
GRÁFICO. 24
MENÚ CONTEXTUAL
Análisis: En este gráfico se aprecia como se presenta un menú contextual en Android, la apariencia es
de una ventana tipo pop-up que contiene las acciones que el usuario puede seleccionar
107
2.2.4.8.9.1.3 SubMenú
Como se podrá apreciar el ejemplo es el mismo utilizado para el menú de opciones,
con la diferencia de que se creó un submenú para agrupar las opciones de zoom.
Clase de Java: Sub_Menu.java
import android.view.SubMenu;
publicclass Sub_Menu extends MapActivity {
privatestaticfinalintMENU_ZOOM=0;
privatestaticfinalintMENU_AUMENTAR=1;
privatestaticfinalintMENU_DISMINUIR=2;
@Override
}
returnfalse;
}
Creación del
boolean rpta = super.onCreateOptionsMenu(menu);
Submenú
SubMenu options=menu.addSubMenu("Zoom");
options.add(MENU_ZOOM, MENU_AUMENTAR, 0, "Aumentar");
options.add(MENU_ZOOM, MENU_DISMINUIR, 0, "Disminuir");
return rpta;
}
caseMENU_AUMENTAR:
return(true);
108
caseMENU_DISMINUIR:
return(true);
}
returnfalse;
}
}
Salida por pantalla
GRÁFICO NO. 25
SUBMENÚ
Análisis: En Android un submenú es un menú que se presenta como resultado de que el usuario haya
selecionado un elemento en otro menú. En el gráfico podemos observar que al dar clic en el elemento
Zoom se abre un submenú
109
2.2.4.8.9.1.4 Menú de opciones a través de un archivo XML
La pantalla de salida del programa es la misma del ejemplo de menú de opciones.
Archivo XML: option_menu.xml
<menuxmlns:android="http://schemas.android.com/apk/res/android">
<itemandroid:id="@+id/MENU_AUMENTAR"
android:title="Aumentar"
android:orderInCategory="0"
android:icon="@drawable/zoom_in"/>
<itemandroid:id="@+id/MENU_DISMINUIR"
android:title="Disminuir "
android:icon="@drawable/zoom_out"
android:orderInCategory="1"/>
</menu>
Clase de Java: Option_Menu_XML.java
import android.view.MenuInflater;
publicclass Option_Menu_XML extends MapActivity {
@Override
}
returnfalse;
}
110
//Creación del objeto que permite capturar el menú definidoen el archivo xml
MenuInflater inflater = getMenuInflater();
inflater.inflate(R.menu.option_menu, menu);
returntrue;
}
case R.id.MENU_AUMENTAR:
return(true);
case R.id.MENU_DISMINUIR:
return(true);
}
returnfalse;
}
}
2.2.4.8.10Proveedor de Contenido (Content Provider)
Los proveedores de contenido permiten almacenar y compartir información entre las
aplicaciones. Android contiene una serie de proveedores de contenido que pueden ser
utilizados por los desarrolladores: audio, video, imágenes, información de las
llamadas, información personal, entre otras.
Una Uri que comience con el esquema “content://” representa una fuente o recurso
para un proveedor de contenidos, la misma que permite realizar operaciones para
crear, leer, actualizar y borrar elementos. Con una Uri se puede obtener una colección
o un solo elemento de esa colección. Por ejemplo, “content://contacts/people" extrae
la información de todos los contactos, mientras que “content://contacts/people/1”
extrae la información del contacto cuyo identificador es el 1.
111
Cuando se realiza la consulta de la colección se utiliza un objeto tipo Cursor, el cual
contiene todos los registros devueltos. Para realizar la consulta se utiliza el método
manageQuery(p1,p2,p3,p4,p5), el cual obtiene 5 parámetros: el Uri del proveedor de
contenido, un arreglo con el nombre de las columnas que se desea obtener, los dos
parámetros siguientes para ingresar clausulas where y finalmente el último parámetro
para indicar el orden de la consulta mediante la cláusula order by.
2.2.4.8.10.1 Ejemplo de proveedor de contenido incluido en el proyecto
El ejemplo mostrado a continuación lista las llamadas realizadas recientemente, al dar
clic sobre una de ellas se abre la pantalla de marcado con el número de teléfono pre
cargado.
Archivo XML: content_provider_row.xml
android:orientation="horizontal"
<ImageView
android:src="@drawable/phone"
android:padding="5px"
/>
<LinearLayout
>
<LinearLayout
android:layout_height="wrap_content">
<TextView
android:textColor="#f0E686"
112
android:paddingTop="5px"
android:text="Numero "
/>
<TextView
android:id="@+id/numero"
/>
</LinearLayout>
<LinearLayout
<TextView
android:text="Tipo: "
/>
<TextView
android:id="@+id/tipo"
/>
</LinearLayout>
<LinearLayout
<TextView
android:text="Duración: "
/>
<TextView
android:id="@+id/duracion"
/>
</LinearLayout>
</LinearLayout>
</LinearLayout>
113
Clase de Java: ContentProviderExample.java
import android.app.ListActivity;
import android.database.Cursor;
import android.provider.CallLog.Calls;
import android.widget.ListAdapter;
import android.widget.SimpleCursorAdapter;
publicclass ContentProviderExample extends ListActivity{
//Objeto del tipo cursor para obtener la información del proveedor de contenido
private Cursor phoneCalls;
//Creación del objeto tipo Uri que identifica de manera única al proveedor de contenido
private Uri llamadas = Uri.parse("content://call_log/calls");
private String[] columnas=new String[]{Calls._ID,Calls.NUMBER, Calls.TYPE,
Calls.DURATION};
private ListView lv;
@Override
//Método para realizar la consulta
phoneCalls=managedQuery(llamadas,columnas,null,null,"Calls.NUMBER asc");
ListAdapter adapter=new SimpleCursorAdapter(this,
R.layout.content_provider_row, phoneCalls,
new String[]
{"Calls.NUMBER","Calls.TYPE","Calls.DURATION"},
newint[] {R.id.numero, R.id.tipo, R.id.duracion});
setListAdapter(adapter);
lv=getListView();
lv.setOnItemClickListener(new OnItemClickListener()
{
@Override
publicvoid onItemClick(AdapterView<?> arg0, View arg1, int arg2,
long arg3) {
phoneCalls.moveToPosition(arg2);
String number =
phoneCalls.getString(phoneCalls.getColumnIndexOrThrow("Calls.NUMBER"));//
startActivity(new
Intent(Intent.ACTION_DIAL,Uri.parse("tel:"+number)));
}});}}
114
Salida por Pantalla
GRÁFICO NO. 26
PROVEEDOR DE CONTENIDOS: LLAMADAS RECIENTES
Análisis: El gráfico muestra una aplicación que lista las llamadas recientes haciendo uso de Content
Providers para extraer la información del teléfono y utilizarla
2.2.4.8.11Intentos (Intents)
Un intento es un mensaje que se pasa entre actividades con el propósito de realizar
una acción. El sistema Android es el que se encarga de resolver que actividad debe
responder al mensaje. Los intentos pueden ser de dos tipos: intentos destinados a una
sola actividad o intentos de difusión (broadcast) que se envían a múltiples
actividades. Un ejemplo de este último sería un mensaje del sistema indicando que la
carga de la batería está baja.
115
Los componentes principales de un intento son:
Action.- como su nombre lo indica action es el verbo, la acción que se quiere
realizar, se representa como una constante. Por ejemplo ACTION_CALL es
una constante de Android que indica que se quiere realizar una llamada.
Data.- representa la información sobre la cual se quiere realizar la acción. La
información se envía a través de un objeto de la clase URI.
2.2.4.8.11.1 Ejemplos de intento incluido en el proyecto
A continuación se muestra una aplicación en donde se utiliza un intento para realizar
una llamada al número ingresado por el usuario en la caja de texto.
Archivo XML: intent_layout.xml
>
<TextView
android:id="@+id/intentTextView"
android:text="Ingrese el numero a marcar"
/>
<EditTextandroid:id="@+id/intentNumeroTelefonico"
/>
<Button
android:id="@+id/intentButton"
android:text="Llamar"
/>
</LinearLayout>
116
Clase de Java: Intento.java
import java.util.regex.Matcher;
import java.util.regex.Pattern;
publicclass Intento extends Activity{
private EditText myEditText;
@Override
setContentView(R.layout.intent_layout);
myEditText=(EditText)findViewById(R.id.intentNumeroTelefonico);
myButton=(Button)findViewById(R.id.intentButton);
myButton.setOnClickListener(new View.OnClickListener() {
@Override
if(validarNumero(myEditText.getText().toString()))
{
//Objeto del tipo Intent que permite definir una acción para que el sistema la
gestione
Intent callIntent=newIntent(Intent.ACTION_CALL,Uri.parse("tel:" +
myEditText.getText()));
startActivity(callIntent);
}
else
{
Toast.makeText(getApplicationContext(), "Error
de formato, trate nuevamente", Toast.LENGTH_SHORT).show();
}
}
});
}
//Método que permite utilizar expresiones regulares para filtrar el contenido de la caja de texto
publicboolean validarNumero(String number){
Pattern numeroTelefono = Pattern.compile("(\\d{2}-)?(\\d{8})");
Matcher matcher = numeroTelefono.matcher(number);
return matcher.matches();
117
}
}
Salida por pantalla
GRÁFICO NO. 27
INTENTO: REALIZAR UNA LLAMADA TELEFÉNICA
Análisis: En este gráfico se visualiza en la parte izquiera una ventana que recibe el número de teléfono
a marcar y en laparte derecha el resultado de utilizar un intento para ejecutar la acción
2.2.4.8.12Adaptadores (Adapters)
Adapters son clases que gestionan colecciones y sirven de puente para enlazar cada
uno de los elementos de esta colección con una vista. Android provee de varias clases
de tipo Adapter: ArrayAdapter, GalleryAdapter, SimpleCursorAdapter, entre otras.
Es importante mencionar que se puede crear nuestras propias clases de tipo Adapter
para que realicen acciones a la medida. A través de los ejemplos realizados a lo largo
del documento ya se ha hecho uso de estos adaptadores, como el caso de
118
GalleryAdapter para crear el ejemplo de Gallery Layout, ArrayAdapter pare el
ejemplo de Menú Contextual y SimpleCursorAdapter en el ejemplo de Proveedores
de Contenido. A continuación se presenta una breve descripción de cada uno:
ArrayAdapter.-permite enlazar objetos de tipo Generic29 con una vista. Por
defeto el objeto que enlaza es de tipo String.
GalleryAdapter.- clase que sirve como puente para enlazar un objeto de tipo
Gallery (Galería) con las imágenes que muestras.
SimpleCursorAdapter.- un adaptador que mapea las columnas devueltas en
un cursor con un objeto ya sea TextView o ImageView. Se puede especificar
que columnas se quieren mostrar y que elementos de la interfaz de usuario
presentan la información.
2.2.4.8.13Base de Datos SQLite
SQLite es un sistema de gestión de bases de datos relacional de dominio público
contenido en una pequeña librería escrita en el lenguaje C y que tiene como principal
característica la de enlazarse con el programa en donde se utiliza de una manera
integral. Esto disminuye las dependencias externas, reduce la latencia, simplifica los
bloqueos generados por transacciones y mejora la sincronización.
29
Generics son una mejora al sistema de tipos introducida en el lenguaje Java desde la versión 5 y que
permite indicarle al compilador de que tipo son los datos que contiene una colección de elementos.
119
Debido a la reputación de ser una base de datos confiable y estable es la elegida de
muchos fabricantes para integrarla en sus productos, se encuentra en diferentes
reproductores MP3, el iPhone y el iPod Touch.
En Android, todas las bases de datos creadas y utilizadas en los programas se
almacenan en la ruta /data/data/nombre_del_paquete/base_de_datos y son por defecto
privadas y accesibles sólo por la aplicación que la creo. Para compartir la información
de una base de datos con otra aplicación lo puede hacer mediante proveedores de
contenido.
Para realizar operaciones con la base, Android proporciona dos clases: Cursors y
Content Values. Con los cursores se pueden realizar operaciones de consulta y con
los Content Values operaciones de inserción de registros. Entre los principales
métodos incluidos en la clase cursor tenemos:
moveToFirst.-posiciona el cursor en la
primera posición devuelta en la
consulta.
moveToNext.-se utiliza para desplazar el cursor al registro siguiente.
moveToPrevious.- desplaza el cursor al registro previo.
getCount.-devuelve el número de columnas retornadas en la consulta.
getColumnIndexOrThrow.- devuelve el índice del registro que contiene la
columna y lanza una excepción si no la encuentra.
120
getColumnName.- devuelve el nombre de la columna especificada en el
índice.
moveToPosition.- mueve el cursor al registro ubicado en esa posición.
getPosition.- retorna la posición en que se encuentra ubicado el cursor en la
consulta.
Como se puede observar en el siguiente código, para almacenar información en un
ContentValue su utiliza el método put(), el cual recibe como parámetro el nombre de
la columna y el valor que se va a almacenar. Finalmente para que el registro sea
guardado en la base se invoca el método insert();
ContentValues values=new ContentValues();
values.put("nombre",wrapper.getNombre());
values.put("apellido", wrapper.getApellido());
values.put("telefono", wrapper.getTelefono());
values.put("direccion", wrapper.getDireccion());
db.insert("personas", null, values);
Para finalizar se recomienda crear una clase que herede de la clase SQLiteHelper para
realizar las rutinas de relación y actualización de la versión de la base.
121
2.2.4.8.14BroadcastReciever
Este componente de Android le proporciona a los desarrolladores la capacidad de
responder a eventos que son lanzados sin un receptor explícito. Generalmente útiles
para responder a eventos del sistema. Este componente es válido mientras dure el
método onRecieve() que es el encargado de recibir el intento y gestionarlo.
Para que este receptor sea visible por Android se debe declarar en el archivo
AndroidManifest,xml.
2.2.4.8.14.1 Ejemplo del BroadcastReciever incluido en el proyecto
Esta aplicación muestra mediante un mensaje el nombre de la acción que se ejecuta
cuando se cambia la configuración del Modo Avión del teléfono.
Clase de Java: BroadcastReceiverExample.xml
import android.app.Notification;
import android.app.NotificationManager;
import android.content.BroadcastReceiver;
import android.util.Log;
publicclass BroadcastRecieverExample extends BroadcastReceiver {
@Override
publicvoid onReceive(Context _context, Intent _intent) {
Toast.makeText(_context, _intent.getAction(), Toast.LENGTH_SHORT).show();
}}
122
Archivo AndroidManifest.xml
<receiverandroid:name=".componentes.BroadcastRecieverExample">
<intent-filter>
<actionandroid:name="android.intent.action.AIRPLANE_MODE"/>
</intent-filter>
</receiver>
Salida por pantalla
GRÁFICO NO. 28
RECEPTOR DE DIFUSIÓN
Análisis: Un broadast receiver es un componente de Android que reacciona ante eventos del sistema o
definidos por el desarrollador, en el gráfico se aprecia que ante el evento de cambiar el modo avión del
dispositivo se presenta un mensaje informando la acción
123
2.2.4.8.15Servicios
Un servicio es un componente que nos proporciona Android para ejecutar acciones
que requieren un largo tiempo de vida y que no poseen interfaz de usuario. Se pueden
utilizar junto con una determinada actividad para realizar una tarea en conjunto, cabe
destacar que un servicio no posee un proceso propio para su ejecución sino que
forma parte de la aplicación donde ha sido definido.
Los servicios al igual que las actividades poseen un ciclo de vida:
onCreate(): método que se ejecuta cuando el servicio es creado.
onStart(): método que se ejecuta cada vez que se invoca el método
startService().
onDestroy(): método invocado cuando el servicio ya no es necesario y debe
ser destruido.
Adicionalmente los servicios se pueden ejecutar de manera local o de manera remota,
para el primer caso la interacción con las actividades se logra mediante la definición
de un objeto de la clase Binder, para el segundo caso es necesario hacer uso de una
interfaz remota AIDL(Android Interface Definition Language).
124
2.1.4.8.15.1 Ejemplo de servicio incluido en el proyecto
Esta pequeña aplicación utiliza un servicio para reproducir y detener un archivo en
formato mp3.
Archivo XML: service_layout.xml
>
<TextView
android:text="Música: Highway to Hell"
/>
<LinearLayout
>
<Button
android:id="@+id/btnReproducir"
android:text="Reproducir"
/>
<Button
android:id="@+id/btnDetener"
android:text="Detener"
/>
</LinearLayout>
</LinearLayout>
125
Clase de Java: ServiceExample.java
import android.app.Service;
import android.media.MediaPlayer;
import android.os.IBinder;
publicclass ServiceExample extends Service {
privatestaticfinal String ETIQUETA = "Mi Servicio";
MediaPlayer player;
@Override
public IBinder onBind(Intent intent) {
returnnull;
}
@Override
publicvoid onCreate() {
Toast.makeText(this, "Servicio creado", Toast.LENGTH_LONG).show();
Log.d(ETIQUETA, "onCreate");
//Creación del objeto MediaPlayer para la reproducción de un archivo de
música
player = MediaPlayer.create(this,R.raw.highwaytohell);
player.setLooping(false); //Para indicar si se cicla o no
}
@Override
publicvoid onDestroy() {
Toast.makeText(this, "Servicio detenido", Toast.LENGTH_LONG).show();
Log.d(ETIQUETA, "onDestroy");
player.stop();
}
@Override
publicvoid onStart(Intent intent, int startid) {
Toast.makeText(this, "Ejecutando el servicio... ",
Toast.LENGTH_LONG).show();
Log.d(ETIQUETA, "onStart");
player.start();
}}
126
Clase de Java: ServiceExampleActivity.java
Esta clase contiene la actividad que ejecuta el servicio.
import android.content.DialogInterface.OnClickListener;
publicclass ServiceExampleActivity extends Activity {
privatestaticfinal String ETIQUETA = "Mi Actividad para mostrar el Servicio";
private Button btnReproducir;
private Button btnDetener;
@Override
setContentView(R.layout.service_layout);
btnReproducir = (Button) findViewById(R.id.btnReproducir);
btnDetener = (Button) findViewById(R.id.btnDetener);
btnReproducir.setOnClickListener(new View.OnClickListener(){
@Override
Log.d(ETIQUETA, "onClick: Servicio ejecutándose");
Intent intento=new
Intent(getApplicationContext(),ServiceExample.class);
startService(intento);
}
});
btnDetener.setOnClickListener(new View.OnClickListener(){
@Override
Intent intento=new
Intent(getApplicationContext(),ServiceExample.class);
stopService(intento);}});}}
127
GRÁFICO NO. 29
SERVICIO
Análisis: Para este ejemplo se utilizó un servicio que gestiona la reproducción de un archivo mp3
2.2.4.8.16Hilo (Thread)
Cuando se habla de hilos estamos hablando de subprocesos que se ejecutan en
segundo plano, en Android para su gestión, se requiere una instancia de la clase
Handler y solo puede existir una por actividad.
Para que el hilo se comunique con el objeto de esta clase se lo puede realizar
mediante dos mecanismos, enviando mensajes o a través de objetos Runnable.
128
En caso de utilizar mensajes el esquema que utiliza el sistema para su gestión es de
tipo cola. Entre los principales métodos tenemos:
sendMessage().-coloca inmediatamente el mensaje en la cola.
sendMessageAtFrontOfQueue().-coloca de manera inmediata el mensaje en
la cola asignándole la mayor prioridad para que se ejecute por delante de los
mensajes anteriores.
sendMessageDelayed().-coloca el mensaje en la cola después del tiempo
indicado.
2.2.4.8.16.1 Ejemplo de hilo incluido en el proyecto
Para la demostración del funcionamiento de los hilos, la aplicación que se muestra a
continuación presenta una barra de progreso que se actualiza cada 3 segundos por la
acción de uno de ellos.
Archivo XML: thread_example.xml
>
<ProgressBar
android:id="@+id/myBar"style="?android:attr/progressBarStyleHorizontal"
/>
</LinearLayout>
129
Clase de Java: ThreadExample.java
import android.os.Handler;
import android.os.Message;
import android.widget.ProgressBar;
publicclass ThreadExample extends Activity {
private ProgressBar progressBar;
//Creación del objeto Handler que permite la interacción con el hilo
Handler handler=new Handler() {
publicvoid handleMessage(Message msg) {
progressBar.incrementProgressBy(5);
}
};
booleanisRunning=false;
@Override
{
setContentView(R.layout.thread_example);
progressBar=(ProgressBar)findViewById(R.id.myBar);
}
publicvoid onStart()
{
super.onStart();
progressBar.setProgress(0);
//creación del objeto Thread
Thread t=new Thread(new Runnable()
{
@Override
publicvoid run() {
try{
for(int i=0;i<20 &&isRunning;i++)
{
//Dormimos el hilo 3 segundos y enviamos un mensaje al
objetoHandler para que incremente la barra de progreso
Thread.sleep(3000);
handler.sendMessage(handler.obtainMessage());
}
}catch(Exception e){}
}
});
isRunning=true;
t.start();
}
130
publicvoid onStop()
{
super.onStop();
isRunning=false; }}
Salida por pantalla
GRÁFICO NO.30
HILO (THREAD)
Análisis:El gráfico presenta una barra de progreso en acción, cada 5 segundos un hilo le indica a la
barra que debe avanzar
2.2.4.8.17Archivos (File)
Las clases que utiliza Android para la gestión de archivo son las propias del lenguaje
Java.
2.2.4.8.17.1 Ejemplo de archivos incluido en el proyecto
El ejemplo que se muestra a continuación es un navegador de archivos, el cual está
estructurado mediante el uso de la clase File. Además del constructor de la clase, los
métodos utilizados son:
131
isDirectory().-permite determinar si el archivo en cuestión es un directorio.
getPath().-devuelve una cadena de caracteres indicando la ruta absoluta del
archivo.
getParent().-devuelve una cadena de caracteres con el nombre del directorio
que contiene ese archivo.
getParentFile().-devuelve un objeto del tipo File que contiene el archivo
padre, es decir el directorio en donde se encuentra el archivo.
listFiles().-devuelve un arreglo de tipo File con todos los archivos ubicados en
ese directorio.
Archivo XML: item_view.xml
<TextViewxmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/_text"
/>
Clase de Java: FileBrowser.java
import java.io.File;
import java.net.URI;
import java.util.ArrayList;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.widget.ArrayAdapter;
132
publicclass FileBrowser extends ListActivity {
ArrayList<String>ls_archivos=new ArrayList<String>();
privatefinalstaticintOPTION_RETROCEDER=0;
privatefinalstaticintOPTION_SALIR=1;
File lf_temp;
File lf_temp2;
@Override
publicvoid onCreate(Bundle icicle) {
super.onCreate(icicle);
this.getFiles(new File("/").listFiles());
}
@Override
protectedvoid onListItemClick(ListView l,View v, int position,long id)
{
int li_columna_seleccionada=(int)id;
if(li_columna_seleccionada==0)
{
if(lf_temp2!=null)
{
if(lf_temp2.isDirectory())
{
if(!lf_temp2.getPath().equals("/")){
lf_temp2=lf_temp2.getParentFile();
getFiles(lf_temp2.listFiles());}
}
else
{
if(!lf_temp2.getParent().equals("/")){
lf_temp2=lf_temp2.getParentFile().getParentFile();
getFiles(lf_temp2.listFiles());
}
}
}
}
else
{
try{
lf_temp=new File(ls_archivos.get(li_columna_seleccionada));
lf_temp2=lf_temp;
if(lf_temp.isDirectory())
{
getFiles(lf_temp.listFiles());
}
else
{
AlertDialog.Builder alert=new
AlertDialog.Builder(FileBrowser.this);
133
alert.setMessage("Archivo seleccionado: " + lf_temp.getName());
alert.setPositiveButton("Aceptar", new DialogInterface.OnClickListener() {
@Override
publicvoid onClick(DialogInterface dialog, int which) {
try {
Intent myIntent=new
Intent(android.content.Intent.ACTION_VIEW,Uri.parse("file://"+lf_temp.getAbsolutePath()));
startActivity(myIntent);
} catch (Exception e) {
e.printStackTrace();
}
}
});
alert.create().show();
}}
catch(Exception e)
{
}
}
}
privatevoid getFiles(File[] files){
try{
if(files==null)
{
Toast.makeText(getApplicationContext(),"No tiene permiso para acceder a este directorio",
Toast.LENGTH_LONG).show();
}
else
{
ls_archivos=new ArrayList<String>();
ls_archivos.add("..");
for(File file : files){
ls_archivos.add(file.getPath());
}
ArrayAdapter<String> fileList = new ArrayAdapter<String>(this,R.layout.item_view,
ls_archivos);
setListAdapter(fileList);
}
}catch(Exception e)
{
}
}
}
134
Salida por pantalla
GRÁFICO NO. 31
NAVEGADOR DE ARCHIVOS
Análisis:En la imagen de la pantalla capturada se muestra la funcionalidad del navegador de archivos,
al acceder un directorio se presenta el listado de archivos y en la parte superior la opción para
retroceder en el árbol de directorios “..”
2.2.4.8.18Navegador WebKit
WebKit es
un framework para
aplicaciones
que funciona como
base para
el navegador web Safari de Apple y que se encuentra disponible para Android. El
navegador de Android es lo suficientemente complejo que cuenta con su propia
librería, android.webkit, y permite mostrar información HTML y utilizar todas las
características de navegación embebidas en nuestra aplicación.
135
2.2.4.8.18.1 Ejemplo del navegador WebKit incluido en el proyecto
El pequeño ejemplo muestra una caja de texto en la cual se debe ingresar la URL a
buscar y un botón que al dar clic realiza la acción de búsqueda.
Archivo XML: webkit_layout.xml
>
<TextView
android:text="URL:"
/>
<EditText
android:id="@+id/edtUrl"
/>
<Button
android:id="@+id/btnAceptar"
/>
<WebView
android:id="@+id/wvWeb"
/>
</LinearLayout>
136
Clase de Java: WebViewExample.java
package android.com.proyecto.widgets;
import android.R.color;
import android.view.View.OnClickListener;
import android.webkit.WebView;
publicclass WebViewExample extends Activity {
private Button btnAceptar;
private EditText edtUrl;
private WebView myWebView;
private String _url;
/** Called when the activity is first created. */
@Override
setContentView(R.layout.webkit_layout);
btnAceptar=(Button)findViewById(R.id.btnAceptar);
edtUrl=(EditText)findViewById(R.id.edtUrl);
myWebView=(WebView)findViewById(R.id.wvWeb);
myWebView.setBackgroundColor(color.black);
myWebView.getSettings().setJavaScriptEnabled(true);
btnAceptar.setOnClickListener(new OnClickListener()
{
@Override
if(edtUrl.getText().toString().equals(""))
{
Toast.makeText(getApplicationContext(), "Ingrese una
URL", Toast.LENGTH_SHORT).show();
}
else
{
try
{
_url=edtUrl.getText().toString();
if(!_url.substring(0,6).equals("http://"))
{
_url="http://" + _url;
}
myWebView.loadUrl(_url);
}
catch(Exception e)
{
137
}
}
}
});
}
}
Salida por pantalla
GRÁFICO NO. 32
NAVEGADOR WEBKIT
Análisis: Android permite a los desarrolladores hacer uso del navegador webkit en sus aplicaciones,
tal como se aprecia en el gráfico
138
2.2.4.8.19Multimedia
Android basa su soporte multimedia haciendo uso de la plataforma multimedia de
código abierto openCORE, desarrollada por la corporación PacketVideo Corporation.
Android utiliza las funcionalidades de openCORE envolviéndolas en un API fácil de
usar por los desarrolladores. Entre las bondades que proporciona tenemos:
Interfaces
para
terceros
y
los
códecs
multimedia
de
hardware,
dispositivos de entrada y salida, y el contenido de las políticas.
Medios de reproducción, streaming, descarga y reproducción progresiva,
incluyendocontenedores 3GPP, MPEG-4, AAC30, y MP3.
Codificadores y decodificadores de video, incluyendo MPEG-4, H.26331y
AVC(H.26432) y JPEG.
Codecs de idioma, incluyendo AMR-NB y AMR-WB33.
Codecs de audio, incluyendo MP3, AAC y AAC +.
Medios de grabación, incluyendo 3GPP, MPEG-4 y JPEG.
Videoconferencia basada en el estándar 324-M.
30
32
33
31
139
A continuación se muestra un cuadro más detallado con la información de los
formatos que soporta:
CUADRO NO. 5
FORMATOS MULTIMEDIA SOPORTADOS EN LA PLATAFORMA
Tipo
Formato
Codificador
Decodificador
Tipos de archivos soportados
LC AAC / LTP
X
3GPP (.3 gp) y MPEG-4 (.
Mp4,. M4a).No tienen soporte
de primas AAC (. Aac)
HE-AAC34v1
(AAC +)
X
HE-AACv2
(mejorado AAC +)
X
AMR-NB
Audio
X
3GPP (.3 gp)
AMR-WB
X
3GPP (.3 gp)
MP3
X
MP3 (. Mp3)
X
Tipo 0 y 1 (. Mid,. XMF.
Mxmf).También RTTTL / RTX
(. RTTTL,. RTX), OTA (.
OTA) y iMelody (. Imy)
X
Ogg (. Ogg)
X
WAVE (. Wav)
X
JPEG (. Jpg)
GIF
X
GIF (. Gif)
PNG
X
PNG (. Png)
BMP
X
BMP (. Bmp)
X
Mp4)
Mp4)
3GPP (.3 gp)
MIDI
X
35
Ogg Vorbis36
PCM / WAVE
JPEG
Imagen
H.263
Vídeo
37
X
X
H.264 AVC
X
MPEG-4 SP38
X
Elaboración: Traducido de la fuente
Fuente: Página oficial de Android: http://developer.android.com/guide/appendix/media-formats.html
34
36
37
38
35
140
2.2.4.8.19.1 MediaPlayer
La
clase
MediaPlayer
permite
reproducir
archivos
multimedia
como
recursos de las aplicaciones, pueden estar almacenados en archivos locales,
proveedores de contenidos, e incluso obtenerlos desde una dirección URL de la red.
2.2.4.8.19.1.1 Reproducción de archivos de audio
En el ejemplo demostrativo de cómo funciona un Servicio se realizó la reproducción
de un archivo con formato MP3. Lo primero que se debe realizar es crear un objeto
pasándole como parámetros el contexto y la fuente de donde se va a obtener la
información. Como se muestra a continuación:
player = MediaPlayer.create(this,R.raw.highwaytohell);
Para ejecutar el archivo se usa el método start() y para detenerlo el método stop();
2.2.4.8.19.1.2Reproducción de archivos de video
Para reproducir un archivo de video existen dos maneras, en ambos casos se debe
especificar la superficie en donde se va a visualizar.
1. Usando la vista VideoView.
2. A través de la clase MediaPlayer pero utilizando el objeto surface para
encapsularlo y poder presentarlo al usuario.
141
2.2.4.8.19.1.3 Grabación de audio y video
Las acciones de grabar audio y video en Android sonadministradas por la clase
MediaRecorder. Para utilizarla se debe dar los permisos necesarios en el archivo de
configuración AndroidManifest.xml:
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.RECORD_VIDEO"/>
Luego es importante el orden en que se realizan las acciones para que la aplicación se
pueda ejecutar y actuar de manera adecuada. Los pasos se describen a continuación:
Crear el objeto MediaRecoreder: MediaRecorder myMediaRecorder = new
MediaRecorder()
Indicar
la
fuente
de
entrada
para
la
grabación:
myMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
Definir el formato de salida:
myMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.DEFAUL
T);
Especificar la codificación de audio y video, velocidad de fotogramas, tamaño
de salida:
myMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.DEFAUL
T);
142
Seleccionar un archivo de salida:
myMediaRecorder.setOutputFile("/sdcard/arhivo_salida.mp4");
Prepararse para la grabación, iniciar el proceso y terminarlo.
 myMediaRecorder.prepare();
 myMediaRecorder.start();
 myMediaRecorder.stop();
2.2.4.8.19.2Ejemplo incluido en el proyecto
Esta pequeña aplicación permite reproducir un archivo de video y enviar una
notificación cuando ha finalizado.
Archivo XML: multimedia_layout.xml
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
<TextView
android:textSize="14px"
android:text="Video Oficial Android 1.6"
/>
<VideoViewandroid:id="@+id/VideoView01"
android:layout_width="176px"
android:layout_height="144px"
/>
<LinearLayout
143
<ImageButton
android:src="@drawable/play"
android:id="@+id/btn_reproducir"
/>
<ImageButton
android:src="@drawable/pause"
android:id="@+id/btn_pausar"
/>
</LinearLayout>
</LinearLayout>
Clase de Java
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.media.MediaPlayer;
import android.widget.ImageButton;
import android.widget.MediaController;
import android.widget.VideoView;
publicclass EjemploMultimedia extends Activity {
private ImageButton btn_reproducir;
private ImageButton btn_pausar;
private VideoView VideoView01;
private MediaController mediaController;
publicstaticfinalintnotification_id=1;
inticon = R.drawable.stop;
CharSequence tickerText = "Reproducción finalizada";
longwhen = System.currentTimeMillis();
@Override
setContentView(R.layout.multimedia_layout);
VideoView01=(VideoView)findViewById(R.id.VideoView01);
Uri path = Uri.parse("android.resource://android.com.proyecto/" + R.raw.official_video);
VideoView01.setVideoURI(path);
144
mediaController=new MediaController(this);
mediaController.setMediaPlayer(VideoView01);
VideoView01.setMediaController(mediaController);
VideoView01.requestFocus();
btn_reproducir=(ImageButton)findViewById(R.id.btn_reproducir);
btn_reproducir.setOnClickListener(new View.OnClickListener() {
@Override
VideoView01.start();}
});
btn_pausar=(ImageButton)findViewById(R.id.btn_pausar);
btn_pausar.setOnClickListener(new View.OnClickListener() {
@Override
VideoView01.pause();}
});
VideoView01.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
@Override
publicvoid onCompletion(MediaPlayer mp) {
Context context = getApplicationContext();
String ns = Context.NOTIFICATION_SERVICE;
NotificationManager notificationManager = (NotificationManager)
getSystemService(ns);
CharSequence contentTitle = "Notificación";
CharSequence contentText = "El video que estaba reproduciendo se acabó!";
Intent notificationIntent = new Intent(getApplicationContext(),
EjemploMultimedia.class);
PendingIntent contentIntent = PendingIntent.getActivity(getApplicationContext(), 0,
notificationIntent, 0);
Notification notification = new Notification(icon, tickerText, when);
notification.setLatestEventInfo(context, contentTitle, contentText, contentIntent);
notificationManager.notify(notification_id, notification);}});}}
145
GRÁFICO NO. 33
REPRODUCCIÓN DE VIDEO
Análisis: En Android la reproducción de video se la realiza haciendo uso de la clase MediaController,
en la imagen se aprecia el resultado de utilizarla
2.2.4.8.20Notificaciones
Como ya se ha mencionado previamente en este documento los teléfonos han
evolucionado, Android pensando en la interacción con el usuario se basa en un
concepto que no es nuevo pero que si lo ha mejorado para permitirle al teléfono
enviar notificaciones al usuario cuando un evento ha ocurrido, estas notificaciones
van desde presentar el evento en la barra de estado hasta emitir un sonido o hacer
vibrar el equipo. Es la tarea del desarrollador sacar provecho a esta característica.
146
Para definir una notificación se debe crear y utilizar un evento de la clase
Notification, y para administrarla se debe implementar un objeto de la clase
NotificationManager. Como el objeto creado en el ejemplo de reproducción de video:
inticon = R.drawable.stop; //Ícono a presentrase
CharSequence tickerText = "Reproducción finalizada"; //Mensaje
longwhen = System.currentTimeMillis(); //Hora
CharSequence contentTitle = "Notificación";
CharSequence contentText = "El video que es taba reproduciendo se acabó!";
Notification notification = new Notification(icon, tickerText, when);
notification.setLatestEventInfo(context, contentTitle, contentText, contentIntent);
notificationManager.notify(notification_id, notification);
El método setLatestEventInfo permite aumentar los detalles de la información que se
muestra cuando se expande el panel de notificaciones como sevisualiza en el Gráfico
No. 34.
147
GRÁFICO NO. 34
NOTIFICACIÓN DE FINALIZACIÓN DE REPRODUCCIÓN DEL VIDEO
Análisis: Otra de las bondades de Android laconstituyen las notificaciones, mecanismo con el cual se
puede alertar al usuario que ha ocurrido un evento, para el ejemplo se muestra en la imagen que se ha
enviado una notificación cuando la reproducción del video llegó a su fin.
2.2.4.8.21Google Maps
Para terminar la explicación demostrativa de Android quiero hablar un poco sobre el
uso de este API, como se habrán dado cuenta en los ejemplos, para utilizar los
mapas se requiere importar la librería com.google.android.maps.
Cuando una aplicación contiene un elemento MapView esta solicita la información
del mapa a presentarse mediante Internet. Como parte de la solicitud que se envía a
Google Maps se incluye una clave que identifica al desarrollador.
148
Los pasos necesarios para generar esta clave única son:
1. Obtener la huella digital MD5 para el certificado de registro
Dirigirse a través de la ventana de comando hasta la carpeta bin
contenida
en
el
SDK
de
java:
cd:
“C:\Archivos
de
programa\Java\jdk1.6.0_18\bin”
Ejecutar el programa keytool con las siguientes opciones: keytool -list
-alias alias_name -keystore my- key.keystore, en donde my-key es el
nombre que se le dará a la clave.
Como resultado el programa nos solicitará ingresar una contraseña
para obtener la clave. Finalmente luego de generarla se visualizará en
la consola un mensaje como el aquí mostrado: Certificate fingerprint
(MD5): 94:1E:43:49:87:73:BB:E6:A6:88:D7:20:F1:8E:B5:98
2. Registrar el certificado de la huella digital en el servicio de Google Maps
Cargar la siguiente página en el navegador: http://code.google.
com/android/maps-api-signup.html
Para realizar el registro se requiere tener una cuenta en Google, una
vez accesado se debe leer y aceptar los términos, pegar el certificado
de la huella digital en la casilla correspondiente y dar clic en generar.
Finalmente se presentará la clave para utilizar el API de Google Maps.
Esta clave debe incluirse en el elemento MapView tal como se muestra
a continuación:
<com.google.android.maps.MapView
149
android:enabled="true"
android:clickable="true"
android:apiKey="example_Maps_ApiKey_String"/>
2.2.4.8.22Opciones avanzadas de Android
2.2.4.8.22.1 Acceso al Hardware
Android proporciona una serie de librerías que le permiten a los desarrolladores
accesar al hardware del Equipo sin tener que preocuparse por detalles de conexión o
código extenuante. Entre las principales librerías que cumplen este cometido
tenemos:
TelephonyManager.- proporciona acceso a la información acerca del
dispositivo y de los servicios telefónicos. Las aplicaciones hacen uso de esta
clase para determinar los estados y los servicios telefónicos, así como también
obtener información del proveedor de los servicios.
LocationManager.- clase que proporciona acceso a los servicios de
localización del sistema. Estos servicios permiten que las aplicaciones puedan
obtener actualizaciones periódicas de la situación geográfica del dispositivo.
150
MediaRecorder.- clase que
proporciona los métodos necesarios para la
grabación de audio y video.
SensorManager.- clase que proporciona el acceso a los diferentes sensores
incorporados en el equipo.En Android, los sensores son parte integral de la
experiencia del usuario. El listado de los sensores soportados por la
plataforma incluye:
 Acelerómetro
 Giroscopio
 Sensor de luz
 Campo magnético
 Orientación
 Presión
 Proximidad
 Temperatura
Librerías de comunicación para el manejo de las conexiones de red, bluetooth
y wifi.
 ConnectityManager.- clase que nos proporciona información de los
estados de la conexión de la red.
 Bluetooth.- protocolo de comunicaciones diseñado para corto alcance.
A partir de Android 2.1, sólo la comunicación encriptada es
compatible,
lo
que
significa
que
sólo
se
puede
151
formar conexiones entre los dispositivos vinculados. Las clases que
gestionan la interacción Bluetooth entre dispositivos son:

BluetoothAdapter.- representa el dispositivo Bluetooth local, es
decir,el dispositivo Android en el que se ejecuta la aplicación.

BluetoothDevice.- cada dispositivo remoto con el que nuestro
equipo se desea comunicar.

BluetoothSocket y BluetoothServerSocket.- la interfaz Bluetooth
Socket es similar a las clases de Java Socket y ServerSocke. Del
lado del servidor crear el método BluetoothServerSocket para crear
un objeto que este escuchando o sensando los otros dispositivos y
administrar la conexión cuando esta se realiza. Del lado del cliente
usar BluetoothSocket para permitir la interacción con el servidor.
 WifiManager.-como su nombre lo indica esta clase nos permite
gestionar los aspectos relacionados a la conexión Wifi. Entre las
opciones que nos facilita tenemos:

Lista de las redes configuradas.

Información de la red Wi-Fi activa, si es que existe alguna.

Definición
de
acciones
a
la
que
pueden
responder
BroadCastReceiver cuando ocurren cambios del estado de la WiFi.
152
Text to speech.- API incluido en Android desde la versión 1.6 y se utiliza para hacer
que las aplicaciones “hablen”.
2.3 FUNDAMENTACIÓN LEGAL
2.3.1Constitución del Ecuador, Título VII, Capítulo Primero, Sección primera
(Educación)
De acuerdo a la Constitución del Ecuador, Título VII (Régimen del buen vivir),
Capítulo Primero (Inclusión y equidad), Sección primera (Educación).
Art. 349.‐El sistema de educación superior tiene como finalidad la formación
académica y profesional con visión científica y humanista; la investigación
científica y tecnológica; la innovación, promoción, desarrollo y difusión de los
saberes y las culturas; la construcción de soluciones para los problemas del país,
en relación con los objetivos del régimen de desarrollo.
2.3.2Constitución del Ecuador, Título VII, Capítulo Primero, Sección octava
De acuerdo a la Constitución del Ecuador, Título VII (Régimen del buen vivir),
Capítulo Primero (Inclusión y equidad), Sección octava(Ciencia, tecnología,
innovación y saberes ancestrales).
153
Art. 386.‐Será responsabilidad del Estado:
1. Facilitar e impulsar la incorporación a la sociedad del conocimiento para
alcanzar losobjetivos del régimen de desarrollo.
2. Promover la generación y producción de conocimiento, fomentar la
investigacióncientífica y tecnológica, y potenciar los saberes ancestrales,
para así contribuir a larealización del buen vivir, al sumak kausay.
3. Asegurar la difusión y el acceso a los conocimientos científicos y
tecnológicos, elusufructo de sus descubrimientos y hallazgos en el marco
de lo establecido en laConstitución y la Ley.
4. Garantizar la libertad de creación e investigación en el marco del respeto
a la ética, lanaturaleza, el ambiente, y el rescate de los conocimientos
ancestrales.
5. Reconocer la condición de investigador de acuerdo a la Ley.
2.4 HIPÓTESIS A CONTESTARSE
¿Constituye Android una oportunidad de negocio?
¿Tiene oportunidades de consolidarse en el mercado mundial de teléfonos
inteligentes?
¿Proporciona mayores ventajas a los desarrolladores en comparación con la
competencia?
¿Es Android el futuro de la computación móvil y la oportunidad que
esperaban los desarrolladores para explotar sus aplicaciones?
154
2.5 VARIABLES DE LA INVESTIGACIÓN
Para demostrar las hipótesis descritas en el tópico anterior se utilizarán una serie de
variables que se han agrupado en función a comparaciones realizadas de las
funcionalidades de Android.
2.5.1 Análisiscomparativo de Android, Symbian OS y Windows Mobile
Para realizar el estudio comparativo entre estas plataformas se han considerado una
serie de criterios de comparación: criterios básicos, criterios principales, criterios
técnicos y criterios de interfaz de usuario.
Debido a las diferentes necesidades de los usuarios, la identificación de un sistema
operativo ideal no es posible, pero se puede realizar una aproximación de sus
preferencias basándose en las estadísticas de las características del mercado de
teléfonos móviles. En base a esta premisa se puede deducir que los siguientes
criterios
son importantes para un sistema operativo exitoso, cada uno con su
respectivo conjunto de variables a ser evaluadas.
155
2.5.1.1 Criterios básicos
2.5.1.1.1 Comparativa de los Mercados de Aplicaciones Móviles
Características principales de cada Tienda. La comparación se realizará en
base a tres criterios:
Interfaz de usuario.- debe considerarse:
 Si la aplicación cliente se encuentra pre-instalada en el
dispositivo o el usuario la debe instalar para poder realizar la
descarga del contenido de la tienda virtual.
 Forma de pago de los productos descargados.
Interfaz de desarrolladores.- debe considerarse:
 Si en el sitio se permite la descarga del SDK
 Si existe un portal propio para los desarrolladores
 El nivel de control para el registro de aplicaciones
Contenido y equipos objetivos.- debe considerarse:
 El tipo de contenido que el usuario del equipo se puede
descargar del sitio.
 El tipo de dispositivo a quienes están dirigidas las aplicaciones
Modelo de ingresos monetarios de cada tienda. Para la comparación se
considerará:
156
Modelo de reparto de ingresos.- cómo se distribuyen las ganancias
obtenidas por las ventas de las aplicaciones. Es decir, el porcentaje que
le corresponde al desarrollador, a la compañía y a la operadora.
Pago y facturación.- constituye el valor monetario que se debe
cancelar a la compañía dueña del sitio y por ende de la plataforma para
poder publicar y vender las aplicaciones en la tienda
Posición en el mercado mundial.- debido a lo joven de la plataforma y a su
recién ingreso en el mercado de teléfonos inteligentes ecuatoriano, se mostrará
las estadísticas de ventas por sistemas operativos a nivel mundial con el
objetivo de tener una visión de las proyecciones.
Estadísticas de las tiendas en línea.- finalmente se presentarán estadísticas
de los sitios con el propósito de demostrar el contenido que ofrece a los
usuarios. Específicamente se evaluará:
Proporción de aplicaciones pagadas vs las gratuitas
Precio promedio de las Aplicaciones
2.5.1.2Criterios principales
Portabilidad.-se
define
como
la
característica
que
posee
un software para ejecutarse en diferentes plataformas, el código fuente del
software es capaz de reutilizarse en vez de crearse un nuevo código cuando el
157
software pasa de una plataforma a otra. A mayor portabilidad menor es la
dependencia del software con respecto a la plataforma.En cuanto a sistemas
operativos para dispositivos móviles avanzados significa la posibilidad de
utilizar dicho sistema operativo en cada teléfono celular, sin importar su
marca o tipo.
Fiabilidad.- capacidad de un sistema para funcionar y mantener sus funciones
en circunstancias ordinarias, así como las circunstancias hostiles o
inesperadas, para un periodo de tiempo.
Conectividad.-en dispositivos móviles significa la posibilidad de conectarse
con otros dispositivos mediante el apoyo del sistema operativo, a través de
tecnologías como bluetooth o infrarrojos. El objetivo es realizar intercambio
de información.
Tamaño del Kernel (Núcleo).-el núcleo del sistema operativo proporciona el
acceso a los distintos elementos del hardware del dispositivo. Ofrece distintos
servicios a las capas superiores como son los drivers para el hardware, la
gestión de procesos, el sistema de archivos y el acceso y gestión de la
memoria. El tamaño del núcleo es un factor vital en los sistemas operativos
para dispositivos móviles ya que es cargado primero durante el proceso de
158
booteo (carga) y luego permanece en la memoria principal del sistema
operativo. Esto influye en la capacidad.
Seguridad.- la seguridad es el atributo de un sistema que lo protege de los
ataques y otras interferencias. En cuanto a sistemas operativos para
dispositivos móviles, significa las características del sistema operativo, con el
fin de que sea seguro en cualquier aspecto.
Características especiales.-constituyen los aspectos distintivos que lo
diferencian de los demás, para la comparativa se
contempla aquellas
prestaciones únicas de cada sistema operativo.
2.5.1.3Criterios técnicos
Administración de energía.- verificar si la plataforma posee mecanismos
para el ahorro de energía como medio para prolongar la duración de la carga
de la batería.
Multitarea.- capacidad para ejecutar varios procesos al mismo tiempo.
159
2.5.1.4 Criterios de Interfaz de usuario
División entre el sistema operativo e interfaz de usuario.-nivel de
dependencia del sistema operativo para la creación de interfaz de usuario de
las aplicaciones.
Personalización de la interfaz de usuario.-indicar el nivel de facilidad con
que el usuario puede personalizar la apariencia de la interfaz gráfica (frontend).
2.5.2 Comparativa de los SDKs de Android y Symbian OS
Las variables a evaluarse son:
Requerimientos del sistema.-características de hardware y de software que
deben poseer los equipos para que se puedan ejecutar cada uno de los
respectivos SDKs.
Ciclos de vida de las Aplicaciones.- diferentes estados por lo que una
aplicación o un programa pasa desde que es ejecutado hasta que finaliza.
160
Librerías.- una librería es una colección de subrutinas o clases que se utilizan
para desarrollar software. Las librerías contienen código y datos que
proporcionan servicios
a programas independientes. Esto permite el
intercambio y el cambio de código y datos de forma modular.
Almacenamiento persistente de datos.- tecnologías utilizadas en cada SDK
para almacenar información que perdure incluso cuando el dispositivo se
encuentra apagado.
Manejo de eventos.- un evento en programación es la acción que se genera
cuando el usuario de la aplicación interactúa con un elemento de la interfaz
gráfica. En la comparativa se evaluará como cada una de las plataformas
gestiona los eventos.
CAPITULO III
METODOLOGÍA
DISEÑO DE LA INVESTIGACIÓN
3.1 MODALIDAD DE LA INVESTIGACIÓN
Investigación bibliográfica o documental.- El presente trabajo se presenta como un
estudio de Android, en un mayor porcentaje se realizará una investigación
documental basándose en diversas fuentes bibliográficas que van desde libros,
páginas de internet y reportes. Sin embargo se realizarán una serie de ejemplos
demostrativos que servirán para presentar de manera práctica lo expuesto de manera
teórica. Además de la creación de cuatro aplicaciones que tiene como objetivo
principal el exponer el verdadero potencial que brinda la plataforma a los
desarrolladores y hacia donde orientarse para sacar el provecho a la misma.
3.1.1TIPO DE INVESTIGACIÓN
La investigación que se procederá a realizar para el desarrollo de este estudio se
presenta como una investigación de “comprobación de hipótesis” y de “acción”.
162
Para cumplir con los objetivos de este tipo de investigación se procederá a realizar
una:
Descripción de las características de Android y evaluación de los
componentes principales que proporciona la plataforma para el desarrollo de
aplicaciones, sustentado mediante pequeños programas.
Comparativa de las características y prestaciones con plataformas que operan
en el mismo mercado objetivo, así como su actual posición
y las
proyecciones a mediano plazo.
Comparativa práctica entre la codificación que se debe realizar para crear una
misma aplicación tanto para Symbian OS como para Android.
3.2 POBLACIÓN Y MUESTRA
Debido a las razones que ya se ha expuesto anteriormente sobre lo reciente de la
plataforma y a que en nuestro país recién hizo su arribo esta tecnología,como parte
del estudio se realizará una encuesta dirigida a personas que trabajan o han trabajado
desarrollando aplicaciones para teléfonos inteligentes. El propósito de dicha encuesta
es determinar primero, en qué plataforma han desarrollado, si tienen conocimiento
sobre Android, además de conocer las características que consideran ellos que una
163
plataforma para teléfonos inteligentes les debe brindar y hacia donde creen se va a
orientar el futuro de esta tecnología.
La población la constituyen los desarrolladores de aplicaciones para teléfonos
inteligentes de la ciudad de Guayaquil, no existe un registro estadístico del número
exacto de personas que realicen esta actividad. Sin embargo, se escogió una pequeña
muestra de 5 personas que trabajan en diferentes empresas para que contesten las
respuestas de acuerdo a su criterio y experiencia. Las personas encuestadas son:
Gregorio Zambrano, Líder de Proyectos. Empresa Corlasosa
Jorge Espinoza, Líder de Proyectos. Empresa Open Mind Technology
Jorge Morán, Desarrollador. Empresa Omtech
Orlando Rubio, Desarrollador. Empresa Banco de Guayaquil
Victor Indacochea, Analista-Programador. Empresa Open Mind Technology
164
3.3 OPERACIONALIZACIÓN DE VARIABLES
CUADRO No. 6
MATRIZ DE OPERACIONALIZACIÓN DE VARIABLES
Variables
Dimensiones
V.I
Sistemas
operativos
Análisis
comparativo
de Android, Symbian OS
Android, Symbian OS y y Windows Mobile
Windows
Mobile.
Debido a las diferentes
necesidades de los usuarios, la
identificación de un sistema
operativo ideal no es posible,
pero se puede realizar una
aproximación
de
sus
preferencias basándose en los
siguientes
criterios:
Básicos, Principales, Técnicos
y de Interfaz de Usuario
V.I
Comparativa de los SDKs de
Android y Symbian OS
Para realizar el análisis de un
SDK no es suficiente el
describir sus características de
manera teórica, es necesario el
desarrollar aplicaciones en el
aspecto práctico para obtener
una visión más clara
Indicadores
Técnicas y/o Instrumentos
Criterios básicos:
Textos
seleccionados,
Características principales de Bibliografía especializada y
cada Tienda, Modelo de encuestas
ingresos monetarios de cada
tienda, Posición en el
mercado
mundial
y
Estadísticas de las tiendas en
línea.
Criterios Principales:
Portabilidad,
Fiabilidad,
Conectividad, Tamaño del
Kernel,
Seguridad
y
Características especiales
Criterios Técnicos:
Administración de energía y
Multitarea
Criterios de Interfaz de
usuario:
División entre el sistema
operativo e interfaz de
usuario y Personalización
Plataformas Android y Requerimientos del sistema Textos
seleccionados,
Symbian OS
Ciclos de vida de las experimentación
Aplicaciones
Librerías
Almacenamiento persistente
de datos
Manejo de eventos
Fuente: Antonio Rodríguez
165
3.4INSTRUMENTOS DE RECOLECCIÓN DE DATOS
Las técnicas de recolección de datos que se aplicarán en la investigación de este
proyecto son:
Documentales
Lectura científica.- para formar conocimientos relativos al tema de estudio se
utilizarán como instrumentos para obtener información la Internet, además de
la extensa bibliografía que se detalla más adelante en este documento.
De campo
La observación directa.-técnica utilizada para comprobar a través del
desarrollo de aplicaciones el funcionamiento y las características de los
componentes que nos brinda la plataforma Android.
La encuesta.-esta técnica se utilizará para tener principalmente una
perspectiva sobre las plataformas que utilizan los desarrolladores, lo que
conlleva a conocer la apertura que tienen en nuestro mercado. Como
instrumento se desarrollará un pequeño cuestionario de preguntas.
166
3.5PROCEDIMIENTOS DE LA INVESTIGACIÓN
El problema:
Ubicación del problema en un contexto
Situación conflicto nudos críticos
Causas y consecuencias del problema
Delimitación del problema
Formulación del problema
Evaluación del problema
Objetivos de la Investigación
Justificación o importancia de la investigación
Marco teórico:
Antecedentes del estudio.
Fundamentación teórica.
Fundamentación legal.
Hipótesis.
Listado y definición de las variables de la investigación.
Metodología:
Diseño de Investigación (Tipo de Investigación)
Población y Muestra
167
Resultado de la encuesta realizada
Instrumentos de recolección de datos
Operacionalización de variables, dimensiones e indicadores
Resultados de la encuesta realizada
Análisis comparativo del sistema operativo Android, Symbian OS y Windows Mobile
Listado de personas: Aplicación implementada utilizando el SDK de Android y el
SDK de Symbian OS
3.6RECOLECCIÓN DE LA INFORMACIÓN
Para obtener la información que ayudará a desarrollar el tema planteado se utilizarán
las técnicas que ya fueron mencionadas en el tópico “instrumentos de recolección de
datos”.
Para el caso de la encuesta dirigida a los desarrolladores de aplicaciones móviles de
Guayaquil, se contactará con las personas que forman parte de la muestra y se les
entregará el documento que posteriormente será tabulado.
3.7PROCESAMIENTO Y ANÁLISIS
Para realizar el análisis de los resultados del procesamiento de datos cuando sea
conveniente se seguirán los siguientes pasos:
168
Revisión de los instrumentos aplicados.
Tabulación de datos obtenidos
Diseño y elaboración de cuadros estadísticos con los resultados anteriores.
Elaboración de gráficos
3.8RESULTADO DE LA ENCUESTA REALIZADA
Pregunta 1:¿Con cuál de las siguientes plataformas ha desarrollado aplicaciones para
teléfonos celulares inteligentes?
Posibles respuestas: Symbian OS, Android, Blackberry, Windows Mobile, iPhone
Respuesta encuestados
Encuestado
Symbian
OS
1
2
3
4
5
Android
Blackberry
Windows
Mobile
x
x
iPhone
x
x
x
x
x
x
x
Tabulación
Symbian
OS
Android
Blackberry
Windows
Mobile
iPhone
2
0
2
5
0
169
GRÁFICO NO. 35
ENCUESTA: PLATAFORMAS OBJETIVO PARA EL DESARROLLO DE
APLICACIONES
5
4
3
2
1
0
Symbian OS
Android
Blackberry
Windows
Mobile
iPhone
Conclusión.- Todas las personas encuestadas han desarrollado para Windows
Mobile, mientras que en el otro extremo ninguno ha desarrollado aún para Android.
Pregunta 2: Tiene conocimiento sobre la plataforma para dispositivos móviles
"Android"
Posibles respuestas: Si, No, Poco
Encuestado
Si
1
2
3
4
5
X
No
X
X
X
X
Poco
170
Tabulación
Si
No
Poco
2
3
0
GRÁFICO NO. 36
ENCUESTA: NIVEL DE CONOCIMIENTO SOBRE ANDROID
4
3
2
1
0
Si
No
Poco
Conclusión.- A pesar de que Android aún no ingresa con fuerza en el mercado
podemos ver que si existe un conocimiento y expectativa sobre la plataforma.
Pregunta 3: Ordene de manera ascendente las características más importantes que
ud. considera debe brindar una plataforma para teléfonos inteligentes
Respuestas a ordenar: Seguridad, eficiencia, tiempos de respuestas óptimos, accesos
al hardware del dispositivo, soporte multimedia
171
Encuestado
Seguridad
Eficiencia
Tiempos de
respuestas
óptimos
Soporte
multimedia
1
Acceso al
hardware
del
dispositivo
2
1
5
4
2
2
1
3
4
5
3
4
3
2
1
5
4
2
1
3
5
4
5
5
4
1
2
3
3
GRÁFICO NO. 37
ENCUESTA: ORDEN DE IMPORTANCIA DE LAS CARACTERÍSTICAS
QUE DEBE POSEER UNA PLATAFORMA PARA TELÉFONOS
INTELIGENTES
6
5
4
Encuestado 1
3
Encuestado 2
2
Encuestado 3
1
Encuestado 4
Encuestado 5
0
Seguridad Eficiencia Tiempos de Acceso al Soporte
respuestas hardware multimedia
óptimos
del
dispositivo
Conclusión.- Como se puede apreciar en la gráfica existe diversidad de criterios
respecto al orden de importancia que le da cada encuestado a las diferentes
características que debe poseer un sistema operativo para teléfonos inteligentes. Se
puede concluir mencionando que Android está diseñado para proporcionar todas estas
características en conjunto con los dispositivos en los que se ejecuta.
172
Pregunta 4: Según su criterio: ¿Cuál es el futuro de los dispositivos móviles,
especialmente de los teléfonos inteligentes?
1. Se va a tender al cloud computing accedido desde smartphones.
2. La conectividad y transparencia a varios dispositivos de manera transparente
ya sea cualquiera su operadora.
3. Tendrán más aceptación mientras se siga innovando en tecnología como en la
actualidad, ya que su uso en la vida diaria es imprescindible.
4. Pues el futuro ya lo estamos viviendo porque este se ha convertido como
nuestra única herramienta en todas las áreas en la que se desenvuelve un ser
humana iniciando en lo personal pasando por lo familiar y terminado en lo
profesional, se puede decir que hoy en día una persona que no use para nada
un teléfono es alguien que no aporta mucho a la sociedad.
5. El futuro es muy bueno con la llegada de teléfono con oficina móvil, da más
agilidad en las tareas diarias de los ejecutivos y estar conectado a la red un
24x7.
Conclusión: El futuro de la los teléfonos inteligentes es la computación ubicua.
173
3.9ANÁLISIS COMPARATIVO DEL SISTEMA OPERATIVO ANDROID,
SYMBIAN OS Y WINDOWS MOBILE
3.9.1 Criterios básicos
3.9.1.1 Comparativa de los merados de aplicaciones móviles
Las tiendas de aplicaciones móviles, MAS por sus siglas en inglés – Mobile
Application Store -
son tiendas en línea donde los usuarios pueden descargar
aplicaciones para sus teléfonos móviles. Este mercado constituye un flujo de ingresos
muy rentable para las empresas propietarias de las plataformas y a su vez para los
desarrolladores de las aplicaciones.
3.9.1.1.1 Tiendas de Aplicaciones Móviles
Ovi de Nokia
Ovi es el nombre del "concepto paraguas" de Nokia para sus servicios
en Internet. Basado en un servicio de escritorio personal ofrece un panel
personalizado donde los usuarios pueden compartir fotos con sus amigos,
comprar música, acceder a servicios de terceros como el sitio de
fotos Flickr de Yahoo, y por supuesto adquirir aplicaciones para sus móviles.
174
Android Market
Android Market es un sistema de distribución open source y de contenido
abierto que le permite a los consumidores buscar, comprar, bajar e instalar
diversos tipos de contenido como juegos, música, noticias, mapas, etc.
Los desarrolladores pueden hacer que sus aplicaciones estén disponibles en
estaplataforma que tiene características similares de retroalimentación y del
sistema de calificación de YouTube mediante tres pasos básicos:
1. Registrarse como desarrollador en el sitio
2. Subir las aplicaciones y describirlas de manera detallada
3. Publicarlas para que sean visibles por los usuarios finales
Windows MarketPlace for Mobile
Windows Marketplace for Mobile es un servicio de Microsoft para su
plataforma Windows Mobile que permite a los usuarios navegar y descargar
aplicaciones que han sido desarrollados por terceros. La aplicación está
disponible para utilizar directamente en los dispositivos Windows Mobile 6.5,
y en los ordenadores personales. Se anunció en el evento “Mobile World
Congress 2009”, y entró en funcionamiento el 6 de octubre del mismo año,
con un número inicial de 246 aplicaciones.
175
CUADRO NO. 7
CARACTERÍSTICAS PRINCIPALES DE CADA TIENDA
Fuente: Research2Guidance, reporte de febrero del 2010: “Smartphone Application
Store
Comparison”.http://www.docstoc.com/docs/33502524/Mobile-Application-Store-Comparison-Tables
CUADRO NO. 8
MODELO DE INGRESOS MONETARIOS DE CADA TIENDA
Fuente: Research2Guidance, reporte de febrero del 2010: “Smartphone Application
Store
Comparison”. http://www.docstoc.com/docs/33502524/Mobile-Application-Store-Comparison-Tables
176
3.9.1.1.2 Posición en el mercado mundial
Si nos fijamos en el Cuadro No. 8 se puede observar que durante el primer cuarto del
año 2010 Symbian OS continúa como líder del mercado mundial de teléfonos
inteligentes y Android se ubica en la cuarta posición por delante de Windows Mobile,
pero si analizamos las cifras comparadas con el mismo lapso de tiempo del año
anterior se puede deducir que el único sistema operativo que ha tenido un aumento en
las preferencias de los usuarios finales es Android, tanto así que hasta el año pasado
se ubicaba en el quinto lugar y hoy ha logrado escalar una posición.
CUADRO NO. 9
VENTAS DE TELÉFONOS INTELIGENTES POR SISTEMA OPERATIVO
(EN MILES)
Compañía
Symbian
Research In Motion
iPhone OS
Android
Microsoft Windows Mobile
Linux
Otros SO
Total
Primer cuarto 2010
Porcentaje
Unidades
del
mercado
24,069.8
44.3
10,552.6
19.4
8,359.7
15.4
5,214.7
9.6
3,706.0
6.8
1,993.9
3.7
404.8
0.7
54,301.4
100.0
Elaboración: Traducido de la fuente
Fuente: Gartner, reporte de mayo del 2010
Primer cuarto 2009
Porcentaje
Unidades
del
mercado
17,825.3
48.8
7,533.6
20.6
3,848.1
10.5
575.3
1.6
3,738.7
10.2
2,540.5
7.0
445.9
1.2
36,507.4
100
177
3.9.1.1.3 Estadísticas de las tiendas en línea
GRÁFICO NO. 38
PROPORCIÓN DE APLICACIONES PAGADAS VS LAS GRATUITAS
Fuente: Distimo39, reporte junio del 2010: “Apple App Store, BlackBerry App World, Google
Android Market,Nokia Ovi Store, Palm App Catalog and Windows Marketplace”
Google Android Market tiene el mayor número de aplicaciones gratuitas (57%) y
Windows Marketplace for Mobile tiene el menor número (22%). Este número
elevado en las cifras de Google Android Market puede estar influenciado porque
hasta el momento solo desarrolladores de 9 países están autorizados para cobrar por
sus aplicaciones.
39
Distimo es una compañía dedicada al análisis de las tiendas de aplicaciones y el mercado en que se
desenvuelven. Fuente: http://www.distimo.com
178
GRÁFICO NO. 39
PRECIO PROMEDIO DE LAS APLICACIONES
Fuente: Distimo, reporte junio del 2010: “Apple App Store, BlackBerry App World, Google Android
Market,Nokia Ovi Store, Palm App Catalog and Windows Marketplace”
En cuanto al precio de las aplicaciones pagadas se puede apreciar en la gráfica que las
aplicaciones más baratas son las desarrolladas para dispositivos Nokia (Symbian OS)
y son distribuidas a través de su tienda en línea Ovi.
3.9.1.1.4 Participación de las empresas fabricantes de equipos en el mercado de
teléfonos inteligentes
Kevin Restivo, analista senior de IDC en la publicación de mayo del presente año
lista las empresas que mayor participación poseen en el mercado mundial de los
dispositivos inteligentes durante el primer cuarto del 2010:
179
En primer lugar de preferencia de los usuarios Nokia se mantiene como el
proveedor líder en todo el mundo. Además de la introducción de varios
nuevos modelos, Nokia anunció su primer modelo Symbian ^ 3, el N8.
En segunda posición se encuentra Research In Motion, ser el proveedor
número dos en todo el mundo se debe alcontinuo crecimiento de su popular
dispositivo BlackBerry. La clave de su éxito fueron su BlackBerry Curve
8520 y BlackBerry Bold 9700, los cualestuvieron una fuerte acogida por parte
de los desarrolladores. Recientemente la compañía dio a conocer su nuevo
sistema operativo, el BlackBerry 6.0, que promete una interfaz de usuario más
suave y más interactiva.
Apple ha
duplicado sus ventas
en comparación hace un año, es más,
recientementese presentó la actualización del sistema operativo, el que
permite realizar múltiples tareas, correo electrónico mejorado, iBooks para los
consumidores, y el iAd, una plataforma de publicidad móvil, para los
desarrolladores.
HTC registró un crecimiento de dos dígitos altos para comenzar el año,
impulsados principalmente por su estable crecimiento de los productos con
Android como el héroe. La empresa no muestra signos de ralentización,
180
después de haber anunciado varios nuevos dispositivos, incluyendo el primer
teléfono WiMAX Android, el EVO 4G, que empezará a finales de este año.
Motorola, que remontó en el espacio de teléfonos móviles en el cuarto
trimestre de 2009, siguió con un nuevo hito en su corta historia de la
navegación dispositivos Android. Ahora que el DROID y CLIQ (conocido
como el Milestone y DEXT, respectivamente, fuera de los Estados Unidos)
tienen un cuarto lleno de disponibilidad, la empresa siguió con seis
dispositivos adicionales. La compañía espera lanzar 20 modelos nuevos de
Android durante este año.
3.9.2 Criterios principales
Para realizar esta comparación cada sistema operativo será evaluado numéricamente,
al final de cada evaluación se otorgará un punto al primer lugar, que es el sistema
operativo que cumpla con la mayoría de los requisitos, medio punto para el segundo
lugar y cero puntos para el que se encuentra en último lugar. Cuando se haya cubierto
cada uno de los aspectos se realizará una conclusión donde se visualizarán a manera
de resumen el resultado de cada uno de los criterios evaluados. El número de puntos
mostrará qué sistema operativo es "el mejor" en comparación con los demás.
181
3.9.2.1 Portabilidad
Symbian OS es un sistema operativo que se utiliza en una gran cantidad de teléfonos
inteligentes y sobre todos en equipos Nokia, gracias a que su arquitectura es
estandarizada. Además, una ventaja la constituye el hecho de que la compañía
convirtiese la plataforma en un producto opensource, del otro lado, el hecho de que
sus aplicaciones no sólo pueden ser creadas utilizando el lenguaje Java lo ponen por
detrás de Android.
Windows Mobile también se puede ejecutar en diferentes plataformas con diferentes
características. Lamentablemente Windows Mobile también tiene varias aplicaciones
que son específicas del hardware, y por lo tanto no es portable.
La plataforma Android es un sistema basado en Linux y tiene la gran ventaja de que
este sistema operativo puede utilizarse en diferentes plataformas. El acceso abierto
ayudará a recopilar una gran cantidad de experiencia que le será más fácil en el futuro
para acceder a otras secciones. El hecho de que Android es basado en el estándar de
programación de lenguaje Java, que también se utiliza para la aplicación desarrollo,
subraya la importancia de la conservación para esta plataforma.
Como resultado Android consigue un punto, el sistema operativo Symbian OS recibe
medio punto y Windows Mobile cero puntos.
182
Total hasta el momento: Symbian OS = 0.5
Windows Mobile = 0
Android = 1
3.9.2.2 Fiabilidad
Un factor determinante a la hora de estimar si un sistema operativo móvil es confiable
lo constituye el tiempo que se encuentra en el mercado, claro que esto no significa
que los dispositivos nunca presentan fallas, sino que permite conocer el grado de
estabilidad en que se encuentran.
Symbian OS y Windows Mobile ya tienen un tiempo considerable en el mercado,
ambas plataformas son estables. Por el otro lado se encuentra Android, aunque su
ingreso al mercado de los dispositivos móviles es reciente cuenta con el respaldo de
trabajar con un kernel basado en Linux, y este ya ha existido durante más de una
década y ha demostrado que es estable y muy confiable.
Estudios demuestran que los sistemas operativos basados en Linux tienen un 99.9 %
de fiabilidad, ya que tienen un rango de “fuera de línea o servicio” que oscila entre 30
minutos y una hora al año, mientras que los sistemas operativos basados en Microsoft
Windows tienen cerca de 5 horas al año que están fuera de línea o servicio.
Hoy en día se emplea con frecuencia en servidores web o aplicaciones similares que
requieren un alto grado de fiabilidad. Con estas premisas me atrevo a decir que
183
Android no se ubicará detrás de Symbian OS y Windows Mobile en cuanto a
fiabilidad.
Debido a que el sistema operativo Symbian y Windows Mobile controlan la mayor
parte del mercado y Android es Basado en Linux voy a dar a cada sistema operativo
un punto, ya que las diferencias desde mi punto de vista no son considerables.
Total hasta el momento: Symbian OS = 1,5
Windows Mobile = 1
Android = 2
3.9.2.3 Conectividad
Sabemos que todo teléfono inteligente puede interactuar con otros equipos para el
intercambio de información y que aunque siempre tenemos la opción de utilizar un
cable como medio para alcanzar este propósito, con el tiempo las preferencias de los
usuarios cambian y la necesidad de movilidad
requiere de mecanismos que
proporcionen una conexión inalámbrica, justo la comparativa se va a centrar en los
mecanismos que cada sistema operativo móvil nos proporciona.
La conexión inalámbrica puede ser de área amplia, como la conexión a Internet, o de
área personal que incluye infrarrojos y enlaces bluetooth. El sistema operativo debe
constar de las aplicaciones que están diseñadas para soportar todos los requisitos, así
como multitareas y los protocolos de comunicación más importantes. También tiene
184
que proporcionar un rico conjunto de API, que son interfaces de código fuente para
apoyar las solicitudes de servicios que deben figurar en ella, para garantizar que las
aplicaciones puedan beneficiarse plenamente de las posibilidades de conectividad
actuales y facilitar su adaptación al sacar provecho de nuevos protocolos como su
aplicación.
Symbian OS tiene funciones de telefonía GSM, Bluetooth, infrarrojos y WI-FI. EL
API del sistema operativo Symbian permite un desarrollo que se dirige a todas estas
características y categorías.
Windows Mobile cuenta con tecnología GSM, Bluetooth, Infrarrojos y WI-FI, por lo
que su API proporciona a los desarrolladores capacidades para trabajar con cada una
de estas tecnologías.
Android posee funciones de telefonía GSM, Bluetooth, EDGE (técnica para aumentar
la velocidad de datos en GSM Mobile de red), 3D (normas móviles de tercera
generación), y WI-FI, desde el punto de vista de las comunicaciones corporativas y
empresariales Android posee dispositivos preparados para redes de datos
HSDPA/WCDMAlo que le confiere una clara ventaja competitiva. Todos los
desarrolladores tienen el mismo acceso al marco de las API utilizado por las
aplicaciones principales.
185
Sistema
Operativo
Android
Symbian
OS
Windows
Mobile
Bluetooth
EDGE
GSM
3D
Wi-Fi
Infrarrojos
X
X
X
X
X
X
X
X
X
X
X
X
X
Cabe recalcar que Android tiene algunas ventajas en cuanto a conectividad en
comparación con los otros dos sistemas operativos, por lo que se le otorgara a
Android 1 punto y a los otros dos sistemas medio punto cada uno.
Total hasta el momento: Symbian OS = 2.
Windows Mobile = 1.5
Android = 3
3.9.2.4 Tamaño del Kernel
Un factor de evaluación de uso frecuente para comparar el tamaño del Kernel es el
“footprint“, que es la cantidad de memoria utilizada por el sistema operativo. Para
una clasificación significativa tenemos que encontrar el sistema operativo con el
menor impacto de "footprint" que a su vez maximiza el rendimiento del sistema
operativo.
186
Cantidad de Memoria
Mínima
Android
Symbian
250 KB
200 KB
Windows
Mobile
300 KB
Todos los datos anteriores se aplican a una instalación con las funciones básicas y
mínimas posibles. Como resultado Symbian OS necesita menos memoria que la que
Android necesita, así mismo Android necesita menos memoria que Windows Mobile.
Así
consigue
un
punto
Symbian,
Android
consigue
medio
punto
y
Windows Mobile cero puntos.
Total hasta la fecha: Symbian OS = 3.5
Windows Mobile = 2
Android = 3.5
3.9.2.5 Seguridad
Symbian OS ofrece una nueva plataforma de arquitectura de seguridad la cual
proporciona una plataforma con la capacidad de defenderse contra los programas
maliciosos o mal aplicados. La arquitectura consta de dos componentes de alto nivel:
"Gestión de certificados" y "Criptografía". Estos dos módulos constituyen la base de
una serie de componentes de alto nivel que incluyen el control de Gestión de
certificados de elemento del panel, instalación de software y comunicaciones seguras.
Windows Mobile también tiene su propio modelo de seguridad. Contiene una
combinación de políticas de seguridad, roles y certificados a la dirección de
configuración, acceso remoto y ejecución de la aplicación.
187
Android es un sistema multiproceso, donde cada aplicación (y partes del sistema)
funciona como su propio proceso. La mayoría de la seguridad entre las aplicaciones y
el sistema se aplica en el nivel de proceso a través de estándares de los servicios de
Linux, tales como identificadores de usuario y grupo que se asignan a las
aplicaciones. Otros elementos de seguridad de segundo plano, se proporcionan a
través de un "permiso", mecanismo que fuerza las restricciones en las operaciones
específicas que un proceso determinado puede realizar.
El sistema de seguridad de Android está diseñado para impedir que las aplicaciones
se interrumpan entre sí, excepto por los permisos que se declaran de forma explícita
que necesitan para capacidades adicionales no previstas por el recinto de seguridad de
base. El sistema maneja las solicitudes de permisos de diversas maneras,
normalmente de forma automática permitiendo o rechazando sobre la base de los
certificados o preguntando al usuario. Los permisos necesarios por la aplicación se les
declara estáticamente en esa solicitud, por lo que se puede conocer por adelantado en
el momento de la instalación y no va a cambiar después de eso.
Cada plataforma tiene su propio modelo de seguridad que cubre las acciones más
importantes relativas a la instalación de software, la comunicación segura, etc. Esto
los hace iguales y los resultados en un punto para cada sistema operativo.
Total hasta el momento: Symbian OS = 4.5
Windows Mobile = 3
Android = 4.5
188
3.9.2.6 Características especiales
Esta sección trata de las funciones o aplicaciones que están diseñadas para hacer que
el sistema sea único.
Windows Mobile tiene, debido a su destacada posición en el mercado de las
computadoras, la ventaja de que la sincronización entre el PC y el teléfono celular es
muy fácil. Symbian OS sin embargo, en mi opinión, no tiene ninguna característica
especial que debe ser mencionada. La comunicación con el Internet y el ordenador
personal desempeñará un papel importante en el futuro con respecto a las plataformas
móviles.
La plataforma móvil Android tiene ventajas significativas en este caso. El nuevo
navegador integrado, basado en el motor WebKit de código abierto permite acceder a
páginas web a través de Internet del mismo modo que a través de la PC. También la
máquina virtual Dalvik optimizada para dispositivos móviles, es una característica
que permite a cada aplicación ejecutarse en su propio proceso. Esto es muy
importante para la estabilidad y fiabilidad.
El punto más fuerte de Android es su Plataforma de Código Abierto. La comunidad
de software abierto es una de las mayores comunidades que han liderado la industria
y su presencia hace que la tecnología sea mejor. Android está basado en el kernel de
189
Linux mientras que Windows Mobile está basado en Windows CE. La plataforma
abierta garantiza la innovación continua y la equidad en el producto. Grandes grupos
de apoyo siempre estarán presentes para ayudar a los clientes a entender sus
problemas y darles soluciones a los mismos.
3.9.3 Clasificación basada en otros criterios
Esta sección contiene una lista con otros criterios que ayudan a clasificar las tres
plataformas móviles que estamos analizando. Dividí los criterios en 2 grupos
diferentes que son "criterios técnicos" y "criterios de interfaz de usuario". El usuario
puede utilizar estas para personalizar su elección de un sistema operativo para su
dispositivo móvil.
3.9.3.1 Criterios técnicos
Android
Symbian OS
Windows Mobile
Administración de energía
X
X
X
Multitarea
X
X
X
3.9.3.2 Criterios de interfaz de usuario
División entre el sistema operativo
y la interfaz de usuario
Android
Symbian OS
Windows
Mobile
Si
Si
Si
190
Personalización
Posible
Casi Imposible
Casi Imposible
Conclusión
En este capítulo la plataforma Android, Symbian OS y Windows Mobile se
compararon con respecto a los criterios principales para un sistema operativo para
móviles. Cada criterio se explica en detalle y se aplica a los tres sistemas operativos.
Al final de cada criterio de clasificación se les dio un puntaje de uno a cero. El mejor
sistema operativo en relación con el criterio tiene un punto, el segundo consiguió
medio punto y el tercero tiene cero puntos. La suma total de puntos añadidos para
cada sistema operativo mostrará cuál de ellos es el "mejor" en relación con los
criterios principales.
La siguiente tabla muestra detalladamente los resultados:
CUADRO NO. 10
RESULTADO COMPARATIVA CRITERIOS PRINCIPALES
Android
Symbian OS
Windows Mobile
Portabilidad
1
0,5
0
Confiabilidad
1
1
1
Conectividad
1
0,5
0,5
0,5
1
0
1
1
1
Tamaño del Kernel (Núcleo)
Seguridad
191
Características Especiales
Resultado
1
0
0,5
5,5
4
3
En cuanto a los criterios principales de la nueva plataforma móvil Android consigue
más puntos. Es el único verdaderamente "sistema abierto" que hace la gran diferencia
en mi opinión. También la característica especial como el navegador de Internet y la
máquina virtual Dalvik desempeñan un papel importante en esta comparación.
Normas en la conectividad, portabilidad y seguridad son más o menos logrados por
todos los sistemas operativos de la misma manera. Con respecto a los criterios
técnicos como administración de energía y multitarea los tres sistemas operativos
tienen un buen desempeño, y en base a los criterios de interfaz de usuario Android es
mucho más abierto en cuanto a personalización.
Como nos podemos dar cuenta Android tiene muchas más características que lo
hacen ver como el sistema operativo ideal para nuestros teléfonos móviles.
192
3.10LISTADO
DE
PERSONAS:
APLICACIÓN
IMPLEMENTADA
UTILIZANDO EL SDK DE ANDROID Y EL SDK DE SYMBIAN OS
Para realizar el análisis de un SDK no es suficiente el describir sus características de
manera teórica, es necesario el desarrollar aplicaciones en el aspecto práctico para
obtener una visión más clara.
3.10.1 ¿Por qué comparar Symbian OS y Android mediante la creación de una
aplicación?
La razón por la que escogí Symbian OS para realizar la comparación con Android es
que ambos productos proporcionan la misma funcionalidad, operan en el mismo
mercado y están dirigidos al mismo grupo objetivo de consumidores.
Otra razón para realizar la comparativa con Symbian OS es la posibilidad de
desarrollar aplicaciones móviles utilizando Java 2 Micro Edition (J2ME), que es el
ambiente de desarrollo de Java para aplicaciones que se ejecutan en dispositivos
móviles. Al igual que en Android, Symbian utiliza Java debido a la posibilidad de
crear un único programa portable a muchos dispositivos con características de
hardware diferentes.
193
3.10.2 Requerimientos del sistema para instalar los SDKs respectivos
Ninguno de los SDKs necesita de características adicionales del equipo en donde se
está desarrollando la aplicación para poder ejecutarlos. Entre las principales
diferencias que existen entre ambos SDKs tenemos:
El SDK de Android se puede ejecutar en una computadora con un procesador
más lento y con menor requerimiento de memoria.
Ambos necesitan de Java, específicamente el entorno de ejecución de Java
versión 5 o superior. Sin embargo, para poder finalizar la instalación del SDK
de Symbian OS es necesario instalar un paquete adicional que contenga el
programa Perl.
El SDK de Android se puede instalar en la mayoría de los sistemas operativos
más utilizados por los usuarios: Windows, Mac y Linux, mientras que el SDK
de Symbian OS sólo se puede instalar en una computadora que tenga como
sistema operativo Windows.
A continuación se muestran dos cuadros comparativos entre los SDKs de Android y
Symbian O.S, el primero de ellos nos proporciona información sobre los
requerimientos mínimos de hardware necesarios para poder instalar los SDKs,
mientras que el segundo proporciona información de los requerimientos de software.
194
CUADRO NO. 11
REQUERIMIENTOS MÍNIMOS DE HARDWARE PARA INSTALAR LOS
SDK
Android
S60
200 MHz
1 GHz (Requerimiento
mínimo del IDE y el
sistema
operativo:
Procesador de 500 MHz)
Memoria
32 MB RAM y 32 MB Flash
512
MB
RAM
(Requerimiento mínimo
del IDE y el sistema
operativo: 128 MB)
Espacio libre en
disco duro
600MB para el paquete base
del SDK
2 GB
Procesador
CUADRO NO. 12
REQUERIMIENTOS MÍNIMOS DE SOFTWARE PARA INSTALAR LOS
SDK
Sistemas
operativos
Android
Windows XP o Vista
Mac OSX 10.4.8 o superior
(Sólo arquitectura X86)
Linux
JDK 5 ó JDK 6
S60
Microsoft Windows 2000 SP4
Microsoft Windows XP SP2
Microsoft Windows Vista
Java Runtime Versión 1.5.0 o
superior
Software adicional
Active Perl Versión 5.6.1 o
superior
Eclipse 3.2 o superior, plugins Eclipse 3.2 o superior y
JDT, WST y ADT
EclipseME versión 1.7.7 o
Herramientas de
superior
desarrollo
Apache Ant 1.6.5 o superior
NetBeans IDE con el paquete
de movilidad 5.5 o superior
195
3.10.3 Instalación
Previamente en este documento se describió el proceso de instalación y configuración
de Android.
Para configurar el entorno de desarrollo de aplicaciones para Symbian OS se
necesitan Eclipse como el IDE de desarrollo, el entorno de ejecución de Java (JRE:
Java Runtime Environment) y Active Perl. Las siguientes versiones de las
herramientas
mencionadas
anteriormente
son
las
más
utilizadas:
Symbian SDK: S60 3 era. Edición
JRE: jre1.6.0_01
Eclipse: Eclipse 3.3.2
Plugin para Eclipse: EclipseME
Active Perl: versión 5.6.1
Symbian ofrece diferentes tipos de SDK en función del teléfono celular.
1. UIQ (User Interface Quartz).- desarrollada por UIQ Technology y usada
principalmente por Sony-Ericsson y Motorola.
196
2. MOAP (Mobile Oriented Applications Platform).- usada por algunos
móviles 3G de NTT-Docomo.
3. La plataforma S60 (Serie 60 User Interface).- se encuentra actualmente
entre las plataformas para smartphone más utilizadas en el mundo y la
cual va a ser objeto de comparación en este estudio.
Adicionalmente Symbian está trabajando en sus SDK para la Serie 80 y Serie 90 de
sus dispositivos.
3.10.4 Descripción de la aplicación
Para una comparación útil en el proceso de desarrollo se ha realizado una pequeña
aplicación que corre de igual manera en ambas plataformas y que hace uso de las
principales funcionalidades que nos facilitan los SDKs. Los criterios a ser evaluados
consisten en:
Interfaz de usuario
Visualización de información
Ingreso de información
Manejo de eventos
Almacenamiento persistente de datos
197
Listado de personas es una aplicación que nos permite manipular información básica
de las personas, realizar ingresos, consultar y eliminar su información.
Las siguientes imágenes muestran como se visualiza la aplicación para cada una de
las plataformas:
Al iniciar la aplicación por primera vez se presentará la pantalla sin información, sólo
mostrando el título de la misma, en este caso “Listado de Personas”.
GRÁFICO NO. 40
ANDROID: PANTALLA INICIAL
GRÁFICO NO. 41
SYMBIAN OS: PANTALLA INICIAL
Para ambos casos se ha implementado un menú de opciones dotado de cuatro
acciones: Agregar persona, Mostrar datos, Eliminar persona y Salir. Para el caso de
Symbian OS el primer elemento del menú se presenta de manera automática en la
pantalla por lo que opté en colocar primero el botón de salir.
198
GRÁFICO NO. 42
ANDROID: MENÚ DE OPCIONES
GRÁFICO NO. 43
SYMBIAN OS: MENÚ DE OPCIONES
La opción de agregar persona como su nombre lo indica, permite ingresar un nuevo
registro con información de la persona y guardarlo utilizando el mecanismo de
almacenamiento persistente de cada una de los SDK.
GRÁFICO NO. 44
GRÁFICO NO. 45
ANDROID: AGREGAR PERSONA SYMBIAN OS: AGREGAR PERSONA
199
En caso de no cumplir con alguna de las validaciones establecidas la aplicación
mostrará por pantalla un mensaje alertando el problema ocurrido.
GRÁFICO NO. 46
ANDROID:
CUADRO DE DIÁLOGO
GRÁFICO NO. 47
SYMBIAN OS:
CUADRO DE DIÁLOGO
Para mostrar el contenido completo de la información de cada persona ingresada se
deberá seleccionar la misma en la lista que se presenta y dar clic en la opción del
menú “Mostrar datos”.
´
200
GRÁFICO NO. 48
ANDROID: MOSTRAR DATOS
GRÁFICO NO. 49
SYMBIAN OS: MOSTRAR DATOS
Finalmente tenemos la opción de “Eliminar persona” que permite eliminar la persona
seleccionada de la lista y del almacenamiento persistente de datos.
3.10.5 Ciclo de vida de una aplicación en Android y Symbian OS
El ciclo de vida de una aplicación en Android es controlado en su mayor parte por el
sistema, y al igual que el ciclo de vida de una actividad (tema tratado anteriormente
en este documento) una aplicación es creada, los procesos que ejecuta son iniciados,
los eventos disparados, cuando corresponde
aplicación es destruida.
los procesos son detenidos y la
201
En cambio, el modelo de desarrollo de aplicaciones ampliamente utilizado en la
plataforma S60 se basa en MIDlets. Un MIDlet (nombre que recibe una aplicación
MIDP -Mobile Information Device Profile- para continuar con el esquema usado para
denominar los applets y los servlets) es un programa en Java que hereda de la clase
abstracta MIDlet ubicada en el paquete javax.microedition.midlet.
Los MIDlets tienen un ciclo de vida específico, que se refleja en los métodos y el
comportamiento de esta clase, la misma que puede pasar por los siguientes estados:
Cuando un MIDlet está a punto de ser ejecutado se crea una instancia del
mismo. El constructor se ejecuta y el MIDlet queda en estado pausado.
Cuando el administrador de la aplicación llama el método startApp(), el
MIDlet cambia al estado de activo.
Mientras el MIDlet se encuentre activo el administrador de la aplicación
puede suspender su ejecución invocando el método pauseApp(). Un MIDlet
puede ponerse a sí mismo en estado de pausa utilizando el método
notifyPaused().
Como es de suponerse el administrador de la aplicación puede cambiar de este
último estado a activo invocando el método startApp().
Finalmente el administrador de la aplicación puede terminar la ejecución del
MIDlet llamando al método destroyApp(). Una aplicación puede destruirse a
sí misma invocando el método notifyDestroyed().
202
GRÁFICO NO. 50
CICLO DE VIDA DE UNA APLICACIÓN EN SYMBIAN
constructor
destroyApp()
Pausado
startApp()
pauseApp()
Ciclo de Vida de un MIDlet
Activo
destroyApp()
Destruido
Elaborado por: Antonio Rodríguez
Fuente: Libro Beginning J2ME: From Novice to Professional, pag. 30
Análisis: En la figura se presentan los estados por los que puede pasar una aplicación en Symbian OS
durante su ciclo de vida
3.10.6 APIs
Los APIs de Android ya fueron descritos anteriormente en este documento, por lo
tanto haré una pequeña descripción del API incluido en el SDK de Symbian OS.
MIDP provee de la funcionalidad base requerida para el desarrollo de una aplicación
móvil. Incluye la interfaz de usuario, conexiones de red, almacenamiento de datos y
administración del ciclo de vida. Toda esta funcionalidad la proporciona el entorno de
ejecución de Java y un conjunto robusto de APIs.
203
MIDP utiliza los paquetes núcleos de CLDC (Connected Limited Device
Configuration): java.lang, java.io, java.util y javax.microedition.io, adicionando tres
paquetes:
1. javax.microedition.lcdui.- proporciona soporte para la creación de interfaces
de usuario.
2. javax.microeditions.midlet.- define aplicaciones MIDP y se encarga de
gestionar la interacción de las aplicaciones con el entorno en que se ejecutan.
3. Javax.microeditions.rms.- proporciona mecanismos para el almacenamiento y
la manipulación de datos de manera persistente.
Existen APIs adicionales que incrementan y mejoran las funcionalidades que se
pueden lograr programando MIDlets, sin embargo los descritos previamente son
relevantes ya que serán utilizados para realizar los ejemplos comparativos.
3.10.7 Comparación práctica de los APIs
3.10.7.1 Interfaz de Usuario: Presentación de elementos en una lista
Android
Para presentar una lista de elementos en la pantalla se necesitan las siguientes
clases:
204
android.app.ListActivity
android.widget.SimpleCursorAdapter
El código para implementar la lista es el siguiente:
El objeto personasCursor que se presenta en la línea 1 es de tipo cursor y
se llena con los elementos que devuelve el método obtenerPersonas() que
realiza la consulta a la base de datos.
Para presentar estos elementos en la vista, se debe crear un objeto del tipo
Adapter, tal como se aprecia en la línea 3, que recibe como parámetros el
contexto de la aplicación, el layout o contenedor que proporciona el
esquema de la interfaz de usuario a visualizarse, un arreglo de Strings que
indica el nombre de las columnas y un arreglo de enteros que identifican
los elementos (widgets) creados a través de un archivo XML.
205
Symbian OS
Para presentar una lista de elementos en la pantalla se necesitan las siguientes
clases:
javax.microedition.lcdui.List
javax.microedition.rms.RecordStore
javax.microedition.lcdui.Display
El código para implementar la lista es el siguiente:
En la línea 2 del código anterior se aprecia que se ha creado un arreglo de
caracteres para almacenar la información de las personas que devuelve el
método obtenerPersonas(). Adicionalmente en la línea 4 se crea un objeto
Display que será el encargado de mostrar la lista generada en la línea 5 en la
interfaz de usuario.
Conclusión
Presentar elementos en la GUI en forma de lista es un proceso sencillo, como
resultado de la comparación dos aspectos que le dan la ventaja a Android
206
corresponden primero, al hecho de que en esta plataforma se puede separar la
creación de la vista y la lógica que la maneja mediante el uso de archivos
XML. El segundo punto es que en Android no se requiere el recorrer la lista
elemento por elemento para obtenerlos.
3.10.7.2 Manejos de Eventos: Reaccionar al dar clic a una opción del menú
Android
Clases requeridas:
android.view.menu
android.view.menu.item
La codificación necesaria para la implementación de los menús comprende:
207
Los métodos onCreateOptionsMenu() y onMenuItenSelected() se ejecutan
automáticamente cuando la aplicación se inicia. El primero permite definir los
elementos del menú, en la línea 6 se puede observar que se ha creado la
opción de “Eliminar persona”. El segundo método contiene las acciones
definidas por el desarrollador y que se ejecutan cuando el usuario la
selecciona, para el ejemplo de eliminar a la persona, en la línea 10 se puede
comprobar que se hace el llamado al método eliminarPersona() para que
borre su información de la base de datos.
Symbian OS
Clases requeridas:
javax.microedition.lcdui.Command
javax.microedition.lcdui.CommandListener
208
El código para la creación de los menús es el siguiente:
Lo primero que se debe hacer para crear el menú de opciones en Symbian OS
es definir los objetos de tipo Command40, en la línea 1 se aprecia la creación
40
Un objeto command es algo que el usuario puede invocar, se puede pensar en él como un botón.
209
del objeto cmdEliminar, luego en el método startApp, que es un método
predefinido de un Midlet que se invoca cada vez que se ejecuta el mismo, se
agrega el nuevo elemento a la lista. Adicionalmente se debe agragar a un
CommandListener,
que
es
el
encargado
de
ejecutar
el
método
CommandAction cuando se presiona la opción “Eliminar persona”, esto se
puede visualizar en la línea 8. Finalmente, es en el método CommandAction
donde se especifican las acciones a ejecutar por cada opción del menú.
Conclusión
Los APIs de las dos plataformas proporcionan una manera estandarizada para
el manejo de los eventos, para el caso de Android se usa un manejador propio
de la actividad, en Symbian se utiliza un objeto del tipo Listener; pero en
ambos casos son ellos los que reaccionan automáticamente cuando el botón es
seleccionado.
3.10.7.3Ingreso de datos
Android
Para el ingreso de datos en Android se puede hacer uso de la clase:
android.widget.EditText
La codificación utilizada se muestra a continuación:
210
Archivo XML con la definición de los elementos de la pantalla:
Fragmento de código donde se atacha la vista con el onjeto en Java
Como ya se ha mencionado previamente en este estudio, en Android los
objetos de la interfaz gráfica generalmente se crean en un arhivo XML y son
utilizados en el lenguaje Java cuando el programa está en ejecución. En la
codificación utilizada se puede observar que el primer bloque corresponde al
archivo XML, en donde se hace referencia principalmente al objeto de tipo
EditText, al cual se le estableció como identificador la palabra “nombre”.
211
En el archivo java se crea un objeto del mismo tipo, tal como se aprecia en la
línea 1, y se lo atacha al elemento definido en el archivo XML mediante las
instrucciones escritas en la línea 5.
Symbian
En esta plataforma las clases requeridas para el ingreso de información
utilizadas en el ejemplo demostrativo son:
javax.microedition.lcdui.Form
javax.microedition.lcdui.TextField
El código desarrollado es el siguiente:
Para presentar un campo de ingreso de información se debe primero crear un
objeto del tipo Form, que define el marco de la ventana y sobre el cual se van
a presentar los elementos, en la línea 1 de la codificación se creó el objeto
frmPersona.
Luego, en la línea cuatro se creó un objeto TextField que se traduce como caja
de texto y que es el encargado de recibir la información. Para atachar este
212
objeto a la formacuando esta se pinta se lo realiza con el método append de la
clase Form.
Conclusión
Si nos fijamos en las líneas de código requeridas para el ejemplo en cada uno
de los APIs pareciera que en Android es más compleja la creación de un
campo de entrada. Sin embargo, el uso de un archivo XML permite tener una
mejor abstracción de programación en capas, que como ya se ha mencionado
antes puede resultar más beneficioso.
3.10.7.4 Almacenamiento persistente de datos
Android
Clases utilizadas:
android.database.sqlite.SQLiteDatabase
android.database.Cursor
213
A continuación se muestra la codificación utilizada para la gestión de la base
de datos y su interacción:
La base de datos SQLite incluida en el API de Android proporciona métodos
predefinidos para la administración de las típicas operaciones sobre la base.
Como se puede observar en la línea 3, para crear la base de datos del ejercicio
expuesto se invoca el método openOrCreateDatabase que recibe como
parámetros el nombre de la base, el modo de apertura y un objeto de tipo
214
Factory, que para el ejemplo es nulo. La sentencia execSQL definida en la
línea 5 se utiliza para ejecutar la creación de los objetos de la base de datos.
Para realizar la inserción de un registro se debe crear primero un objeto del
tipo ContentValues, al que se le pasa el contenido de las columnas, para
finalmente ingresarlas mediante el método insert mostrado en la línea 26 del
código.
En la línea 30 se muestra como se elimina un registro mediante el _id y para
las consultas se hace uso del método rawQuery que devuelve los registros
consultados a un objeto tipo Cursor.
Symbian OS
Clases utilizadas:
javax.microedition.rms.RecordStore
215
La codificación desarrollada se muestra a continuación:
216
En la línea 1 se muestra la creación de un objeto RecordStore, al cual se le
asigna un nombre y un valor booleano para indicar si debe ser creado en caso
de que no exista.
Para insertar información en este medio de almacenamiento persistente se la
debe transformar a un arreglo de bytes, por lo que se hace uso de los objetos
ByteArrayOutputStream y DataOutputStream, como se observa en las líneas 6
y 7 del código previamente mostrado.
En caso de que la operación sea eliminar un registro, se debe usar el método
deleteRecord(int pos), donde el parámetro que recibe es la posición del mismo
en el RecordStore.
Finalmente para las consultas se debe realizar la operación contraria a la
inserción, si se desea obtener un solo registro lo que se obtiene como salida es
un String, si son varios se obtiene un arreglo de String, como se visualiza en
las líneas 47 y 67 respectivamente.
Conclusión
Ambos APIs proporcionan métodos para gestionar el almacenamiento de
datos persistente, sin embargo, cuando se usa un RecordStore, que es el caso
de Symbian se requiere más esfuerzo, es necesario realizar conversiones de
manera explícita para que la información se almacene como arreglos de bytes.
CAPÍTULO IV
MARCO ADMINISTRATIVO
4.1 CRONOGRAMA
Según lo establecido en las fechas de presentación de sustentaciones se determina el siguiente cronograma, con la finalidad de
definir los puntos de control del proyecto a desarrollarse.
218
219
220
221
222
223
4.2 PRESUPUESTO
4.2.1 EGRESOS
EGRESOS
DÓLARES
Suministros de oficina y computación
12.00
Computadora y servicios de Internet
120.00
Transporte
8.50
Refrigerio
17.00
Empastado, anillado de tesis de grado
50.00
TOTAL………………………………………
207.50
4.2.2 INGRESOS
El monto de los gastos a los que se debe incurrir para la elaboración del presente
proyecto va a ser cubierto en su totalidad por financiamiento propio.
CAPÍTULO V
5.1 CONCLUSIONES Y RECOMENDACIONES
5.1.1 CONCLUSIONES
El objetivo principal de este estudio consistía en evaluar la plataforma, hacer uso de
sus prestaciones, determinar cuáles son sus ventajas y desventajas frente a otras
plataformas que tienen el mismo mercado objetivo y por ende se ubican en el mismo
campo en el que se encuentra Android.
Para la consecución de este objetivo este documento ha sido dividido en cuatro
secciones, en el Marco Teórico se realizó una introducción a la plataforma y cómo
desarrollar aplicaciones para ella, orientado principalmente a que sirva como una guía
para que cualquier persona interesada en crear aplicaciones tenga una base en donde
obtener información.
Luego, en el Capítulo III se realizó una comparativa teórica que contrastaba Android
con Symbian OS y Windows Mobile. Symbian OS actualmente es un producto 100%
open source mientras que Windows Mobile continua siendo un producto propietario,
justamente fue esta una de las razones principales de utilizarlos en la comparación.
225
También se comparó Android con Symbian OS de manera práctica, se evaluaron sus
SDKs y cómo es el proceso de creación de una aplicación en ambas plataformas.
Finalmente se desarrollaron 3 aplicaciones considerables que muestran el potencial de
la plataforma Android y lo que cualquier desarrollador puede lograr usando el API
robusto que viene incluido en ella:
Ventajas principales
Plataforma abierta.- El hecho de que cualquier persona tenga la posibilidad de
utilizar y modificar el código de Android para ajustarlo a sus necesidades trae
consigo varios beneficios:
 Desde un punto de vista macro, cualquier empresa puede utilizar Android
y personalizar el producto que quiere vender. Los consumidores seriamos
los beneficiados al no existir un monopolio, como los creados por
empresas propietarias de ciertos productos.
 Para el caso de las personas con conocimiento en programación las
posibilidades son muy amplias. Entre las características disponibles para
ser explotadas se encuentran: sensores, servicios de localización, Google
Maps, entre otros.
226
Diversidad de productos objetivos.- La instalación de Android es posible en
cualquier teléfono inteligente, y no sólo está limitado a ellos, más adelante se
mostrarán en que otros dispositivos ya se encuentra instalado como su sistema
operativo.
Android Market.- Tienda virtual que ha tenido un notable y rápido
crecimiento, en comparación con sus contrincantes proporciona el mayor
número de aplicaciones gratuitas.
Trato igualitario de las aplicaciones nativas y las desarrolladas por terceros.Android no hace diferencias entre sus aplicaciones, la plataforma permite
accesar al hardware del equipo y explotar todo su potencial.
Lenguaje de programación Java.- Java es un lenguaje de programación
ampliamente utilizado y difundido. El principal beneficio que se obtiene al
utilizar este lenguaje es la portabilidad.
Dalvik.- Máquina virtual basada en registros y que ha sido optimizada para un
nivel bajo de requerimiento de memoria.
Base de datos real.- Android incluye SQLite como base de datos para que
pueda ser utilizada por los desarrolladores en sus aplicaciones.
227
Emulador potente.- Android incluye en su SDK un emulador con un diseño
moderno y fácil de utilizar. Proporciona un medio para probar y simular el
comportamiento de las aplicaciones como si estuviesen instaladas en un
equipo real.
Desventajas
Tiempo en el medio.-Android a nivel mundial a pesar de tener poco tiempo en
el mercado ha logrado escalar posiciones y competir con las plataformas
líderes en el mercado de los dispositivos móviles. Sin embargo, en nuestro
país recientemente arribo el primer equipo que ejecuta este sistema operativo,
se trata de Pulse de Huawei, el cual fue introducido por la operadora Movistar.
A pesar de las notables ventajas que proporciona el hecho de ser una
plataforma open source, la seguridad se ve afectada. Es responsabilidad de los
desarrolladores el crear aplicaciones seguras para sus clientes. En internet se
puede encontrar un estudio hecho por la empresa ISEC Partners41en donde se
establecen una serie de mecanismos para construir aplicaciones seguras. El
mismo
se
puede
encontrar
en:
https://www.isecpartners.com/.../iSEC_Securing_Android_Apps.pdf
41
ISEC Partners es una empresa líder en seguridad para aplicaciones móviles, web y cliente/servidor.
Fuente: https://www.isecpartners.com/
228
Finalmente quiero concluir respondiendo a la hipótesis central que se definió
inicialmente en este documento: ¿Es Android el futuro de la computación móvil?
A continuación presento una lista de diferentes equipos que no son teléfonos celulares
y en los que Android se ejecuta:
Tablet/Slate PCs.- el listado es amplio, SmartQ-V5, SmartQ-V7,
M16
aPad/Iped,M800 aPad/iPed, Orphan iRobot M003 aPad/iPed, E7001, Mastone
Lifepad 3G I850, FlatPad A10,LePad, M001, M003, Dell Streak/Mini5,
JAND700, ODROID-T, zenPAD, WebStation, Gentouch78, EeePad, Archos
5, Archos 7, 1& 1 SmartPad.
E-Readers.- tenemos los equipos nook, eDGe y Alex.
Netbooks. -existen Aspire One D250y Odroid-S
Vehículos.- Chevrolet Volt será el primer vehículo en tener integrado Android
junto con el sistema de seguridad OnStar de General Motors. El objetivo es
que Android permita buscar el auto vía GPS, utilizar reconocimiento de voz
para preguntar direcciones a Google Maps, asi como controlar diversas
funciones
del
auto.
229
Fuente:http://online.wsj.com/article/SB10001424052748704314904575251140310
072962.html?mod=WSJ_Tech_LEFTTopNews
Cada vez son más los tipos de equipos de los que Android forma parte, sabemos que
al poseer un sistema común la integración entre ellos es más transparente y es justo el
fin de la computación ubicua, un entorno
en donde las personas puedan vivir
interactuando con la tecnología sin notar su presencia.
5.1.2 RECOMENDACIONES
Como resultado del desarrollo de la investigación se puede concluir que Android es
en este momento una plataforma robusta y que proporciona un número elevado de
prestaciones y posibilidades tanto para los desarrolladores de aplicaciones como para
los otros tipos de usuarios de dispositivos móviles, específicamente pare el caso de
teléfonos inteligentes en este estudio.
La única limitante que considero existe, de manera temporal, es que recién se está
comercializando equipos que tienen instalado este sistema operativo en el Ecuador,
razón por la cual aun esta tecnología no es muy conocida en nuestro medio. Sin
embargo, después de la lectura de este documento estoy convencido que muchas
personas estarán interesadas en probar Android por lo cual el procedimiento a seguir
230
es descargar las herramientas, instalarlas y apoyarse en la información que tienen aquí
disponible y la que se encuentra en la Internet.
BIBLIOGRAFÍA
LIBROS
Ableson Frank, Collins Charlie, Sen Robi (2009). Unlocking Android: A
developers guide. Estados Unidos: Manning Publications Co.
De Jode Martin (2004). Programming Java 2 Micro Edition for Symbian OS: A
developer's guide to MIDP 2.0. Estados Unidos: Wiley.
DiMarzio J.F. (2008). Android: A programmers’s guide. Estados Unidos: McGrawHill.
Gail Rahn Frederick (2010). Beginning Smartphone Web Development: Building
Javascript, CSS, HTML and Ajax-Based Applications for iPhone, Android, Palm Pre,
Blackberry, Windows Mobile and Nokia S60. Estados Unidos; Apress
Haseman Chris (2008). Android Essentials. Estados Unidos: Apress.
Hammer Carol (2007). Creating Mobile GamesUsing JavaTM ME Platform to Putthe
Fun into Your Mobile Deviceand Cell Phone. Estados Unidos: Apress.
Li Sing, Knudsen Jonathan (2005). Beginning J2ME: From Novice to Professional.
Estados Unidos: Apress.
Kreibich Jay A (2010). Using SQLite. Estados Unidos: O'Reilly Media
Murphy Mark L.(2008). The Busy Coder's Guide to Android Development. Estados
Unidos: CommonsWare.
Murphy Mark L. (2010). Beggining Android 2: Begin the journey toward your own
successful Android 2 applications. Estados Unidos: Apress.
Owens Michael (2006). The Definitive Guide to SQLite. Estados Unidos: Apress.
RogersRick, Lombardo John, Mednieks Zigurd, Meike Blake (2009). Android
Application Development. Estados Unidos: O’Reilly Media
Rusty Harold Elliotte (2001). Processing XML with Java: A guide to SAX, DOM,
JDOM, JAXP, and TrAX. Estados Unidos: Addison-Wesley.
DIRECCIONES WEB
Android
Developers.
Android
API
Levels.
Extraido
desde:
http://developer.android.com/guide/appendix/api-levels.html
Android
Developers.Android
Supported
Media
Formats.
Extraido
desde:http://developer.android.com/guide/appendix/media-formats.html
Android
Developers.
What
is
Android?
Disponible
en:
Extraido
de:
http://developer.android.com/guide/basics/what-is-android.html
Android
Developers.System
Requirements.
http://developer.android.com/sdk/requirements.html
Distimo (junio de 2010). Apple App Store, BlackBerry App World, Google Android
Market,Nokia Ovi Store, Palm App Catalog and Windows Marketplace. Reporte
disponible para descargarse en: http://www.distimo.com/
Dot Com Infoway. Android by 2012, A study on present and future of Google's
Android.
Estudio
disponible
en:
http://www.dotcominfoway.com/attachments/268_White-paper-Android-by-2012.pdf
IDC, nota de prensa (Enero de 2010).IDC Says Android Will Be the #2 Mobile
Operating
System
by
2013.
Disponible
en:
http://www.idc.com/getdoc.jsp?containerId=prUS22176610
IDC, nota de prensa (Mayo de 2010).Worldwide Converged Mobile Device
(Smartphone) Market Grows 56.7% Year Over Year in First Quarter of 2010, Says
IDC. Disponible en: http://www.idc.com/getdoc.jsp?containerId=prUS22333410
ISEC partners (octubre de 2008).DEVELOPING secure mobile applications for
Android.An introduction to making secure Android applications. Disponible en:
https://www.isecpartners.com/.../iSEC_Securing_Android_Apps.pdf
Gartner, nota de prensa (Febrero de 2010).Gartner Says Worldwide Mobile Phone
Sales to End Users Grew 8 Per Cent in Fourth Quarter 2009; Market Remained Flat
in 2009. Disponible en:http://www.gartner.com/it/page.jsp?id=1306513
Gartner, nota de prensa (Mayo de 2010).Gartner Says Worldwide Mobile Phone
Sales
Grew
17
Per
Cent
in
First
Quarter
2010.
Disponible
en:http://www.gartner.com/it/page.jsp?id=1372013
Matos
Victor.
Android
Application’s
Life
Cycle.
Disponible
en:
http://www.slideshare.net/peterbuck/microsoft-powerpoint-androidchapter03lifecycle
Morrish Jim (abril de 2010). Smartphones forecast to grow to 26% of handsets by
2014.
Disponible
en:http://www.analysysmason.com/Research/Content/ViewPoints/RDMY0smartphones-forecast-OS-Apr2010/?journey=3710,3686
Open Hanset Alliance. Página oficial: http://www.openhandsetalliance.com
Research2Guidance (febrero de 2010). Smartphone Application Store Comparison.
Disponible en: http://www.docstoc.com/docs/33502524/Mobile-Application-StoreComparison-Tables
Rubin
Andy
(mayo
de
2007).Where’s
my
Gphone?
Disponible
en:
http://googleblog.blogspot.com/2007/11/wheres-my-gphone.html
Rubin Andy (septiembre de 2009).The future of mobile. Disponible en:
http://googleblog.blogspot.com/2008/09/future-of-mobile.html
Redación Conatel.Celulares e Internet, en una carrera sin trabas en Ecuador.
Disponible
en:http://www.conatel.gov.ec/site_conatel/index.php?option=com_content&view=arti
cle&id=595:celulares-e-internet-en-una-carrera-sin-trabas-encuador&catid=46:noticias-articulos&Itemid=184
Redacción INEC.Tecnologías de la información y Comunicaciones en el Ecuador.
Disponible
en:
http://www.inec.gov.ec/c/document_library/get_file?folderId=954942&name=DLFE34202.pdf
Spectrum (febrero 2008), Thoughts on Google Android. Estudio disponible en:
http://www.spectrumdt.com/documents/SDTAndroidTechnicalWhitePaper_001.pdf
Wikipedia.
Android
(operating
system).Disponible
http://en.wikipedia.org/wiki/Android_(operating_system)
en:
ANEXOS
ANEXO 1. Glosario
1. ACC (Advanced Audio Coding): Codificación de audio avanzado:Es un
formato de audio digital comprimido con pérdida. Fue diseñado con el fin de reemplazar
al MP3. Para un mismo número de impulsos por segundo (bitrate) y un mismo tamaño
de archivo MP3, el formato AAC es más estable y tiene más calidad, produciendo un
sonido más cristalino.
2. AMR-WB: El formato de audio (Adaptive Multi Rate - WideBand o AMR-WB)
es un formato de muy baja calidad de audio, se usan en melodías de móviles como
sonido "reales".
3. API (Application Programming Interface - Interfaz de Programación de
Aplicaciones): Grupo de rutinas (conformando una interfaz) que provee un
sistema operativo, una aplicación o una biblioteca, que definen cómo invocar
desde un programa un servicio que éstos prestan. En otras palabras, una API
representa un interfaz de comunicación entre componentes software.
4. AVRCP (Audio/Video Remote Control Profile): El perfil AVRCP proporciona
una interfaz estándar para controlar a distancia televisores, equipos de alta
fidelidad o cualquier otro equipo electrónico y permitir así, que un único control
remoto o cualquier otro tipo de mando controle todo el equipo de audio y vídeo al
que el usuario tiene acceso.El perfil AVRCP indica cómo controlar las
características de transferencia continua de archivos de imagen y sonido, entre
otras las funciones de pausa, stop, play de la reproducción y el control del
volumen, así como otras funciones de control remoto.También permite
extensiones específicas del fabricante.
5. A2DP(Advanced Audio Distribution Profile): Distribución de audio avanzada.
Define cómo se puede propagar un stream de audio (mono o estéreo) entre
dispositivos a través de una conexión Bluetooth. El perfil A2DP establece los
protocolos y procedimientos que realizarán la distribución del contenido de audio
de alta calidad en modo mono o estéreo a través de los canales ACL.
6. Framework:Un framework, en el desarrollo de software es una estructura de
soporte definida en la cual otro proyecto de software puede ser organizado y
desarrollado.
7. GUIs (Graphical User Interface - Interfaz gráfica de usuario): Sistema de
interacción entre el ordenador y el usuario, caracterizado por la utilización de
iconos y elementos gráficos en su concepción. Es un paso más allá de los
interfaces basados en caracteres, que sólo incluían líneas de texto para introducir
comandos y conocer las respuestas del sistema.
8. HE-AAC (High-Efficiency Advanced Audio Coding - Codificador avanzado de
audio de alta eficiencia): Es un formato de compresión de audio digital de muy
alta calidad (muy superior al MP‐3). Sus ventajas se manifiestan, sobre todo, para
audio multicanal (5.1 y 7.1) aunque también puede aplicarse para canales de audio
mono y estéreo.
9. H.263: es un estándar de códec de vídeo diseñado originalmente como un formato
de baja calidad comprimido para videoconferencias. Fue desarrollado por la UITT Video Expertos Codificación Group (VCEG) en un proyecto que termina en
1995/1996 como un miembro de la familia H.26x de codificación de vídeo
estándares en el dominio de la UIT-T.
10. H.264/AVC (Advanced Video Coding): es un estándar para la compresión de
vídeo.
11. IDE (Integrated Development Environment - Entorno integrado de desarrollo).
Aplicación compuesta por un conjunto de herramientas útiles para un
programador.
Un entorno IDE puede ser exclusivo para un lenguaje de programación o bien,
poder utilizarse para varios. Suele consistir de un editor de código, un compilador,
un
debugger
y
un
constructor
de
interfaz
gráfica
GUI.
Muchos entornos IDE vienen en paquetes SDK.
12. JDT (Java Developer Tools - Herramientas para desarrolladores de Java): El
proyecto JDT proporciona la herramienta plug-ins que implementan un IDE Java
de apoyo para el desarrollo de cualquier aplicación Java, incluyendo los plug-ins
de Eclipse.
13. Kernel (Núcleo): Es la parte fundamental de un sistema operativo. Es el software
encargado de gestionar los recursos del sistema.
14. Middleware: Es un módulo intermedio que actúa como conductor entre
sistemas permitiendo a cualquier usuario de sistemas de información comunicarse
con varias fuentes de información que se encuentran conectadas por una red.
Desde un punto de vista amplio una solución basada en productos middleware
debe permitir conectar entre sí a una variedad de productos procedentes de
diferentes proveedores. De esta forma se puede separar la estrategia de sistemas
de información de soluciones propietarias de un sólo proveedor.
15. MIDIS: Es un formato de sonido de muy pequeño tamaño. Los midis tienen
menos calidad que los wav o mp3. Sin embargo su tamaño es mucho menor, lo
que hace que no consuman casi memoria. Esto hace que los midis sean ideales
para las músicas de fondo del juego.
16. MPEG-4 SP: es una técnica de compresión de vídeo desarrollada por MPEG.
Pertenece al estándar ISO/IEC MPEG-4. Es un estándar de compresión basado en
la Transformada de coseno discreta (DCT), similar a estándares anteriores como
MPEG-1 y MPEG-2.
17. OGG VORBIS: es un códec de audio perceptivo de fines generales previsto para
permitir
flexibilidad
máxima
del
codificador,
permitiéndole
escalar
competitivamente sobre una gama excepcionalmente amplia de calidad/bitrates.
18. PCM/WAVE: es un formato de audio digital normalmente sin compresión de
datos, desarrollado y propiedad de Microsoft y de IBM que se utiliza para
almacenar sonidos en el PC, admite archivos mono y estéreo a diversas
resoluciones y velocidades de muestreo, su extensión es “.wav”.
19. PIM (Personal Information Management): Sistema avanzado de gestión del
organizador del teléfono móvil. Permite programar el calendario y sincronizarlo
con PC y PDA.
20. SAP (Service Acces Point -Punto de Acceso al Servicio): Interfaz física a través
de los cuales los niveles de orden más bajo en el modelo OSI proveen servicios a
los de mayor orden.
21. SDK (Software development kit - Kit de desarrollo de software): Es un conjunto
de herramientas y programas de desarrollo que permite al programador crear
aplicaciones para un determinado paquete de software, estructura de software,
plataforma de hardware, sistema de computadora, consulta de videojuego, sistema
operativo o similar.
22. Smartphones (Teléfono inteligente): Son pequeños dispositivos que integran
funcionalidades de teléfono móvil con las funcionalidades más comunes de un
PDA. Los Smartphones funcionan como teléfonos móviles y además permiten a
los usuarios almacenar información, enviar y recibir mensajes e E-mail e instalar
programas.
23. SMS(ShortMessage Service - Servicio de mensaje corto): Es un servicio de
mensajería por teléfonos celulares. Con este sistema se puede enviar o recibir
mensajes entre celulares y otros dispositivos electrónicos, e incluso utilizando
internet.
24. SSL (Secure Sockets Layer): Es un proceso que administra la seguridad de las
transacciones que se realizan a través de Internet. Se basa en un proceso de
cifrado de clave pública que garantiza la seguridad de los datos que se envían a
través de Internet. Su principio consiste en el establecimiento de un canal de
comunicación seguro (cifrado) entre dos equipos (el cliente y el servidor) después
de una fase de autenticación.
25. Teclado QWERTY:El término QWERTY se refiere al tipo de Teclado por la
forma en que se distribuyen sus letras. Las teclas en la fila superior debajo de los
números forman la palabra QWERTY al leerlas de izquierda a derecha. De aquí
proviene su nombre.
26. WAP
(Wireless
Application
Protocol)
-
Protocolo
de
aplicaciones
inalámbricas): Esun estándar seguro que permite que los usuarios accedan a
información de forma instantánea a través de dispositivos inalámbricos como
PDAs, teléfonos móviles, walkie-talkies y teléfonos inteligentes (smartphones).
27. Widgets:Componente con el cual un usuario interactúa en una interfaz gráfica.
Son ejemplos de widget las ventanas, cajas de texto, checkboxs, listbox, entre
otros.
Son utilizados por los programadores para hacer aplicaciones con interfaces
gráficas (GUI).
28. XML(Extensible Markup Language) - Lenguaje de marcado ampliable o
extensible): es una especificación/lenguaje de programación desarrollada por el
W3C. XML es una versión de SGML, diseñado especialmente para los
documentos de la web. Permite que los diseñadores creen sus propias etiquetas,
permitiendo la definición, transmisión, validación e interpretación de datos entre
aplicaciones y entre organizaciones.
ANEXO 2. Código fuente de la aplicación “Listado de Personas” implementada
utilizando el SDK de Android.
package android.com.proyecto.ejemplocomparativo;
import android.widget.ListAdapter;
import android.widget.SimpleCursorAdapter;
publicclass PantallaPrincipal extends ListActivity {
privatestaticfinalintCREAR_ACTIVIDAD = 0;
privatestaticfinalintAGREGAR_ID = Menu.FIRST+1;
privatestaticfinalintMOSTRAR_ID = Menu.FIRST+2;
privatestaticfinalintELIMINAR_ID = Menu.FIRST+3;
privatestaticfinalintSALIR_ID = Menu.FIRST+4;
privatelongtemp_id=0;
private DatabaseHelper dbh;
private Cursor personasCursor=null;
ListView myLv;
@Override
dbh=new DatabaseHelper(this);
dbh.open();
listarPersonas();
}
/*Métodoquelistalaspersonasingresadasenla base dedatos*/
publicvoid listarPersonas()
{
personasCursor = dbh.obtenerPersonas();
startManagingCursor(personasCursor);
ListAdapter adapter=new SimpleCursorAdapter(this,
R.layout.row, personasCursor,
new String[] {"_id","datos"},
newint[] {R.id._id,R.id.nombre});
setListAdapter(adapter);
myLv=getListView();
myLv.setOnItemClickListener(new OnItemClickListener() {
publicvoid onItemClick(AdapterView<?> parent, View view,
int position, long id) {
temp_id=id;
}
});
}
/*Métodoparacrearlasopicionesdelmenú*/
menu.add(Menu.NONE, AGREGAR_ID, Menu.NONE, "Agregar
persona")
.setAlphabeticShortcut('a');
menu.add(Menu.NONE, MOSTRAR_ID, Menu.NONE, "Mostrar
datos")
.setAlphabeticShortcut('m');
menu.add(Menu.NONE, ELIMINAR_ID, Menu.NONE, "Eliminar
persona")
.setAlphabeticShortcut('e');
menu.add(Menu.NONE, SALIR_ID, Menu.NONE, "Salir")
.setAlphabeticShortcut('s');
return(super.onCreateOptionsMenu(menu));
}
/*Métodoparaindicarlasaccionesquedeberealizarcada
elementodelmenú*/
@Override
caseAGREGAR_ID:
agregarPersona();
return(true);
caseMOSTRAR_ID:
mostrarPersona();
return(true);
caseELIMINAR_ID:
dbh.eliminarPersona(temp_id);
listarPersonas();
returntrue;
caseSALIR_ID:
finish();
return(true);
}
return(super.onOptionsItemSelected(item));
}
/*Métodoqueinvocalaactividadenlacualseagregauna
persona*/
privatevoid agregarPersona() {
Intent i = new Intent(this, AgregarPersonaScreen.class);
startActivityForResult(i,CREAR_ACTIVIDAD);
}
/*Métodoqueinvocalaactividadenlacualsemuestrala
informaióndelapersonaseleccionada*/
privatevoid mostrarPersona() {
Intent i = new Intent(this, MostrarPersonaScreen.class);
System.out.println("Sale: " + temp_id);
i.putExtra("_id", temp_id);
startActivityForResult(i,CREAR_ACTIVIDAD);
}
}
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
publicclass AgregarPersonaScreen extends Activity {
private EditText nombre;
private EditText apellido;
private EditText cedula;
private EditText telefono;
private EditText direccion;
privatestaticfinalintALERTA_NOMBRE=0;
privatestaticfinalintALERTA_APELLIDO=1;
privatestaticfinalintALERTA_CEDULA=2;
@Override
setContentView(R.layout.persona);
dbh = new DatabaseHelper(this);
dbh.open();
nombre=(EditText)findViewById(R.id.nombre);
apellido=(EditText)findViewById(R.id.apellido);
cedula=(EditText)findViewById(R.id.cedula);
telefono=(EditText)findViewById(R.id.telefono);
direccion=(EditText)findViewById(R.id.direccion);
btnAceptar.setOnClickListener(new View.OnClickListener() {
@Override
boolean avanzar=true;
if((nombre.getText().toString().equals("") ||
nombre.getText().toString()==null)&&avanzar==true)
{
avanzar=false;
showDialog(ALERTA_NOMBRE);
}
if((apellido.getText().toString().equals("") ||
apellido.getText().toString()==null)&&avanzar==true)
{
avanzar=false;
showDialog(ALERTA_APELLIDO);
}
if((cedula.getText().toString().equals("") ||
cedula.getText().toString()==null)&&avanzar==true)
{
avanzar=false;
showDialog(ALERTA_CEDULA);
}
if(avanzar==true)
{
/*Llamadaalmétododela base
dedatosparaingresarunanuevapersona*/
dbh.crearPersona(nombre.getText().toString(),
apellido.getText().toString(),
cedula.getText().toString(),
telefono.getText().toString(),
direccion.getText().toString());
dbh.close();
setResult(RESULT_OK);
finish();
}
}
});
}
/*Métodoparagestionarlasalertasdemensajequesepresentan*/
@Override
public Dialog onCreateDialog(int id) {
switch(id) {
case (ALERTA_NOMBRE) :
AlertDialog.Builder alerta1 = new AlertDialog.Builder(this);
alerta1.setTitle("Ingreso de persona");
alerta1.setMessage("El nombre de la persona es obligatorio");
alerta1.setPositiveButton("Aceptar",
new DialogInterface.OnClickListener() {
publicvoid onClick(DialogInterface dialog,
int whichButton) {}});
return alerta1.create();
case (ALERTA_APELLIDO) :
alerta2.setMessage("El apellido de la persona es obligatorio");
case (ALERTA_CEDULA) :
alerta3.setMessage("El número de cédula de la persona es
obligatorio");
}
returnnull;
}
}
publicclass MostrarPersonaScreen extends Activity {
private TextView nombre;
private TextView apellido;
private TextView cedula;
private TextView telefono;
private TextView direccion;
private Intent extras;
private Cursor personaCursor;
private String ls_nombre, ls_apellido;
@Override
setContentView(R.layout.persona);
Long s=getIntent().getLongExtra("_id",0);
dbh = new DatabaseHelper(this);
dbh.open();
/*Invocacióndelmétodoqueobtienelosdatosdelapersona*/
personaCursor=dbh.obtenerPersona(s);
personaCursor.moveToFirst();
nombre=(TextView)findViewById(R.id.nombre);
apellido=(TextView)findViewById(R.id.apellido);
cedula=(TextView)findViewById(R.id.cedula);
telefono=(TextView)findViewById(R.id.telefono);
direccion=(TextView)findViewById(R.id.direccion);
btnAceptar.setVisibility(4);
nombre.setEnabled(false);
apellido.setEnabled(false);
cedula.setEnabled(false);
telefono.setEnabled(false);
direccion.setEnabled(false);
nombre.setText(personaCursor.getString(1));
apellido.setText(personaCursor.getString(2));
cedula.setText(personaCursor.getString(3));
telefono.setText(personaCursor.getString(4));
direccion.setText(personaCursor.getString(5));
}
}
import android.content.ContentValues;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
publicclass DatabaseHelper {
privatestaticfinal String DATABASE_NAME="PersonasDB";
privatestaticfinal String TABLE_NAME="personas";
publicstaticfinal String ROWID = "_id";
publicstaticfinal String NOMBRE="nombre";
publicstaticfinal String APELLIDO="apellido";
publicstaticfinal String CEDULA="cedula";
publicstaticfinal String TELEFONO="telefono";
publicstaticfinal String DIRECCION="direccion";
privatestaticfinal String CREAR_BD ="CREATE TABLE IF NOT EXISTS "
+ TABLE_NAME +
" (_id integer primary key autoincrement, nombre text not " +
" null, apellido text not null, cedula text not null, " +
" telefono text, direccion text);";
private SQLiteDatabase personasDB = null;
privatefinal Context myCtx;
/*Constructor delaclase*/
public DatabaseHelper(Context context) {
this.myCtx=context;
}
/*Métodoquecreala base o abrelaconexiónsiyaestá
creada*/
public DatabaseHelper open() throws SQLException {
try {
personasDB =
myCtx.openOrCreateDatabase(DATABASE_NAME,Context.MODE_PRIVATE, null);
personasDB.execSQL(CREAR_BD);
} catch (SQLException ex) {
thrownew SQLException("No se puede crear la base");
}
returnthis;
}
/*Métodoparacerrarlaconexiónconla base dedatos*/
publicvoid close() {
personasDB.close();
}
/*Métodoparainsertarunregistroenlatablapersonas*/
publiclong crearPersona(String nombre, String apellido, String cedula, String
telefono, String direccion)
{
ContentValues personasValues = new ContentValues();
personasValues.put(NOMBRE, nombre);
personasValues.put(APELLIDO, apellido);
personasValues.put(CEDULA, cedula);
personasValues.put(TELEFONO, telefono);
personasValues.put(DIRECCION, direccion);
returnpersonasDB.insert(TABLE_NAME, null,
personasValues);
}
/*Métodoparaeliminarunregistrodelatablapersonas*/
publicboolean eliminarPersona(long id) {
returnpersonasDB.delete(TABLE_NAME, "_id" + "=" + id, null) > 0;
}
/*Métodoparaobtenertodaslaspersonasalmacenadasenlatabla,
formateadosdeunamaneradeterminada*/
public Cursor obtenerPersonas() {
returnpersonasDB.rawQuery("SELECT _id ,nombre||' '||apellido ||'.
Ced: '||cedula datos "+
"FROM personas ORDER BY _id",
null);
}
/*Métodoparaconsultarlainformacióndeunasolapersona*/
public Cursor obtenerPersona(long rowId) throws SQLException {
returnpersonasDB.rawQuery("SELECT * "+
"FROM personas where _id= " + rowId + ";",
null);
}
}
Código fuente de la aplicación “Listado de Personas” implementada utilizando
el SDK de Symbian OS.
package symbian.com.proyecto.ejemplocomparativo;
import java.io.IOException;
import javax.microedition.lcdui.Choice;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.List;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
import javax.microedition.rms.InvalidRecordIDException;
import javax.microedition.rms.RecordStore;
import javax.microedition.rms.RecordStoreException;
import javax.microedition.rms.RecordStoreFullException;
import javax.microedition.rms.RecordStoreNotFoundException;
import javax.microedition.rms.RecordStoreNotOpenException;
public class PantallaPrincipal extends MIDlet implements CommandListener
{
Display display = null;
List personas = null;
SymbianDB db = null;
int numeroPersonas=0;
RecordStore rs = null;
AgregarPersonaScreen a;
// Definición de los elementos del menú
static
final
Command
cmdSalir
=
new
Command("Salir",
Command.CANCEL, 0);
static final Command cmdAgregar = new Command("Agregar
persona",Command.SCREEN,1);
static final Command cmdMostrarInfo= new Command("Mostrar datos",
Command.SCREEN,2);
static final Command cmdEliminar = new Command("Eliminar
persona",Command.SCREEN, 3);
String currentMenu = null;
// Constructor de la clase, apertura del record store.
public PantallaPrincipal() throws RecordStoreFullException,
RecordStoreNotFoundException, RecordStoreException {
rs = RecordStore.openRecordStore("PersonasDB", true);
}
//Al iniciarse la aplicación se cargan las personas en la pantalla
public void startApp() throws MIDletStateChangeException{
db = new SymbianDB();
try {
numeroPersonas = rs.getNumRecords();
String[] listaPersonas = new String[numeroPersonas];
listaPersonas = db.obtenerPersonas(numeroPersonas, rs);
display = Display.getDisplay(this);
personas = new List("Listado de Personas", Choice.IMPLICIT);
for (int i = 0; i < numeroPersonas; i++) {
personas.append(listaPersonas[i], null);
}
personas.addCommand(cmdAgregar);
personas.addCommand(cmdMostrarInfo);
personas.addCommand(cmdEliminar);
personas.addCommand(cmdSalir);
personas.setCommandListener(this);
display.setCurrent(personas);
} catch (RecordStoreNotOpenException e) {
} catch (IOException e) {
} catch (NullPointerException e) {
} catch (RecordStoreException e) {
}
}
public void pauseApp() {
display = null;
personas = null;
}
public void destroyApp(boolean unconditional) {
notifyDestroyed();
}
//Definición de las acciones que debe realizar cada elementodel menú
public void commandAction(Command c, Displayable d)
{
String label = c.getLabel();
if (label.equals("Salir")) {
destroyApp(true);
}
else if (label.equals("Agregar persona")) {
display.setCurrent(new AgregarPersonaScreen(this,rs));
}
else if (label.equals("Mostrar datos")) {
try{
String[] datos=new String[5];
Integer.toString(db.obtenerRecordId(rs,this.personas.getString(
this.personas.getSelectedIndex())));
display.setCurrent(new
MostrarPersonaScreen(this,rs,Split.split(db.obtenerPersona(db.obtener
RecordId(rs,this.personas.getString(
this.personas.getSelectedIndex())), rs),"/")));
} catch (InvalidRecordIDException e) {
}
}
else if (label.equals("Eliminar persona")){
try {
db.eliminarPersona(db.obtenerRecordId(rs,
this.personas.getString(this.personas.getSelectedIndex())), rs);
} catch (RecordStoreNotFoundException e) {
}
try {
startApp();
} catch (MIDletStateChangeException e) {
// TODO Auto-generated catch block
}
}
}
public void deleteRS() throws RecordStoreNotFoundException,
RecordStoreException{
RecordStore.deleteRecordStore("PersonasDB");
}
}
import javax.microedition.lcdui.*;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.TextField;
public class AgregarPersonaScreen extends Canvas implements CommandListener{
Form frmPersona = new Form ("Agregar Persona");
TextField tfNombre = new TextField ("Nombre", "", 30, TextField.ANY);
TextField tfApellido = new TextField ("Apellido", "", 30, TextField.ANY);
TextField tfCedula = new TextField ("Cédula", "", 30, TextField.NUMERIC);
TextField tfTelefono = new TextField ("Teléfono", "", 30,
TextField.NUMERIC);
TextField tfDireccion = new TextField ("Dirección", "", 30, TextField.ANY);
public PantallaPrincipal localTest;
public Display display;
private SymbianDB db;
RecordStore localRS = null;
public
static
final
Command
cmdSalir
=
new
Command("Salir",Command.BACK, 0);
public
static
final
Command
cmdAgregar
=
new
Command("Agregar",Command.SCREEN, 1);
//Constructor de la clase, agregando opciones del menú
public AgregarPersonaScreen(PantallaPrincipal test, RecordStore rs) {
localRS = rs;
localTest = test;
display = Display.getDisplay(test);
frmPersona.addCommand(cmdSalir);
frmPersona.addCommand(cmdAgregar);
frmPersona.setCommandListener(this);
}
//Método para dibujar la pantalla
protected void paint(Graphics g) {
frmPersona.append(tfNombre);
frmPersona.append(tfApellido);
frmPersona.append(tfCedula);
frmPersona.append(tfTelefono);
frmPersona.append(tfDireccion);
display.setCurrent(frmPersona);
}
//Método que gestiona los eventos de cada elemento del menú
public void commandAction(Command command, Displayable displayable) {
boolean avanzar=true;
String label = command.getLabel();
try {
localTest.startApp();
}
}
else if (label.equals("Agregar")) {
if(tfNombre.getString().equals("")||tfNombre==null)
{
avanzar=false;
Alert
a=new
Alert("Agregar
Personas","Debe
ingresar
el
nombre.",null,null);
display.setCurrent(a);
}
if(tfApellido.getString().equals("")||tfApellido==null)
{
avanzar=false;
Alert
a=new
Alert("Agregar
Personas","Debe
ingresar
el
apellido.",null,null);
}
if(tfCedula.getString().equals("")||tfCedula==null)
{
avanzar=false;
Alert a=new Alert("Agregar Personas","Debe ingresar el número de
cédula.",null,null);
}
if(avanzar==true)
{
db = new SymbianDB(); //Creación de un nuevo RecordStore
//Método que almacena la información en el RecordStore
db.crearPersona(tfNombre.getString(),tfApellido.getString(),tfCedula.
getString(),
tfTelefono.getString(), tfDireccion.getString(), localRS);
try {
}
}
}
}
}
import java.util.Vector;
import javax.microedition.lcdui.*;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.TextField;
public class MostrarPersonaScreen extends Canvas implements CommandListener{
Form frmPersona = new Form ("Datos Persona");
TextField
tfNombre
=
new
TextField
("Nombre",
"",
30,
TextField.ANY|TextField.UNEDITABLE);
TextField tfApellido = new TextField ("Apellido", "", 30,
TextField
tfCedula
=
new
TextField
("Cédula",
"",
30,
TextField.NUMERIC|TextField.UNEDITABLE);
TextField tfTelefono = new TextField ("Teléfono", "", 30,
TextField.NUMERIC|TextField.UNEDITABLE);
TextField tfDireccion = new TextField ("Dirección", "", 30,
public PantallaPrincipal localTest;
public Display display;
private SymbianDB db;
RecordStore localRS = null;
public
static
final
Command
cmdSalir
=
new
Command("Salir",Command.BACK, 0);
public static final int posNombre =0;
public static final int posApellido =1;
public static final int posCedula =2;
public static final int posTelefono =3;
public static final int posDireccion =4;
//Constructor de la clase, se indica la información que contienen los
//elementos de la GUI
public MostrarPersonaScreen(PantallaPrincipal test, RecordStore rs, Vector
datos)
{
localRS = rs;
localTest = test;
display = Display.getDisplay(test);
frmPersona.addCommand(cmdSalir);
frmPersona.setCommandListener(this);
tfNombre.setString((String)datos.elementAt(posNombre));
tfApellido.setString((String)datos.elementAt(posApellido));
tfCedula.setString((String)datos.elementAt(posCedula));
tfTelefono.setString((String)datos.elementAt(posTelefono));
tfDireccion.setString((String)datos.elementAt(posDireccion));
}
//Método que dibuja la pantalla con los elementos definidos
protected void paint(Graphics g) {
frmPersona.append(tfNombre);
frmPersona.append(tfApellido);
frmPersona.append(tfCedula);
frmPersona.append(tfTelefono);
frmPersona.append(tfDireccion);
display.setCurrent(frmPersona);
}
//Método que especifia las acciones que realizan los elementos del menú
public void commandAction(Command command, Displayable displayable) {
String label = command.getLabel();
try {
}
}
}
}
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import javax.microedition.rms.RecordComparator;
import javax.microedition.rms.RecordEnumeration;
import javax.microedition.rms.RecordFilter;
public class SymbianDB {
protected void startApp() throws MIDletStateChangeException {}
protected void pauseApp() {}
//Método que cierra la conexión con el RecordStore
protected void destroyApp(RecordStore rs) throws MIDletStateChangeException
{
try
{
rs.closeRecordStore();
}
}
//Método que permite guardar información en el RecordStore
public RecordStore crearPersona(String nombre,String apellido, String cedula,
String telefono,String direccion, RecordStore rs)
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream outputStream = new DataOutputStream(baos);
try {
outputStream.writeUTF(nombre);
outputStream.writeUTF(apellido);
outputStream.writeUTF(cedula);
outputStream.writeUTF(telefono);
outputStream.writeUTF(direccion);
}
catch (IOException e)
{
}
byte[] b = baos.toByteArray();
try
{
rs.addRecord(b, 0, b.length);
}
catch (RecordStoreNotOpenException e) {
} catch (RecordStoreFullException e) {
}
return rs;
}
//Método que elimina la información de la persona almacenada enel RecordStore
public void eliminarPersona(int id, RecordStore rs){
try {
rs.deleteRecord(id);
rs.enumerateRecords((RecordFilter)null, (RecordComparator)null, true);
}
}
//Método que devuelve todos los registros almacenados en el RecordStore
public String[] obtenerPersonas(int numeroPersonas, RecordStore rs) throws
RecordStoreNotOpenException, RecordStoreException, IOException,
NullPointerException
{
String[]
personasArray
=
new
String[rs.enumerateRecords(null,
null,true).numRecords()];
RecordEnumeration
re
=
rs.enumerateRecords((RecordFilter)null,(RecordComparator) null, true);
int i = 0 ;
while (re.hasNextElement())
{
byte[] persona = re.nextRecord();
ByteArrayInputStream bais = new ByteArrayInputStream(persona);
DataInputStream dis = new DataInputStream(bais);
personasArray[i]= dis.readUTF()+" " +dis.readUTF()+". Ced: " +
dis.readUTF();
i++;
}
return personasArray;
}
//Método que devuelve la información de una persona específica almacenada
//en el RecordStore
public
String
obtenerPersona(int
id,
RecordStore
rs)
throws
RecordStoreNotOpenException, IOException
{
byte[] b = null;
try {
b = rs.getRecord(id);
}
ByteArrayInputStream bais = new ByteArrayInputStream(b);
String
datos
=
dis.readUTF()+"/"+dis.readUTF()+"/"+dis.readUTF()+"/"+dis.readUTF()+"/"+
dis.readUTF();
return datos;
}
public String obtenerColumna(int id, int columna, RecordStore rs){
String nombre = null;
String apellido = null;
String cedula= null;
String telefono=null;
String direccion=null;
String rpta=null;
byte[] b = null;
try {
b = rs.getRecord(id);
}
ByteArrayInputStream bais = new ByteArrayInputStream(b);
try {
nombre = dis.readUTF();
apellido = dis.readUTF();
cedula = dis.readUTF();
telefono=dis.readUTF();
direccion=dis.readUTF();
}
switch(columna)
{
case 1:
rpta=nombre;
case 2:
rpta=apellido;
case 3:
rpta=cedula;
case 4:
rpta=direccion;
case 5:
rpta=telefono;
}
return rpta;
}
public int obtenerRecordId(RecordStore rs, String registro) throws
InvalidRecordIDException, RecordStoreException, IOException
{
int recordID = 1;
boolean found = false;
String ls_cedula=registro.substring(registro.indexOf("Ced: ")+5);
RecordEnumeration re = rs.enumerateRecords((RecordFilter)null,
(RecordComparator) null, false);
re.keepUpdated(true);
while (re.hasNextElement() && found == false)
{
byte[] nextRec = re.nextRecord();
ByteArrayInputStream bais = new ByteArrayInputStream(nextRec);
String nombre = dis.readUTF();
String apellido=dis.readUTF();
String cedula=dis.readUTF();
if (cedula.equalsIgnoreCase(ls_cedula))
{
found = true;
if (re.hasNextElement() == true){
re.nextRecord();
recordID = re.previousRecordId();
} else if (re.hasPreviousElement() == true){
re.previousRecord();
recordID = re.nextRecordId();
}
}
}
return recordID;
}
public void eliminarRS(String nombre) throws RecordStoreNotOpenException,
RecordStoreException{
RecordStore.deleteRecordStore(nombre);
}
}
import java.util.Vector;
/*Clase que simula el comportamiento de la clase split*/
public class Split {
public static Vector split(String cadena, String separador){
Vector items = new Vector();
int pos = 0;
pos = cadena.indexOf(separador);
while(pos >= 0){
items.addElement(cadena.substring(0,pos).trim());
cadena = cadena.substring(pos + separador.length());
pos = cadena.indexOf(separador);
}
items.addElement(cadena);
return items;
}
}

TOMO I - Repositorio CISC - Universidad de Guayaquil

Transcripción

Documentos relacionados

RECEPTOR ANDROID + DVB-S2 EN 1010

El Blog de Songo Magazine 3.0