UNIVERSIDAD PONTIFICIA COMILLAS ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA (ICAI) INGENIERO EN INFORMÁTICA

PROYECTO  FIN  DE  CARRERA  

DESARROLLO DE SOFTWARE PARA iPHONE

AUTOR:

ALFREDO MARTÍN DÍAZ MADRID, SEPTIEMBRE 2010

Autorizada la entrega del proyecto del alumno/a: Alfredo Martín Díaz

EL DIRECTOR DEL PROYECTO David Contreras Bárcena

Fdo.: ……………………

Fecha: ……/ ……/ ……

Vº Bº del Coordinador de Proyectos David Contreras Bárcena

Fdo.: ……………………

Fecha: ……/ ……/ ……

 

UNIVERSIDAD PONTIFICIA COMILLAS ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA (ICAI) INGENIERO EN INFORMÁTICA

PROYECTO  FIN  DE  CARRERA  

DESARROLLO DE SOFTWARE PARA iPHONE

AUTOR: DIRECTOR:

ALFREDO MARTÍN DÍAZ DAVID CONTRERAS BÁRCENA MADRID, SEPTIEMBRE 2010

   

 

Alfredo Martín Díaz Desarrollo de software para iPhone

AGRADECIMIENTOS Me gustaría agradecer el trabajo, apoyo e interés a las personas que me han rodeado estos años en estas pocas líneas, ya que muchas veces las palabras carecen del significado suficiente para describir los sentimientos que habría que reflejar, pero espero conseguirlo igualmente. En primer lugar, me gustaría dar las gracias a mis padres, sin cuyo sacrificio y confianza no hubiera podido hacer la carrera, ni conseguir cada meta marcada, a mi hermana, quién me ha apoyado y motivado en cada momento. A los grandes amigos que he hecho durante estos años, como Isidro Ruíz, Antonio Melé, Alejandro Garrido, Javier Martín, Roberto Merlo, …. , ya que con ellos he compartido los mejores momentos de mi vida y espero seguir haciendolo. Vosotros habéis sido el apoyo imprescindible para poder recorrer este camino sin importar las dificultades encontradas en él. También me gustaría dar las gracias al profesor D. David Contreras Bárcena por su atención y ayuda prestada. A todos vosotros, gracias de todo corazón por los buenos momentos vividos.

Escuela Técnica Superior de Ingeniería (ICAI)  

I

   

 

Alfredo Martín Díaz Desarrollo de software para iPhone

RESUMEN Desde hace unos años, los cambios en los medios tecnológicos están invadiendo paulatinamente la cultura contemporánea reconfigurando el esquema tradicional de comunicación social. En estos tiempos de continuo cambio, la nueva era tecnológica ha llevado a que la sociedad actual confíe todo tipo de actividades, desde las personales hasta las más profesionales, a la tecnología. Esta nueva era tecnológica de smartphone, ha modificado las conductas del ser humano, empleando el actual medio para comunicarse, acceder a información y realizar funciones y actividades propias de sus negocios mediante sus terminales móviles. Así en los últimos años, la fiebre de los móviles con pantalla táctil, desatada primeramente por el iPhone, ha revolucionado el mercado, ya no sólo en la venta de móviles sino todo el verdadero y jugoso negocio de las aplicaciones móviles. Y es que estos terminales se han convertido en el ordenador del futuro con el valor añadido de disponibilidad total y de la comodidad y sobre todo portabilidad. En líneas generales, el objetivo de este proyecto es el estudio de la plataforma de desarrollo del iPhone proporcionada por Apple, mediante la realización de diversos prototipos, para acabar con el desarrollo de una aplicación que se encarga de gestionar diferentes puntos de acceso a través del dispositivo y mediante el manejo de XML, para permitir en todo momento la persistencia de la información a través de Property list. Todo ello desarrollado de una forma fácil de usar y escalable para futuras ampliaciones posteriores que proporcionen un servicio eficaz e innovador. Esta meta propuesta se ha dividido en varios objetivos que se han alcanzado en mayor parte, dando como resultado la aplicación Puntos de Acceso. Para el desarrollo se han utilizado las herramientas de desarrollo proporcionadas por Apple, es decir su SDK, y se ha hecho uso del lenguaje Objective-C. De esta forma se ha conseguido desarrollar una aplicación que cumple con el diseño y la funcionalidad.

Escuela Técnica Superior de Ingeniería (ICAI)  

II

   

 

Alfredo Martín Díaz Desarrollo de software para iPhone

ABSTRACT Since some years ago, the changes in the technological media are invading gradually the contemporary culture, reconfiguring the traditional methods of social communication. In these times of continuous change, the new technological field has carried the companies to trust all kinds of their activities, since the personnel’s to the most professional, to the new technologies. This new filed of smarthphone technology has modified the conducts of the people, employing this media to communicate with others, to agree to information and to carry out functions and activities of their business through their mobile terminals. So in recent years, the fever of touch screen mobile, triggered first by the iPhone, has revolutionized the market, not only in the sale of mobile, but all real and lucrative business of mobile applications. And is that these terminals has become the computer of the future with the added value of total availability and the convenience and above all portability. In general lines, the main objective of this project is to study de iPhone development platform provides by Apple, by making various prototypes to stop the development of an application that manages multiple access points through device and through the management of XML, at all times to allow the persistence of information through the Property list. All this developed in an easy to use and scalable for future subsequent enlargements that supply an efficient service and innovator. This proposed goal has been divided into various objectives that have been reached in greater part, giving as a result the application access points. For the development it have been utilized the development tools provided by Apple, is its SDK, and has made use of Objective-C language. In this way it has developed an application that complies with the design and functionality.

Escuela Técnica Superior de Ingeniería (ICAI)  

III

   

 

Alfredo Martín Díaz Desarrollo de software para iPhone

ÍNDICE  

1.  Introducción.......................................................................................................................1   2.  Sistemas  Operativos  Móviles ........................................................................................2   2.1  iPhone  OS................................................................................................................................... 5   2.1.1  SDK  iPhone  OS:Xcode ..................................................................................................................7   2.1.2  Lenguaje  de  programación ......................................................................................................7   2.1.3  Proceso  de  desbloqueo    o  Jailbreak  del  iPhone ...........................................................8   2.2  Symbian...................................................................................................................................... 8   2.2.1  SDK  Symbian:Carbide .............................................................................................................. 10   2.3  Android.....................................................................................................................................11   2.3.1  Android  SDK .................................................................................................................................. 14   2.3.2  Android  NDK ................................................................................................................................. 14   2.3.3  Lenguajes  de  programación ................................................................................................. 15   3.  iPhone:  Arquitectura  y  SDK........................................................................................ 16   3.1  Características  principales ................................................................................................18   3.1.1  Especificaciones  de  entrada  y  salida............................................................................... 19   3.1.2  Especificaciones  de  la  red  del  iPhone............................................................................. 22   3.1.3  Hardware  del  iPhone................................................................................................................ 23   3.1.4  Gestión  de  la  memoria............................................................................................................. 25   3.2  Lenguaje  Objetive  C ..............................................................................................................26   3.2.1  Memoria  dinámica ..................................................................................................................... 29   3.2.2  Tipos  dinámicos .......................................................................................................................... 29   3.2.3  Introspección ................................................................................................................................ 30   3.2.4  Enlace  dinámico .......................................................................................................................... 30   3.2.5  Carga  dinámica ............................................................................................................................ 31   3.3  iPhone  OS.................................................................................................................................31   3.4  iPhone  SDK:  API’s  y  frameworks .....................................................................................33   3.4.1  Interfaces  visuales ..................................................................................................................... 33   3.4.2  Sonido................................................................................................................................................ 35   3.4.3  Localización  GPS.......................................................................................................................... 38   3.5  Herramientas .........................................................................................................................39   3.5.1  Xcode.................................................................................................................................................. 39   3.5.2  Instruments ................................................................................................................................... 42   3.5.3  DashCode......................................................................................................................................... 44   3.5.4  iPhone  Simulator ........................................................................................................................ 45   3.5.5  Interface  Builder......................................................................................................................... 47   3.6  Arquitectura ...........................................................................................................................49   3.6.1  Cocoa  Touch................................................................................................................................... 50   3.6.2  Media ................................................................................................................................................. 52   3.6.3  Core  Services ................................................................................................................................. 53   3.6.4  Core  OS.............................................................................................................................................. 54   3.7  Tecnologías .............................................................................................................................54   3.7.1  XML ..................................................................................................................................................... 54   3.7.2  Wi-­Fi ................................................................................................................................................... 64   3.8  Proceso  de  desarrollo  de  una  aplicación  en  el  iPhone.............................................65   4.  Alcance  del  proyecto..................................................................................................... 72   4.1  Objetivos ..................................................................................................................................72   Escuela Técnica Superior de Ingeniería (ICAI)  

IV

   

 

Alfredo Martín Díaz Desarrollo de software para iPhone

4.2  Motivación...............................................................................................................................74   4.3  Justificación ............................................................................................................................75  

5.  Desarrollo  de  prototipos............................................................................................. 79   5.1  Pruebas  triviales  del  entorno  de  desarrollo  con  simulador ..................................79   5.2  Desarrollo  de  pequeños  prototipos................................................................................83   6.  Aplicación  Puntos  de  acceso ...................................................................................... 90   7.  Conclusiones  y  trabajos  futuros ............................................................................... 99   8.  Bibliografía ....................................................................................................................101   9.  Anexos .............................................................................................................................102   9.1  iPhone .................................................................................................................................... 102   9.2  iPhone  3G.............................................................................................................................. 104   9.3  iPhone  3G  S........................................................................................................................... 106   9.4  Tutorial  de  iniciación  al  SDK  del  iPhone.................................................................... 108   9.5  Manual  de  usuario ............................................................................................................. 123   9.6  Código  fuente....................................................................................................................... 131  

Escuela Técnica Superior de Ingeniería (ICAI)  

V

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

1. Introducción El objeto del proyecto se basa en describir las funcionalidades del teléfono de Apple Inc. y estudiar el entorno de desarrollo que se nos proporciona a los desarrolladores de dispositivos móviles, para posteriormente, realizar un análisis y diseño de una aplicación. A su vez, cabe destacar que nos encontramos ante un nicho todavía en evolución, o matizando más, en crecimiento continuo. El número de dispositivos móviles y el número de tecnologías nacidas a su alrededor es cada vez más grande. La presentación del iPhone en Enero de 2007 fue un revulsivo en todo el panorama internacional pero aún lo fue más la salida en Febrero de 2008 del SDK para el iPhone OS, el conjunto de herramientas y documentación para poder desarrollar y probar las aplicaciones para el iPhone. El desarrollo para dispositivos móviles abarca uno de los aspectos más importantes y con más evolución dentro de la informática de los últimos años. iPhone podría ser la plataforma más interesante a entrar en razón en un tiempo, especialmente ahora que Apple proporciona un conjunto de elegancia, con una gran documentación, y con herramientas para el desarrollo de aplicaciones. El avance que ha experimentado el desarrollo de teléfonos móviles, asimilando las propiedades de agendas personales, de las cámaras, los dispositivos GPS y heredando parte importante de la funcionalidad de los ordenadores; todo esto en conjunto con una serie de mejoras desde el punto de vista de la arquitectura física permite trasladar muchos de los programas y paradigmas ya existentes en el mundo de la informática.

Escuela Técnica Superior de Ingeniería (ICAI)  

1

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

2. Sistemas Operativos Móviles Los sistemas operativos, en su condición de capa de software que posibilitan y simplifican el manejo del terminal, desempeñan una serie de funciones básicas esenciales para la gestión del equipo. Un sistema operativo se puede encontrar en la mayoría de los aparatos electrónicos que utilicen microprocesadores para funcionar, ya que gracias a estos se puede interactuar con la máquina y que ésta cumpla con sus funciones (ordenadores, teléfonos móviles, reproductores de DVD, radios, etc.). Entre las más destacables se encuentran las siguientes: •

Gestionar de manera eficiente los recursos del equipo , ejecutando servicios para los procesos (programas).

•

Brindar una interfaz al usuario, ejecutando instrucciones (comandos).

Un sistema operativo desempeña 5 funciones básicas en la operación de un sistema informático: suministro de interfaz al usuario, administración de recursos, administración de archivos, administración de tareas y servicio de soporte y utilidades. Lo más esencial e importante en un sistema operativo es el núcleo (kernel). Android usa un kernel Linux, con una mezcla especial de Java. El iPhone se basa en OS X, que a su vez es una variante de Unix, uno de los sistemas operativos más poderosos en el mundo de la informática. S60 y Windows Mobile son sistemas operativos muy maduros y estables, aunque la edad no siempre es una ventaja. Por último, RIM usa un kernel propio, que al igual que Android, tiene un motor Java, y aunque han mejorado la interfaz notablemente, suele mostrar algunas limitaciones propias de su edad.

Escuela Técnica Superior de Ingeniería (ICAI)  

2

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

A continuación se muestra la Fig.1 donde se recogen los sistemas operativos más usados en los teléfonos inteligentes:

Figura 1. Distribución de los sisemas operativos en telefonía móvil

Figura 2. Tráfico de los sistemas operativos en telefonía móvil

Escuela Técnica Superior de Ingeniería (ICAI)  

3

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Aunque todos los sistemas operativos en telefonía móvil proporcionan las funcionalidades básicas anteriormente mencionadas, existen otras más propias de una agenda personal y que caracterizan a ciertos Smartphone que se recogen a continuación: • Multitarea: Mientras Apple ha decidido no permitir la ejecución de más de una aplicación al mismo tiempo (hasta su versión 3, a partir del lanzamiento de la 4, oficialmente para Junio de 2010, si soportará multitarea), Palm promociona esa misma opción como una de las mejores características de su sistema operativo webOS. Los demás sistemas operativos (Android, S60 y BlackBerry) también permiten ejecutar aplicaciones de fondo, con mayor o menor eficacia. • El servicio de correo Push: Es característica distintiva de los Blackberry. Mientras webOS utilizará una tecnología que depende del Internet (Synergy), BlackBerry ha demostrado que su servicio de envío de mensajes es uno de los mejores del mercado. Windows Mobile no se queda atrás, y la integración con Exchange es muy sencilla y placentera para el consumidor. • Búsquedas Globales: En el futuro se espera que todos los teléfonos las permitan, función que Apple implementó en la nueva version 3.0 de su sistema operativo a través del programa Spotlight. Para poder incluir nuevas funcionalidades y nuevas aplicaciones, es importante que la plataforma admita desarrollo de terceros. En este sentido todas las plataformas mencionadas ponen a disposición de los desarrolladores el SDK que permite desarrollar aplicaciones para la plataforma en cuestión. Todas estas aplicaciones desarrolladas por terceros deben dejarse disponibles en algún lugar de la red para que los usuarios puedan descargárselas a sus terminales. iPhone fue pionero en crear un mercado virtual, conocido como AppStore, en el que los desarrolladores colgasen sus aplicaciones y los usuarios pudiesen descargarlas. En este mercado se superan las 200.000 aplicaciones, tanto gratuitas como de pago; y un dato a Escuela Técnica Superior de Ingeniería (ICAI)  

4

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

destacar es que se estima que se alcanzarán las 300.000 aplicaciones para finales del 2010. A iPhone le siguió Android con su Android Market, que en apenas meses de su lanzamiento conto con más de 10.000 aplicaciones. Además de las aplicaciones de terceras personas, también es importante que la plataforma cuente con aplicaciones nativas propias de la plataforma. Tanto iPhone como Android, Symbian y Windows Mobile cuentan con aplicaciones de este tipo. En los siguientes apartados se describen tres de los mencionados sistemas operativos mayoritarios del mercado de la telefonía móvil.

2.1 iPhone OS iPhone OS es el sistema operativo móvil de Apple, uno de los más recientes en el mercado y nacido junto a su aparato físico iPhone y poco después iPod Touch. Se basa en una variante del Mach Kernel que se encuentra en Mac OS X(sistema operativo actual de los Mac). El sistema operativo ocupa menos de medio giga y está diseñado para que las antiguas aplicaciones funcionen para las futuras versiones del sistema operativo. El sistema operativo no tenia nombre hasta que salió la primera versión beta del iPhone SDK el 6 de marzo del 2008. Este sistema operativo dispone de muchos escritorios para organizar las aplicaciones, así dando una interfaz sencilla y agradable cara al usuario. Con una organización cuadricular y con el toque de estilo de Apple. El iPhone OS está basado en una variante del Mach kernel que se encuentra en Mac OS X. El iPhone OS incluye el componente de software “Animación Core” de Mac OS X que junto con el PowerVR MBX el hardware de 3D, es responsable de las animaciones usadas en el interfaz de usuario. iPhone OS tiene 4 capas de abstracción: la capa del núcleo del sistema operativo, la capa de Servicios Principales, la capa de Medios de comunicación y la capa de Cocoa Touch. El sistema operativo ocupa bastante menos de medio GB del total del dispositivo, 8 GB o el almacenaje de 16 GB e incluso 32GB. Esto se realizó para poder soportar futuras aplicaciones de Apple. La unidad central que se usa en el iPhone y el iPod touch es un procesador ARM en vez

Escuela Técnica Superior de Ingeniería (ICAI)  

5

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

de un x86 procesador usado en los ordenadores de Macintosh de Apple. Las aplicaciones del Mac OS X no pueden ser copiadas y ni controladas con un dispositivo que funcione con iPhone OS. Las aplicaciones tienen que ser escritas y compiladas expresamente para el iPhone OS y la arquitectura ARM. Sin embargo, el navegador web de Safari apoya “las aplicaciones web”. Las aplicaciones normales están disponibles para dispositivos con iPhone OS 2.0. Una de las preocupaciones más importantes del grupo de ingeniería de Apple fue dar al usuario la sensación de velocidad. Esto se logra con algunos "trucos", como por ejemplo, cachear el bitmap inicial de las aplicaciones utilizadas, de tal forma que al lanzarla nuevamente, el sistema coloca inmediatamente en primer plano la pantalla inicial, dando la sensación de una velocidad que, en realidad, no es tal. Por otro lado, Apple prohibe la instalación de aplicaciones de terceros que contengan JITter (Just-­‐in-­‐ time compilers), como por ejemplo, .NET en la forma de "Mono", el CLR de .NET para entornos basados en Unix/Linux. Por lo tanto, este tipo de soluciones deben compilar a código nativo, a fin de asegurarse que la misma funcione de la forma más rápida posible.

Figura 3. iPhone OS

Escuela Técnica Superior de Ingeniería (ICAI)  

6

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

2.1.1 SDK iPhone OS:Xcode Xcode es el entorno de desarrollo integrado (IDE) de Apple Inc. y se suministra gratuitamente junto con Mac OS X. Xcode trabaja conjuntamente con Interface Builder, una herencia de NeXT, una herramienta gráfica para la creación de interfaces de usuario. Xcode incluye la colección de compiladores del proyecto GNU (GCC), y puede compilar código C, C++, Objective-­‐C, Objective-­‐C++, Java y AppleScript mediante una amplia gama de modelos de programación, incluyendo, pero no limitado a Cocoa, Carbon y Java. Otras compañías han añadido soporte para GNU Pascal, Free Pascal, Ada y Perl. Entre las características más apreciadas de Xcode está la tecnología para distribuir el proceso de construcción a partir de código fuente entre varios ordenadores, utilizando Bonjour. El SDK se puede descargar gratis, pero para liberar el software, hay que registrarse en el programa de desarrollo del iPhone, un paso que requiere el pago y la aprobación de Apple. Unas claves firmadas son entregadas para poder subir una aplicación a la tienda de aplicaciones de Apple. Las aplicaciones pueden se distribuidas de 3 formas: por la tienda app de Apple, por despliegue de la empresa a los empleados, y sobre un “Ad-­‐hoc” en base de hasta 100 iPhones. Este modelo de distribución para el software iPhone hace imposible liberar el software basado en el código autorizado con GPLV3. Cualquier código que modifique el código autorizado bajo GPLV3 también debe tener licencia como GPLV3. Un desarrollador no es capaz de distribuir una aplicación autorizada bajo el GPLV3 sin distribuir también las claves para firmar (que Apple posee) para permitir la carga de las versiones modificadas de aquel software.

2.1.2 Lenguaje de programación Objective-­‐C es un lenguaje de programación orientado a objetos creado como un superconjunto de C pero que implementase un modelo de objetos parecido al de Smalltalk. Originalmente fue creado por Brad Cox y la corporación StepStone en 1980. En 1988 fue adoptado como lenguaje de programación de NEXTSTEP y en 1992 fue liberado bajo licencia GPL para el compilador GCC. Actualmente se usa como lenguaje Escuela Técnica Superior de Ingeniería (ICAI)  

7

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

principal de programación en Mac OS X y GNUstep.

2.1.3 Proceso de desbloqueo o Jailbreak del iPhone El proceso de desbloquear (más conocido como jailbreak) el teléfono móvil consiste en aprovechar un bug en el sistema de carga del iPhone para instalar una versión modificada del firmware del teléfono. Inicialmente Apple no permitía desarrollar aplicaciones nativas para el teléfono ni tan siquiera acceder directamente al sistema de ficheros, además de las restricciones a que son sometidas las aplicaciones para poder ser distribuidas en la AppStore. Esto motivó a un grupo de desarrolladores a realizar tales modificaciones en el código del firmware de los teléfonos con el objetivo de ampliar sus funcionalidades y por ende aumentando las posibilidades de programación y portando a esta nueva plataforma con base Unix muchas aplicaciones existentes. Entre las aplicaciones existentes se encuentran un compilador de C/C++, una consola, un servidor SSH, etc y versiones de aplicaciones muy conocidas como Flex, Bison, etc. La forma de instalar aplicaciones de terceros está centralizada a través de programas que se instalan en el teléfono al cargar las imágenes firmware modificadas. Estos programas se encargan de gestionar las instalaciones de las aplicaciones en el dispositivo. Han existido diversas alternativas con este uso: Installer, Cydia, Icy,... Todas ellas vienen organizadas por categorías para hacer la búsqueda más fácil además de incluir gestor de actualizaciones, desinstalación y la posibilidad de añadir nuevos repositorios (Se asemeja a los instaladores de paquetes de las distribuciones Linux).

2.2 Symbian Es un sistema operativo propietario diseñado para dispositivos móviles, con sus librerías, interfaces de usuario, implementaciones y herramientas. Está desarrollado por Symbian Ltd y desciende directamente de los sistemas operativos EPOC de Psion. Sólo funciona sobre procesadores ARM. El SO Symbian está estructurado como muchos otros sistemas operativos de ordenador, es multitarea expropiativo y lleva el control de la memoria. Se caracterizaba por ser un sistema operativo basado en ROM, donde antiguamente no Escuela Técnica Superior de Ingeniería (ICAI)  

8

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

se podían escribir sobre la memoria, y otra de las características era su diseño enfocado hacia el ahorro de energía. También destaca por su robustez que evitaba situaciones de bloqueo que obligaban a reiniciar el terminal. Además el sistema posee componentes que permiten el diseño de aplicaciones multiplataforma, esto es diferentes tamaños de pantalla, color, resolución, teclados, etc. La mayoría de estos componentes han sido diseñados en C++. La última versión estable fue la 9.5.

Symbian cuenta con seis interfaces de usuario o plataformas para su sistema operativo: • Serie 60, Serie 80, Serie 90. Usadas por la mayoría de los móviles con Symbian y elegidas por la Symbian Fundation como plataformas a continuar. • UIQ. Usada principalmente por Sony-­‐Ericsson y Motorola, desarrollada por UIQ Technology. • MOAP. Usada por algunos móviles 3G de NTT-­‐Docomo. El objetivo de Symbian fue crear un sistema operativo para terminales móviles que pudiera competir con el de Palm o el Windows Mobile de Microsoft. La mayoría de los móviles con Symbian en la actualidad pertenecen a Nokia: todos los modelos de la serie 60 y superiores, incluyéndose toda la Serie N y los denominados "communicator". Symbian se diseñó siguiendo 3 pautas principales: la integridad y seguridad de los datos del usuario, el tiempo del usuario es oro, y todos los recursos son escasos. Esto llevó a un diseño con microkernel; un sistema de llamada y respuesta para los servicios; una diferenciación total entre el interfaz de usuario y los servicios del sistema; reusabilidad; extensibilidad; y un robusto sistema de recuperación. Teniendo en cuenta el hardware, el sistema operativo está pensado para dispositivos con batería de poca potencia y con memoria ROM. Tanto las aplicaciones como el sistema operativo están programados bajo el paradigma de la orientación a objetos. A causa de la demanda del Mercado, a partir de la versión 8 se introdujo un kernel de tiempo real y una plataforma de seguridad. Se ha hecho un gran énfasis en el ahorro de recursos, tanto de procesador, como de disco (o memoria flash en el caso de los móviles). De hecho, Symbian está programado según los eventos, y el procesador se apaga cuando las aplicaciones no están directamente ocupadas con un evento. Esto se consigue programando con una tecnología llamada objetos activos. Escuela Técnica Superior de Ingeniería (ICAI)  

9

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El sistema operativo Symbian EKA2 soporta suficientemente respuestas en tiempo real como para construir un teléfono alrededor de un solo procesador. Por ejemplo con Linux esta característica no era posible. Así, los móviles con este sistema se han ido haciendo más pequeños, más baratos y también han ido reduciendo su gasto energético. Salió al mercado en el 2004, y una de sus ventajas era la posibilidad de elegir entre 2 kernel, el EKA1 y el EKA2. Aunque el kernel EKA2 no se implementó hasta la versión 8.1b de Symbian. Desde el punto de vista del usuario los kernel se comportan igual, pero internamente son muy diferentes. Muchos fabricantes han elegido el EKA1 para mantener la compatibilidad con controladores más antiguos que pudieran tener, mientras que el EKA2 es ya un sistema operativo de tiempo real. Aparte de todo esto, incluía nuevas APIs para soportar CDMA (Code Division Multiple Access, es un método de acceso al medio), 3G, streaming bidireccional, DVB-­‐H (televisión en el móvil) y OpenGL.

Figura 4. Symbian

2.2.1 SDK Symbian:Carbide Carbide.c++ es una herramienta para el desarrollo de software en lenguaje C++ destinado a dispositivos que funcionan bajo Symbian OS. Se usa tanto para desarrollar los teléfonos que incorporan dicho sistema operativo como para las aplicaciones que ejecutan estos.

Escuela Técnica Superior de Ingeniería (ICAI)  

10

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Está formada por una familia de IDEs desarrollada por Nokia, basada en Eclipse, al que se han incorporado plug-­‐ins para el desarrollo de Symbian OS. Reeemplazó a CodeWarrior como primer entorno de desarrollo para Symbian OS. Desde la versión 2.0, Carbide.c++ es gratuito y se ofrece en tres versiones (Developer, Professional, y OEM).

Figura 5. Carbide

2.3 Android Android es un sistema operativo para dispositivos móviles basado en el núcleo Linux. Inicialmente fue desarrollado por Google y luego por la Open Handset Alliance (liderada por la propia Google). La presentación de la plataforma Android se realizó el 5 de noviembre de 2007 junto con la fundación Open Handset Alliance, un consorcio de 48 compañías de hardware, software y telecomunicaciones comprometidas a la promoción de estándares abiertos para dispositivos móviles. También tiene una interfaz ya adaptada para pantallas táctiles. Dispone de 3 escritorios donde se puede organizar por carpetas, widgets y aplicaciones. También dispone de una pestaña donde aparece todo lo que contiene el móvil. Al ser un sistema operativo de código libre y gratuito, ha sido una gran ventaja para las grandes empresas para implementar el mismo sistema operativo con distintas interfaces graficas. La mayoría del código fuente de Android ha sido publicado bajo la licencia de software Apache, una licencia de software libre y código fuente abierto. Google lanzó la

Escuela Técnica Superior de Ingeniería (ICAI)  

11

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

última versión de Android, la Cupcake 1.5, en abril de 2009.

Figura 6. Android

La arquitectura de Android descrita según sus diferentes niveles: • Aplicaciones: Las aplicaciones base incluirán un cliente de email, programa de SMS, calendario, mapas, navegador, contactos, y otros. Todas las aplicaciones están escritas en el lenguaje de programación Java. • Framework de aplicaciones: Los desarrolladores tienen acceso completo a los mismos APIs del framework usados por las aplicaciones base. La arquitectura está diseñada para simplificar el reuso de componentes; cualquier aplicación puede publicar sus capacidades y cualquier otra aplicación puede luego hacer uso de esas capacidades (sujeto a reglas de seguridad del framework). Este mismo mecanismo permite que los componentes sean reemplazados por el usuario. • Bibliotecas: Android incluye un set de librerías C/C++ usadas por varios componentes del sistema Android. Estas capacidades se exponen a los desarrolladores a través del framework de aplicaciones de Android. Algunas son: System C library (implementación librería C standard), librerías de medios,

Escuela Técnica Superior de Ingeniería (ICAI)  

12

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

librerías de gráficos, 3D, SQLite, entre otras. • Runtime de Android: Android incluye un set de bibliotecas base que proporcionan la mayor parte de las funcionalidades disponibles en las bibliotecas base del lenguaje de programación Java. Cada aplicación Android ejecuta su propio proceso, con su propia instancia de la máquina virtual Dalvik. Dalvik ha sido escrito de forma que un dispositivo puede ejecutar múltiples máquinas virtuales de forma eficiente. Dalvik ejecuta archivos en el formato Dalvik Executable (.dex), el cual está optimizado para memoria mínima. La Máquina Virtual está basada en registros, y activa clases compiladas por el compilador de Java que han sido transformadas al formato.dex por la herramienta incluida "dx".

• Núcleo -­‐ Linux: Android depende de un Linux versión 2.6 para los servicios base del sistema como seguridad, gestión de memoria, gestión de procesos, stack de red, y modelo de controladores. El núcleo también actúa como una capa de abstracción entre el hardware y el resto del stack de software.

Dalvik es la máquina virtual que utiliza la plataforma para dispositivos móviles Android. Está optimizada para requerir poca memoria y está diseñada para permitir ejecutar varias instancias de la máquina virtual simultáneamente, delegando en el sistema operativo subyacente el soporte de aislamiento de procesos, gestión de memoria e hilos. A menudo Dalvik es nombrada como una máquina virtual Java, pero esto no es estrictamente correcto, ya que el bytecode con el que opera no es Java bytecode. Sin embargo, la herramienta dx incluida en el SDK de Android permite transformar los archivos Class de Java compilados por un compilador Java al formato de archivos Dex.

Escuela Técnica Superior de Ingeniería (ICAI)  

13

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

2.3.1 Android SDK El SDK de Android incluye un set completo de herramientas de desarrollo. Éstas incluyen un debugger, librerías, un emulador de manos libres (basado en QEMU), documentación, ejemplos de código y tutoriales. Actualmente, las plataformas de desarrollo incluyen versiones de Linux (cualquier distribución), Mac OS X 10.4.8 o posterior, Windows XP o Vista. Los requisitos también incluyen el kit de desarrollo de Java, Apache Ant y Python 2.2 o posterior. El entorno de desarrollo (IDE) es Eclipse (3.2 o posterior), que utiliza las herramientas de desarrollo Android (ADT) Plugin. Aunque los desarrolladores pueden usar cualquier editor de texto para editar los ficheros Java y XML, y las aplicaciones desde la línea de comandos para crear, compilar y depurar aplicaciones para Android.

2.3.2 Android NDK NDK proporciona herramientas que permiten a los desarrolladores de aplicaciones de Android insertar componentes que hacen uso del código nativo en sus aplicaciones Android. Las aplicaciones de Android funcionan en la máquina virtual Dalvik. El NDK permite a los desarrolladores implementar partes de sus aplicaciones utilizando lenguajes de código nativo tales como C y C++. Esto puede proporcionar beneficios a ciertas clases de aplicaciones, en forma de volver a usar códigos existentes y, en algunos casos, e8n incremento de velocidad. El NDK proporciona: • Un set de herramientas y una estructura de ficheros utilizada para generar librerías de código nativo desde fuentes C y C++. • Una forma de insertar las librerías nativas correspondientes en ficheros de paquete de aplicación (.apks) que pueden ser desplegados en dispositivos Android. • Un set de cabeceras nativas y librerías que seguirán siendo compatibles con las futuras versiones de Android, empezando por Android 1.5.

Escuela Técnica Superior de Ingeniería (ICAI)  

14

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Esta versión del NDK soporta el juego de instrucciones de la máquina ARMv5TEy proporciona cabeceras para libc (la librería C), libm (la librería matemática), el interfaz JNI y otras librerías. El NDK no beneficiará a la mayoría de aplicaciones. Como un desarrollador, necesitará hacer un balance de sus beneficios en contra de sus desventajas; notablemente, utilizar un código nativo no supone un incremento automático de velocidad, pero siempre incrementa la complejidad de la aplicación. Los buenos candidatos típicos para el NDK son las aplicaciones con mucha carga de operaciones de CPU que no asignan mucha memoria, tales como señales de procesamiento, simulaciones físicas, etc. Codificar de nuevo un método para funcionar en C, normalmente no implica un gran incremento de velocidad. Sin embargo, el NDK puede ser una forma efectiva de reutilizar código C/C++ existente.

2.3.3 Lenguajes de programación Las aplicaciones para este sistema operativo están escritas en lenguaje de programación Java y controlar los dispositivos por medio de bibliotecas desarrolladas o adaptadas por Google, con la posibilidad de utilizar bibliotecas escritas por Google. Esta plataforma permite el desarrolllo de aplicaciones por terceros (personas ajenas a Google). Los desarrolladores deben escribir el código gestionado en el lenguaje de programación Java a través de la SDK que proporciona Google. Una alternativa es el uso de la NDK (Native Development Kit) de Google para hacer el desarrollo en C en código nativo.

Escuela Técnica Superior de Ingeniería (ICAI)  

15

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3. iPhone: Arquitectura y SDK El iPhone de Apple es un smartphone (teléfono inteligente) diseñado y distribuido por Apple. Desde el primer momento entre las características del dispositivo destacaba la interfaz casi totalmente basada en la pantalla táctil siendo el interfaz de usuario por hardware mínimo. Entre otras características permite el uso de la cámara, como reproductor multimedia y conectarse a Internet de manera bastante parecida a como lo hace un PC. Otra de los puntos que diferencian al iPhone (sobre todo en los primeros monentos) del resto de productos similares es la existencia de la App Store. En esta tienda los usuarios pueden adquirir directamente las aplicaciones para su terminal, de hecho, es la única manera de obtener software nativo para el iPhone fuera de las aplicaciones incluidas por defecto. Por tanto, los desarrolladores están obligados a introducir sus trabajos en este sistema, previo pago de una módica suma. Además Apple obtiene un 30% de los beneficios de cada venta y tiene control absoluto sobre la tienda, pudiendo añadir o quitar aplicaciones a su gusto. Esto por un lado es un problema para los desarrolladores, pero parece que ha funcionado con los usuarios que no tienen que preocuparse de la procedencia de lo que instalan ya que, idealmente, todo es fiable. En el año 1980 el lanzamiento de ordenadores Apple llego a ser innovador en los negocios de ordenadores. Su ordenador 1984 de Macintosh revolucionó la computación personal y la autoedición igualmente. Para el año 1990 la compañía había empezado a descolorarse, esto dependío en gran medida de su base de usuarios leales y sus éxitos en el pasado en lugar de crear el nuevo corte de tecnología punta. Los cambios aparecieron en 1996 cuando el fundador Steve Jobs volvío al redil. Dos años después aparecio el primer iMac de color. Era sólo la primera de varias innovaciones bajo la vigilancia de Jobs, la más notable de las cuales es probablemente en 2001 con la aparición de iPod, el cual se considero una obra maestra de diseño portátil. Puso de relieve una interfaz sencilla y hermosa, dando a los usuarios acceso a miles de canciones que podían llevar con ellos todo el tiempo, lo cuál provoco un gran apetito en numeroso público.

Escuela Técnica Superior de Ingeniería (ICAI)  

16

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En 2006 surgieron especulaciones y rumores a través de Internet sobre las principales innovaciones de Apple, es decir, la salida de un iPod como teléfono móvil que con el tiempo sería llamado iPhone. Posteriormente Apple reconoció que estaban trabajando en un iPhone a principios de 2007. Según iban analizando su tecnología, se hizo cada vez más evidente que el iPhone iba a ser algo nuevo y diferente, esto provoco que la emoción creciera a un ritmo frenético. En la fecha de lanzamiento, es decir, 29 de junio de 2007, multitud de personas acamparon fuera de las tiendas de Apple para conseguir el smarthphone de la primera generación móvil fácil de usar. Cuando los usuarios comenzaron a probar sus nuevos iPhones, descubrieron su facilidad de uso y la gran posibilidad de cosas que ofrecía, esto provoco unas elevadas ventas, debido al interés frenético de la gente, Apple vendió 270.000 iPhones en dos días y superó el millón de unidades en sólo un mes y medio. Ahora, pasado ya un tiempo desde su lanzamiento, el interés día a día en el iPhone sigue creciendo sin parar. El primer iPhone, es muy similar al iPhone 3G, posee pantalla multitáctil, altavoces, cámara de 2.0 megapíxeles, jack para auriculares, conectividad EDGE y Wi-Fi. Puede reconocerse por su parte trasera, que se encuentra dividida en dos, la parte superior es de color aluminio, mientras que la inferior es negra. El modelo 3G de iPhone incorporó desde su lanzamiento conectividad vía 3G, como su propio nombre indica, A-GPS y una nueva carcasa enteramente de plástico, además de las características del primer modelo de iPhone (el conocido como 2G). El iPhone 3GS, obtiene su nombre de la palabra inglesa speed (velocidad), puesto que es hasta dos veces más rápido que el iPhone 3G. Incorpora grabación de video, brújula y cámara de 3 megapíxeles con autofocus y balance de blancos, comandos de voz, además de una mayor duración de la batería. Otras características nuevas, como la grabación de voz, copiar, pegar y cortar, entre otras, no son exclusivas del iPhone 3GS, sino del iPhone OS 3.1, que también está disponible para los modelos anteriores.

Escuela Técnica Superior de Ingeniería (ICAI)  

17

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El 11 de julio de 2008 Apple realizo el lanzamiento del nuevo iPhone 3G, y se produjo también el despliegue del kit de desarrollo de software (SDK), esto iba a multiplicar el éxito del iPhone en el futuro, con un número aún mayor de ventas para 2009 y más allá. Los 3G consiguieron alcanzar un millón de unidades vendidas en apenas tres días. Se entraba cada vez más en una oleada de nuevas tecnologías y todavía no la cresta final.ç Parece ser que el nuevo iPhone 4G saldrá con una pantalla OLED (más delgada, con mayor contraste, brillo y ángulo de visión y un menor consumo), iChat con videoconferencia y batería intercambiable.

3.1 Características principales El iPhone es más que un simple teléfono móvil y más de un smartphone como los que han permitido el acceso limitado a Internet y otras funcionalidades en los últimos años. Si el iPod es una indicación de las tendencias, el iPhone será el primero de una generación de dispositivos, pero al mismo tiempo se mantendrá como líder indiscutible en el campo de nuevas tecnologías, debido a un fuerte reconocimiento de la marca Apple y a su trayectoria constante de innovación. Técnicamente, la versión original del iPhone es del año 2007, la versión de 2008 del 3G y la de 2009 del 3Gs. Cada iPhone contiene una CPU ARM de 620 MHz, la cuál incluye 128 MB de RAM dinámicas (DRAM), y de 4 a 32 GB de memoria Flash. La principal diferencia esta en el sistema de posicionamiento global (GPS) y la creación de redes. En cuanto a programación, el iPhone está construido sobre OS X de Apple, la cual tiene en la parte superior de Unix. XCode, es el mismo entorno de desarrollo que se utiliza para programar para Macintosh, es el núcleo de la programación nativa para el propio dispositivo. Todo esto revela un desarrollo maduro y un entorno de ejecución no visto en la mayoría de los teléfonos móviles (con la posible excepción de Windows Mobile, pero no se puede comparar en la misma medida) y que las tecnologías smartphone próximas no serán capaz de rivalizar en mucho tiempo. Escuela Técnica Superior de Ingeniería (ICAI)  

18

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Estas especificaciones generales citadas anteriormente son sólo una parte de la historia, al analizar más profundamente el iPhone, su producción, su red y sus otras capacidades, se podrá descubrir lo que hace que el iPhone se considere una plataforma informática verdaderamente innovadora.

3.1.1 Especificaciones de entrada y salida Tanto la entrada y salida de las funcionalidades del iPhone estará determinada por los desarrolladores de programas de la plataforma. La entrada del iPhone se lleva a cabo a través de su capacidad multitáctil de la pantalla, la cuál no precisa de ninguna herramienta de tipo lápiz óptico ni de ningún otro tipo. Dicha pantalla táctil es de 3,5”, pantalla de 480x320 píxeles, se trata de una de las pantallas más grandes que se ha visto en la mayoría de teléfonos móviles hasta la fecha. El dispositivo puede ser girado para visualizarse en dos modos, ya sea horizontal o vertical; lo que significa que puede ofrecer un ancho de 480 pixeles, o de 480 pixeles de altura de pantalla. La salida del iPhone también soporta una variedad de medios de comunicación, como música, en una serie de formatos incluyendo AAC (Advanced Audio Coding), AIFF (Audio Interchange File Format), Apple Lossless, Audible, MP3 y WAV, y así como videos MPEG4. Aunque los usuarios cargan gran parte de sus archivos de audio y video directamente desde sus ordenadores, el iPhone puede reproducir secuencias de 900 kbps a través de Wifi, hay varios tipos de transmisión para elegir el método óptimo para la interfaz de la red actual. (Veáse punto 3.1.2) Aunque un iPhone tiene una resolución de pantalla de 480x320 píxeles, permite al usuario tocar en torno a las páginas de una forma algo similar al pasar el ratón, y proporciona notables diferencias de una interfaz de ratón. Estas diferencias ponen de relieve los elementos finales notables en la historia, lo cuál hace único al iPhone. Cuando se utiliza el iPhone para la mayoría de los casos, se puede observar que tiene una pantalla de 480x320 que se muestra para la mayoría de los casos. Esto no está muy lejos de las pantallas de vídeo 640x480 común en ordenadores de sobremesa a finales Escuela Técnica Superior de Ingeniería (ICAI)  

19

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

de 1980, aunque con más colores y nitidez de los principios de EGA y monitores VGA. La pantalla del iPhone se convierte en interesante cuando se usa para ver páginas web, ya que la pantalla 480x320 no muestra las páginas web en ese tamaño. En cambio, por defecto un usuario mira una página web que se ha dictado una resolución de 980 píxeles. Este punto de vista a escala es lo que el iPhone llama un “visor”. Como se puede apreciar, el tamaño del visor se puede ajustar a mano como parte de un diseño de página web, obligando a una página a escala más o menos cuando es traducida en el iPhone. Sin embargo, para cualquier página web sin una orden explícita de visualización, con 980 píxel de tamaño de valor predeterminado. Se sabe que la mayoría de las páginas se escala por un factor de al menos dos, lo cuál es vital para comprender cómo las páginas web se verá en un iPhone. El desarrollo web bueno para el iPhone depende de que las palabras y las imágenes aparecen en un tamaño razonable, a pesar de la escala. Un elemento importante es la salida del iPhone; su capacidad para mostrar en dos orientaciones diferentes, 480x320 o 320x480. Cada orientación tiene sus propias ventajas. La orientación vertical es ideal para las listas, mientras que la orientación horizontal es más fácil de leer. Cada una de estas orientaciones también presenta el iPhone de “chrome” de una manera diferente. Este “chrome” varía de un programa SDK a otro, y es coherente con las versiones de páginas web en Safari.

Figura 7. El iPhone soporta dos diferentes vistas, consideradas paisaje y retrato

Escuela Técnica Superior de Ingeniería (ICAI)  

20

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Uno de los hechos interesantes reflejados en la anterior figura es que la web ocupa un mayor porcentaje de la pantalla del iPhone en el modo horizontal (paisaje) que en el modo vertical (retrato). Esto se puede apreciar en la siguiente figura:

Figura 8. Dependiendo de la orientación del iPhone, se tendrán diferentes cantidades de espacio de pantallas disponibles.

La diferencia entre las orientaciones no es tan mala, sin la barra de URL, que se desplaza fuera de la parte superior de la pantalla a medida que los usuarios se mueven hacía abajo, pero cuando los usuarios llaman primero una página web en el iPhone en modo horizontal (paisaje), sólo conseguirán ver un pequeño porcentaje de ella.

A pesar de esta limitación que existe en modo paisaje, muchas de las mejores aplicaciones es probable que llamen más la atención en ese diseño, un ejemplo sería la aplicación integrada en YouTube. Se ha citado la capacidad multitáctil del iPhone a través de su pantalla que nos permite el acceso al dispositivo por golpeo sobre la pantalla con nuestros propios dedos; este trabajo es muy diferente de un ratón. Otro elemento interesante de la pantalla táctil se muestra fuera por el hecho de que el dedo no es singular, ya que permite a los usuarios manipular el iPhone con varios dedos a través de diferentes "gestos". El "pellizco" zoom del iPhone es un ejemplo. Para hacer zoom en una página, se da un toque de dos dedos en una página. A la hora de desarrollar para la web, hay que ser aún más cuidadoso, sobre todo en lo referente a los estándares de Internet.

Escuela Técnica Superior de Ingeniería (ICAI)  

21

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.1.2 Especificaciones de la red del iPhone El iPhone ofrece dos métodos de conectividad de red inalámbrica: de área local y de áre amplia. El método mejor para el iPhone respecto a su conectividad es a través de una red de área local inalámbrica de trabajo. Se permite el uso del protocolo 802.11 g para conectarse a cualquier red Wifi próxima (siempre y cuando se dispongan de los permisos para hacerlo). Esto puede proporcionar conexiones locales a altas velocidades de hasta 54 megabits por segundo (Mbit/s), lo que permite hacer relación a una red como Internet la fuente más probable de los límites de velocidad, no al propio dispositivo iPhone. Todo esto se ha hecho para que la conectividad de área local, sea tan fácil de usar como sea posible; para ello contraseñas y otros detalles de la conexión se guardan en el iPhone, el cuál vuelve a conectar automáticamente a la red conocida, siempre que puede.

El iPhone original utiliza la red EDGE para la conectividad inalámbrica de área amplia. La red EDGE soporta velocidades de hasta 220 kbits por segundo (Kbits/s). En comparación con los viejos modems con los que se accedía a Internet hace 15 años, dicha velocidad se puede considerar como bastante rápida, pero en comparación con conectividad de banda ancha no es tan bueno. Aunque los iPhones originales ya se han eliminado, millones de usuarios aún los siguen usando, y por lo tanto la velocidad de la red EDGE sigue siendo pertinente. El iPhone 3G soporta la tarcera generación de estándares de telefonía móvil, que están bien desarrolladas en Europa, y que acaba de salir en los Estados Unidos. Las normas de velocidad de red de 3G se encuentra con velocidades de transferencia fija a un nível bajo en torno a 384 kbit/s, y alta en torno a varios Mbit/s. En general una conexión 3G debería ser notablemente más rápida que EDGE, pero aún no tan rápida como una red de área local. Estas especificaciones de la red son las que pueden poner algunas limitaciones en el desarrollo web del iPhone (y será un aspecto muy a tener en cuenta para los programas

Escuela Técnica Superior de Ingeniería (ICAI)  

22

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

del SDK en el acceso a Internet también). Si se trabaja en un entorno donde todo el mundo tiene acceso a sus aplicaciones a través de una conexión Wifi, no será muy importante preocuparse acerca de cómo puede llegar a afectar a la aplicación; en cambio si se van a crear páginas web del iPhone para un uso más amplio, se tendrá que suponer un porcentaje de usuarios, para así saber más o menos el ancho de red inalámbrica que se precisa. Esto debería alentar a los desarrolladores haciendo que desarrollen páginas web más pequeñas y usen unas hojas de estilo con un formato muy limpio, imágenes cuidadosamente creadas…etc. Un elemento claramente web es el naveagador, el cuál es una versión móvil de Safari de Apple. Se trata como de un escritorio navegador a DOM, CSS y JavaScript.; en el cuál no hay acceso por parte del cliente a terceros. Los dos paquetes más utilizados de fabricantes de software de terceros que no están disponibles de forma nativa para el iPhone son Flash y Java. Una de la posible lista de lo que está disponible para el navegador Safari de iPhone (y también de lo que no está disponible), se observa que funciona de una forma única, es decir, existen pequeños cambios que optimizan Safari para el iPhone, por ejemplo, en lugar de la navegación por pestañas de Safari estándar, individuales “fichas” aparecen como ventanas independientes, en las cuales un usuario puede moverse entre las páginas como si fueran individuales. El navegador Safari del iPhone tiene unas características únicas, sobre todo en su barra de herramientas, se trata de unas barras grises que aparecen en la parte superior e inferior de cada pantalla web del iPhone. En la parte superior de cada página se muestra la URL actual y características de los iconos, entre ellas las de carga. En la parte inferior aparecen iconos adicionales para desplazarse por las distintas páginas web y las “fichas” (comentadas anteriormente). La barra de herramientas se trata de un elemento permanente en las páginas web del iPhone.

3.1.3 Hardware del iPhone La función principal de la mayoría de los teléfonos dentro del hardware es la cámara. En la tabla de abajo se muestran alguno de los elementos principales del dispositivo: Escuela Técnica Superior de Ingeniería (ICAI)  

23

   

 

Gadget (“Artiugio”)

Alfredo Martín Díaz   Desarrollo de software para iPhone

Comentarios

Acelerometro

El iPhone contiene tres acelerómetros. Su uso principal es para detectar un cambio de orientación con relación a la gravedad, es decir, tienen la sensación de que el iPhone es girado de posición vertical a modo de paisaje o la espalda. Sin embargo, también se puede utilizar para aproximar mapa de movimiento del iPhone a través de tres dimensiones del espacio.

Bluetooth

Al ser un protocolo estándar para los teléfonos móviles modernos permite el acceso a los dispositivos inalámbricos. El iPhone utiliza el protocolo Bluetooth 2.0 + EDR. Enhanced Data Rate (EDR) permite una velocidad de transmisión de aproximadamente el triple que la de versiones anteriores de Bluetooth (permitiendo un 3,0 Mbit / s de señalización y un práctico índice de tasa de transferencia de datos de 2,1 Mbit / s).

Camera

Otro requisito para un moderno teléfono. La cámara del iPhone es de 2,0 megapíxeles.

GPS

El iPhone original (2G) no es compatible con GPS real, sino que ofrece, "peer-to-peer detección de ubicación". Este GPS triangula de forma falsa basándose en la ubicación relativa de las torres de teléfonos y redes wifi para los que GPS real existen datos, y luego extrapola la ubicación del usuario. Lamentablemente, la precisión puede variar dramáticamente de un radio potencial de varios kilómetros, todavía, es mejor que no tener GPS en todos. El iPhone 3G incluye un cierto Assisted GPS (A-GPS), que complementa el servicio GPS normal, con información de la célula de la red. Aunque hay una diferencia en la precisión entre los dos tipos de sistema GPS, ambos pueden acceder a través del SDK de iPhone usando la misma interfaz.

De estas características de hardware, los que realmente destacan son los acelerómetros y el GPS, que no son el tipo de cosas que más disponibles están en la telefonía móvil.

Escuela Técnica Superior de Ingeniería (ICAI)  

24

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.1.4 Gestión de la memoria La gestión de la memoria en el iPhone es similar a la de C++ en cuanto que se deberá indicar explicitamente cuando reservar memoria para un objeto y cuando liberarla. Sin embargo, a diferencia de C++ donde lo importante son los objetos, en el iPhone lo importante son las referencias. Cuando se crea o duplica un objeto (alloc, new, copy) se crea una referencia fuerte a dicho objeto y se le añade un contador de referencia inicialmente a 1. Cuando se asigna un objeto a una propiedad se podrá hacer mediante una referencia fuerte (retain) o mediante una referencia debil (assign). Cuando se deja de usar una referencia fuerte, se debe liberar (release) de tal forma que se decremente el contador, en el momento en el que el contador llega a 0, el objeto se liberará de forma automática. Para facilitar el uso del sistema de gestión de memoria, los programas del iPhone siguen una serie de reglas en las que se oculta el contador de referencias y en su lugar se usa el concepto de propietario de un objeto. El propietario de un objeto es una clase u objeto que crea un nueva instancia mediante un metodo que comience por alloc o new, o que contenga la palabra copy, convirtiendose en propietario de dicha instancia. También aquella clase u objeto que llame al metodo retain de otro objeto, se convertirá en su propietario. El propietario de un objeto es el encargado de liberarlo cuando finalice su uso mediante una llamada a release. El contador de referencias de un objeto indicará el número de propietarios que tiene, y cuando el objeto no tengan ningún propietario, su contador llegará a 0 y el objeto se liberará. También se debe tener en cuenta, que si una clase u objeto consiguen una referencia a otro objeto pero no es su propietario, nunca debe liberar dicha referencia, como por ejemplo, recibir una referencia como parametro.

Existen casos especiales con los que hay que tener especial cuidado si se quiere uno ajustar a las reglas explicadas. Cuando se crea un objeto mediante un constructor de conveniencia (un metodo que nos devuelve un nuevo objeto), cuyo nombre no contiene ninguna de las palabras alloc, new o copy, se obtendrá una referencia que no se puede liberar al no ser sus propietarios. Aparentemente se tendría una laguna de memoria, ya que nadie parece ir a liberar dicha referencia. En realidad la clase que ofrece el Escuela Técnica Superior de Ingeniería (ICAI)  

25

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

constructor de conveniencia meterá la referencia en una lista de objetos a liberar (autorelease) antes de devolverla, de tal forma que el objeto se liberará automaticamente en un breve plazo de tiempo. Ese breve plazo será suficiente para que se use el objeto con normalidad de forma temporal (en un ciclo de eventos) o para que se pueda hacer su propietario mediante una llamada a retain evitando así que se libere y pudiendo usarlo de forma permanente. También se debe tener cuidado con las colecciones de objetos que ofrece el lenguaje (arrays, listas, tablas hash, …). Dichas colecciones retienen los objetos que almacenan y los liberan al quitarlos de la colección. Por ejemplo, si se elimina un objeto del cuál no se es propietario de una colección y se quiere seguir usando, antes de eliminarlo se tendrá que hacer que sea propiestario propio mediante una llamada a retain.

3.2 Lenguaje Objetive C Objective-C es el único lenguaje de programación válido para desarrollar aplicaciones en el iPhone OS. Este lenguaje es un superconjunto diseñado por Apple del lenguaje de programacion. El lenguaje de programación C fue diseñado en los laboratorios de AT&T en la década de los 70 y Brad J. Cox diseñó Objective-C. Objective-C es al igual que C++ una extensión de C para hacerlo orientado a objetos, pero a diferencia de C++, Objective-C está basado en ideas de Smalltalk, lo cual hace que se trate de un lenguaje mucho más limpio. En el entorno de Mac OS X se trata de un lenguaje mucho más popular y conocido, debido a que Objective-C es el lenguaje utilizado para programar en Cocoa, la API orientada a objetos de Mac OS X que sustituye y mejora la antigua API de programación Carbon. A diferencia de otros lenguajes de las GCC, Objective-C no ha sido estandarizado por ningún organismo internacional, sino que fue la NeXTSTEP, y ahora Mac OS X quienes han contribuido a crear este lenguaje. NeXT, la empresa que creó NeXTSTEP Escuela Técnica Superior de Ingeniería (ICAI)  

26

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

cedió la implementación de Objective-C a las GCC, y ambos están ahora trabajando en mantener y mejorar el lenguaje. Debido a que Objective-C es una extensión de C, muchas de sus características han sido heredadas, entre ellas: Sentencias de control de flujo. Los tipos de datos fundamentales, estructuras y punteros. Conversiones implícitas y explícitas entre tipos. Los ámbitos de las variables: Globales, estáticas y locales. Las funciones y su sintaxis. Las directivas del preprocesador, aunque también se añaden las directivas del compilador. Objective-C se trata de un lenguaje dinámico, en el cual muchas de las decisiones se toman en tiempo de ejecución, al contrario de lo habitual en otro lenguajes que lo hacen en tiempo de compilación. La gran ventaja del dinamismo se puede observar en las herramientas de desarrollo, donde las herramientas tienen acceso a todo el runtime del programa, con lo que las herramientas de desarrollo pueden instanciar los objetos del programa, representarlos visualmente, personalizarlos, monitorizarlos, y depurarlos de forma muy cómoda para el programador.

Los cinco tipos de dinamismo que diferencian a Objective-C de otros lenguajes, son los siguientes: 1) Memoría dinámica. 2) Tipos dinámicos. 3) Introspección. 4) Enlace dinámico. 5) Carga dinámica.

Escuela Técnica Superior de Ingeniería (ICAI)  

27

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En 2007, Apple lanzó una actualización del lenguaje que se llamó Objective-C 2.0. En ese mismo año, se lanzó el iPhone y los desarrolladores solicitaron a Apple la posibilidad de desarrollar aplicaciones para ese dispositivo revolucionario. En un principio, Apple rechazó esa posibilidad (quería sólo que se desarrollasen aplicaciones web que corriesen bajo Safari, su navegador web), aunque unos meses después Apple cambió de opinión y anuncio que se podrían desarrollar aplicaciones nativas para el iPhone. Poco tiempo después, se puso a disponibilidad de todo el mundo el SDK que permitía un desarrollo rápido de aplicaciones. Este entorno de desarrollo permite a los programadores probar su código en el ordenador, sin tener que pasar la aplicación al iPhone y probarla en el dispositivo real.

Cada fichero en Objective-C consta de lo siguiente:  @interface: Describre la clase, los componentes de la clase y sus métodos (cuando se define una clase se deben realizar varias acciones, entre una de las más importantes es decirle al compilador quién es la clase padre o superclase). Además se debe especificar qué tipo de datos se van a guardar en los objetos de esa clase. Para terminar, se deben definir que tipo de operaciones o métodos se pueden utilizar con los objetos de dicha clase. Los métodos del interface serán entre otros, los getters y setters, que permiten acceder a los atributos del objeto.  @implementation: Contiene el código que implementa dicho código, es decir, el código de los métodos que se declararon en la sección @interface. En esta sección se define el código que se declaró en la sección anterior.  @program: Contiene el código del programa para resolver el correspondiente problema. Este código puede estar dividido en varios archivos en caso de ser necsario, pero siempre tiene que haber una rutina main, donde el programa empezará la ejecución.

Escuela Técnica Superior de Ingeniería (ICAI)  

28

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.2.1 Memoria dinámica En los primeros lenguajes la cantidad de memoria que usaba un programa quedaba fijada durante su compilación. En vista a esto, los lenguajes empezaron a ser conscientes de la importancia de que un programa pudiera decidir en tiempo de ejecución la cantidad de memoria que quería reservar. Un ejemplo sería C que introdujo la función malloc () para reservar memoria dinámicamente. Lenguajes como C++ permitieron que, no sólo la memoria usada para almacenar datos, sino la memoria ocupada por los objetos se pudiera decidir en tiempo de ejecución. De hecho en C++ podemos reservar memoria para los objetos tanto en la pila (memoria estática) como en el heap (memoria dinámica).

Posteriormente, los lenguajes de programación se dieron cuenta de que reservar memoria para los objetos en la pila provocaba que el tamaño de está fuera mucho más difícil de predecir, debido a que siempre había que dejar reservada una gran cantidad de memoria para la pila para por si hacía falta, lo cual daba lugar a un bajo aprovechamiento de la memoria. Lenguajes más modernos como Java o Objective-C arreglan dicho problema obligando a que los objetos se creen siempre en memoria dinámica, evitando así los desbordamientos de pila. En Objective-C, a diferencia de C++, los objetos siempre se crean en memoria dinámica.

3.2.2 Tipos dinámicos Asociar un tipo a una variable es algo que ayuda al compilador a identificar errores de codificación. La tipificación de los objetos permite al compilador informar al programador de que está intentando acceder a un método o variable de instancia que no existe en el objeto.

Escuela Técnica Superior de Ingeniería (ICAI)  

29

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

La tipificación de variables puede ser de dos tipos: Tipificación estática: Se produce cuando es el compilador quien lleva la cuenta de los tipos de variables para identificar errores. Tipificación dinámica: Se produce cuando es el runtime del lenguaje el que en tiempo de ejecución detecta y usa el tipo de las variables. Lenguajes como C++ tienen una tipificación dinámica muy limitada, en concreto C++ permite realizar la tipificación dinámica durante el enlace dinámico de métodos marcados como virtual. Más allá del enlace dinámico C++ dispone de una extensión al lenguaje llamada RTTI (RunTime Type Information) que permite obtener algo de información dinámica sobre los objetos, pero de forma bastante limitada. Java y Objective-C son lenguajes que proporcionan una tipificación dinámica muy rica.

3.2.3 Introspección La introspección es la característica que tienen algunos lenguajes, como ObjectiveC o Java, de observar y manipular como datos el propio estado de su ejecución. Con la introspección se puede saber en tiempo de ejecución sobre un objeto cosas como las siguientes: clase a la que pertenece, clase de la cual deriva, protocolos, métodos..etc.

3.2.4 Enlace dinámico Los lenguajes orientados a objetos reemplazan el concepto de llamada a función por el del envío de mensajes. La diferencia está en que el mismo mensaje puede ejecutar diferentes funciones dependiendo del objeto que reciba el mensaje. A esta capacidad que tienen los objetos de respoder al mismo mensaje de distinta forma es a lo que se

Escuela Técnica Superior de Ingeniería (ICAI)  

30

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

llama poliformismo. En lenguajes como C++ el poliformismo lo implementa el compilador contruyendo una tabla, llamada virtual-table, de las cuales se una por cada clase que tenga métodos virtuales, y donde en tiempo de ejecución se decidirá qué función ejecutar para cada mensaje que reciba el objeto. Por el contrario, en Objective-C es el runtime el que, una vez recibido un mensaje, busca en la clase del objeto, y en las clases base, la función a ejecutar.

3.2.5 Carga dinámica La carga dinámica es una característica que tienen algunos lenguajes como Java u Objective-C, consiste en poder cargar sólo un conjunto básico de clases al empezar el programa, y luego, en función de la evolución del flujo del programa ir cargando las clases de nuevos objetos que se necesiten instanciar.

La principal ventaja de la carga dinámica de clases que hace a los programas extensibles. Los plug-ins son la forma en la que Cocoa implementa este concepto. (un ejemplo serín los componentes de Interface Builder). Una vez que ser carga una clase, los objetos de esta clase se tratan como cualquier otro objeto Objective-C, lo único que tiene que hacer un programa que quiera ser extensible mediante plug-ins es definir un protocolo que deban implementar los plug-ins.

3.3 iPhone OS El sistema operativo utilizado por el iPhone se llama, desde la publicación del primer SDK, OS X iPhone, o más comúnmente iPhone OS. Como el primer nombre indica, está fuertemente basado en Mac OS X, la línea de sistemas operativos que desarrolla Apple y que se incluye en todos los ordenadores Macintosh desde 2002. Al igual que su “padre”, iPhone OS deriva de la fundación Darwin, que a diferencia de Mac OS X, es de código abierto.

Escuela Técnica Superior de Ingeniería (ICAI)  

31

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El sistema operativo varía en gran medida de sus antecesores debido a las características propias del iPhone como su interfaz táctil y la menor cantidad de memoria disponible así como su arquitectura de procesador (basado en ARM en lugar de x86) lo que provoca que los programas desarrollados para Mac OS X deban ser adaptados para la nueva plataforma. El iPhone OS es el sistema operativo que utiliza el iPod Touch, iPhone e iPad, diseñado por 175 ingenieros de Apple. Está basado en una variante del Mach kernel que se encuentra en Mac OS X. El iPhone OS incluye el componente de software “Animación Core” de Mac OS X v10.5 que, junto con el PowerVR MBX el hardware de 3D, es responsable de las animaciones usadas en el interfaz de usuario. iPhone OS tiene 4 capas de abstracción: la capa del núcleo del sistema operativo, la capa de Servicios Principales, la capa de Medios de comunicación y la capa de Cocoa Touch. El sistema operativo, localizado en la partición “/root” del dispositivo, ocupa menos de 500 MB. Esto se realizó para poder soportar futuras aplicaciones de Apple. Este sistema operativo no tenía un nombre oficial hasta que salió la primera versión beta del iPhone SDK, el 6 de marzo de 2008. Antes de esto, Apple declaró, que “el iPhone controla un sistema operativo OS X”, una referencia al padre de los sistemas operativos de los iPhone, el Mac OS X. Al igual que un iPod, el iPhone se maneja con la versión 7.3 de iTunes, el cual es compatible con Mac OS X versión 10.4.10, y con Windows XP o Vista. En lo referente a las versiones del iPhone OS, su lanzamiento fue el 29 de junio de 2007. Apple proporciona actualizaciones para el sistema operativo del iPhone por iTunes, y dice que esto es una ventaja en comparación con otros teléfonos móviles. Los parches de seguridad, así como las características nuevas y mejoradas, son lanzadas de la misma forma. Apple proporciona simultáneamente la misma versión del iPhone OS para el iPod touch. Los usuarios de iPhone reciben todas las actualizaciones de software gratis, mientras que los usuarios del iPod touch tienen que pagar por algunas actualizaciones de software gratis, mientras que los usuarios del iPod touch tienen que pagar por algunas de las actualizaciones de software. iTunes se usa para manejar muchas de las funciones del iPhone y el iPod touch, incluyendo las actualizaciones del iPhone OS. Y funciona en la versiones modernas de Mac OS X, Windows XP y Escuela Técnica Superior de Ingeniería (ICAI)  

32

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Windows Vista. Versión 1.0 2.0 3.0 3.2 4.0 (beta)

Fecha de lanzamiento 29 de junio de 2007 11 de julio de 2008 17 de julio de 2009 3 de abril de 2010 8 de abril de 2010

Detalles Lanzamiento inicial del iPhone Lanzamiento de la versión OS 2.0 Salida de la versión del iPhone OS 3.0 Solo para el iPad Solo para 3G y 3GS

3.4 iPhone SDK: API’s y frameworks Con la salida del iPhone en 2007, no se proveía un SDK propiamente dicho para el desarrollo de aplicaciones nativas, Apple se guardaba el monopolio absoluto del software que podía correr en el teléfono. Tras la salida se ofrecía la posibilidad de desarrollar web apps, las cuales se ejecutaban en Safari, el navegador propio del iPhone (aunque actualmente también se permite el uso del navegador Opera, pero aún no ha alcanzando el nivel de uso de Safari). Estas “aplicaciones web” estaban escritas en HTML y JavaScript ofreciendo Apple los recursos necesarios (imágenes, animaciones) para que éstas tuvieran una apariencia similar a la de las aplicaciones nativas así como un mecanismo para colocarlas en el menú principal. No obstante, al no ser posible copiarlas al iPhone, era necesario en todos los casos tener un servidor web que sirviera las páginas a los clientes. Hasta marzo de 2008 no se público un SDK propiamente dicho para el desarrollo de aplicaciones para el iPhone.

3.4.1 Interfaces visuales Las aplicaciones desarrolladas para iPhone utilizan el patron modelo-vistacontrolador para separar datos, interfaces y lógica, ya que es la manera más lógica de dividir el código en una aplicación visual. Este patrón asegura la máxima reusabilidad y divide la funcionalidad en tres categorías, las cuáles se comentan a continuación:

Escuela Técnica Superior de Ingeniería (ICAI)  

33

   

  

Alfredo Martín Díaz   Desarrollo de software para iPhone

Modelo: Equivale a los datos manejados por la aplicación, y por lo general lo forman los ficheros y objetos que usamos en la aplicación para almacenar datos de una forma persistente o temporalmente.



Vista: Equivale a la interfaz de usuario de la aplicación. Como parte del SDK proporcionado por Apple para desarrollar aplicaciones para iPhone, se incluye el Interface Builder, que permite diseñar visualmente interfaces gráficas de una forma fácil e intuitiva. Sin embargo, la vista por si sola no sirve para nada, se necesita que cuando el usuario interactue con ella se ejecute código que responda a dicha interacción.



Controlador: Equivale a la lógica de la aplicación. Un controlador se encargará de proporcionar el código necesario para que se ofrezca una respuesta a los eventos generados durante la interacción del usuario con una o más vistas. En el controlador se implementarán los métodos necesarios para responder a dichos eventos.

Siguiendo este patrón, en las aplicaciones del iPhone, se diseñará por un lado y de forma separada la vista (Interfaz Builder) y por otro lado el controlador (XCode), siendo por tanto necesario enlazarlas de algún modo. Para realizar dicha tarea existen tres técnicas para aplicar, las cuales son las siguientes:  Las propiedades con el modificador IBOutlet se utilizan para acceder desde el código del controlador a las instancias de los controles que hayamos colocado en la vista. Esto es necesario, por ejemplo, para obtener el texto que ha introducido el usuario en una caja de texto, para cambiar el texto de una etiqueta, para deshabilitar un boton, etc.  Los manejadores de eventos se utilizan para enlazar los eventos que generan los controles que se han colocado en la vista, con el método del controlador que se ejecuta cuando el usuario haga saltar dichos eventos. Esto es necesario, por ejemplo, para que cuando el usuario pule un boton se ejecute una cierta acción, etc. Escuela Técnica Superior de Ingeniería (ICAI)  

34

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

 Los delegados se utilizan para enlazar un control que ofrece una interfaz (delegador) con otro objeto que reciba avisos de dicho control implementando dicha interfaz (delegado). La delegación es una alternativa a los manejadores de eventos que suele utilizarse para que el delegado responda a varios eventos estrechamente relacionados o a eventos con una interfaz más compleja de lo normal. Esta técnica se utiliza en muchas de las clases de la SDK, no solo en las relacionadas con interfaces de usuario. La utilización de delegates permite a las aplicaciones implementar comportamiento común sin tener que hacer subclases o, más aún, saber cómo funciona internamente cada clase. En Objective-C existen protocolos que son, en funcionalidad idénticos a las interface en Java o a las clases puras virtuales en C++. Al definir entre un protocolo, se está obligando a implementar ciertos métodos.

3.4.2 Sonido La reproducción de sonido en el iPhone puede ser tan compleja como se requiera. Desde reproducir un simple fichero de sonido hasta reproducir distintos sonidos sincronizados y con efecto tridimensional, la SDK nos ofrece distintos frameworks que nos permitirán hacer todo ello, siendo más complejos de usar cuanto más potentes sean. Además de los distintos frameworks, la reproduccion de sonido en un dispositivo movil va acompañada de ciertas complejidades adicionales, especialmente si tenemos en cuenta que pueden ejecutarse a la vez multiples aplicaciones que generan sonido y que en cualquier momento el usuario puede recibir una llamada que interrumpa nuestra aplicacion. Para solventar este problema iPhone ofrece las llamadas sesiones de audio, que deberemos usar independiendientemente del framework de sonido que utilicemos. El framework AVAudioPlayer, es el que más frecuentemente utilizaremos en nuestras aplicaciones debido a su relación entre potencia y simplicidad. El framework ofrece varias clases e interfaces que nos facilitarán la tarea de reproducir ficheros de sonido y de realizar tareas básicas como cambiar el volumen, pausar la reproducción o iniciarla desde cualquier punto. Escuela Técnica Superior de Ingeniería (ICAI)  

35

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El SDK del iPhone consta de los frameworks mostrados en la siguiente tabla y agrupados por funcionalidades: Nombre del Framework AddressBook.framework

Descripción Proporciona acceso a la base de datos centralizada para el almacenamiento de contactos de un usuario

AddressBookUI.framework

Proporciona la interfaz de usuario para mostrar los contactos almacenados en la base de datos de la Libreta de direcciones.

AudioToolbox.framework

Proporciona las API de bajo nivel C para la grabación y reproducción de audio, así como la gestión del hardware de audio.

AudioUnit.framework

Proporciona la interfaz para el iPhone OS suministrado por procesamiento de audio plug-ins en la aplicación.

AVFoundation.framework

Proporciona las API de bajo nivel C para la grabación y reproducción de audio, así como de la gestión del hardware de audio.

CFNetwork.framework

Proporciona acceso a los servicios de red y configuraciones, como HTTP, FTP, y los servicios de Bonjour.

CoreAudio.framework

Declara tipos de datos y constantes utilizados por otros núcleos interfaces de audio

CoreData.framework

Proporciona una solución generalizada para la gestión de objeto gráfico en la aplicación.

CoreFoundation.framework

Proporciona abstracción para los tipos de datos común, las cadenas Unicode, XML, recursos URL.

CoreGraphics.framework

Proporciona las API de C-basada en 2D extracción de grasas; basado en el motor de dibujo de Cuarzo.

CoreLocation.framework

Proporciona información de localización y redes Wi-Fi.

ExternalAccessory.framework

Proporciona una forma de comunicarse con los accesorios.

Escuela Técnica Superior de Ingeniería (ICAI)  

36

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Nombre del Framework MapKit.framework

Descripción Proporciona una interfaz de mapas integrados para la aplicación.

MediaPlayer.framework

Ofrece facilidades para reproducir películas y archivos de audio.

MessageUI.framework

Proporciona una interfaz de vista-cotrolador basado para componer e-mails.

MobileCoreServices.framework Proporciona acceso a los tipos estándar y constantes. OpenAL.framework

Proporciona una implementación de la especificación de OpenAL.

OpenGLES.framework

Proporciona un subconjunto compacto y eficiente de la API OpenGL para dibujar en 2D y 3D.

QuartzCore.framework

Proporciona capacidad de configurar animaciones y efectos.

Security.framework

Ofrece la posibilidad de proteger los datos, y el control de acceso al software.

StoreKit.framework

Proporciona apoyo en la compra (app) para las aplicaciones.

SystemConfiguration. framework

Ofrece la posibilidad de determinar la disponibilidad de la red y el estado en el dispositivo.

UIKit.framework

Proporciona los objetos fundamentales de la gestión de la interfaz de usuario de una aplicación.

Foundation.framework

Proporciona clases para Objective C, tipos de datos básicos y servicios del sistema operativo.

GameKit.framework

Proporciona capacidades de red a los juegos.

IOKit.framework

Proporciona capacidades de desarrollo de pilotos.

Escuela Técnica Superior de Ingeniería (ICAI)  

37

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.4.3 Localización GPS El SDK ofrece un único y sencillo framework para utilizar las funciones de localización GPS o similares. En este apartado se explican las características y forma de uso de este framework. El Framework Core Location ofrece la funcionalidad para obtener la localización del dispositivo actual y volver a obtenerla cada vez que cambie una cierta cantidad de espacio, dando al mismo tiempo información sobre la velocidad instántanea y la dirección en la que se mueve el dispositivo. También permite obtener la orientación del dispositivo respecto al norte geográfico. Una de las últimas funcionalidades es calcular distancias entre localizaciones. Este framework consta de las siguientes clases: 

CLLocationManager (Localizador): Realiza la tarea de localizar el dispositivo, según los parametros con los que se le configure.



CLLocationManagerDelegate (Receptor de localizaciones): Recibe mensajes del localizador cada vez que este detecte que la localización ha cambiado lo suficiente.



CLLocation (Localización): Contiene los datos de la localizción del dispositivo tal y como los has capturado el localizador.



CLHeading (Orientación): Contiene los datos de la orientación del dispositivo tal y como los ha capturado el localizador.

Escuela Técnica Superior de Ingeniería (ICAI)  

38

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.5 Herramientas Para desarrollar aplicaciones para el iPhone OS, se necesita un equipo Mac OS X que ejecutará las herramientas en el entorno Xcode. Xcode es una suite de Apple de herramientas de desarrollo que proporcionan apoyo a la gestión de proyectos, edición de código, la creación de ejecutables, la depuración a nivel fuente, la gestión de código fuente del repositorio, el ajuste del rendimiento, y mucho más. En el centro de esta suite es la aplicación Xcode sí mismo, que proporciona el entorno de base de código fuente de desarrollo.

3.5.1 Xcode Es un IDE (entorno integrado de desarrollo) que permite escribir, compilar, ejecutar y depurar el código, así como organizar los ficheros por proyectos e importarlos y exportarlos de manera sencilla y eficiente, es decir, es la aplicación en la cuál se realiza la mayor parte del desarrollo. Nos permite administrar el proyecto e ir añadiendo código. Además incluye un depurador gráfico bastante potente que corre sobre gdb, el debugger clásico. Esta herramienta trabaja con ficheros Java (.java), C/C++ (.h,.c,.cpp), Objective-C (.h,.m) y Objective-C++ (.h,.mm,.M), e incluso podemos hacer un programa parte en Objective-C y parte en Java. Pero concretamente, para desarrollar una aplicación para el iPhone sólo es disponible actualmente hacerlo en Objective-C. Cuando se está desarrollando una aplicación en Xcode, se puede elegir entre realizar el build en un simulador o en el propio terminal conectado al Mac. El simulador provee un entorno local de ejecución sin la necesidad de tener que conectar el iPhone, muy adecuado en las primeras fases del desarrollo. Los últimos test de la aplicación, antes justo de ser puesta en producción o distribuirla oficialmente, es recomendable llevarlos a cabo en el propio terminal. En el entorno de trabajo se tienen los ficheros del proyecto, información de errores y diferentes advertencias, localización de ejecutables binarios, control de versiones,

Escuela Técnica Superior de Ingeniería (ICAI)  

39

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

puntos de ruptura en el código, etc. Los principales detalles de nuestro entorno pueden ser de dos formas: en modo proyecto y en modo depuración. El modo proyecto es el tipo de vista que permite trabajar con todos los ficheros y grupos de nuestro proyecto. Los grupos son la clasificación para organizar todo, y son clases, otros fuentes (fichero main.m, el cuál define la función main como punto de entrada a nuestra aplicación, y el fichero pch que es el que contiene las cabeceras precompiladas y ayuda a reducir los tiempos de compilación), recursos (fichero xib o fichero de recursos de la interfaz gráfica), frameworks (librerías utilizadas) y productos (fichero compilado y listo para ejecutarse). Entre las características más importantes de Xcode para hacer más fácil el desarrollo de aplicaciones se encuentran las siguientes:  Un sistema de gestión de proyectos para la definición de los productos de software.  Un entorno de edición de código que incluye características tales como color de sintaxis, autocompletado de código, y el símbolo indexación.  Un visor de la documentación para la visualización y búsqueda de documentación de Apple.  Un inspector sensible al contexto para ver la información sobre los símbolos de código seleccionado.  Un avanzado sistema de construcción con la comprobación de dependencias.  Compiladores GCC apoyo C, C++, Objective-C, Objective-C++ y Objective-C 2.0 y otros idiomas.  Avanzadas características de depuración, como la corrección, y formateadotes de datos personalizados.  Herramientas avanzadas de refactorización que permiten hacer modificaciones al código mundial sin cambiar el comportamiento global.  Apoyo para las fotos del proyecto, que proporcionan una forma ligera de apoyo.  Locales de gestión de código fuente para el lanzamiento de herramientas de rendimiento para analizar si apoyo para la gestión integrada de software de código fuente de apoyo.  AppleScript para automatizar el proceso de generación.

Escuela Técnica Superior de Ingeniería (ICAI)  

40

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Para crear una aplicación para el iPhone, se deberá empezar por crear un nuevo proyecto en Xcode. Un proyecto gestiona toda la información asociada a su aplicación, incluyendo los archivos de origen, construir valores y normas necesarias para poner posteriormente todas las piezas juntas. El corazón de cada proyecto de Xcode es la ventana del proyecto, que se muestra en la Fig.9. Esta ventana proporciona acceso rápido a todos los elementos clave de su aplicación. En los grupos y la lista de archivos del proyecto, incluyendo los archivos de origen y construyendo los objetivos que se crean a partir de los archivos de código fuente. En la barra de herramientas, se puede acceder a herramientas de uso general y los comandos. En el panel de detalles, se puede configurar un espacio para trabajar en el proyecto. Otros aspectos de la ventana del proyecto proporciona información contextual sobre el proyecto en cuestión.

Figura 9. IDE XCode

Al generar la aplicación en Xcode, se tiene la opción de construirlo para el simulador del iPhone o para un dispositivo. El simulador ofrece un entorno local para probar las aplicaciones para asegurarse de que se comportan básicamente de la manera deseada. Cuando el comportamiento básico de la aplicación sea el deseado, se puede indicar en Xcode que se genere la aplicación y se ejecute en un iPhone o iPod touch conectado a

Escuela Técnica Superior de Ingeniería (ICAI)  

41

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

un ordenador. Ejecutar la aplicación en un dispositivo proporciona el entorno de prueba final, y Xcode permite conectar el built-in depurador al código que se ejecuta allí.

Figura 10. Ejecucción un proyecto de Xcode

3.5.2 Instruments Instruments es una potente herramienta de depuración y de análisis de rendimiento de las aplicaciones, y medición del uso de la memoria mediante gráficas que se actualizan en tiempo real. Permite ejecutar la aplicación tanto en el simulador como en el teléfono y realizar trazas de la cantidad de memoria que está consumiendo en cada momento ( un aspecto vital de las aplicaciones al ser ejecutadas en un entorno con más limitaciones de memoria y rendimiento que en una CPU) así como del uso de la batería que está haciendo.

Escuela Técnica Superior de Ingeniería (ICAI)  

42

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 11. Instruments XCode

Instruments recoge los datos de su aplicación en ejecución y presenta los datos en una pantalla gráfica llamada línea de tiempo. Se pueden recopilar datos sobre el uso de la memoria de la aplicación, la actividad del disco, la actividad de red (y el consumo que se está llevando hasta el momento) y rendimiento gráfico. El punto de vista línea de tiempo puede mostrar todos los diferentes tipos de lado a lado de la información, que le permite correlacionar el comportamiento general de la aplicación, y no sólo el comportamiento en un área específica.

Escuela Técnica Superior de Ingeniería (ICAI)  

43

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 12. Usando Instruments con una aplicación

Además de proporcionar el punto de vista temporal, Instruments proporciona herramientas para ayudar a analizar el comportamiento de la aplicación en relación con el tiempo. Por ejemplo, la ventan de Instruments permite almacenar los datos de varias tandas para que se pueda ver si el comportamiento de la aplicación es en realidad el mejor, o si aún se precisa trabajo. Se pueden guardar todos estos datos y abrirlos en cualquier momento.

3.5.3 DashCode Destinada al desarrollo de aplicaciones web para el iPhone. Su principal finalidad es facilitar la tarea de escribir páginas que sean compatibles para la versión de Safari incluida en el dispositivo. Incluye una serie de plantillas de ejemplo y de imágenes así como código JavaScript que ayudan a la hora de que la apariencia de la página sea consistente con el diseño general del interfaz del usuario del sistema operativo. Adicionalmente, incluye herramientas para depurar el código.

Escuela Técnica Superior de Ingeniería (ICAI)  

44

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 13. DashCode en XCode

3.5.4 iPhone Simulator Es un simulador del iPhone que permite probar las aplicaciones desarrolladas sin necesidad de pasarlas a un iPhone (y pagar la tarifa correspondiente). Implementa el API completa del iPhone y, además incluye Safari con lo que es posible probar tanto programas nativos como las aplicaciones web desarrolladas con DashCode. Es importante resaltar que se trata de un simulador y no un emulador, es decir, implementa el API sobre la plataforma x86 existente en los ordenadores Mac actuales y no intenta emular el hardware del iPhone; es un detalle importante sobre todo si se atiende a la velocidad, ya que la máquina sobre la que corre el simulador va a ser siempre más rápida. Las principales características del simulador del iPhone son: 

Rotación de la pantalla (izquierda, centrada, y derecha).



Soporte de diferentes gestos: o

Pequeños golpes.

Escuela Técnica Superior de Ingeniería (ICAI)  

45

   

 



o

Tocar y soltar.

o

Doble golpe.

o

Golpe fuerte.

o

Golpe rápido.

o

Arrastrar.

o

Pellizcar.

Alfredo Martín Díaz   Desarrollo de software para iPhone

Simulaciones de alerta con memoria baja.

Sin embargo, el simulador del iPhone, es un simulador de software real, el cuál tiene sus limitaciones, algunas características no incluidas en el simulador son las siguientes: 

La obtención de datos de localización.



Realización de llamadas telefónicas.



Acceso al acelerómetro.



Enviar y recibir mensajes SMS.



Instalación de aplicaciones de la App Store.



Características de la cámara y micrófono.



Varias características de OpenGL ES.

La velocidad del simulador del iPhone se encuentra acoplada con las características del sistema Mac en cuestión, que puede ser muy diferente a como sería en el propio dispositivo. Por lo tanto, es fundamental probar la aplicación en el dispositivo real, en lugar de confiar en el simulador para la prueba, aunque para las pruebas iniciales es el más recomendado. A pesar de las limitaciones mencionadas con el simulador del iPhone, se trata de una herramienta muy útil para conseguir aplicaciones probadas. Dicho esto, probar la aplicación en un iPhone real es algo imprescindible antes de implementarla en la App Store.

Escuela Técnica Superior de Ingeniería (ICAI)  

46

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.5.5 Interface Builder Es la herramienta para el desarrollo visual de la interfaz gráfica de las aplicaciones tanto para Mac como para el iPhone. Mediante drag and drop ( arrastrar y soltar ) se van añadiendo los componentes, controles y creando la interfaz de la aplicación. Se genera código envuelto en ficheros .nib ( ficheros de descripción de la componente gráfica ) que se cargan al arrancar la aplicación y que usa Cocoa Touch para pintar la ventana con sus componentes, vistas y controles en la pantalla. El uso de Interface Builder reúne varias ventanas de la aplicación arrastrando y soltando diferentes componentes preconfigurados en él, como se puede ver en la Fig.14.

Figura 14.Construcción de la interfaz con Interface Builder

Escuela Técnica Superior de Ingeniería (ICAI)  

47

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Los componentes incluyen un sistema de controles estándar tales como campos de texto y botones, y también puntos de vista personalizados para representar los puntos de vista de la aplicación en cuestión. Una vez colocados los componentes en la superficie de la ventana, se pueden posicionar arrastrando por la superficie, configurar sus atributos con el inspector, y establecer las relaciones entre los objetos y el código. Los ficheros .nib creados en Interface Builder contienen toda la información que UIKit necesitará para recrear los mismos objetos en su aplicación, y todo ello ya en tiempo de ejecución. Al cargar un fichero .nib se crean diferentes versiones en tiempo de ejecución de todos los objetos almacenados en el archivo, es decir, de la configuración realizada con Interface Builder. También utiliza la información de conexión que se haya especificado para establecer conexiones entre los objetos de nueva creación y todos los objetos existentes en la aplicación. Estas conexiones proporcionan el código con punteros a los objetos de tipo fichero .nib y también proporcionar la información que los propios objetos necesitan para comunicar las acciones del usuario en su código. En general, el uso de Interface Builder ahorra una enorme cantidad de tiempo cuando se trata de la creación de la interfaz de usuario de la aplicación. Interface Builder elimina el código personalizado necesario para crear, configurar, y la posición de los objetos que componen la interfaz. Debido a que es un editor visual, se llega a ver exactamente lo que se verá en tiempo de ejecución.

Escuela Técnica Superior de Ingeniería (ICAI)  

48

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.6 Arquitectura El desarrollo en el iPhone se basa en el uso de una variedad de frameworks y tecnologías sobre las que el programador se irá apoyando para construir su nueva aplicación. El SDK permite el acceso a estos recursos mediante una arquitectura por capas partiendo de las funciones más básicas y cercanas a la máquina, y terminando por las tareas más sofisticadas como los efectos gráficos. La implementación del sistema iPhone OS se puede ver como un conjunto de capas, donde la capa más baja corresponde a los servicios fundamentales en los cuales la aplicación delega mientras las capas superiores contienen los servicios y tecnologías más sofisticadas.

Figura 15. Arquitectura del sistema operativo del iPhone

Escuela Técnica Superior de Ingeniería (ICAI)  

49

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.6.1 Cocoa Touch Cocoa Touch es la capa más importante de todas en el iPhone OS, ella comprende dos frameworks fundamentales, como son el UIKit y el Foundation framework, es decir, es principalmente la capa del interfaz del usuario. Es la versión para iPhone de Cocoa de Mac OS X con lo que conserva muchas de sus características como el modelo vista controlador. Además ofrece la posibilidad de integrar aplicaciones entre sí mediante mensajes. Se puede decir que Cocoa Touch es una evolución del API, ya existente en la plataforma Mac, llamada Cocoa, añadiendo características para el soporte de la tecnología multitáctil. En la siguiente imagen se puede ver la pequeña diferencia a grandes rasgos entre Cocoa, utilizado en el desarrollo de aplicaciones para Mac OS X, y Cocoa Touch

Figura 16. Cocoa Touch

Los dos Frameworks Objective-C que contiene son: 1)

UIKit: Framework en Objective-C que provee la infraestructura para la implementación de los gráficos, la estructura de la aplicación, el control de los eventos, el manejo de la interfaz, la representación de las vistas y controles así como el soporte de texto y contenido web. Soporta a su vez código para el manejo del acelerómetro, la cámara, la librería de fotos o toda la información que posee el dispositivo.

Escuela Técnica Superior de Ingeniería (ICAI)  

50

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Aunque el conjunto de clases es mucho más extenso, las más significantes se pueden observar en la siguiente imagen:

Figura 17. Framework UIKit

2)

Foundation: Framework en Objective-C que define el acceso y manejo de objetos, provee acceso a los tipos de datos primitivos, colecciones y servicios del sistema operativo. Se puede trabajar con ficheros de bajo

Figura 18. Framework Foundation

Escuela Técnica Superior de Ingeniería (ICAI)  

51

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Los principales elementos de la capa de Cocoa Touch son: 

Eventos y controles multi-Touch.



Acelerómetro.



Jerarquía de vistas.



Localización.



Alertas.



Vistas Web.



Selector de personas y de imágenes.



Controladores.

3.6.2 Media Esta capa contiene los frameworks y servicios dependientes de Core Services y que proveen los servicios de gráficos y multimedia a la capa superior, Cocoa Touch. Incluye tecnologías de Video, además de ofrecer varias tecnologías para dibujar en 2d y 3d con mayor o menor nivel de abstracción. La capa se compone de los siguientes componentes principales: 

Core Audio.



Open GL.



Mezcla y grabación de audio.



JPG, PNG, TIFF.



PDF.



Core Animation.



Open GL ES.

Escuela Técnica Superior de Ingeniería (ICAI)  

52

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.6.3 Core Services La capa Core Services proporciona un acceso fundamental a los servicios del iPhone OS. Proporciona una abstracción de los servicios prestados en la capa de núcleo del sistema operativo. Los frameworks de esta capa proveen la manipulación de strings, colecciones, el manejo de contactos y las preferencias así como las utilidades de URL o de la red. Esta capa incluye el Framework Core Foundation, el cuál ofrece una abstracción a los tipos de datos, como strings y colecciones. Es decir, principalmente se encuentra compuesta por Core Foundation y CFNetwork, donde la primera es una serie de librerías construidas sobre la capa anterior que facilitan el manejo de colecciones, fechas URLs, Streams y mucho más. CFNetwork se centra en el uso de protocolos tales como http, FTP, Bonjour, etc. Además en Core Services se ofrecen frameworks que ayudan en temas de seguridad así como manejo de bases de datos SQLite para las aplicaciones y XML. La capa de la base de servicios consta de los siguientes componentes: 

Colecciones.



Agenda de direcciones.



Creación de redes.



Acceso a los ficheros.



SQLite.



Core Location.



Servicios de red.



Hilos.



Preferencias.



Utilidades URL.

Escuela Técnica Superior de Ingeniería (ICAI)  

53

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.6.4 Core OS Se trata de la capa inferior del sistema operativo que contiene el Kernel (que es la base del sistema operativo), los ficheros del sistema y la infraestructura de red, seguridad, manejo de la memoria y los drivers del dispositivo, es decir, de aquello más cercano al sistema operativo y la máquina. Permite acceso a utilidades como: Hebras (POSIX), Redes (Sockets de BSD), entrada y salida estándar, sistema de ficheros, manejo de memoria…etc. El núcleo del sistema operativo tiene elementos tales como: 

OS X Kernel.



Mach 3.0.



Sockets de BSD.



Seguridad.



Administración de energía.



Llavero de certificados.



Sistema de archivos.

3.7 Tecnologías 3.7.1 XML Libxml2 es el analizador XML C y kit de herramientas desarrolladas para el proyecto GNOME (pero utilizable fuera de la plataforma Gnome), es software libre disponible bajo la licencia MIT. XML es en sí un metalenguaje para diseñar lenguajes de marcado, idioma de los textos, es decir, cuando semántica y la estructura se añade al contenido utilizando extra “marcado” la información encerrada entre paréntesis angulares. HTML es el lenguaje de marcas más conocidas. Aunque la biblioteca está escrita en C, una variedad de enlaces de lenguaje que esté disponible en otros entornos. Libxml2 es conocido por ser muy portable, la biblioteca debe construir y trabajar sin problemas graves en una variedad de sistemas (Linux, Unix, Windows, Cygwin,

Escuela Técnica Superior de Ingeniería (ICAI)  

54

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

MacOS, MacOS X, RISC OS / 2, VMS, QNX, MVS, Vx Works, ….). Libxml2 implementa una serie de normas existentes para relacionarse con los diferentes lenguajes. XML es un estándar basado para documentos estructurados de marcado. En la Fig.19 se muestra un ejemplo de documento XML.

Figura 19. Ejemplo de documento XML

La primera línea especifica que se de trata de un documento XML y ofrece información útil acerca de su codificación. Luego el resto es un formato de texto cuya estructura se especifica por etiquetas entre paréntesis. Cada etiqueta abierta tiene que ser cerrada posteriormente. Sin embargo, si una etiqueta está vacía (es decir, sin ningún contenido) , una sola etiqueta puede servir tanto a la apertura y etiqueta de cierre si termina con /> en lugar de con >. Se debe tener en cuenta, que por ejemplo la etiqueta de imagen no tiene contenido (sólo un atributo) y se cierra, poniendo fin a la etiqueta con />. XML puede aplicarse con éxito a una amplia gama de tareas, que van desde el mantenimiento del documento a plazos largos estructurados (en donde se siguen los pasos de SGML) para datos simples con mecanismos de codificación como la configuración de formatos de archivo, hojas de cálculo (gnumeric), o incluso documentos de vida más corta, tales como WebDAV, donde se utiliza para codificar las llamadas remotas entre un cliente y un servidor.

Escuela Técnica Superior de Ingeniería (ICAI)  

55

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

XML es un lenguaje de marcado que permite describir la estructura de los datos de un documento totalmente en texto, utilizando etiquetas que se pueden definir arbitrariamente. (“XML” significa “Extensible Markup Language”). Las normas que rigen la estructura se especifican en un esquema de lenguaje como DTD (Document Type Definition). Cocoa proporciona una clase, NSXMLParser, cuyas instancias son los analizadores basados en eventos (a veces llamados analizadores de transmisión) que de forma secuencial encuentran las construcciones de un documento XML, así como las declaraciones DTD asociado. Informan lo que encuentran a un delegado, y le corresponde al delegado de hacer algo con estos datos. La forma más sencilla para entender y utilizar NSXMLParser se muestra a continuación: Analizador de Capacidades y Arquitectura Hay dos enfoques generales de análisis y manejo de XML, cada uno con su propio estilo de API: 

Árbol API: basado en acercar los mapas de un documento XML hacía una estructura de árbol interior que se ajusta a una estructura lógica, la cuál facilita la navegación y la manipulación de dicho árbol. Un ejemplo de API basada en árboles, sería incluir el DOM (Document Object Model), propuesto por el World Wide Web Consortium (W3C). El lenguaje XML Path (XPath), XML Incluye (XInclude) y XML Pointer Language (XPointer) son WC3 interfaces de programación para realizar consultas y el manejo del XML en las estructuras de árbol DOM de estilo.



A través de eventos de la propia API: En este enfoque el analizador de informes de análisis de eventos (como el inicio y final de cada elemento) de una aplicación, se encarga de encontrarlo. En la API basada en C, dicha información se obtiene a través de llamadas implementadas por la aplicación para manejar los tipos de eventos. SAX es el ejemplo

Escuela Técnica Superior de Ingeniería (ICAI)  

56

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

más conocido de este estilo de API de análisis. Este tipo de analizador es a veces conocido como un analizador de secuencias. La clase NSXMLParser adopta el estilo orientado a eventos de procesamiento. Pero en vez de usar las devoluciones de llamada, un objeto NSXMLParser (o simplemente, un programa de análisis) envía mensajes a su delegado, que envía un mensaje diferente para cada tipo de análisis de eventos. A medida que el programa de análisis secuencial encuentra cada elemento de un XML o DTD de archivo de elementos, atributos, declaración, referencia de la entidad, y así sucesivamente, informa a su delegado (si el delegado implementa el método asociado), junto con cualquier contexto que lo rodea. No hace nada con el tema, excepto reportarlo.

En la realización de los diferentes prototipos se ha enfatizado el control y los diferentes aspectos del paradigma Modelo-Vista-Controlador, donde cada una de las aplicaciones desarrolladas han leído los datos de fuera del paquete de solicitud, ningún prototipo ha salvado sus datos a través de cualquier forma de almacenamiento persistente, del equipo o dispositivo; con la excepción de la configuración de la aplicación, es decir, todas las aplicaciones o prototipos analizados no guardan ni utilizan el almacenamiento volátil o no persistente, ya que en cada solicitud de lanzamiento de la misma, aparecía exactamente con los mismos datos que tenía la primera vez que se lanzó. Este enfoque ha servido para analizar los diferentes prototipos analizados en el punto 4.1, pero en el mundo real, las aplicaciones deben conservar datos de manera que cuando los usuarios hagan cambios, los cambios se almacenen y estén ahí cuando se inicie el programa de nuevo, para esto existen una serie de diferentes mecanismos disponibles para la persistencia de datos en el iPhone:  El uso de listas de propiedades (Property List). (Esta ha sido la usada en la aplicación desarrollada).  Los archivos objeto (o archivado).  El incrustado de la base de datos relacional llamada SQLite3.  Herramienta de persistencia llamada Datos Básicos.

Escuela Técnica Superior de Ingeniería (ICAI)  

57

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Property List, Archivos Objeto, SQLite3 y Datos Básicos no son las únicas formas para lograr la persistencia de los datos en un iPhone. Son las formas más comunes de lograrlo y las más fáciles. Pero también se tiene la opción de utilizar las tradicionales llamadas como fopen () para leer y escribir datos. También se puede utilizar del bajo nivel de Cocoa las herramientas de administración de archivos; lo cuál puede dar lugar a un esfuerzo mucho más grande en cuanto a codificación y raras veces se precisa, pero dichas herramientas son utilizables también. Cada uno de estos cuatro mecanismos de persistencia de datos citados comparten un elemento común importante, su aplicación o carpeta de documentos. Cada aplicación tiene su propia carpeta de documentos, y a las aplicaciones sólo se les permite leer y escribir desde su propio directorio / Documentos. Para darle un poco de contexto, se abre un ventana del Finder, y se accede al directorio personal, luego se accede a Library / Application Support / iPhoneSimulator / usuario /. A partir de aquí se ven cinco subcarpetas, una de las cuáles lleva el nombre de las aplicaciones.

Figura 20. Guía de usuario que muestra la carpeta de aplicaciones

Aunque esta lista representa el simulador, la estructura de archivos es similar a lo que hay en el dispositivo real. Como es de esperar, la carpeta de aplicaciones es donde almacena el iPhone sus aplicaciones. Si se accede a la carpeta de aplicaciones, se observan un montón de carpetas y archivos con nombres que son cadenas largas de caracteres. Estos nombres son generados automáticamente por Xcode. Cada una de estas carpetas contiene una aplicación y sus propias carpetas de apoyo. Escuela Técnica Superior de Ingeniería (ICAI)  

58

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En los directorios de la aplicación se observan archivos .sb, los cuáles contienen ajustes que el simulador utiliza para lanzar el programa que comparte el mismo nombre (nunca es necesario tocar dichos datos). Si se abre una aplicación de archivos, se deberá ver algo más familiar, se encontrará una de las aplicaciones del iPhone que se ha construido, junto con tres carpetas de apoyo: documentos, Biblioteca, y tmp. Dicha aplicación almacena sus datos en los documentos, con excepción de las configuraciones de preferencia basada en NSUserDefaults, que se almacena en la carpeta Library / Preferences. El directorio tmp ofrece un lugar donde la aplicación puede almacenar los archivos temporales, los archivos escritos en / tmp no serán respaldados por iTunes al sincronizar el dispositivo iPhone, pero la aplicación debe asumir la responsabilidad de eliminar los archivos en / tmp, una vez que ya no sean necesarios para evitar llenar su sistema de archivos. Para obtener el directorio de documentos, dado que la aplicación está en una carpeta con un nombre aparentemente al azar, la forma de recuperar la ruta completa del directorio de documentos de modo que se pueda leer y escribir en los archivos es en realidad bastante fácil, ya que la función en C NSSearchPathForDirectoriesInDomain () localizará directorios diversos, se trata de una función de Foundation, por lo que s comparte con Cocoa para Mac OS X. Muchas de sus opciones disponibles están diseñadas para OS X y no devolverá ningún valor en el iPhone, ya sea porque dichos lugares no existen en el iPhone (por ejemplo, la carpeta de descargas) o porque la aplicación no tiene derecho a acceder a la ubicación debido a un mecanismo sandboxing del iPhone. Aquí está algo de código para recuperar la ruta con los documentos del directorio: NSArray  *paths  =  NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,   NSUserDomainMask,  YES);   NSString  *documentsDirectory  =  [paths  objectAtIndex:0];

La constante NSDocumentDirectory dice que se esta buscando la ruta de acceso al directorio de documentos. La segunda constante, NSUserDomainMask, indica que se quiere restringir la búsqueda en la propia aplicación. En Mac OS X, está misma

Escuela Técnica Superior de Ingeniería (ICAI)  

59

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

constante se utiliza para indicar que se quiere que la función de buscar en el directorio home del usuario, lo cuál explica el nombre tan extraño. Se puede tener en cuenta el directorio de documentos que residen en el índice 0 de la matriz, debido que se sabe que sólo un directorio cumple con los criterios que se han especificado, ya que cada aplicación tiene un único directorio de documentos. Se puede crear un nombre de archivo para lectura o escritura, y si se añade otra cadena en el extremo de la ruta que se acaba de recuperar se tendrá que usar el método NSString diseñado para el fin denominado stringByAppendingPathComponent: , asi: NSString  *filename  =  [documentsDirectory  stringByAppendingPathComponent:@”theFile.txt”];    

Después de esta llamada, el nombre del fichero que contiene la ruta completa a un archivo llamado theFile.txt en nuestra aplicación del directorio de documentos, y en donde se puede usar el nombre de archivo para crear, leer, y escribir de ese archivo. Para obtener el directorio tmp, se debe obtener una referencia al directorio temporal de la aplicación, lo cuál es más fácil que obtener una referencia al directorio de documentos. La función de llamada Foundation NSTemporaryDirectory () se encargará de devolver una cadena que contiene la ruta completa al directorio temporal de la aplicación. Para crear un nombre de archivo para un archivo que se almacena en el directorio temporal, lo primero que se encontraría sería lo siguiente:

NSString  *tempPath  =  NSTemporaryDirectory();

Luego se creará una ruta a un archivo en ese directorio y se añadirá un nombre de archivo de dicho camino, así: NSString  *tempFile  =  [tempPath  stringByAppendingPathComponent:@”tempFile.txt”];    

Estrategias de ahorro en los archivos; en el caso de SQLite3, se creará una base de datos única SQLite3, la cuál se preocupará del almacenamiento y recuperación de los datos. En la forma más simple, Core Data se encarga de toda la gestión del sistema de archivos. Con la persistencia de otros dos mecanismos, listas de propiedades (Property

Escuela Técnica Superior de Ingeniería (ICAI)  

60

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

List), y el archivo, se deberá pensar en si se van a almacenar los datos en un único archivo o en varios.  

La persistencia de un único archivo, hace que el uso de un solo archivo sea el método más sencillo y con muchas aplicaciones. Se comienza creando un objeto de raíz, por lo genera un NSArray o NSDictionary, aunque el objeto raíz también puede basarse en una clase personalizada utilizando un archivo. Posteriormente, se rellena el objeto raíz con toda la información con la cuál posteriormente debe persistir. Cuando se guarda, el código vuelve a escribir el contenido completo de dicho objeto raíz en un solo archivo, así cuando la aplicación se inicia, leerá todo el contenido de dicho archivo de la memoria, y cuando se cierra, escribirá todo el contenido. El incoveniente de usar un único archivo es que tiene que cargar todos los datos de la aplicación en la memoria, y se tendrá que escribir todo lo que contiene la misma al correspondiente sistema de archivos, incluso se deberá hacer para los cambios más pequeños. La persistencia de archivos múltiples, dicho enfoque es definitivamente uno de lo más complicados. Este método da la oportunidad de liberar memoria cuando se recibe una notificación con poca memoria, ya que toda la memoria que se utiliza para almacenar datos que el usuario no use en el momento pueden eliminarse y simplemente se volverán a cargar al archivo del sistema la próxima vez que se necesiten. El lado negativo de la persistencia sobre múltiples archivos es que se añade una buena cantidad de complejidad sobre la aplicación, por lo cuál es mejor la persistencia de un único archivo. En lo referente a la persistencia de datos de aplicaciones, los métodos más importantes de persistencia son: listas de propiedades, los archivos objeto, SQLite3 y Datos Básicos. Respecto a la serialización de Property List o lista de propiedades, la aplicación Puntos de acceso desarrollada ha hecho uso de listas de propiedades para especificar las preferencias de la aplicación, una property list suele ser conveniente ya que puede ser editada manualmente usando Xcode o la aplicación de la lista Editor de propiedades, y

Escuela Técnica Superior de Ingeniería (ICAI)  

61

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

en ambos casos NSArray y NSDictionary pueden ser escritos y creados a partir de listas de propiedades, siempre y cuando la matriz correspondiente contenga el diccionario o sólo los objetos serializables específicos. Un objeto serializado se ha convertido en una secuencia de bytes para que pueda ser almacenado en un archivo o transferido a través de una red. Aunque cualquier objeto puede ser serializable, sólo algunos objetos se pueden colocar en una clase de colección, como un NSDictionary o NSArray, y se almacenan

en

una

property

list

utilizando

las

clases

de

colección

“writeToFile:atomically:method”. Las clases en Objective-C que se pueden serializar de esta manera son:  NSArray  NSMutableArray  NSDictionary  NSMutableDictionary  NSData  NSMutableData  NSString  NSMutableString  NSNumber  NSDate Si se va a construir un modelo de datos de sólo objetos, se pueden utilizar property list para guardar fácilmente y cargar los datos. Si se utilizan listas de propiedades para persistir los datos de las aplicaciones, se deberá usar ya sea un NSArray o NSDictionary para contener los datos que persisten. Suponiendo que todos los objetos que se ponen en el NSArray o NSDictionary son objetos serializables, se puede escribir una Property list mediante una llamada al writeToFile:atomically:method en el diccionario o en instacia de la matriz, de este modo: [myArray  writeToFile:@”/some/file/location/output.plist”atomically:YES];  

Escuela Técnica Superior de Ingeniería (ICAI)  

62

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El parámetro atomically dice el método para escribir los datos a un archivo auxiliar, no a la ubicación especifica. Cuando el archivo se ha escrito de una forma correcta, se copia dicho archivo auxiliar para así tener la ubicación especifica. Esta forma es una manera más segura de escribir un archivo, ya que si la aplicación se bloquea al guardar, el archivo existente, si lo hubo, no será dañado. Tiene el incoveniente de añadir un poco de sobrecarga, pero en general vale la pena el coste. Un problema con el enfoque de la lista de propiedades (Property list) es que los objetos no se puedan serializar en listas de propiedades. Tampoco se pueden usar otras clases de Cocoa Touch que no sean de la lista comentada anteriormente de objetos serializables, lo que significa que las clases como NSURL, UIImage, UIColor no se pueden utilizar directamente. No lograr serializar los objetos significa que no se pueden crear fácilmente las propiedades de derivados ni calculados (por ejemplo, una propiedad que es la suma de otras dos propiedades), y algunos de su código que realmente deberían estar contenidos en las clases del modelo y se tienen que trasladar a las clases del controller. Esto hace que estas restricciones esten bien para los modelos de datos simple y aplicaciones sencillas. La mayoría de las veces, la propia aplicación será mucho más sencilla de mantener si se creal clases dedicadas del modelo. A pesar de lo anterior, las listas de propiedades pueden ser útiles en aplicaciones complejas. Son una gran maner de incluir los datos estáticos en la aplicación. Por ejemplo, cuando una aplicación incluye un selector, a menudo la mejor manera de incluir la lista de elementos para ir en su selector es crear una lista de propiedades del archivo e incluirlo en la carpeta del proyecto en recursos, y así se compilarán en la solicitud.

Escuela Técnica Superior de Ingeniería (ICAI)  

63

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3.7.2 Wi-Fi Hoy en día las tecnologías para red de área local (LAN) inalámbrica están experimentando un gran avance, sobre todo en el campo de la implantación. Numerosos proveedores de redes wireless están instalando sus sistemas en hoteles, cafés, aeropuertos y otros edificios en los que se considera rentable una oferta de acceso a Internet de alta velocidad. Estas nuevas infraestructuras también soportan localización de dispositivos móviles, por lo que las aplicaciones basadas en la posición para entornos de área local resultan viables. En el ámbito del patrimonio y el turismo, se han puesto en funcionamiento redes de este tipo de forma experimental en museos, excavaciones arqueológicas, hoteles y parques temáticos, todo esto con el fin de ofertar servicios basados en la filosofía de suministrar al usuario información de interés ligada a su posición. Antes de explicar el proceso de localización de terminales mediante redes inalámbricas, es necesario saber de qué tipo de tecnología se está hablando. Las redes inalámbricas cubren áreas de hasta 75 metros en el interior de edificios, y de 300 metros en el exterior, ampliables a varios kilómetros mediante antenas. Están implementadas en un grupo de estándares, conocido como 802.11 que comprende varias modalidades, cada una de ellas con unas características de ancho de banda y alcance determinadas. La modalidad más popular es la que se conoce como 802.11b, introducida en 1997. Opera a una frecuencia de 2,4 GHz, y su índice de transferencia de datos es de 11Mbps. Esta tasa se ve ampliamente superada por el estándar 802.11a, que llega a ofrecer 55Mbps en una frecuencia de funcionamiento de 5GHz. El problema es que dicha parte del espectro no está disponible en países como España, Italia, Portugal o Alemania, pues es de uso restringido militar. Algunas estimaciones afirman que a finales de 2008 había en Europa 53 millones de dispositivos de WLAN (Wi-Fi). La localización mediante redes locales inalámbricas puede llevarse a cabo de diferentes maneras. La más sencilla es la basada únicamente en el punto de acceso más cercano al terminal. Este método confunde a menudo la planta del edificio, pues es fácil que la antena más cercana a un usuario ubicado en una determinada planta sea la misma que la

Escuela Técnica Superior de Ingeniería (ICAI)  

64

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

correspondiente a un usuario situado en una planta superior, si la posición sobre el piso es similar. Por otra parte la señal es vulnerable debido a las interferencias, lo que puede afectar, además de a la precisión, a la seguridad de la comunicación.

3.8 Proceso de desarrollo de una aplicación en el iPhone El tamaño de la pantalla es considerablemente menor que en un Mac, por tanto el desarrollador debe tener en cuenta dicho aspecto durante todo el desarrollo y más concretamente durante el diseño de la interfaz de usuario. El tamaño es exactamente de 480*320, por tanto la interfaz de usuario se debe centrar en lo esencial que el usuario pueda necesitar en cada pantalla, o mejor dicho en cada vista. El uso de la memoria es crucial en cualquier software, pero cuando se habla de móviles lo es aún más. El iPhone no dispone de espacio de cache para la memoria luego hay que tener especial cuidado con el uso de memoria que la aplicación lleva a cabo en cada momento. Para ello, se ofrece al desarrollador la aplicación Instruments a través de la cual se puede monitorizar el uso que está realizando una aplicación en cada momento. El iPhone sólo permite que haya una aplicación corriendo o ejecutándose a la vez. Entonces si se está utilizando una aplicación y el teléfono suena o llega un mensaje, la aplicación se cierra (entra en modo pausa) y se deben guardar tanto los datos como el estado de la aplicación lo más rápido posible, para ofrecer al usuario un entorno rico y agradable, y no ofrecer una experiencia de usuario negativa. Una de las grandes diferencias entre una aplicación de escritorio y una aplicación para un móvil, y es que el iPhone sólo permite una ventana simultánea en el dispositivo. Dicha ventana puede tener varias vistas pero el usuario accederá a ellas de manera secuencial y nunca simultáneamente. Una de los aspectos más importantes a tener en cuenta en el desarrollo de una aplicación es la simplicidad, es decir, que el usuario una vez que arranque una aplicación nunca

Escuela Técnica Superior de Ingeniería (ICAI)  

65

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

debe preguntarse que hacer o como hacer tal cosa. Por lo tanto, la simplicidad de una aplicación debe ser absoluta evitando tener que recurrir a implementar una ayuda.

A la hora de diseñar una aplicación existen tres opciones actualmente: o Aplicación web: Aplicación basada en solamente en contenido web, adaptado a la pantalla y uso del iPhone. o Aplicación nativa: Aplicación que reside en el teléfono y que hace uso de todas las tecnologías del iPhone. o Híbrido entre los dos anteriores: Aplicación nativa en el iPhone pero que parte de sus funcionalidades e infraestructura la lleva a cabo a través de una aplicación web. Hay que saber que existen, fundamentalmente, tres tipos de estilo de aplicaciones: 1)

Aplicaciones Productivas

Figura 21. Aplicaciones productivas

Escuela Técnica Superior de Ingeniería (ICAI)  

66

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Las aplicaciones productivas son esa clase de aplicaciones donde prima ante todo la organización y manipulación de la información. El usuario en este tipo de aplicaciones agradece ante todo encontrar fácilmente la información, sin prestar demasiada atención a la interfaz de usuario.

La información, en este tipo de aplicaciones, se aconseja mostrarla de lo más general a lo más específico, permitiendo que sea el usuario quien navega si lo desea de menús más generales a menús con un nivel de detalle mayor. 2)

Aplicaciones de utilidad

Figura 22. Aplicaciones de utilidad

Las aplicaciones de utilidad se caracterizan por requerir la mínima acción del usuario para mostrar la información. Suelen ser visualmente atractivas y la información se organiza en una sucesión de vistas.

Escuela Técnica Superior de Ingeniería (ICAI)  

67

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El usuario no necesita navegar en vistas más específicas para encontrar la información, sino que el tipo de información es la misma en cada vista. El usuario navega por las diferentes vistas para encontrar la misma información pero de diferentes objetos.

3)

Aplicaciones a pantalla completa

Figura 23. Aplicaciones a pantalla completa

Este tipo de aplicaciones ofrecen todo su contenido a pantalla completa y con una riqueza visual excelente. Videojuegos, música o reproductores de vídeo son las que encajan en este tipo de aplicaciones donde lo que busca el usuario es divertirse y pasarlo bien. Se basan en el contenido visual y en la experiencia de usuario. Utilizan una cantidad enorme de información pero que no se muestra al usuario, por lo que éste no necesite que se le muestren barras de navegación o métodos de acceder a la información como sucede en las dos clases anteriores de aplicaciones. Una vez comentados los tipos de aplicación, y los diferentes estilos que se pueden escoger como desarrollador, se citan algunas recomendaciones básicas para obtener una buena aplicación móvil: 

Definir exactamente el producto o aplicación.



Conocer la audiencia hacia la cual va dirigida la aplicación, es decir, saber si son novatos o usuarios expertos.

Escuela Técnica Superior de Ingeniería (ICAI)  

68

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone



Debe ser sencilla, y abrirse y cerrarse lo más rápido posible.



Se debe utilizar una gama de colores para la interfaz gráfica que transmita al usuario un feeling de lo que es la aplicación.



Hacer la aplicación simple y fácil de usar.



Separar adecuadamente los botones, o cualquier objeto sustancial de ser pulsado con los dedos, para evitar pulsaciones erróneas por parte del usuario.



Utilizar barras de estado adecuadas para la aplicación.



Evitar pantallas de bienvenida o Acerca de nada más lanzarse la aplicación.



Por defecto, el uso debe de ser en modo vertical y no forzar que cuando la aplicación se hace el usuario tenga que rotar el dispositivo.



Almacenar el estado de la aplicación cuando se cierra y restaurarla adecuadamente para ofrecer una experiencia de uso rica.



Implementar o tener presente en todo momento que hacer cuando la aplicación recibe una notificación de falta de memoria, evento que puede producirse dentro del ciclo de vida de una aplicación.

El último punto a abordar en el desarrollo de una aplicación de forma eficiente, es conocer el entorno de ejecución de la aplicación en el iPhone. El entorno está continuamente recibiendo eventos del sistema y respondiendo a dichos eventos presentándolos al usuario de manera adecuada; este es el patrón de diseño llamado “Event and drawing cycle”.

Escuela Técnica Superior de Ingeniería (ICAI)  

69

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 24. Diseño Event and drawing cycle

Una vez que la aplicación se ejecuta, el sistema operativo del iPhone llama a la función Main (punto de entrada en cualquier aplicación). La principal clase es la UIApplicationMain, la cual inicializa el Event and Drawing Cycle.

Figura 25. Main en una aplicación del iPhone

El sistema detecta los eventos ocurridos en el dispositivo y los coloca en la cola de eventos de la aplicación. El objeto de la aplicación coge el evento superior de la cola y lo delega en el objeto determinado para su ejecución.

Escuela Técnica Superior de Ingeniería (ICAI)  

70

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En la Fig.26 se muestra el ciclo de vida de una aplicación:

Figura 26. Ciclo de vida de una aplicación

Como se puede observar en el diagrama, una vez que el usuario presiona el icono de la aplicación se inicia el Events and Drawing cycle, el cual captura los eventos y responde ante ellos. Pero existen eventos que pueden parar dicho ciclo de ejecución, como puede ser que el usuario presione el botón de Home o reciba una llamada de teléfono, o recibir una notificación de falta de memoria. Al sólo poder ejecutarse una aplicación simultáneamente, la actual se cerrará terminando su ejecución.

Escuela Técnica Superior de Ingeniería (ICAI)  

71

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

4. Alcance del proyecto 4.1 Objetivos Los principales objetivos que cubre el proyecto son los siguientes:

1) Documentación sobre la plataforma. Para el desarrollo de una aplicación que pueda ser instalada de manera oficial en el iPhone se dispone de tres herramientas principalmente: XCode, Interfaz Builder, Instruments.

2) Pruebas de implantación sobre el iPhone. Para poner las aplicaciones a disposición de los usuarios, hay que darse de alta en uno de los tres planes que Apple ha puesto a disposición de los desarrolladores. Una vez elegido el plan (comercial, autónomo o empresa) y realizado el pago de la correspondiente cuota anual, el desarrollador puede categorizar su aplicación y ponerla/subirla a la plataforma de distribución App Store eligiendo el mismo precio de la misma así como permitir su descarga gratuita. El usuario, por contraste, accederá al App Store desde la aplicación iTunes de su Mac o PC. Una vez elegida la aplicación ha descargar y realizado el pago si ésta lo requiere se descargará automáticamente a su PC o Mac y ya podrá instalarla en el iPhone o iPod Touch de nuevo a través de la aplicación iTunes.

Escuela Técnica Superior de Ingeniería (ICAI)  

72

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

3) Desarrollo de la aplicación final. La aplicación final desarrollada consiste en la gestión y administración de diferentes puntos de acceso dentro del dispositivo y en formato XML. En dicha aplicación se cargarán los puntos de acceso en formato de tabla, y pulsando cada item se podrá acceder a una vista donde se verán los cuatro campos de información (nombre, mac, posición, descripción), también se podrán añadir, editar, desplazar, guardar y borrar cada uno de los correspondientes puntos de acceso.

Escuela Técnica Superior de Ingeniería (ICAI)  

73

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

4.2 Motivación La sociedad actual en los últimos años se esta fijando en gran medida en las nuevas tecnologías, debido al gran éxito que están desarrollando, como en el caso de la telefonía móvil, que esta de una manera muy activa presente en la vida diaria. Nos encontramos ante un nicho todavía en evolución, es decir, en crecimiento continuo. El número de dispositivos móviles y el número de tecnologías nacidas a su alrededor es cada vez más grande. La presentación del iPhone en Enero de 2007 fue un revulsivo en todo el panorama internacional pero aún lo fue más la salida en Febrero de 2008 del SDK para el iPhone OS, el conjunto de herramientas y documentación para poder desarrollar, probar las aplicaciones para el iPhone. El desarrollo para dispositivos móviles abarca uno de los aspectos más importantes y con más evolución dentro de la informática de los últimos años. Este proyecto pretende profundizar en el estudio de la plataforma iPhone, ya que la programación es aún muy nueva, para finalmente desarrollar un prototipo final. En relación con los sistemas operativos, estos desempeñan 5 funciones básicas en la operación de un sistema informático: suministro de interfaz al usuario, administración de recursos, administración de archivos, administración de tareas y servicio de soporte y utilidades. Lo más esencial e importante en un sistema operativo es el núcleo (kernel). Android usa un kernel Linux, con una mezcla especial de Java. El iPhone se basa en OS X, que a su vez es una variante de Unix, uno de los sistemas operativos más poderosos en el mundo de la informática. S60 y Windows Mobile son sistemas operativos muy maduros y estables, aunque la edad no siempre es una ventaja. Por último, RIM usa un kernel propio, que al igual que Android, tiene un motor Java, y aunque han mejorado la interfaz notablemente, suele mostrar algunas limitaciones propias de su edad.

Escuela Técnica Superior de Ingeniería (ICAI)  

74

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

4.3 Justificación El desarrollar tanto para dispositivos móviles como para la plataforma Mac OS X ha provocado en el iPhone junto con la distribución del SDK una oportunidad para crear aplicaciones sobre un dispositivo que integra una cantidad enorme de nuevas tecnologías. El uso de la interfaz multitáctil, los acelerómetros o la localización permiten crear aplicaciones o videojuegos con una riqueza visual, interfaz y sobre todo experiencia del usuario. Disponer de buenas herramientas de desarrollo y de una plataforma estable que lo sustenta todo, basada en Mac OS X y con Cocoa Touch como estandarte, hace que el proceso de desarrollo de una aplicación para el iPhone se centre exclusivamente en transmitir correctamente el objetivo o finalidad de la aplicación desarrollada. El aprendizaje por tanto se resume en conocer principalmente el lenguaje ObjetiveC y estudiar el framework Cocoa Touch, el desarrollo y distribución es más sencillo. Los operadores móviles y los proveedores de software para móviles tienen la esperanza de que el efecto del 3G y la cantidad de móviles de estas características que se están vendiendo en la actualidad provoquen un cambio drástico en la industria de las aplicaciones móviles, consiguiendo expandir el uso de dichas aplicaciones y servicios de una manera comercial. Ejemplos de aplicaciones comerciales pueden ser: servicios de información, anuncios, servicios basados en contenido, servicios basados en localización o aplicaciones de pago sobre móvil.

Escuela Técnica Superior de Ingeniería (ICAI)  

75

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 27. Evolución de los pedidos móviles, terminales y portátiles en el mundo

Así, en los últimos años, la fiebre de los móviles con pantalla táctil, desatada primeramente por el iPhone, ha revolucionado el mercado, ya no sólo en la venta de móviles sino todo el verdadero y jugoso negocio de las aplicaciones móviles. Y es que estos terminales se ha convertido en el ordenador del futuro con el valor añadido de disponibilidad total y de la comodidad y portabilidad. Un indicador muy eficaz para medir la emergencia de ciertas tendencias en el ámbito del desarrollo de software, es la actividad de las listas de correo y foros de la comunidad de desarrollo. En ORielly Media hicieron el ejercicio pasado un año tras el lanzamiento del dispositivo, y tras unos meses después del lanzamiento de Android, obteniendo el resultado que se puede ver en la Fig.28.

Figura 28. Listas de correos de desarrolladores interesados en determinadas plataformas y propias del fabricante (O’Reilly Media)

El sistema operativo que posee esta clase de terminales ofrece un sinfín de posibilidades, como si el de un ordenador se tratará; y todo esto combinado con la actual potencia de procesamiento y capacidad de almacenamiento que permiten la ejecución no sólo de aplicaciones ligeras sino de una gran parte de las pesadas; sin olvidar otras funcionalidades incorporadas a los móviles, como son el GPS, pantallas táctiles, llamadas telefónicas, posibilidad de enviar mensajes cortos, etc. Escuela Técnica Superior de Ingeniería (ICAI)  

76

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

A medida que el negocio de las aplicaciones móviles se va expandiendo y haciéndose rentable, se tienen que investigar las metodologías óptimas de desarrollo software para tales aplicaciones y entornos que lleven dicho desarrollo a éxito de una forma atractiva y eficiente; todo esto antes de que sea demasiado tarde y que el mercado esté tan maduro que las empresas hayan optado por las metodologías necesarias debido a que el software móvil debe satisfacer requerimientos y restricciones especiales. A pesar de estas características tan especiales, el software producido debe exigir un alto nivel de calidad para que este pueda operar propiamente en la cantidad numerosa de terminales que llegan el mercado actual y venidero. El desarrollador de aplicaciones móviles se enfrenta, además, con un escenario muy fragmentado, formado por multitud de plataformas incompatibles, como Symbian, Windows Mobile, Brew, Android, Linux o Java, y el propio iPhone SDK. Todo esto hace que el proceso de desarrollo para plataformas móviles sea más complejo.

Figura 29. Comparativa en volumen y tipos de aplicaciones descargadas durante las primeras 24 horas del App Store y el Android Market

Escuela Técnica Superior de Ingeniería (ICAI)  

77

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El desarrollo en los almacenes de aplicaciones, “Application Stores”, es un fenómeno en sí mismo. De hecho podemos ver en la Fig.29 la explosividad del mercado con la evolución de las descargas en las primeras 24 horas de Android y iPhone. Pero tiene muchas contrapartidas, como el hecho de la falta de la viralidad; las tiendas no tienen buenos sistemas de comunicación entre los usuarios para que aprovechen este efecto de red. Tanto Android como iPhone, tienen la capacidad de intercambiar aplicaciones. Pero se encuentra limitada en el origen; de momento, Google ha comentado que están analizando la manera de hacerlo, muy probablemente porque intenten ver si este intercambio se puede rentabilizar de alguna manera para no suscitar las quejas de los desarrolladores.

Escuela Técnica Superior de Ingeniería (ICAI)  

78

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

5. Desarrollo de prototipos 5.1 Pruebas triviales del entorno de desarrollo con simulador

En este punto se muestran algunos de los principales controles analizados: El SandBox es un conjunto de controles que limitan a la aplicación (por motivos de seguridad) el acceso a ficheros, recursos de red, de hardware, etc. Toda aplicación instalada reside en un espacio de disco donde ninguna otra aplicación tiene acceso. Gracias al directorio root de la aplicación y su identificador único, el sistema contruye el path o ruta del directorio único de la aplicación ( /ApplicationRoot/ApplicationID). Por tanto, durante la instalación, el sistema configura el entorno de ejecución de la aplicación, copia el Bundle en el directorio único y crea los subdirectorios correspondientes en el inicio. Este SandBox (espacio único de cada aplicación) simplifica las operaciones de acceso, restauración y desistalación.

Figura 30. Directorios del SandBox

Escuela Técnica Superior de Ingeniería (ICAI)  

79

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El Bundle es un directorio en el sistema de ficheros del iPhone que agrupa los recursos comunes de la aplicación (ejecutable, imágenes, recursos de internacionalización).

Figura 31. Directorios del Bundle

Utilizar el acelerómetro que viene integrado en el iPhone para dotar de mayor riqueza visual y experiencia de usuario a la aplicación, pudiendo cambiar las vistas y el interfaz gráfico según la posición del iPhone.

Figura 32. Acelerómetro

Escuela Técnica Superior de Ingeniería (ICAI)  

80

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En la Fig.33 se ve un ejemplo de cómo recibir un evento por medio del acelerómetro

Figura 33. Uso del acelerómetro

Integrar la cámara en la aplicación desarrollada, permitiendo hacer fotos y trabajar con ellas directamente desde nuestro software. En la Fig.34 se observa un ejemplo de cómo iniciar la cámara desde nuestra aplicación:

Figura 34. Uso de la cámara

Escuela Técnica Superior de Ingeniería (ICAI)  

81

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Uso de la localización del dispositivo gracias al Framework Core Location, podemos conocer la posición actual del dispositivo utilizando para ello la triangulación de la señal emitida y recibida por la antena. Un ejemplo de ello es la aplicación de Google Maps que viene ya integrada con el iPhone, la cuál nos muestra nuestra localización en el mapa. En la Fig.35 se observa un ejemplo del uso de la localización mediante el framework Core Location:

Figura 35. Uso de la localización en el iPhone

Escuela Técnica Superior de Ingeniería (ICAI)  

82

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

5.2 Desarrollo de pequeños prototipos. Se estudiará la plataforma a través de la realización de pequeños prototipos, con lo cuales se realizarán integraciones con el propio dispositvo iPhone.

El desarrollo de prototipos se centra principalmente en el manejo de ficheros XML. Un primer desarrollo se centro en la captura de información introducida en campos de texto, para posteriormente añadirla a un fichero XML, y también se permitia el borrado de los datos introducidos.

Figura 36. Vista del prototipo de captura de tres campos de texto

Escuela Técnica Superior de Ingeniería (ICAI)  

83

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En la Fig.37 se muestra el desarrollo de otro de los prototipos diseñados, que consiste en la captura de la información introducida en un campo de texto, para posteriormente leer y mostrar en otro campo de texto que se encuentra en otra vista.

Figura 37. Vista inicial del prototipo

En la siguiente vista ya se observa como muestra el campo de texto introducido en la vista inicial anteriormente.

Escuela Técnica Superior de Ingeniería (ICAI)  

84

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 38. Vista final del prototipo

Otro de los prototipos diseñados se basa en la navegación por diferentes vistas según se seleccione uno u otro campo dentro de una tabla contenida en una vista, en donde se accede a otra vista en forma de tabla del item que se seleccione y así sucesivamente, siempre manteniendo el titulo del item seleccionado en la parte superior de la vista y proporcionando la correspondiente navegación para regresar a la vista anterior o acceder a la vista posterior.

Escuela Técnica Superior de Ingeniería (ICAI)  

85

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 39. Vista inicial del prototipo

Figura 40. Vista final del prototipo

Escuela Técnica Superior de Ingeniería (ICAI)  

86

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Uno de los prototipos finales diseñados antes de llegar a la aplicación final tiene el nombre de PA (Punto de acceso), y consta de una vista inicial, en la cuál se muestran dos botones con las opción de gestionar los diferentes puntos de acceso, y la opción de descubrir puntos de acceso mediante bluetooth.

Figura 41. Pantalla de bienvenida del prototipo PA

En este prototipo se manejaban los diferentes puntos de acceso en un fichero xml, pero sólo mantenía los datos en tiempo de ejecución, y en el propio terminal no guardaba nada internamente, lo cuál significaba un “reseteo a la versión inicial” en cada uno de los lanzamientos de la aplicación, y no se producía un correcto mantenimiento del fichero xml, lo cuál era objeto y finalidad de la aplicación final.

Escuela Técnica Superior de Ingeniería (ICAI)  

87

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 42. Pantalla de la opción gestión del prototipo PA

En la figura anterior se muestra una vista de la opción de gestionar los puntos, con los cuatro campos que se tratarán también en la aplicación final, y su correspondiente botón guardar, todo ello asociado en la pestaña “Añadir”, en la pestaña “Ver” se mostaría en una vista de tabla todos los puntos de acceso, pero esa parte no fue desarrollada en dicho prototipo. En la Fig.43 se muestra la primera implementación sobre un prototipo del UIAlert, es decir la ventana que aparece para mostrar la alerta de que la información se ha mostrado con éxito.

Escuela Técnica Superior de Ingeniería (ICAI)  

88

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 43. Pantalla de la opción gestión del prototipo PA con el UIAlert

Escuela Técnica Superior de Ingeniería (ICAI)  

89

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

6. Aplicación Puntos de acceso La aplicación desarrollada se llama Puntos de Acceso y tiene como objeto y finalidad el gestionar y administrar diferentes puntos de acceso dentro del propio dispositivo iPhone, manteniendo en todo momento la persistencia de los datos y todo se almacena en formato XML, a través de un Property list llamado Puntos.plist, como se puede observar en la Fig.44. En dicha aplicación se cargarán los puntos de acceso en formato de tabla, y pulsando cada item se podrá acceder a una vista donde se verán los cuatro campos de información (nombre, mac, posición y descripción), también se podrán añadir, editar, desplazar y guardar cada uno de los correspondientes puntos de acceso.

Figura 44. Vista del fichero .plist de información del proyecto

Escuela Técnica Superior de Ingeniería (ICAI)  

90

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Posteriormente se muestra el fichero Property list de Puntos.plist donde se puede observar cada uno de los items correspondientes a cada uno de los puntos de acceso de la aplicación, anteriormente se ha creado como clave un Array, y cada item se ha creado como un Dictionary, el cuál contiene cuatro campos de tipo String, es decir, el Nombre del punto de acceso, la dirección Mac correspondiente o asociada al punto de acceso, la posición en la cuál se encuentra ubicado y finalmente el último campo la Descripción. (todo esto se puede observar en la Fig.45).

Figura 45. Vista del fichero .plist de información del proyecto

Escuela Técnica Superior de Ingeniería (ICAI)  

91

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En la siguiente Fig.46 se muestra el icono que da acceso a la aplicación Puntos de Acceso

Figura 46. Vista del icono de la aplicación Puntos de Acceso

Escuela Técnica Superior de Ingeniería (ICAI)  

92

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El formato del fichero XML que se crea a guardar el Property list es el siguiente: − − Nombre Punto de acceso 1 Mac 1 Posicion icai Descripcion aula 1 − Nombre Punto de acceso 2 Mac 2 Posicion icai Descripcion aula 2 − Nombre Punto de acceso 3 Mac 3 Posicion icai Descripcion aula 3 − Nombre Punto de acceso 4 Mac 4 Posicion icai

Escuela Técnica Superior de Ingeniería (ICAI)  

93

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Descripcion aula 4 − Nombre Punto de acceso 5 Mac 5 Posicion icai Descripcion aula 5 − Nombre Punto de acceso 6 Mac 6 Posicion icai Descripcion aula 6 − Nombre Punto de acceso 7 Mac 7 Posicion icai Descripcion aula 7 − Nombre Punto de acceso 8 Mac 8 Posicion icai Descripcion aula 8 Escuela Técnica Superior de Ingeniería (ICAI)  

94

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En la Fig.47 se muestra el código que se invoca justo antes de que la aplicación termine. Se usa para guardar los cambios que el usuario ha hecho con la aplicación, es decir, si ha editado, borrado, guardado o añadido algún punto de acceso.   -­‐  (void)applicationWillTerminate:(UIApplication  *)application   {          [_listController  guardar];     Figura 47. Código de Puntos de Acceso

En el siguiente código se indica la ruta en la cuál debe ser guardado el fichero para en posteriores reinicios de la aplicación se carga de un modo persistente. También se inicializa la matriz de objetos mostrados por la lectura de ellos desde el sistema de archivos. +  (NSString  *)pathForDocumentWithName:(NSString  *)documentName   {          NSArray  *paths  =  NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,                                                                                                                    NSUserDomainMask,                                                                                                                      YES);          NSString  *path  =  [paths  objectAtIndex:0];                    return  [path  stringByAppendingPathComponent:documentName];   }   -­‐  (NSMutableArray  *)displayedObjects   {          if  (_displayedObjects  ==  nil)          {                  NSString  *path  =  [[self  class]  pathForDocumentWithName:@"Puntos.plist"];                  NSArray  *puntoDicts  =  [NSMutableArray  arrayWithContentsOfFile:path];                  if  (puntoDicts  ==  nil)                  {                          NSLog(@"No  se  puede  leer  el  archivo  plist  en  la  ruta:  %@",  path);                          path  =  [[NSBundle  mainBundle]  pathForResource:@"Puntos"                                                                                                        ofType:@"plist"];                          puntoDicts  =  [NSMutableArray  arrayWithContentsOfFile:path];                  }                  _displayedObjects  =  [[NSMutableArray  alloc]                                                            initWithCapacity:[puntoDicts  count]];                                    for  (NSDictionary  *currDict  in  puntoDicts)                  {                          Punto  *punto  =  [[Punto  alloc]  initWithDictionary:currDict];  

Escuela Técnica Superior de Ingeniería (ICAI)  

95

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

                       [_displayedObjects  addObject:punto];                  }          }          return  _displayedObjects;   }   Figura 48. Código de Puntos de Acceso

 

Se puede observar como en futuros reinicios se guarda la información de cada punto de acceso.

Figura 49. Vista de la información de un item

Escuela Técnica Superior de Ingeniería (ICAI)  

96

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

El siguiente código sirve para reemplazar el método heredado que sirve para configurar el botón Edit y botón + (Agregar), y para definir el título del controlador, el cuál se muestra en la barra de navegación.   -­‐  (void)viewDidLoad   {          [super  viewDidLoad];                    [self  setTitle:@"Gestión"];                    [[self  tableView]  setRowHeight:54.0];                    //    Configurar  el  botón  Editar          [[self  navigationItem]  setLeftBarButtonItem:[self  editButtonItem]];                    //    Configurar  el  botón  Añadir          UIBarButtonItem  *addButton  =  [[UIBarButtonItem  alloc]                                                                        initWithBarButtonSystemItem:UIBarButtonSystemItemAdd                                                                      target:self                                                                      action:@selector(add)];                    [[self  navigationItem]  setRightBarButtonItem:addButton];          [addButton  release];   }   Figura 50. Código de Puntos de Acceso

   

La siguiente figura muestra el código de cómo reemplazar el método heredado para activar/desactivar el botón Edit -­‐  (void)setEditing:(BOOL)editing                      animated:(BOOL)animated   {          [super  setEditing:editing                            animated:animated];                    UIBarButtonItem  *editarButton  =  [[self  navigationItem]  rightBarButtonItem];          [editarButton  setEnabled:!editing];   } Figura 51. Código de Puntos de Acceso

Escuela Técnica Superior de Ingeniería (ICAI)  

97

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Finalmente la aplicación mostrará la apariencia de la Fig.52 cuando se añada un nuevo punto de acceso a la misma.

Figura 52. Vista con información almacenada

Escuela Técnica Superior de Ingeniería (ICAI)  

98

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

7. Conclusiones y trabajos futuros Para todas aquellas personas que se estén preguntando porque programar para esta plataforma móvil, hay que señalar que no se trata de una plataforma móvil como el resto, se puede afirmar que es mucho más que eso. El núcleo de este dispositivo es el mismo que el de un Mac. No se trata de un móvil con capacidad multimedia, sino de un dispositivo multimedia que incorpora el teléfono como una característica más. Con su interfaz de usuario puede llegar en un breve periodo de tiempo a ser una de las plataformas de juegos más impresionantes. Con su explorador safari se puede acceder por la web 2.0 como si se tratase de un PC, es decir, sería como navegar en un PC, pero en este caso sería de reducidas dimensiones. Actualmente en el año 2010 el sistema operativo del iPhone, iPod touch e iPad, es decir, el iPhone OS cuenta aproximadamente con 75 millones de dispositivos en el mercado que hacen uso del sistema, se trata de una cifra nada despreciable y que puede llegar fácilmente a los 100 millones en lo que resta de año, es decir, todos estos datos son una motivación muy buena para seguir desarrollando y haciendo crecer esta plataforma en el futuro. En la actualidad los porcentajes aproximados de la cantidad de dispositivos es la siguiente: • • • • • •

iPhone 2G: 2% iPhone 3G: 20% iPhone 3GS: 39% iPod touch 1G: 2% iPod touch 2G: 25% iPod touch 3G: 12%

Si se hacen números se puede comprobar como Apple ha decidido dejar casi el 50% de los dispositivos obsoletos este mismo verano, puesto que únicamente el 51% de los equipos vendidos hasta la fecha podrán acceder a todas las nuevas funciones del sistema operativo.

Escuela Técnica Superior de Ingeniería (ICAI)  

99

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 53. Estructura de los 75 millones de dispositivos que usan el iPhone OS

En el verano de 2010 tras la presentación de la nueva versión del sistema que corre en los dispositivos iPhone, iPod Touch e iPad, surge la llegada de la multitarea, a través de un sencillo sistema de barra deslizante (que se puede observar al hacer doble click sobre el botón de home), y así se puede saltar entre aplicaciones o cerrarlas desde la propia barra. Es un aspecto muy poco original por parte de Apple, ya que es uno de los últimos en ofrecer multitarea (Symbian o Windows Mobile lo ofrecen desde hace tiempo y Android desde el primer día), pero Apple si destaca el ofrecer un sistema que no afecta al rendimiento global del aparato, mediante la activación de servicios que se encargan de las tareas en segundo plano.

Escuela Técnica Superior de Ingeniería (ICAI)  

100

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

8. Bibliografía [1] Web de manejo de la memoria: http://memo.tv/memory_management_with_objective_c_cocoa_iphone [2]Web de desarrolladores de Apple: http://developer.apple.com/ [3] Manejo del SDK: http://open.movilforum.com/tutorial/iphone/tutorial1 [4] Web comparativa Android y iPhone: http://www.medialets.com/blog/2008/10/23/android-market-vs-iPhone-app-store-thefirst-24-hours/ [5] Blog sobre gamekit: http://ipadspain.es/blog/tag/gamekit [6] Web sobre Cocoa: http://zbutton.wordpress.com/2010/02/15/construyendo-unaaplicacion-cocoa-sin-interface-builder/ [7] Pilone, Dan & Tracey. Head First iPhone Development, OReilly, 2009. [8] Stark, Jonathan. Building iPhone Apps with HTML, CSS and JavaScript, OReilly, 2010. [9] Stevenson, Scott. Cocoa and Objective-C Up and Running, OReilly, 2010 [10] Manual de iPhone Development Guide: http://developer.apple.com/ [11] Mark, Dave & LaMarche Jeff. Beginning iPhone Development, Apress, 2009 [12] Mark, Dave & LaMarche Jeff. Beginning iPhone 3 Development, Apress, 2009 [13] Brannan, James A. iPhone SDK Programming. MCGrawHill, 2010 [14] Dudney, Bill & Adamson, Chris. iPhone SDK Development, Pragmatic Bookshelf, 2009

Escuela Técnica Superior de Ingeniería (ICAI)  

101

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

9. Anexos En los apartado 8.1, 8.2 y 8.3 se recogen las hojas de características de los equipos y componentes respectivos a cada terminal de Apple.

9.1 iPhone

Figura 54. iPhone 2G

Hoja  de  características   Brand   Manufacturer   Hardware-­‐Designer   Model  ID   Release  +  Date   Software  Environment   Embedded  Operating  System     Operating  +  System  +  Kernel   ROM:  Upgrade   Microprocessor  Chipset   CPU  clock   CPU     Width  +  of_Machine  +  Word:   CPU  Core   Level1  cache   Instruction  +  Set   Memory,  Storage  &  Capacity   RAM  +  type  

iPhone  2G  8Gb   Apple   Foxconn   Apple   MA712   June,  2007     Apple  iPhone  OS  1.0   Browse  devices  running  this  OS   Mach  1.0.0   ROM  image  for  iPhone  8  GB     400  MHz   Samsung  S5L8900   Browse  devices  based  on  S5L8900   32  bit   ARM1176JZF-­‐S   16  KB  data  cache  /  16  kB  instruction  cache   ARMv6     SDRAM  ,  100MHz  

Escuela Técnica Superior de Ingeniería (ICAI)  

102

    RAM  capacity   ROM  +  type   ROM  capacity   ROM  capacity  bytes   Graphical  subsystem   Display  type   Display  color  depth   Display  diagonal   Display  resolution   Viewable  Display  Size   Dot  Pitch   Graphical  Controller   Audio  Subsystem   Audio  Channels   Digital/  Analog  Converter   Microphone   Audio  Output   Cellular  Phone   Cellular  Networks   Cellular  Antena   Call  Allert   Vibrating  alert   Speakerphone   Control  Peripherals   USB   Bluetooth  +(802.15)   Wireless  LAN/Wi-­‐Fi  +  (802.11)   Multimedia  +  Broadcast   Analog  radio   Power  Supply   Battery  technology   Battery  Build   Battery  Capacity   Additional  Details   Built  in  accelerometer   Additional  +Features  

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

128  MiB   Flash  EEPROM   7630  MiB   8  GB  (billion  bytes)     color  transflective  TFT  display   16  bit/pixel  (65536  scales)   3.5  "  (89  millimetres)   320  x  480  (153600  pixels)   1.94  "  x  2.92  "  (49.37  x  74.05  millimetres)   164.6  pixel/inch  (0.15428   millimetre/pixel)   PowerVR  MBX  Lite     stereo  sound   16  bit  resolution   mono  sound   3.5mm  plug     GSM850,  GSM900,  GSM1800,  GSM1900   Internal  antenna   64  -­‐chord  melody  (polyphonic)   Supported   Supported     USB  2.0  client,  Hi-­‐Speed  (480Mbit/s)   Bluetooth  2.0  +  Enhanced  Data  Rate,   Internal  antenna   IEEE  802.11b,  IEEE  802.11g,  54  Mbit/s     Not  supported     Lithium-­‐ion  battery   built-­‐in   1400  mAh     Supported   GPRS  Class  10  

Escuela Técnica Superior de Ingeniería (ICAI)  

103

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

9.2 iPhone 3G

Figura 55. iPhone 3G

Hoja  de  características   Brand   Manufacturer   Hardware-­‐Designer   Release  +  Date   Software  Environment   Embedded  Operating  System   Operating  +  System  +  Kernel   Microprocessor  Chipset   CPU  clock   CPU     Width  +  of_Machine  +  Word:   CPU  Core   Level1  cache   Instruction  +  Set   Memory,  Storage  &  Capacity   RAM  +  type   RAM  capacity   ROM  +  type   ROM  capacity   ROM  capacity  bytes   Graphical  subsystem   Display  type   Display  color  depth   Display  diagonal   Display  resolution   Viewable  Display  Size  

iPhone  2G  8Gb   Apple   Foxconn   Apple   July,  2008     Apple  iPhone  OS  2.0   Mach  2.0.0     412  MHz   Samsung  S5L8900   Browse  devices  based  on  S5L8900   32  bit   ARM1176JZF-­‐S   16  KiB  data  cache  /  16  kiB  instruction   cache   ARMv6     SDRAM,  103  MHz   128  MiB   Flash  EEPROM   15258  MiB   16  GB       color  transfective  TFT  display   18  bit/pixel    (262144  scales)   3.5  “  (89  milimetres)    320  x  480  (153600  pixels)   1.94”  x  2.92”  (49.37  x  74.5  millimetres)  

Escuela Técnica Superior de Ingeniería (ICAI)  

104

    Dot  Pitch   Graphical  Controller   Audio  Subsystem   Audio  Channels   Digital/  Analog  Converter   Microphone   Audio  Output   Cellular  Phone   Cellular  Networks   Cellular  Antena   Call  Allert   Vibrating  alert   Speakerphone   Control  Peripherals   USB   Bluetooth  +(802.15)   Wireless  LAN/Wi-­‐Fi  +  (802.11)   Multimedia  +  Broadcast   Analog  radio   GPS  protocol   GPS  Antena   Power  Supply   Battery  technology   Battery  Build   Battery  Capacity   Additional  Details   Built  in  accelerometer   Additional  +Features  

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

164.6  pixel/inch  (0.15428   millimetre/pixel)   PowerVR  MBX  Lite     stereo  sound   16  bit  resolution   mono  sound   3.5mm  plug     GSM850,  GSM900,  GSM1800,  GSM1900,   UMTS850,  UMTS1900,  UMTS2100   Internal  antenna   64  -­‐chord  melody  (polyphonic)   Supported   Supported     USB  2.0  client,  Hi-­‐Speed  (480Mbit/s)   Bluetooth  2.0  +  Enhanced  Data  Rate,   Internal  antenna   IEEE  802.11b,  IEEE  802.11g,  54  Mbit/s     Not  supported   NMEA  0183   Internal  antenna     Lithium-­‐ion  battery   built-­‐in   1400  mAh     Supported   GPRS  Class  10,  HSDPA  1.4  

Escuela Técnica Superior de Ingeniería (ICAI)  

105

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

9.3 iPhone 3G S

Figura 56. iPhone 3G S

Hoja  de  características   Brand   Manufacturer   Hardware-­‐Designer   Release  +  Date   Software  Environment   Embedded  Operating  System   Operating  +  System  +  Kernel   Microprocessor  Chipset   CPU  clock   CPU     Width  +  of_Machine  +  Word:   CPU  Core   Level1  cache   Instruction  +  Set   Level-­‐2:cache   Memory,  Storage  &  Capacity   RAM  +  type   RAM  capacity   ROM  +  type   ROM  capacity   ROM  capacity  bytes   Graphical  subsystem   Display  type   Display  color  depth   Display  diagonal   Display  resolution   Viewable  Display  Size   Dot  Pitch  

iPhone  2G  8Gb   Apple   Foxconn   Apple   June,  2009     Apple  iPhone  OS  3.0   Mach  3.0     600  MHz   Samsung  S5PC100   Browse  devices  based  on  S5PC100   32  bit   ARM  Cortex-­‐A8   32KiB  data  cache  /  32  KiB  instruction   cache   ARMv7   256  KiB     SDRAM  ,  150MHz   256  MiB   Flash  EEPROM   15258  MiB   16  GB  (billion  bytes)     color  transflective  TFT  display   18  bit/pixel  (262144  scales)   3.5  "  (89  millimetres)   320  x  480  (153600  pixels)   1.94  "  x  2.92  "  (49.37  x  74.05  millimetres)   164.6  pixel/inch  (0.15428  

Escuela Técnica Superior de Ingeniería (ICAI)  

106

   

Graphical  Controller   Audio  Subsystem   Audio  Channels   Digital/  Analog  Converter   Microphone   Audio  Output   Cellular  Phone   Cellular  Networks   Cellular  Antena   Call  Allert   Vibrating  alert   Speakerphone   Control  Peripherals   USB   Bluetooth  +(802.15)   Wireless  LAN/Wi-­‐Fi  +  (802.11)   Multimedia  +  Broadcast   Analog  radio   GPS  protocol   GPS  Antena   Power  Supply   Battery  technology   Battery  Build   Additional  Details   Built  in  accelerometer   Additional  +Features  

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

millimetre/pixel)   PowerVR  SGX     stereo  sound   16  bit  resolution  (playing)  48000  Hz   holding  frequency   mono  sound   3.5mm  plug     GSM850,  GSM900,  GSM1800,  GSM1900,   UMTS850,  UMTS1900,  UMTS2100   Internal  antenn   64  -­‐chord  melody  (polyphonic)   Supported   Supported     USB  2.0  client,  Hi-­‐Speed  (480Mbit/s)   Bluetooth  2.1  +  Enhanced  Data  Rate,   Internal  antenna   IEEE  802.11b,  IEEE  802.11g,  54  Mbit/s     Not  supported   NMEA  0183   Internal  antenna     Lithium-­‐ion  battery   built-­‐in     Supported   GPRS  Class  10   HSDPA  7.2  built-­‐in  digital  compass  OpenGL   ES  2.0  support  Voice  Control  Google  Maps  

Escuela Técnica Superior de Ingeniería (ICAI)  

107

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

9.4 Tutorial de iniciación al SDK del iPhone A continuación se muestra un tutorial que sirve de guía para aquellas personas que quieran empezar a programar en el entorno Mac/iPhone. Se encuentra estructurado en tres partes. En una primera se comenta el SDK, y los respectivos cambios que se han ido produciendo con las diferentes versiones del SDK. En la segunda parte se intalara el SDK y finalmente se realizará un proyecto de una aplicación sencilla a modo de ejemplo. PARTE 1: SOBRE EL SDK El 6 de marzo de 2008 Apple sorprendió a todos con el anuncio de un SDK para sus dispositivos iPhone y iPod Touch, desde entonces son numerosos los cambios que se han ido produciendo en el SDK Pasamos a analizar tanto puntos positivos como negativos acerca del SDK: A favor: • Facilidad a la hora de programar una aplicación. Documentación extensa unida a ejemplos. • Conjunto de herramientas muy completas. Todo lo necesario está incluido en el SDK. • Simulador: para probar aplicaciones sin disponer del dispositivo. • Acceso a los Framework de más funcionalidades del dispositivo: multitouch, acelerómetro, localización, cámara…etc. • Para un programador de Mac le será transparente programar para dicha plataforma. En contra: • Programa de desarrollo: se debe pasar por caja para ver las aplicaciones en el dispositivo físico. • Lenguaje de programación: Objective-C no es muy extendido actualmente. • SDK solo válido para la plataforma Mac. No hay herramientas oficiales para Windows.

Escuela Técnica Superior de Ingeniería (ICAI)  

108

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

• Las aplicaciones no corren en segundo plano. Se debe guardar el estado para recuperarlo en cada ejecución. PARTE 2: INSTALACIÓN En esta segunda parte se explica la instalación del SDK. Para empezar es necesario descargarse el SDK oficial de Apple. Se localiza en el siguiente enlace http://developer.apple.com/iphone/sdk1/. Como único requisito inicial se pedirá registrarse en la página como desarrollador (gratis).

Figura 57. Instalación SDK

Una vez descargado el archivo, automáticamente se montará en el sistema como una unidad más. Se accede al Finder y se ejecuta la instalación. A partir de este momento se guiará a través de asistentes.

Figura 58. Instalación desde el finder

Escuela Técnica Superior de Ingeniería (ICAI)  

109

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Una vez instalado, se observa que las herramientas no están en la carpeta Aplicaciones, pero

las

herramientas

esenciales

del

SDK

las

podemos

encontrar

en

Developer/Applications. Se pueden crear enlaces en el dock con las herramientas que se quieran.

Figura 59. Herramientas del SDK

Herramientas que se encuentran en la carpeta Aplicaciones:     

Xcode Interface Builder DashCode iPhone Simulator Instruments

Escuela Técnica Superior de Ingeniería (ICAI)  

110

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

PARTE 3: PRIMER PROYECTO HELLO WORLD Una vez acabada la instalación se van a comentar los pasos para la realización de una sencilla primera aplicación. La idea es la típica aplicación Hello World, donde el usuario introduce su nombre, pulsa un botón y recibe un saludo personalizado por parte de la aplicación. Para ello se ejecutará XCode. Aparecerá la siguiente pantalla de bienvenida. Le damos a Archivo Nuevo Proyecto.

Figura 60. Inicio Xcode

Nos saldrá una ventana con las dos plataformas disponibles y el tipo de proyecto que se quiere crear. Se elegirá la parte correspondiente al iPhone.

Escuela Técnica Superior de Ingeniería (ICAI)  

111

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

A continuación se muestran los diferentes tipos de proyectos (plantillas) disponibles en este momento: Navigation-Bases Application: plantilla para crear una aplicación con el objeto de navegación. OpenGL ES Applications: plantilla para aplicaciones que hagan uso del motor gráfico OpenGL. Tab Bar Application: plantilla para aquellas aplicaciones donde necesitamos el elemento Tab Bar (como iPod o contactos) Utility Application: plantilla para aplicaciones tipo Widget (Bolsa, Mapas, Tiempo). View-Based Application: plantilla para aplicaciones tipo VistaControlador. Ideal para aplicaciones sencillas Window-Based Application: plantilla por defecto. Preparada para personalizarla como queramos. Para este primer ejemplo se seleccionará View-Based Application.

Figura 61. Inicio proyecto View-Based Application en Xcode

Escuela Técnica Superior de Ingeniería (ICAI)  

112

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En la Fig.62 se solicita el nombre que se quiere dar al proyecto y su ubicación:

Figura 62. Inicio proyecto View-Based Application en Xcode con nombre y ubicación

Una vez completado el paso anterior se accede a la interfaz de Xcode:

Figura 63. Inicio proyecto View-Based Application en Xcode interfaz

Escuela Técnica Superior de Ingeniería (ICAI)  

113

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

A continuación se describen los componentes del proyecto: Explorador de los archivos del proyecto: Nos mostrará todos los elementos pertenecientes a nuestro proyecto.

Figura 64. Explorador de archivos del proyecto

Como se puede observar, se tienen dos clases:  Mi_ProyectoAppDelegate: encargado de la gestión de la memoria del programa, de lanzar los controladores para cada vista que creemos. Para este caso lo único de lo que se encarga es de lanzar el controlador de la vista.  Mi_ProyectoViewController: encargado de mostrar y definir los elementos de la vista que creemos y de mostrarla por pantalla. Recoge y envía los eventos de la misma.

Escuela Técnica Superior de Ingeniería (ICAI)  

114

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Vista Carpeta: Vista de la carpeta seleccionada desde el explorador:

Figura 65. Vista Carpeta

Vista Código:

Figura 66. Vista código

Barra de Herramientas: Opciones más comunes.

Figura 67. Vista Barra de Herramientas

Escuela Técnica Superior de Ingeniería (ICAI)  

115

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

 Build: Acción de compilar el proyecto.  Build & Go: Compilar y ejecutar el proyecto.  Info: Propiedades del proyecto.  Editor: Vista con solo el editor de código. Una vez explicada la interfaz de Xcode con los compentes de proyecto se compilara el proyecto sin más. Para ello se pulsará en “Build & Go” de la barra de herramientas. Se ve como no se generan errores y posteriormente se ejecutará la aplicación en el simulador.

Figura 68. Simulador iPhone

Aparecerá una pantalla en blanco debido a que todavía no se ha definido. Si se pulsa el botón Home saldremos de la aplicación. Es una de las principales pegas a la hora de programar aplicaciones para el iPhone es que estas no se pueden ejecutar en segundo plano. Tanto si se pulsa el botón Home como si ocurre un evento del sistema (llamda, SMS, …etc) nuestra aplicación se cerrará (cosa que no pasa en la versión OS 4 que se

Escuela Técnica Superior de Ingeniería (ICAI)  

116

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

lanzará en junio/ julio 2010), y al menos que se guarde el estado, la siguiente vez que se ejecute será como la “primera” vez. Para el ejemplo comentado en este tutorial no es crítico guardar el estado Código: Se empezaran definiendo los elementos necesarios para el controlador de vista que se necesita para crear la aplicación. En resumen se necesita lo siguiente:  Etiquetas: Una para el título y otra para pedir al usuario que introduzca el nombre. Una última para saludar al usuario de forma personalizada.  Campo de texto: donde el usuario introducirá su nombre.  Imagen: Se mostrará junto con la etiqueta de saludo cuando el usuario pulse el botón.  Botón: A través del cual se ejecuta el método de saludo.  Imagen de fondo: imagen de la interfaz para que no quede la aplicación sosa. Se pulsará en el archivo de definición del controlador, Mi_ProyectoViewController.h y se añaden las siguientes líneas:

Figura 69. Mi_ProyectoViewController.h

Escuela Técnica Superior de Ingeniería (ICAI)  

117

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

IBOutlet sirve para indicar al compilador que este elemento lo enlazaremos en la herramienta Interface Builder. Solo se necesita la etiqueta de saludo, el campo de texto para capturar el nombre y la imagen a mostrar cuando saludemos. Luego se definen las propiedades de los elementos para facilitar el acceso a los mismos, es decir, en Objective-C el acceso a los métodos o propiedades de las clases se realiza entre corchetes, con estas propiedades se podrá acceder por puntos ahorrándo código. Lo último que se hace es definir la cabecera del método que lanza el botón. Para ello, y por defecto, recibe un objeto Id devuelve un IBAction (todo lo que empieze por IB son acciones que se enlazarán con la herramienta Interface Builder).

Figura 70. Implementación Mi_ProyectoViewController.m

Escuela Técnica Superior de Ingeniería (ICAI)  

118

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

clickSaludo es el método que se lanzará cuando se pulse el botón. Captura el texto y lo muestra en la etiqueta antes definida mostrando además una imagen. El método textFieldShouldReturn es para que al pulsar “done” cuando se termine de introducir el nombre desaparezca el teclado, ya que por omisión no desaparece. Por último, se insertan los archivos correspondientes a las imágenes que se necesitan: -

Background.png : Imagen de fondo.

-

Hello.png: Imagen que usaremos como saludo.

-

Icon.png: Nuestro icono de la aplicación.

Se selecciona desde el Finder y se arrastra hasta la carpeta Resources del proyecto. Aparecerá una pantalla confirmando si se desea enlazar los archivos al proyecto. Se pulsa en “Add” y con esto termina la parte correspondiente de Xcode.

Figura 71. Pantalla para enlazar archivos al proyecto

Escuela Técnica Superior de Ingeniería (ICAI)  

119

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Diseño de la interfaz: Para empezar, se debe pulsar dos veces encima del archivo con el siguiente nombre: Mi_ProyectoViewController.xib dentro del explorador de archivos. Este archivo se encarga de definir la vista del controlador. En la Fig.72 se observa como se ejecutará la herramienta Interface Builder.

Figura 72. Interface Builder

De izquierda a derecha se describen los componentes más importantes de un archivo xib. o Vista: Este componente es lo que realmente se ve en el iPhone. Aquí se diseña la interfaz. o File´s Owners: Objeto responsable de controlar la vista. En este caso el controlador Mi_ProyectoViewController. o Atributos: Atributos del objeto que se selecciona. o Library: Librería de objetos junto con su descripción: botones, etiquetas…etc.

Escuela Técnica Superior de Ingeniería (ICAI)  

120

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Se empezará arrastrando los componentes necesarios: o Imagen de fondo: Se elige el objeto Image View y se arrastra a la ventana. En la ventana “Image View Attributes”, se elige como valor para “Image” la imagen Background.png. o Titulo y petición del nombre: Se elige el objeto Label. o Campo de texto donde el usuario introducirá el nombre: Para ello se selecciona TextField. o Botón: de tipo Rounded Button. o Saludo: etiqueta vacía. o Imagen para el saludo: de tipo Image View asociada a la imagen “Hello.png” como ya se ha hecho con la imagen de fondo. Se seleccionará también la propiedad “Hidden” Posteriormente se enlazará la interfaz con el código, para ello se selecciona File’s Owner y se mantiene pulsado el botón Ctrl arrastrando el ratón hacía los componentes diseñados. El siguiente paso es con los componentes, solo se hace con aquellos que se han definido en el código. Pasos: • Primero se enlaza el campo de texto. • Se enlaza la etiqueta vacía. • Se enlaza la imagen del saludo. • Para enlazar el botón con el método se hace click sobre el ratón con la tecla ctrl presionada, entonces aparecerán todos los eventos relacionados con el botón, con el ctrl pulsado se hace click sobre “Touch Up Inside” y se arrastra hacia File`s Owner seleccionando “clickSaludo”. • Para que el teclado desaparezca al introducir el nombre además de la función que se ha implementado en el código se necesita que el controlador sea el “delegate” del campo de texto, para ello se enlaza desde el campo de texto hacia el controlador. Escuela Técnica Superior de Ingeniería (ICAI)  

121

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

• Por último, para asociar un icono a nuestra aplicación se selecciona el archivo “Info.plist” dentro de Xcode. El campo “Icon” se completa con el nombre de la imagen que se desa añadir. Con estos pasos se termina el tutoria Hello World, se cierra Interface Builder, y en Xcode se pulsa el Build & Go.

Figura 73. Interface Builder

Escuela Técnica Superior de Ingeniería (ICAI)  

122

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

9.5 Manual de usuario Este documento corresponde al Manual de Usuario de la aplicación Puntos de Acceso. En este manual se describirá el funcionamiento de la aplicación, así como el conjunto de interfaces que la aplicacón presenta en el momento preciso. Para comenzar el uso de la aplicación Puntos de Acceso se debe hacer click sobre el icono Puntos que aparece en la vista de la Fig.74, y posteriormente se abrirá la aplicación.

Figura 74. Vista del icono de la aplicación Puntos de Acceso

Escuela Técnica Superior de Ingeniería (ICAI)  

123

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Una vez abierta la aplicación Puntos se podrá ver la vista inicial de la aplicación como se puede apreciar en la Fig.75. El proceso de gestión de los puntos de acceso se llevará a cabo sobre una tabla en la que se irá mostrando en cada celda el item correspondiente a cada punto de acceso con su información asociada en modo subtitulo. En esta vista inicial se tendrán en la parte superior dos botones, el botón “edit” y “+”. En el caso del “edit” servirá para editar el punto de acceso y hará que salga en el lateral izquierdo de cada celda la opción de borrarla, y en el lateral derecho la posibilidad de desplazar los puntos de acceso. En el caso de “+” proporciona la opción de añadir un nuevo punto de acceso.

Figura 75. Vista inicial de la aplicacón

Escuela Técnica Superior de Ingeniería (ICAI)  

124

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Al pulsar sobre cualquier celda de la vista de la Fig.75 se accederá a la vista de la Fig.76, donde se podrá ver cada uno de los cuatro campos de los que consta la aplicación, es decir, el nombre del punto de acceso, la correspondiente dirección Mac, la posición en la cuál se encuentra ubicada, y la descripción. En este punto se podrá ver la información completa del punto de acceso, bien para ver lo que contiene o para editarlo.

Figura 76. Vista de la información de un item

Escuela Técnica Superior de Ingeniería (ICAI)  

125

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Al entrar a través de está opción se podrá editar el correspondiente punto de acceso pulsando sobre el campo de texto que se precise y borrando o cambiando toda la información asociada al punto de acceso como se muestra en la Fig.77.

Figura 77. Vista de la información de un item en modo edicción de un campo de texto

Escuela Técnica Superior de Ingeniería (ICAI)  

126

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Volviendo a la vista inicial de la aplicación, al presionar el botón “edit” dicho botón cambiará para llamarse “Done” y proporcionará la opción comentada al principio del manual, es decir, en el lateral izquierdo dará la posibilidad de borrar la celda que se desee pulsando sobre un icono como este

, y esto hará que aparezca en el lateral

derecho otro botón con la opción “Delete”, y al pulsar sobre él borrará la celda entera del punto de acceso, y no aparecerá ya en futuros lanzamientos de la aplicación. (Todo esto se puede ver con más claridad en la Fig.78).

Figura 78. Vista con la opción de borrar

Escuela Técnica Superior de Ingeniería (ICAI)  

127

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

En la vista de la Fig.79 se ve la opción también señalada al pulsar el botón “edit” se cambia a “Done” y en el lateral derecho aparece la siguiente imagen

, la cuál

permite realizar el desplazamiento de cada uno de los items que componen las celdas de la tabla en la correspondiente vista.

Figura 79. Vista con un item desplazado

Escuela Técnica Superior de Ingeniería (ICAI)  

128

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Partiendo de la vista inicial y pulsando sobre el botón “+” aparece la vista que se muestra en la Fig.80, la cuál contiene los cuatro campos correspondientes al punto de acceso (nombre, Mac, posición y descripción), y aparece cada uno de ellos con su correspondiente etiqueta y campo de texto para rellenar la información correspondiente. Si se pulsa el botón de cancelar no se guardará nada y se volverá a la pantalla inicial de la Fig.75.

Figura 80. Vista con la opción de introducir información

Al pulsar sobre el botón “Save” se procederá a salvar toda la información manteniendo siempre en todo momento la persistencia de los datos (internamente guardado en formato XML). Y aparecerá un UIAlert, es decir, un mensaje de alerta indicando que la información se ha guardado con éxito como se puede ver en la Fig.81.

Escuela Técnica Superior de Ingeniería (ICAI)  

129

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

Figura 81. Vista con información almacenada

Escuela Técnica Superior de Ingeniería (ICAI)  

130

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

9.6 Código fuente /*    MyAppDelegate.h    Alfredo  Martín  Díaz    */   #import       @class  MyListController;     @interface  MyAppDelegate  :  NSObject     {          UIWindow  *_window;          UINavigationController  *_navigationController;          MyListController  *_listController;   }     @property  (nonatomic,  retain)  UIWindow  *window;   @property  (nonatomic,  retain)  UINavigationController  *navigationController;   @property  (nonatomic,  retain)  MyListController  *listController;     @end  

/*    MyAppDelegate.m    Alfredo  Martín  Díaz    */     #import  "MyAppDelegate.h"   #import  "MyListController.h"     @implementation  MyAppDelegate     @synthesize  window  =  _window;   @synthesize  navigationController  =  _navigationController;   @synthesize  listController  =  _listController;     #pragma  mark  -­‐     -­‐  (void)dealloc     {          [_window  release];          [_navigationController  release];          [_listController  release];                    [super  dealloc];   }     #pragma  mark  -­‐   #pragma  mark  UIApplicationDelegate  Protocol     Escuela Técnica Superior de Ingeniería (ICAI)  

131

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

  //  Se  invoca  justo  antes  de  que  la  aplicación  termina.  Se  usa  para   //  guardar  los  cambios  que  el  usuario  ha  hecho.     -­‐  (void)applicationWillTerminate:(UIApplication  *)application   {          [_listController  guardar];   }     //   Crea  una  ventana  y  un  controlador  de  la  tabla  de  vista,  y  hace  que  la  vista  de  tabla   //   controlador  vea  una  subvista  de  la  propia  ventana.   //   -­‐  (void)applicationDidFinishLaunching:(UIApplication  *)application     {          CGRect  rect  =  [[UIScreen  mainScreen]  bounds];          UIWindow  *window  =  [[UIWindow  alloc]  initWithFrame:rect];          [self  setWindow:window];                    //    De  forma  predeterminada,  UITableViewController  rellena  su  propia  'vista'   propertywith       //    una  nueva  instancia  de  UITableView,  y  se  hace  la  vista  de  la  tabla     //   instancia  de  origen  de  datos  y  con  su  correspondiente  delegado.          //          MyListController  *tableViewController  =  [[MyListController  alloc]                                                                                            initWithStyle:UITableViewStylePlain];          [self  setListController:tableViewController];               //  UINavigationController  se  inicializa  con  el  controlador  que          //  Maneja  sus  iniciales,  o  la  raíz,  vista.  El  controlador  de  navegación  fija  su          //  Propiedad  desde  el  punto  de  vista  para  apuntar  a  la  vista  del  controlador  de  la  visión   en  la          //  Parte  superior  de  su  pila  interna  de  los  controladores  de  vista.          //          UINavigationController  *navController  =  [[UINavigationController  alloc]                                                                                            initWithRootViewController:tableViewController];                    [self  setNavigationController:navController];                    [window  addSubview:[navController  view]];          [window  makeKeyAndVisible];                    [window  release];          [navController  release];   }     @end  

Escuela Técnica Superior de Ingeniería (ICAI)  

132

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

/*    UIImage+Resizing.h    Alfredo  Martín  Díaz    */   #import       @interface  UIImage  (Resizing)     +  (UIImage  *)imageOfSize:(CGSize)size  fromImage:(UIImage  *)image;     -­‐  (UIImage  *)imageScaledToSize:(CGSize)size;     @end  

   

/*    UIImage+Resizing.m    Alfredo  Martín  Díaz   */   #import  "UIImage+Resizing.h"     @implementation  UIImage  (Resizing)     +  (UIImage  *)imageOfSize:(CGSize)size  fromImage:(UIImage  *)image;   {     UIGraphicsBeginImageContext(size);               [image  drawInRect:CGRectMake(0,0,  size.width,  size.height)];     UIImage  *scaledImage  =  UIGraphicsGetImageFromCurrentImageContext();               UIGraphicsEndImageContext();         return  scaledImage;           }     -­‐  (UIImage  *)imageScaledToSize:(CGSize)size   {     return  [[self  class]  imageOfSize:size  fromImage:self];   }     @end  

Escuela Técnica Superior de Ingeniería (ICAI)  

133

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

/*    MyListController.h    Alfredo  Martín  Díaz    */   #import       @interface  MyListController  :  UITableViewController     {          NSMutableArray  *_displayedObjects;   }     @property  (nonatomic,  retain)  NSMutableArray  *displayedObjects;     +  (NSString  *)pathForDocumentWithName:(NSString  *)documentName;     -­‐  (void)add;   -­‐  (void)guardar;   -­‐  (void)addObject:(id)anObject;     @end       /*    MyListController.m    Alfredo  Martín  Díaz    */   #import  "MyListController.h"   #import  "MyDetailController.h"   #import  "UIImage+Resizing.h"   #import  "Punto.h"     @implementation  MyListController     @synthesize  displayedObjects  =  _displayedObjects;     #pragma  mark  -­‐     -­‐  (void)dealloc   {          [_displayedObjects  release];                    [super  dealloc];   }     +  (NSString  *)pathForDocumentWithName:(NSString  *)documentName   {          NSArray  *paths  =  NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,                                                                                                                    NSUserDomainMask,                                                                                                                      YES);          NSString  *path  =  [paths  objectAtIndex:0];                    return  [path  stringByAppendingPathComponent:documentName];  

Escuela Técnica Superior de Ingeniería (ICAI)  

134

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

}     //  Inicializa  la  matriz  de  objetos  mostrados  por  la  lectura   //  de  ellos  desde  el  sistema  de  archivos.   //   -­‐  (NSMutableArray  *)displayedObjects   {          if  (_displayedObjects  ==  nil)          {                  NSString  *path  =  [[self  class]  pathForDocumentWithName:@"Puntos.plist"];                  NSArray  *puntoDicts  =  [NSMutableArray  arrayWithContentsOfFile:path];                                    if  (puntoDicts  ==  nil)                  {                          NSLog(@"No  se  puede  leer  el  archivo  plist  en  la  ruta:  %@",  path);                          path  =  [[NSBundle  mainBundle]  pathForResource:@"Puntos"                                                                                                        ofType:@"plist"];                          puntoDicts  =  [NSMutableArray  arrayWithContentsOfFile:path];                  }                                    _displayedObjects  =  [[NSMutableArray  alloc]                                                            initWithCapacity:[puntoDicts  count]];                                    for  (NSDictionary  *currDict  in  puntoDicts)                  {                          Punto  *punto  =  [[Punto  alloc]  initWithDictionary:currDict];                          [_displayedObjects  addObject:punto];                  }          }                    return  _displayedObjects;   }     -­‐  (void)addObject:(id)anObject   {          if  (anObject  !=  nil)          {                  [[self  displayedObjects]  addObject:anObject];          }   }     -­‐  (void)guardar   {          NSString  *path  =  [[self  class]  pathForDocumentWithName:@"Puntos.plist"];          NSString  *plist  =  [[self  displayedObjects]  description];                    NSError  *error  =  nil;          [plist  writeToFile:path                          atomically:YES                              encoding:NSUTF8StringEncoding                                    error:&error];      

Escuela Técnica Superior de Ingeniería (ICAI)  

135

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

       if  (error)          {                  NSLog(@"Error  escribiendo  el  fichero  en  la  ruta:  %@;  Error  fue  %@",  path,  error);          }   }     #pragma  mark  -­‐   #pragma  mark  UIViewController     //   Reemplaza  el  método  heredado  para  así  actualizar  automáticamente  los  datos  de  la   vista  de  la  tabla   //   -­‐  (void)viewWillAppear:(BOOL)animated   {          [super  viewWillAppear:animated];                    [[self  tableView]  reloadData];   }     //  Reemplaza  el  método  heredado  para  configurar  el  botón  Editar  y  botón  Agregar   //  y  para  definir  el  título  del  controlador  (que  se  muestra  en  la  barra  de  navegación).   //   -­‐  (void)viewDidLoad   {          [super  viewDidLoad];                    //  El  controlador  de  título  (si  está  configurado)  se  mostrará  en  el          //  controlador  de  navegación  de  la  barra  de  navegación  en  la  parte  superior  de  la   pantalla.          //     [self  setTitle:@"Gestión"];                    [[self  tableView]  setRowHeight:54.0];                    //    Configurar  el  botón  Editar          [[self  navigationItem]  setLeftBarButtonItem:[self  editButtonItem]];                    //    Configurar  el  botón  Añadir          UIBarButtonItem  *addButton  =  [[UIBarButtonItem  alloc]                                                                        initWithBarButtonSystemItem:UIBarButtonSystemItemAdd                                                                      target:self                                                                      action:@selector(add)];                    [[self  navigationItem]  setRightBarButtonItem:addButton];          [addButton  release];   }     //  Reemplaza  el  método  heredado  para  activar/desactivar  el  botón  Editar   //   -­‐  (void)setEditing:(BOOL)editing                      animated:(BOOL)animated   {  

Escuela Técnica Superior de Ingeniería (ICAI)  

136

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

       [super  setEditing:editing                            animated:animated];                    UIBarButtonItem  *editarButton  =  [[self  navigationItem]  rightBarButtonItem];          [editarButton  setEnabled:!editing];   }     #pragma  mark  -­‐   #pragma  mark  Action  Methods     //  Crea  un  controlador  de  navegación  nuevo  con  una  instancia  de  MyDetailController   como   //  su  raíz  controlador  de  punto  de  vista,  y  lo  ejecuta  como  un  controlador  de  vista  modal.   //  Por  defecto,  hace  que  la  vista  de  detalle  se  deslize  desde  la  parte  inferior  de  la   //  pantalla.  No  hay  botón  de  retroceso.   //   -­‐  (void)add   {          MyDetailController  *controller  =  [[MyDetailController  alloc]                                                                              initWithStyle:UITableViewStyleGrouped];                    id  punto  =  [[Punto  alloc]  init];          [controller  setPunto:punto];          [controller  setListController:self];                    UINavigationController  *newNavController  =  [[UINavigationController  alloc]                                                                                                  initWithRootViewController:controller];                    [[self  navigationController]  presentModalViewController:newNavController                                                                                                        animated:YES];                    [punto  release];          [controller  release];   }     #pragma  mark  -­‐   #pragma  mark  UITableViewDelegate  Protocol     //  El  delegado  de  vista  de  la  tabla  es  notificado  de  los  eventos  en  tiempo  de  ejecución,   como  cuando   //  el  usuario  pulsa  en  una  determinada  fila,  o  agrega,  quita  o  reordena  las  filas.   //  Notifica  el  delegado  cuando  el  usuario  selecciona  una  fila.   //   -­‐  (void)tableView:(UITableView  *)tableView   didSelectRowAtIndexPath:(NSIndexPath  *)indexPath   {          MyDetailController  *controller  =  [[MyDetailController  alloc]                                                                              initWithStyle:UITableViewStyleGrouped];                    NSUInteger  index  =  [indexPath  row];          id  punto  =  [[self  displayedObjects]  objectAtIndex:index];            

Escuela Técnica Superior de Ingeniería (ICAI)  

137

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

       [controller  setPunto:punto];          [controller  setTitle:[punto  Nombre]];                    [[self  navigationController]  pushViewController:controller                                                                                        animated:YES];     [controller  release];   }     #pragma  mark  -­‐   #pragma  mark  UITableViewDataSource  Protocol   //   //  De  forma  predeterminada,  UITableViewController  se  hace  el  delegado  de  su  propia   //  instancia  UITableView,  para  que  podamos  poner  en  práctica  métodos  de  datos  del   protocolo  de  origen  aquí.   //   //  Devuelve  el  número  de  secciones  en  la  vista  de  la  tabla.  El  estilo  de  esta   //  vista  de  tabla  es  "normal"  y  no  "agrupados",  por  lo  que  sólo  hay  una  sección.   //   -­‐  (NSInteger)numberOfSectionsInTableView:(UITableView  *)tableView     {          return  1;   }     //    Devuelve  el  número  de  filas  de  la  sesión  actual   //   -­‐  (NSInteger)tableView:(UITableView  *)tableView    numberOfRowsInSection:(NSInteger)section   {          return  [[self  displayedObjects]  count];   }     //    Devuelve  YES  para  permitir  al  usuario  reordenar  las  filas  de  la  vista  de  la  tabla   //   -­‐  (BOOL)tableView:(UITableView  *)tableView   canMoveRowAtIndexPath:(NSIndexPath  *)indexPath   {          return  YES;   }     //  Se  invoca  cuando  el  usuario  arrastra  una  de  las  celdas  de  la  vista  de  la  tabla.   //   -­‐  (void)  tableView:(UITableView  *)tableView   moveRowAtIndexPath:(NSIndexPath  *)sourceIndexPath                toIndexPath:(NSIndexPath  *)targetIndexPath   {          NSUInteger  sourceIndex  =  [sourceIndexPath  row];          NSUInteger  targetIndex  =  [targetIndexPath  row];                    if  (sourceIndex  !=  targetIndex)          {                  [[self  displayedObjects]  exchangeObjectAtIndex:sourceIndex                                                                            withObjectAtIndex:targetIndex];  

Escuela Técnica Superior de Ingeniería (ICAI)  

138

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

       }   }     //  Actualización  de  la  matriz  de  objetos  mostrados  para  insertar/eliminar  objetos  como   sea  necesario.   //   -­‐  (void)  tableView:(UITableView  *)tableView   commitEditingStyle:(UITableViewCellEditingStyle)editingStyle      forRowAtIndexPath:(NSIndexPath  *)indexPath   {          if  (editingStyle  ==  UITableViewCellEditingStyleDelete)          {                  [[self  displayedObjects]  removeObjectAtIndex:[indexPath  row]];                                        NSArray  *indexPaths  =  [NSArray  arrayWithObject:indexPath];                  [[self  tableView]  deleteRowsAtIndexPaths:indexPaths                                                                  withRowAnimation:UITableViewRowAnimationFade];          }   }     //  Devuelve  una  celda  que  contiene  el  texto  a  mostrar  en  el  índice  de  la  fila  para  siempre.   //   -­‐  (UITableViewCell  *)tableView:(UITableView  *)tableView                    cellForRowAtIndexPath:(NSIndexPath  *)indexPath     {          UITableViewCell  *cell  =  [tableView  dequeueReusableCellWithIdentifier:@"MyCell"];                    if  (cell  ==  nil)          {                  cell  =  [[UITableViewCell  alloc]  initWithStyle:UITableViewCellStyleSubtitle                                                                              reuseIdentifier:@"MyCell"];                                    [cell  setAccessoryType:UITableViewCellAccessoryDisclosureIndicator];                                    UIFont  *titleFont  =  [UIFont  fontWithName:@"Georgia-­‐BoldItalic"  size:18.0];                  [[cell  textLabel]  setFont:titleFont];                                    UIFont  *detailFont  =  [UIFont  fontWithName:@"Georgia"  size:16.0];                  [[cell  detailTextLabel]  setFont:detailFont];                                    [cell  autorelease];          }                    NSUInteger  index  =  [indexPath  row];          id  punto  =  [[self  displayedObjects]  objectAtIndex:index];                    NSString  *title  =  [punto  Nombre];          [[cell  textLabel]  setText:(title  ==  nil  ||  [title  length]  <  1  ?  @"?"  :  title)];                    NSString  *detailText  =  [NSString  stringWithFormat:                                                          @"%@        %@",  

Escuela Técnica Superior de Ingeniería (ICAI)  

139

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

              [punto  Nombre],                 [punto  Mac],                 [punto  Posicion],                 [punto  Descripcion]];                    [[cell  detailTextLabel]  setText:detailText];                          return  cell;   }     @end  

/*    MyDetailController.h    Alfredo  Martín  Díaz    */   #import     #import  "MyListController.h"     @class  Punto;   @class  EditableDetailCell;     //    Constantes  que  representan  los  campos  de  los  puntos  de  acceso   //   enum  {          PuntoNombre,          PuntoMac,          PuntoPosicion,          PuntoDescripcion,   };     //    Constantes  que  representan  varias  secciones  correspondientes  a  la  vista  de  la  tabla   //   enum  {          NombreSection,          MacSection,          PosicionSection,          DescripcionSection   };     typedef  NSUInteger  PuntoAttribute;     @interface  MyDetailController  :  UITableViewController     {          Punto  *_punto;          MyListController  *_listController;          EditableDetailCell  *_NombreCell;          EditableDetailCell  *_MacCell;          EditableDetailCell  *_PosicionCell;   Escuela Técnica Superior de Ingeniería (ICAI)  

140

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

       EditableDetailCell  *_DescripcionCell;   }     @property  (nonatomic,  retain)  Punto  *punto;     @property  (nonatomic,  retain)  MyListController  *listController;     @property  (nonatomic,  retain)  EditableDetailCell  *NombreCell;   @property  (nonatomic,  retain)  EditableDetailCell  *MacCell;   @property  (nonatomic,  retain)  EditableDetailCell  *PosicionCell;   @property  (nonatomic,  retain)  EditableDetailCell  *DescripcionCell;     -­‐  (BOOL)isModal;     -­‐  (EditableDetailCell  *)newDetailCellWithTag:(NSInteger)tag;     //    Métodos   //   -­‐  (void)guardar;   -­‐  (void)cancelar;     @end  

/*    MyDetailController.m    Alfredo  Martín  Díaz    */   #import  "MyDetailController.h"   #import  "EditableDetailCell.h"   #import  "Punto.h"     @implementation  MyDetailController     @synthesize  punto  =  _punto;   @synthesize  listController  =  _listController;     @synthesize  NombreCell  =  _NombreCell;   @synthesize  MacCell  =  _MacCell;   @synthesize  PosicionCell  =  _PosicionCell;   @synthesize  DescripcionCell  =  _DescripcionCell;       #pragma  mark  -­‐     -­‐  (void)dealloc   {          [_listController  release];          [_punto  release];                    [_NombreCell  release];          [_MacCell  release];   Escuela Técnica Superior de Ingeniería (ICAI)  

141

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

       [_PosicionCell  release];          [_DescripcionCell  release];                    [super  dealloc];   }     -­‐  (BOOL)isModal   {          NSArray  *viewControllers  =  [[self  navigationController]  viewControllers];          UIViewController  *rootViewController  =  [viewControllers  objectAtIndex:0];                    return  rootViewController  ==  self;   }     //   Método  que  devuelve  una  instancia  totalmente  configurada  de  nuevo   EditableDetailCell.   //   -­‐  (EditableDetailCell  *)newDetailCellWithTag:(NSInteger)tag   {          EditableDetailCell  *cell  =  [[EditableDetailCell  alloc]  initWithFrame:CGRectZero                                                                                                                      reuseIdentifier:nil];          [[cell  textField]  setDelegate:self];          [[cell  textField]  setTag:tag];                    return  cell;   }     #pragma  mark  -­‐   #pragma  mark  Action  Methods     -­‐  (void)guardar   {          [[self  listController]  addObject:[self  punto]];                    [self  dismissModalViewControllerAnimated:YES];             //  Mensaje  de  información  de  que  el  punto  de  acceso  se  ha  guardado  con  éxito           UIAlertView  *alert  =  [[UIAlertView  alloc]  initWithTitle:@"Información  guardada  con   éxito"             message:"Información"  delegate:self  defaultButton:@"OK"             cancelButton:nil  otherButtons:nil];     [alert  show];     [alert  release];           }     -­‐  (void)cancelar   {  

Escuela Técnica Superior de Ingeniería (ICAI)  

142

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

       [self  dismissModalViewControllerAnimated:YES];   }     #pragma  mark  -­‐   #pragma  mark  UIViewController  Methods     -­‐  (void)viewDidLoad   {       //  Si  el  usuario  hace  clic  en  el  botón  '+'  en  la  vista  de  lista,  se          //  crea  una  nueva  entrada  en  lugar  de  modificar  una  ya  existente,  por  lo  que          //  estamos  en  un  controlador  de  navegación  entre  modos  de  transporte.  los   controladores  de  navegación  modal  no  añaden          //  un  nuevo  botón  a  la  barra  de  navegación,  sino  vamos  a  añadir  botones  Guardar  y   Cancelar.          //              if  ([self  isModal])          {                  UIBarButtonItem  *guardarButton  =  [[UIBarButtonItem  alloc]                                                                                  initWithBarButtonSystemItem:UIBarButtonSystemItemSave                                                                                target:self                                                                                action:@selector(guardar)];                                    [[self  navigationItem]  setRightBarButtonItem:guardarButton];                  [guardarButton  release];                                    UIBarButtonItem  *cancelarButton  =  [[UIBarButtonItem  alloc]                               initWithBarButtonSystemItem:UIBarButtonSystemItemCancel                                                                                    target:self                                                                                    action:@selector(cancelar)];                                    [[self  navigationItem]  setLeftBarButtonItem:cancelarButton];                  [cancelarButton  release];          }                    [self  setNombreCell:     [self  newDetailCellWithTag:PuntoNombre]];          [self  setMacCell:       [self  newDetailCellWithTag:PuntoMac]];          [self  setPosicionCell:     [self  newDetailCellWithTag:PuntoPosicion]];          [self  setDescripcionCell:      [self  newDetailCellWithTag:PuntoDescripcion]];     }     //  Sobreescribe  este  método  para  colocar  automáticamente  el  punto  de  inserción  en  el   //  primer  campo.   //   -­‐  (void)viewWillAppear:(BOOL)animated   {          [super  viewWillAppear:animated];                    NSUInteger  indexes[]  =  {  0,  0  };          NSIndexPath  *indexPath  =  [NSIndexPath  indexPathWithIndexes:indexes  

Escuela Técnica Superior de Ingeniería (ICAI)  

143

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

                                                                                                               length:2];                    EditableDetailCell  *cell  =  (EditableDetailCell  *)[[self  tableView]                                                                                                              cellForRowAtIndexPath:indexPath];                    [[cell  textField]  becomeFirstResponder];   }       -­‐  (void)viewWillDisappear:(BOOL)animated   {          [super  viewWillDisappear:animated];                    for  (NSUInteger  section  =  0;  section  <  [[self  tableView]  numberOfSections];  section++)          {                  for  (NSUInteger  row  =  0;  row  <  [[self  tableView]  numberOfRowsInSection:section];   row++)                  {                          NSUInteger  indexes[]  =  {  section,  row  };                          NSIndexPath  *indexPath  =  [NSIndexPath  indexPathWithIndexes:indexes                                                                                                                                  length:2];                                                    EditableDetailCell  *cell  =  (EditableDetailCell  *)[[self  tableView]                                                                                                                              cellForRowAtIndexPath:indexPath];                          if  ([[cell  textField]  isFirstResponder])                          {                                  [[cell  textField]  resignFirstResponder];                          }                  }          }   }     #pragma  mark  -­‐   #pragma  mark  UITextFieldDelegate  Protocol       //  UITextField  envía  este  mensaje  a  su  delegado  después  de  renunciar  al  estado   //  FirstResponder.  Se  usa  esto  para  salvar  el  campo  de  texto  con   //  valor  a  la  propiedad  correspondiente  del  objeto  modelo.   //   -­‐  (void)textFieldDidEndEditing:(UITextField  *)textField   {          static  NSNumberFormatter  *_formatter;                    if  (_formatter  ==  nil)          {                  _formatter  =  [[NSNumberFormatter  alloc]  init];          }                    NSString  *text  =  [textField  text];                    switch  ([textField  tag])  

Escuela Técnica Superior de Ingeniería (ICAI)  

144

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

       {                  case  PuntoNombre:     [_punto  setNombre:text];                break;                  case  PuntoMac:       [_punto  setMac:text];       break;                  case  PuntoPosicion:     [_punto  setPosicion:text];     break;                  case  PuntoDescripcion:      [_punto  setDescripcion:text];   break;          }   }     //  UITextField  envía  este  mensaje  a  su  delegado,  cuando  la  tecla  de  volver   //  se  pulsa.  Se  usa  para  navegar  de  nuevo  a  la  vista  de  lista.       //  Si  el  usuario  quiere  añadir  un  nuevo  tema  en  lugar  de  editar  uno  ya  existente,   //  se  responde  a  la  tecla  de  volver  al  mover  el  punto  de  inserción  a  la  celda  siguiente   //  TextField,  a  menos  que  ya  estamos  en  la  última  celda.   //   -­‐  (BOOL)textFieldShouldReturn:(UITextField  *)textField   {          if  ([textField  returnKeyType]  !=  UIReturnKeyDone)          {       //  Si  no  es  el  último  campo  (en  cuyo  caso  el  teclado  devuelve  la  etiqueta  clave),                    NSInteger  nextTag  =  [textField  tag]  +  1;                  UIView  *nextTextField  =  [[self  tableView]  viewWithTag:nextTag];                                    [nextTextField  becomeFirstResponder];          }          else  if  ([self  isModal])          {       //  Estamos  en  un  controlador  de  navegación  entre  modos  de  transporte,  lo  que   significa  que  el  usuario                  //  añade  un  nuevo  punto  de  acceso  en  lugar  de  editar  uno  ya  existente.                  //                  [self  guardar];          }          else          {                  [[self  navigationController]  popViewControllerAnimated:YES];          }                    return  YES;   }     #pragma  mark  -­‐   #pragma  mark  UITableViewDataSource  Protocol     -­‐  (NSInteger)numberOfSectionsInTableView:(UITableView  *)tableView     {          return  4;   }     -­‐  (NSInteger)tableView:(UITableView  *)tableView  

Escuela Técnica Superior de Ingeniería (ICAI)  

145

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

 numberOfRowsInSection:(NSInteger)section   {          return  section  ==  1  ?  2  :  1;   }     -­‐  (NSString  *)tableView:(UITableView  *)tableView   titleForHeaderInSection:(NSInteger)section   {          switch  (section)          {                  case  NombreSection:    return  @"Nombre";                  case  MacSection:  return  @"Mac";                  case  PosicionSection:      return  @"Posicion";                  case  DescripcionSection:    return  @"Descripcion";          }                    return  nil;   }     -­‐  (UITableViewCell  *)tableView:(UITableView  *)tableView                    cellForRowAtIndexPath:(NSIndexPath  *)indexPath   {          EditableDetailCell  *cell  =  nil;          NSInteger  tag  =  INT_MIN;          NSString  *text  =  nil;          NSString  *placeholder  =  nil;               //  Seleccionar  la  celda  editable  y  los  valores  de  su  campo  de  texto          //          NSUInteger  section  =  [indexPath  section];          switch  (section)            {                  case  NombreSection:                  {                          cell  =  [self  NombreCell];                          text  =  [_punto  Nombre];                          tag  =  PuntoNombre;                          placeholder  =  @"Nombre";                          break;                  }                  case  MacSection:                  {         cell  =  [self  MacCell];         text  =  [_punto  Mac];         tag  =  PuntoMac;         placeholder  =  @"Mac";         break;                                          }                  case  PosicionSection:                  {                          cell  =  [self  PosicionCell];                          text  =  [_punto  Posicion];  

Escuela Técnica Superior de Ingeniería (ICAI)  

146

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

                       tag  =  PuntoPosicion;                          placeholder  =  @"Posicion";                          break;                  }                  case  DescripcionSection:                  {                          cell  =  [self  DescripcionCell];                          text  =  [_punto  Descripcion];                          tag  =  PuntoDescripcion;         placeholder  =  @"Descripcion";                          break;                  }          }                    UITextField  *textField  =  [cell  textField];          [textField  setTag:tag];          [textField  setText:text];          [textField  setPlaceholder:placeholder];                      return  cell;   }     @end  

/*    Punto.h    Alfredo  Martín  Díaz    */   #import       @interface  Punto  :  NSObject     {          NSString  *_Nombre;          NSString  *_Mac;          NSString  *_Posicion;          NSString  *_Descripcion;   }     @property  (nonatomic,  retain)  NSString  *Nombre;   @property  (nonatomic,  retain)  NSString  *Mac;   @property  (nonatomic,  retain)  NSString  *Posicion;   @property  (nonatomic,  retain)  NSString  *Descripcion;         -­‐  (id)initWithDictionary:(NSDictionary  *)dictionary;     @end  

Escuela Técnica Superior de Ingeniería (ICAI)  

147

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

/*    Punto.h    Alfredo  Martín  Díaz    */   #import  "Punto.h"     @implementation  Punto     @synthesize  Nombre  =  _Nombre;   @synthesize  Mac  =  _Mac;   @synthesize  Posicion  =  _Posicion;   @synthesize  Descripcion  =  _Descripcion;     -­‐  (void)dealloc   {          [_Nombre  release];          [_Mac  release];          [_Posicion  release];          [_Descripcion  release];                    [super  dealloc];   }       -­‐  (id)init   {          self  =  [super  init];               //  Se  establecen  estas  cadenas  en  blanco  para  evitar  la  escritura  de  cero  al          //  archivo  plist  si  el  usuario  no  establece  todos  los  valores.          //          [self  setNombre:@""];          [self  setMac:@""];          [self  setPosicion:@""];          [self  setDescripcion:@""];                    return  self;   }     -­‐  (id)initWithDictionary:(NSDictionary  *)dictionary   {          self  =  [self  init];                  NSString  *nomStr  =  [dictionary  valueForKey:@"nombre"];                      NSMutableDictionary  *mutableDict  =  [dictionary  mutableCopy];          [mutableDict  removeObjectForKey:@"nombre"];                    [self  setValuesForKeysWithDictionary:mutableDict];                    return  self;  

Escuela Técnica Superior de Ingeniería (ICAI)  

148

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

}       -­‐  (NSString  *)description   {          NSArray  *keys  =  [NSArray  arrayWithObjects:                                            @"Nombre",                                            @"Mac",                                            @"Posicion",                                            @"Descripcion",                                            nil];                    return  [[self  dictionaryWithValuesForKeys:keys]  description];   }     @end  

      /*    EditableDetailCell.h    Alfredo  Martín  Díaz    */   #import       @interface  EditableDetailCell  :  UITableViewCell   {          UITextField  *_textField;   }     @property  (nonatomic,  retain)  UITextField  *textField;     @end  

      /*    EditableDetailCell.m    Alfredo  Martín  Díaz    */   #import  "EditableDetailCell.h"     @implementation  EditableDetailCell     @synthesize  textField  =  _textField;     #pragma  mark  -­‐     -­‐  (void)dealloc   {          [_textField  performSelector:@selector(release)  

Escuela Técnica Superior de Ingeniería (ICAI)  

149

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

                                         withObject:nil                                            afterDelay:1.0];                    [super  dealloc];   }     -­‐  (id)initWithStyle:(UITableViewCellStyle)style          reuseIdentifier:(NSString  *)identifier   {          self  =  [super  initWithStyle:style  reuseIdentifier:identifier];                    if  (self  ==  nil)          {                    return  nil;          }                    CGRect  bounds  =  [[self  contentView]  bounds];          CGRect  rect  =  CGRectInset(bounds,  20.0,  10.0);          UITextField  *textField  =  [[UITextField  alloc]  initWithFrame:rect];                    //    Modifica  la  etiqueta  que  devuelve  el  teclado  a  siguiente     //          [textField  setReturnKeyType:UIReturnKeyNext];                    //  Hace  que  el  botón  de  borrado  aparecerá  automáticamente.          [textField  setClearButtonMode:UITextFieldViewModeWhileEditing];          [textField  setBackgroundColor:[UIColor  whiteColor]];          [textField  setOpaque:YES];                    [[self  contentView]  addSubview:textField];          [self  setTextField:textField];                    [textField  release];                    return  self;   }     //    Desactiva  el  realce  de  la  celda  seleccionada  actualmente.   //   -­‐  (void)setSelected:(BOOL)selected                        animated:(BOOL)animated     {          [super  setSelected:selected  animated:NO];                    [self  setSelectionStyle:UITableViewCellSelectionStyleNone];   }     @end  

Escuela Técnica Superior de Ingeniería (ICAI)  

150

   

 

Alfredo Martín Díaz   Desarrollo de software para iPhone

 

Escuela Técnica Superior de Ingeniería (ICAI)  

151