Programacin Iphone

ndice de contenido
Introduccin a Xcode e IOS4.................................................................................................9
Introduccin.......................................................................................................................9
El sistema operativo IOS 4..............................................................................................10
Capas del IOS:............................................................................................................12
Capa: Core OS........................................................................................................12
Capa: Core Services...............................................................................................13
Frameworks del Core Services...........................................................................15
Capa: Media Layer..................................................................................................18
Frameworks de Media Layer..............................................................................21
Capa: Cocoa Touch Layer...........................................................................................23
Frameworks de Cocoa Touch.................................................................................26
XCODE............................................................................................................................30
Edicin y visualizacin de tipos de datos................................................................32
Escribir, editar y comprobar cdigo fuente..............................................................32
Editar la configuracin.............................................................................................33
Edicin de valores y claves.....................................................................................33
Diseo grfico del modelo de objetos.....................................................................33
Definir reglas de trasformacin en la migracin delos datos del modelo...............33
Diseo grfico del interfaz de usuario.....................................................................34
Visualizar archivos en paneles separados..............................................................35
Bsqueda de informacin para editar o visualizar..................................................35
Visualizacin de los archivos del proyecto o del rea de trabajo Workspace.....35
Navegacin a travs de los smbolos en un proyecto............................................35
Bsqueda de texto..................................................................................................36
Visualizacin de alertas..........................................................................................36
Manejo de puntos de control...................................................................................36
Control de los hilos y la pila de ejecucin...............................................................36
Grabacin de logs de usuario.................................................................................37
Informacin complementaria en el editor................................................................37
Obtener plantillas, archivos y objetos del Interface Builder....................................38
La Ventana del Organizador...................................................................................39
Visualizar y marcar documentos del proyecto........................................................39
Creacin de un nuevo proyecto..............................................................................40
Ms caractersticas de Xcode.................................................................................42
Espacios de trabajo (Workspaces).........................................................................42
Actualizacin de proyectos.....................................................................................43
Objective-C y Patrn MVC...................................................................................................44
El lenguaje Objective-C...................................................................................................44
Introduccin.................................................................................................................44
Clases..........................................................................................................................46
La interfaz................................................................................................................46
La implementacin..................................................................................................47
Objetos........................................................................................................................48
Instanciar Objetos...................................................................................................48
Tipos estticos y dinmicos....................................................................................48
Variables de instancia.............................................................................................49
Los mtodos................................................................................................................49
Declaracin de un mtodo......................................................................................50
Implementacin de un mtodo................................................................................50
5

Ejecucin de un mtodo..........................................................................................51
Encapsulacin.........................................................................................................51
Estructuras de datos usando clases...........................................................................51
Cadenas de caracteres...............................................................................................52
Crear cadenas.........................................................................................................52
Imprimir cadenas formateadas................................................................................52
Tipos de Datos.............................................................................................................53
Herencia......................................................................................................................53
Los receptores especiales Self y Super......................................................................54
Objetos de Clases.......................................................................................................55
Categoras...................................................................................................................56
Protocolos....................................................................................................................56
Extensiones.................................................................................................................57
Modelo-Vista-Controlador................................................................................................58
Creacin de Interfaces Grficas..........................................................................................62
Arquitectura de ventanas y vistas....................................................................................63
Jerarquas de vistas y manejo de subvistas....................................................................64
El ciclo de vida de un grfico...........................................................................................65
Modos de contenidos.......................................................................................................65
Vistas extensibles............................................................................................................66
Soporte integrado de animaciones..................................................................................67
Vistas geomtricas y sistemas de coordenadas.............................................................68
Propiedades Frame, Bounds y Center de las vistas.......................................................68
Transformaciones del sistema de coordenadas..............................................................70
Puntos vs Pixel................................................................................................................70
Modelo de interaccin en tiempo de ejecucin con las vistas........................................71
Uso Efectivo de las vistas................................................................................................72
Interface Builder...................................................................................................................74
Los archivos .nib..............................................................................................................74
Crear la interfaz de usuario.............................................................................................75
El rea de utilidades....................................................................................................77
Aadir objetos a una vista...........................................................................................79
Configurar los contenidos de objetos..........................................................................80
Poner nombre a una accin e inicializarla..................................................................81
Aadir un Outlet........................................................................................................83
Probar la aplicacin.....................................................................................................84
Jerarqua de objetos en Interface Builder..................................................................84
Gestin de la pantalla..........................................................................................................85
Ventanas..........................................................................................................................85
Crear y configurar una ventana...................................................................................85
Cambiar el nivel de ventana........................................................................................86
Vistas...............................................................................................................................87
Creando y manejando una jerarqua de vistas...........................................................90
Aadir y borrar subvistas........................................................................................90
Ajustar el tamao y la posicin de una vista en tiempo de ejecucin....................93
Modificacin de vistas en tiempo de ejecucin.......................................................95
Interaccin con las capas Core Animation..............................................................96
Definir una vista personalizada...............................................................................98
Animaciones..................................................................................................................101
Animacin de Cambios en las propiedades de una vista.........................................102
6

Eventos..............................................................................................................................106
Acerca de los eventos en iOS.......................................................................................106
Reconocedores de gestos.............................................................................................107
Creacin de un reconocedor de gestos personalizado.............................................112
Entrega de eventos: La cadena de respuesta...........................................................113
Eventos de movimiento.............................................................................................114
Eventos de control remoto.........................................................................................116
Persistencia de datos.........................................................................................................118
Introduccin....................................................................................................................118
Core Data Stack........................................................................................................119
Gestin de un modelo de datos................................................................................123
Aadiendo Eventos........................................................................................................126
Preferencias de usuario.....................................................................................................132
Acerca de las preferencias y ajustes.............................................................................132
Sobre el sistema de usuario por defecto.......................................................................132
Qu hace bueno una preferencia?.....................................................................132
Proporcionar una interfaz de Preferencia.............................................................133
La Organizacin de las Preferencias....................................................................133
Visualizar las preferencias utilizando la herramienta por defecto........................135
Acceso a los valores de las preferencias......................................................................136
Registro de Preferencias de su aplicacin por defecto.............................................136
Sincronizando y detectando cambios en las preferencias........................................137
Estados de las App y multitarea.........................................................................................138
Gestin de cambios de estado de una aplicacin.........................................................138
Acerca de la funcin main...........................................................................................142
Qu hacer en tiempo de lanzamiento de una app?....................................................143
Repuesta a interrupciones.............................................................................................144
Moviendo App al background........................................................................................147
Volviendo al primer plano..............................................................................................148
Finalizacin de una App.................................................................................................149
El bucle de ejecucin principal......................................................................................150
Ejecucin en background y multitarea...........................................................................151
Determinar si Multitarea est disponible.......................................................................151
Ejecucin de una tarea finita en el background............................................................152
Encolando la distribucin de notificaciones locales......................................................152
Implementando tareas de ejecucin prolongada en el background.............................153
Mapas y localizacin..........................................................................................................155
Obtencin de la ubicacin del usuario...........................................................................155
Obtener la ubicacin actual del usuario........................................................................156
Puesta en marcha del Servicio Estndar Localidad......................................................156
Inicio del servicio de ubicacin significativo..................................................................157
Convertir coordenadas en informacin de un lugar......................................................159
Obtencin de informacin mediante Placemark CLGeocoder......................................159
Conversin de nombres de lugares en coordenadas...................................................160
Dibujando Mapas...........................................................................................................161
Agregar una vista del mapa a la interfaz de usuario.....................................................161
Acceso a la librera de imgenes.......................................................................................165
Uso del Framework Image I / O en una aplicacin.......................................................165
Formatos de imagen admitidos.....................................................................................166
Creando y usando fuentes de imgenes.......................................................................167
7

Creacin de una imagen a partir de una fuente de imagen......................................167

Creacin de una imagen en miniatura a partir de una fuente de imagen.................168
Cargado incremental de imgenes...........................................................................169
Visualizar las propiedades de una imagen...............................................................170
Trabajar con destino de imgenes ...............................................................................173
Definir las propiedades de un destino de imagen.....................................................173
Escritura de una imagen a un destino de imagen.....................................................174
Bibliografa.........................................................................................................................175
Enlaces de Inters.............................................................................................................175

Introduccin a Xcode e IOS4

Introduccin
La plataforma de Iphone es similar a la que sustenta Ipad e Ipod Touch, por lo que los
programas desarrollados para uno de los dispositivos serviran para el otro siempre que
no incluyan funcionalidades de telefona u otro tipo de hardware que no est en los
dispositivos.

Fuente: http://developer.apple.com

IOS es el Sistema Operativo que se ejecuta en los dispositivos Iphone, Itouch e Ipad. El
Sistema operativo controla el hardware de los dispositivos y proporciona la tecnologa
necesaria para implementar aplicaciones nativas. El Sistema Operativo tambin maneja
las aplicaciones del sistema como el telfono, correo el navegador (safari) y proporciona
servicios estndar del sistema al usuario.
El SDK Software Development Kit junto con el programa Xcode, es el entorno que permite
realizar desarrollo de programas en estos dispositivos, contienen las herramientas e
interfaces que se necesitan para desarrollar, instalar, ejecutar y realizar los test de
aplicaciones que aparecen en el escritorio de un sistema IOS.
Los programas nativos utilizan los frameworks del sistema y el lenguaje Objective-C y se
ejecutan directamente sobre IOS. De forma distinta que las aplicaciones web, las
aplicaciones nativas se instalan fsicamente en un dispositivo y estn siempre disponibles
para el usuario, incluso si el dispositivo est en modo "vuelo". Las aplicaciones son
residentes al igual que las del sistema y cualquier aplicacin as como datos pueden ser
sincronizadas con el ordenador del usuario va Itunes.

Es posible crear tambin aplicaciones web usando una combinacin de html, CSS y
cdigo JavaScript, esta se ejecutarn dentro del navegador Safari y requerirn una
conexin a Internet. Las aplicaciones nativas por otra parte como son instaladas
directamente en el dispositivo pueden ejecutarse sin conexin a Internet.

El sistema operativo IOS 4

El sistema operativo IOS es una versin de UNIX realizada para MAC.
IOS est dividido en capas de programas, cada una de estas capas realiza funciones
distintas y permiten al desarrollador poder abstraerse y no tener que programar
funciones para manejar el GPS o para acceder a los contenidos y programas que tiene el
sistema operativo.
El nivel ms alto, IOS realiza la intermediacin entre el hardware (memoria, discos, GPS,
Giroscopio, Telfono, wifi, etc...) y las aplicaciones que se ejecutan en la pantalla. Las
aplicaciones por lo tanto no necesitan comunicarse con los dispositivos hardware que
tiene el dispositivo directamente. Las aplicaciones se comunican con el hardware a travs
de un conjunto de interfaces que protegen a la aplicacin de cambios en el hardware y
viceversa. Esta abstraccin permite desarrollar aplicaciones independiente de los
dispositivos y el tipo y capacidad de hardware instalados en ellos.

Las capas de IOS son las que se pueden apreciar en la figura anterior
Las capas superiores estn ms cercanas al usuario y reciben las entradas que realiza
este en el programa, gestionan dichas entradas y las traducen a acciones que se derivan
en actuaciones del hardware que est ms cerca de los niveles inferiores.
Para los programadores de IOS es preferible escribir cdigo que use las capas de mayor
nivel siempre que sea posible, simplemente se ahorrar tiempo en el desarrollo de las
aplicaciones, ya que dichas capas proveen un nivel de abstraccin orientado a objetos y
superior. Escribir cdigo para las capas de alto nivel libera al programador de controlar
sockets e hilos de ejecucin. Aunque las capas de bajo nivel son accesibles, solamente se
deberan utilizar para programar determinadas funciones que o bien no estn
implementadas o la implementacin que tienen no es suficiente para el software que se
est desarrollando.
10

Las tecnologas de IOS se empaquetan en frameworks

Apple entrega la mayora de interfaces de los

sistemas en unos paquetes llamados frameworks. Un
framework es un directorio que contiene una librera
dinmica compartida y recursos asociados (como
cabeceras de archivos, imgenes, ayudas, etc..)
necesarios para usar dicha librera. Para utilizar
dichas libreras deben ser enlazadas a los proyectos
de las aplicaciones que se desarrollan igual que se
haran en otros lenguajes de programacin con
libreras. Enlazndolas al proyecto se facilita el uso de
las funcionalidades y recursos asociados a dicho
framework y se permite que la herramienta de
desarrollo conozca donde encontrar lo encabezados y
otros recursos asociados a dicho framework.

Figura 1.2
Fuente: http://www.calvinx.com

IOS y OS X comparten la mayora de frameworks

La mayora de tecnologas desarrolladas para
IOS estn tambin disponibles en OS X. La
mayor diferencia entre las dos plataformas se
producen a nivel interfaces a pesar de que la
presentacin y el manejo son similares. Como
resultado de esto, es sencillo migrar aplicaciones
desde un sistema a otro con un poco de
esfuerzo.

Xcode es el entorno de desarrollo que se utiliza para construir, comprobar, depurar y

ajustar las aplicaciones desarrolladas. Xcode aglutina las herramientas
necesarias para construir las aplicaciones incluido el simulador de IOS. Las
aplicaciones se escriben y se prueban en el mismo entorno. Para poder instalar
11

Xcode es necesario registrase como usuario en developer.apple.com y

descargar las aplicacin.

Capas del IOS:

Capa: Core OS

Es la base del sistema operativo. Se encarga de realizar la gestin de memoria, el

sistema de ficheros, conexin a la red y procesos que interactan con el hardware
contiene los siguientes frameworks:
Accelerate Framework: Introducido en iOS 4.0, contiene interfaces para trabajar con DSP
(http://en.wikipedia.org/wiki/Digital_signal_processing, http://ayudaelectronica.com/que-esun-dsp/), el lgebra lineal, y los clculos de procesamiento de imgenes. La ventaja de
utilizar este framework en escribir sus propias versiones de estas interfaces es que estn
optimizados para todas las configuraciones de hardware presentes en dispositivos
basados en iOS. Por lo tanto, se puede escribir el cdigo una vez y estar seguro de que
funciona de manera eficiente en todos los dispositivos.
Core Bluetooth Framework: permite a los desarrolladores interactuar especficamente con
Bluetooth y dispositivos de baja energa ("LE=Low Energy") . Las interfaces de ObjectiveC de este framework le permiten escanear en busca de accesorios LE, conectar y
desconectar a los que encuentre, leer y escribir los atributos de un servicio, etc..
External Accessory Framework: Introducido en iOS 3.0, proporciona soporte para la
comunicacin con los dispositivos de hardware conectados y que son compatibles con
IOS. Los dispositivosse conectan mediante el conector dock de 30 pines o de forma
inalmbrica mediante Bluetooth, Este framework permite la obtencin de informacin
sobre cada dispositivo disponible e iniciar sesiones de comunicacin con ellos.
Generic Security Services Framework: Introducido en iOS 5, el Generic Security Services
Framework (GSS.framework) proporciona un conjunto de servicios de seguridad
relacionados con las aplicaciones para iOS. Las interfaces bsicas de este framework se
especifican en el IETF RFC 2743 (http://www.ietf.org/rfc/rfc2743.txt) y RFC 4401
(http://tools.ietf.org/html/rfc4401). Incluye algunas funciones aadidas para la gestin de
credenciales que no estn especificados en la norma, pero que son requeridos por
muchas aplicaciones.
Security Framework: Adems de sus caractersticas integradas de seguridad, iOS tambin
proporciona un framework explcito de Seguridad (Security.framework) que se puede
utilizar para garantizar la seguridad de los datos que las aplicaciones gestionan. Este
framework proporciona interfaces para la gestin de certificados, claves pblicas y
12

privadas, y las polticas de confianza. Es compatible con la generacin de nmeros

pseudoaleatorios criptogrficamente seguros. Tambin es compatible con el
almacenamiento de certificados y claves criptogrficas en el llavero, que es un repositorio
seguro para la informacin confidencial del usuario. La "Common biblioteca Crypto"
proporciona apoyo adicional para el cifrado simtrico, HMAC, y "Digest"
(http://en.wikipedia.org/wiki/Digest_access_authentication). La caracterstica de validacin
"Digest" proporciona funciones que son esencialmente compatibles con los de la
biblioteca OpenSSL, que no est disponible en iOS. En iOS 3.0 o posterior, es posible
compartir el llavero entre varias aplicaciones. Compartir el llavero hace que sea ms fcil
para aplicaciones interoperar con mayor usabilidad. Por ejemplo, puede utilizar esta
funcin para compartir las contraseas de usuario u otros elementos que de otro modo
requieren de su solicitud al usuario por cada aplicacin. Para compartir datos entre
aplicaciones se debe configurar el proyecto Xcode de cada aplicacin, con los derechos
adecuados.
System: El nivel de sistema abarca el entorno del ncleo, los controladores y las
interfaces de bajo nivel UNIX del sistema operativo IOS. El propio ncleo se basa en el
micronucleo Mach y es responsable de todos los aspectos del sistema operativo.
Gestiona el sistema de memoria virtual, hilos, sistema de archivos, red y comunicacin
entre procesos. Los drivers en esta capa tambin proporcionan la interfaz entre el
hardware disponible y frameworks del sistema. Por razones de seguridad, el acceso al
ncleo y los controladores se limita a un conjunto limitado de los frameworks del sistema y
las aplicaciones.
iOS proporciona un conjunto de interfaces para el acceso a muchas caractersticas de
bajo nivel del sistema operativo. El acceso a estas funciones es a travs de la biblioteca
Libsystem. Las interfaces estn basados en C y proporcionar soporte para:

Threading (hilos POSIX)

Conexin en red (sockets BSD)

Archivo y sistema de acceso

E / S estndar

Bonjour DNS y servicios

Configuracin regional de informacin

Asignacin de memoria

Clculos matemticos

Capa: Core Services

Contiene los servicios fundamentales del sistema que utilizan las aplicaciones. Muchas de
las partes del IOS usan esos servicios directamente. Las tecnologas disponibles
en esta capa son:
Almacenamiento iCloud es un servicio ofrecido a partir de IOS 5 que permite al sistema
acceder a los ficheros que el usuario haya almacenado en la nube de Apple. Hay dos
formas de que las aplicaciones usen el almacenamiento de iCloud, cada uno de los cuales
tiene un uso diferente:

Almacenamiento de documentos en iCloud:sirve para almacenar documentos y

datos de usuario en la cuenta de iCloud del usuario.
13

Almacenamiento de bases de datos (key-value data): esta funcin sirve para

compartir pequeas cantidades de datos entre instancias de la aplicacin.

Automtic Reference count (ARC): es una caracterstica a nivel-compilador que simplifica

el proceso de gestin de la vida til de los objetos de Objective-C. Libera al programador
de tener que recordar cundo tiene que retener o liberar un objeto, ARC evala los
requisitos de vida til de los objetos y los inserta automticamente las llamadas a mtodos
adecuados en tiempo de compilacin. ARC reemplaza al estilo de programacin de al
gestin del modelo de memoria tradicional de versiones anteriores de iOS. Los nuevos
proyectos se crean automticamente utilizar ARC. Y Xcode ofrece herramientas de
migracin para ayudar a convertir los proyectos existentes para utilizar ARC
Block Objects: Introducido en iOS 4.0, los Block Objects son objetos generados en
lenguaje C que se pueden incorporar en el cdigo C y Objective-C. UnBlock Objects es
esencialmente una funcin, annima, y datos que van con esa funcin, algo que en otros
idiomas se denomina a veces un cierre (closure) o lambda. Los Block Objects son
particularmente tiles como devoluciones de llamada o en lugares donde se necesita una
manera fcil de combinar tanto el cdigo a ejecutar y los datos asociados.
En iOS, los Block Objects se utilizan comnmente en los siguientes escenarios:

Como un reemplazo para las delegaciones y los mtodos delegados

Como un reemplazo para las "callback functions".

Para implementar los controladores de finalizacin de las operaciones de una sola

vez

Para facilitar la realizacin de una tarea en todos los elementos de una coleccin

Junto a las "dispatch queues", para realizar tareas asncronas

Data Protection: Introducido en iOS 4.0, permite a las aplicaciones que trabajan con datos
de usuario confidenciales usar la encriptacin disponible en algunos dispositivos. Cuando
se designa a un archivo especfico como protegido, el sistema almacena ese archivo en
disco en un formato codificado. Mientras el dispositivo est bloqueado, el contenido del
archivo es inaccesible tanto para la aplicacin como para cualquier intruso potencial. En
iOS 5 y versiones posteriores, la proteccin de datos incluye niveles adicionales de
seguridad. Estos niveles permiten acceder a un archivo abierto, incluso si el usuario
bloquea el dispositivo y acceder a un archivo despus del arranque del dispositivo y
desbloqueo primero, incluso si el usuario posteriormente bloquea el dispositivo.
File-Sharing Support: Introducido en iOS 3.2, permite que los archivos de usuario estn
14

disponibles para las aplicaciones a travs de iTunes 9.1 y posteriores.

Pasos para habilitar el uso compartido de archivos para una aplicacin:

Agregar la clave UIFileSharingEnabled en el archivo Info.plist de la aplicacin y

establecer el valor de la clave a YES.

Poner los archivos que desea compartir en el directorio Documents de la

aplicacin.

Cuando el dispositivo est conectado a la computadora del usuario, iTunes muestra

la seccin de ficheros compartidos y la pestaa de la aplicacin en el dispositivo
seleccionado.

El usuario puede aadir archivos a este directorio o al escritorio.

Las aplicaciones que permiten compartir archivos debe ser capazes de reconocer
cuando se han agregado archivos en el directorio de "Document" y responder
adecuadamente.

Grand Central Dispatch (GCD): Introducido en iOS 4.0, es una tecnologa a nivel BSD que
se utiliza para gestionar la ejecucin de tareas de la aplicacin. GCD combina un modelo
de programacin asncrona con un ncleo altamente optimizado para proporcionar una
conveniente (y ms eficaz) alternativa al "Threading". GCD tambin ofrece alternativas
convenientes para muchos tipos de tareas de bajo nivel, tales como leer y escribir
descriptores de archivo, implementar temporizadores, y monitorizar las seales de control
y los eventos del proceso.
In-App Purchase: Introducido en iOS 3.0, da la capacidad para vender contenidos y
servicios desde el interior de la aplicacin. Esta funcin se lleva a cabo usando el
framework "Store Kit", que proporciona la infraestructura necesaria para procesar las
transacciones financieras utilizando la cuenta del usuario en iTunes. La aplicacin se
encarga de la experiencia general del usuario y la presentacin de los contenidos o
servicios a la venta. En iOS 6, se ha aadido soporte para alojamiento de contenidos y
para la compra de contenidos de iTunes desde el interior de la aplicacin. Con el
alojamiento de contenidos, ahora se puede guardar el contenido descargable en los
servidores de Apple. Con la compra con iTunes, la aplicacin identifica los elementos que
se desea estn disponibles para la compra, pero el resto de la operacin es manejada
por el "Store Kit".
SQLite: La librera de SQLite permite incrustar una base de datos SQL ligera en su
aplicacin sin tener que ejecutar un proceso separado en un servidor remoto de base de
datos. Desde la aplicacin, se puede crear archivos de base de datos local y manejar las
tablas y registros en dichos archivos. La biblioteca est diseada para un uso general
pero est optimizada para proporcionar un acceso rpido a los registros de la base de
datos.
XML Support: el framework "Foundation" proporciona el la clase "Parser" NSXML para
poder recuperar elementos de un documento XML. Tambin tiene soporte para manipular
contenidos en XML a travs de la librera libXML2. Esta librera "Open Source" permite
"parsear" o escribir de manera arbitraria datos rpidamente en XML y transformar
contenido XML en HTML.
Frameworks del Core Services

En esta seccin se describen los frameworks de esta capa y los servicios que contienen.
Accounts Framework: Introducido en iOS 5, el framework de Cuentas
(Accounts.framework) proporciona un inicio de sesin nico para las cuentas de usuario.
Single sign-on mejora la experiencia del usuario, ya que las aplicaciones ya no tienen que
15

solicitar al usuario por separado los datos de registro relacionados con una cuenta.
Tambin simplifica el modelo de desarrollo para el programador de la gestin del proceso
de autorizacin en cuenta para la aplicacin. En iOS 5.0, las aplicaciones pueden utilizar
este framework, en relacin con el framework de Twitter para acceder a la cuenta de un
usuario de Twitter.
Address Book Framework: proporciona acceso a los contactos almacenados en el
dispositivo del usuario. Si la aplicacin utiliza la informacin de contacto, puede usar este
framework para acceder y modificar los registros en la base de datos de contactos del
usuario. En iOS 6 y versiones posteriores, el acceso a los contactos de un usuario
requiere el permiso explcito del usuario.
Ad Support Framework: Introducido en iOS 6, proporciona acceso a un identificador que
las aplicaciones pueden utilizar con fines publicitarios. Este framework tambin
proporciona una bandera que indica si el usuario ha optado por no seguimiento de
anuncios. Aplicaciones estn obligados a leer y aceptar la bandera con permisos antes de
intentar obtener acceso al identificador de publicidad
CFNetwork Framework: es un conjunto de interfaces de alto rendimiento basado en C que
utiliza abstracciones orientadas a objetos para trabajar con protocolos de red. Estas
abstracciones ofrecen un control detallado sobre la pila de protocolos y facilite el acceso
a construcciones de bajo nivel como los sockets BSD. Se puede utilizar para simplificar
tareas tales como la comunicacin con servidores FTP y HTTP o resolver DNS. Con el
framework CFNetwork, puede:

Usar sockets BSD

Crear conexiones cifradas mediante SSL o TLS

Resolver los hosts DNS

Trabajar con servidores HTTP, la autenticacin de servidores HTTP, HTTPS y

servidores

Trabajar con servidores FTP

Publicar, resolver y explorar los servicios de Bonjour

Core Data Framework: Introducido en iOS 3.0, es una tecnologa para la gestin del
modelo de datos de una aplicacin de Modelo-Vista-Controlador. Est diseado para uso
en aplicaciones en las que ya est el modelo de datos altamente estructurado. En lugar
de definir estructuras de datos mediante la programacin, se utiliza las herramientas de
Xcode para construir un esquema que representa el modelo de datos. Mediante esta
gestin del modelo de datos se reduce significativamente la cantidad de cdigo que se
tiene que escribir. Tambin proporciona las siguientes caractersticas:

Almacenamiento de datos de objeto en una base de datos SQLite para un

rendimiento ptimo

Una clase NSFetchedResultsController para gestionar los resultados de las vistas

de tablas

Gestin de deshacer / rehacer ms all de la edicin de texto bsico

Apoyo a la validacin de los valores de las propiedades

Apoyo a la propagacin de los cambios y asegurar que las relaciones entre los
objetos sigan siendo coherentes
16

Apoyo a la agrupacin de datos, filtrado y organizacin de la memoria

Core Foundation Framework: es un conjunto de interfaces basadas en C que permita la

gestin de datos bsicos y caractersticas de servicio para las aplicaciones de iOS. El
framework bsico Foundation est estrechamente relacionado con el framework de la
Fundacin, que proporciona interfaces de Objective-C para las mismas caractersticas
bsicas.Este framework incluye soporte para las siguientes:

Coleccin de tipos de datos (matrices, conjuntos, etc)

"Bundles" (Ficheros empaquetados)

Manejo de "Strings"

Gestin deFecha y tiempo

Gestin de bloques de datos

Gestin de Preferencias

URL y manipulacin corriente

Hilos y bucles

Puerto y comunicacin "socket"

Core Location Framework: proporciona informacin de ubicacin y rumbo a las

aplicaciones. Para obtener informacin sobre la ubicacin, el framework utiliza el GPS
integrado, la radio del telfono o Wi-Fi para encontrar la longitud actual del usuario y la
latitud. Se puede incorporar esta tecnologa en las aplicaciones para proporcionar
informacin de posicin basado en el usuario. En iOS 3.0, se ha aadido soporte para el
acceso a la informacin basada en la brjula rumbo en los dispositivos iOS que incluyen
un magnetmetro. En iOS 4.0, se introdujo por un bajo consumo de energa en la
localizacin de monitoreo servicio que utiliza las torres celulares para rastrear cambios en
la ubicacin del usuario.
Core Media Framework: Introducido en iOS 4.0, proporciona los siguientes tipos de
medios de bajo nivel que utiliza el framework AV Foundation. La mayora de las
aplicaciones no necesitan usar esta plataforma, pero es suministrada por los pocos
desarrolladores que necesitan un control ms preciso sobre la creacin y presentacin de
contenidos de audio y video.
Core Motion Framework: proporciona un nico conjunto de interfaces para el acceso a los
datos de movimiento disponibles en un dispositivo. El framework permite el acceso a los
datos del acelermetro. En los dispositivos con giroscopio, puede recuperar los datos de
ste, as como los datos elaborados que reflejan la actitud y las tasas de rotacin del
dispositivo. Puede utilizar tanto el acelermetro y giroscopio para los juegos u otras
aplicaciones que utilizan el movimiento como entrada o como una manera de mejorar la
experiencia general del usuario.
Core Telephony Framework: Introducido en iOS 4.0, proporciona interfaces para
interactuar con la informacin del telfono basado en dispositivos que tienen un radio
celular. Las aplicaciones pueden utilizar este framework para obtener informacin del
telfono del usuario y del proveedor. Aplicaciones basadas en eventos de llamada
celulares (tales como las aplicaciones de VoIP) tambin pueden ser notificadas cuando
dichos eventos se produzcan.
17

Event Kit Framework: Introducido en iOS 4.0, proporciona una interfaz para acceder a los
eventos del calendario en el dispositivo del usuario. Se pueden obtener eventos
existentes y aadir nuevos eventos al calendario del usuario. Los eventos del calendario
pueden incluir alarmas configurables con las reglas de cundo deben ser entregadas. En
iOS 6, se ha aadido soporte para la creacin y el acceso a los recordatorios en el
dispositivo del usuario.
Foundation Framework: proporciona envoltorios o "Wrappers" en Objective-C de muchas
de las caractersticas que se encuentran en el framework Core Foundation.
Mobile Core Services Framework: Introducido en iOS 3.0, define los tipos de bajo nivel
utilizados en identificadores de tipo de uniformes (IU).
Newsstand Kit Framework: Introducido en iOS 5, Newsstand proporciona un lugar central
para que los usuarios lean revistas y peridicos. Los editores que deseen publicar su
revista y el contenido del peridico a travs de Newsstand pueden crear sus propias
aplicaciones para iOS utilizando el framework Kit (NewsstandKit.framework), que le
permite iniciar la descarga de fondo de la nueva revista y los contenidos de los diarios.
Despus de iniciar una descarga, el sistema se encarga de la operacin de descarga y
notifica a la aplicacin cuando el nuevo contenido est disponible..
Pass Kit Framework: Introducido en iOS 6, Kit Pass utiliza los servicios web, un nuevo
formato de archivo y un framework Objective-C (PassKit.framework) para implementar el
soporte para descargar tickets. Las empresas pueden crear tickets para representar
elementos, tales como cupones, tarjetas de embarque, boletos para eventos, y tarjetas de
descuento para las empresas. En lugar de llevar una representacin fsica de estos
elementos, los usuarios pueden almacenar en su dispositivo iOS y los utilizan de la misma
manera que antes.
Quick Look Framework: Introducido en iOS 4.0, proporciona una interfaz directa para
previsualizar el contenido de archivos que la aplicacin no soporta directamente. Este
framework est diseado principalmente para aplicaciones que descargan archivos desde
la red o que trabajan con archivos de fuentes desconocidas. Despus de obtener el
archivo, se utiliza el controlador de vista que ofrece este framework para mostrar el
contenido de ese archivo directamente en la interfaz de usuario.
Social Framework: Introducido en iOS 6, proporciona una interfaz sencilla para acceder a
las cuentas de redes sociales del usuario. Este framework sustituye al de Twitter que se
introdujo en iOS 5 y aade soporte para otras cuentas sociales, incluyendo Facebook y
Sina Weibo. Las aplicaciones pueden utilizar este framework para publicar actualizaciones
de estado e imgenes a una cuenta de usuario.
Store Kit Framework: Introducido en iOS 3, proporciona apoyo para la adquisicin de
contenidos y servicios desde las aplicaciones para iOS. Por ejemplo, se puede utilizar
esta funcin para permitir al usuario desbloquear caractersticas adicionales de la
aplicacin. O en un juego, se podra ofrecer niveles de juego adicionales. En ambos
casos, el framework Store Kit se encarga de los aspectos financieros de la operacin, el
procesamiento de las solicitudes de pago a travs de la cuenta del usuario en iTunes
Store y la disponibilidad para su solicitud con informacin acerca de la compra.
System Configuration Framework: proporciona interfaces de acceso, que se puede utilizar
para determinar la configuracin de red de un dispositivo. Puede utilizar este framework
para determinar si una conexin Wi-Fi o telefnica est en uso y si un servidor host en
particular es accesible.
Capa: Media Layer

La capa contiene los medios de comunicacin grficos, audio, vdeo y tecnologas

18

dirigidas a crear la mejor experiencia multimedia disponible en un dispositivo mvil. Las

tecnologas de esta capa fueron diseadas para hacer ms fcil la creacin aplicaciones
que se ven y suenan muy bien.
Tecnologas de grficos: Grficos de alta calidad son una parte importante de todas las
aplicaciones para iOS. La ms simple (y ms eficiente) forma de crear una aplicacin es
el uso de imgenes predefinidas junto con las vistas y controles estndar ofrecidas por el
framework UIKit. Sin embargo, puede haber situaciones en las que debe ir ms all de un
simple grfico. En esas situaciones, puede utilizar las siguientes tecnologas para
gestionar el contenido grfico de la aplicacin:

Core Graphics (tambin conocida como "Quartz") se encarga de la representacin

nativa 2D vectorial y basado en imgenes.

Core Animation (parte de la estructura del ncleo de "Quartz") proporciona soporte

avanzado para la animacin de puntos de vista y otros contenidos.

Core Image proporciona soporte avanzado para la manipulacin de vdeo e

imgenes fijas.

OpenGL ES y GLKit proporcionar apoyo para el renderizado 2D y 3D acelerados

por hardware usando interfaces.

Texto Core ofrece un diseo de texto sofisticado y motor de renderizado.

Imagen de E / S proporciona interfaces para leer y escribir la mayora de formatos

de imagen.

El framework "Assets Library" proporciona acceso a las fotos y los vdeos de la

biblioteca de fotos del usuario.

Tecnologas de audio: Las tecnologas de audio disponibles en iOS estn diseadas para
ayudar a proporcionar una rica experiencia de audio para los usuarios. Esta experiencia
incluye la capacidad de reproducir audio de alta calidad, grabar audio de alta calidad, y
activar la funcin de vibracin en ciertos dispositivos. El sistema ofrece varias formas de
reproducir y grabar contenido de audio. Los frameworks de la siguiente lista se ordenan
de nivel alto a nivel bajo, el framework Media Player ofrece las interfaces de ms alto nivel
que puede utilizar. Al elegir una tecnologa de audio, recuerde que los frameworks de alto
nivel son ms fciles de usar y se prefieren en general. Frameworks de bajo nivel ofrecen
ms flexibilidad y control, pero requieren ms trabajo. Los frameworks de la siguiente lista
se ordenan de nivel alto a nivel bajo, el framework Media Player ofrece las interfaces de
ms alto nivel que puede utilizar. Al elegir una tecnologa de audio, recuerde que los
frameworks de alto nivel son ms fciles de usar y se prefieren en general. Los
frameworks de bBajo nivel ofrecen ms flexibilidad y control, pero requieren ms trabajo.

Framework Media Player ofrece un acceso fcil a la biblioteca de iTunes del

usuario y soporte para la reproduccin de pistas y listas de reproduccin.

El framework AV Fundacin proporciona un conjunto de funciones fciles de usar

Objective-C interfaces para la gestin de la reproduccin y grabacin de audio.

OpenAL proporciona un conjunto de interfaces multi-plataforma para la entrega de

audio posicional.
19

Framework Core Audio ofrece dos interfaces simples y sofisticados para reproducir
y grabar contenido de audio. Estas interfaces se utilizan para reproducir los sonidos
del sistema, la capacidad de vibracin de un dispositivo, y la gestin del
almacenamiento temporal y la reproduccin de contenido de audio multicanal local
o streaming.

Las tecnologas de audio en iOS compatible con los siguientes formatos de audio:
AAC, Apple Lossless (ALAC), A-law, IMA / ADPCM (ima4), Linear PCM, -law, DVI /
Intel ADPCM IMA, Microsoft GSM 6.10, AES3-2003

Tecnologas de vdeo: cuando se estn visualizando o descargando archivos de pelcula

desde la red, iOS ofrece varias tecnologas para reproducir contenido basado en video.
En los dispositivos con cmara de vdeo, tambin se pueden utilizar estas tecnologas
para capturar y ms tarde incorporar vdeos en la aplicacin. Los frameworks de alto nivel
simplifican el trabajo de desarrollo en estas tecnologas. Los frameworks de la siguiente
lista se ordenan de mayor a menor nivel, con el framework Media Player se ofrecen los
interfaces de ms alto nivel que se pueden utilizar:

La clase UIImagePickerController en UIKit proporciona una interfaz estndar para

la grabacin de vdeo en dispositivos con una cmara compatible.

El framework Media Player proporciona un conjunto de fcil uso de interfaces para

presentar pelculas completas o parciales de pantalla de la aplicacin.

El framework "AV Foundation" proporciona un conjunto de interfaces de ObjectiveC para el manejo de la captura y la reproduccin de pelculas.

En Core Media se describen los tipos de datos de bajo nivel que utilizan los
frameworks de alto nivel y proporciona interfaces de bajo nivel para la manipulacin
de los medios de comunicacin.

Las tecnologas de vdeo en iOS soportan la reproduccin de archivos de pelcula

con el mov, mp4, m4v, y .3 gp extensiones de archivos y el uso de los estndares
de compresin siguientes...: Vdeo H.264, hasta 1,5 Mbps, 640 por 480 pxeles, 30
fotogramas por segundo, versin de baja complejidad del perfil bsico H.264 con
sonido AAC-LC de hasta 160 Kbps, 48 kHz, audio estreo en formato. M4v, . mp4,
y formatos de archivo MOV. Vdeo H.264, hasta 768 Kbps, 320 por 240 pxeles, 30
fotogramas por segundo, perfil bsico hasta nivel 1.3 con sonido AAC-LC de hasta
160 Kbps, 48 kHz, audio estreo en formato. M4v,. Mp4, y. Mov. Vdeo MPEG-4 de
hasta 2,5 Mbps, 640 por 480 pxeles, 30 fotogramas por segundo, perfil simple con
sonido AAC-LC de hasta 160 Kbps, 48 kHz, audio estreo en formato. M4v,. Mp4, y
formatos de archivo MOV. Numerosos formatos de audio, incluyendo los que
aparecen en "Audio Technologies".

AirPlay: AirPlay es una tecnologa que permite hacer streaming de audio hacia
Apple TV y altavoces AirPlay. El soporte de AirPlay est integrado en el framework
de AV Foundation y Core Audio . Cualquier contenido de audio que juega usando
estos frameworks se realiza automticamente elegible para la distribucin de
AirPlay. Una vez que el usuario decida reproducir el audio utilizando AirPlay, es
dirigida automticamente por el sistema. En iOS 5, los usuarios pueden reflejar el
contenido de un iPad 2 a un Apple TV 2 con AirPlay para cualquier aplicacin.Los
desarrolladores que quieran mostrar contenido diferente (en lugar de espejo) puede
asignar un objeto a una nueva ventana UIScreen y conectarla a un iPad 2 a travs
20

de AirPlay. iOS 5 tambin ofrece ms maneras de entregar contenido a travs de

AirPlay, incluyendo el uso de la clase AvPlayer en el framework de AV Foundation y
la clase UIWebView en el framework UIKit. Adems, el framework Media Player
ahora incluye soporte para mostrar "Now Playing" en varios lugares.
Frameworks de Media Layer

la siguiente seccin describe los frameworks de Media y los servicios ofrecidos en esta
capa:
Assets Library Framework: proporciona una interfaz basada en consultas para la
recuperacin de fotos y vdeos del dispositivo del usuario. El uso de este framework, se
puede acceder a los mismos ficheros que normalmente gestiona la aplicacin Fotos,
incluidos los elementos de lbum del usuario, fotos y vdeos de todos los que se
importaron en el dispositivo.
AV Foundation Framework: contiene las clases de Objective-C para la reproduccin de
contenido de audio. Se pueden reproducir varios sonidos simultneamente y controlar
varios aspectos de reproduccin de cada sonido. En iOS 3.0 y versiones posteriores, este
framework tambin incluye soporte para la grabacin de audio y la gestin de informacin
de la sesin de audio. En iOS 4.0 y versiones posteriores, los servicios que ofrece este
framework se han ampliado para incluir:

Gestin de contenidos multimedia propios, edicin de medios, captura de vdeo,

reproduccin de vdeo, metadatos para la gestin de elementos multimedia, gestin
de sonidos (Stereophonic panning), sincronizacin precisa entre los sonidos, una
interfaz Objective-C para determinar detalles sobre los archivos de sonido, como el
formato de datos, frecuencia de muestreo y el nmero de canales.
En IOS 5 se incluye la gestin de AirPlay.

Core Audio: Soporte nativo para audio es proporcionada por la familia de frameworks
Core Audio , que se enumeran en la Tabla 2-1. Core Audio es una interfaz basada en C
que soporta la manipulacin de estreo basado en audio. Puede utilizar Core Audio en
iOS para generar, grabar, mezclar y reproducir audio en las aplicaciones. Tambin puede
utilizar Core Audio para activar la funcin de vibracin en los dispositivos que lo soporten.

21

Core Graphics Framework: contiene las interfaces de la API de dibujo de Quartz 2D.
Quartz es el mismo pero ms avanzado, dibujo vectorial y es el mismo motor de dibujo
que se utiliza en OS X. Proporciona soporte para dibujo basado en "Paths",
representacin suavizada (Anti-aliased), degradados, colores, transformaciones de
coordenadas espaciales, y creacin y visualizacin de documentos PDF. Aunque la API
est basada en C, utiliza abstracciones orientada a objetos para representar los
elementos fundamentales de dibujo, por lo que es fcil de almacenar y reutilizar su
contenido grfico.
Core Image Framework: Introducido en iOS 5, ofrece un potente conjunto de filtros
integrados para la manipulacin de vdeo e imgenes fijas. Se puede utilizar filtros
integrados para todo, desde operaciones simples (como retocar y corregir fotos) a las
operaciones ms avanzadas (como deteccin de rostro). La ventaja de utilizar estos filtros
es que operan de manera no destructiva a fin de que las imgenes originales no se
modifiquen directamente. Adems, Core Image aprovecha la CPU disponible y la
potencia de procesamiento de la GPU para asegurar que las operaciones son rpidas y
eficientes. La clase CIImage proporciona acceso a un conjunto estndar de filtros que se
utilizan para mejorar la calidad de una fotografa.
Core MIDI Framework: Introducido en iOS 4.2, proporciona una forma estndar de
comunicacin con dispositivos MIDI, como teclados y sintetizadores hardware. Este
framework se utiliza para enviar y recibir mensajes MIDI e interactuar con los perifricos
MIDI que estn conectados a un dispositivo basado en iOS usando el conector de la base
o de la red.
Core Text Framework: Introducido en iOS 3.2, contiene un conjunto simple de interfaces
de alto rendimiento basados en C para escribir texto y manipular las fuentes. Este
framework Core proporciona un motor de diseo de texto completo que se puede utilizar
para gestionar la colocacin del texto en la pantalla, las fuentes utilizadas y los estilos.
Este framework est diseado para su uso en aplicaciones que requieran sofisticadas
capacidades de manejo de texto, tales como aplicaciones de procesamiento de textos. Si
su aplicacin requiere uso de texto simple, es mejor utilizar las clases de texto existentes
en el framework UIKit.
Core Video Framework: proporciona soporte para "buffer" y "buffer pooll" en el framework
de Core Media.
Image I/O Framework: Introducido en iOS 4.0, proporciona interfaces para importar y
exportar datos de imgenes y metadatos de imagen. Este framework hace uso de los
grficos bsicos los tipos de datos y funciones y soporta todos los tipos de imgenes
estndar disponibles en iOS. En iOS 6 y versiones posteriores, puede utilizar este
framework para acceder a las propiedades EXIF e IPTC de metadatos para imgenes.
GLKit Framework: Introducido en iOS 5, contiene un conjunto de clases de Objective-C
que simplifican el esfuerzo necesario para crear una aplicacin OpenGL ES 2.0. GLKit
proporciona soporte para cuatro reas clave de desarrollo de aplicaciones:

El GLKView y clases GLKViewController proporcionan una implementacin

estndar de una vista OpenGL ES y la representacin del bucle asociado.

La clase GLKTextureLoader ofrece conversin de imgenes y rutinas de carga de

la aplicacin, lo que le permite cargar automticamente imgenes de textura en el
contexto. Se puede cargar texturas de forma sincrnica o asincrnica.

El framework GLKit proporciona implementaciones de vectores, matrices y

cuaterniones, as como un funcionamiento de la pila de matrices que proporciona la
misma funcionalidad que se tiene en OpenGL ES 1,1.
22

Las clases GLKBaseEffect, GLKSkyboxEffect y GLKReflectionMapEffect

proporciona la gestin de piezas de cdigo (graphics shader)que son comnmente
utilizadas operaciones grficas. En particular, la clase GLKBaseEffect implementa
la iluminacin y el modelo de material que se encuentra en la especificacin
OpenGL ES 1,1, simplificando el esfuerzo necesario para migrar una aplicacin de
OpenGL ES 1,1 a 2,0 OpenGL ES.

Media Player Framework: proporciona soporte de alto nivel para la reproduccin de audio
y vdeo desde una aplicacin. Se puede utilizar este framework para reproducir vdeo
mediante una interfaz estndar del sistema. En iOS 3.0, se ha aadido soporte para el
acceso a la biblioteca del usuario en iTunes msica. Con este soporte, pueden reproducir
pistas de msica y listas de reproduccin, buscar canciones, y presentar una interfaz para
seleccionar los medios. En iOS 3.2, se han realizado cambios para la reproduccin de
vdeo desde una ventana de tamao variable. Adems, se han aadido numerosas
interfaces para configurar y gestionar de la reproduccin de vdeos. En iOS 5, se ha
aadido funcionalidad para la visualizacin de "Reproduccin en curso". Esta informacin
tambin se puede visualizar en un Apple TV a travs de AirPlay. Tambin hay interfaces
para detectar si el vdeo se est transmitiendo a travs de AirPlay.
OpenAL Framework: es un estndar multiplataforma para enviar audio posicional en las
aplicaciones. Se puede utilizar para implementar audio de alto rendimiento y alta calidad
en juegos y otros programas que requieren salida de audio posicional. OpenAL es un
estndar entre plataformas, el cdigo de los mdulos en iOS puede ser portado a otras
plataformas fcilmente.
OpenGL ES Framework: proporciona herramientas para dibujar contenidos en 2D y 3D.
Se trata de un framework basado en C que trabaja en estrecha colaboracin con el
hardware del dispositivo para proporcionar alta velocidad de fotogramas. El framework
OpenGL se utiliza junto con las interfaces EAGL. Estas interfaces son parte del framework
de OpenGL ES y proporcionan la interfaz entre el cdigo de dibujo OpenGL ES y los
objetos de ventana nativos definidos por UIKit.
Quartz Core Framework: contiene las interfaces Core Animation. Core Animation es una
tecnologa avanzada animacin y de composicin que utiliza una ruta de reproduccin
optimizada para ejecutar complejas animaciones y efectos visuales. Core Animation se
integra en muchas partes de iOS, incluyendo las clases UIKit como UIView,
proporcionando animaciones para muchos comportamientos estndar del sistema.
Tambin puedos utilizar la interfaz Objective-C en este framework para crear animaciones
personalizadas.

Capa: Cocoa Touch Layer

Cocoa Touch contiene los frameworks clave para crear aplicaciones en iOS. Esta capa
define la infraestructura bsica de las aplicaciones da soporte para las tecnologas clave,
tales como la multitarea, entradas basadas en el contacto, notificaciones push, y muchos
servicios de alto nivel del sistema. En el diseo de aplicaciones, se debe tener en cuenta
las tecnologas en esta primera capa para ver si se ajustan a sus necesidades.
A continuacin se describen las caractersticas y funcionalidades de la capa.
AutoLayout: Introducido en iOS 6, mejora a los frameworks springs and struts" utilizados
anteriormente para exponer los elementos de la interfaz de usuario. Con Auto Layout, se
definen reglas para la manera de disponer los elementos de la interfaz de usuario. Estas
23

reglas expresan una clase ms amplia de relaciones y son ms intuitivas de usar que
lossprings and struts". Por ejemplo, se puede especificar que un botn siempre debe
tener 20 micras desde el borde izquierdo de la vista padre. Las entidades usadas en Auto
Layout automtico son objetos Objective-C llamados restricciones (constrains). Este
enfoque le ofrece una serie de ventajas:

La localizacin es a travs de intercambio de cadenas solo, en vez de renovar

tambin diseos.
Duplicacin de elementos de la interfaz de usuario de derecha a izquierda idiomas
como el hebreo y el rabe.
Mejor superposicin de prioridades entre los objetos de la vista y las capas de
controlador.
La vista de un objeto tiene y conoce su tamao estndar, su posicionamiento
dentro de su Super vista, y su posicionamiento en relacin a los de sus objetos
hermanos. Un controlador de vista puede anular estos valores si es necesario.

Storyboards: Introducido en iOS 5, los storyboards sustituyen a los archivos nib como la
forma recomendada para el diseo de la interfaz de usuario de la aplicacin. A diferencia
de los archivos nib, los storyboards permiten disear la interfaz de usuario completa en un
solo lugar para que se puedan ver todas las vistas, controladores y cmo trabajan juntos.
Una parte importante de los storyboards es la capacidad de definir segues, que son las
transiciones desde una vista hacia el controlador. Se pueden definir estas transiciones
visualmente en Xcode o mediante programacin en Xcode. Estas transiciones permiten
capturar el flujo de su interfaz de usuario, adems de los contenidos. Se puede utilizar un
archivo de storyboard nico para almacenar todos los controladores de vista y vistas, o se
pueden utilizar mltiples storyboards de vistas para organizar las partes de la interfaz. Al
momento de la construccin, Xcode toma el contenido del archivo de storyboardy lo divide
en trozos que se pueden cargar de forma individual para un mejor rendimiento. Las
aplicaciones no necesitan manipular estas piezas directamente, sin embargo. El
framework UIKit ofrece clases de conveniencia para acceder a los contenidos de un guin
grfico desde el cdigo.
Document Support: Introducido en iOS 5, el framework UIKit introdujo la clase
UIDocument para la gestin de los datos asociados a los documentos del usuario. Esta
clase realiza la implementacin de aplicaciones basadas en documentos mucho ms fcil,
especialmente las aplicaciones que almacenan documentos en iCloud. Adems de
proporcionar un recipiente para todos los datos relativos a los documentos, la clase
UIDocument ofrece soporte integrado para lectura y escritura asncrona de datos de
archivo, archivo seguro de datos, archivo automtico de datos, soporte para la deteccin
de conflictos iCloud, y el soporte para archivos planos o representaciones de paquetes de
archivos. Para las aplicaciones que utilizan los datos bsicos en su modelo de datos, se
puede utilizar la subclase UIManagedDocument para administrar almacenes de datos.
Multitasking: Las aplicaciones creadas con iOS SDK 4.0 o posterior (en funcionamiento en
iOS 4.0 y posteriores) no se cierran cuando el usuario pulsa el botn Inicio, en cambio,
cambian a un contexto de ejecucin en segundo plano. El soporte multitarea definido por
UIKit ayuda a la aplicacin hacia una transicin hacia y desde el estado de fondo sin
problemas. Para preservar la vida de la batera, la mayora de las aplicaciones son
suspendidas por el sistema poco despus de entrar en el background. La solicitud de
suspensin permanece en la memoria pero no ejecuta ningn cdigo. Este
24

comportamiento permite que una aplicacin pueda reanudar rpidamente cuando se

relance sin consumir energa de la batera en ese intervalo. Sin embargo, las aplicaciones
se les podra permitir que continuasen funcionando en segundo plano por las siguientes
razones:

Una aplicacin puede solicitar una cantidad finita de tiempo para completar una
tarea importante.
Una aplicacin puede declararse como soporte de servicios especficos que
requieren tiempo regular ejecucin en segundo plano.
Una aplicacin puede utilizar notificaciones locales para generar alertas de usuario
en los horarios establecidos, si la aplicacin se est ejecutando.
Independientemente de si una aplicacin se suspende o contina funcionando en
segundo plano, el soporte de la multitarea requiere trabajo adicional. El sistema
avisa a la aplicacin de las transiciones hacia y desde el background. Estos puntos
de notificacin son seales para realizar tareas en aplicaciones importantes, como
guardar los datos de los usuarios

Printing: Introducido en iOS 4.2, el soporte de impresin UIKit permite a las aplicaciones
enviar contenido de forma inalmbrica a impresoras cercanas. En su mayor parte, UIKit
hace todo el trabajo pesado asociado con la impresin. Gestiona las interfaces de
impresin, trabaja con su aplicacin para representar el contenido imprimible, y se
encarga de la programacin y la ejecucin de los trabajos de impresin en la impresora.
Los trabajos de impresin enviados por la aplicacin son manejados por el sistema de
impresin, que gestiona el proceso de impresin. Los trabajos de impresin de todas las
aplicaciones en un dispositivo estn en la cola y se imprimen en orden de llegada, . Los
usuarios pueden ver el estado de los trabajos de impresin desde la aplicacin Centro de
impresin y puede incluso utilizar esa aplicacin para cancelar los trabajos de impresin.
Todos los dems aspectos de la impresin se manejan de forma automtica por el
sistema.
UI State Preservation: Introducido en iOS 6, estado de conservacin hace que sea ms
fcil para las aplicaciones restaurar la interfaz de usuario al estado en que se encontraba
cuando el ltimo usuario la utiliz. Cuando una aplicacin pasa a un segundo plano, se le
pide que guarde el estado de sus vistas y controladores de visualizacin. Al reiniciar, la
aplicacin utiliza este estado para restaurar la interfaz y hacer que parezca como si la
aplicacin nunca hubiera pasado a segundo plano. UI State Preservation se integra en
UIKit, que proporciona la infraestructura para guardar y restaurar la interfaz de su
aplicacin.
Apple Push Notification Service: Introducido en iOS 3.0, el Apple Push Notification Service
proporciona una forma de alertar a los usuarios de que hay nueva informacin, incluso
cuando la aplicacin no est ejecutndose. El uso de este servicio, puede enviar
notificaciones de texto, aadir una divisa a un icono o activar alertas audibles en los
dispositivos de usuario en cualquier momento. Estos mensajes son para que los usuarios
sepan que deben abrir la aplicacin para recibir la informacin relacionada.
os usuarios.
Local Notification: Introducido en iOS 4.0, notificaciones locales complementa el
mecanismo de notificacin push existentes, proporcionando una va para de generacin
25

de las notificaciones a nivel local en lugar de depender de un servidor externo. Las

aplicaciones que se ejecutan en segundo plano pueden utilizar las notificaciones locales
como una forma de llamar la atencin del usuario cuando suceden eventos importantes.
Por ejemplo, una aplicacin de navegacin que se ejecuta en segundo plano pueden
utilizar las notificaciones locales para alertar al usuario cuando es el momento de hacer un
giro. Las aplicaciones tambin pueden programar la entrega de notificaciones locales para
una fecha y hora posteriores y tener esas notificaciones entregado incluso si la aplicacin
no se est ejecutando. La ventaja de las notificaciones locales es que son independientes
de la aplicacin. Una vez que una notificacin est programado, el sistema gestiona la
entrega de la misma. Su aplicacin no tiene ni siquiera para estar en ejecucin cuando la
notificacin se entrega.
Gesture Recognizers: Introducido en iOS 3.2, on objetos que se conectan a las vistas y
se utilizan para detectar tipos comunes de gestos, tales como golpes y pellizcos. Despus
de adjuntar un reconocedor de movimientos a una vista, hay que programar la accin a
realizar cuando se produce el gesto. El objeto reconocedor de movimientos despus de
reconocer el tipo de gesto aplica las heursticas definidas por el sistema para que el gesto
dado sea reconocido.
Peer-to-Peer Services: Introducido en iOS 3.0, ofrece conexin peer-to-peer a travs de
Bluetooth. Puede utilizar conexin peer-to-peer para iniciar sesiones de comunicacin con
dispositivos cercanos y poner en prctica muchas de las caractersticas encontradas en
los juegos multijugador. Aunque se utiliza principalmente en los juegos, tambin se puede
utilizar esta funcin en otros tipos de aplicaciones
Standar system view controller: Muchos de los frameworks de la capa de Cocoa Touch
contienen controladores para ver la presentacin de interfaces estndar del sistema. Para
presentar una experiencia de usuario consistente es conveniente usar estos controladores
de vista en las aplicaciones. Siempre que sea necesario llevar a cabo una de las
siguientes tareas, se debe utilizar un controlador de vista del framework correspondiente:
Mostrar o editar la informacin de contacto
Crear o editar eventos de calendario
Redactar un correo electrnico o mensaje SMS
Abrir o previsualizar el contenido de un archivo
Tomar una fotografa o eligir una foto de la foto de la biblioteca del usuario
Mostrar un video clip
External Display Support: Introducido en iOS 3,2, soporte de visualizacin externo permite
que algunos dispositivos basados en iOS puedan ser conectados a una pantalla externa a
travs de un conjunto de cables compatibles. Cuando est conectado, la pantalla
asociada puede ser utilizada por la aplicacin para visualizar el contenido.
Frameworks de Cocoa Touch

Address Book UI Framework: es una interfaz de programacin de Objective-C que se

utiliza para visualizar las interfaces de sistema estndar para la creacin de nuevos
contactos y para la edicin y seleccin de los contactos existentes. Este framework
simplifica el trabajo necesario para mostrar la informacin de contacto de su aplicacin y
26

tambin asegura que la aplicacin utiliza las mismas interfaces que las dems solicitudes,
garantizando as la coherencia en la plataforma.
Event Kit UI Framework: Introducido en iOS 4.0, proporciona controladores para ver la
presentacin de las interfaces de sistema estndar para la visualizacin y edicin de
eventos relacionadas con el calendario.
Game Kit Framework: Introducido en iOS 3.0, permite aadir capacidades peer-to-peer de
red para las aplicaciones. En concreto, este framework proporciona soporte para
conexiones peer-to-peer y el juego de funciones de voz. Aunque estas caractersticas se
encuentran ms comnmente en los juegos multijugador de red, tambin se pueden
incorporar en las aplicaciones que no sean juegos. El framework proporciona funciones de
red a travs de un simple (pero potente) conjunto de clases construidas en la parte
superior de Bonjour. Para desarrolladores que pueden no tener experiencia en la
programacin en red, el framework permite incorporar funciones de red en sus
aplicaciones.
Introducido en iOS 4.1, Game Center es una extensin del framework Game Kit que
proporciona soporte para las siguientes funciones:
Alias, para permitir a los usuarios crear su propio personaje en lnea. Los usuarios inician
sesin en el Centro de Juego e interactuar con otros jugadores de forma annima a travs
de sus alias. Los jugadores pueden configurar mensajes de estado, as como marcar
determinadas personas como sus amigos.
Tablas de clasificacin, para permitir su aplicacin para publicar puntuaciones de los
usuarios de Game Center y recuperarlos ms tarde. Puede utilizar esta caracterstica para
mostrar los mejores resultados entre todos los usuarios de la aplicacin.
Matchmaking, que le permite crear partidas multijugador mediante la conexin de los
jugadores que han iniciado sesin en Game Center. Los jugadores no tienen que ser
locales entre s para unirse a una partida multijugador.
Logros, que le permiten registrar el progreso de un jugador ha hecho en su juego.
Desafos, permiten a un jugador para desafiar a un amigo a batir un logro o resultado.
(IOS 6 y versiones posteriores)
En iOS 5 y versiones posteriores, se puede utilizar la clase GKTurnBasedMatch para
implementar el soporte para juegos por turnos, lo que permite a los juegos para crear
partidas persistentes cuyo estado se almacena en iCloud. El juego maneja la informacin
de estado para la partida y determina qu jugador debe jugar para seguir la partida
iAd Framework: Introducido en iOS 4.0, permite mostrar anuncios basados en banners en
la aplicacin. Los anuncios se integran en la aplicacin y se muestran cuando sea
necesario. Las vistas trabajan con el servicio de anuncios de Apple que se encarga del
manejo del anuncio.
Map Kit Framework: Introducido en iOS 3.0, proporciona una interfaz de mapa con scroll
que se puede integrar en las jerarquas de vistas existentes en la aplicacin. Este mapa
proporciona direcciones o resalta puntos de inters.La aplicacin puede establecer los
atributos del mapa o permitir al usuario navegar por el mapa libremente. Tambin puede
anotar el mapa con imgenes personalizadas o contenido. En iOS 4.0, la vista del mapa
bsico obtuvo el soporte para anotaciones y plantillas personalizadas. En iOS 6.0, ahora
se puede crear una aplicacin para enrutamiento, cuyo trabajo consiste en orientar a los
usuarios. Cuando el usuario solicita una direccin, la aplicacin Maps ahora permite al
27

usuario elegir la aplicacin desde la que recibir esa direccin.

Message UI Framework: Introducido en iOS 3.0, ofrece soporte para la creacin de
mensajes de correo electrnico en la bandeja de salida. El soporte consta de una interfaz
de controlador de vista que se presenta en la aplicacin. En iOS 4.0 y versiones
posteriores, este framework proporciona un controlador de vista para la presentacin de
una pantalla de composicin de SMS.
Twitter Framework: En iOS 6, este framework se sustituye por el framework social, que es
compatible con una interfaz de usuario para generar tweets y apoyo para la creacin de
URL para acceder al servicio de Twitter.
UIKit Framework: Proporciona la infraestructura para el uso de grficos, aplicaciones
basadas en eventos en iOS. Todas las aplicaciones iOS utiliza este framework para
implementar las funciones bsicas siguientes:
Gestin de aplicaciones

Gestin de interfaz de usuario, incluyendo soporte para guiones grficos y archivos

nib

Grficos y ventanas, incluyendo soporte para mltiples pantallas

Multitarea apoyo

Soporte de impresin, consulte "Impresin"

Apoyo a la personalizacin de apariencia de los controles estndar de UIKit (iOS 5

y versiones posteriores)

Apoyo a la implementacin de controladores de vista que incorporan contenido de

otros controladores de vista (iOS 5 y posteriores)

Soporte para el manejo y eventos de movimiento basados en el tacto

Los objetos que presentan las vistas del sistema y controles estndar

Soporte para el texto y el contenido web

Cortar, copiar y pegar

Soporte para la animacin del contenido de la interfaz de usuario

Integracin con otras aplicaciones en el sistema a travs de esquemas de URL e

interfaces

Compatibilidad de accesibilidad para usuarios con discapacidad

Soporte para el servicio de notificacin push de Apple, consulte "Apple Push

Notification Service"

28

Programacin local notificacin y entrega; ver "Notificaciones locales"

Creacin de PDF

Soporte para el uso de vistas personalizadas que se comportan como el teclado del
sistema

Apoyo a la creacin de vistas personalizadas de texto que interactan con el

teclado del sistema

Soporte para compartir contenido a travs de correo electrnico, Twitter, Facebook

y otros servicios.

Adems de proporcionar el cdigo fundamental para la construccin de su aplicacin,

UIKit tambin incorpora soporte para algunas funciones especficas de los dispositivos,
tales como:

Datos del acelermetro

Cmara incorporada (si existe)

Biblioteca de fotos del usuario

Nombre del dispositivo e informacin del modelo

Estado de la batera

Informacin de proximidad de los sensores

Remote-control de los auriculares conectados

29

XCODE
Xcode es el entorno de programacin para Apple tanto para dispositivos mviles como
para Mac. Para crear una aplicacin en iOS, necesitaramos Xcode 4.3 o posterior. Xcode
debe instalarse para su ejecucin en un entorno Mac, al instalar Xcode en el Mac, se
consigue el SDK de iOS, que incluye las interfaces de programacin de la plataforma iOS.

La ventana principal (Workspace Window) de Xcode tiene el siguiente aspecto:

Fuente:
http://developer.apple.es

30

Ventana de navegacin de proyecto. rea de edicin.

Contiene todos los recursos delEn esta rea manejamos los datos del proyecto,
proyecto.
incluyendo el cdigo fuente, listas de propiedades
(plists), modelos de datos bsicos, y la interfaz de
usuario.

rea de depuracin de cdigo (debug).

Esta rea se visualiza cuando al ejecutar el cdigo fuente hay un error o cuando se
incluye un punto de control o breakpoint.

31

Edicin y visualizacin de tipos de datos

Xcode incluye editores para muchos tipos de datos como:

Cdigo fuente
Proyectos y configuraciones
Archivos de propiedades
Archivos .rtf
Modelos del Core Data
Modelos de mapeado de Core Data
Archivos de interfaz de usuario (User interface (nib))
Archivos de script de Apple
Archivos de diccionario de script

Adems Xcode tiene visualizadores para archivos de grficos, vdeos y otras

variedades.
Para abrir un visualizador slo hay que seleccionar el archivo en cuestin y si no hubiese
editor Xcode le ensea el Finder de MAC para buscar uno.
Xcode tiene un editor de Hexadecimal y un editor de ficheros de texto .rtf.
Escribir, editar y comprobar cdigo fuente

El editor de cdigo fuente tiene variedad de caractersticas para ayudar a desarrollar

programas. En el rea de edicin a travs del editor de cdigo se puede escribir y editar
cdigo, activar o desactivar puntos de control breakpoints, o controlar la ejecucin del
programa mientras se hace depuracin Debug

32

Editar la configuracin

Al hacer clic en el icono del proyecto en el navegador de proyectos, el editor/configurador

de proyectos aparece a la derecha, que muestra informacin del proyecto y de destino.
La Figura muestra algunos de los datos de destino en el editor de proyectos.
Se puede seleccionar la visualizacin de configuracin bsica, o por el contrario todos los
elementos de configuracin.
Si se selecciona
el botn Levels se pueden visualizar todos los niveles y
configuraciones posibles.
Edicin de valores y claves

En el rea de edicin se pueden modificar, aadir o crear propiedades de los objetos del
proyecto.

Diseo grfico del modelo de objetos

Si al crear un nuevo proyecto seleccionamos Use Core Data indicamos al proyecto que
vamos a utilizar el framework Core Data, Xcode a travs del editor de Data Model
nos permite disear mediante entorno grfico las propiedades y los objetos en el modelo
vista controlador. El manejador del modelo de objetos nos representa un esquema que
describe los objetos de nuestro modelo incluyendo las relaciones entre ellos.
Definir reglas de trasformacin en la migracin delos datos del modelo

Si se quiere cambiar de modelo de Datos Bsicos es necesario mapear el modelo nuevo

con el antiguo a efectos de la migracin. Xcode nos da una herramienta grfica para
poder hacerlo.
33

El mapeo del modelo de objetos describe las transformaciones necesarias para convertir
los datos descritos por un modelo de datos a otro modelo con un esquema diferente.

Diseo grfico del interfaz de usuario

En las primeras versiones de Xcode Apple inclua una herramienta llamada Interface
Buider para el diseo grfico de la interfaz de usuario. Actualmente esa herramienta est
integrada junto con el resto de editores en la ventana de trabajo Workspace window de
Xcode.
Los ficheros que contienen las definiciones y objetos de la interfaz tiene extensin .nib

34

Visualizar archivos en paneles separados

Se pueden visualizar dos o ms vistas diferentes de un archivo, dos o ms archivos

diferentes, o dos versiones diferentes del mismo archivo en paneles adyacentes.
Bsqueda de informacin para editar o visualizar

Xcode ofrece dos maneras de navegar a travs de su proyecto: barras de navegacin y la

barras de salto Jump bar. Muchos de las barras de navegacin incluyen campos de
texto para buscar a travs del proyecto o el filtrado de los elementos en el navegador,
algunos incluyen botones para limitar el alcance de los elementos mostrados. La barra de
salto aparecer en la parte superior del panel del editor y proporciona una forma
alternativa de navegar por los archivos y smbolos en el proyecto. Debido a que la barra
de salto siempre est disponible, se puede utilizar para buscar elementos en el proyecto,
incluso cuando el rea del navegador se cierra.
Visualizacin de los archivos del proyecto o del rea de trabajo Workspace

El navegador de proyectos permite visualizar proyectos, grupos, carpetas y archivos.

El proyecto o proyectos son el nivel ms alto de la jerarqua en el navegador de
proyectos. A travs del tringulo del proyecto se accede a la informacin para ver los
grupos, carpetas y archivos en el proyecto. Seleccionando el proyecto se visualiza el
editor de proyectos, donde se puede ver y editar la configuracin del proyecto.
Un grupo aparece en el navegador de proyectos como un icono de carpeta amarilla. El
grupo no representa una carpeta en el disco, sino que es una forma de organizar los
ficheros del usuario.
Una carpeta es una referencia a una carpeta en el disco y aparece en el navegador de
proyectos como un icono de la carpeta azul. Es importante sealar, sin embargo, que los
archivos que aparecen en un icono de la carpeta en el navegador de proyectos no son
parte de su proyecto, a menos que los haya aadido al proyecto explcitamente (en cuyo
caso aparece directamente en el proyecto o en un grupo, as como en la carpeta).
Un archivo en el navegador de proyectos es una referencia a un archivo en disco.
Navegacin a travs de los smbolos en un proyecto

Smbolo de una clase y sus miembros

Smbolo de un elemento de un framework externo
Smbolo de un miembro de una clase como un mtodo una propiedad o una
variable

35

Bsqueda de texto

Xcode nos permite realizar bsqueda de texto libre en los recursos del proyecto.
Visualizacin de alertas

Xcode maneja un listado de errores y advertencias en el proyecto que permite realizar la

depuracin del cdigo y otros errores que sean detectados en los objets y recursos del
proyecto.
Manejo de puntos de control

Xcode permite incluir puntos de control Breakpoints

que permiten depurar el cdigo fuente y visualizar valores
dentro de la ejecucin de los programas que realizaremos.
Control de los hilos y la pila de ejecucin

Utilizando los puntos de control se puede ver el estado de

los hilos de ejecucin y de la pila.

36

Grabacin de logs de usuario

Xcode graba determinadas acciones realizadas por el usuario como la creacin o anlisis
de errores mediante debug, esto permite tener un histrico de dichas tareas.

Informacin complementaria en el editor

Hay varios tipos de informacin que se encuentra en el rea de utilidades de la ventana

del rea de trabajo o workspace window, incluida la ayuda rpida Quick help, el
inspector de archivo file inspector, el inspector del Interface Builder, y las bibliotecas las
plantillas, fragmentos de cdigo, objetos de Interface Builder, y archivos multimedia. Ver
ejemplo de inspector en la figura.

37

Obtener plantillas, archivos y objetos del Interface Builder

Las bibliotecas que se visualizan en la parte inferior del rea de servicios pblicos (Ver
figura ) proporcionan plantillas de archivos y fragmentos de cdigo que se pueden
arrastrar en el proyecto o espacio de trabajo, elementos de interfaz de usuario que se
pueden utilizar en Interface Builder, y archivos multimedia (grficos, archivos de sonido,
etc) que se utilizan en el espacio de trabajo.

38

La Ventana del Organizador

Xcode tiene dos ventanas principales. Hemos visto la ventana de trabajo (ver figura
siguiente), que se utiliza para la edicin, depuracin, y el diseo de la interfaz.

La otra ventana principal, llamada la Ventana de Organizador, muestra documentacin,

control de cdigo fuente, la organizacin del proyecto, y para iOS, el acceso a los
dispositivos mviles. Ver figura siguiente.

Visualizar y marcar documentos del proyecto

Para ver la documentacin, abrir la Ventana de Organizador, haga clic en el botn

Documentacin en la barra de herramientas y haga clic en el botn Examinar en la parte
superior del panel de navegacin.

39

Creacin de un nuevo proyecto

para poder activar un proyecto en Xcode tendremos que realizar los siguientes pasos
1.- Seleccionar Archivo> Nuevo> Nuevo proyecto.

2.- Seleccionar la plantilla o tipo de proyecto para su iOS o producto OS X y hacer clic en
Siguiente.

40

3.- Introducir el nombre del programa y otros detalles del proyecto y hacer clic en
Siguiente.

4.- Especificar la ubicacin del proyecto en el sistema de archivos y hacer clic en Guardar

41

Ms caractersticas de Xcode

Interfaz en ventana nica: la mayor parte de los flujos de trabajo del desarrollo se realizan
en una nica ventana.
Interfaz para el diseo de objetos grficos: con el editor de interfaz de usuario de Xcode,
llamado Interface Builder, se disean la mayora de los detalles de la interfaz de usuario
de una aplicacin, tales como el diseo de los controles, y la conexin con la lgica de
negocio y los datos que maneja la aplicacin. Interface Builder trabaja en estrecha
colaboracin con otros editores, como el editor de cdigo fuente, que conecta el diseo
con el comportamiento de la aplicacin.
Edicin asistida: Cuando se necesita trabajar en diferentes aspectos de un mismo
componente, como el diseo de la interfaz de usuario y la implementacin de la
funcionalidad se pueden utilizar varios editores que abren el contenido necesario cuando
lo necesita. Por ejemplo, cuando se trabaja en un archivo de implementacin en el editor
principal, Xcode puede abrir el archivo de cabecera correspondiente en un panel de
edicin secundaria.
Correccin e Identificacin automtica de errores. Xcode comprueba el cdigo fuente
mientras este se est escribiendo. Cuando Xcode descubre un error, el editor de cdigo
fuente lo destaca. A continuacin, el programador recibe informacin del error para que
pueda subsanarlo.
Control del cdigo: se puede proteger los archivos del proyecto en los repositorios Git
Subversion y el cdigo fuente.
Espacios de trabajo (Workspaces)

Xcode permite la creacin de un espacio de trabajo (Workspace) para que varios

proyectos compartan el mismo directorio de construccin (Build directory) Los beneficios
que se obtienen son los siguientes:
Un proyecto puede utilizar los recursos y productos de otro, mientras se est realizando.
Si un proyecto depende de los productos de otro en el mismo espacio de trabajo, Xcode
puede detectarlo y construir automticamente los proyectos en la secuencia correcta.
Debido a que todos los archivos de un proyecto son visibles para todos los otros
proyectos en el rea de trabajo, no es necesario copiar las bibliotecas compartidas en
cada carpeta del proyecto por separado.
La indexacin se realiza a todo el espacio de trabajo, extendiendo el mbito de las
caractersticas de Content-Aware tales como la finalizacin de cdigo.
Debido a que cada proyecto obtiene una identidad individual, un proyecto puede incluirse
en ms de un rea de trabajo o eliminarlo de un rea de trabajo sin afectar al proyecto. El
archivo de rea de trabajo en s slo contiene punteros a los proyectos y otros archivos
que incluye el espacio de trabajo, ms una cantidad mnima de datos tales como los
planes almacenados en el espacio de trabajo. Los punteros a los archivos de cdigo
fuente, bibliotecas, incluidas las configuraciones de generacin y otros datos se
almacenan en los archivos del proyecto.

42

Actualizacin de proyectos

Xcode evala si un proyecto tiene actualizada todos sus libreras y productos, si detecta
que no y ayuda al usuario a actualizarlo. Esa caracterstica permite que el proyecto tenga
las ltimas actualizaciones del SDK las mejores prcticas.
ARC (automatic reference counting)
Xcode en versin 4.2 o posterior incluye ARC que sirve para que los objetos de ObjectiveC gestionen la memoria de manera ms eficiente. En primer lugar, Xcode revisa el
proyecto para determinar si hay elementos que no se pueden convertir (y que por lo tanto
debe cambiar manualmente). Entonces, Xcode vuelve a escribir su cdigo fuente para
utilizar ARC. (Para aadir ARC a un nuevo proyecto, consultar "Opciones de Seleccionar
al crear un nuevo proyecto.")

43

Objective-C y Patrn MVC

El lenguaje Objective-C
Introduccin
Objective-C es una extensin del lenguaje de programacin C que ha sido realizada para
ser
un
lenguaje
de
programacin
orientado
a
objetos.
(ver
http://es.wikipedia.org/wiki/Lenguajes_Orientados_a_Objetos).
Originalmente fue creado por Brad Cox y la corporacin StepStone en 1980. En 1988 fue
adoptado como lenguaje de programacin de NEXTSTEP y en 1992 fue liberado bajo
licencia GPL para el compilador GCC. Actualmente se usa como lenguaje principal de
programacin en Mac OS X, iOS y GNUstep.
Objective-C es una capa que est por encima de C, por lo que un compilador de
Objective-C debera compilar sin problema un programa escrito en C puro.
Al ser Objective-C un lenguaje extendido de C
sintaxis de C han sido heredadas por l como:

muchas de las caractersticas de la

Los tipos de datos fundamentales

Conversiones entre tipos
Los mbitos de las variables
Las funciones y su sintaxis
Las directivas del preprocesador

Lenguaje dinmico
La gran diferencia con el resto de lenguajes de programacin es que ste es un lenguaje
dinmico, es decir muchas decisiones sobre el programa se toman en tiempo de
ejecucin. De esta forma las herramientas de desarrollo tienen acceso a todo el runtime
del programa y el programador tiene un control ms extenso sobre dicho programa y sus
objetos.
Los dinamismos implementados en objective-C son los siguientes:
Introspeccin
Es la caracterstica de algunos lenguajes de observar y manipular como si fueran datos el
estado de su ejecucin. De esa forma en tiempo de ejecucin se puede preguntas a un
objeto de que clase es o que protocolos implementa.
Enlace dinmico
Se enlazan los mensajes con las clases de los objetos que responden a ese mensaje de
manera dinmica.

44

Memoria dinmica
La memoria necesaria para la creacin de objetos se realiza en tiempo de ejecucin, de
esa forma se evita el desbordamiento de la pila.
Tipos dinmicos
Se deja al runtime del programa decidir de que tipo es cierta variable.
Carga dinmica
Consiste en cargar un conjunto bsicos de clases al ser ejecutado e ir cargando el resto
segn se vayan utilizando en la ejecucin.
Asociaciones: la conexin y la agregacin
Una asociacin es un tipo de relacin entre dos objetos. Esta relacin puede ser:
Extrnseca: asociaciones en donde los objetos no se dominan entre s, peer-to-peer
Intrnseca: uno de los objetos domina sobe el otro:
Composicin: la vida de un objeto depende y est asociada a la de su contenedor o
propietario
Agregacin: la vida de un objeto no est limitada a la de su contenedor
El Interface Builder permite guardar en ficheros .nib los grafos de relacin entre los
objetos, de esta forma se cargarn en memoria en tiempo de ejecucin. EL grafo tambin
guarda las conexiones entre los objetos.
Conexiones :

Outlet: punteros de un objeto hacia otro

Target-Action: se crean relaciones que permiten el envo de mensajes desde un
Action hacia un Target
Bindings: permite sincronizar dos objetos. Se usa en Cocoa Bindings para
sincronizar objetos en el modelo Vista-controlador.

Componentes y Frameworks
La mayora de los lenguajes de programacin modernos se apoyan en una gran cantidad
de libreras realizadas para ahorrar tiempo a la programacin. No obstante el mayor
tiempo que pasa un programador en el aprendizaje del lenguaje es aprendiendo el
conjunto de clases y funcionalidades desarrolladas en esas libreras. Dichas libreras se
pueden desarrollar de estas dos formas:

Libreras de componentes: conjunto de clases de uso comn que se desarrollan

para extender la funcionalidad del lenguaje.
Frameworks: son un conjunto de clases desarrolladas pero que cuentan con u
modelo o patrones de diseo que el programador debe seguir para construir las
aplicaciones. El framework suele llevar asociado un esqueleto de aplicacin que el
programador va rellenando y extendiendo.
45

La diferencia ms significativa entre estos dos modelos es que la librera deja mucha
libertad al programador que es quien establece las relaciones entre los objetos y clases
de la aplicacin. Por otra parte los frameworks al ser ms estructurados permiten que un
nuevo programador entienda el cdigo mucho ms rpido ya que estar escrito de una
forma ms ordenada.

Clases
Una clase est formada por las definiciones de las propiedades y comportamiento de un
tipo de objeto concreto. (Un objeto es un agregado de datos y de mtodos que permiten
manipular dichos datos).
Las clases en Objective-C estn construidas por la interfaz que indica la estructura de un
objeto y la implementacin que contiene el comportamiento de los mtodos de dicho
objeto.
La interfaz de una clase est contenida en un fichero de extensin .h el cdigo fuente de
este fichero debe estar abierto para que o utilicen los programadores.
La implementacin de una clase est contenida en un fichero de extensin .m, este
fichero puede entregarse compilado a los programadores.
Se recomienda poner una implementacin y una interfaz en cada fichero, no obstante se
pueden incorporar varias implementaciones en un solo fichero. Tambin como en C++ un
fichero de implementacin puede incorporar la interfaz y la implementacin a la vez.
La interfaz

Normalmente la interfaz comienza con las clases que se importan o que hace referencia
#import.
En este caso NSObject , la clase se denomina fraction y hereda de NSObjetc.
X e Y son los atributos que al no poner de que tipo (@protected, @public o @private)
toma por defecto @protected. Los mtodos declarados tienen la siguiente estructura:
alcance (Tipo devuelto) nombre del mtodo : (parmetro y tipo) nombre del parmetro.
Hay que tener en cuenta que
en Objective-C las variables de
instancia no pueden ser
objetos sino punteros a
objetos, adems no pueden
ser compartidas entre clases,
para
tener
una
variable
compartida
habra
que
declararla una esttica o global
en el mdulo. Para tener una
variable
esttica
pblica
deberamos definirla en el
mdulo
y
hacer
una
declaracin extern
en
la
46

interfaz.
La implementacin

En la implementacin se tiene que importar la interfaz y se comienza con

@implementation nombre de la clase.
Si una clase no tiene mtodos entonces se puede obviar su implementacin.
No se pueden declarar ms variables de instancia pero s se pueden declarar mtodos
que seran privados de la propia clase.
El mtodo init , que es el constructor de la clase retorna self , el mtodo dealloc sera el
destructor.
En este caso no se declaran al ser todos mtodos de instancia .

47

Objetos
Los objetos se crean en la memoria dinmica por lo que slo se pueden referenciar a
travs de punteros.
Es decir punto* p;
Por lo tanto las funciones no se pasan por valor si no por referencia, si indicamos que p es
un objeto de la clase Punto significa que es un puntero a dicha clase.
Instanciar Objetos

Los objetos se instancian utilizando los mtodos init y alloc.

Punto* p= (Punto alloc);
P = (p init);
El mtodo alloc reserva la memoria dinmica y resetea las variables de instancia del
objeto. Init inicializa las variables de instancia del objeto. Las llamadas se pueden realizar
en una sola lnea:
Punto* p= ([punto alloc] init);
Aunque las dos operaciones a la vez se pueden sustituir por New.
Punto* p= (punto new);
Los objetos una vez usados deben ser descargados o eliminados de la memoria.
Aunque Cocoa tiene un sistema propio de liberacin de objetos debemos conocer el
mtodo release que sirve para liberar objetos. [p release];
Tipos estticos y dinmicos

La referencia a objetos en Objective-C se realiza mediante punteros. Para poder

referenciar a un objeto mediante un tipo esttico (conocido en tiempo de ejecucin) se
realiza mediante un puntero, por lo que los objetos estticos que apuntan a objetos se les
llama punteros a objetos estticos.
Un ejemplo sera: Punto* ps= (Punto New)
Los tipos dinmicos son tipos no conocidos e tiempo de compilacin, Objective-C permite
el uso de objetos dinmicos pero slo con punteros a objetos. EL runtime s que conoce el
tipo del objeto y sera un puntero a un objeto dinmico mediante el tipo id.
Id pd = (Punto new) como podemos ver id no lleva asterisco pues l mismo es de tipo
puntero.

48

De esta forma podemos utilizar los objetos en Objective-C, la diferencia es que cuando
utilicemos puntero esttico a objetos el compilador comprueba que existe el objeto
mientras que si usamos un puntero a n objeto esttico es el runtime quien lo comprueba,
por lo que si no existiese se producira una excepcin.
La ventaja de trabajar con punteros a 0bjetos dinmicos es que se podr trabajar con
objetos polimrficos.
Objective-C adems del identificador Null tiene las palabras reservadas nil (puntero a
objeto sin inicializar) y Nill (puntero a clase o metaclase sin inicializar)
Variables de instancia

Los objetos pueden contener variables, que pueden ser variables simples u objetos de
cualquier clase. Las variables de instancia son diferentes en cada objeto, por lo que si
tenemos dos objetos de la clase punto y accedemos a la variable x, cada uno devolver
un valor diferente.
Las variables de instancia deben declararse en la interfaz, por lo que no se pueden aadir
variables de instancia en la implementacin. Para acceder a una variable de instancia hay
que aadir la flecha, ejemplo
Punto* ps = [punto New];
Ps x = 3;
Las variables de instancia son @protected es decir protegidas, por lo que no son
accesibles fuera del objeto. Para acceder a una variable dentro de un mtodo se utilizar
self o no se pondr nada, ejemplo:
X=3
Self x = 3
El operador flecha slo se puede usar con punteros a objetos estticos, si fueran
dinmicos slo se podran utilizar a travs de mtodos setter y getter.
Este cdigo dara error:
Id pd = [punto New];
Pd x= 3; error de compilacin
[pd setx: 3]; esto sera correcto

Los mtodos
Los mtodos son funcionalidades que se asocian a un objeto, estos pueden utilizarse para
49

cambiar las propiedades del objeto o tambin para que el objeto realice determinadas
acciones. En Objective-C para ejecutar un mtodo se le enva un mensaje al objeto. El
mtodo a ejecutar depender del mensaje y se realizar siempre en tiempo e ejecucin.
Declaracin de un mtodo

Las principales partes definidas en la declaracin de un mtodo son las siguientes:

Nivel del mtodo: indica quien recibe el mensaje, si es (+) es la clase quien lo recibe y si
es (-) es la instancia de la clase.
Tipo de retorno: indica el tipo de variable que retorna el mtodo. En el caso de que no se
devuelva nada se indicar usando void, normalmente por defecto se devuelve id. Ken
Objective-C se deben de poner los tipos de retorno y de los parmetros entre parntesis.
Nombre del mtodo: es obligatorio y junto a los nombres de los mtodos deberan
identificar de forma nica al objeto.
Parmetro del objeto: se utiliza una notacin infija heredada de Smaltalk.

(void) setX: (NSInteger) paramX

Un mtodo tiene tantos parmetros como veces escribamos el smbolo de dos puntos.
Despus de los dos puntos debemos indicar, obligatoriamente, el tipo del parmetro (entre
parntesis) y un nombre para ese parmetro. Si el mtodo no tuviese parmetros no
debemos escribir ningn smbolo de :.
Pueden existir mtodos como el init del ejemplo que o reciben ningn parmetro.
Implementacin de un mtodo

La funcionalidad de un mtodo aparece escrita en el cuerpo del mtodo en la

implementacin. El mtodo se comienza a escribir de la misma forma que en la interfaz,
pero al final se pone la llave { para poner comenzar a escribir el cdigo del mtodo,
ejemplo:
(void) setX: (NSInteger) paramX Y:(NSInteger) paramY
{
X = paramX;
Y = paramY;
}
La implementacin de una case puede tener mtodos privados que o se declaran en la
interfaz. En este caso debern aparecer antes que los pblicos en la implementacin. Los
mtodos privados permiten una mayor encapsulacin.
Es recomendable que los mtodos setter y getter tengan el mismo nombre que la variable
de instancia a la que accedemos, en el ejemplo x .
50

Ejecucin de un mtodo

Si ejecutamos un mtodo deber existir el receptor que ser una clase o un a instancia de
una clase y el nombre del mtodo.
Para ejecutarlo se incluye el nombre del objeto receptor y el mtodo entre corchetes: [p
setX:4 Y:3];
Si el mtodo tiene parmetros se metern separados por espacios.En el caso de que se
llame al mtodo con n nmero variable de parmetros, estos se separan con comas.
Ejemplo de interfaz: + (punto*) suma: NSInteger n, ..; los puntos indican que ah van un
nmero indeterminado de parmetros. La llamada sera: punto* p3= [punto suma: 2, 1,
p1];
Una llamada a un mtodo es una expresin por lo que si el mtodo devuelve un valor ste
se puede asignar a una variable. Ejemplo:
NSInteger ancho = [p x];
Las llamadas a mtodos se pueden anidar. Ejemplo: [p2 setX: [p x] ];

Encapsulacin

Para ocultar las variables de instancia de un objeto se deben usar los modificadores de
acceso en la declaracin de estas, estos indicadores son:

@protected: la variable es vivible solo dentro del objeto pero tambin es visible
dentro de una clase derivada.
@public: variable accesible desde cualquier parte del programa.
@private: la variable es visible dentro del objeto nicamente.

Si no se indicaran las variables sera @protected por defecto.

Por otra parte los mtodos slo pueden ser de dos clases, o pblicos en cuyo caso se
declara en la interfaz, o privados, en cuyo caso se han declarado en la implementacin y
no son visibles afuera de la clase.

Estructuras de datos usando clases

Se pueden crear clases que no derivan de otras, pero en este caso no tendrn las
propiedades heredadas de las clases ms comunes como NSObject. Este tipo de clases
se utilizan muchas veces para crear estructuras de datos. Ejemplo:
@interface Fecha {
@public
51

NsiInteger dia;
NSInteger mes;
NSIntegar anyo;
}
@end
Como la clase carece de mtodos no hace falta implementarla. Como no se realiza la
implementacin no podremos utilizar el mtodo new para crear el objeto, as que lo
crearemos de esta forma: Fecha* f= (Fecha*) malloc (sizeof (Fecha)); f-->x = 3; free(d);

Cadenas de caracteres
Se utilizan los tipo de caracteres Char*para cadenas acabadas en cero y para objeto tipo
strings se usan:

NSString para cadenas cuyo contenido no cambia en tiempo de ejecucin

NSMuteString para cadenas cuyo contenido cambia en tiempo de ejecucin.

La clase NSMutableString es derivada de NSString. El contenido de las cadenas se

almacena en Unicode aunque se pueden convertir en otros formatos a travs de mtodos
Crear cadenas

La manera ms sencilla de crear objetos cadena sera:

NSString* mensaje = @Hola Mundo;
Concatenacin de cadenas:
char* msg = @Este manual es para programadores
@que quieran comenzar a programar en mviles;
Se pueden formatear las cadenas a travs del mtodo initWithFormat:format, del la clase
NSString.
Imprimir cadenas formateadas

Se puede imprimir cadenas a partir de la funcin:

void NSLog (NSString* format,......);
NSLog(@"El cliente %s pide %d unidades del producto %s" ,"Pedro",2,"Zapatos
blancos");
Esta funcin da como resultado una salida de esta forma:
2008-08-01 10:02:11.124 [543:813] El cliente Pedro pide 2 unidades del producto Zapatos
blancos

52

Tipos de Datos
Hay varios tamaos para los tipos de datos de Objective-C. Dependiendo del convenio
elegido el tamao ser distinto. ILP32 para 32 bits y ILP64 para 64 bits.

Herencia
La herencia es un concepto asociado con la <programacin Orientada a Objetos,
bsicamente se pueden declarar clases que heredan de otra funcionalidad y datos. En
algunos casos la clase hija modifica o aade alguna funcionalidad de la que tiene la
madre.
Ejemplo de herencia:
/* Punto.h */
#import <Foundation/Foundation.h>
@interface Punto : NSObject {
NSInteger x;
NSInteger y;
}
- init;
+ (NSString*)sistema;
- (NSInteger)x;
- (void)setX:(NSInteger)paramX;
- (void)setX:(NSInteger)paramX
incrementando:(NSInteger)paramSumar;
- (NSInteger)y;
- (void)setY:(NSInteger)paramY;
53

- (void)setY:(NSInteger)paramY
incrementando:(NSInteger)paramSumar;
- (void)setX:(NSInteger)paramX Y:(NSInteger)paramY;
+ (Punto*)suma:(Punto*)p1 :(Punto*)p2;
+ (Punto*)suma:(NSInteger) n ,...;
- (void)dealloc;
@end
Indicamos que la clase Punto hereda de la clase NSObject (base de las clases en Cocoa
Touch).La clase base solo se indica en el fichero de interfaz.
Todas las clases en Objective-C derivan de la clase raz. EN el caso de Cocoa Touch es
NSObject.
Objective-C nos permite redefinir (override) mtodos en la clase derivada volviendo a
definir un mtodo con el mismo prototipo. Para redefinir un mtodo heredado no hace falta
declararlo en la interfaz de la clase derivada (aunque es conveniente por claridad), basta
con declararlo en la implementacin. Esta es una diferencia con C++ donde para poder
redefinir un mtodo es necesario declararlo tanto en la interfaz como en la
implementacin.
En Objective-C no se pueden redefinir las variables de instancia, es decir, no podemos
volver a declarar una variable de instancia con el mismo nombre (aunque tenga distinto
tipo) en la clase derivada .

Los receptores especiales Self y Super

Un receptor es un objeto al cual se enva un mensaje. Cuando se enva un mensaje a un
receptor, primero se busca el mtodo en los mtodos de instancia del objeto, y luego en
los mtodos de instancia de las clases base hasta llegar a la raz. Objective-C tiene dos
receptores especiales llamados self y super que vamos a comentar en este apartado.
El receptor self no es ms que un puntero a objeto esttico tipificado con la clase sobre la
que se ejecuta el mtodo (el equivalente a this en C++ o Java). En consecuencia, el
receptor self slo tiene sentido utilizarlo dentro de un mtodo.
El receptor super proporciona una forma de saltarse los mtodos redefinidos e ir
directamente al mtodo de la clase base, es decir, evita que se busque el mtodo en la
clase donde nos encontramos, y comienza la bsqueda del mtodo en la clase base.
Una diferencia importante entre self y super es que super se resuelve en tiempo de
compilacin sin embargo self se resuelve en tiempo de ejecucin

54

Objetos de Clases
La definicin de una clase contiene varios tipos de informacin
El nombre de la clase y de su superclase,
los nombres de los mtodos,
su retorno,
sus parmetros, y
su implementacin.
Toda esta informacin es recopilada por el compilador y guardada en estructuras de datos
que son usadas por el runtime de Objective-C.
El compilador crea un objeto clase por cada clase que tenga el programa, donde en
tiempo de ejecucin se almacena informacin sobre la clase. Estos objetos son
inicializados por el runtime antes de que el programa empiece su ejecucin, con lo que
estn siempre disponibles.
Para acceder al objeto clase disponemos de los mtodos de clase y de instancia:
+ (Class)class
(Class)class
El mtodo de clase se ejecuta sobre el nombre de la clase, y se limita a devolver self, con
lo que para obtener el objeto clase de Punto podemos hacer:
id c = [Punto class];
El mtodo de instancia se puede ejecutar tanto sobre un objeto de instancia, como sobre
un objeto clase. Por ejemplo, para obtener el objeto clase de un Punto podemos hacer:
Punto* p = [Punto new];
id c = [p class];
Pero tambin podemos ejecutar el mtodo class directamente sobre el objeto clase:
id c2 = [c class];
Donde se cumple que c==c2. Esto se debe a que al recibir el mensaje class el objeto
clase, primero busca su implementacin en sus mtodos (los mtodos de clase), y luego
en los mtodos de la clase base (los mtodos de instancia de la clase raz). Como el
mtodo de clase class es un mtodo del objeto clase, se ejecuta y devuelve self.
Las clases son la forma ms importante de asociar mtodos a objetos, pero no la nica.
En los siguientes apartados veremos otras formas de declarar mtodos y asocirselos a
objetos:
1.- Las categoras, que nos permiten dividir una clase en partes, o bien extender su
funcionalidad,
2.- los protocolos, que nos permiten declarar mtodos que pueden ser implementados por
varias clases
55

3.- las extensiones, que nos permiten aadir mtodos a una clase para uso exclusivo del
framework al que pertenece la clase.

Categoras
Las categoras nos permiten modificar una clase ya existente aunque no dispongamos de
su cdigo fuente. La diferencia que hay entre las herencia y la categorizacin es que la
herencia slo nos permite crear nuevas hojas en la jerarqua de clases, mientras que la
categorizacin nos permite modificar nodos interiores de la jerarqua de clases.
Al igual que la herencia tiene varias finalidades (reutilizacin, clasificacin, ...), la
categorizacin tambin tiene al menos cuatro finalidades:
1. Las categoras se pueden usar para implementar una clase en distintos ficheros de
cdigo fuente. Esto nos permite particionar una clase en grupos de mtodos relacionados,
lo cual por ejemplo, reduce el tiempo de compilacin de una clase grande al slo compilar
el fichero de la categora modificada. Dividir la clase en varias categoras tambin podra
permitir repartir el trabajo de implementacin de la clase entre varios programadores.
2. Las categoras permiten aadir a las clases de libreras de otros fabricantes mtodos
que nos hubiese resultado especialmente til que tuviesen, pero que le fabricante de la
librera no meti. Por ejemplo, con las categoras podemos aadir mtodos a clases de la
librera Cocoa sin necesidad de crear una derivada. Los mtodos aadidos a la clase son
automticamente heredados por las subclases, y en tiempo de ejecucin son
indistinguibles de los mtodos de la clase. Es muy tpico crear categoras que aaden
nuevos mtodos (p.e. mtodos de bsqueda) a las clases que implementan colecciones
como NSArray.
3. Otra ventaja de las categoras es que permiten diferenciar entre un API pblica y un API
para el framework. De esta forma podemos crear dos versiones de nuestra clase: una con
un conjunto de mtodos pblicos que todo el mundo puede usar, y otra con mtodos
aadidos destinados a uso exclusivo para nuestro framework.
4. Una cuarta finalidad de las categoras es declarar protocolos informales.

Protocolos
La interfaz de una clase o categora declara mtodos asociados con una clase en
particular. Por el contrario, los protocolos declaran mtodos no asociados con ninguna
clase, sino que cualquier clase o conjunto de clases pueden implementar. Segn esto, los
protocolos nos permiten indicar que un conjunto de clases no relacionadas comparten un
conjunto de mtodos comunes. Por ejemplo, un conjunto de clases que representen
objetos de interfaz grfica podran compartir los mtodos:
- (void)mouseDown:(NSEvent*)theEvent;
- (void)mouseDragged:(NSEvent*)theEvent;
- (void)mouseUp:(NSEvent*)theEvent;
Se dice que una clase cumple, adopta o implementa un protocolo si dispone de mtodos
56

que reciben los mensajes del protocolo. De esta forma los protocolos nos permiten
separar la jerarqua de clases del hecho de compartir funcionalidad comn. El objetivo es
que los objetos se pueden agrupar, no slo por su jerarqua, sino por los protocolos que
adoptan.

Extensiones
Anteriormente indicamos que los mtodos en Objective-C slo pueden ser de dos tipos:
Pblicos cuando se declaran en la interfaz de la clase (y se implementan en su
implementacin), y privados cuando slo aparecen en la implementacin de la clase. Los
mtodos privados slo deben ser llamados desde la clase donde se sitan. En el apartado
5 del Tema 3 tambin indicamos que los mtodos privados de una clase deban
declararse en el fichero de implementacin siempre antes que los mtodos pblicos, o en
caso contrario obtendramos un warning al llamar al mtodo privado desde el pblico. Las
extensiones (introducidas en Objective-C 2.0) nos permiten implementar mtodos
privados ignorando esta regla.
Las extensiones son parecidas a las categoras pero con tres diferencias:
1. Son "annimas", es decir, no se las asigna un nombre. Una clase puede tener varias
extensiones, pero todas ellas sern annimas.
2. Se aconseja declarar la interfaz de la extensin en el fichero de implementacin de la
clase a la que extiende, en vez de en un fichero de interfaz como ocurre con las
categoras.
3. Sus mtodos se implementan en la implementacin de la clase a la que extienden, en
vez de usar una seccin @implementation distinta como ocurre con las categoras.

57

Modelo-Vista-Controlador
Los programadores que desarrollaron Cocoa Touch usaron un concepto conocido como
Modelo-Vista-Controlador (MVC) como base para el codigo de las aplicaciones de iPhone
e iPad.
Divide los objetos o partes del programa en tres partes independientes pero conectadas.
Esta es la idea basica:
Modelo: contiene los datos y las clases que hacen que la aplicacion funcione. Es la
parte del programa donde se encuentran las secciones de codigo que resuelve los
requerimientos del programa. Este codigo tambien puede contener objetos que
representen elementos que podrias tener en tu aplicacion (por ejemplo nombres en
bases de datos, citas en tu calendario).
Vista: controladores subordinados e interfaces genricas re utilizables, objetos que
se utilizan para determinados trabajos y los responsables de cmo se ve el modelo
en la pantalla. Esta es la combinacion de todas las pantallas que los usuarios ven
cuando usan tu aplicacion. Son los objetos con los que el usuario interacta:
botones, barras de desplazamiento, controles.
Controlador: El controlador conecta el modelo y la vista controlando lo que el
usuario esta haciendo. Es la espina dorsal de la aplicacion. Nos sirve para
coordinar los botones las pulsaciones del usuario y, si es necesario, el cambio de
una vista por otra, todo en respuesta a los datos, reacciones, entradas etc. del
usuario.

Controlador

Vista

Modelo

La lnea verde significa comunicacin unidireccional, es decir el controlador se conecta al

modelo y le solicita informacin.
El controlador conoce el modelo y puede usar las cabeceras que ofrece el modelo para
comunicarse con l.
El controlador tambin puede comunicarse directamente con la vista

58

Outlet son punteros hacia las vistas para saber a cual estamos preguntando.

Controlador
O
ut
le
t
Vista

Modelo

No se deben comunicar directamente el modelo y la vista

Controlador
t
le
ut
O

Vista

Modelo

"Target action" es la forma de comunicarse entre la vista y el controlador.

Targ
et

Controlador
t io
Ac
n

t
le
ut
O

Vista

Modelo

59

En el controlador hay targets que son activados cuando ocurre alguna accin en el
controlador.
Algunas veces la vista quiere saber que hacer cuando ocurren eventos en ella y necesita
indicrselo al controlador:

Should? Puedo abrir este enlace?

Did? He hecho esto hago scroll?

"Delegation": el controlador realiza y controlas las acciones de la vista de manera

delegada. Slo se permite una delegacin por vista
Las vistas no son propietarias de los datos que pintan ya que:

queremos que sean genricas

necesitamos que sean eficaces (mejor que no manejen muchos datos)

"Data Source": la vista puede preguntar por el dato al controlador, por ejemplo de una lista
de 2.000 canciones dame las siete primeras

Target

Controlador
n
t
le
t io
ut Ac
O

e
at
e
leg
rc
De sou
ta
Da

Modelo

Vista

El controlador interpreta y da formato a la informacin del modelo que maneja la vista

60

"Notification & KVO (Key Value Observing)": el modelo nunca puede

controlador, no obstante necesita a veces comunicar cambios.

"hablar" con el

Esto se realiza mediante Broadcast de los objetos del Modelo y suele pasar el puntero al
objeto que ha cambiado.

Target

Controlador
n
t
t io
le
ut Ac
O

e
at
leg
ce
ur
De
so
ta
Da

Notification
& KVO

Vista

Modelo

Un programa es una combinacin de MVC coordinados.

Para el manejo de la aplicacin y su documentacin es necesario que haya pocas flechas
entre MVC y dentro de los MVC

61

Creacin de Interfaces Grficas

En iOS, se utilizan ventanas y vistas a presentar el contenido de la aplicacin en la
pantalla. Las ventanas no tienen ningn contenido visible pero s proporcionan un
contenedor de base para las vistas de la aplicacin. Las vistas definen una parte de la
ventana que desea llenar con algn contenido. Por ejemplo, se podra tener vistas que
muestran las imgenes, textos, formas, o alguna combinacin estos objetos. Tambin
puede utilizar las vistas para organizar y gestionar otras vistas.
Cada aplicacin tiene al menos una ventana y una vista para la presentacin de su
contenido. UIKit y otros frameworks del sistema proporcionan vistas predefinidas que se
pueden utilizar para presentar contenido. Estos puntos de vista varan desde simples
botones y etiquetas de texto a las vistas ms complejas, como las vistas de tablas. En los
lugares donde las vistas predefinidas no ofrecen lo que se necesita, se pueden definir
vistas personalizadas y gestionar la elaboracin y control de eventos usted mismo.
Las tecnologas que manejan los grficos en IOS son:

Core Graphics (tambin conocida como "Quartz") se encarga de la representacin

nativa 2D vectorial y basado en imgenes.

Core Animation (parte de la estructura del ncleo de "Quartz") proporciona soporte

avanzado para la animacin de puntos de vista y otros contenidos.

Core Image proporciona soporte avanzado para la manipulacin de vdeo e

imgenes fijas.

OpenGL ES y GLKit proporcionar apoyo para el renderizado 2D y 3D acelerados

por hardware usando interfaces.

Core Text ofrece un diseo de texto sofisticado y motor de renderizado.

Imagen de E / S proporciona interfaces para leer y escribir la mayora de formatos

de imagen.

El framework "Assets Library" proporciona acceso a las fotos y los vdeos de la

biblioteca de fotos del usuario.

62

Una vista es una instancia de la clase UIView (o una de sus subclases) y gestiona un rea
rectangular en la ventana de aplicacin. Las vistas son responsables de dibujar
contenidos, gestionar eventos multitctiles, y gestionar la distribucin de las subvistas.
Dibujar implica el uso de tecnologas de grficos, tales como Core Graphics, OpenGL ES,
o UIKit para dibujar formas, imgenes y texto dentro de una vista rectangular. Una vista
responde a los eventos producidos por el tacto en su rea rectangular ya sea mediante el
uso de reconocedores de gesto (Gesture recognizers) o por el manejo directo de eventos
de presin. En la jerarqua de vistas, las vistas padres son responsables de posicionar y
dimensionar las vistas hijas y pueden hacerlo de forma dinmica. Esta capacidad de
modificar las vistas hijas dinmicamente permite que a las vistas ajustarse dinmicamente
a las condiciones cambiantes, como las rotaciones del interfaz y las animaciones.
Las ventanas coordinan la visualizacin de sus vistas. Una ventana es una instancia de la
clase UIWindow y se encarga de la representacin general de la interfaz de usuario en la
aplicacin. Las ventanas trabajan con las vistas (y sus controladores de vista propietarios)
para gestionar las interacciones y los cambios en la jerarqua de vistas. En la mayora de
las aplicaciones la ventana principal no suele cambiar. Despus de que la ventana se
cree, se mantiene la misma y cambia slo las vistas mostradas en ella. Cada aplicacin
tiene al menos una ventana que muestra la interfaz de usuario de la aplicacin en la
pantalla principal de un dispositivo.
Las animaciones proporcionan a los usuarios informacin visible sobre cambios en la
jerarqua de vistas. El sistema define por defecto animaciones estndar para la
presentacin de de vistas y la transicin entre los diferentes grupos de vistas.
Sin embargo, muchos de los atributos de una vista tambin se pueden animar
directamente. Por ejemplo, a travs de una animacin se puede cambiar la transparencia
de una vista, su posicin en la pantalla, su tamao, su color de fondo, u otros atributos. Y
si se trabaja directamente con el objeto de la vista la capa subyacente Core Animation,
puede realizar muchas otras animaciones tambin.
Interface Builder es una aplicacin que se utiliza para construir grficamente y configurar
las ventanas de una aplicacin y sus vistas. Usando el Interface Builder, se montan las
vistas y se recogen en un archivo nib, que es un archivo de recursos que almacena las
vista y otros objetos. Cuando se carga un archivo nib en tiempo de ejecucin, los objetos
en su interior se reconstituyen en objetos reales cuyo cdigo se puede manipular
mediante programacin.
Interface Builder simplifica mucho el trabajo que tenemos que hacer en la creacin de
interfaz de usuario de la aplicacin. Debido a que el apoyo a la interfaz de archivos
Builder y plumn se incorpora a travs de iOS, se requiere poco esfuerzo para incorporar
archivos nib en el diseo de la aplicacin.

Arquitectura de ventanas y vistas

Un objeto vista, que es una instancia de la clase UIView define un espacio rectangular de
la ventana y maneja los eventos que se producen en dicho rectngulo. Una vista padre
manejar las vistas hija en el mismo sentido.
63

Las vistas trabajan con Core Animation que proporciona comportamiento grfico y la
animacin a dichas vistas.
Cada vista est respaldada por un objeto capa de la clase CALayer que maneja el su
almacenamiento y las animaciones definidas.La mayora de las operaciones se realizan a
travs de la interfaz de UIView.
Para ayudar a entender la relacin entre vistas y capas de Core Animation nos fijamos en
la figura a continuacin.

Las vistas de la aplicacin incluyen una ventana (que es tambin una vista, un objeto
genrico UIView que actual como una vista contenedor,una vista de una imagen, una
barra de herramientas para controles y un tem botn (que no es una vista en s mismo
pero que maneja una vista internamente). Cada vista tiene un objeto de capa
correspondiente que es accesible a travs de las propiedades de la capa, (como el botn
no es una vista no podemos acceder a la capa a travs de l) Detrs de cada objeto de
capa esta Core Animation representndolos y en ltima instancia el hardware a travs de
cada pixel.
Los objetos de capa de Core Animation permiten que la representacin de grficos en la
pantalla se guarde en cach, de forma que no ocupan tiempo de proceso.

Jerarquas de vistas y manejo de subvistas

Las vistas pueden contener otras vistas mediante la relacin padre e hijos. La vista hija la
nombramos como subvista y al padre como supervista.
Visualmente, el contenido de una vista secundaria oculta todo o parte de los contenidos
de su vista padre
La relacin supervista subvista tambin afecta a varios comportamientos de la vista.
64

Cambiar el tamao de una vista padre tiene un efecto domin que puede provocar que el
tamao y la posicin de las subvistas que cambien tambin. No obstante configurando a
las subvistas esto se podra evitar.
La disposicin de las vista en una jerarqua de vistas tambin determina cmo responde
la aplicacin a los eventos. Cuando un evento de tacto se produce dentro de una vista
especfica el sistema enva un objeto evento con la informacin de contacto directamente
a la vista para su manejo. Sin embargo, si la vista no se ocupa de ese evento, se puede
pasar el objeto evento a la supervista y si ocurriera lo mismo el objeto evento se
trasladara hacia arriba en la jerarqua de vistas.

El ciclo de vida de un grfico

La clase UIView usa un modelo de dibujo bajo demanda. Cuando una vista aparece por
primera vez en la pantalla, el sistema le pide que dibuje su contenido. El sistema captura
una instantnea de este contenido y utiliza la instantnea como representacin visual de
la vista. Si no se cambia el contenido de la vista, el cdigo de la vista de dibujo no puede
ser llamado de nuevo. La imagen de la instantnea se vuelve a utilizar para la mayora de
operaciones de la vista. Si se cambia el contenido, se notifica al sistema que la vista ha
cambiado. La vista vuelve a repetir el proceso de elaboracin de la visin y la captura de
una instantnea de los nuevos resultados.
Cuando el contenido ola vista cambia no se vuelve a dibujar otra vez. En su lugar, se
invalida la vista utilizando los mtodos setNeedsDisplay o setNeedsDisplayInRect. Estos
mtodos indican al sistema que el contenido de la vista cambia y es necesario volver a
dibujar en la prxima oportunidad. El sistema espera hasta el final del bucle de ejecucin
antes de iniciar las operaciones de dibujo. Esta demora le da la oportunidad de invalidar
varias vistas, agregar o quitar vistas de su jerarqua, ocultar vistas, vistas, cambiar el
tamao y la posicin de puntos de vista al mismo tiempo. Todos los cambios realizados se
reflejan al mismo tiempo.
Para manejar la forma de realizar el dibujo habra que sobre escribir el mtodo Drawrect.

Modos de contenidos
Cada vista tiene un modo de contenido que controla como la vista controla la forma
cuando se recicla su contenido en respuesta a cambios en la geometra de la vista o si se
recicla todo su contenido. Cuando una vista se muestra por primera vez, dibuja su
contenido,por defecto y los resultados se recogen en un mapa de bits subyacente.
Despus de eso, los cambios en la geometra de la vista no siempre causan el mapa de
bits que se vuelva a crear. En cambio, el valor de la propiedad contentMode determina si
el mapa de bits se debe ser escalado para ajustarse a los lmites nuevos o simplemente
se fija a una esquina o borde de la vista.
El modo el contenido se aplica en la vista cuando se produce lo siguiente:

Cambio del ancho o el alto del rectngulo de la vista o de os bordes del rectngulo.
65

Asignar una transformacin que incluye un factor de escala a la propiedad de la

vista.

Por defecto la propiedad ContentMode para las vistas se establece a

UIViewContentModeScaleToFill, lo que provoca que la imagen se ajuste al tamao nuevo
del frame.
Un ejemplo de modo de contenido sera el indicado en la figura:

Vistas extensibles
Se puede designar una parte de una vista como extensible de modo que cuando el
tamao de la vista, slo cambia el contenido en la porcin extensible afectada.
Normalmente, se utilizan zonas extensibles para los botones u otras vistas donde parte de
la vista define un patrn repetible. Por supuesto, cuando se estira una vista a lo largo de
dos ejes, los bordes de la vista tambin se debe definir un patrn repetible para evitar
cualquier distorsin. La figura muestra cmo esta distorsin se manifiesta en una vista. El
color de cada uno de los pxeles originales de la vista se replica para rellenar el rea
correspondiente en la vista ms grande.

Se especifica la zona elstica de una vista mediante la propiedad contentStretch. Esta

propiedad acepta un rectngulo cuyos valores estn normalizados a la gama de 0,0 a 1,0.
Cuando se extiende la vista, el sistema multiplica estos valores normalizados de los
66

lmites actuales de la vista y el factor de escala para determinar qu pxel o pxeles

necesitan ser estirados. La utilizacin de valores normalizados alivia la necesidad de
actualizar la propiedad contentStretch cada vez que los lmites cambien.
El modo de vista del contenido tambin juega un papel en la determinacin de cmo se
utiliza el rea estirable de la vista. Las zonas estirables slo son utilizadas cuando el
modo de contenido causar que el contenido de la vista sea escalada. Esto significa que
los puntos de vista que pueden ser estirados slo son compatibles con los modos
UIViewContentModeScaleToFill,
UIViewContentModeScaleAspectFit,
y
UIViewContentModeScaleAspectFill. Si se especifica un modo de contenido ancla el
contenido al borde o esquina (y por lo tanto no escala el contenido), la vista ignora la zona
estirable.

Soporte integrado de animaciones

Uno de los beneficios de tener un objeto de capa detrs de cada vista es que se puede
animar las vistas de manera fcil. Las animaciones son un medio til para comunicar la
informacin al usuario y siempre debe tenerse en cuenta durante el diseo de la
aplicacin. Muchas de las propiedades de la clase UIView son susceptibles de ser
animadas, es decir, existe funcionalidad semiautomtica para realizar la animacin de un
valor a otro.
Para realizar una animacin de una de estas propiedades susceptibles de ser animadas,
habra que:
Decir al UIKit que se desea realizar una animacin.
Cambiar el valor de dicha propiedad.
Entre las propiedades que pueden animar a un objeto UIView estn las siguientes:

Frame: animar cambios de posicin y el tamao de la vista.

Bounds: animar los cambios en el tamao de la vista.
Centre: animar la posicin de la vista.
Transform: se utiliza para rotar o escalar la vista.
Alpha: cambiar la transparencia de la vista.
BackgroundColor: cambiar el color de fondo de la vista.
ContentStretch: cambiar el modo en el contenido de la vista estirar.

Un lugar donde las animaciones son muy importantes es cuando se realizan transiciones
de un conjunto de vista a otro. Normalmente, se utiliza un controlador de vista para
gestionar las animaciones asociadas con cambios significativos entre las partes de la
interfaz de usuario. Por ejemplo, para interfaces que implican la navegacin de nivel
superior al de menor nivel de informacin, normalmente se utiliza un controlador de
navegacin para gestionar las transiciones entre las vistas para cada nivel sucesivo de
datos. Sin embargo, tambin puede crear transiciones entre dos conjuntos de vistas
utilizando animaciones en lugar de un controlador de vista. Es posible hacerlo cuando el
nivel de controlador de vista no producen los resultados deseados.
Adems de las animaciones creadas mediante clases UIKit, tambin se pueden crear
67

animaciones con las capas de Core Animation. Bajando al nivel de capa hay mucho ms
control sobre el momento y las propiedades de las animaciones.

Vistas geomtricas y sistemas de coordenadas

El sistema de coordenadas predeterminado en UIKit tiene su origen en la esquina superior
izquierda y tiene ejes que se extienden hacia abajo y hacia la derecha del punto de
origen. Los valores de las coordenadas se representan mediante nmeros de punto
flotante, que permiten la distribucin exacta y la colocacin de contenido,
independientemente de la resolucin de la pantalla subyacente. La figura siguiente
muestra este sistema de coordenadas respecto a la pantalla. Adems del sistema de
coordenadas de pantalla, las ventanas y vistas definen sus propios sistemas de
coordenadas locales que le permiten especificar coordenadas relativas al origen de la
vista o ventana en lugar de respecto a la pantalla.

Hay que tener cuidado cuando se realizan animaciones y transiciones para conocer el
sistema de coordenadas en uso, UIWindow y UIView proporcionan mtodos para poder
convertir dichas coordenadas de un sistema a otro.

Propiedades Frame, Bounds y Center de las vistas

La propiedad de Frame contiene el rectngulo de framework, que especifica el tamao y
la ubicacin de la vista en el sistema de coordenadas de su supervista.
La propiedad Bounds contiene los lmites del rectngulo, que especifica el tamao de la
vista (y su origen de contenido) en el propio sistema de coordenadas local de la vista.
La propiedad Centre contiene el centro conocido de la vista en el sistema de coordenadas
68

de la supervista.
Se utiliza el Centre y las propiedades del Frame principalmente para la manipulacin de la
geometra de la vista actual. Por ejemplo, se pueden utilizar estas propiedades al construir
su jerarqua de vistas o cambiar la posicin o el tamao de una vista en tiempo de
ejecucin. Si cambiamos slo la posicin de la vista (y no su tamao), la propiedad del
Centre es la mejor forma de hacerlo.
Se utiliza la propiedad bounds principalmente durante su dibujo. EL Bound del rectngulo
se expresa en el propio sistema local de coordenadas de la vista. El origen
predeterminado de este rectngulo es (0, 0) y su tamao coincide con el tamao del
rectngulo del Frame. Cualquier cosa que se dibuje dentro de este rectngulo es parte del
contenido visible de la vista. Si cambia el origen del Bounds del rectngulo, cualquier cosa
que se dibuje dentro del nuevo rectngulo se convierte en parte del contenido visible de la
vista.
La figura siguiente muestra la relacin entre los rectngulos del Frame y Bounds. En la
figura, la esquina superior izquierda de la imagen de la vista se encuentra en el punto (40,
40) en el sistema de coordenadas de su supervista y el tamao del rectngulo es de 240
por 380 puntos. Para el Bounds, el punto de origen es (0, 0) y el tamao del rectngulo es
similar 240 por 380 puntos.

Si se cambian las propiedades de alguno de ellos afectar a las otras en el sentido

siguiente:

Cuando se establece la propiedad Frame, el valor del tamao de la propiedad

Bounds cambia para que coincida con el nuevo tamao del rectngulo del Frame.
El valor de la propiedad del centro de manera similar cambia para coincidir con el
nuevo punto central del rectngulo del Frame.
Cuando se establece la propiedad del Centre, el valor de origen en el Frame
cambia en consecuencia.
Cuando se establece el tamao de la propiedad Bounds, el valor de tamao en el
Frame cambia de propiedad para que coincida con el nuevo tamao del Bounds del
69

rectngulo.

Transformaciones del sistema de coordenadas

Las transformaciones del sistema de coordenadas proporciona una manera de alterar la
vista (o su contenido) de forma rpida y sencilla. Una transformacin afn es una matriz
matemtica que especifica el nmero de puntos en un sistema de coordenadas de mapa
de puntos en un sistema de coordenadas diferente.
Se pueden aplicar transformaciones afines a la vista para cambiar el tamao, la
ubicacin o la orientacin de la vista con respecto a su supervista. Tambin se pueden
utilizar transformaciones afines en el cdigo de dibujo para realizar el mismo tipo de
manipulaciones a las piezas individuales de contenido.
Cmo aplicar esas transformaciones depender del contexto, por ejemplo:
Para modificar toda la vista, se realizara una modificacin a travs de la propiedad
tranform de la vista
Para modificar alguna parte especfica de contenido en la vista se usar el mtodo
DrawRect modificando la matriz afin.

Por lo general, se modifica la propiedad transform del objeto cuando se desea

implementar animaciones. Por ejemplo, puede utilizar esta propiedad para crear una
animacin de la vista girando alrededor de su punto central. No se suele utilizar esta
propiedad para hacer cambios permanentes a las vistas, como modificar su posicin o el
tamao de una vista dentro de su espacio de coordenadas de supervista. Para ese tipo de
cambio, se debe modificar el rectngulo del Frame de la vista en su lugar.

Puntos vs Pixel
En iOS, todos los valores de las coordenadas y las distancias se especifican mediante
valores de punto flotante en unidades conocidas como puntos. El tamao mensurable de
un punto vara de un dispositivo a otro y es en gran medida irrelevante. Lo ms importante
a comprender acerca de los puntos es que proporcionan un marco fijo de referencia para
el dibujo.

Dispositivo

Dimensiones en puntos de la
pantalla)

iPhone e iPod touch

iPad

320 x 480
768 x 1024

El sistema de medida basado en puntos es utilizado para cada tipo de dispositivo y define
lo que se conoce como el espacio de coordenadas del usuario. Este es el espacio de
coordenadas estndar que utiliza para casi todo el cdigo. Por ejemplo, se pueden utilizar
los puntos y el espacio de coordenadas del usuario en la manipulacin de la geometra de
una vista o llamando al funciones del Core Graphics para dibujar el contenido de una
70

vista. Aunque las coordenadas del espacio de coordenadas del usuario se asignan
directamente a los pxeles de la pantalla del dispositivo, nunca debe asumir que este es el
caso. En su lugar, siempre debe recordar lo siguiente:
Un punto no corresponde necesariamente a un pxel en la pantalla.

Modelo de interaccin en tiempo de ejecucin con las vistas

Cada vez que un usuario interacta con la interfaz de usuario, o en cualquier momento su
propio cdigo mediante programacin cambia algo, una secuencia compleja de eventos
tiene lugar dentro de UIKit para manejar esa interaccin. En puntos especficos durante
esa secuencia, UIKit llama a sus clases de vista y les da la oportunidad de responder en
nombre de la aplicacin. Entender estos puntos de llamada es importante para entender
dnde las vistas encajan en el sistema. La Figura siguiente muestra la secuencia bsica
de eventos que se inician cuando el usuario toca la pantalla y termina con la respuesta de
actualizacin del sistema de grficos. La misma secuencia de acontecimientos tambin
podra ocurrir por las acciones iniciadas mediante programacin.

Los pasos siguientes explican la secuencia de eventos de la figura anterior.y se explica lo

que sucede en cada etapa y cmo es posible que la aplicacin reaccione en respuesta.
1. El usuario toca la pantalla.
2. El hardware informa sobre el evento contactar al framework UIKit.
3. El framework UIKit empaqueta la interaccin en un objeto UIEvent y lo enva a la
vista apropiada.
4. El cdigo de gestin de eventos de la vista responde al evento. Por ejemplo, el
cdigo podra:
Cambiar las propiedades (frame, bounds, alfph, etc) de la vista o de sus
subvistas.
Llamar al mtodo setNeedsLayout para marcar la vista (o sus subvistas)
para una actualizacin de diseo.
71

Llamar a los mtodos setNeedsDisplay o setNeedsDisplayInRect: para

marcar la vista (o sus subvistas) para volver a dibujarla.
Notificar a un controlador sobre los cambios en alguna pieza de datos.
Si la geometra de una vista es cambiada por cualquier razn, UIKit actualizar sus
subvistas de acuerdo con las siguientes reglas:
Si ha configurado reglas de tamao automticamente para sus puntos de
vista, UIKit ajusta cada vista de acuerdo con esas reglas.
Si la vista implementa el mtodo layoutSubviews, UIKit lo llamar.

Si cualquier parte de cualquier vista es marcada con la necesidad de volver a

dibujaser, UIKit pedir a la vista que se re dibuje.
Cualquier vista actualizada se compondr con el resto del contenido visible de la
aplicacin y se enva al hardware de grficos para visualizacin.
El hardware de grficos transfiere el contenido presentado en la pantalla.

5.

6.
7.
8.

Uso Efectivo de las vistas

Las vistas no siempre cuentan con un controlador
Pocas veces existe una relacin de uno a uno entre vistas individuales y controladores de
vista de la aplicacin. El trabajo de un controlador de vista es la gestin de una jerarqua
de vistas, que a menudo consiste en ms de una vista utilizado para implementar algunas
caracterstica de auto-contenido. Para las aplicaciones de iPhone, cada jerarqua de
vistas tpicamente ocupa toda la pantalla, aunque para aplicaciones de iPad una jerarqua
de vistas puede llenar slo una parte de la pantalla.
Al disear la interfaz del usuario de la aplicacin, es importante tener en cuenta el papel
que jugarn los controladores de vista. Los controladores de vista proporcionan una gran
cantidad de funciones importantes, tales como la coordinacin de la presentacin de la
vista en la pantalla, la coordinacin de la eliminacin de la vista de la pantalla, liberando
memoria en respuesta a las advertencias de poca memoria, y la rotacin de la vista en
respuesta a los cambios de orientacin de la interfaz. Eludir estos comportamientos
podran hacer que la aplicacin se comporte incorrectamente o de manera inesperada.
Minimizar el uso dibujo personalizado
Aunque el dibujo personalizado es necesario a veces, tambin es algo que se debe evitar
siempre que sea posible. La nica vez que realmente se debera hacer cualquier dibujo
personalizado es cuando las clases del sistema de visin existentes no proporcionan la
apariencia o la capacidad que se necesita. Cada vez que su contenido puede ser
montado con una combinacin de vistas existentes, lo mejor es combinar los objetos de
vista dentro de una jerarqua vista personalizada.
Aprovechar los modos de contenido
Modos contenido minimizan la cantidad de tiempo dedicado re dibujar las vistas. De forma
predeterminada, las vistas utilizan el modo de contenido UIViewContentModeScaleToFill,
que escala contenidos existentes de la vista para adaptar el rectngulo de la vista. Puede
72

cambiar este modo, segn sea necesario para ajustar su contenido de forma diferente,
pero se debe evitar el uso del modo de contenido UIViewContentModeRedraw si se
puede. Siempre se puede obligar a re dibujar una vista con llamando a setNeedsDisplay
y setNeedsDisplayInRect.
Implementar Vistas opacas siempre que sea posible
UIKit utiliza la propiedad opaca de cada vista para determinar si la vista puede optimizar
las operaciones de composicin. Establecer el valor de esta propiedad a Yes para una
vista personalizada UIKit conocer que no tiene qu dibujar ningn contenido detrs de la
vista. No tener que dibujar tanto dar lugar a un mayor rendimiento para el cdigo de
dibujo. Por supuesto, si se establece la propiedad opaco en YES, la vista debe llenar el
rectngulo completamente con contenido totalmente opaco.
Ajustar el comportamiento de dibujo de la vista para cuando se realice scroll
El desplazamiento puede incurrir en numerosas actualizaciones del dibujo en un corto
perodo de tiempo. Si el cdigo de la vista de dibujo no se ajusta adecuadamente, el
rendimiento de desplazamiento de su punto de vista podra ser lento. En lugar de trate de
asegurar que el contenido de su vista es original en todo momento, puede cambiar el
comportamiento de la vista, cuando una operacin de desplazamiento comienza. Por
ejemplo, se puede reducir la calidad del contenido representado de forma temporal o
cambiar el modo de contenido mientras que un desplazamiento en curso. Cuando el
desplazamiento se detenga, a continuacin, puede volver la vista a su estado anterior y
actualizar los contenidos cuando sea necesario.

73

Interface Builder
Interface Builder puede usarse como editor e interfaz de usuario, aunque tambin hay que
entenderlo como una herramienta de administracin de objetos ms general.
EN XCODE IB (Interface Building) tiene varias funciones:

Utilizamos IB para disear la interfaz de usuario de una aplicacin. Este diseo

incluye, adems de ventanas y vistas con sus controles asociados, otros objetos
coo botones, cuadros de textos, etc... Para estos objetos grficos podemos
establecer sus propiedades, posicin y controlar si tiene sombra, el color etc...
Tambin se pueden confeccionar y configurar objetos grficos e otra ndole y ms
personalizados.
Podemos utilizar IB para crear previamente instancias de objetos de nuestra
aplicacin. Cualquier objeto aadido a un archivo .nib se crea en la memoria
cuando cargaos el archivo. Los objetos que se crean de esta forma no tienen por
qu ser visibles en parte de la interfaz de usuario.
Se puede usar tambin IB para generar una coleccin de objetos de interfaz
personalizados por el programador. Algunos programadores avanzados generan
una coleccin de objetos personalizados con el cdigo asociado. De esa forma se
generan archivos .nib tiles con colecciones de objetos que se cargan cuando sea
preciso.
Se puede usar para vincular caractersticas de cdigo con objetos de la interfaz de
usuario. Los eventos y las acciones del usuario se envan a nuestro cdigo
utilizando acciones (actions, mtodos que se activan en el cdigo cuando el
usuario interacta con una vista o un control). Las propiedades de los objetos de
interfaz de usuario como el tamao, la posicin, el color, el estado, el texto, etc... se
configuran con outlets.

Los archivos .nib

Los archivos creados por IB se llaman archivos nib (la extensin de esos archivos es .xib).
Las aplicaciones IOSy OSX cargan un archivo nib cuando arrancan. Este archivo se
especifica en la plist de la aplicacin. Puede ocurrir ue un archivo nib cargue otro, iB no
muestra esa jerarqua de llamadas.
Cuado un archivo nib se carga automticamente sus objetos se cargan en el programa, ya
sea a nivel de pantalla y de memoria. Tambin se pueden cargar objetos de esta forma,
eso sustituira a las llamadas init y alloc de Objective-C.
Para crear un conjunto de objetos de interfaz no har falta usar IB, sino que con llamadas
init y alloc bastara. Por ejemplo si quisiramos crear mens emergentes, con
animaciones exclusivas habra que programar los objetos directamente y no servira de
mucho IB.
IB es muy bueno que utilizan el Kit de Apple estndar de objetos tal cual, usando IB como
herramienta de diseo y vista previa que controla los elementos estticos de la
interfaz.para interfaces sencillos como la alineacin, justificacin, etc..
74

Los programadores avanzados usan IB para la personalizacin de los objetos, como por
ejemplo sustituir el grfico de un botn estndar por otro ms dibujado.
La creacin de archivos .nib se ve complementada por la creacin de ficheros .nib que se
pueden cargar a peticin de cualquier objetos que los necesite.
La carga manual de nib es similar a la automtica, con la diferencia de que los objetos
definidos pueden cargarse y quitarse desde la memoria cuando sea necesario. Este
mtodo permite ahorra espacio en memoria ya que al pasar de una vista a otra la primera
se elimina de la memoria.

Crear la interfaz de usuario

Interface Builder al igual que otros editores de Xcode, se ha asociado inspectores y y
libreras en el rea de utilidades. Interface Builder aparece en el rea de edicin de la
ventana del rea de trabajo cuando se selecciona un archivo o un archivo nib o un
StoryBoard en el navegador de proyectos. Al abrir un archivo nib o storyboard, los
objetos de la interfaz de usuario aparecen en el rea de edicin y los inspectores de
Interface Builder aparecern en el rea de servicios pblicos. Hay que utilizar estos
inspectores para configurar los objetos de la interfaz y hacer conexiones entre ellos. Las
libreras de objetos y multimedia en el panel de la biblioteca del rea de utilidades
tambin son para su uso con Interface Builder, que utilizan estas bibliotecas para agregar
nuevos objetos para el diseo de su interfaz de usuario.
Las reglas bsicas para la creacin del interfaz de usuario son:
Cuando se quiera leer las propiedades de un objeto desde la interfaz e usuario, se
debe aadir la clase correspondiente a su cdigo. Por ejemplo si la interfaz de
usuario incluye una etiqueta, se debe utilizar IB para aadir un objeto UILabel al
cdigo.
El cdigo est situado en un controlador de vista, y el objeto que aparece en
pantalla se incluye en el archivo nib de vista correspondiente. No se trata de una
regla absoluta pero es un punto de partida tpico.
Cuando tenemos el cdigo para un objeto de interfaz de usuario, se puede definir
una referencia outlet que los vincule. Cuando el cdigo modifica propiedades de
un objeto (tamao, posicin, etc..) el vnculo copia el cambio en el administrador de
la interfaz e usuario y la representacin visible del objeto se actualiza en la
pantalla.
Si se quiere que la aplicacin responda a eventos de usuario, se debe definir una
accin para cada evento. Una accin es un mtodo especial aadido al cdigo para
manejar eventos de usuario.
Los objetos de interfaz de usuario pueden soportar outlets y acciones al mismo
tiempo.
Podemos crear objetos sin outlets ni acciones para decorar la interfaz, estos no
responden a eventos de usuario.

75

Para comenzar a usar IB hay que crear o usar un proyecto de aplicacin basada en IOS
que utilice ventanas.
Una vez creado seleccionamos en archivo .xil. En este caso si llamamos al proyecto
IB_prueba el archivo creado porXcode se llamar IB_pruebaViewController.nib.
Si seleccionamos el archivo en la ventana de trabajo se muestra la siguiente disposicin:

La columna de iconos a la izquierda del rea del editor principal muestra los objetos del
archivo nib.
Un tringulo en la parte inferior de esta columna despliega una lista ms detallada con
descriptores de texto.
El men de navegacin jerrquico encima del rea del editor proporciona acceso rpido a
los objetos en el nib y a otros archivo nib.
En el rea del editor se encuentra los objetos del interfaz rodeada por una linea azul que
permite mover la interfaz de posicin.
Si un objeto carga otro nib (cuando un controlador de vista carga una vista) el editor
muestra un mensaje de marcador de posicin sencillo que indica que ah van los
contenidos de otro nib.

76

El rea de utilidades
Muestra iconos y opciones que permiten configurar el archivo nib.

Identity inspector muestra una lista de la clase objeto

77

Attributes inspector es una lista de las propiedades predeterminadas. Tiene diferentes

contenidos para cada objeto de IB.

Las opciones Simulated Metrics ofrecen una vista previa de las caractersticas de
navegacin de manera que se pueden disear el resto de la vista con las proporciones
correctas.
Casi todas las opciones que aparecen en ambas listas se pueden modificar por cdigo
pero es ms sencillo obtener una vista del resultado en IB.
Size Inspector configura las dimensiones y la alineacin de un objeto. Tambin controla
el auto dimensionamiento: la capacidad de un objeto de auto dimensionarse al tamao y
posicin de una ventana o vista tras una rotacin o dimensionamiento manual.

78

Connections Inspector, ofrecen una lista de acciones y referencias de un objeto. Cuando

las propiedades y los mtodos estn vinculados a cdigo se pueden revisar y modificar
aqu.

Aadir objetos a una vista

Para poder aadir objetos a una vista intentamos configurar la pantalla de trabajo como se
muestra a continuacin:

Se llega a esta pantalla seleccionando el fichero IB_pruebaViewControler.xib y haciendo

click en Assitant editor.
Para aadir objetos a una vista hay que seleccionar el objeto de la ventana de Objects y
soltarlo en la ventana de la vista.

79

Al seleccionar un objeto de la ventana se mostrar a la izquierda una descripcin

emergente de dicho objeto . Al arrastrar aparecern guas en el rea de trabajo que nos
permitirn centrar el objeto en la vista.

Configurar los contenidos de objetos

Si incluyramos por ejemplo una etiqueta Label, habra que realizar los siguientes
pasos:
1. Configurar la etiqueta de texto
2. Opcionalmente, cambiar la fuente el tamao y el color (Mediante Attributes
Inspector)
3. Opcionalmente, cambiar la configuracin del texto y los saltos de lnea (Mediante
Attributes Inspector)
4. Opcionalmente aadir una sombrea paralela (Mediante Attributes Inspector)
5. Re dimensionar el objeto para garantizar que el texto se muestra correctamente
6. Re alinear el objeto otra vez despus de los cambios
Todos estos pasos se realizan en el cuadro de utilidades a la derecha del rea de trabajo.
Vinculacin de objetos a cdigo
La creacin de acciones y referencias es un proceso relativamente sencillo en Xcode 4.
En esta versin Xcode aade el cdigo correcto de manera automtica. Crea las
propiedades adecuadas, las sintetiza y aade stubs de cdigo de mtodo. Bien es verdad
que es el programador el que rellena los stubs de cdigo de control de eventos, pero los
elementos esenciales los incluye Xcode.
Aadir una accin: un botn debera realizar algo cuando se le presiones, en IOS
tendremos que aadir el cdigo necesario para que esto ocurra a travs de un mtodo
que controle los eventos del ratn en el botn. La clase IBViwewControler administra la
interfaz de usuario, as que el cdigo ase aade en esta clase. Cada vez que creamos
una accin para un control, aparece ella lista del Conector Inspector
La accin se crea en el rea debajo de las llaves de la clase pero encima de la directiva
@end. Aunque se puede aadir una accin a un archivo de implementacin, es ms
80

sencillo aadirla a un archivo de encabezado, porque el encabezado alberga una lista

sencilla y clara de todas las acciones.

Poner nombre a una accin e inicializarla

Si pulsamos en la accin, dentro del Connector inspector y la soltamos antes del @end y
tendremos que ponerle un nombre a dicha accin y definir los parmetros que se pasan al
mtodo (opcional) en la ventana de Connection.

En la opcin type podemos seleccionar id, o la clase del objeto que enva el mensaje, en
este ejemplo UIButton. Es conveniente utilizar el tipo id para manejar mensajes de varios
objetos diferentes o no se necesita leer las propiedades del objeto. A partir de ese
momento se puede aadir cdigo extra que determine la clase que envi el mensaje. Se
utilizar una clase especfica cuando se quiera leer informacin del botn o cambiar
alguna de las propiedades.
La pestaa Event permite cambiar el evento si nos hemos equivocado y queremos
seleccionar otro diferente.La opcin Arguments ofrece las siguientes posibilidades:

None: si no se conoce al objeto emisor

Sender: cuando se quieran conocer las propiedades del objeto emisor
Sender and Event: cuando se quieran conocer las del objeto emisor y la
informacin de un objeto UIEvent que llega con el mensaje.

Para finalizar la creacin de la accin seleccionaremos Connect.

81

La figura siguiente muestra el resultado. La firma de una accin se aade al archivo

encabezado. En el final del archivo de implementacin se aadi un stub correspondiente

82

Aadir un Outlet
El manejador que hemos incluido debera tener alguna accin visible asociada. Vamos a
hacer que esa accin cambie el texto de la etiqueta. Para ello necesitamos conectar la
etiqueta a una referencia Outlet de manera que podamos leer y escribir sus propiedades
con cdigo.
Seleccionamos la etiqueta y se mostrar un Connection Inspector que mostrar un
subpanel Referencing Outlet y un subpanel Referencing Outlet Collections. Ignoramos
la opcin Collections y arrastramos la linea desde el crculo junto a New Referencing
Outlet debajo de las llaves, ver figura a continuacin.

Al soltar el botn del ratn aparecer un cuadro de dilogo para indicar el nombre del
Outlet. El Type indica el tipo del objeto, que en este acaso es la etiqueta, y la opcin de
Storage nos permite administrara la gestin de memoria del objeto. Por lo general es
mejor escoger Retain. Pulsamos Connect y ya estar creado el Outlet.
IB aade el outlet en dos lugares, aparecer una propiedad prefijada dentro de las llaves
y, debajo de ellas aparece una declaracin @property separada por una directiva
IBOutlet.
Xcode generar un cdigo en cuatro lugares:
Ha aparecido una nueva directiva @synthesize que sintetiza el acceso a la
propiedad de la etiqueta.
EL objeto de etiqueta se ha incluido el mtodo dealloc , lo que asegura que la
memoria utilizada por la etiqueta del objeto se libera cuando la clase de controlador
libera memoria.
La etiqueta se ha aadido al mtodo viewDidUnload.
Finalmente el mtodo buttonWasTrapped se ha aadido como un stub aparte.
83

Rellenar un stub de acciones

La aplicacin se encuentra ya casi terminada. Lo que falta es el cdigo personalizado del
stub e acciones que actualiza la etiqueta cuando se da un toque al botn.
En el archivo de implementacin tendremos que aadir el cdigo siguiente entre las llaves
del stub IBAction:
If ([theLabel.text isEqualToString: @this is of])
theLabel.txt = <@This is on;
else
theLabel.text = this is off;

Probar la aplicacin
Para probar una aplicacin hay que pulsar la flecha Build & Run en la parte superior
izquierda de la barra de herramientas de Xcode. La aplicacin debera de compilarse y
ejecutarse en la ventana del simulador.

Jerarqua de objetos en Interface Builder

Los objetos estn en niveles diferentes, lo que significa que los objetos de la parte ms
baja de la lista cubren objetos que quedan ms arriba cuando aparecen en la pantalla.
Los objetos de un archivo nib se organizan en un rbol. Algunos objetos como UIViews
pueden contener otros objetos. La estructura es similar a las carpetas del Finder.
Podemos utilizar los tringulos de despliegue para abrir y cerrar objetos mostrando los
objetos que contienen.
En teora se podra aadir un UIView separado a la interfaz de usuario re dimensionando
ambos para crear una interfaz de usuario dividida en os paneles.

84

Gestin de la pantalla
Ventanas
Todas las aplicaciones iOS necesitan por lo menos una ventana, una instancia de la clase
UIWindow, algunos pueden incluir ms de una ventana. Un objeto ventana tiene varias
responsabilidades:

Tiene contenidos visibles de la aplicacin.

Desempea un papel clave en la distribucin de eventos de presin a la vista y
otros objetos de la aplicacin.
Funciona con los controladores de vista de la aplicacin para facilitar los cambios
de orientacin.

En iOS, las ventanas no tienen barras de ttulo, botn de salida, o cualquier elemento
visual. Una ventana es siempre un recipiente blanco para una o varias vistas. Adems, las
aplicaciones no cambian su contenido, mostrando nuevas ventanas. Si desea cambiar el
contenido que aparece, cambia la vista del primer plano en su lugar.
La mayora de las aplicaciones de iOS crean y utilizan una ventana durante su ejecucin.
Esta ventana se extiende por la pantalla principal del dispositivo y se carga desde el
archivo nib de la aplicacin principal (o se crea mediante programacin) al comienzo de la
vida de la aplicacin. Sin embargo, si una aplicacin es compatible con el uso de una
pantalla externa para la salida de vdeo, se puede crear una ventana adicional para
mostrar contenido en dicha pantalla externa. Todas las dems ventanas son tpicamente
creadas por el sistema, y se crean generalmente en respuesta a eventos especficos,
tales como una llamada telefnica entrante.
Para muchas aplicaciones la nica vez que interactan con una ventana es al inicio. No
obstante hay otras ocasiones para comunicarse:

Cambiar el sistema de referencia

Comprobar si la ventana esta cerrada o abierta

Crear y configurar una ventana

Se puede crear y configurar la ventana principal de la aplicacin mediante programacin o
mediante Interface Builder. En cualquier caso, se crea la ventana en el momento del
lanzamiento y debe retener y almacenar una referencia a l en su objeto delegado de la
aplicacin.
Siempre debe crear la ventana principal de la aplicacin en tiempo de puesta en marcha,
independientemente de si su solicitud est siendo lanzada en el primer plano o de fondo.
Crear y configurar una ventana no es una operacin costosa por s misma. Sin embargo,
si la aplicacin se ejecuta directamente en el fondo, se debe evitar que la ventana sea
visible hasta que su solicitud entra en primer plano.

85

Creacin mediante Interface Builder ver captulo siguiente.

Creacin mediante cdigo
Si se crea la ventana principal de la aplicacin mediante programacin, sedebe incluir
cdigo similar al siguiente en la solicitud: didFinishLaunchingWithOptions: del mtodo de
su aplicacin delegada:
self.window = [[[UIWindow alloc] initWithFrame: [[mainScreen UIScreen] lmites]]
autorelease];
Aadir contenido a una ventana
Cada ventana tiene tpicamente un objeto vista de raz nica (gestionado por su
controlador de vista correspondiente) que contiene todas las otras vistas que representan
el contenido. Usar un vista con nica raz simplifica el proceso de cambiar el interfaz, para
mostrar el nuevo contenido, lo nico que se tiene que hacer es sustituir vista de la raz.
Para alojar una vista en la ventana, se utiliza el mtodo addSubview. Por ejemplo, para
alojar una vista que es manejada por un controlador de vista, se deber utilizar un cdigo
similar al siguiente:
[window addSubview:viewController.view]
En lugar del cdigo anterior, tambin se puede configurar la propiedad
RootViewController de la ventana en el archivo nib. Esto ofrece una forma cmoda de
configurar la vista de origen de la ventana con un archivo nib en lugar de mediante
programacin. Si esta propiedad se establece cuando la ventana se carga desde el
archivo nib, UIKit instala automticamente las vistas desde el controlador de vista
asociada como la vista raz de la ventana. Esta propiedad se utiliza slo para instalar la
vista raz y no se utiliza por la ventana para comunicarse con el controlador de vista.

Cambiar el nivel de ventana

Cada objeto UIWindow tiene una propiedad windowLevel configurable que determina la
forma en que la ventana se coloca en relacin con otras ventanas. En su mayor parte, no
es necesario cambiar el nivel de las ventanas de la aplicacin. Las nuevas ventanas se
asignan automticamente al nivel normal de la ventana en el momento de la creacin. El
nivel normal de la ventana indica que la ventana de aplicacin presenta contenido
relacionado. Los niveles ms altos de ventana estn reservados para la informacin que
necesita flotar sobre el contenido de la aplicacin, tales como la barra de estado del
sistema o los mensajes de alerta. Y aunque podemos asignar niveles a ventanas por
nosotros mismos, el sistema normalmente lo hace por nosotros cuando utiliza interfaces
especficas. Por ejemplo, al mostrar u ocultar la barra de estado o mostrar una vista
alerta, el sistema crea automticamente las ventanas necesarias para mostrar los
elementos.
Seguimiento de los cambios en ventanas
Si se desea realizar un seguimiento de la aparicin o desaparicin de las ventanas dentro
86

de la aplicacin, se realiza a travs de estas notificaciones relacionadas con ventanas:

UIWindowDidBecomeVisibleNotification
UIWindowDidBecomeHiddenNotification
UIWindowDidBecomeKeyNotification
UIWindowDidResignKeyNotification

Vistas
Debido a que los objetos vistas son la forma principal de la aplicacin interacta con el
usuario, tienen muchas responsabilidades. stos son slo algunas:

Diseo y gestin subvista

Una vista define sus propios comportamientos predeterminados de cambio de
tamao en relacin con su vista padre.
Una vista puede administrar una lista de subvistas.
Una vista puede anular el tamao y la posicin de sus subvistas segn sea
necesario.
Una vista puede convertir puntos en su sistema de coordenadas de los sistemas de
coordenadas de otros puntos de vista o la ventana.
Dibujo y animacin
Una opinin se basa en el contenido de su rea rectangular.
Algunas propiedades de la vista se puede animar a los nuevos valores.
gestin de eventos
Una vista puede recibir eventos tctiles.
Una vista participa en la cadena de respuesta.

Creando y configurando objetos de vistas

Creacin de objetos de vistas utilizando Interface Builder (ver captulo Interface Builder)
Creacin de objetos vistas mediante programacin
Para crear vistas mediante programacin, se puede hacer utilizando el estndar de
asignacin / inicializacin del patrn. El mtodo de inicializacin por defecto para las
vistas es el mtodo initWithFrame, que establece el tamao inicial y la posicin de la vista
en relacin con su (pronto-a-ser-establecida) vista padre. Por ejemplo, para crear un
objeto nuevo UIView genrico, puede utilizar cdigo similar al siguiente:
CGRect viewRect CGRectMake = (0, 0, 100, 100);
UIView * myView = [[UIView alloc] initWithFrame: viewRect];
Una vez creada la vista debera aadirse a una ventana o otra vista. Para saber como
aadir una vista a la jerarqua de vistas ver Aadir y borrar subvistas..
Configuracin de las vistas
La clase UIView tiene varias propiedades declaradas para controlar el aspecto y el
87

comportamiento de la vista. Estas propiedades son para la manipulacin del tamao y la

posicin de la vista, la transparencia de la vista, el color de fondo, y su comportamiento de
representacin. Todas estas propiedades tienen valores por defecto adecuados que se
pueden cambiar ms adelante si es necesario. Tambin puede configurar muchas de
estas propiedades de Interface Builder utilizando la ventana Inspector.
Tabla de propiedades
Propiedades
alpha, hidden, opaque

bounds,
transform

frame,

autoresizingMask,
autoresizesSubviews

Uso
Estas propiedades afectan a la opacidad de la vista. El
alpha y hidden cambian la opacidad de la vista
directamente.
La propiedad opaque indica al sistema cmo debe
compuesta la vista. Establezca esta propiedad en S si
el contenido de su punto de vista es totalmente opaco y
por lo tanto no revela el contenido de la vista
subyacente. Al establecer esta propiedad en YES
mejora el rendimiento mediante la eliminacin de
operaciones innecesarias de composicin.
center, Estas propiedades afectan el tamao y la posicin de
la vista. El center y frame representan la posicin de la
vista con respecto a su vista padre. El frame tambin
incluye el tamao de la vista. La propiedad bounds
define el rea de la vista de contenido visible en su
propio sistema de coordenadas.
La propiedad transform se utiliza para animar o mover
toda la vista de manera compleja. Por ejemplo, se
utiliza una transformacin para rotar o escalar la vista.
Si la transformacin actual no es la transformacin de
la identidad, la propiedad frame est definida y debe
ser ignorada.
Estas propiedades afectan al comportamiento de
cambio de tamao automtico de la vista y sus
subvistas. La propiedad autoresizingMask controla
cmo una visin responde a los cambios en los lmites
de la visin de los padres. La propiedad
autoresizesSubviews controla si la vista cambia de
tamao absoluto.

contentMode,
contentStretch, Estas propiedades afectan al comportamiento de
contentScaleFactor
representacin de los contenidos dentro de la vista. El
contentMode y las propiedades contentStretch
determinan cmo el contenido se trata cuando el ancho
de la vista o la altura cambans. La propiedad
contentScaleFactor slo se utiliza cuando se necesita
para personalizar el comportamiento de la vista de
dibujo para pantallas de alta resolucin.
gestureRecognizers,
userInteractionEnabled,

Estas propiedades afectan cmo la vista procesa los

eventos
tctiles.
La
propiedad
contiene
88

multipleTouchEnabled,
exclusiveTouch

gestureRecognizers contiene reconocimiento de gesto

asociados ala vista. Las otras propiedades controlan
cuales eventos de tacto son soportados por la vista.

backgroundColor,
subviews, Estas propiedades y mtodos ayudan a administrar
drawRect:
method,
layer, el contenido real de la vista. Para las vistas
(layerClass method)
simples, se puede establecer un color de fondo y

agregar uno o ms subvistas. La propiedad

subvistas s contiene una lista de slo lectura de
subvistas, pero existen varios mtodos para
agregar y reorganizar subvistas. Para las vistas de
dibujo con un comportamiento personalizado, debe
reemplazar el drawRect: mtodo.

89

Creando y manejando una jerarqua de vistas

Manejar jerarquas de vistas es una parte crucial del desarrollo de interfaz de usuario en
una aplicacin. La organizacin de las vistas influye en el aspecto visual de la aplicacin y
cmo su aplicacin responde a los cambios y eventos. Por ejemplo, las relaciones entre
padres e hijos en la jerarqua de vistas determina qu objetos podra manejar un evento
de contacto especfico. Del mismo modo, las relaciones entre padres e hijos definen cmo
cada vista responde a los cambios de orientacin de la interfaz.
La figura siguiente muestra un ejemplo de cmo la disposicin en capas de vistas crea el
efecto visual deseado en una aplicacin. En el caso de la aplicacin de reloj, la jerarqua
de la vista se compone de una mezcla de vistas derivadas de diferentes fuentes.

Aadir y borrar subvistas

Interface Builder es la forma ms conveniente para construir jerarquas de vista, ya que

monta sus vistas de manera grfica, permite ver las relaciones entre las vistas, y permite
ver exactamente cmo esas vistas aparecern en tiempo de ejecucin. Al utilizar el
Interface Builder, guarda su jerarqua de la vista resultante en un archivo nib, que se carga
en tiempo de ejecucin como las vistas correspondientes sean necesarias.
Para agregar una vista secundaria a un padre, se llama al mtodo addSubview: Mtodo
de la vista padre. Este mtodo agrega la subvista al final de la lista de subvistas del padre.
Para insertar una vista secundaria en el medio de la lista de los padres de subvistas,
llame a cualquiera de los insertSubview:
90

Para reordenar subvistas existentes en

bringSubviewToFront:,
sendSubviewToBack:
withSubviewAtIndex

el
o

interior del padre, utilizar

exchangeSubviewAtIndex:

Para eliminar una vista secundaria del padre, se llama al mtodo removeFromSuperview
de la subvista (no la vista padre).
Cuando se aade una subvista al padre, el actual vista del Frame denota su posicin
inicial dentro de la vista padre. Una subvista cuyo frame se encuentre fuera de los lmites
visibles de su Superview no se recorta de forma predeterminada. Si desea que la subvista
sea recortada a los lmites de la Superview, se debe establecer explcitamente la
propiedad de la supervista clipsToBounds en YES.
El ejemplo ms comn de agregar una vista secundaria a otra vista se produce en la
aplicacin: didFinishLaunchingWithOptions: Mtodo de casi todas las aplicaciones.
El cdigo siguiente muestra una versin de este mtodo que instala en el controlador de
vista de la aplicacin en la ventana. Tanto la ventana y el controlador de vista se
almacenan en el archivo de la aplicacin principal, que se carga antes de que se llame al
mtodo. Sin embargo, la jerarqua de la vista gestionada por el controlador de vista no se
carga realmente hasta que la propiedad accede a la vista.
Aadir una vista a una ventana:
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:
(NSDictionary *)launchOptions
{
// Override point for customization after application launch.
// Add the view controller's view to the window and display.
[window addSubview:viewController.view];
[window makeKeyAndVisible];
return YES;
}
Aadir vistas a una jerarqua de vistasGestin
(void)viewDidLoad
{
[super viewDidLoad];
self.title = NSLocalizedString(@"TransitionsTitle", @"");
// create the container view which we will use for transition animation (centered
horizontally)
CGRect frame = CGRectMake(round((self.view.bounds.size.width kImageWidth) / 2.0),
kTopPlacement, kImageWidth, kImageHeight);
self.containerView = [[[UIView alloc] initWithFrame:frame] autorelease];
[self.view addSubview:self.containerView];
// The container view can represent the images for accessibility.
[self.containerView setIsAccessibilityElement:YES];
91

[self.containerView setAccessibilityLabel:NSLocalizedString(@"ImagesTitle",
@"")];
// create the initial image view
frame = CGRectMake(0.0, 0.0, kImageWidth, kImageHeight);
self.mainView = [[[UIImageView alloc] initWithFrame:frame] autorelease];
self.mainView.image = [UIImage imageNamed:@"scene1.jpg"];
[self.containerView addSubview:self.mainView];
// create the alternate image view (to transition between)
CGRect imageFrame = CGRectMake(0.0, 0.0, kImageWidth, kImageHeight);
self.flipToView = [[[UIImageView alloc] initWithFrame:imageFrame] autorelease];
self.flipToView.image = [UIImage imageNamed:@"scene2.jpg"];
}
Ocultar vistas
Para ocultar la visin de una vista, se puede establecer su propiedad oculta en YES o
cambiar la propiedad alpha a 0,0. Una vista oculta no recibe eventos de contacto del
sistema. Sin embargo, vistas ocultas no participan en tamao automtico y otras
operaciones de diseo asociados con la jerarqua de vistas. Por lo tanto, ocultando una
vista es a menudo una alternativa conveniente a la eliminacin de vistas en la jerarqua de
vista, especialmente si se va a mostrar la vista de nuevo en algn momento.
Localizacin de una vista en una jerarqua de vistas
Hay dos maneras de localizar vistas en una jerarqua de vistas:

Guardar los punteros a las vistas relevantes en un lugar apropiado, como en el

controlador de vista que pertenece a la vista.
Asigne un nmero entero nico para cada propiedad tag de la vista y utilizar el
mtodo viewWithTag para localizarlo.

Trasladando, escalando, rotando vistas

Cada vista tiene asociada una transformacin afn que se puede utilizar para trasladar,
escalar o rotar el contenido de la vista. La transformacin de la vista altera la apariencia
final renderizada de la vista y con frecuencia se utiliza para implementar el
desplazamiento, las animaciones y otros efectos visuales.
La propiedad transform de UIView contiene una estructura CGAffineTransform con las
transformaciones a aplicar. De forma predeterminada, esta propiedad se establece en la
transformacin de la identidad, que no modifica el aspecto de la vista. Puede asignar una
nueva transformacin a esta propiedad en cualquier momento. Por ejemplo, para girar
una vista de 45 grados, podra utilizar el siguiente cdigo:
/ / M_PI/4.0 es un cuarto de un crculo medio, o 45 grados.
CGAffineTransform xform = CGAffineTransformMakeRotation (M_PI/4.0);
self.view.transform = xform;
Aplicando la transformacin en el cdigo anterior a una vista la girara en sentido horario
92

alrededor de su punto central. La Figura siguiente muestra cmo esta transformacin se

vera si se aplicara a una imagen de la vista incrustada en una aplicacin.

Conversin de Coordenadas de la jerarqua de la vista

En varias ocasiones, sobre todo cuando se manejan eventos, una aplicacin puede
necesitar convertir los valores de las coordenadas de un sistema de referencia a otro. Por
ejemplo, los eventos de tacto reportan la ubicacin de cada contacto en el sistema de
coordenadas de la ventana, pero los objetos de vista a menudo necesitan esa informacin
en el sistema de coordenadas de la vista local.
La clase UIView define los siguientes mtodos para la conversin de coordenadas a el
sistema de coordenadas local:
convertPoint: fromView:
convertRect: fromView:
convertPoint: toView:
convertRect: toView:
Ajustar el tamao y la posicin de una vista en tiempo de ejecucin

Siempre que el tamao de una vista cambie, el tamao y la posicin de sus subvistas
debe cambiar en consecuencia. La clase UIView admite la disposicin automtica y
manual de las vistas en una jerarqua de vistas. Con la disposicin automtica, se
establecen las reglas que debe seguir cada vista cuando cambia el tamao de su vista
padre. Con diseo manual, se ajustar manualmente el tamao y la posicin de las vistas
cuando sea necesario.
Estar preparado para los cambios de diseo
Los cambios de disposicin pueden ocurrir cuando cualquiera de los siguientes eventos
ocurren en una vista:

El tamao de las dimensiones del rectngulo de la vista cambian.

Ocurre un cambio de la orientacin del interfaz, que por lo general provoca un
cambio de las dimensiones del rectngulo de la vista raz.
El conjunto de subcapas Core Animation asociadas con la vista cambia y requiere
nueva disposicin.
93

La aplicacin fuerza que se produzca un cambio de disposicin al llamar a los

mtodos layoutIfNeeded setNeedsLayout de una vista.
La aplicacin obliga a una nueva disposicin llamando al mtodo setNeedsLayout
del objeto vista de la capa subyacente.

Manejo de los cambios de disposicin utilizando las reglas de auto ajuste

Cuando se cambia el tamao de una vista, la posicin y el tamao de las subvistas
embebidas normalmente necesita cambiar para tener en cuenta el nuevo tamao de su
vista padre. La propiedad de autoresizesSubviews de la vista padre determina si cambia
el tamao del subvistas de manera automtica. Si esta propiedad se establece en YES, la
vista utiliza la propiedad autoresizingMask de cada subvista para determinar la forma, el
tamao y la posicin de la subvista.
Para cada vista de la jerarqua de vistas, el establecimiento de esa propiedad
autoresizingMask en un valor adecuado es una parte importante del manejo de los
cambios automticos de diseo.
La Tabla siguiente enumera las opciones de cambio de tamao automtico que se pueden
aplicar a una vista determinada y se describen sus efectos durante las operaciones de
diseo.
Propiedad

Definicin

UIViewAutoresizingNone

La vista no se auto dimensiona

UIViewAutoresizingFlexibleHeight

Altura de la vista cambia cuando cambia la

altura de la vista padre. Si esta constante no
se incluye, la altura de la vista no cambia.

UIViewAutoresizingFlexibleWidth

La vista cambia el ancho cuando cambia el

ancho de la vista padre . Si esta constante no
est incluido, el ancho de la vista no cambia.

UIViewAutoresizingFlexibleLeftMargin

La distancia entre el borde izquierdo de la

vista y el borde izquierdo del vista padre crece
o disminuye segn sea necesario. Si esta
constante no se incluye, con el borde
izquierdo de la vista se mantiene una
distancia fija desde el borde izquierdo de la
vista padre.

UIViewAutoresizingFlexibleRightMargin

La distancia entre el borde derecho de la vista

y el borde derecho de la vista padre crece o
disminuye segn sea necesario. Si esta
constante no est incluida, el borde derecho
de la vista se mantiene a una distancia fija
desde el borde derecho de la vista padre.

UIViewAutoresizingFlexibleBottomMargin La distancia entre el borde inferior de la vista y

el borde inferior de la vista padre aumenta o
disminuye segn sea necesario. Si esta
constante no est incluida, el borde inferior de
94

la vista sigue siendo una distancia fija desde

el borde inferior de la vista padre.
UIViewAutoresizingFlexibleTopMargin

La distancia entre el borde superior de la vista

y el borde superior de la vista padre crece o
disminuye segn sea necesario. Si esta
constante no est incluida, el borde superior
de la vista se mantiene una distancia fija
desde el borde superior de la vista padre.

La figura siguiente muestra como se aplican las propiedades que hemos visto en la tabla.

Optimizando las disposiciones de las vistas manualmente

Cada vez que el tamao de una vista cambia, UIKit aplica automticamente las
dimensiones de las vistas y subvistas llamando al mtodo layoutSubviews de la vista para
poder hacer cambios manuales. Se podra implementar el mtodo layoutSubviews en
vistas personalizadas cuando el dimensionamiento y la disposicin automtica de estas
por s mismas no producen los resultados deseados.
Modificacin de vistas en tiempo de ejecucin

Las aplicaciones al recibir un input del usuario ajustan su interfaz en respuesta a dicha
entrada. Una aplicacin puede modificar sus vistas para reorganizar, modificar su tamao
o posicin, ocultando o mostrndolas, o cargando un nuevo conjunto de vistas. En las
aplicaciones de iOS, hay varios lugares y formas en que se realizan estos tipos de
acciones:
En un controlador de vista:

Un controlador de vista tiene que crear sus vistas antes de mostrarlas. Puede
cargar los puntos de vista de un archivo nib o crearlas mediante programacin.
95

Cuando las vistas ya no son necesarias, las descarga.

Cuando cambia un dispositivo de orientacin, un controlador de vista puede ajustar
el tamao y la posicin de sus vistas para que encajen. Como parte de su
adaptacin a la nueva orientacin, puede ocultar algunas vistas y ensear otras.
Cuando un controlador de vista administra contenido editable, puede ajustar su
jerarqua de vistas para adaptarse al modo edicin. Por ejemplo, puede aadir
botones adicionales y otros controles para facilitar la edicin de diversos aspectos
de su contenido. Esto tambin puede requerir el cambio de tamao de las vistas
existentes para acomodar los controles adicionales.

En los bloques de animacin:

Cuando se requiera hacer una transicin entre diferentes conjuntos vista en la

interfaz de usuario, ocultar algunas y mostrar otras en un bloque de animacin.
Al aplicar efectos especiales, se puede utilizar un bloque de animacin para
modificar varias propiedades de la vista. Por ejemplo, para animar los cambios en
el tamao de una vista, tendra que cambiar el tamao del borde de su rectngulo.

Otras formas:

Cuando los eventos tctiles y de gesto se producen, su interfaz podra responder

mediante la carga de un nuevo conjunto de vistas o cambiar el sistema actual de
vistas.
Cuando el usuario interacta con una barra de desplazamiento en una vista, un
rea de desplazamiento grande puede ocultar y mostrar subvistas.
Cuando aparece el teclado, es posible cambiar la posicin o el tamao de vistas a
fin de que no se encuentran bajo el teclado

Si se implementa soporte para la edicin de contenido de una vista, el mtodo setEditing

de UIViewController le da la posibilidad de hacer la transicin de vistas desde sus
versiones editables.
Los Bloques de animacin son otro lugar comn para iniciar la vista de los cambios
relacionados. La ayuda de la animacin integrada en la clase UIView hace que sea fcil
animar los cambios en las propiedades de las vistas. Tambin se puede utilizar los
mtodos
transitionWithView:duration:options:animations:completion:
o
transitionFromView:toView:duration:options:completion: para sustituir vistas por otro
conjunto de vistas.
Interaccin con las capas Core Animation

Cada objeto vista tiene una capa dedicada de Core Animation que gestiona la
presentacin y animacin del contenido de la vista en la pantalla. Aunque se puede hacer
muchas cosas con los objetos de la vista, tambin se puede trabajar directamente con los
objetos de la capa correspondiente cuando sea necesario. El objeto capa de la vista se
almacena en la propiedad capa de la vista.
Cambio de la Clase Capa asociada a una vista

96

El tipo de capa asociada a una vista no se puede cambiar despus de que la vista se
crea. Por lo tanto, cada vista se utiliza el mtodo de la clase layerClass para especificar la
clase de su objeto capa. La implementacin predeterminada de este mtodo devuelve la
clase CALayer y la nica manera de cambiar este valor es reemplazar el mtodo y
devolver un valor diferente. Es posible que desee cambiar este valor en los siguientes
casos:

La aplicacin utiliza OpenGL ES para el dibujo, en cuyo caso, la capa debe ser una
instancia de la clase CAEAGLLayer.
Su vista utiliza mosaico para ver una zona desplazable ms grande, en cuyo caso
es posible que desee utilizar la clase CATiledLayer.

La implementacin del mtodo layerClass simplemente debe crear el objeto Class

deseado y devolverlo. Por ejemplo, una vista compatible con el dibujo mediante OpenGL
ES tendra la siguiente implementacin del mtodo:
+ (Clase) layerClass
{
retorno [clase CAEAGLLayer];
}
Cada vista llama a su mtodo layerClass al inicio de su proceso de inicializacin y utiliza
la clase devuelta para crear el objeto de la capa. Adems, la vista siempre se asigna
como delegado de su objeto capa. En este punto, la vista es propietaria de su capa y la
relacin entre la vista y la capa no debe cambiar. No se debe asignar la misma vista como
delegada de otr0 objeto capa. Cambiar las relaciones de propiedad o delegacin de la
vista puede causar problemas de dibujo y accidentes potenciales en la aplicacin.
Incorporacin de objetos de la capa en una vista
Si fuera preferible trabajar principalmente con objetos de capa en lugar de vistas, se
podran incorporar objetos de capa personalizados en la jerarqua de vista segn fuera
necesario. Un objeto de capa personalizado es cualquier instancia de CALayer que no
sea propiedad de una vista. Por lo general, se crearn capas personalizadas mediante
programacin y se incorporarn utilizando las rutinas de Core Animation. Las capas
personalizadas no reciben eventos o participan en la respuesta, pero se dibujan y
responden a los cambios de tamao en su vista padre o la capa de acuerdo con las reglas
bsicas de animacin.
El cdigo siguiente muestra un ejemplo del mtodo viewDidLoad de un controlador de
vista que crea un objeto de capa personalizado y lo aade a su vista raz. La capa se
utiliza para mostrar una imagen esttica que est animada. En lugar de aadir la capa a la
vista en s, la agrega a la capa subyacente de la vista.
- (void)viewDidLoad {
[super viewDidLoad];
// Create the layer.
CALayer* myLayer = [[CALayer alloc] init];
97

// Set the contents of the layer to a fixed image. And set

// the size of the layer to match the image size.
UIImage layerContents = [[UIImage imageNamed:@"myImage"] retain];
CGSize imageSize = layerContents.size;
myLayer.bounds = CGRectMake(0, 0, imageSize.width, imageSize.height);
myLayer = layerContents.CGImage;
// Add the layer to the view.
CALayer* viewLayer = self.view.layer;
[viewLayer addSublayer:myLayer];
// Center the layer in the view.
CGRect
viewBounds = backingView.bounds;
myLayer.position = CGPointMake(CGRectGetMidX(viewBounds),
CGRectGetMidY(viewBounds));
// Release the layer, since it is retained by the view's layer
[myLayer release];
}
Definir una vista personalizada

Si el sistema de vistas estndar no hace exactamente lo que se necesita en la aplicacin,

se pueden definir vistas personalizada. Las vistas personalizadas dan un control total
sobre el aspecto del contenido de la aplicacin y de las interacciones con los contenidos
que se manejan.
Lista de verificacin para la aplicacin de una vista personalizada
El trabajo de una vista personalizada es presentar contenidos y gestionar las
interacciones de ese contenido. La implementacin con xito de una vista personalizada
implica algo ms que el dibujo y la gestin de eventos. La siguiente lista incluye los
mtodos ms importantes que se pueden sobre-escribir (y comportamientos que pueden
proporcionar) al aplicar una vista personalizada:
1. Definir los mtodos de inicializacin adecuadas para la vista:
Para las vistas que planea crear mediante programacin, sobre-escribir el
mtodo initWithFrame: o definir un mtodo de inicializacin personalizado.
Para las vistas que cargar desde archivos nib, sobre-escribir el mtodo
initWithCoder: mtodo. Utilizar este mtodo para inicializar la vista y
establecerla en un estado apropiado.
Implementar un mtodo dealloc para manejar la limpieza de los datos
personalizados.
Para manejar cualquier dibujo personalizado, sobre-escribir el mtodo drawRect: y
hacer el dibujo all.
Establecer la propiedad autoresizingMask de la vista para definir su
comportamiento automtico.
Si la clase de vista maneja una o varias subvistas, habr que realizar lo siguiente:
Crear las subvistas durante la secuencia de inicializacin de la vista.
Establecer la propiedad autoresizingMask de cada subvista durante la
creacin.

2.
3.
4.
5.

98

Si las subvistas requieren diseo personalizado, sobre-escribir el mtodo

layoutSubviews e implementar su cdigo de diseo all.

6. Para manejar los eventos tctiles, haga lo siguiente:

Adjuntar cualquier reconocedores de gesto adecuados a la vista mediante el

mtodo addGestureRecognizer:.
Para situaciones en las que desea procesar los tactos o toques, sobreescribir los mtodos touchesBegan: withEvent:, touchesMoved: withEvent:,
touchesEnded: withEvent: y touchesCancelled: withEvent:. (Recordar que
siempre debe sobre-escribir los mtodos touchesCancelled: withEvent:
mtodo, independientemente de que otros mtodos de reconocimiento de
gestos se reemplacen.)

Inicializar la vista personalizada

Cada objeto de vista nuevo a definir debe incluir un mtodo inicializador initWithFrame.
Este mtodo es el responsable de iniciar la clase en tiempo de creacin y poner al objeto
vista en un estado conocido. Este mtodo se utiliza cuando se crean instancias de la vista
mediante programacin.
El cdigo siguiente muestra una implementacin del esqueleto de un mtodo estndar
initWithFrame. Este mtodo llama a la implementacin heredada del mtodo padre y
luego inicializa las variables de instancia y la informacin del estado de la clase antes de
devolver el objeto inicializado.
// Initializing a view subclass
- (id)initWithFrame:(CGRect)aRect {
self = [super initWithFrame:aRect];
if (self) {
// setup the initial properties of the view
...
}
return self;
}
Si se van a cargar las instancias de la clase de vista de un fichero nib, debemos ser
conscientes de que en iOS, el cdigo de carga nib no utiliza el mtodo initWithFrame:
para instanciar nuevos objetos de la vista. En su lugar, se utiliza el mtodo initWithCoder:
que es parte del protocolo de NSCoding.
Implementar el cdigo de dibujo
Para las vistas que tiene que realizar un dibujo personalizado, se debe reemplazar el
mtodo drawRect: y hacer el dibujo all. El dibujo personalizado se recomienda slo como
ltimo recurso. En general, si se pueden utilizar otras vistas para presentar su contenido s
mejor.
La implementacin del mtodo drawRect: debe hacerse exactamente una cosa: el dibujo
del contenido. Este mtodo no es el lugar para estar actualizando las estructuras de datos
99

de la aplicacin o la realizacin de las tareas no relacionadas con el dibujo. Se debe

configurar el entorno de dibujo, dibujar su contenido, y salir lo ms rpido posible.
Antes de llamar al mtodo drawRect de la vista, UIKit configura el entorno de dibujo
bsico para la vista. Especficamente, se crea un contexto de grficos y ajusta el sistema
de coordenadas y la zona de recorte para que coincida con el sistema de coordenadas y
lmites visibles de la vista. Por lo tanto, en el momento de la llamada al mtodo drawRect,
se puede empezar a dibujar el contenido con tecnologas nativas de dibujo como UIKit y
Core Graphics. Se obtiene un puntero al contexto grfico actual con la funcin
UIGraphicsGetCurrentContext.
El cdigo siguiente muestra una implementacin simple de un mtodo drawRect: que
dibuja un borde rojo de 10 pxeles de ancho alrededor de la vista. Dado que las
operaciones de dibujo utilizan UIKit Core Graphics para sus implementaciones
subyacentes, se pueden mezclar llamadas de dibujo, como se muestra aqu, para obtener
los resultados que se esperan.
- (void)drawRect:(CGRect)rect {
CGContextRef context = UIGraphicsGetCurrentContext();
CGRect myFrame = self.bounds;
// Set the line width to 10 and inset the rectangle by
// 5 pixels on all sides to compensate for the wider line.
CGContextSetLineWidth(context, 10);
CGRectInset(myFrame, 5, 5);
[[UIColor redColor] set];
UIRectFrame(myFrame);
Responder a eventos
los objetos vista son objetos-respondedores (instancias de la clase UIResponder) y son
por lo tanto capaces de recibir eventos de tacto. Cuando se produce un evento de
contacto, la ventana distribuye los correspondientes objetos eventos correspondientes a
la vista en la que se produjo el contacto. Si su vista no est interesado en ese evento,
puede ignorarlo o pasarlo por la cadena de respuesta para ser manejado por un objeto
diferente.
Adems de manejar los eventos de toque directamente, las vistas tambin pueden utilizar
reconocedores gesto para detectar toques, barridos, pellizcos, y otros tipos de gestos
relacionadas con el tacto. Los reconocedores de gestos hacer el trabajo duro de rastrear
eventos de toque y de asegurarse de que siguen los criterios correctos para calificarlos
como un gesto de destino. En vez de que la aplicacin tenga que rastrear eventos de
toque, se puede crear el reconocedor de movimientos, a medida, asignando un objeto de
destino y un mtodo de accin adecuado a la misma, e instalndolo en la vista con el
mtodo addGestureRecognizer:. El reconocedor de movimientos a continuacin, llama a
su mtodo de accin cuando se produce el gesto correspondiente.
Si se prefiere manejar eventos de toque directamente, se deben implementar los mtodos
siguientes:
100

touchesBegan: withEvent:
touchesMoved: withEvent:
touchesEnded: withEvent:
touchesCancelled: withEvent:
Liberacin de vistas
Si la clase de vista asigna alguna memoria, almacena referencias a objetos
personalizados, o mantienen recursos que deben ser liberados cuando la vista se libera,
se debe implementar el mtodo dealloc. El sistema llama al mtodo dealloc cuando su
contador de vista llega a cero y es el momento de liberarla. La implementacin de este
mtodo debe liberar todos los objetos o recursos en poder de la vista y luego llamar a la
implementacin heredada, como se muestra en el cdigo siguiente.
No se debe usar este mtodo para realizar cualquier otro tipo de tareas.
- (void)dealloc {
// Release a retained UIColor object
[color release];
// Call the inherited implementation
[super dealloc];
}

Animaciones
Las animaciones fluidas proporciona transiciones visuales entre los diferentes estados de
la interfaz de usuario. En iOS, las animaciones se utilizan ampliamente para cambiar la
posicin de las vistas, cambiar su tamao, eliminar las jerarquas de vista, y ocultarlas. Se
pueden usar animaciones para transmitir informacin al usuario o para implementar
interesantes efectos visuales.
En iOS, para la creacin de animaciones sofisticadas, no es necesario escribir ningn
cdigo de dibujo. Para todas las tcnicas de animacin descritas a continuacin se utiliza
el soporte integrado proporcionado por Core Animation. Todo lo que hay que hacer es
activar la animacin y dejar que Core Animation maneje el procesamiento de los
fotogramas individuales. Esto permite que la creacin de animaciones sofisticadas se
muy sencilla, con slo unas pocas lneas de cdigo.
Qu puede animarse?
Tanto UIKit y Core Animation proporcionan apoyo a las animaciones, el nivel de soporte
vara en cada tecnologa. En UIKit, las animaciones se realizan con objetos UIView. Las
vistas soportan un conjunto bsico de animaciones que cubren muchas de las tareas
comunes. Por ejemplo, se puede animar los cambios a las propiedades de las vistas o
usar animaciones de transicin para sustituir a un conjunto de vistas con otras.
La Tabla siguiente enumera las propiedades animables que incorporan la animacin de
apoyo de la clase UIView. Ser animable no significa que las animaciones sucedan
automticamente. Cambiar el valor de los propiedades de una vista normalmente slo
actualiza la propiedad (y la vista) inmediatamente sin una animacin. Para ejecutar una
animacin, debe cambiar el valor de la propiedad desde el interior de un bloque de
101

animacin.
Propiedad

Cambios que se pueden hacer

frame

Modificar esta propiedad para cambiar el tamao de la vista y

posicin relativa al sistema de coordenadas de su supervista.

bounds

Modificar esta propiedad para cambiar el tamao de la vista.

centre

Modificar esta propiedad para cambiar la posicin relativa al sistema

de coordenadas de su supervista de la vista.

transform

Modificar esta propiedad para escalar, rotar o convertir la vista en

relacin a su punto central. Transformaciones que usan esta
propiedad siempre se realizan en el espacio 2D. (Para realizar
transformaciones 3D, debe animar objetos de la vista capa con Core
Animation.)

alpha

Modificar esta propiedad

transparencia de la vista.

para

cambiar

gradualmente

la

backgroundcolor Modificar esta propiedad para cambiar el color de fondo de la vista.

contentStrech

Modificar esta propiedad para cambiar la forma en contenido de la

vista se extenda para llenar el espacio disponible.

Las transiciones animadas de vistas son una manera de hacer cambios en la jerarqua de
vistas ms all de las ofrecidas por los controladores de vista. Aunque se deben utilizar
controladores de vista para administrar jerarquas de vistas, puede haber ocasiones en las
que desea reemplazar todo o parte de una jerarqua de vistas. En esos casos, puede
utilizar la vista a base de transiciones para animar la adicin y eliminacin de vistas.

Animacin de Cambios en las propiedades de una vista

Con el fin de animar a los cambios en una propiedad de la clase UIView, se debe ajustar
los cambios en el interior de un bloque de animacin. El trmino bloque de animacin se
utiliza en el sentido genrico para referirse a cualquier cdigo que asigne cambios
animados. En iOS 4 y posteriores, se crean bloques de animacin con objetos bloque. En
versiones anteriores de iOS, se marca el comienzo y el final de un bloque de animacin
utilizando mtodos especiales de clase de la clase UIView. Ambas tcnicas son
compatibles con las mismas opciones de configuracin y ofrecen la misma cantidad de
controles sobre la ejecucin de la animacin. Sin embargo es referible usar los mtodos
basados en bloques siempre que sea posible.
En las secciones siguientes se centran en el cdigo que necesita con el fin de animar los
cambios para ver las propiedades.
Realizar animaciones utilizando el mtodo basado en bloques
En iOS 4 y posteriores, se utilizan los mtodos de la clase basadas en bloques para iniciar
la animacin. Hay varios mtodos basados en bloques que ofrecen distintos niveles de
configuracin para el bloque de animacin. Estos mtodos son:

102

animateWithDuration:animations:
animateWithDuration:animations:completion:
animateWithDuration:delay:options:animations:completion:
Debido a que son mtodos de clase, los bloques de animacin creados no estn
vinculados a una nica vista. Por lo tanto, se pueden utilizar estos mtodos para crear una
animacin simple que involucra cambios en mltiples vistas. Por ejemplo, el cdigo
siguiente muestra el cdigo necesario para una animacin con desvanecimiento en una
sola vista, y otro desvanecimiento durante un perodo de tiempo de un segundo. Cuando
se ejecuta este cdigo, las animaciones especficas se inician inmediatamente en otro
hilo, para evitar bloquear el subproceso actual o el hilo principal de la aplicacin.
[UIView animateWithDuration:1.0 animations:^{
firstView.alpha = 0.0;
secondView.alpha = 1.0;
}];
El cdigo siguiente muestra un ejemplo de un bloque de animacin que utiliza un
controlador de finalizacin para iniciar una nueva animacin despus de que uno de los
primeros haya acabado. La primera llamada a
animateWithDuration:delay:options:animations:completion:
crea una animacin fade-out y lo configura con algunas opciones de personalizacin.
Cuando la animacin se ha completado, su controlador de finalizacin ejecuta y configura
la segunda mitad de la animacin, que se desvanece de la vista de nuevo despus de un
retraso.
El uso de un controlador de finalizacin es la principal forma en que se vincula varias
animaciones.
- (IBAction)showHideView:(id)sender
{
// Fade out the view right away
[UIView animateWithDuration:1.0
delay: 0.0
options: UIViewAnimationOptionCurveEaseIn
animations:^{
thirdView.alpha = 0.0;
}
completion:^(BOOL finished){
// Wait one second and then fade in the view
[UIView animateWithDuration:1.0
delay: 1.0
options:UIViewAnimationOptionCurveEaseOut
animations:^{
thirdView.alpha = 1.0;
}
completion:nil];
}];
103

}
Si se realizan animaciones con IOS 3.2 o anterior se debera usar el mtodo
Begin/Commit.
Animaciones en las transiciones entre vistas
Transiciones entre vistas ayudan a ocultar los cambios bruscos asociados a la inclusin,
supresin, ocultacin, o mostrar vistas en la jerarqua de vistas. Utilizar transiciones de
vista para implementar los siguientes tipos de cambios:

Cambiar las subvistas visibles de una vista existente. Por lo general, seleccione
esta opcin si se desean realizar cambios relativamente pequeos a una vista
existente.
Reemplazar una vista con otra en nuestra jerarqua de vistas con una perspectiva
diferente. Por lo general, seleccione esta opcin si se desea reemplazar una
jerarqua de vistas que abarcan la totalidad o la mayor parte de la pantalla.

Cambiar las subvista de una vista-controlador

Cambiar las subvistas de una vista permite hacer cambios moderados a la vista. Por
ejemplo, se pueden agregar o quitar subvistas para cambiar la vista padre entre dos
estados diferentes.
En iOS 4 o posterior, se utiliza el mtodo
ttransitionWithView:duration:options:animations:completion:
para iniciar una animacin de transicin para una vista. En los bloques de animaciones
pasados a este mtodo los nicos cambios que normalmente son animados son los
asociados a mostrar, ocultar, agregar o quitar subvistas.
El cdigo siguiente es un ejemplo de cmo utilizar una animacin de transicin para hacer
que parezca como si una pgina de introduccin de texto nuevo ha sido aadida. En este
ejemplo, la vista principal contiene dos vistas de texto incrustadas. Las vistas de texto
estn configuradas de forma idntica, pero una es siempre visible mientras que la otra
est siempre escondida. Cuando el usuario pulsa el botn para crear una nueva pgina,
este mtodo cambia la visibilidad de los dos puntos de vista.
- (IBAction)displayNewPage:(id)sender
{
[UIView transitionWithView:self.view
duration:1.0
options:UIViewAnimationOptionTransitionCurlUp
animations:^{
currentTextView.hidden = YES;
swapTextView.hidden = NO;
}
completion:^(BOOL finished){
// Save the old text and then swap the views.
[self saveNotes:temp];
104

UIView* temp = currentTextView;

currentTextView = swapTextView;
swapTextView = temp;
}];
}
Reemplazar una vista con otra diferente
La sustitucin de vistas es algo que se hace cuando se quiere que la interfaz sea
totalmente diferente. Debido a que esta tcnica slo cambia vistas el programador es
responsable del diseo de los objetos de la aplicacin del controlador adecuadamente.
Esta tcnica es simplemente una manera de presentar nuevas vistas rpidamente
utilizando algunas transiciones estndar.
En iOS 4 o posterior, utilice el mtodo de transicin entre dos vistas
transitionFromView:toView:duration:options:completion: Este mtodo en realidad elimina
la vista previa de su jerarqua e inserta otra, por lo que debe asegurarse de que tiene una
referencia a la primera vista si desea mantenerla. Si desea ocultar puntos de vista en
lugar
de
eliminarlos
de
su
jerarqua
de
la
vista,
pase
UIViewAnimationOptionShowHideTransitionViews como una de las opciones.
El cdigo siguiente muestra el cdigo necesario para alternar entre dos vistas principales
gestionadas por un controlador de vista nico. En este ejemplo, la opinin del controlador
de vista de la raz siempre muestra uno de los dos puntos de vista del nio (o
primaryView secondaryView). Cada vista presenta el mismo contenido pero lo hace de
una manera diferente.
- (IBAction)toggleMainViews:(id)sender {
[UIView transitionFromView:(displayingPrimary ? primaryView : secondaryView)
toView:(displayingPrimary ? secondaryView : primaryView)
duration:1.0
options:(displayingPrimary ? UIViewAnimationOptionTransitionFlipFromRight :
UIViewAnimationOptionTransitionFlipFromLeft)
completion:^(BOOL finished) {
if (finished) {
displayingPrimary = !displayingPrimary;
}
}];
}

105

Eventos
Acerca de los eventos en iOS
Los usuarios manipulan sus dispositivos iOS de muchas maneras, tocando la pantalla o
agitando el dispositivo. iOS interpreta cundo y cmo el usuario manipula el hardware y
pasa esta informacin a la aplicacin. Si la aplicacin responde a las acciones en forma
natural e intuitiva, la experiencia para el usuario ser muy satisfactoria.
UIKit hace ms fcil para la aplicacin la deteccin de gestos
Las aplicaciones iOS reconocen combinaciones de toques y responden a ellas de manera
que sean intuitivas para los usuarios, como hacer zoom sobre el contenido en respuesta a
un gesto de pellizco y el desplazamiento por el contenido en respuesta a un gesto de
arrastrar. De hecho, algunos gestos son tan comunes que estn integradas en UIKit.
Por ejemplo, las subclases uicontrol, tales como UIButton y UISlider, responden a gestos
especficos un toque en un botn y un arrastre para ua barra de desplazamiento. Al
configurar estos controles, se enva un mensaje de accin a un objeto de destino cuando
ese contacto se produce. Tambin puede utilizar el mecanismo Target-Action en vistas
utilizando reconocedores gesto. Cuando se conecta un reconocedor de movimientos a
una vista, toda la vista acta como un control de la respuesta a cualquier gesto que
especifique.
Reconocedores de gestos proporcionan una abstraccin de alto nivel a la lgica compleja
de la gestin de eventos. Reconocedores de gestos son la mejor forma de poner en
prctica el control de eventos tctil en la aplicacin porque los reconocedores gesto son
muy potentes, reutilizables y adaptables. Se puede utilizar uno de los reconocedores de
gesto integrados y personalizar su comportamiento. O se puede crear su propio
reconocedor de movimientos para reconocer un nuevo gesto.

106

Reconocedores de gestos
Son objetos que se conectan a una vista y que permiten que las vitas respondan a las
acciones de la manera que el control se haya definido. Los reconocedores de gestos
interpretan los toques para determinar si corresponden a un gesto especfico, como un
golpe, un pellizco o una rotacin. Si reconocen el gesto asignado, se enva un mensaje de
accin a un objeto de destino. El objeto de destino es tpicamente controlador de la vista,
que responde al gesto como se muestra en la Figura siguiente. Este patrn de diseo es a
la vez potente y simple, se pueden determinar dinmicamente las acciones a las que una
vista responde, se pueden aadir reconocedores gesto a una vista sin tener que hacer
una subclase de la vista.

Utilice reconocedores gesto para simplificar el control de eventos

El framework proporciona UIKit reconocedores gesto predefinidos que detectan gestos
comunes. Lo mejor es utilizar un reconocedor de movimientos predefinidos cuando sea
posible, ya que su simplicidad reduce la cantidad de cdigo que tiene que escribir.
Adems, utilizando un reconocedor de movimientos estndar en lugar de escribir uno
propio asegura que su aplicacin se comporte de la forma en que los usuarios esperan.
Si desea que su aplicacin reconozca un gesto nico, como una marca o un movimiento
oscilante, se puede crear su propio reconocedor de gestos personalizado.
Para aprender cmo disear e implementar un reconocedor de gestos a medida, consultar
"Creacin de un reconocedor de movimientos personalizada".

107

Reconocedor de gestos comn

Al disear la aplicacin, puede considerar qu gestos que se desea habilitar. Entonces,
para cada gesto, determinar si uno de los reconocedores gesto predefinido en la Tabla
siguiente es suficiente.
Gesto
Pulsacin
Pinchazos de entrada y salida
(para el zoom de una vista)
Desplazamiento o arrastrando
Deslizar (en cualquier direccin)
Rotacin (los dedos se mueven en
direcciones opuestas)
Pulsacin larga (tambin conocido
como "tocar y mantener")

Clase de UIKit
UITapGestureRecognizer
UIPinchGestureRecognizer
UIPanGestureRecognizer
UISwipeGestureRecognizer
UIRotationGestureRecognizer
UILongPressGestureRecognizer

Los reconocedores gesto se asocian a una vista

Cada reconocedor de movimiento est asociado con una sola vista. Por el contrario, una
vista puede tener mltiples reconocedores gesto, porque una sola vista podra responder
a muchas diferentes gestos. Cuando un usuario toca la vista, el reconocedor de
movimientos recibe un mensaje de que se produjo un contacto. Como resultado, el
reconocedor de movimiento puede responder a toques en nombre de la vista.
Mensajes de accin
Cuando un reconocedor de movimientos reconoce su gesto especificado, se enva un
mensaje de accin a su objetivo. Para crear un reconocedor de movimientos, lo inicializa
con un objetivo y una accin.
Gestos discretos y continuos
Los gestos pueden ser discretos o continuos. Un gesto discreto, tal como una pulsacin,
se produce una vez. Un gesto continuo, como pellizcos, tiene lugar durante un perodo de
tiempo. Para gestos discretos el reconocedor de movimientos enva un mensaje de una
sola accin a su destino. Un reconocedor de movimientos para los gestos continuos
mantiene el envo de mensajes de accin a su objetivo hasta que la secuencia termina.

108

Responder a los eventos con reconocedores gesto

Hay tres cosas que se pueden hacer para aadir un reconocedor de movimiento a la
aplicacin:

Crear y configurar una instancia de reconocedor de movimientos.

Esta etapa incluye la asignacin de un Target y Action y algunas veces de la
asignacin especfica del gesto-atributos (tales como la numberOfTapsRequired).
Conectar el reconocedor de movimientos a una vista.
Poner en prctica el mtodo de accin que maneja el gesto.

Usando el Interface Builder para agregar un reconocedor de movimientos en una

aplicacin
Dentro de Interface Builder en Xcode, se agrega un reconocedor de movimientos a la
aplicacin de la misma manera que se agrega cualquier objeto al interfaz de usuario
arrastrando el reconocedor de movimientos a partir de la biblioteca de objetos a una vista.
Al hacer esto, el reconocedor de movimientos automticamente se adhiere a esta vista.
Se puede comprobar qu el reconocedor de movimientos se adjunta a la vista, cambiando
la conexin en el archivo nib.
Despus de crear el objeto reconocedor de movimientos, es necesario crear y conectar un
mtodo de accin. Este mtodo se llama cada vez que el reconocedor de movimientos
conectado reconoce el gesto.
Aadir un reconocedor de gestos a la aplicacin conInterface Builder
interface APLGestureRecognizerViewController ()
@property (nonatomic, strong) IBOutlet UITapGestureRecognizer *tapRecognizer;
@end
@implementation
(IBAction)displayGestureForTapRecognizer:(UITapGestureRecognizer
*)recognizer
// Will implement method later...
}
@end
Aadir un reconocedor de gestos a travs de cdigo
Se puede crear un reconocedor de gestos mediante programacin a travs de la
asignacin y la inicializacin de una instancia de una subclase UIGestureRecognizer
concreto, como UIPinchGestureRecognizer. Cuando se inicializa el reconocedor de
gestos, se especifica un objeto de destino y un selector de accin, como en el Listado
siguiente. A menudo, el objeto de destino es el controlador de la vista vista.
- (void)viewDidLoad {
[super viewDidLoad];
// Create and initialize a tap gesture
109

UITapGestureRecognizer *tapRecognizer = [[UITapGestureRecognizer alloc]

initWithTarget:self action:@selector(respondToTapGesture:)];
// Specify that the gesture must be a single tap
tapRecognizer.numberOfTapsRequired = 1;
// Add the tap gesture recognizer to the view
[self.view addGestureRecognizer:tapRecognizer];
// Do any additional setup after loading the view, typically from a nib
}
Respondiendo a los gestos discretos
Al crear un reconocedor de gestos, se conecta el reconocedor a un mtodo de accin.
Utilice este mtodo de accin para responder a su gesto gesto reconocedor. El listado a
continuacin proporciona un ejemplo de la respuesta a un gesto discreto (doble
pulsacin). Cuando el usuario pulsa la vista el gesto reconocido es adjuntado, el
controlador de la vista muestra una vista de la imagen que dice Tapp. El mtodo
showGestureForTapRecognizer: permite determinar la ubicacin del gesto en la vista de a
travs de la propiedad locationInView y luego muestra el imagen en esa ubicacin.
- (IBAction)showGestureForTapRecognizer:(UITapGestureRecognizer *)recognizer
{
// Get the location of the gesture
CGPoint location = [recognizer locationInView:self.view];
// Display an image view at that location
[self drawImageForGestureRecognizer:recognizer atPoint:location];
// Animate the image view so that it fades out
[UIView animateWithDuration:0.5 animations:^{
self.imageView.alpha = 0.0;
}];
}
Definir cmo los reconocedores de gesto interactan
A menudo, a medida que se agregan reconocedores gesto a la aplicacin, se deber
especificar acerca de cmo se desea que los reconocedores interaccionen entre s o
cualquier otro cdigo de control de evento tctil en su aplicacin. Para ello, primero es
necesario entender un poco ms acerca de cmo el trabajo reconocedores gesto.
Las operaciones de reconocimiento de gestos operan en una mquina finita
Las transiciones de los reconocedores de gesto de un estado a otro se realizan en una
manera predefinida. A partir de cada estado, se puede pasar a una de los posibles
estados siguientes en funcin de si se renen ciertas condiciones. La mquina de estado
exacto vara dependiendo de si el reconocedor de movimiento es discreto o continuo,
como se ilustra en la Figura siguiente. Todos los reconocedores de gesto comienzan en el
estado Posible (UIGestureRecognizerStatePossible). Analizan las secuencias multi toque
que reciben, y durante el anlisis o bien reconocen o no un gesto. No reconocer un gesto
significa que las transiciones reconocedor de movimientos tienen el estado Failed
(UIGestureRecognizerStateFailed).

110

Cuando un reconocedor de movimientos discretos reconoce su gesto, las transicin del

reconocedor de gestos pasa de Possible a Recognized
(UIGestureRecognizerStateRecognized) y el reconocimiento es completo.
Para gestos continuos, las transiciones de reconocedor de movimientos pasa de
Possible a Began (UIGestureRecognizerStateBegan) cuando el gesto se reconoce por
primera
vez.
Entonces,
este
cambia
deBegan
a
Changed
(UIGestureRecognizerStateChanged), y contina movindose desde
Changed a
Changed hasta que el gesto termine. Cuando el ltimo dedo del usuario se levanta de la
vista las transiciones del reconocedor de movimientos pasa al estado Ended
(UIGestureRecognizerStateEnded) y el reconocimiento es completo.
Un reconocedor de un gesto continuo tambin puede pasar de Changed a Cancelled
(UIGestureRecognizerStateCancelled) si se decide que el gesto ya no encaja en el patrn
esperado.
Cada vez que un reconocedor de movimientos cambia de estado, el reconocedor de
movimiento enva un mensaje de accin a su Target, a menos que ste pase Error o
Cancelled. As, un reconocedor de movimientos discretos slo enva un mensaje de
accin individual cuando ste pasa de Possible a Recognized. Un reconocedor de
movimiento continuo enva muchos mensajes de accin, ya que cambia de estado.
Cuando un reconocedor de movimientos llega a la Recognized. (o termin) del estado,
se restablece el estado a Possible. La transicin hacia atrs a Possible no provoca un
mensaje de accin.

111

Interactuar con otros controles de la interfaz de usuario

En iOS 6.0 y versiones posteriores, las acciones predeterminadas de control de
comportamiento impiden la acumulacin de comportamientos de gestos.
Por ejemplo, la accin predeterminada de un botn es un solo toque. Si se tiene un
reconocedor de Tap unido a la vista padre de un botn, y el usuario pulsa el botn,
entonces el mtodo del botn de accin recibe el evento tctil en lugar del reconocedor de
movimientos de la vista Esto se aplica slo a reconocimiento de gestos que se
superponen a la accin predeterminada de un control, lo que incluye:

La puncin de un solo dedo en

UIButton, UISwitch, UIStepper,
UISegmentedControl y UIPageControl.
Un golpe solo dedo en una UISlider (Bara de deslizamiento), en una direccin
paralela a la barra.
Un solo dedo gesto pan en una switch UISwitch, en una direccin paralela al
conmutador.
Si usted tiene una subclase personalizada de uno de estos controles y desea
cambiar la accin predeterminada, adjunte un reconocedor de movimientos
directamente al control en lugar de a la vista padre. Luego, el reconocedor de
movimiento recibe el evento de primer toque.

Creacin de un reconocedor de gestos personalizado

Para implementar un reconocedor de movimientos a medida, primero debe crear una
subclase de UIGestureRecognizer en Xcode. A continuacin, agregar la siguiente directiva
de importacin en el archivo de cabecera de la subclase:
# import <UIKit/UIGestureRecognizerSubclass.h>
A
continuacin,
copiar
las
siguientes
declaraciones
de
mtodos
de
UIGestureRecognizerSubclass.h en el archivo de cabecera, que son los mtodos que
reemplazan en la subclase:
- (Void) reset;
- (Void) touchesBegan: (NSSet *) touches withEvent: (UIEvent *) event;
- (Void) touchesMoved: (NSSet *) touches withEvent: (UIEvent *) event;
- (Void) touchesEnded: (NSSet *) touches withEvent: (UIEvent *) event;
- (Void) touchesCancelled: (NSSet *) touches withEvent: (UIEvent *) event;
Estos mtodos tienen la misma firma y el comportamiento exacto que los mtodos de
control de eventos correspondientes al tacto descritos anteriormente. En todos los
mtodos que sobre escriban se, debe llamar a la implementacin de la superclase,
aunque el mtodo tenga aplicacin nula.
Observe que el estado de la propiedad en UIGestureRecognizerSubclass.h ahora de
lectura y escritura en lugar de slo lectura, como lo es en UIGestureRecognizer.h. La
subclase cambia su estado asignando UIGestureRecognizerState constantes a esa
propiedad.
112

Entrega de eventos: La cadena de respuesta

Al disear una aplicacin, es probable que desee para responder a eventos de forma
dinmica. Por ejemplo, un toque puede ocurrir en muchos objetos en pantalla diferentes, y
hay que decidir cul es el objeto que se desea que responda a un determinado evento y
entender cmo ese objeto recibe el evento.
Cuando un evento generado por el usuario se produce, UIKit crea un objeto de evento
que contiene la informacin necesaria para procesar el evento. Luego se coloca el objeto
evento en cola de eventos de la aplicacin activa. Para eventos de toque, ese objeto es
un conjunto de toques envasados en un objeto UIEvent. Para los eventos de movimiento,
el objeto de evento vara en funcin del framework que utiliza y el tipo de evento de
movimiento que se est interesado.
Un evento viaja a lo largo de una ruta especfica hasta que se entrega a un objeto que
puede manejarlo. En primer lugar, el objeto singleton(objeto nico) UIApplication toma el
evento de la parte superior de la cola y lo enva para su manejo. Normalmente, se enva el
evento a la aplicacin objeto al window object, la cual pasa el evento a un objeto inicial
para su manipulacin. El objeto inicial depende del tipo de evento.

Eventos de toque. Para los eventos de toque, el objeto de la primera ventana

intenta entregar el caso a la vista donde se produjo el toque. Este punto de vista se
conoce como el punto de vista hit-test. El proceso de encontrar la vista que es
llamada se denomina hit-testing.
Movimiento y eventos de control remoto. Con estos eventos, el objeto ventana,
enva el movimiento o de eventos de control remoto al First Responder para su
manejo."

El objetivo final de estos caminos de eventos es encontrar un objeto que pueda controlar y
responder a un evento. Por lo tanto, UIKit primero enva el evento al objeto que es el ms
adecuado para controlar el evento. Para los eventos de toque, ese objeto es la vista hittest, y para otros eventos, ese objeto es elFirst Responder.
Los eventos no son los nicos objetos que se basan en la cadena de respuesta. La
cadena de respuesta se utiliza en todos los siguientes:

Touch events. Si la vista hit-test no puede manejar un evento tctil, el evento se

pasa una cadena de respuesta que se inicia con la opinin de hit-test.
Motions Events. Para controlar el movimiento de agitacin en eventos con UIKit,
la primera respuesta debe implementar ya sea el motionBegan: withEvent: o
motionEnded: withEvent: ". Deteccin de movimiento Shake-Eventos con UIEvent"
mtodo de la clase UIResponder, como se describe en
Remote control events. Para controlar eventos de control remoto, la primera
respuesta debe implementar la remoteControlReceivedWithEvent: mtodo de la
clase UIResponder.
Action messages. Cuando el usuario manipula un control, tal como un botn o un
interruptor, y el objetivo para el mtodo de accin es nula, el mensaje se enva a
travs de una cadena de respondedores de partida con la vista de control.
Editing-menu messages. Cuando un usuario toca los comandos del men de
113

edicin, iOS utiliza una cadena de respuesta para encontrar un objeto que
implementa los mtodos necesarios (tales como corte:, copia: y :) pasta. Para
obtener ms informacin, consulte "Visualizacin y Administracin del men Edit" y
el proyecto de cdigo de ejemplo, CopyPasteTile.
Test editing. Cuando un usuario toca un campo de texto o una vista de texto, esa
visin se convierte automticamente en el primer nivel de respuesta. Por defecto, el
teclado virtual y el campo de texto o en la vista texto se convierte en el foco de
edicin. Puede mostrar una vista de entrada personalizado en lugar del teclado si
es apropiado para su aplicacin. Tambin puedes aadir una vista de entrada
personalizado a cualquier objeto que responde. Para obtener ms informacin,
consulte "Vistas personalizadas para la entrada de datos".

UIKit ajusta automticamente el campo de texto o en la vista de texto que un usuario toca
ser el primero en responder; apps debe establecer explcitamente todos los dems
objetos primer nivel de respuesta con el mtodo becomeFirstResponder.

Eventos de movimiento
Los usuarios generan eventos de movimiento cuando se mueven, agitar o inclinan el
dispositivo. Estos eventos de movimiento son detectados por el hardware del dispositivo,
especficamente, el acelermetro y el giroscopio.
El acelermetro se compone realmente de tres acelermetros, uno para cada eje-x, y, y z.
Cada uno mide los cambios en la velocidad en el tiempo a lo largo de una trayectoria
lineal. La combinacin de los tres acelermetros permite detectar el movimiento del
dispositivo en cualquier direccin y obtener orientacin actual del dispositivo. Aunque hay
tres acelermetros, el resto de este documento se refiere a ellos como una sola entidad.
El giroscopio mide la tasa de rotacin alrededor de los tres ejes.
Todos los eventos de movimiento se originan por el mismo hardware. Hay varias maneras
diferentes que se pueda acceder a los datos de hardware, dependiendo de las
necesidades de la aplicacin:

Si se necesita detectar la orientacin general de un dispositivo, pero no es

necesario conocer el vector de orientacin, utilice la clase UIDevice.
Si se desea que la aplicacin responda cuando un usuario mueve el dispositivo,
puede utilizar el manejador de los eventos de movimiento de la clase UIKit.
Si ni el UIDevice ni las clases UIEvent son suficientes, es posible utilizar el
framework Motion Core para acceder al acelermetro, giroscopio, y las clases de
dispositivos de movimiento.

Obtencin de la orientacin del dispositivo actual con UIDevice

Se utilizan los mtodos de la clase UIDevice cuando lo que se necesita saber solamente
es la orientacin general del dispositivo y no en el vector de orientacin exacta. Usando
UIDevice es simple y no requiere que se calcule el vector de orientacin.
Antes de que se pueda obtener la orientacin actual, tiene que instanciar a la clase
UIDevice para comenzar la generacin de notificaciones dispositivo de orientacin
114

llamando al mtodo beginGeneratingDeviceOrientationNotifications. Esto activa el

acelermetro, que puede ser apagado para conservar energa de la batera.
Despus de habilitar las notificaciones de orientacin, se puede obtener la orientacin
actual de la orientacin por la propiedad del objeto UIDevice. Si desea que se le notifique
cuando cambia la orientacin del dispositivo, registrarse para recibir notificaciones
UIDeviceOrientationDidChangeNotification. La orientacin del dispositivo reporta la
utilizacin de constantes UIDeviceOrientation, que indican si el dispositivo est en modo
horizontal, modo vertical, la pantalla hacia arriba, la pantalla hacia abajo, y as
sucesivamente. Estas constantes indican la orientacin fsica del dispositivo y no se
corresponden necesariamente a la orientacin de la interfaz de usuario de su aplicacin.
Cuando ya no es necesario conocer la orientacin del dispositivo, siempre desactivar las
notificaciones
de
orientacin
llamando
al
mtodo
UIDevice,
endGeneratingDeviceOrientationNotifications. Esto le da al sistema la posibilidad de
desactivar el acelermetro hardware si no est siendo utilizado en otros lugares, lo que
ahorra energa de la batera.
Ejemplo:
-(void) viewDidLoad {
// Request to turn on accelerometer and begin receiving accelerometer events
[[UIDevice currentDevice] beginGeneratingDeviceOrientationNotifications];
[[NSNotificationCenter defaultCenter] addObserver:self
selector:@selector(orientationChanged:)
name:UIDeviceOrientationDidChangeNotification object:nil];
}
- (void)orientationChanged:(NSNotification *)notification {
// Respond to changes in device orientation
}
-(void) viewDidDisappear {
// Request to stop receiving accelerometer events and turn off accelerometer
[[NSNotificationCenter defaultCenter] removeObserver:self];
[[UIDevice currentDevice] endGeneratingDeviceOrientationNotifications];
}
Deteccin de movimiento Shake-Eventos con UIEvent
Cuando los usuarios hacen temblar un dispositivo iOS se evalan los datos del
acelermetro. Si los datos cumplen con ciertos criterios, iOS interpreta el gesto
tembloroso y crea un objeto UIEvent para representarla. Despus, enva el objeto de
evento a la aplicacin activa en ese momento para su procesamiento. Hay que tener en
cuenta que la aplicacin puede responder a eventos de movimiento reorganizacin y
cambios de orientacin del dispositivo al mismo tiempo.
Los eventos de movimiento son ms simples que los eventos tctiles. El sistema le dice a
una aplicacin cuando un movimiento se inicia y se detiene, pero no cuando se produce
cada movimiento individual. Y, eventos de movimiento son slo un tipo de evento
(UIEventTypeMotion), subtipo evento (UIEventSubtypeMotionShake) y timestamp.

115

Designar un Firts Responder para eventos de movimiento

Para recibir eventos de movimiento, se designa un objeto que responde como el primer
nivel de respuesta. Este es el objeto de respuesta que desea controlar los eventos de
movimiento. A continuacin se muestra cmo un respondedor puede hacerse la primera
respuesta.
- (BOOL)canBecomeFirstResponder {
return YES;
}
- (void)viewDidAppear:(BOOL)animated {
[self becomeFirstResponder];
}

Eventos de control remoto

Eventos de control remoto permiten a los usuarios controlar elementos multimedia de una
aplicacin. Si la aplicacin reproduce el contenido de audio o vdeo, es posible responder
a los eventos de control remoto que se originan a partir de controles de transporte o
accesorios externos. (Los accesorios externos deben cumplir con las especificaciones
proporcionadas por Apple.) IOS convierte los comandos en objetos UIEvent y entrega los
eventos a la aplicacin. La aplicacin enva el mensaje al First Responder y, si ste no
los maneja, viajan hacia la cadena de respuesta.
En este captulo se describe la forma de recibir y administrar los eventos de control
remoto. Los ejemplos de cdigo estn tomadas de la mezcladora de audio (MixerHost)
Proyecto de cdigo de ejemplo.
Preparacin de la aplicacin de control remoto para Eventos
Para recibir eventos de control remoto, su aplicacin debe hacer tres cosas:

S el primero en responder. El controlador de vista o la vista que presenta el

contenido multimedia debe ser el primero en responder.
Encienda la entrega de eventos de control remoto. La aplicacin debe solicitar
explcitamente para empezar a recibir los eventos de control remoto.
Comenzar a reproducir audio. Su aplicacin debe ser la app "Now Playing".
Replanteado, incluso si la aplicacin es el First Responder y se haya cambiado la
entrega de eventos, la aplicacin no recibe eventos del control remoto hasta que
comience la reproduccin de audio.

Para hacer que sea capaz de convertirse en el First Responder, la vista o el controlador
vista controlador debe reemplazar el mtodo de la clase canBecomeFirstResponder
UIResponder para retornar S. Tambin se debera enviar el mtodo
becomeFirstResponder en un momento apropiado. Por ejemplo, un controlador de vista
podra utilizar el mtodo becomeFirstResponder en un mtodo viewDidAppear, como en
el listado siguiente. Este ejemplo tambin muestra como enciende el controlador de vista
la entrega de eventos de control remoto mediante una llamada al mtodo
beginReceivingRemoteControlEvents de UIApplication.
116

- (void)viewDidAppear:(BOOL)animated {
[super viewDidAppear:animated];
// Turn on remote control event delivery
[[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
// Set itself as the first responder
[self becomeFirstResponder];
}

117

Persistencia de datos
Introduccin
Cuando en una aplicacin de iOS necesitemos almacenar informacin que se conserve
entre una y otra ejecucin de nuestra aplicacin, tendremos ante nosotros las siguientes
opciones:
NSUserDefaults: podemos almacenar simples preferencias de usuario utilizando tipos de
datos como NSString o NSInteger.
Ficheros .plist: son ficheros de tipo XML donde poder almacenar medianas cantidades
de informacin. Esta informacin podra ser objectos serializados y por tanto es una
opcin muy a tener en cuenta en cuando a sencillez y posibilidades.
SQL Lite: es un motor de base de datos que ofrece nuestro dispositivo y sobre el cual
podemos construir modelos completos de datos.
Core Data: es un framework que nos facilita Apple, y que por debajo realmente utiliza
SQL Lite, pero contamos con una serie de herramientas que nos facilita tanto la creacin
del modelo como su gestin posterior desde cdigo. Esta es la opcin que vamos a
abordar en este artculo.
Core Data es una tecnologa para la gestin del modelo de datos de una aplicacin de
Modelo-Vista-Controlador. Est diseado para uso en aplicaciones en las que ya est el
modelo de datos altamente estructurado. Fundamentalmente, Core Data ayuda a guardar
los objetos del modelo (en el sentido del patrn de diseo modelo-vista-controlador) a un
archivo y leer del mismo otra vez. Esto es similar a la gestin de archivos (ver Gua de
Archivos y serializaciones de programacin), pero no los Core ofrece mucho ms que eso.
Entre otras cosas, estas:

Proporciona una infraestructura para la gestin de todos los cambios en los objetos
modelo. Esto da soporte automtico para deshacer y rehacer, y para el
mantenimiento de las relaciones recprocas entre los objetos.
Permite tener slo un subconjunto de los objetos del modelo en memoria en un
momento dado. Esto es especialmente importante en la conservacin de la
memoria iOS donde es crtica.
Utiliza un esquema para describir el objeto del modelo. Se definen las principales
caractersticas de la clase del modelo, incluyendo las relaciones entre ellos en un
editor basado en GUI. Esto proporciona una gran cantidad de funcionalidades
bsicas "de forma gratuita", incluyendo la fijacin de valores predeterminados.
Permite mantener conjuntos disjuntos de las ediciones de los objetos. Esto es til si
se desea, por ejemplo, permitir al usuario hacer cambios en una vista que se puede
desechar sin afectar a los datos que se muestran en otra vista.
Cuenta con una infraestructura de control de versiones del almacn de datos y la
migracin. Esto permite fcilmente actualizar una versin antigua del archivo del
usuario para la versin actual.

118

Core Data se apoya en tres conceptos bsicos:

Managed Object Model: definicin del modelo de datos.

Persistent Storage Coordinator: es el encargado de persistir la informacin.
Managed Object Context: memoria temporal donde poder trabajar antes de
realizar la persistencia.

Si creamos un nuevo proyecto y activamos el check Utilizar Core Data para persistencia,
veremos que en la carpeta Resources de nuestro proyecto hay un fichero con extensin
.xcdatamodel. Este fichero es el encargado de almacenar cul es la estructura de nuestro
modelo de datos.
Para ello, XCode nos ofrece una herramienta visual de modelado de datos donde poder
crear tablas, campos y relaciones entre los mismos.
Los conceptos bsicos del modelo de datos Code Data

Entity: son las tablas de nuestro modelo

Property: equivale a un campo de nuestra tabla. Puede ser: Attribute o
Relationship.
Attribute: es el valor que se almacena en alguna Property de nuestra tabla.
Relationship: es una conexin entre dos Entidades de nuestro modelo de datos.

Core Data est disponible en iOS 3.0 o posterior.

Es necesario aprender a usar los datos bsicos sobre iOS, incluyendo:

Los patrones de diseo y tcnicas fundamentales que son la base de Core Data
Los aspectos bsicos del uso de la herramienta de modelado de datos Xcode
Cmo crear, actualizar y eliminar objetos gestionados por datos bsicos y la forma
de confirmar los cambios en un almacn de datos

El objetivo de este captulo es proporcionar una introduccin prctica a la estructura de

datos bsicos en Core Data y cmo se usa.

Core Data Stack

Stack es el trmino utilizado para describir una coleccin de objetos bsicos del
framework de Core Data que funcionan juntos para modelar objetos y guardar dichos
objetos en un almacn persistente (el archivo donde se almacenan los datos).
Conceptualmente, un almacn persistente es como una base de datos con tablas y
registros. (Uno de los tipos de almacenamiento que puede utilizar con datos bsicos es
SQLite, pero el almacn no tiene por qu ser una base de datos real.)

119

La figura siguiente muestra la ms simple y la ms comn-configuracin del Stack.

Gestin de objetos y contexto de gestin de objetos

Un objeto administrado es una instancia de NSManagedObject o de una subclase de
NSManagedObject. Conceptualmente, se trata de una representacin de objeto de un
registro en una tabla de una base de datos, por lo que es un modelo (en el sentido del
patrn de diseo modelo-vista-controlador) objeto que est gestionado por datos bsicos.
La gestin de objetos representa los datos que operan en la aplicacin por ejemplo, los
departamentos y los empleados en una aplicacin de recursos humanos, las formas, las
reas de texto y grupos en una aplicacin de dibujo, lbumes, artistas, y las pistas de una
aplicacin de gestin de msica. Un objeto administrado siempre se asocia a un contexto
del objeto gestionado.
El contexto del objeto gestionado es una instancia de NSManagedObjectContext. Un
contexto representa un espacio nico objeto, o bloc de notas, en una aplicacin. Su
principal responsabilidad es administrar una coleccin de objetos administrados. Estos
objetos forman un grupo de objetos relacionados con el modelo que representan una vista
internamente consistente de uno o ms almacenes persistentes. El contexto es un objeto
de gran alcance con un papel central en la aplicacin, con las responsabilidades de la
gestin del ciclo de vida para la validacin, mantenimiento de la relacin, y de la gestin
de deshacer/rehacer.
Cuando se crea un nuevo objeto gestionado, se inserta en un contexto. Se buscan los
registros existentes en la base de datos en el contexto como objetos administrados.
(Fetching se analiza con mayor detalle en "Aadiendo Eventos"). Cualquier cambio que se
haga (si la insercin o eliminacin de objetos completos, o la manipulacin de los valores
de propiedad) se guardan en la memoria hasta que realmente se indique la escritura en el
almacn.

120

La Figura siguiente ilustra un contexto del objeto administrado que contiene dos objetos
administrados que corresponden a dos registros en una base de datos externa. En uno de
los objetos, un valor de la propiedad se ha cambiado en la memoria, pero el cambio no se
ha comprometido con la base de datos. Tenga en cuenta que hay dos registros
adicionales en la base de datos para los cuales no existen objetos correspondientes
administrados.

El modelo de objetos administrados

Un modelo de objeto gestionado es una instancia de NSManagedObjectModel. Es la
representacin de un objeto en el esquema que describe la base de datos, y de los
objetos administrados que utiliza en la aplicacin. Un modelo es una coleccin de
entidades que describen objetos (instancias de NSEntityDescription). Una descripcin de
la entidad describe una entidad (una tabla en la base de datos) en trminos de su nombre,
el nombre de la clase que se utiliza para representar a la entidad en su aplicacin, y qu
propiedades (atributos y relaciones) tiene.
La Figura siguiente ilustra la relacin entre la descripcin de la entidad y un modelo, una
tabla en la base de datos y un objeto administrado que corresponde a un solo registro de
la tabla.

Core Data utiliza el modelo de la asignacin entre objetos gestionados en su aplicacin y

los registros en la base de datos. Es importante tener en cuenta que si cambia el
esquema en su solicitud, de datos bsicos no ser capaz de leer los almacenes creados
usando el modelo anterior. (Esto es algo comn a muchos mecanismos de persistencia.
Datos bsicos, sin embargo, lo es tambin proporcionar una infraestructura para la
121

gestin de tales cambios.

Coordinador del almacn persistente
El coordinador de almacenamiento persistente juega un papel central en como Core Data
gestiona los datos, sin embargo, no se suele interactuar directamente con el coordinador
cuando se utiliza el framework.
Un
coordinador
de
almacenamiento
persistente
es
una
instancia
de
NSPersistentStoreCoordinator. Administra una coleccin de almacenes de objetos
persistentes. Un almacn de objetos persistentes representa un almacn externo (archivo)
de datos persistentes. Es el objeto que realmente mapea los objetos de la aplicacin y los
registros en la base de datos. Hay diferentes clases de almacn de objetos persistentes
para los diferentes tipos de archivos soportados porCore Data. Tambin se puede
implementar uno propio.
En una aplicacin de iOS, por lo general, slo hay un almacn, pero en aplicaciones
complejas (especialmente para Mac OS X), puede haber varios, cada uno de las
entidades que pueden contener diferentes datos. El papel del coordinador de
almacenamiento persistente es gestionar estas almacenes y presenta a sus contextos
objetos gestionados de la fachada de una almacn unificado. Al buscar registros, datos
bsicos recupera los resultados de todos ellos (a menos que especifique qu almacn
interesa).
En cualquier aplicacin se pueden tener mltiples contextos de objetos administrados. Es
posible que se desee mantener conjuntos discretos de objetos administrados y editar
esos objetos, o es posible que se desee realizar una operacin en segundo plano usando
un contexto al tiempo que permite al usuario interactuar con los objetos. Cada uno de
estos estara conectado al coordinador del mismo.
En la figura siguiente se puede visualizar el rol del coordinador.

122

Gestin de un modelo de datos

Como se seala en "El modelo de objetos administrados", el modelo es una coleccin de
objetos y descripcin de propiedades de la entidad que le dicen a Core Data acerca de los
objetos gestionados en la aplicacin. Se puede crear el modelo mediante programacin, o
utilizar la herramienta de modelado de Xcode para crear el modelo grficamente, de forma
similar a aquel en el que se crea una interfaz de usuario con Interface Builder.
Esta aplicacin ejemplo tiene slo una nica entidad, un evento, con tres atributos: la
fecha de creacin, la latitud y la longitud.
Aadir la Entidad
En primer lugar, agregar una entidad evento.
>> En Xcode, en el grupo Recursos seleccionar el archivo de modelo
(Locations.xcdatamodel) para visualizar el editor de modelos.
>> Seleccione Disear> Modelo de Datos> Aadir Entidad para agregar una nueva
entidad en el modelo.
Tambin puede utilizar el botn Aadir (+) en la parte inferior izquierda del panel de
entidad, o utilizar el men contextual en la vista de diagrama en el editor de modelos.
Se debe ver una nueva entrada para la entidad (denominada "Entidad") que aparece en el
panel de la entidad en la parte superior izquierda del editor de documentos, y una
representacin grfica de la entidad (un rectngulo redondeado) aparecen en la vista de
diagrama. Ahora puede establecer el nombre para la nueva entidad.
>> Asegurar que se dispone de la nueva entidad seleccionada en el panel entidad de
manera que se puede ver informacin sobre la entidad en el panel de detalles de la
derecha. Cambiar el nombre de la entidad para eventos. (No cambie el nombre de la
clase.)
La pantalla debe ser similar a esta:

Hay una diferencia importante entre el nombre de la entidad y el nombre de la clase

123

Objective-C utilizada para representar las instancias de la entidad. Core de datos utiliza la
descripcin de la entidad para averiguar sobre los objetos de datos que gestiona, por lo
que el nombre de la clase no tiene que ser el mismo que el nombre de la entidad. De
hecho, en algunos casos varias entidades pueden ser representados por la misma claseNSManagedObject. Core Data es capaz de diferenciar los casos sobre la base de su
descripcin de la entidad asociada.
Agregar los atributos
En primer lugar, agregar el atributo de la fecha de creacin.
>> Asegurarse de que ha seleccionado en el panel Evento entidad, a continuacin,
seleccione Disear> Modelo de Datos> Aadir atributo.
Se debe ver a un nuevo atributo (llamado NewAttribute) aparecen en el panel de
propiedades. Es necesario configurar el nombre y el tipo.
>> Asegrese de que ha seleccionado el nuevo atributo en el panel de propiedades, a
continuacin, en el panel de detalles cambia el nombre del atributo que creationDate, y
seleccione Fecha en el tipo de men emergente.
No es necesario configurar cualquiera de los otros valores.
Ahora Se agregan los atributos de latitud y longitud.
>> Asegurarse de que ha seleccionado en el navegador de eventos entidad, a
continuacin, seleccione Disear> Modelo de Datos> Aadir atributo dos veces (para
sumar dos atributos).
>> Seleccionar los atributos nuevos en el panel de propiedades, a continuacin, en el
panel de detalles, seleccione el tipo de doble men emergente.
>> Seleccionar slo el primer atributo nuevo en el panel de propiedades y, en el panel de
detalles cambia el nombre del atributo de la latitud.
>> Seleccionar slo el segundo atributo nuevo en el panel de propiedades y, en el panel
de detalles cambia el nombre del atributo a la longitud.
La pantalla debe ser similar a esto:

124

Clase personalizada de gestin del objeto

Aunque en principio se puede representar una entidad usando NSManagedObject, en la
prctica, es comn el uso de una clase personalizada. Esto proporciona varias ventajas,
entre ellas:

Mejor soporte de las herramientas de desarrollo.

Se tiene la oportunidad de completar el cdigo para los mtodos de acceso a las
propiedades.
Soporte para mtodos personalizados para la entidad.
En muchas situaciones, se desea proporcionar una lgica especial para la entidad,
tales como los mtodos de validacin o propiedades derivadas. Por ejemplo, en
una entidad Persona es posible aplicar el mtodo de validacin para asegurar que
una propiedad hasDriversLicense no puede ser True si la propiedad edad es
inferior a 17, o un mtodo FullName que devuelve una concatenacin adecuada de
nombre y apellido.

Ahora usemos Xcode para generar los archivos para una clase personalizada para
representar a la entidad evento.
>> En Xcode, en el modelo, seleccionar la entidad de sucesos. (Debe seleccionar la
entidad, la seleccin se utilizan para indicar los elementos que desea para crear
subclases.)
>> Seleccione Archivo> Nuevo archivo. En el cuadro de dilogo Nuevo archivo,
seleccione Clase Managed Object.
Dependiendo de la versin de Xcode que est utilizando, la clase de objeto gestionado
puede estar disponible en la seccin de iOS en las clases Cocoa Touch, o puede que
tenga que elegir la plantilla en la seccin de Mac OS X, en Cocoa, ya sea funcionar
correctamente.
Haga clic en Siguiente >>. La ubicacin correcta y objetivos debera estar seleccionas por
Xcode. Hacer clic en Siguiente para aceptar.
Se deber ver el panel de seleccin de la entidad, con la entidad del evento seleccionado.
La "Generacin de acceso" y "Generar Objective-C 2.0" propiedades de opciones tambin
deben estar seleccionadas.
>> Haga clic en Finalizar para generar los archivos.
La interfaz de la clase de eventos y archivos de implementacin se crea y se agrega al
proyecto. Hay un par de cosas para anotar:
En el archivo de interfaz (Event.h), todos los atributos se representan por los
valores de objeto.
A pesar de que ha especificado la latitud y la longitud tipos de atributos como doble,
los valores de las propiedades en tiempo de ejecucin son instancias de
NSNumber. Datos Bsicos utiliza objetos para representar los valores.
En el archivo de aplicacin (Event.m), las propiedades se implementan como
dinmica.
Normalmente se puede esperar para ver sintetizada, sin embargo los datos bsicos
genera los mtodos de acceso en tiempo de ejecucin.
En el archivo de aplicacin (Event.m), no hay ningn mtodo dealloc.
Normalmente, usted puede esperar ver un mtodo para liberar dealloc variables de
instancia, sin embargo Datos Bsicos es responsable de la ciclo de vida de todas
las propiedades de modelado de un objeto administrado. (Si usted aada sus
125

propias variables de instancia que no tienen propiedades correspondientes en el

modelo de objetos gestionados, entonces usted necesita para manejar los mismo
como normal.)
El modelo tambin se actualiza-la entidad del evento est representado por la clase
Event.
Debido a que el modelo ha cambiado, que hay que salvar.

>> Guarde el archivo de modelo.

Por ltimo, debido a que el controlador de vista de la tabla va a hacer uso de la nueva
clase, importar el archivo de encabezado en el archivo de implementacin del controlador
de vista tabla.
>> En el archivo de aplicacin el controlador de vista tabla (RootViewController.m),
despus de la declaracin de importacin inicial, aadir:
# Import "Event.h"

Aadiendo Eventos
El objetivo de este punto es crear la lgica de la aplicacin para permitir al usuario pueda
crear objetos de evento nuevos y los muestre en la interfaz de usuario.
Implementar el Mtodo addEvent
Para crear nuevos objetos de eventos en el mtodo addEvent. Recordemos que se invoca
cuando el usuario pulsa el botn Agregar (vea "viewDidLoad de aplicacin"). Hay varias
partes en el mtodo. Tiene que:

Obtener la ubicacin actual

Crear un objeto de evento y configurarlo usando la informacin de ubicacin actual
Guardar el objeto de evento
Actualizacin de la matriz de los acontecimientos y la interfaz de usuario
Primero, sin embargo, declarar el mtodo addEvent.

>> Aadir una declaracin del mtodo

RootViewController:

addEvent al archivo de encabezado

(Void) addEvent;
Obtener la ubicacin actual
Cuando se crea un nuevo objeto de evento, debe configurar su ubicacin. Usted obtiene
la ubicacin del gestor de ubicacin. Si no es capaz de proporcionar una ubicacin,
entonces no contine.
>> Aadir lo siguiente al archivo de implementacin RootViewController:
- (void)addEvent {
CLLocation *location = [locationManager location];
126

if (!location) {
return;
}
}
Crear y configurar el objeto evento
Por
lo
general,
crear
un
objeto
administrado
mediante
el
mtodoinsertNewObjectForEntityForName: inManagedObjectContext: de NSEntityDescription,
devuelve una instancia inicializada correctamente de la clase correcta de la entidad que
se especifique, insertada en el contexto del objeto administrado. Despus de crear el
objeto, se pueden establecer sus valores de propiedad.
Se obtiene la latitud y longitud del lugar como valores escalares, por lo que necesita para
convertir estos objetos NSNumber para el objeto de evento. Se puede obtener la marca
de tiempo de la ubicacin tambin, pero este es un valor constante en el simulador. En
cambio, aqu se puede utilizar el mtodo de la fecha de NSDate para obtener un objeto
fecha que representa la fecha y hora actuales.
// Create and configure a new instance of the Event entity.
Event *event = (Event *)[NSEntityDescription
insertNewObjectForEntityForName:@"Event"
inManagedObjectContext:managedObjectContext];
CLLocationCoordinate2D coordinate = [location coordinate];
[event setLatitude:[NSNumber numberWithDouble:coordinate.latitude]];
[event setLongitude:[NSNumber numberWithDouble:coordinate.longitude]];
[event setCreationDate:[NSDate date]];
Esto ilustra la tcnica general que se utiliza para actualizar un objeto administrado, ya sea
un nuevo objeto gestionado que se ha creado, o uno que viene del almacn. Slo se
tienen que utilizar estos mtodos de acceso, al igual que lo hara con cualquier objeto
Cocoa. Es importante destacar, sin embargo, los cambios no son llevados al almacn
persistente hasta que guarde explcitamente el contexto.
Captacin de Eventos
Para recuperar objetos de un almacn persistente, se necesita un contexto del objeto
gestionado y una peticin de recuperacin. Una peticin de recuperacin es una instancia
de NSFetchRequest. Como mnimo, se especifica la entidad que se est interesado .
Tambin se pueden especificar las restricciones sobre los valores que los objetos deben
tener y qu orden desea que una copia. Por ejemplo, en una aplicacin de informacin de
la empresa, puede crear un peticin de recuperacin para recuperar los objetos
empleados, ordenados por nombre, cuyo salario es mayor que una cierta cantidad. Las
limitaciones se representan mediante un predicado (una instancia de NSPredicate). El
orden es un gnero representado por una array de objetos NSSortOrdering.
A menos que realmente se necesiten todos los objetos de una determinada entidad, se
debe utilizar un predicado para limitar el nmero de objetos devueltos a aquellos que en
realidad ests interesado (Si se va a mostrar objetos en una vista de tabla, tambin puede
utilizar una controlador de recuperacin de resultados NSFetchedResultsController para
127

gestionar un conjunto de resultados. ste intentar asegurar que los datos se mantengan
en la memoria el mayor tiempo posible.)
Hay que tener en cuenta que no siempre se necesita para ejecutar un recuperador para
recuperar los objetos. Core Data, si es necesario, recupera automticamente los objetos
que estn en el destino de una relacin. Por ejemplo, si se ejecuta un recuperador para
recuperar un objeto Empleado, entonces se le pide su Departamento relacionado,
entonces Core Data obtiene el Departamento para usted si no hubiera sido solicitado
antes.
Flujo de recuperacin de datos:

Creacin y ejecucin del evento

Cuando el controlador de vista de la tabla se carga la vista, debe recuperar los objetos
evento y mantenerlos en la matriz de eventos para que puedan aparecer ms tarde. La
matriz de eventos tiene que ser mutable ya que el usuario puede aadir y eliminar
eventos.
Crear el evento
Crear una peticin de recuperacin y ajustar la entidad.
>> Agregar el cdigo siguiente al final de la actual aplicacin de viewDidLoad:
NSFetchRequest *request = [[NSFetchRequest alloc] init];
NSEntityDescription *entity = [NSEntityDescription entityForName:@"Event"
inManagedObjectContext:managedObjectContext];
[request setEntity:entity];

128

El mtodo de
inters aqu
es entityForName NSEntityDescription
de:
inManagedObjectContext:. Se proporciona el nombre de la entidad que se desea y el
contexto del objeto gestionado que est tratando, el mtodo luego pide (objeto
administrado) al modelo de contexto (objeto gestionado) coordinador (almacn
persistente) y recupera a partir de que la entidad con el nombre especificado..
Conceptualmente no es muy difcil (que acaba de navegar por la pila), y se podra hacer
con bastante facilidad, pero es mucho ms conveniente utilizar el mtodo de clase.
Establecer el descriptor de Orden
Si no se especifica un descriptor de clase, el orden en que los objetos son devueltos
desde una recuperacin es indefinido. Para recuperar los eventos en orden cronolgico,
por lo tanto, debe especificar un descriptor de clasificacin para la obtencin de
informacin. Debido a que es posible que desee especificar mltiples ordenamientos de
clasificacin (por ejemplo, es posible que desee ordenar los empleados por departamento,
el apellido y nombre de pila), es necesario poner el descriptor de tipo Array.
>> Al final de la implementacin actual de viewDidLoad, se crea un descriptor de
clasificacin para ordenar los objetos de eventos por fecha de creacin (los ms recientes
primero) y un Array mutable. Aadir el descriptor de clase a la matriz, y establecer el Array
como el Array de solicitud de recuperacin sortDescriptors:
NSSortDescriptor *sortDescriptor = [[NSSortDescriptor alloc]
initWithKey:@"creationDate" ascending:NO];
NSArray *sortDescriptors = [[NSArray alloc] initWithObjects:sortDescriptor, nil];
[request setSortDescriptors:sortDescriptors];
[sortDescriptors release];
[sortDescriptor release];
(A menudo es til usar los initWithObjects: Mtodo de NSArray en caso de que desee
aadir ms descriptores de clasificacin ms adelante.)
Ejecutar el evento
Despus de haber creado una peticin de recuperacin, ahora lo ejecuta. El Array de
eventos tiene que ser mutable, as hay que hacer una copia mutable del resultado.
>> Se agrega el cdigo siguiente al final de la actual aplicacin de viewDidLoad:
NSError *error = nil;
NSMutableArray *mutableFetchResults = [[managedObjectContext
executeFetchRequest:request error:&error] mutableCopy];
if (mutableFetchResults == nil) {
// Handle the error.
}
Terminar
>> Se agrega el cdigo siguiente al final de la actual aplicacin de viewDidLoad:
129

[self setEventsArray:mutableFetchResults];
[mutableFetchResults release];
[request release];
Borrado de Eventos
El objetivo de este punto es permitir al usuario borrar eventos de la lista.
Eliminacin de objetos gestionados
Como se vio al crear un nuevo objeto administrado, el tiempo de vida de un registro en la
base de datos no est vinculado a la duracin de un determinado objeto administrado. Si
se crea un objeto administrado, esto no significa automticamente que se cree para ese
objeto en la base de datos un registro, es necesario debe guardar el contexto para ello.
De manera similar, simplemente porque un objeto se des-asigne no significa que el
registro correspondiente en s se destruya.
Para eliminar un registro, se indica al contexto del objeto gestionado que marque un
objeto como eliminado utilizando el mtodo deleteObject: de NSManagedObjectContext.
Despus para destruir realmente el registro, escriba la accin siguiente y utilice save:.
Eliminacin de un evento
Para hacer frente a la eliminacin, se implementa la vista de la tabla de origen de datos
tableView mtodo: commitEditingStyle: forRowAtIndexPath:. Se necesita hacer tres cosas:
Eliminar el objeto seleccionado.
Actualizacin de la vista de tabla.
Guarde los cambios.
Debe hacer esto slo si la accin es una eliminacin.
>> En el archivo de implementacin RootViewController, aplicar el tableView:
commitEditingStyle: forRowAtIndexPath: mtodo de la siguiente manera:
- (void)tableView:(UITableView *)tableView commitEditingStyle:
(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath
*)indexPath {
if (editingStyle == UITableViewCellEditingStyleDelete) {
// Delete the managed object at the given index path.
NSManagedObject *eventToDelete = [eventsArray
objectAtIndex:indexPath.row];
[managedObjectContext deleteObject:eventToDelete];
// Update the array and table view.
[eventsArray removeObjectAtIndex:indexPath.row];
[tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath]
withRowAnimation:YES];
// Commit the change.
130

NSError *error = nil;

if (![managedObjectContext save:&error]) {
// Handle the error.
}
}
}

131

Preferencias de usuario
Acerca de las preferencias y ajustes
Las preferencias son piezas de informacin que se almacenan continuamente y se utilizan
para configurar la aplicacin. Las aplicaciones a menudo exponen las preferencias de los
usuarios para que puedan personalizar la apariencia y el comportamiento de la aplicacin.
La mayora de las preferencias se almacenan localmente utilizando las preferencias de
Cocoa Preferences Systems conocido como el sistema de usuario por defecto. Las
aplicaciones tambin puede almacenar las preferencias en iCloud en la cuenta de un
usuario utilizando el Key-value Store.
El sistema de usuario por defecto y Key-value Store estn diseados para el
almacenamiento de datos simples tipo cadenas, nmeros, fechas, valores booleanos,
URLs, objetos de datos, y as sucesivamente, en una lista de propiedades. El uso de una
lista de propiedades tambin significa que se pueden organizar los datos de preferencia
utilizando un Array de tipo diccionario. Tambin es posible almacenar otros objetos en una
lista de propiedades codificadas en un objeto NSData.

Sobre el sistema de usuario por defecto

El sistema de usuario predeterminado administra el almacenamiento de las preferencias
de cada usuario. La mayora de las preferencias se almacenan persistentemente y por lo
tanto no cambian entre los ciclos posterior lanzamiento de su aplicacin. Las aplicaciones
usan el sistema de las preferencias para realizar un seguimiento de la configuracin y los
cambios (iniciales y programadas).
Qu hace bueno una preferencia?

Al definir las preferencias de la aplicacin, es mejor utilizar los valores simples y tipos de
datos cuando sea posible. El sistema de preferencias est construido en base a la
propiedades de una lista, tales como cadenas, nmeros y fechas. Aunque se puede
utilizar un objeto NSData para almacenar objetos arbitrarios en las preferencias, no se
recomienda su uso en la mayora de los casos.
El almacenamiento persistente de objetos significa que la aplicacin tiene que decodificar
ese objeto en algn momento. En el caso de las preferencias, un objeto almacenado
significa decodificar el objeto cada vez que acceda a la preferencia. Tambin significa que
una nueva versin de la aplicacin tiene que asegurarse de que es capaz de decodificar
los objetos creados y escritos en el disco usando una versin anterior de la aplicacin, lo
que es potencialmente propenso a dar errores.
Un mejor enfoque de las preferencias es almacenar cadenas simples y valores para crear
los objetos necesarios para las aplicaciones. Almacenar valores simples significa que la
aplicacin siempre se puede acceder al valor. Lo nico que cambia de una versin a otra
132

es la interpretacin del valor simple y los objetos de la aplicacin crea como respuesta.
Proporcionar una interfaz de Preferencia

Para enfrentarnos a las preferencias, la Tabla siguiente lista las opciones a mostrar en las
preferencias del usuario. Como se puede ver en esta tabla, la mayora de las opciones
implican la creacin de una interfaz de usuario personalizada para la gestin y la
presentacin de las preferencias. Si se va a crear una aplicacin para iOS, se puede
utilizar un Setting Bundle para presentar las preferencias, pero hay que hacerlo slo si la
configuracin el usuario cambia con poca frecuencia.
Preference
Frequently changed preferences
Infrequently changed preferences

iOS
Custom UI
Settings bundle

OS X
Custom UI
Custom UI

Las preferencias en las aplicaciones de Mac son accesibles desde un elemento de men
Preferencias en el men de aplicaciones. En aplicaciones Cocoa creadas usando las
plantillas de Xcode, ste proporciona un elemento de men de forma automtica. Es
responsabilidad del programador presentar una interfaz de usuario correspondiente
cuando el usuario elige esta opcin del men. Se puede establecer la interfaz de usuario
mediante la definicin de un mtodo de accin en la aplicacin Delegate que muestra
una ventana de preferencias personalizadas y conectar ese mtodo de accin para el
elemento de men en Interface Builder.
No hay una forma estndar para mostrar preferencias personalizadas desde dentro de
una aplicacin para iOS. Se puede integrar las preferencias de muchas maneras,
incluyendo el uso de una ficha independiente en una interfaz de ficha o usando un botn
personalizado en una de las pantallas de su aplicacin. Las preferencias generalmente se
presentan utilizando un controlador de vista distinto de modo que los cambios en las
preferencias se pueden grabar cuando el controlador de esa vista es cerrado por el
usuario.
La Organizacin de las Preferencias

Preferencias estn agrupadas en dominios, cada uno de los cuales tiene un nombre y un
uso especfico. Por ejemplo, hay un dominio especfico de las preferencias especficos de
la aplicacin y otro para las preferencias de todo el sistema que se aplican a todas las
aplicaciones. Todas las preferencias se almacenan y se accede en funcin de cada
usuario. No hay soporte para el intercambio de preferencias entre los usuarios.
Cada preferencia tiene tres componentes:

El dominio en el que se almacena

Su nombre (especificado como un objeto NSString)
Su valor, que puede ser cualquier objeto propiedad de la lista (NSData, NSString,
NSNumber, NSDate, NSArray o NSDictionary)
133

La vida til de una preferencia depende del dominio en el que se guarde. Algunos
dominios almacenan las preferencias de manera persistente escribindolas en la base de
datos del usuario por defecto. Tales preferencias siguen existiendo desde el lanzamiento
de aplicacin hasta la siguiente. Otros dominios almacenan las preferencias de una
manera ms voltil, preservando los valores de preferencia slo para la vida del
correspondiente objeto de valores de usuario predeterminados.
Para realizar bsquedas para el valor de una preferencia dada se procede a revisar
dominios en la lista de bsqueda de un objeto de NSUserDefaults. Solo los dominios en la
lista de bsqueda se buscan, y se buscan en el orden que se muestra en la Tabla
siguiente, comenzando con el dominio NSArgumentDomain. La bsqueda termina cuando
una preferencia con el nombre especificado se encuentra. Si varios dominios contienen la
misma preferencia, el valor se obtiene del dominio ms cercano al principio de la lista de
bsqueda.
Dominio

NSArgumentDomain
Application (Identified by the apps identifier)

NSGlobalDomain
Languages (Identified by the language names)

NSRegistrationDomain

Estado
volatile
persistent
persistent
volatile
volatile

El dominio argumento (NSArgument Domain)

El dominio argumento comprende valores establecidos en argumentos de lnea de
comandos (si inici la aplicacin desde la lnea de comandos) y se identifica por la
constante NSArgumentDomain. Los valores establecidos desde la lnea de comandos se
colocan automticamente en este campo por el sistema. Para agregar un valor a este
dominio, especifique el nombre de preferencia en la lnea de comandos (precedido por un
guin) y seguir con el valor correspondiente.
Por ejemplo, el comando siguiente inicia Xcode y define el valor de su preferencia
IndexOnOpen a NO:
localhost> Xcode.app / Contents / MacOS / Xcode IndexOnOpen-NO
Las preferencias configuradas desde la lnea de comandos anulan temporalmente los
valores establecidos almacenados en bases de datos de usuario por defecto. En el
ejemplo anterior, estableciendo la preferencia IndexOnOpen a NO previene Xcode de
proyectos de indizacin automtica, incluso si la preferencia se establece en YES en la
base de datos de usuario por defecto.
El dominio aplicacin
El dominio de aplicacin contiene preferencias especficas da la aplicacin que se
almacenan en la base de datos de usuario por defecto en el usuario actual. Cuando se
utiliza el objeto compartido NSUserDefaults (o un objeto NSUserDefaultsController en OS
X) para escribir las preferencias, las preferencias se colocan automticamente en este
campo.
134

Debido a que este dominio es de la aplicacin especfica, los contenidos del dominio
estn vinculados al identificador de paquete de su aplicacin. Los contenidos de este
dominio se almacenan en un archivo que est gestionado por el sistema. En la actualidad,
este archivo se encuentra en el directorio $ HOME / Library / Preferences /, donde $
HOME es el directorio inicial sea la aplicacin o el directorio home del usuario
(dependiendo de la plataforma y de si su aplicacin est en una sandbox). El nombre del
archivo de base de datos de usuario por defecto es <ApplicationBundleIdentifer>.Plist,
donde <ApplicationBundleIdentifer> es el identificador del paquete de la aplicacin. No se
debe modificar el archivo directamente, pero se puede inspeccionar durante la depuracin
para asegurarse de que los valores de preferencia se escriben por la aplicacin.
El dominio global
El dominio global contiene preferencias que son aplicables a todas las aplicaciones y se
identifican por la constante NSGlobalDomain. Este dominio es utilizado habitualmente por
los frameworks del sistema para almacenar todo el sistema de valores y no debe ser
utilizado por su aplicacin para almacenar valores especficos. Si se desea cambiar el
valor de una preferencia en el dominio global, se escribe el valor de esa preferencia en el
dominio de la aplicacin.
El dominio de registro
El registro del dominio define el conjunto de valores por defecto para usar si la preferencia
dada no se establece explcitamente en uno de los otros dominios. En el momento del
lanzamiento, una aplicacin puede llamar a los mtodos de registerDefaults:
NSUserDefaults para especificar un conjunto predeterminado de valores para las
preferencias importantes. Cuando una aplicacin se inicia por primera vez, la mayora de
las preferencias no tienen valores, por lo que la recuperacin de ellos producira
resultados no definidos. El registro de un conjunto de valores predeterminados asegura de
que su aplicacin siempre tiene un conjunto bien conocido de los valores a operar.
El contenido del registro de dominio slo se puede establecer mediante el uso del mtodo
registerDefaults:.
Visualizar las preferencias utilizando la herramienta por defecto

En OS X, la herramienta por defecto de lnea de comando proporciona una manera para

examinar el contenido de la base de datos de preferencias de usuario por defecto.
Durante el desarrollo de aplicaciones, se puede utilizar esta herramienta para validar las
preferencias que la aplicacin escribe en el disco. Para ello, se utiliza un comando de la
forma siguiente desde la aplicacin Terminal:
defaults read <application-bundle-identifier>
Para leer los contenidos del dominio gobal, se utiliza el siguiente comando:
defaults read NSGlobalDomain

135

Acceso a los valores de las preferencias

Se usa la clase NSUserDefaults para acceder a las preferencias de la aplicacin. Cada
aplicacin dispone de una nica instancia de esta clase, accesible desde el mtodo de la
clase standardUserDefaults.
Se usan para:

Especificar los valores por defecto de las preferencias de su aplicacin en el

momento de su lanzamiento.
Obtener y establecer los valores individuales de preferencias almacenadas en el
dominio de aplicacin.
Quitar los valores de preferencia.
Examinar el contenido de los dominios de las preferencias voltiles.

Las aplicaciones de Mac que utilizan enlaces Cocoa puede utilizar el objeto
NSUserDefaultsController para establecer y obtener las preferencias de forma automtica.
Por lo general, aadir un objeto as en el fichero nib se utiliza para mostrar las
preferencias de visualizacin del usuario. Se enlazan los controles de interfaz de usuario
a los elementos del controlador de usuario por defecto, que se encarga del proceso de
obtener y establecer valores en la base de datos de usuario por defecto.
Los valores de preferencia debe ser uno de los tipos de los tipos de las propiedades
estndar del objeto de lista: NSData, NSString, NSNumber, NSDate, NSArray o
NSDictionary. La clase NSUserDefaults tambin ofrece funciones para almacenar objetos
NSURL como valores preferentes.

Registro de Preferencias de su aplicacin por defecto

En el momento del lanzamiento, una aplicacin debe registrar valores por defecto para
cualquier preferencia que se espera sea presentada y vlida. Cuando se solicita el valor
de una preferencia que nunca se ha establecido, los mtodos predeterminados de los
valores de la clase NSUserDefaults retornan valores por defecto que son apropiados a
tipo de datos. Para valores numricos, normalmente significa devolver 0, pero para
strings y otros objetos significa devolver nill. Si estos valores estndar por defecto no
son adecuados para la aplicacin, se pueden registrar valores propios predeterminados
utilizando el mtodo registerDefaults: Este mtodo coloca sus valores predeterminados
personalizados en el dominio NSRegistrationDomain.
Cuando se llama a los mtodos de registerDefaults:, se debe proporcionar un diccionario
de todos los valores por defecto que se necesitan colocar.El Listado siguiente muestra un
ejemplo en el que una aplicacin iOS registra sus valores por defecto en el ciclo de
lanzamiento. Puede registrar valores por defecto en cualquier momento, por supuesto,
pero siempre debe registrarse antes de intentar recuperar los valores de preferencia.
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:
(NSDictionary *)launchOptions {
// Register the preference defaults early.
136

NSDictionary *appDefaults = [NSDictionary

dictionaryWithObject:[NSNumber numberWithBool:YES]
forKey:@"CacheDataAgressively"];
[[NSUserDefaults standardUserDefaults] registerDefaults:appDefaults];
// Other initialization...
}

Sincronizando y detectando cambios en las preferencias

Debido a que la clase NSUserDefaults almacena en cach los valores, a veces es
necesario sincronizar los valores almacenados en cach con el contenido actual de la
base de datos de usuario por defecto. La aplicacin no es siempre la nica entidad que la
modifica la base de datos de usuario por defecto. En iOS, la aplicacin de configuracin
puede modificar los valores de las preferencias para las aplicaciones que tienen un
conjunto de configuracin. En OS X, el sistema y otras aplicaciones pueden modificar los
valores de preferencias en respuesta a las acciones del usuario. Por ejemplo, si el usuario
cambia de idioma preferido, el sistema escribe los nuevos valores a la base de datos de
usuario por defecto. En OS X v10.5 y posteriores, el objeto compartido NSUserDefaults
sincroniza sus caches automticamente a intervalos peridicos. Sin embargo, las
aplicaciones pueden llamar al mtodo sincronizar manualmente para forzar una
actualizacin de los valores almacenados en cach.
Para detectar cuando se produce un cambio de un valor de una preferencia, las
aplicaciones tambin pueden registrarse en NSUserDefaultsDidChangeNotification
notificacin. El objeto compartido NSUserDefaults enva esta notificacin a su aplicacin
siempre que detecte un cambio en una preferencia situado en uno de los dominios
constantes. Se puede utilizar esta notificacin para responder a los cambios que puedan
afectar a su interfaz de usuario. Por ejemplo, se podra utilizar para detectar cambios en el
idioma preferido del usuario y actualizar el contenido de la aplicacin adecuada.

137

Estados de las App y multitarea

Para aplicaciones de iOS, es crucial saber si la aplicacin se est ejecutando en primer
plano o el background. Debido a que los recursos del sistema son ms limitados en los
dispositivos iOS, una aplicacin debe comportarse de manera diferente en el background
que en el primer plano. El sistema operativo tambin limita lo que su aplicacin puede
hacer en un segundo plano con el fin de mejorar la vida de la batera y mejorar la
experiencia del usuario con la aplicacin en activo. El sistema operativo notifica a la
aplicacin cada vez que se mueve entre el primer plano y el background. Estas
notificaciones son la oportunidad para modificar el comportamiento de su aplicacin.
Mientras que su aplicacin est activa y en primer plano, el sistema enva eventos de
tacto a l para el procesamiento. La infraestructura UIKit hace la mayora del trabajo de la
entrega de los eventos a los objetos personalizados. Todo lo que tienes que hacer es
reemplazar los mtodos en los objetos adecuados para procesar esos eventos. Para los
controles, UIKit simplifica las cosas an ms por el manejo de los eventos de toque para ti
y para llamar a su cdigo personalizado slo cuando algo interesante ocurre, por ejemplo,
cuando el valor de un campo de texto cambia.
Al implementar la aplicacin, es recomendable seguir estas pautas:

(Obligatorio) Responder adecuadamente a las transiciones de estado que se

producen. No manejar estas transiciones adecuadamente puede conducir a la
prdida de datos y una mala experiencia de usuario.
(Obligatorio) Cuando se desplaza a un segundo plano, asegrese de que su
aplicacin se ajusta su conducta apropiada.
(Recomendado) Registro de las notificaciones que informan de cambios en el
sistema que afectan a las necesidades de la aplicacin. Cuando una aplicacin es
suspendida, las notificaciones de keys del sistema se encolan y se entregan
cuando la aplicacin reanuda la ejecucin. Las aplicaciones deben utilizar estas
notificaciones para hacer una transicin a la ejecucin sin problemas de nuevo.
(Opcional) Si la aplicacin necesita hacer el trabajo real, mientras est en el
background, es necesario pedir al sistema permisos adecuados para seguir
funcionando.

Gestin de cambios de estado de una aplicacin

En un momento dado, su aplicacin se encuentra en uno de los estados que se indican en
la tabla siguiente. El sistema mueve la aplicacin a partir de un estado a otro en
respuesta a las acciones que suceden en todo el sistema. Por ejemplo, cuando el usuario
presiona el botn de inicio, una llamada telefnica entrante, o se produce cualquiera de
otras posibles interrupciones, el estado cambia en respuesta a ese evento.
Estado
Not running
Inactive

Descripcin
La aplicacin no se ha lanzado o ha sido finalizada por el
sistema.
La aplicacin se ejecuta en segundo plano, pero no est
138

Active

Background

recibiendo actualmente los eventos. (Se puede ejecutar

otro cdigo sin embargo.) Una aplicacin normalmente se
queda en este estado brevemente en la transicin a un
estado diferente.
La aplicacin se ejecuta en primer plano y est recibiendo
los eventos. Este es el modo normal para aplicaciones en
primer plano.
La aplicacin est en segundo plano y su cdigo en
ejecucin. La mayora de las aplicaciones dque van a
entrar en suspensin pasan por este estado brevemente
Sin embargo, una aplicacin que solicita el tiempo de
ejecucin adicional puede permanecer en este estado
durante un perodo mas largo de tiempo.
La aplicacin est en el background, pero no ejecuta
cdigo. El sistema mueve a la app a este estado
automticamente y no le notificar antes de hacerlo.
Mientras est suspendido, una aplicacin permanece en la
memoria pero no ejecuta ningn cdigo.

Suspended
Cuando se produce una condicin de memoria, el sistema
puede liberarse de aplicaciones suspendidas sin previo
aviso para hacer ms espacio en memoria para la
aplicacin activa.

La Figura siguiente muestra los caminos que toma una aplicacin cuando pasa de un
estado a otro

La mayora de las transiciones de estado son acompaados por una llamada

correspondiente a los mtodos del objeto delegado de la app. Estos mtodos son la
139

oportunidad de responder a los cambios de estado de una manera apropiada. Estos

mtodos se enumeran a continuacin, junto con un resumen de cmo puede utilizarlos.

Application:willFinishLaunchingWithOptions:-Este mtodo es la primera oportunidad

de su aplicacin para ejecutar cdigo en tiempo de lanzamiento.
Application:didFinishLaunchingWithOptions:-Este mtodo permite realizar cualquier
inicializacin final antes de que la aplicacin se muestre en pantalla al usuario.
applicationDidBecomeActive:-Permite a la aplicacin saber que est a punto de
convertirse en una app en primer plano. Utilice este mtodo para cualquier
preparacin de ltima hora.
applicationWillResignActive:-Le permite saber que la aplicacin est en la
transicin lde dejar de ser una aplicacin en primer plano. Utilice este mtodo para
poner su aplicacin en un estado de reposo.
applicationDidEnterBackground:-Le permite saber que su aplicacin se est
ejecutando en segundo plano y puede ser suspendida en cualquier momento.
applicationWillEnterForeground:-Le permite saber que su aplicacin se est
moviendo fuera del background y de nuevo pasa a primer plano, pero que todava
no est activa.
applicationWillTerminate:-Le permite saber que su aplicacin se est terminando.
Este mtodo no se puede llamar si su aplicacin est suspendida.

El ciclo de lanzamiento de una App

Cuando la aplicacin est en marcha, se mueve desde un estado en el que no se est
ejecutando hacia el estado activo o el background, a travs de una breve transicin breve
en el estado inactivo. Como parte del ciclo de puesta en marcha, el sistema crea un
proceso y un hilo conductor para la aplicacin y llama a la funcin principal de su
aplicacin en el hilo principal. La funcin principal por defecto que viene con el proyecto
de Xcode ctoma pronto el control sobre el framework UIKit, que hace la mayor parte del
trabajo en la inicializacin de la aplicacin y la preparara para que funcione.

140

La Figura siguiente muestra la secuencia de eventos que ocurren cuando una aplicacin
se ejecuta hacia el primer plano, incluyendo los mtodos de aplicaciones delegados que
se llaman.

Si la aplicacin es lanzada hacia el background el ciclo de lanzamiento cambia un poco al

que se muestra en la figura siguiente. La principal diferencia es que en lugar de que la
aplicacin se hace activa, entra en el background para controlar el evento y luego se
suspende poco despus. Cuando se lanza a un segundo plano, el sistema todava carga
los archivos de interfaz de usuario de la aplicacin, pero no se muestra la ventana de la
aplicacin.

141

Para determinar si la aplicacin est poniendo en marcha en el primer o en el background,

hay que comprobar la propiedad del objeto applicationState del objeto compartido
UIApplicationen o en los mtodos delegados application:willFinishLaunchingWithOptions:
o application:didFinishLaunchingWithOptions:. Cuando la aplicacin se inicia en el primer
plano, esta propiedad contiene el valor UIApplicationStateInactive. Cuando la aplicacin
se
ejecuta
en
segundo
plano,
la
propiedad
contiene
el
valor
UIApplicationStateBackground en su lugar. Se puede utilizar esta diferencia para ajustar el
comportamiento en tiempo de lanzamiento de los mtodos delegados en consecuencia.
Acerca de la funcin main
Al igual que cualquier aplicacin basada en C, el punto de entrada principal para una
aplicacin iOS en el momento del lanzamiento es la funcin principal. En una aplicacin
para iOS, la funcin principal se utiliza slo mnimamente. Su funcin principal es entregar
el control al framework UIKit. Por lo tanto, cualquier proyecto nuevo que cree en Xcode
viene con una funcin principal por defecto como el que se muestra en el cdigo ejemplo
siguiente:
#import <UIKit/UIKit.h>
int main(int argc, char *argv[])
{
@autoreleasepool {
return UIApplicationMain(argc, argv, nil, NSStringFromClass([MyAppDelegate
class]));
}
}
142

La funcin UIApplicationMain toma cuatro parmetros y los utiliza para inicializar la

aplicacin. Nunca se debern cambiar los valores por defecto pasados a esta funcin. Sin
embargo, es importante entender su propsito y cmo iniciar la aplicacin.
Los parmetros argc y argv contienen los argumentos que se pasan a la aplicacin del
sistema al arrancar la app. Estos argumentos son analizados por la infraestructura de
UIKit.
El tercer parmetro identifica el nombre de la clase principal de la aplicacin. Esta es la
clase responsable de ejecutar la aplicacin. Se recomienda especificar nulo para este
parmetro, lo que hace que UIKit utilice la clase UIApplication.
El cuarto parmetro identifica la clase de su delegado de aplicacin personalizado. El
delegado de aplicacin se encarga de gestionar las interacciones de alto nivel entre el
sistema y el cdigo. Los proyectos de plantilla de Xcode ajustan este parmetro a un valor
apropiado automticamente.
Otra cosa que hace la funcin UIApplicationMain es cargar el archivo principal de interfaz
de usuario de la aplicacin. El archivo de interfaz principal contiene los objetos de vistas
iniciales relacionados con la interfaz de usuario de su aplicacin que se quiere mostrar.
Para las aplicaciones que utilizan "Storyboards", esta funcin carga el controlador de vista
inicial del guin y lo instala en la ventana proporcionada por su delegado app. Para las
aplicaciones que utilizan archivos nib, la funcin carga el contenido del archivo nib en la
memoria pero no los instala en la ventana de su aplicacin, el mtodo delegado de la app
application:willFinishLaunchingWithOptions: quien lo carga.
Una aplicacin puede tener un archivo principal de Storyboard o un archivo nib principal,
pero no puede tener ambas cosas. Los Storyboards son el mejor medio para especificar la
interfaz de usuario de una aplicacin, pero no son compatibles con todas las versiones de
iOS. El nombre del archivo de su aplicacin guin grfico principal va en la key
UIMainStoryboardFile del archivo Info.plist de la aplicacin. (Para los interfaces basados
en nib, el nombre del archivo nib principal va en la key NSMainNibFile.) Normalmente,
Xcode establece el valor de lkey apropiado cuando se crea un proyecto, pero se puede
cambiar ms adelante si es necesario.
Qu hacer en tiempo de lanzamiento de una app?
Cuando la aplicacin est en marcha (ya sea en primer plano o en ell background),se usa
la solicitud d mtodos del delegado de APP application:willFinishLaunchingWithOptions: y
application:didFinishLaunchingWithOptions: para hacer lo siguiente:

Comprobar el contenido de las acciones de lanzamiento del diccionario para

obtener informacin acerca de por qu la aplicacin se puso en marcha, y
responder adecuadamente.
Inicializar las estructuras crticas de la app de datos.
Preparar ventana de su aplicacin y las vistas de pantalla.
Las aplicaciones que utilizan OpenGL ES no debe utilizar este mtodo para
preparar su entorno de dibujo. En cambio, deben diferir las llamadas OpenGL ES
143

giro al mtodo applicationDidBecomeActive:.

Si la aplicacin no carga automticamente el archivo principal del guin grfico o nib en el
momento
del
lanzamiento,
se
puede
utilizar
el
mtodo
application:
willFinishLaunchingWithOptions: para preparar la ventana de la aplicacin para su
visualizacin.
Para las aplicaciones que soportan orientacin vertical y horizontal, siempre hay que
configurar el controlador de vista raz de la ventana principal en una orientacin vertical. Si
el dispositivo est en una orientacin diferente en el momento del lanzamiento, el sistema
le indica al controlador de vista raz que rote sus vistas a la orientacin correcta antes de
mostrar la ventana.
Los mtodos

application:willFinishLaunchingWithOptions:
application:didFinishLaunchingWithOptions:

siempre deben ser lo ms ligeros posibles para reducir el tiempo de lanzamiento de la

aplicacin. Se espera de las aplicaciones que se pongan en marcha y se inicien y
empiecen a controlar eventos en menos de 5 segundos. Si una aplicacin no termina su
ciclo de puesta en marcha en el momento oportuno, el sistema la libera por no responder.
Por lo tanto, cualquier tarea que pueda ralentizar el lanzamiento (por ejemplo, el acceso a
la red) debe ser ejecutado de forma asincrnica en un subproceso secundario.
Al poner en marcha en el primer plano, el sistema llama al mtodo
applicationDidBecomeActive: para finalizar la transicin al primer plano. Debido a que este
mtodo es llamado tanto a la hora de lanzamiento y en la transicin desde el background,
utilicelo para la mejor de tareas que son comunes a las dos transiciones.
Repuesta a interrupciones
Cuando una interrupcin se produce, como una llamada telefnica entrante, la aplicacin
se desplaza temporalmente al estado inactivo para que el sistema pueda solicitar al
usuario cmo proceder. La aplicacin permanece en este estado hasta que el usuario se
encarga de la alerta.
En este punto, la aplicacin, vuelve al estado activo o pasa al background. Esta figura
muestra el proceso:

144

En iOS 5, las notificaciones que muestran un banner no desactivan la aplicacin en la

misma forma en que hemos explicado. En cambio, el banner se coloca a lo largo del
borde superior de la ventana de la aplicacin y esta aplicacin sigue recibiendo eventos
de tacto como antes. Sin embargo, si el usuario tira de la bandera hacia abajo para
revelar el centro de notificacin, la aplicacin pasa al estado inactivo, como si una
interrupcin por alertas y se hubiera producido.
Pulsar el botn de reposo / activacin es otro tipo de interrupcin que hace que la
aplicacin pase a estar desactivada temporalmente. Cuando el usuario pulsa este botn,
el sistema desactivar eventos de toque y mueve la aplicacin para el background, pero
establece el valor de la propiedad applicationState a UIApplicationStateInactive (en vez de
UIApplicationStateBackground), y finalmente bloquea la pantalla. Una pantalla bloqueada
tiene consecuencias adicionales para las aplicaciones que utilizan la proteccin de datos
para cifrar archivos.
Qu hacer cuando se produce una interrupcin
Las alertas basadas en interrupciones dan como resultado una prdida temporal del
control de la aplicacin. La aplicacin sigue ejecutndose en primer plano, pero no recibe
eventos de tacto del sistema. (sin embargo sigue recibiendo notificaciones y otros tipos de
eventos, tales como eventos acelermetro.) Como respuesta a este cambio, la aplicacin
debe hacer lo siguiente en el mtodo applicationWillResignActive::

Detener tareas peridicas y temporizadores.

Detenga las bsquedas de metadatos en ejecucin.
No iniciar ninguna tarea nueva.
Pausar la reproduccin de pelculas (excepto cuando se reproduce a travs de
AirPlay).
145

Entrar en un estado de pausa si su aplicacin es un juego.

Moderar la velocidad de frames del OpenGL ES.
Suspender cualquier cola o colas de despacho de operaciones de ejecucin que no
sean crticas. (Se puede continuar procesando las solicitudes de red y otras
sensibles al tiempo y tareas en segundo plano mientras est inactivo).

146

Moviendo App al background

Cuando el usuario pulsa el botn de inicio, presiona el botn de reposo / activacin, o el
sistema lanza otra aplicacin, las transiciones de la aplicacin activa pasan al estado
inactivo y luego al background. Estas acciones son el resultado de las llamadas al mtodo
delegado de app applicationWillResignActive
y applicationDidEnterBackground:
como se muestra en la figura a continuacin.
Despus de regresar del mtodo applicationDidEnterBackground:
la mayora de las aplicaciones se mueven al estado de suspensin un poco despus. Las
aplicaciones que soliciten tareas especficas en background (como la reproduccin de
msica) o solicitan un poco de tiempo de ejecucin ms del sistema pueden continuar
funcionando un poco ms de tiempo.

147

Qu hacer cuando la aplicacin transita hacia el background?

Las aplicaciones pueden utilizar el mtodo applicationDidEnterBackground: para
prepararse para pasar a la situacin de background. Al trasladarse a un segundo plano,
todas las aplicaciones deben hacer lo siguiente:

Preprese
para
realizar
la
foto.
Cuando
el
mtodo
el
applicationDidEnterBackground: retorna, el sistema toma una fotografa de la
interfaz de usuario de la aplicacin y utiliza la imagen resultante para las
animaciones de transicin. Si las vistas de la interfaz de usuario contienen
informacin confidencial, se debe ocultar o modificarla vista antes de la ejecucin
del mtodo applicationDidEnterBackground:.
Guardar los datos de usuario y la informacin del estado de la aplicacin.
Todos los cambios no guardados se deben escribir en el disco al entrar en el
background. Este paso es necesario porque la aplicacin podra ser liberada
mientras est en el background. Puede realizar esta operacin desde un
subproceso de fondo segn sea necesario.
Liberar tanta memoria como sea posible. Para obtener ms informacin acerca
de qu hacer y por qu esto es importante, consulte "Uso de la memoria para
aplicaciones de fondo."

Volviendo al primer plano

Volviendo al primer plano es la oportunidad de la aplicacin para reiniciar las tareas que
se detuvo cuando se traslad al background. Los pasos que tienen lugar cuando se
mueve en el primer plano se muestra en la figura siguiente.
El mtodo applicationWillEnterForeground: debera deshacer cualquier cosa que la
aplicacin realiz en el mtodo applicationDidEnterBackground: y el mtodo
applicationDidBecomeActive: debera seguir para realizar las tareas de activacin igual
que lo hara en el momento de su lanzamiento.

148

Finalizacin de una App

Aunque las aplicaciones generalmente son transferidos al background y suspendidas, si
alguna de las siguientes condiciones son verdaderas, la aplicacin se termina y se libera
la memoria que ocupabar:

La aplicacin est vinculada con una versin de iOS anterior a la 4.0.

La aplicacin se implementa en un dispositivo que ejecuta una versin de iOS
anterior a la 4.0.
El dispositivo actual no es compatible con multitarea.
La aplicacin incluye la clave UIApplicationExitsOnSuspend en el archivo Info.plist.

Si la aplicacin est en ejecucin (ya sea en el primer o segundo plano) en tiempo de

finalizacin, el sistema llama al mtodo applicationWillTerminate: para que pueda realizar
la limpieza necesaria. Puede utilizar este mtodo para guardar los datos del usuario y la
informacin del estado de la app que se usara para restaurar la aplicacin a su estado
actual en un lanzamiento posterior. Su mtodo tiene aproximadamente 5 segundos para
realizar las tareas y el retorno.
Importante: El mtodo applicationWillTerminate: no conoce si su aplicacin est
suspendida.

149

El bucle de ejecucin principal

El bucle de ejecucin principal de la aplicacin es responsable de procesar todos los
eventos relacionados con el usuario. El objeto UIApplication configura el bucle de
ejecucin principal en el momento del lanzamiento y lo utiliza para procesar eventos y
manejar las actualizaciones de interfaces. Como su nombre indica, el bucle de ejecucin
principal se ejecuta en el subproceso principal de la aplicacin. Este comportamiento se
asegura de que los eventos relacionados con el usuario se procesan en serie en el orden
en que se recibieron.
La figura siguiente muestra la arquitectura del bucle de ejecucin principal. Cuando el
usuario interacta con un dispositivo, los eventos relacionados con esas interacciones son
generados por el sistema y entregados a la aplicacin a travs de un puerto especial
establecido por UIKit. Los eventos se ponen en cola internamente por la aplicacin y se
envian a uno a uno al bucle de proceso principal para su ejecucin. El objeto
UIApplication es el primer objeto para recibir el evento y tomar la decisin sobre lo que
hay que hacer. Un evento tctil se envan generalmente al objeto de ventana principal,
que a su vez enva a la vista en la que se produjo el contacto.

150

Ejecucin en background y multitarea

En iOS 4 y posteriores, la multitarea permite que las aplicaciones siguan funcionando en
segundo plano, incluso despus de que el usuario cambie a otra aplicacin sin dejar de
preservar la vida de la batera tanto como sea posible.
La mayora de las aplicaciones se trasladan al estado suspendido poco despus de entrar
en el background. Slo las aplicaciones que proporcionan importantes servicios a los
usuarios se les permite seguir funcionando durante cualquier cantidad de tiempo.
En la medida de lo posible, se anima a evitar la ejecucin en segundo plano y se deja que
la aplicacin se suspenda. Si es necesario que la aplicacin lleve a cabo tareas en el
background, aqu se indican algunas pautas para cuando sea necesario:

Es necesario implementar al menos uno de los varios servicios especficos del

usuario.
Es necesario realizar una nica tarea de longitud finita.
Es necesario utilizar las notificaciones para alertar al usuario de algn dato
relevante cuando la aplicacin no se est ejecutando.

El sistema mantiene las aplicaciones suspendidas en la memoria el mayor tiempo

posible, la eliminacin de ellas slo se realiza cuando la cantidad de memoria libre est
baja. Permanecer en la memoria significa que los lanzamientos posteriores de la
aplicacin son mucho ms rpidos. Al mismo tiempo, la suspensin significa que la
aplicacin no gasta la batera del dispositivo tan rpidamente.
Determinar si Multitarea est disponible
Aplicaciones deben estar preparados para manejar situaciones en las que la multitarea (y
por lo tanto, ejecucin en segundo plano) no se encuentra disponible. Incluso si el
dispositivo est funcionando con iOS 4 o posterior, puede que el dispositivo no sea
compatible con la multitarea. La multitarea no est disponible en dispositivos que ejecutan
iOS 3 y anteriores. Si la aplicacin es capaz de funcionar con estas versiones anteriores
de iOS, debe estar preparado para funcionar sin multitarea.
Si la presencia o ausencia de multitarea cambia la forma en que la aplicacin se
comporta, compruebe la propiedad multitaskingSupported de la clase UIDevice para
determinar si la multitarea est disponible antes de realizar la tarea correspondiente. Para
hacer esto, usted debe construir su aplicacin contra iOS SDK 4 o posterior y comprobar
si la propiedad est disponible antes de acceder a ella, en el cdigo ejemplo siguiente se
comprueba la multitarea:
eUIDevice* device = [UIDevice currentDevice];
BOOL backgroundSupported = NO;
if ([device respondsToSelector:@selector(isMultitaskingSupported)])
backgroundSupported = device.multitaskingSupported;
151

Ejecucin de una tarea finita en el background

Las aplicaciones que pasan al background pueden solicitar una cantidad adicional de
tiempo para terminar importantes tareas de ltima hora. Para solicitar tiempo de ejecucin
fondo, llame al mtodo beginBackgroundTaskWithExpirationHandler: de la clase
UIApplication. Si la aplicacin pasa a segundo plano mientras la tarea est en progreso, o
si su aplicacin ya se encontraba en el fondo, este mtodo retrasa la suspensin de la
aplicacin.
La manera de utilizar el mtodo beginBackgroundTaskWithExpirationHandler: es llamarlo
antes de comenzar la tarea que se desea proteger. Cada llamada a este mtodo debe ser
equilibrada por una llamada correspondiente al mtodo endBackgroundTask: mtodo para
marcar el final de la tarea. Cdigo ejemplo:
- (void)applicationDidEnterBackground:(UIApplication *)application
{
bgTask = [application beginBackgroundTaskWithExpirationHandler:^{
// Clean up any unfinished task business by marking where you
// stopped or ending the task outright.
[application endBackgroundTask:bgTask];
bgTask = UIBackgroundTaskInvalid;
}];
// Start the long-running task and return immediately.
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEF
AULT, 0), ^{
// Do the work associated with the task, preferably in chunks.
[application endBackgroundTask:bgTask];
bgTask = UIBackgroundTaskInvalid;
});
}
Encolando la distribucin de notificaciones locales
Las notificaciones son una forma de llamar la atencin de un usuario aunque la aplicacin
est suspendida y se encuentra en el background o no se est ejecutando. Las
aplicaciones pueden utilizar las notificaciones locales para mostrar las alertas, reproducir
sonidos, cambie el icono de la aplicacin, o una combinacin de los tres. Por ejemplo, una
aplicacin de reloj despertador puede utilizar las notificaciones locales para reproducir un
sonido de alarma y mostrar una alerta para desactivar la alarma. Cuando una
notificacin se entrega al usuario, el usuario debe decidir si las rdenes de informacin
con lo que la aplicacin de nuevo al primer plano.
Para programar la entrega de una notificacin local, se crea una instancia de la clase
UILocalNotification, y se configuran los parmetros de notificacin y se programa
utilizando los mtodos de la clase UIApplication. Ejemplo de notificacin de una alarma:
- (void)scheduleAlarmForDate:(NSDate*)theDate
{
152

UIApplication* app = [UIApplication sharedApplication];

NSArray* oldNotifications = [app scheduledLocalNotifications];
// Clear out the old notification before scheduling a new one.
if ([oldNotifications count] > 0)
[app cancelAllLocalNotifications];
// Create a new notification.
UILocalNotification* alarm = [[UILocalNotification alloc] init];
if (alarm)
{
alarm.fireDate = theDate;
alarm.timeZone = [NSTimeZone defaultTimeZone];
alarm.repeatInterval = 0;
alarm.soundName = @"alarmsound.caf";
alarm.alertBody = @"Time to wake up!";
[app scheduleLocalNotification:alarm];
}
}
Implementando tareas de ejecucin prolongada en el background
Para las tareas que requieren ms tiempo de ejecucin, se deben solicitar permisos
especficos para ejecutarse en segundo plano. En iOS, slo determinados tipos
especficos de aplicaciones que se pueden ejecutar en segundo plano:

Aplicaciones que relizan contenido audible para el usuario mientras estn en

background, como una aplicacin de reproductor de msica
Aplicaciones que mantienen informados a los usuarios de su ubicacin en todo
momento, como una aplicacin de navegacin
Aplicaciones de Voz sobre Protocolo de Internet (VoIP)
Aplicaciones que necesitan descargar y procesar nuevos contenidos
Las aplicaciones que reciben actualizaciones regulares de los accesorios externos

Las aplicaciones que implementan estos servicios deben declarar los servicios en los que
se apoyan y utilizar los frameworks del sistema para aplicar los aspectos pertinentes de
esos servicios. La declaracin de los servicios permite al sistema saber qu servicios
utiliza, pero en algunos casos se trata de los frameworks del sistema que realmente
impiden la aplicacin de la suspensin.
Concurrencia y threads secundarios
El sistema crea el hilo principal de la aplicacin, pero la aplicacin puede crear sub
procesos adicionales, segn sea necesario para llevar a cabo otras tareas. La mejor
forma de crear hilos es dejar que el sistema lo haga por usted mediante el uso de colas en
Grand Central Dispatch y colas de operacin. Ambos tipos de cola proporcionan un
modelo de ejecucin asncrono para las tareas que usted defina. Cuando se enva una
tarea a una cola, el sistema prepara un hilo y se ejecuta la tarea en ese hilo. Dejando que
el sistema de gestin de los hilos simplifique el cdigo y permite que el sistema gestione
estos hilos de la forma ms eficiente disponible.
153

Se debe utilizar siempre que sea posible las colas para realizar tareas fuera del hilo
principal de la aplicacin. Debido a que el hilo conductor es responsable de procesar
eventos de tacto y dibujar la interfaz, nunca debe realizar tareas prolongadas en l. Por
ejemplo, nunca se debe esperar una respuesta de la red en el subproceso principal de tu
aplicacin. Es mucho mejor hacer la solicitud asincrnica utilizando una cola y procesar
los resultados cuando llegan.
Otro buen momento para mover las tareas a temas secundarios es el momento del
lanzamiento. Lanzamiento de aplicaciones tienen una cantidad limitada de tiempo
(alrededor de 5 segundos) para hacer su inicializacin y comienza el procesamiento de
eventos. Si se utiliza el tiempo de lanzamiento para tareas que se pueden aplazar o
ejecutar en un subproceso secundario, debe quitarlas del hilo principal de inmediato y
usar el hilo principal slo para presentar la interfaz de usuario e iniciar el control de
eventos.

154

Mapas y localizacin
Utilizar informacin basada en localizacin en las aplicaciones es una forma de mantener
al usuario conectado con el mundo circundante. Si se utiliza esta informacin para fines
prcticos (como la navegacin) o para el entretenimiento, la informacin basada en la
ubicacin puede mejorar la experiencia general del usuario.

La informacin basada en la localizacin en iOS se compone de dos piezas: servicios de

localizacin y mapas. Los servicios de localizacin son proporcionados por el framework
Core Location, que proporciona interfaces de Objective-C para obtener informacin
acerca de la ubicacin del usuario y rumbo. Los mapas son proporcionados por el
framework Map Kit, que permite tanto la visualizacin y anotacin de mapas similares a
los encontrados en la aplicacin Mapas.

Obtencin de la ubicacin del usuario

Las aplicaciones usan datos de localizacin para una amplia variedad de propsitos, que
van desde las redes sociales hasta servicios de navegacin. Las aplicaciones obtienen los
datos de ubicacin mediante las clases del framework Core Location. Este framework
ofrece varios servicios que se pueden utilizar para obtener y monitorear la ubicacin
actual del dispositivo:

El servicio de ubicacin significativo proporciona los servicios de una manera que

realiza bajo consumo para obtener la ubicacin actual y ser notificado de los
155

cambios en esa ubicacin. (iOS 4.0 o posterior).

El servicio de ubicacin estndar ofrece una forma ms configurable para obtener

la ubicacin actual.

Monitoreo de Regin le permite supervisar los cruces de frontera para un rea

definida. (iOS 4.0 o posterior en los dispositivos de monitoreo apoyo para la
regin).

Para utilizar las funciones del framework Core Location, debe enlazar la aplicacin al
gframework Core Location.en el proyecto de Xcode. Para acceder a las clases y los
encabezamientos del framework hay que incluir una declaracin import
<CoreLocation/CoreLocation.h> en la parte superior de los archivos fuente
correspondientes.
Para poder usar los servicios de localizacin es necesario conocer que estn disponibles
en el dispositivo. Para que funcionen correctamente, se debe incluir la clave
UIRequiredDeviceCapabilities en el archivo Info.plist de la aplicacin.

Obtener la ubicacin actual del usuario

El framework Core Location le permite localizar la posicin actual del dispositivo y utilizar
esa informacin en su aplicacin. El framework utiliza la informacin obtenida del celular,
Wi-Fi, o hardware GPS para triangular una ubicacin fija para el dispositivo. Se informa
que la ubicacin en el cdigo y, en funcin de cmo se configure el servicio, tambin
proporciona actualizaciones peridicas a medida que recibe datos nuevos o mejorados.
Hay dos servicios diferentes que puede utilizar para obtener la ubicacin actual del
usuario:

El servicio de ubicacin estndar es un configurable, de propsito general solucin

y es compatible con todas las versiones de iOS.

El servicio de ubicacin significativo que ofrece un servicio de localizacin de baja

potencia para los dispositivos con radios celulares. Este servicio slo est
disponible en iOS 4.0 y posteriores.

Puesta en marcha del Servicio Estndar Localidad

El servicio de ubicacin estndar es la forma ms comn de adquirir la ubicacin actual
del usuario, ya que est disponible en todos los dispositivos y en todas las versiones de
iOS. Antes de utilizar este servicio, se configura mediante la especificacin de la precisin
deseada de los datos de localizacin y la distancia que se debe recorrer antes de informar
de una nueva posicin. Cuando se inicia el servicio, utiliza los parmetros especificados
156

para determinar que las radios para permitir y luego procede a notificar eventos de
ubicacin para su aplicacin.
Para utilizar el servicio de localizacin estndar, se crea una instancia de la clase
CLLocationManager y se configuran sus propiedades desiredAccuracy distanceFilter.
Para comenzar a recibir las notificaciones de ubicacin, asignar un delegado para el
objeto y llamar al mtodo startUpdatingLocation. Cuando los datos de ubicacin estn
disponible,s lel manejador de localizacin notifica al objeto delegado. Si una actualizacin
de posicin ya ha sido entregada, se pueden obtener los datos de localizacin ms
recientes directamente desde el objeto CLLocationManager sin esperar a que un nuevo
evento que se entregue. Para detener el envo de actualizaciones de ubicacin, llame al
mtodo stopUpdatingLocation del objeto de jefe de locacin.
Ejemplo de cdigo para comenzar el seervicio:
- (void)startStandardUpdates
{
// Create the location manager if this object does not
// already have one.
if (nil == locationManager)
locationManager = [[CLLocationManager alloc] init];
locationManager.delegate = self;
locationManager.desiredAccuracy = kCLLocationAccuracyKilometer;
// Set a movement threshold for new events.
locationManager.distanceFilter = 500;
[locationManager startUpdatingLocation];

Inicio del servicio de ubicacin significativo

En iOS 4.0 o posterior, puede utilizar el servicio de localizacin ubicacin significativo para
recibir eventos. Este servicio ofrece un ahorro de energa significativo y proporciona una
exactitud que es lo suficientemente buena para la mayora de aplicaciones. Se utiliza la
radio celular del dispositivo para determinar la ubicacin del usuario y el informe de los
cambios en esa ubicacin, permitiendo que el sistema administre el uso de energa
mucho mejor. Este servicio tambin es capaz de despertar una aplicacin que est
actualmente suspendida o no se est ejecutando con el fin de entregar nuevos datos de
ubicacin.
Para utilizar el servicio de localizacin de cambio significativo, se crea una instancia de la
clase CLLocationManager, se asigna un objeto delegado a la misma, y se llama al mtodo
startMonitoringSignificantLocationChanges como se muestra en el cdigo de ejemplo
siguiente.

157

Cuando los datos de ubicacin estn disponibles, el manejador de localizacin notificar a

su objeto delegado. Si una actualizacin de posicin ya ha sido entregada, tambin se
puede obtener los datos de localizacin ms recientes directamente desde el objeto
CLLocationManager sin esperar a que un nuevo evento de entrega.
- (void)startSignificantChangeUpdates
{
// Create the location manager if this object does not
// already have one.
if (nil == locationManager)
locationManager = [[CLLocationManager alloc] init];
locationManager.delegate = self;
[locationManager startMonitoringSignificantLocationChanges];
}
La forma de recibir la localizacin en ambos servicios es idntica y se muestra un ejemplo
de implementacin de el procesado de un evento de localizacin:
// Delegate method from the CLLocationManagerDelegate protocol.
- (void)locationManager:(CLLocationManager *)manager
didUpdateLocations:(NSArray *)locations {
// If it's a relatively recent event, turn off updates to save power
CLLocation* location = [locations lastObject];
NSDate* eventDate = location.timestamp;
NSTimeInterval howRecent = [eventDate timeIntervalSinceNow];
if (abs(howRecent) < 15.0) {
// If the event is recent, do something with it.
NSLog(@"latitude %+.6f, longitude %+.6f\n",
location.coordinate.latitude,
location.coordinate.longitude);
}
}
Datos de geolocalizacin
Los datos de ubicacin se devuelven normalmente como un par de valores numricos que
representan la latitud y longitud del punto correspondiente en el globo. Estas coordenadas
ofrecen una manera precisa y fcil de especificar los datos de localizacin en el cdigo,
pero no son muy intuitivos para los usuarios. En lugar de coordenadas globales, los
usuarios son ms propensos a entender una ubicacin que se especifica utilizando la
informacin que estn ms familiarizados con tales como calle, ciudad, estado, pas y la
informacin. Para situaciones en las que desee mostrar una versin fcil de usar de un
lugar, se puede utilizar un objeto geocodificador para obtener esa informacin.
Acerca de los objetos Geocoder
Un objeto geocodificador utiliza un servicio de red para convertir valores de latitud y
158

longitud y en una marca de posicin fcil de usar, que es una coleccin de datos, tales
como la calle, ciudad, estado y pas. Reverse Geocoding es el proceso de convertir una
latitud y longitud en una marca de posicin. Forward Geocoding es el proceso de
convertir la informacin en un lugar nombre latitud y longitud valor. Reverse Geocoding
es compatible con todas las versiones de iOS pero Forward Geocoding slo es
compatible con iOS 5.0 o posterior.
Debido a que los geocodificadores corren en un servicio de red, una conexin de red
activa debe estar presente para que una solicitud de codificacin geogrfica tenga xito.
Si un dispositivo est en modo avin o la red no est configurada actualmente, el
geocodificador no se puede conectar con el servicio que necesita y por lo tanto debe
devolver un error apropiado. Aqu hay algunas reglas generales para la creacin de
solicitudes de codificacin geogrfica:

Enviar como mximo una solicitud de codificacin geogrfica para cualquier accin
de usuario.

Si el usuario realiza varias acciones que implican geocodificacin la misma

ubicacin, reutilizar los resultados de la solicitud de codificacin geogrfica inicial
en lugar de iniciar peticiones individuales para cada accin.

Si se desea actualizar la ubicacin de forma automtica (por ejemplo, cuando el

usuario est en movimiento), se emite la solicitud de codificacin geogrfica
nicamente cuando la ubicacin del usuario se ha movido una distancia
considerable y despus de un perodo razonable de tiempo haya pasado. Por
ejemplo, en una situacin normal, no se debe enviar ms de una solicitud de
codificacin geogrfica por minuto.

No se empieza una solicitud de codificacin geogrfica en un momento en que el

usuario no vea los resultados inmediatamente. Por ejemplo, no empiece una
solicitud si la aplicacin esta en el background o se interrumpi y se encuentra en
estado inactivo.

Convertir coordenadas en informacin de un lugar

Nota: En iOS 5.0, MKReverseGeocoder y MKReverseGeocoderDelegate estn en desuso
a fin de utilizar CLGeocoder para todo el desarrollo de aplicaciones nuevas.
En iOS, puede utilizar el CLGeocoder o clase MKReverseGeocoder para manejar
geocodificacin inversa peticiones. El uso de CLGeocoder es preferido y est disponible
en iOS 5.0 o posterior. Sin embargo, si la aplicacin debe ejecutarse en las versiones
anteriores de iOS, se puede utilizar la clase MKReverseGeocoder.

Obtencin de informacin mediante Placemark CLGeocoder

159

Para iniciar una solicitud de codificacin geogrfica inversa con la clase CLGeocoder, hay
que crear una instancia de la clase y llamar al mtodo reverseGeocodeLocation:
completionHandler: El objeto geocoder inicia la solicitud de codificacin geogrfica inversa
asncrona y entrega los resultados al objeto de bloque que usted proporciona. El objeto de
bloque se ejecuta si la solicitud tiene xito o fracasa. En el caso de un fallo, un objeto de
error se pasa al bloque que indica el motivo del fallo.
Ejemplo de cdigo que geocodifica un lugar:
@implementation MyGeocoderViewController (CustomGeocodingAdditions)
- (void)geocodeLocation:(CLLocation*)location forAnnotation:
(MapLocation*)annotation
{
if (!geocoder)
geocoder = [[CLGeocoder alloc] init];
[theGeocoder reverseGeocodeLocation:location completionHandler:
^(NSArray* placemarks, NSError* error){
if ([placemarks count] > 0)
{
annotation.placemark = [placemarks objectAtIndex:0];
// Add a More Info button to the annotation's view.
MKPinAnnotationView* view = (MKPinAnnotationView*)[map
viewForAnnotation:annotation];
if (view && (view.rightCalloutAccessoryView == nil))
{
view.canShowCallout = YES;
view.rightCalloutAccessoryView = [UIButton
buttonWithType:UIButtonTypeDetailDisclosure];
}
}
}];
}
@end
Conversin de nombres de lugares en coordenadas
En iOS 5.0 y versiones posteriores, se utiliza la clase CLGeocoder para iniciar un
Forward Geocoding utilizando ya sea un diccionario con informacin de la libreta de
direcciones o una cadena simple. Hay un formato designado para peticiones basadas en
cadenas, los caracteres delimitadores son bienvenidos, pero no es obligatorio, y el
servidor geocodificador trata la cadena como entre maysculas y minsculas. Por lo tanto,
cualquiera de las siguientes cadenas se obtendran resultados:
"Apple Inc"
"1 Infinite Loop"
"1 Infinite Loop, Cupertino, CA, EE.UU."
160

Cuanta ms informacin se pueda proporcionar al geocodificador mejores sern los

resultados devueltos. El objeto geocoder analiza la informacin que le dan y, si se
encuentra una coincidencia, devuelve un nmero de objetos de marcas de posicin. El
nmero de objetos devueltos de marcas de posicin depende en gran medida de la
especificidad de la informacin proporcionada. Por lo tanto, proporcionar calle, ciudad,
provincia, pas es mejor que poner una simple direccion.
El bloque controlador que se pasa al geocodificador, debe estar preparados para manejar
mltiples marcas de posicin, como se muestra en el siguiente ejemplo:
[geocoder geocodeAddressString:@"1 Infinite Loop"
completionHandler:^(NSArray* placemarks, NSError* error){
for (CLPlacemark* aPlacemark in placemarks)
{
// Process the placemark.
}
}];

Dibujando Mapas
Introducido en iOS 3.0, el framework Map Kit permite incorporar una interfaz de mapas
completamente funcional en su aplicacin. El soporte a mapas proporcionado por este
framework incluye muchas de las caractersticas que normalmente se encuentran en
aplicaciones de Mapas. Puede mostrar informacin a nivel de plano o imgenes de
satlite, o una combinacin de los dos. Puede hacer zoom y desplazar el mapa
programacin y el framework proporciona apoyo automtico a los eventos tctiles que
permiten a los usuarios ampliar y explorar el mapa. Tambin puede anotar el mapa con
informacin personalizada.
Para utilizar las caractersticas de la estructura Mapa Kit, debe vincular su aplicacin al
framework de MapKit. en el proyecto de Xcode. Para acceder a las clases y a las
declaraciones del framework, incluya una instruccin # import <MapKit/MapKit.h> en la
parte superior de los archivos fuente correspondientes.

Agregar una vista del mapa a la interfaz de usuario

La clase MKMapView es una interfaz independiente para presentar los datos del mapa en
la aplicacin. Esta clase proporciona soporte para la visualizacin de los datos del mapa,
para gestionar las interacciones del usuario, y para alojamiento de contenidos
personalizado proporcionado por la aplicacin. Nunca se debe sobre escribir MKMapView
slo se debe insertar como est en la jerarqua de vistas de la aplicacin. Tambin debe
asignar un objeto delegado en el mapa. La vista del mapa informa de todas las
interacciones relacionadas con su delegado para que tenga la oportunidad de responder
161

apropiadamente.
Se puede agregar una vista de mapa para la aplicacin mediante programacin o
mediante el Generador de Interfaz:
Para agregar un mapa mediante Interface Builder, arrastre un objeto mapa a la vista
apropiada o ventana.
Para agregar un mapa mediante programacin, se crea una instancia de la clase
MKMapView, se inicializa utilizando el mtodo initWithFrame: y a continuacin, se agrega
como un subvista a su jerarqua de vistas.
Debido a que es una vista, puede manipular la vista de mapa de la misma manera se
manipulan otras vistas. Se puede cambiar su tamao y posicin en la jerarqua de vistas,
se puede configurar sus comportamientos y tamao automticamente, y se pueden aadir
subvistas a ella. A diferencia de una vista, nunca esta maneja los eventos de toque
directamente. La vista del mapa en s es un envase opaco para una visin compleja de la
jerarqua que controla la visualizacin de mapas y datos relacionados con las
interacciones con esos datos. Si desea que un contenido permanezca fijo con respecto a
un mapa especfico de coordenadas debe utilizar las anotaciones o superposiciones.
Los nuevos mapas estn configurados para aceptar las interacciones del usuario y los
datos de visualizacin del mapa solamente. Se puede configurar el mapa para visualizar
las imgenes de satlite o una mezcla de los datos de satlite y mapa cambiando el
atributo Type del mapa en Interface Builder o cambiar el valor de la propiedad mapType.
Si desea limitar las interacciones del usuario, puede cambiar los valores de las
propiedades y zoomEnabled scrollEnabled. Si se desea responder a las interacciones del
usuario, debe hacerlo a travs de un delegadoConfiguracin de las propiedades de un mapa
La clase MKMapView tiene un puado de propiedades que se pueden configurar
mediante programacin. Estas propiedades controlan la informacin importante como qu
parte del mapa es visible actualmente y qu interacciones de los usuarios se les permite.
Ajustado de la parte visible de un mapa
La propiedad de la clase regin MKMapView controla la parte actualmente visible del
mapa. Cuando se crea por primera vez, en la regin visible de un mapa se encuentra
normalmente el mundo entero. En otras palabras, la regin abarca el rea que muestra la
mayor cantidad de mapa como sea posible. Puede cambiar esta regin en cualquier
momento mediante la asignacin de un nuevo valor a la propiedad regin. Esta propiedad
contiene una estructura MKCoordinateRegion, que tiene la siguiente definicin:

162

typedef struct {
CLLocationCoordinate2D center;
MKCoordinateSpan span;
} MKCoordinateRegion;
Responder a las interacciones del usuario en un Mapa
La clase MKMapView reporta importantes relacionados con mapas hechos a su objeto
delegado asociado. El objeto delegado es un objeto que cumple con el protocolo
MKMapViewDelegate. Se proporciona este objeto en situaciones en las que se desea
responder a los siguientes tipos de eventos:

Cambios en la regin visible del mapa

Carga de los mosaicos de mapas de la red

Cambios en la ubicacin del usuario

Cambios asociados con anotaciones y superposiciones..

Agregar anotaciones a un mapa

Las anotaciones ofrecen una manera de resaltar unas coordenadas determinadas en el
mapa y proporcionar informacin adicional sobre el. Se puede utilizar las anotaciones
para denominar determinadas direcciones, puntos de inters y otros tipos de destinos.
Cuando aparece en el mapa, las anotaciones suelen tener algn tipo de imagen para
identificar su ubicacin y tambin puede tener una llamada burbuja proporcionar
informacin y enlaces a ms contenido. Ejemplo de anotacin en un mapa.

163

Con el fin de mostrar una anotacin en un mapa, la aplicacin debe proporcionar dos
objetos distintos:

Un objeto que cumpla con el protocolo MKAnnotation y gestione los datos de la

anotacin. (Este objeto es el objeto de anotacin).

Una vista (derivado de la clase MKAnnotationView) utilizada para dibujar la

representacin visual de la anotacin sobre la superficie del mapa. (Esta es la vista
de anotacin.)

164

Acceso a la librera de imgenes

El interface de programacin de I / O de Imgenes permite que las aplicaciones lean y
escriban la mayora de los formatos de archivo de imagen. Originalmente fue parte del
framework Core Graphics, actualmente Image I / O reside en su propio framework para
que los desarrolladores puedan usarlo independientemente de Core Graphics (Quartz
2D). Image I / O proporciona la forma definitiva para acceder a los datos de imagen, ya
que es altamente eficiente, permite un fcil acceso a los metadatos y proporciona la
gestin del color.
El interfaz de Image de I / O est disponible en OS X v10.4 y posteriores y en iOS 4 y
posteriores.
Fundamentos de la utilizacin de Image I / O
El framework de Image I / O proporciona tipos de datos opacos para la lectura de datos de
imagen desde una fuente (CGImageSourceRef) y las escritura de datos de imagen a un
destino (CGImageDestinationRef). Es compatible con una amplia gama de formatos de
imagen, incluyendo los formatos web estndar, imgenes de alto rango dinmico y datos
brutos de cmara. Image I / O tiene muchas otras caractersticas tales como:

Es el ms rpido decodificando y codificando de imagen para la plataforma Mac

La capacidad de cargar imgenes de forma incremental
Soporte para metadatos de la imagen
Almacenamiento eficaz en cach

Puede crear fuentes de imgenes y objetos de imagen desde:

URLs. Imgenes cuya ubicacin se pueden especificar como una direccin URL
puede actuar como un proveedor o receptor de datos de imagen. En Image I / O,
una URL es representada en los tipo de datos Core Foundation CFURLRef .
Los objetos Core Foundation CFDataRef y CFMutableDataRef.
El consumidor de datos Quartz (CGDataConsumerRef) y elproveedor de datos
(CGDataProviderRef).

Uso del Framework Image I / O en una aplicacin

Image I / O se encuentra en el framework Application Services en OS X, y en el framework
Image I / O en iOS. Despus de aadir el framwork a la aplicacin, importe el archivo de
cabecera mediante la inclusin de esta declaracin:
#import <ImageIO/ImageIO.h>

165

Formatos de imagen admitidos

El framework imagen de I / O comprende la mayora de los formatos de imgenes
comunes, como JPEG, JPEG2000, RAW, TIFF, BMP y PNG. No todos los formatos estn
soportados en cada plataforma. Para listar lo mas actualizada de lo que admite image I /
O se pueden utilizar lassiguientes funciones:

CGImageSourceCopyTypeIdentifiers devuelve un array con los Uniform Type

Identifiers (UTIs) que Image I / O admite como fuentes de imagen.
CGImageDestinationCopyTypeIdentifiers devuelve un array con los Uniform Type
Identifiers (UTIs) que Image I / O admite como destinos de imgenes.

Se puede utilizar la funcin de CFShow para imprimir la matriz a la consola del debuger
en Xcode, como se muestra en el listado siguiente
CFArrayRef mySourceTypes = CGImageSourceCopyTypeIdentifiers();
CFShow(mySourceTypes);
CFArrayRef myDestinationTypes = CGImageDestinationCopyTypeIdentifiers();
CFShow(myDestinationTypes);
Los Strings del array devueltos por estas funciones toman la forma de com.apple.pict,
public.jpeg, public.tiff, y as sucesivamente. La tabla enumera las UTIs para muchos
formatos comunes de archivos de imagen. OS X y iOS definen constantes para la mayora
de formatos comunes de archivos de imagen, el conjunto completo de las constantes se
declaran en el archivo de cabecera UTCoreTypes.h. Se puede utilizar estas constantes
cuando es necesario especificar un tipo de imagen, ya sea como un indicio de una fuente
de imagen (kCGImageSourceTypeIdentifierHint) o como un tipo de imagen de un destino
de imagen.
Uniform type identifier
public.image
public.png
public.jpeg
public.jpeg-2000 (OS X only)
public.tiff
com.apple.pict (OS X only)
com.compuserve.gif

Image content type constant

kUTTypeImage
kUTTypePNG
kUTTypeJPEG
kUTTypeJPEG2000
kUTTypeTIFF
kUTTypePICT
kUTTypeGIF

166

Creando y usando fuentes de imgenes

Una fuente de la imagen abstrae la tarea de acceso a datos y elimina la necesidad de que
la gestin de datos a travs de un bfer de memoria en bruto. Una fuente de la imagen no
puede contener ms de una imagen, las imgenes en miniatura, las propiedades de cada
imagen, y el archivo de imagen. Cuando se trabaja con datos de imagen y se ejecuta la
aplicacin en OS X v10.4 o posterior, las fuentes de imagen son la mejor forma de mover
los datos de imagen en su aplicacin. Despus de crear un objeto CGImageSource, se
pueden obtener imgenes, miniaturas, Caractersticas de la imagen y la informacin de
otra imagen usando las funciones descritas en la referencia CGImageSource.
Creacin de una imagen a partir de una fuente de imagen
Una de las tareas ms comunes que llevan a cabo con el frameworz image I/O es crear
una imagen a partir de una fuente de imagen, similar a lo que se muestra en el listado
siguiente. En este ejemplo se muestra cmo crear una fuente de imagen a partir de una
ruta y luego extraer la imagen. Cuando se crea un objeto de fuente de imagen, puede
proporcionar una pista sobre el formato del archivo de la imagen.
CGImageRef MyCreateCGImageFromFile (NSString* path)
{
// Get the URL for the pathname passed to the function.
NSURL *url = [NSURL fileURLWithPath:path];
CGImageRef
myImage = NULL;
CGImageSourceRef myImageSource;
CFDictionaryRef myOptions = NULL;
CFStringRef
myKeys[2];
CFTypeRef
myValues[2];
// Set up options if you want them. The options here are for
// caching the image in a decoded form and for using floating-point
// values if the image format supports them.
myKeys[0] = kCGImageSourceShouldCache;
myValues[0] = (CFTypeRef)kCFBooleanTrue;
myKeys[1] = kCGImageSourceShouldAllowFloat;
myValues[1] = (CFTypeRef)kCFBooleanTrue;
// Create the dictionary
myOptions = CFDictionaryCreate(NULL, (const void **) myKeys,
(const void **) myValues, 2,
&kCFTypeDictionaryKeyCallBacks,
& kCFTypeDictionaryValueCallBacks);
// Create an image source from the URL.
myImageSource = CGImageSourceCreateWithURL((CFURLRef)url, myOptions);
CFRelease(myOptions);
// Make sure the image source exists before continuing
if (myImageSource == NULL){
fprintf(stderr, "Image source is NULL.");
return NULL;
167

}
// Create an image from the first item in the image source.
myImage = CGImageSourceCreateImageAtIndex(myImageSource,
0,
NULL);
CFRelease(myImageSource);
// Make sure the image exists before continuing
if (myImage == NULL){
fprintf(stderr, "Image not created from image source.");
return NULL;
}
return myImage;
}
Cuando se crea una imagen a partir de una fuente de imagen, es necesario especificar un
ndice que pueda brindar un diccionario de propiedades (pares key.-value) para
especificar cosas como crear una miniatura o permitir el almacenamiento en cach.
CGImageSource Reference y CGImageProperties Reference lista las referencias y el tipo
de datos del valor esperado para cada key.
Se debe proporcionar un valor al ndice debido a que algunos formatos de archivo de
imagen permiten mltiples imgenes residentes en el mismo archivo fuente. Para un
archivo de fuente de imagen que contiene slo una imagen, hay que pasar 0. Se pueden
encontrar imgenes en un archivo de origen de la imagen mediante una llamada al la
funcin CGImageSourceGetCount.
Creacin de una imagen en miniatura a partir de una fuente de imagen
Algunos archivos de origen de imgenes contienen imgenes en miniatura (Thumbnails)
que se pueden recuperar. Si las miniaturas no estn presentes, Image I / O le da la opcin
de crearlas. Tambin puede especificar un tamao de imagen mximo y si se debe aplicar
una transformacin a la imagen en miniatura.
El siguiente ejemplo muestra cmo crear una fuente de imagen de datos, crear un
diccionario que contiene las opciones relacionadas con la miniatura, y luego crear una
imagen en miniatura. Utilice la key CGImageSourceCreateThumbnailWithTransform para
especificar si la imagen en miniatura deben rotarse y escalarse para que coincida con la
relacin de aspecto de pxeles y la orientacin de la imagen completa.
CGImageRef MyCreateThumbnailImageFromData (NSData * data, int imageSize)
{
CGImageRef
myThumbnailImage = NULL;
CGImageSourceRef myImageSource;
CFDictionaryRef myOptions = NULL;
CFStringRef
myKeys[3];
CFTypeRef
myValues[3];
CFNumberRef
thumbnailSize;
// Create an image source from NSData; no options.
myImageSource = CGImageSourceCreateWithData((CFDataRef)data,
168

NULL);
// Make sure the image source exists before continuing.
if (myImageSource == NULL){
fprintf(stderr, "Image source is NULL.");
return NULL;
}
// Package the integer as a CFNumber object. Using CFTypes allows you
// to more easily create the options dictionary later.
thumbnailSize = CFNumberCreate(NULL, kCFNumberIntType, &imageSize);
// Set up the thumbnail options.
myKeys[0] = kCGImageSourceCreateThumbnailWithTransform;
myValues[0] = (CFTypeRef)kCFBooleanTrue;
myKeys[1] = kCGImageSourceCreateThumbnailFromImageIfAbsent;
myValues[1] = (CFTypeRef)kCFBooleanTrue;
myKeys[2] = kCGImageSourceThumbnailMaxPixelSize;
myValues[2] = (CFTypeRef)thumbnailSize;
myOptions = CFDictionaryCreate(NULL, (const void **) myKeys,
(const void **) myValues, 2,
&kCFTypeDictionaryKeyCallBacks,
& kCFTypeDictionaryValueCallBacks);
// Create the thumbnail image using the specified options.
myThumbnailImage = CGImageSourceCreateThumbnailAtIndex(myImageSource,
0,
myOptions);
// Release the options dictionary and the image source
// when you no longer need them.
CFRelease(thumbnailSize);
CFRelease(myOptions);
CFRelease(myImageSource);
// Make sure the thumbnail image exists before continuing.
if (myThumbnailImage == NULL){
fprintf(stderr, "Thumbnail image not created from image source.");
return NULL;
}
return myThumbnailImage;
}
Cargado incremental de imgenes
Si se tiene una imagen muy grande, o se cargan los datos de imagen en la web, es
posible que desee crear una fuente de imagen incremental para que pueda dibujar los
datos de la imagen a medida que se acumulan. Es necesario realizar las siguientes tareas
para cargar una imagen de forma incremental desde objeto CFData:
1. Crear el objeto CFData para acumular los datos de imagen.
2. Crear un origen de imagen incremental llamando a la funcin
CGImageSourceCreateIncremental.
3. Aadir los datos de imagen para el objeto CFData.
4. Llamar a la funcin CGImageSourceUpdateData, pasando el objeto CFData y un
169

valor booleano (tipo de datos bool) que especifica si el parmetro de datos contiene
toda la imagen, o que los datos slo parciales. En cualquier caso, el parmetro de
datos debe contener todos los datos de archivo de imagen acumulados hasta ese
punto.
5. Si se han acumulado suficientes datos de imagen, crear una imagen llamando
CGImageSourceCreateImageAtIndex, que dibuja la parte de la imagen y, a
continuacin liberar el objeto.
6. Comprobar si tiene todos los datos de una imagen mediante una llamada a la
funcin CGImageSourceGetStatusAtIndex. Si la imagen se completa, esta funcin
devuelve kCGImageStatusComplete. Si la imagen no es completa, repetir los
pasos 3 y 4 hasta que sea.
7. Libere el origen de la imagen incremental.
Visualizar las propiedades de una imagen
Las fotos digitales se marcan con una gran cantidad de informacin acerca de las
dimensiones de la imagen, la resolucin, la orientacin, el perfil de color, apertura, modo
de medicin, la longitud focal, fecha de creacin, las palabras clave, ttulo, y mucho ms.
Esta informacin es muy til para el manejo de imagen y edicin, pero slo si los datos se
exponen
en
la
interfaz
de
usuario.
Aunque
la
funcin
CGImageSourceCopyPropertiesAtIndex recupera un diccionario de todas las propiedades
asociadas a una imagen en una fuente de imagen, tendr que escribir el cdigo que
recorre ese diccionario para recuperar y mostrar esa informacin.
En esta seccin vas a echar un vistazo de cerca a una rutina a partir del cdigo de
ejemplo de ImageApp OS X, que es una aplicacin de visualizacin de imgenes que se
pueden descargar y experimentar. Una de las caractersticas del cdigo de ejemplo
ImageApp es una ventana de informacin de imagen que muestra una imagen en
miniatura y las propiedades de la imagen para la imagen activa, como se muestra en la
Figura siguiente.

170

Para tener una idea de cmo se pueden utilizar las funciones CGImageSource para
soportar una aplicacin de edicin de imagen, podemos ver un ejemplo en el listado
siguiente:
- (void) setURL:(NSURL*)url
{
if ([url isEqual:mUrl])
return;
mUrl = url;
CGImageSourceRef source = CGImageSourceCreateWithURL((CFURLRef)url,
NULL);
// 1
if (source)
{
NSDictionary* props =
(NSDictionary*) CGImageSourceCopyPropertiesAtIndex(source, 0, NULL);
// 2
[mTree setContent:[self propTree:props]];
// 3
NSDictionary* thumbOpts = [NSDictionary dictionaryWithObjectsAndKeys:
(id)kCFBooleanTrue, (id)kCGImageSourceCreateThumbnailWithTransform,
(id)kCFBooleanTrue,
(id)kCGImageSourceCreateThumbnailFromImageIfAbsent,
[NSNumber numberWithInt:128],
(id)kCGImageSourceThumbnailMaxPixelSize,
nil];
// 4
CGImageRef image = CGImageSourceCreateThumbnailAtIndex(source, 0,
(CFDictionaryRef)thumbOpts);
// 5
[mThumbView setImage:image];
// 6
CGImageRelease(image);
// 7
[mFilePath setStringValue:[mUrl path]];
// 8
NSString* uti = (NSString*)CGImageSourceGetType(source);
// 9
[mFileType setStringValue:[NSString stringWithFormat:@"%@\n%@",
ImageIOLocalizedString(uti), uti]];
// 10
CFDictionaryRef fileProps = CGImageSourceCopyProperties(source, nil);
// 11
[mFileSize setStringValue:[NSString stringWithFormat:@"%@ bytes",
(id)CFDictionaryGetValue(fileProps, kCGImagePropertyFileSize)]];
// 12
}
else
// 13
{
171

[mTree setContent:nil];
[mThumbView setImage:nil];
[mFilePath setStringValue:@""];
[mFileType setStringValue:@""];
[mFileSize setStringValue:@""];
}
}
Esto es lo que hace el cdigo:
1. Crea un objeto de origen de la imagen con la URL pasada a la rutina.
2. Copia las propiedades de la imagen ubicada en la posicin de ndice 0. Algunos
archivos de imagen pueden admitir ms de una imagen, pero este ejemplo se
supone que hay una sola imagen (o que la imagen de nuestro inters es la primera
en el archivo).
La funcin devuelve un objeto CGImageSourceCopyPropertiesAtIndex
CFDictionary. Aqu, el cdigo devuelve el CFDictionary como un objeto
NSDictionary, ya que estos tipos de datos son intercambiables.
El diccionario que se devuelve contiene todas las propiedades que son pares keyvalue. Sin embargo, algunos de los valores son en s mismos diccionarios que
contienen propiedades.
3. Extrae las propiedades del diccionario y los pone a un controlador de rbol. Si nos
fijamos en el archivo ImageInfoPanel.h, se ver que la variable es un objeto mTree
NSTreeController que es una salida en Interface Builder. Este controlador gestiona
un rbol de objetos. En este caso, los objetos son propiedades de la imagen.
El mtodo propTree: es proporcionado por el archivo ImageInfoPanel.m. Su
propsito es recorrer las propiedades del diccionario recuperado en el paso
anterior, extraer las propiedades de la imagen, y construir la matriz que est
enlazado al objeto NSTreeController.
Las propiedades aparecen en una tabla de key-value.
4. Establece un diccionario de opciones para utilizar cuando se crea una imagen de la
fuente de imagen. Recordemos que las opciones se pasan en un diccionario. El
panel de informacin muestra una imagen en miniatura. El cdigo de aqu
establece opciones que crean una imagen en miniatura que se hace girar y escalar
a la misma orientacin y relacin de aspecto de la imagen completa. Si la miniatura
no existe, se crea uno, y su tamao mximo es de 128 pxeles por 128 pxeles.
5. Se crea una imagen en miniatura de la primera imagen de la fuente de la imagen,
utilizando las opciones establecidas en el paso anterior.
6. Se establece la imagen en miniatura en la vista en el panel Informacin.
7. Se libera la imagen, sino que ya no se necesita.
8. Se extrae la ruta de la URL se pasa al mtodo, y se establece la cadena al campo
de texto que est destinado en el panel Informacin.
9. Se obtiene el identificador del tipo de la fuente de imagen. (Esto puede ser
diferente del tipo de las imgenes de la fuente.)
10. Se llama a una funcin para recuperar la cadena localizada por la UTI
(ImageIOLocalizedString se declara en el fichero ImagePanel.m) y luego se
establece la cadena para el campo de texto que est destinado en el panel
Informacin.
11. Se recupera un diccionario de las propiedades asociadas con el origen de la
imagen. Estas propiedades se aplican al contenedor (por ejemplo, el tamao del
172

archivo), no necesariamente las imgenes individuales en el origen de la imagen.

12. Se recupera el valor de tamao del diccionario de la fuente de imagen obtenida en
el paso anterior, a continuacin se establece la cadena asociada al campo de texto
que est destinado a el panel Informacin.
13. Si la fuente no se crea, se asegura de que todos los campos en la interfaz de
usuario reflejen este hecho.

Trabajar con destino de imgenes

Un destino de imagen abstrae la tarea de la escritura de datos y elimina la necesidad de
que la gestin de datos se realice a travs de un buffer de imgen Raw Buffer. Un
destino de imagen puede representar una sola imagen o varias imgenes. Puede
contener imgenes en miniatura, as como propiedades de cada imagen. Despus de
crear un objeto CGImageDestination para el destino apropiado (URL, objeto CFData o
consumidor de datos de Quartz), se puede agregar los datos de imagen y establecer las
propiedades de imagen. Cuando haya terminado de agregar los datos, llamar a la funcin
CGImageDestinationFinalize.
Definir las propiedades de un destino de imagen
La funcin CGImageDestinationSetProperties aade un diccionario (CFDictionaryRef) de
propiedades (pares key-value) a las imgenes en un destino de imagen. Aunque la
configuracin de las propiedades es opcional, hay muchas situaciones para las cuales se
querr ajustar. Por ejemplo, si la aplicacin permite a los usuarios aadir palabras clave a
las imgenes o el cambio de saturacin, exposicin u otros valores, tendr que guardar
esa informacin en el diccionario de opciones.
Imagen de I / O define un amplio conjunto de claves para especificar cosas como la
calidad de la compresin, el color de fondo de la composicin, las claves de diccionario
Exif, los valores de color del modelo, GIF claves de diccionario, Nikon y Canon teclas de
cmara, entre otras muchas.
Cuando se escriba el diccionario, se tienen dos opciones. Se puede crear un objeto
CFDictionary ose puede crear un objeto NSDictionary, luego proyectarlo como una
referencia
CFDictionaryRef
al
pasarlo
mediante
la
funcin
CGImageDestinationSetProperties . El cdigo ejemplo siguiente muestra un fragmento de
cdigo que asigna pares key-value de tres propiedades, a continuacin, crea un
diccionario que contiene las propiedades. Debido a que este es un fragmento de cdigo,
las llamadas necesarias para liberar el CFNumber y objetos CFDictionary creados por el
cdigo no se muestran. Cuando se escribe el cdigo, debe llamar CFRelease cuando ya
no necesite cada uno de estos objetos.
Cuando se configura un par key-value de una propiedad, es necesario consultar la
documentacin de referencia (vase la referencia CGImageDestination y Referencia
CGImageProperties) para el tipo de datos esperado del valor. Como se puede ver en el
lcdigo de ejemplo, los valores numricos tpicamente necesitan ser envueltos en un
objeto CFNumber. Cuando se usa los tipos de Core Foundation para valores del
173

diccionario, tambin puede suministrar las constantes de devolucin de llamada cuando

se
crea
el
diccionario-kCFTypeDictionaryKeyCallBacks
y
kCFTypeDictionaryValueCallBacks.
float compression = 1.0; // Lossless compression if available.
int orientation = 4; // Origin is at bottom, left.
CFStringRef myKeys[3];
CFTypeRef myValues[3];
CFDictionaryRef myOptions = NULL;
myKeys[0] = kCGImagePropertyOrientation;
myValues[0] = CFNumberCreate(NULL, kCFNumberIntType, &orientation);
myKeys[1] = kCGImagePropertyHasAlpha;
myValues[1] = kCFBooleanTrue;
myKeys[2] = kCGImageDestinationLossyCompressionQuality;
myValues[2] = CFNumberCreate(NULL, kCFNumberFloatType, &compression);
myOptions = CFDictionaryCreate( NULL, (const void **)myKeys, (const void
**)myValues, 3,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
// Release the CFNumber and CFDictionary objects when you no longer need them.
Escritura de una imagen a un destino de imagen
Para escribir una imagen a un destino, primero debe crear un objeto de destino llamando
a
las
funcionesimagen
CGImageDestinationCreateWithURL,
CGImageDestinationCreateWithData o CGImageDestinationCreateWithDataConsumer.
Se deber proporcionar la UTI del archivo de imagen resultante. Se puede aportar la UTI
o la constante equivalente.
Despus de crear un destino de imagen, se puede agregar una imagen a l llamando a
las funciones
CGImageDestinationAddImage o CGImageDestinationAddImageFromSource.
Si el formato del archivo de destino de imagen admite varias imgenes, se pueden aadir
imgenes de manera repetida. Llamando a la funcin CGImageDestinationFinalize se
indica a Immage I/O que se ha finalizado la carga mltiple. Una vez finalizado, no se
puede aadir ms datos en el destino de la imagen.
El cdigo siguiente muestra cmo se puede implementar un mtodo para escribir un
archivo de imagen. Aunque este cdigo muestra cmo utilizar una imagen de destino
dentro de un mtodo Objective-C, se puede crear y utilizar fcilmente un destino de
imagen en una funcin C. El parmetro de opciones incluye las propiedades que se
desean especificar para la imagen, como la cmara o los ajustes de compresin.
- (void) writeCGImage: (CGImageRef) image toURL: (NSURL*) url withType:
(CFStringRef) imageType andOptions: (CFDictionaryRef) options
{
CGImageDestinationRef myImageDest =
CGImageDestinationCreateWithURL((CFURLRef)url, imageType, 1, nil);
174

CGImageDestinationAddImage(myImageDest, image, options);

CGImageDestinationFinalize(myImageDest);
CFRelease(myImageDest);
}

Bibliografa

Programming in Objective-C
Autor: Stephen G. Kochan
Editorial: Developers Library
iPhone Programming
Autores: Joe Conaway & Aaron Hillegas
Editorial: Big Nerd Ranch,
Aplicaciones iPhone e iPad para Principiantes
Autor: Rory Lewis
Editorial: Apress

Enlaces de Inters

https://developer.apple.com
http://mobile.tutsplus.com/tutorials/
https://developer.apple.com/support/
http://nshipster.com
http://www.ipadsfera.com
http://www.raywenderlich.com

175