Manual IOS Avanzado v1.2 (V Final)

Contenido del curso
Manual IOS
Avanzado
Curso de desarrollo de
aplicaciones en plataforma
IOS
Tabla de contenido
Manejo de directorios............................................................................................................ 4
Cambiar Directorios ........................................................................................................... 5
Crear Leer y Borrar Directorios............................................................................................ 5
Listar contenido de un directorio ........................................................................................ 6
Obtener atributos de un archivo o directorio ....................................................................... 7
Manejo de archivos ............................................................................................................... 7
Verificar si existe un archivo ............................................................................................... 8
Comparacin de dos archivos ............................................................................................. 8
Verificando los permisos del archivo ................................................................................... 9
Mover o renombrar un archivo ........................................................................................... 9
Copiar un archivo............................................................................................................. 10
Borrar un archivo ............................................................................................................. 10
Crear un link simblico ..................................................................................................... 10
Leer y escribir archivos con NSFileManager ....................................................................... 11
Crear un objeto NSFileHandle ........................................................................................... 12
Proceso de desplazamiento (Offsets) y bsqueda (Seeking) ................................................ 12
Leer datos en un archivo .................................................................................................. 13
Escribir los datos en el archivo .......................................................................................... 14
Base de Datos...................................................................................................................... 16
Qu es SQLite?............................................................................................................... 16
Historia........................................................................................................................... 16
Caractersticas............................................................................................................... 16
Plataformas de SQLite .................................................................................................. 17
Aplicaciones de SQLite ................................................................................................. 17
Estructurar BD ................................................................................................................. 18
Abrir o Crear una BD......................................................................................................... 18
Crear Tabla de BD............................................................................................................. 19
Prepara y Ejecutar sentencias SQL..................................................................................... 19
Integrar SQL Lite en proyecto............................................................................................ 21
Extraer informacin de una BD. ........................................................................................ 23
Multitouch, Tap, y Gestos .................................................................................................... 35
Gestos, Taps y Touches..................................................................................................... 35

Crear una aplicacin con Gestos........................................................................................ 37
Detectar Gestos dentro de la pantalla ............................................................................... 45
Integracin de Mapas .............................................................................................................. 73
Adicionar Mapa ................................................................................................................... 73
Ubicar posicin.................................................................................................................... 78
Calcular distancias ............................................................................................................... 82
Cmara ............................................................................................................................... 83
Crear Aplicacin con cmara. ............................................................................................ 83
Manejo de imgenes. ....................................................................................................... 91
Carga de una Imagen desde Internet ................................................................................. 95
Carga de una imagen desde la Galera de fotos .................................................................. 96
Ejercicio subir imgenes a servicio..................................................................................... 97
Redes Sociales........................................................................................................................102
Uso de SL Request. ..........................................................................................................102
Integrar Twitter...............................................................................................................106
Integrar Facebook. ..........................................................................................................108
Disear interface de usuario. ...........................................................................................111
Realizar "testing" a la aplicacin.......................................................................................115
XML & JSON. ..........................................................................................................................118
Crear, modificar, eliminar archivos XML & JSON. ..................................................................118
Subir archivos a Web Service o FTP. .....................................................................................122
Crear certificados y aprovisionar perfiles. ................................................................................122
Tipos de licencias de desarrollo ...........................................................................................122
Apple Developer .............................................................................................................122
iOS University Program....................................................................................................123
iOS Developer Program ...................................................................................................123
iOS Developer Enterprise Program ...................................................................................123
Crear un certificado de desarrollo........................................................................................123
Instalar un App dentro de un dispositivo. .............................................................................125
Crear un App ID ..................................................................................................................126
Asociar un App ID con un APP..............................................................................................127
Crear un aprovisionamiento de perfil de desarrollo. .............................................................128

Compatibilidad de versiones. ..............................................................................................129
Anexo....................................................................................................................................130
Agregar icono a la aplicacin ...............................................................................................130
Archivar aplicacin para distribucin ...................................................................................138
Proceso de distribucin inalmbrica de apps ....................................................................138
Catlogo de apps internas ...............................................................................................138
Administracin de actualizaciones....................................................................................139
Administracin de dispositivos mviles ............................................................................139
Configurar la aplicacin en ITunes........................................................................................139
Registrarse como Apple Developer...................................................................................139
Entrando en el programa iOS Developer Program .............................................................140
Instalando Xcode: entorno de desarrollo ..........................................................................140
iOS Provisioning portal: certificados .................................................................................140
iOS Provisioning portal: dispositivos de entorno de pruebas ..............................................141
iOS Provisioning portal: App ID y Provisioning...................................................................141
Programar la aplicacin en Objective C.............................................................................141
Probar en iPhone/iPad/iPod ............................................................................................142
Subiendo la App a App Store con iTunes Connect..............................................................142
Manejo de directorios
Las clases NSFileManager, NSFileHandle y NSData
NSFileManager - Esta clase puede ser utilizada para realizar operaciones bsicas con archivos o
carpetas como crear, mover, leer y escribir archivos y leer y modificar los atributos de los mismos.
Tambin cuenta con mtodos para manejar los directorios, como leer su contenido, moverlos,
borrarlos, etc.
NSFileHandle - Esta clase provee de operaciones de bajo nivel y de alto rendimiento, como
bsqueda, lectura y escritura de archivos.
NSData - Esta clase maneja un buffer donde se puede leer y escribir los datos en un archivo.
Para las clases que se mencionan, los archivos se manejan como en UNIX. Utilizamos la diagonal
(/) para separar las carpetas. Si no inicia con la diagonal, entonces se considera a partir de l
directorio actual.
La carpeta inicial (o home) del cual puede el usuario iniciar, se maneja con una tilde (~). Si un
archivo se escribe como ~/miArchivo.m se hace referencia al archivo raz del usuario. Tambin se
puede hacer la referencia a un directorio raz de un usuario por medio de la tilde, por
ejemplo ~desarroll/demo.m, busca el directorio raz del usuario "desarrollo".
La clase NSFileManager contiene un mtodo llamado defaultManager podemos obtener la

referencia a la carpeta donde se encuentra la aplicacin:
NSFileManager *raiz;
raz = [NSFileManager defaultManager];
A partir de este archivo, podemos utilizarlo de como apuntador para a partir de l, leer archivos y
directorios.
Definir el directorio actual

El directorio de trabajo se puede obtener con el mtodo currentDirectoryPath de la clase
NSFileManager. El mtodo regresa el valor como una cadena NSString:
NSString *directorioActual;
raiz = [NSFileManager defaultManager];
directorioActual = [raiz currentDirectoryPath];

NSLog (@"El directorio actual es %@", directorioActual);
Cambiar Directorios
Por medio del mtodo changeCurrentDirectoryPath podemos cambiar de directorio de la
aplicacin. El nuevo destino del directorio es pasada como parmetro como un objetoNSString.
Este mtodo regresar un valor Booleano (YES/NO) para indicar si el cambio se efectu en forma
exitosa o si existi un error:
NSString *dirActual;
dirActual = [raiz currentDirectoryPath];
NSLog (@"El directorio actual es %@", dirActual);
if ([raiz changeCurrentDirectoryPath: @"/temp/mydir"] == NO)
NSLog (@"Error al cambiar de directorio.");
dirActual = [raiz currentDirectoryPath];
NSLog (@"El directorio actual es %@", dirActual);
Crear Leer y Borrar Directorios
Crear un directorio
Podemos crear un nuevo directorio por medio del mtodo createDirectoryAtURL pasndole como
un argumento a una instancia de la clase NSURL. Podemos pasarle diferentes atributos para el
directorio:
NSURL *newDir = [NSURL fileURLWithPath:@"/tmp/mynewdir"];
[raiz createDirectoryAtURL: newDir withIntermediateDirectories:YES
attributes: nil error:nil];
El mtodo createDirectoryAtURL regresa un valor booleano indicando si la operacin fue exitosa o

no.
Borrar un directorio
Un directorio puede ser borrado del disco del sistema utilizando el mtodo removeItemAtPath,
pasando como argumento el directorio que se desee eliminar:
raiz= [NSFileManager defaultManager];
[raiz removeItemAtPath: @"/tmp/mynewdir" handler: nil];
Renombrar o mover un directorio

Un directorio puede ser movido o renombrado usando el mtodo moveItemAtURL. Este mtodo
toma como argumentos el origen y el destino por medio de objetos NSURL y es necesario que el
objeto final NO EXISTA. Si el objeto destino ya existe, el mtodo regresara un valor booleano
negativo (NO):
NSURL *dirOrigen= [NSURL fileURLWithPath:@"/tmp/mynewdir"];
NSURL *dirNuevo= [NSURL fileURLWithPath:@"/tmp/mynewdir2"];
[raiz moveItemAtURL: dirOriegan toURL: dirNuevo error: nil];
Listar contenido de un directorio
La lista de los archivos contenidos en un directorio se puede obtener por medio del mtodo
contentsOfDirectoryAtPath. Este mtodo toma como argumento el camino del directorio que se
desea leer como una cadena NSString y regresa un arreglo con los nombre de los archivos y
subdirectorios contenidos:
NSString *dirActual;
NSArray *listaArchivos;
int num;
int i;

listaArchivos= [raiz contentsOfDirectoryAtPath: @"/tmp" error: nil];
num= [listaArchivos count];
for (i = 0; i < num; i++)
NSLog (@"%@", [listaArchivos objectAtIndex: i]);
Obtener atributos de un archivo o directorio
Los atributos de un archivo o directorio se pueden obtener usando el mtodo

attributesOfItemAtPath. Este toma como argumentos la ruta del directorio y un objeto NSError
opcional en el que se colocar la informacin sobre cualquier error (puede especificarse como
NULL si no se requiere esta informacin). Los resultados se devuelven en forma de un objeto de
diccionario NSDictionary.
NSFileManager *filemgr;
NSDictionary *attribs;
filemgr=[NSFileManager defaultManager];
attribs=[filemgr attributesOfItemAtPath:
@"/Applications" error:Null];
NSLog (@"File Type %@",[attribs objectForKey:NSFileType]);
NSLog (@"POSIX Permissions %@",[attribs
objectForKey:NSFilePosixPermissions]);
Manejo de archivos
Uno de los temas ms importantes para hacer aplicaciones robustas con Objective-C es el manejo
de archivos.
El directorio por referencia
1.
Primero debemos de obtener el directorio de la aplicacin, la cual por lo general la
conocemos como "home", "root" o "raiz".
2.
Esta referencia raz la obtenemos con el mtodo defaultManager de la
claseNSFileManager, creando una instancia de la misma:
Verificar si existe un archivo

1.
La clase NSFileManager contiene un mtodo llamado fileExistsAtPath el cual
verifica la existencia de un archivo.
2.
El mtodo toma como argumento una cadena NSString y regresar un valor
booleano verdadero (YES) si el archivo existe o un valor negativo (NO) de lo contrario:
if ([raiz fileExistsAtPath: @"/tmp/myfile.txt" ] == YES)
NSLog (@"Si existe el archivo");
else
NSLog (@"Archivo no encontrado");
Comparacin de dos archivos

Podemos comparar el contenido de dos archivos por medio del mtodo contentsEqualAtPath. Este
mtodo toma como argumentos al nombre y el directorio de los dos archivos. Regresa un valor
falso (NO) si es que son diferentes y un verdadero (YES) si los contenidos son iguales:

if ([raiz contentsEqualAtPath: @"/tmp/compras.txt" andPath:
@"/tmp/ventas.txt"] == YES)
NSLog (@"Los contenidos son iguales");
else
NSLog (@"Los contenidos son diferentes");
Verificando los permisos del archivo

La mayora de los sistemas operativos (de servidores, locales o de dispositivos mviles) asignan
"permisos" a cada archivo y directorio. Por medio de los siguientes mtodos podemos saber si se
cuenta con el permiso
respectivo: isReadableFileAtPath,isWritableFileAtPath, isExecutableFileAtPath y isDeletableFileAtP
ath. Cada uno regresa un valor booleano verdadero (YES) si el archivo tiene ese permiso o un falso
(NO) si no lo tiene
if ([raiz isWritableFileAtPath: @"/tmp/myfile.txt"] == YES)
NSLog (@"El archivo tiene permiso para ser escrito");
else
NSLog (@"El archivo es slo lectura");
Mover o renombrar un archivo

Un archivo puede ser renombrado, en caso que tenga ese permiso, usando el mtodo
moveItemAtURL. Este mtodo regresar un valor booleano verdadero (YES) si la accin de
renombrar fue exitosa y uno falso (NO) de lo contrario. Se tiene un objeto de tipo error NSError, el
cual devuelve un valor nil si la operacin fue exitosa, y un objeto de error si la operacin de
renombrar fall:
NSURL *dirAct = [NSURL fileURLWithPath:@"/tmp/archivoActual.txt"];
NSURL *dirNuevo= [NSURL fileURLWithPath:@"/tmp/archivoNuevo.txt"];
[raiz moveItemAtURL: dirAct toURL: dirNuevo error: nil];
Copiar un archivo
Por medio del mtodo copyItemAtPath es posible copiar un archivo. Los argumentos y valores de
respuesta son los mismos que en el proceso de renombrar el archivo que se vieron en el segmento
anterior.
if ([raiz copyItemAtPath: @"/tmp/archivoActual.txt" toPath:
@"/Users/demo/archivoNuevo.txt" error: NULL] == YES)
NSLog (@"Copia exitosa");
else
NSLog (@"Error en la copia");
Borrar un archivo
El mtodo removeItemAtPath permite borrar o remover un archivo. El mtodo toma el nombre de
archivo con su camino (opcional) y un objeto de la clase NSError. Regresa un valor booleano en
respuesta a la operacin, indicando si la misma fue exitosa (YES) o no (NO).
if ([raiz removeItemAtPath: @"/tmp/miArchivo.txt" error: NULL]
NSLog (@"Borrado exitoso");
else
NSLog (@"Error al borrar");
== YES)
Crear un link simblico

Podemos crear un link simblico a un archivo por medio del mtodo createSymbolicLinkAtPath.
Los argumentos de este mtodo son el camino que deseamos volver link simblico, el nombre del
archivo y un objeto de la clase NSError, que regresa algn valor si la operacin no fue satisfactoria.
10
if ([raiz createSymbolicLinkAtPath: @"/tmp/archivo2.txt"
withDestinationPath: @"/tmp/archivo.txt" error: nil] ==
YES)
NSLog (@"Ligado exitoso");
else
NSLog (@"Error al crear el link");
Leer y escribir archivos con NSFileManager

Una forma muy bsica y limitada de leer y escribir archivos es por medio de la clase
NSFileManager.
El contenido que se va a grabar debe de estar contenido en un objeto de tipo NSData antes de
utilizar el mtodo contentsAtPath:
NSData *databuffer;
databuffer = [raiz contentsAtPath: @"/tmp/archivo.txt" ];
Una vez que los datos estn almacenados en el objeto NSData, podemos utilizar el
mtodo createFileAtPath para escribir el archivo:
databuffer = [raiz contentsAtPath: @"/tmp/archivo.txt" ];

[raiz createFileAtPath: @"/tmp/ArchivoNuevo.txt" contents: databuffer
attributes: nil];
Esta forma de crear un archivo no nos permite saber cunta informacin se copi ni hacer una
11
operacin de append al final del mismo. Si el archivo destino ya existe, se sobrescribe perdiendo
los datos anteriores. Una forma mucho ms robusta de grabar informacin es por medio de la
clase NSFileHandle perteneciente al Framework-Fundation.
Uso de la clase NSFileHandle para la operacin con archivos
La clase NSFileHandle ofrece una amplia gama de mtodos diseados para proporcionar un
mecanismo ms avanzado para trabajar con archivos. Adems de los archivos, esta clase tambin
se puede utilizar para trabajar con dispositivos y conectores de red. En las siguientes secciones
vamos a ver algunos de los usos ms comunes de esta clase.
Crear un objeto NSFileHandle
Un objeto NSFileHandle al abrir un archivo para leer, escribir o aadir datos al final del mismo.
Para ello se pueden utilizar, respectivamente, los siguientes mtodos:
fileHandleForReadingAtPath,
fileHandleForWritingAtPath
fileHandleForUpdatingAtPath
Una vez efectuado su operacin, se deber cerrar con el mtodo closeFile. Si el proceso de
apertura del archivo falla, el mtodo regresar un valor de nil.
NSFileHandle *archivo;
archivo = [NSFileHandle fileHandleForWritingAtPath: @"/tmp/archivo.txt"];
if (archivo == nil)
NSLog(@"Error al abrir el archivo");
[archivo closeFile];
Proceso de desplazamiento (Offsets) y bsqueda (Seeking)

1.
Un objeto de la clase NSFileHandle mantiene un apuntador para marcar la
posicin actual del archivo.
2.
Esta posicin se le conoce como offset, o el desplazamiento del apuntador con
respecto al inicio del arc hivo.
3.
Cuando el archivo es abierto, este apuntador se encuent ra al inicio del mismo y su
valor es cero (0).
12
4.
cero.
Esto quiere decir que cualquier operacin iniciar con un valor del apunt ador de
5.
Para efectuar una operacin en otra parte del archivo, digamos al final,
necesitamos primero buscar (seek) es e desplazamiento (offset).
6.
Por ejemplo, si desea mover el apuntador al final del archivo, puede hac erlo por
medio del mtodo seek ToEndOfFile .
7.
Si desea mover el apuntador a un lugar en especfico, puede utilizar el mtodo
seek ToFileOffset el cual le permite es pecificar el lugar ex acto dentro del archivo.
8.
Para identific ar el lugar donde se encuentra el apuntador, puede hacerlo con el
mtodo offsetInFile.
9.
Para que el apuntador pueda almac enar su ubicacin en un archivo muy grande,
su tipo es un entero unsigned long long.
Por ejemplo:
NSFileHandle * archivo;
archivo = [NSFileHandle fileHandleForUpdatingAtPath:
@"/tmp/archivo.txt"];
if (archivo == nil)
NSLog (@"Offset = %llu", [archivo offsetInFile]);
[archivo seekToEndOfFile];
[archivo seekToFileOffset: 30];
Leer datos en un archivo

1.
Una vez que se ha abierto el archivo y que tenemos la referencia, el contenido del
mismo puede ser ledo a partir de la posicin del apuntador (offset).
2.
El mtodo readDataOfLengt h lee un nmero especific ado de nmeros de bytes a
partir del apuntador (offset).
3.
Por ejemplo, el siguiente cdigo lee 5 bytes a partir de la posicin 10 a partir del
inicio del arc hivo.
13
4.
La informacin leda es enc apsulada dentro de un objeto NS Data:
NSData *databuffer;
archivo = [NSFileHandle fileHandleForReadingAtPath: @"/tmp/archivo.txt"];
if (archivo == nil)
NSLog(@"Failed to open file");
databuffer = [archivo readDataOfLength: 5];
El mtodo readDataToEndOfFile lee los datos encontrados desde el offset hasta el fin del archivo.
Escribir los datos en el archivo
El mtodo writeData escribe la informacin encontrada en un objeto NSData a partir de la
ubicacin del apuntador u offset.
Este proceso no inserta datos, ms bien los sobrescribe.
Para ver este comando en accin, cree un archivo de texto con la sentencia:
hola, cara de bola
A continuacin ejecute el siguiente cdigo:
#import <Foundation/Foundation.h>
int main (int argc, const char * argv[])
{
@autoreleasepool {
NSMutableData *data;
const char *bytestring = "black dog";
data = [NSMutableData dataWithBytes:bytestring
length:strlen(bytestring)];
14

if (archivo == nil)

[archivo writeData: data];
}
return 0;
}
Abra con un editor el archivo para ver el cambio.

Truncar un archivo
Un archivo puede ser truncado por medio del mtodo truncateFileAtOffset.
Para borrar todo el contenido del archivo, el apuntador u offset deber encontrarse al inicio del
archivo, es decir, ser cero:
if (archivo == nil)
[archivo truncateFileAtOffset: 0];
15
Base de Datos
El uso de las bases de datos ya se ha extendido de los servidores hacia los dispositivos
mviles. El desarrollo constante de la tecnologa conjuntamente con los nuevos
requerimientos de las empresas ha llevado a crear diversos mtodos de almacenamiento de
informacin en dispositivos mviles, embebidos y empotrados.
La demanda de bases de datos para dispositivos mviles como PDAs y telfonos celulares ha
crecido exponencialmente en los ltimos aos debido a la necesidad de las empresas de tener
la informacin al instante de lo que sucede en el campo y as responder ms rpidamente ante
la competencia. Esta necesidad ha provocado que el almacenamiento de los datos en estos
dispositivos haya mejorado tanto en capacidad como en herramientas. Gracias a esto,
actualmente contamos con diversas opciones de manejadores de bases de datos para
mviles, y una de mis favoritas es SQLite, que es en la que se enfoca este artculo.
Qu es SQLite?
SQLite es una herramienta de software libre, que permite almacenar informacin en
dispositivos empotrados de una forma sencilla, eficaz, potente, rpida y en equipos con pocas
capacidades de hardware, como puede ser una PDA o un telfono celular. SQLite implementa
el estndar SQL92 y tambin agrega extensiones que facilitan su uso en cualquier ambiente
de desarrollo. Esto permite que SQLite soporte desde las consultas ms bsicas hasta las
ms complejas del lenguaje SQL, y lo ms importante es que se puede usar tanto en
dispositivos mviles como en sistemas de escritorio, sin necesidad de realizar procesos
complejos de importacin y exportacin de datos, ya que existe compatibilidad al 100% entre
las diversas plataformas disponibles, haciendo que la portabilidad entre dispositivos y
plataformas sea transparente.
Historia
SQLite apareci en mayo del ao 2000 de la mano de su creador D. Richard Hip, quin ha
liberado las diferentes versiones de SQLite en base a la licencia GPL por lo que su cd igo es
de dominio pblico y puede ser modificado por cualquier persona. Gracias a esto, SQLite ha
sido mejorada a lo largo de 7 aos por un gran nmero de colaboradores y tambin ha sido
migrada a diversas plataformas.
Caractersticas
Estas son algunas de las caractersticas principales de SQLite:
La base de datos completa se encuentra en un solo archivo.

Puede funcionar enteramente en memoria, lo que la hace muy rpida.
Tiene un footprint menor a 230KB.
Es totalmente autocontenida (sin dependencias externas).
Cuenta con libreras de acceso para muchos lenguajes de programacin.
16
Soporta texto en formato UTF-8 y UTF-16, as como datos numricos de 64 bits.

Soporta funciones SQL definidas por el usuario (UDF).
El cdigo fuente es de dominio pblico y se encuentra muy bien documentado.
Plataformas de SQLite
SQLite est construida en C, lo cual facilita la migracin a diversas plataformas de sistemas
operativos y de dispositivos. Dado que una base de datos de SQLite se almacena por
completo en un solo archivo, est puede ser exportada a cualquier otra plataforma y tener
interoperatibilidad al 100% sin ningn requerimiento de programacin adicional o cambios de
configuracin.
Las plataformas principales dnde SQLite se encuentra funcionando son:
Windows 95, 98, ME, 2000, XP y Vista

Windows CE & Pocket PC
Mac OSX
Linux
OpenEmbedded
PalmOS
Symbian
Aplicaciones de SQLite
Las caractersticas y plataformas previamente mencionadas hacen de SQLite una excelente
opcin en diversos casos tales como:
Cuando se requiere una base de datos integrada dentro de una aplicacin. SQLite es una
excelente opcin por su facilidad de configuracin. El inconveniente es que no escala a bases
de datos demasiado grandes (en el orden de los terabytes).
Para realizar demostracin de aplicaciones que utilizan un RDBMS (Para que utilizar un
manejador de BD pesado que ocupa grandes recursos de sistema cuando solo se requiere
hacer un demo de una aplicacin?)
Como cache local de un manejador de base de datos empresarial. Esto acelera el tiempo de
respuesta y reduce la carga sobre la base de datos central.
Para aplicaciones en dispositivos mviles que manejan una BD local que se sincroniza por
batch con una base de datos remota.
Almacenamiento persistente de objetos, configuraciones y preferencias de usuario. Permite
fcilmente crear una estructura para almacenar configuraciones de la aplicacin.
17
Estructurar BD
Si deseamos conocer la estructura de una base de datos SQLite tan solo tenemos que hacer un
SELECT a la tabla sqlite_master.
Esta tabla es una tabla especial de SQLite que conserva la estructura de todo el fichero de la base
de datos, por lo tanto nos informa de todas las tablas que contiene y sus respectivos campos.
Por ejemplo, para volcar la informacin:
SELECT * FROM sqlite_master
Y para ver la definicin (en formato SQL) de la tablas, realizamos una consulta sobre el
campo sql del tipo table con:
SELECT sql FROM sqlite_master WHERE type='table'
Abrir o Crear una BD.
En primer lugar, necesitamos crear las tablas de nuestra base de datos. Para ello, nos
descargaremos el addon de Firefox SQLite Database Manager. Si no utilizamos Firefox, tambin
podemos descargar un gestor desde SQLAbs. Ejecutamos el addon y creamos una nueva base de
datos, utilizando el botn que se indica en la imagen:
18
Elegimos el nombre que queramos. Una vez aceptemos, nos crear un fichero .sqlite con el
nombre que hayamos elegido en la ubicacin que queramos. Para este ejemplo, hemos elegido el
nombre vehiculos.sqlite.
Crear Tabla de BD.
A continuacin hacemos click en el botn de Crear Tabla y podremos crear la primera tabla de
nuestra nueva base de datos. Rellenamos los campos tal y como se ve en la siguiente imagen:
Prepara y Ejecutar sentencias SQL

Una vez creada nuestra tabla, vamos a insertar algunos datos de prueba en ella. Para ello,
desplegamos la seccin de Tables y despus seleccionamos nuestra tabla. Con nuestra tabla
seleccionada, en la parte derecha de la ventana veremos un botn que nos permitir aadir una
nueva fila a la tabla. En la siguiente imagen vemos de qu botn se trata:
19
Nos aparecer una ventana con los tres campos de la tabla para rellenar. Insertamos los datos que
queramos (para este ejercicio, con tres vehculos nos bastar) rellenando todos los campos y
confirmando los cambios cuando el programa nos lo pida. Repetimos la operacin hasta completar
el nmero de vehculos que queramos. Para finalizar, una vez hayamos insertado el ltimo,
hacemos click en el botn de cancelar y nos aparecer lo siguiente por pantalla:
20
Con esto terminan nuestras operaciones con el gestor de base de datos.

Integrar SQL Lite en proyecto
A continuacin vamos a crear el proyecto de XCode con el que crearemos nuestra aplicacin.
Elegimos un proyecto de tipo Single View Application y lo nombramos como queramos, en este
caso hemos elegido el nombre VehiculosCRUD. Indicaremos que la aplicacin ser para iPhone,
utilizar Storyboards y tambin utilizar ARC.
Una vez hayamos creado el proyecto, nos dirigimos a la seccin de Linked Frameworks and
Libraries y aadimos una nueva entrada con el botn +. En el buscador que se nos abre, buscamos
la librera libsqlite3.0.dylib y la aadimos. Ahora, buscamos el fichero que contiene nuestra base
de datos, la cual hemos creado antes y lo arrastramos a la lista de ficheros del proyecto. En la
pantalla que aparece, dejamos las opciones tal y como se ven en la siguiente imagen:
21
Ahora vamos a crear las operaciones. Primero crearemos un grupo y lo haremos desde el men
File y seleccionando la opcin New Group. Le pondremos como nombre modelo. Una vez creado el
nuevo grupo, crearemos la clase que nos mapear la tabla de vehculo. La clase la crearemos
seleccionando el nuevo grupo y, desde el men contextual, seleccionaremos New File. Elegimos
Objective-C class, le indicamos que ser una subclase de NSObject y la llamaremos Vehiculo. Una
vez la creemos, le aadimos las propiedades necesarias para mapear los campos de la tabla de
base de datos, tal y como podemos ver en el siguiente cdigo:
Vehiculo.h
@interface Vehiculo : NSObject{
NSInteger vehiculoID;
NSString *nombreVehiculo;
NSInteger numeroRuedas;
}
@property (nonatomic, assign) NSInteger vehiculoID;
@property (nonatomic, retain) NSString *nombreVehiculo;
@property (nonatomic, assign) NSInteger numeroRuedas;
@end
22
Vehiculo.m
#import "Vehiculo.h"
@implementation Vehiculo
@synthesize vehiculoID;
@synthesize nombreVehiculo;
@synthesize numeroRuedas;
@end
A continuacin creamos la clase que nos permitir realizar las operaciones contra la base de datos.
Esta clase tambin la crearemos dentro del grupo modelo. Repetimos la misma operacin con la
que creamos la clase Vehiculo: Objective-C class, subclase de NSObject y la llamaremos
VehiculoDAO.
Extraer informacin de una BD.
Una vez creada, le aadiremos las propiedades necesarias y definiremos los mtodos de obtener
datos y obtener la ruta de base de datos, tal y como podemos ver en el siguiente cdigo:
VehiculoDAO.h
#import
@interface VehiculoDAO : NSObject{
sqlite3 *bd;
}
- (NSMutableArray *) obtenerVehiculos;
- (NSString *) obtenerRutaBD;
@end
VehiculoDAO.m
#import "VehiculoDAO.h"
@implementation VehiculoDAO
- (NSString *) obtenerRutaBD{
NSString *dirDocs;
NSArray *rutas;
NSString *rutaBD;
rutas = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory,
NSUserDomainMask, YES);
dirDocs = [rutas objectAtIndex:0];
23
NSFileManager *fileMgr = [NSFileManager defaultManager];

rutaBD = [[NSString alloc] initWithString:[dirDocs
stringByAppendingPathComponent:@"vehiculos.sqlite"]];
if([fileMgr fileExistsAtPath:rutaBD] == NO){
[fileMgr copyItemAtPath:[[[NSBundle mainBundle] resourcePath]
stringByAppendingPathComponent:@"vehiculos.sqlite"] toPath:rutaBD
error:NULL];
}
return rutaBD;
}
- (NSMutableArray *) obtenerVehiculos{
NSMutableArray *listaVehiculos = [[NSMutableArray alloc] init];
NSString *ubicacionDB = [self obtenerRutaBD];
if(!(sqlite3_open([ubicacionDB UTF8String], &bd) == SQLITE_OK)){
NSLog(@"No se puede conectar con la BD");
}
const char *sentenciaSQL = "SELECT id, nombre_vehiculo,
numero_ruedas FROM vehiculo";
sqlite3_stmt *sqlStatement;
if(sqlite3_prepare_v2(bd, sentenciaSQL, -1, &sqlStatement, NULL)
!= SQLITE_OK){
NSLog(@"Problema al preparar el statement");
}
while(sqlite3_step(sqlStatement) == SQLITE_ROW){
Vehiculo *vehiculo = [[Vehiculo alloc] init];
vehiculo.vehiculoID = sqlite3_column_int(sqlStatement, 0);
vehiculo.nombreVehiculo = [NSString
stringWithUTF8String:(char *) sqlite3_column_text(sqlStatement, 1)];
vehiculo.numeroRuedas = sqlite3_column_int(sqlStatement,
2);
[listaVehiculos addObject:vehiculo];
}
return listaVehiculos;
}
Hemos creado el mtodo obtenerRutaBD el cual usaremos en la segunda parte del ejercicio, en el
que realizaremos inserciones, modificaciones y borrados. El propsito de este mtodo es el de
copiar al directorio de Documents del dispositivo el fichero .sqlite siempre y cuando ste no
exista. Esto es debido a que no se puede escribir en ficheros que se encuentren en la raz de la
aplicacin (main bundle) ya que es de slo lectura. Por otro lado, en el mtodo obtenerVehiculos
podemos ver cmo se obtiene la ruta de nuestro fichero de base de datos, se abre la conexin, se
prepara la sentencia y se lanza. Todo esto puede hacerse gracias a los mtodos sqlite3_open,
sqlite3_prepare_v2 y sqlite3_step.
24
Ahora crearemos nuestro storyboard para poder gestionar todas estas operaciones. Primero de
todo, aadiremos a nuestro storyboard un TableViewController. Una vez aadido, selecci onamos el
controller y una vez hecho esto, abrimos el men Editor y seleccionamos la opcin Embed In ->
Navigation Controller. Tambin aadiremos un ViewController al storyboard, y a este nuevo
ViewCont roller le aadimos dos UILabel y dos UITextField y le ponemos como identificador el
nombre visualizacin, quedando finalmente nuestro storyboard t al y como muestra la siguiente
imagen:
Tambin seleccionamos la celda del TableViewController y le ponemos como identificador el

nombre celda.
Ahora vamos a centrarnos en mostrar datos en el TableViewController. Lo primero que haremos
ser crear una nueva clase que sea una subclase de UITableViewController, la
llamaremos ListaVehiculosViewController y en nuestro storyboard se la asignaremos al
TableViewController. En esta nueva clase definiremos un objeto de tipo VehiculoDAO y otro de
tipo NSMutableArray. En el mtodo viewDidLoad inicializaremos estos dos objetos y, una vez
inicializados, lanzaremos una consulta para que nos devuelva todos los vehculos de nuestra tabla
con este cdigo:
ListaVehiculosViewController.h
#import <UIKit/UIKit.h>
@interface ListaVehiculosViewController : UITableViewController{
VehiculoDAO *dao;
NSMutableArray *vehiculos;
}
@property (nonatomic, strong) VehiculoDAO *dao;
@property (nonatomic, strong) NSMutableArray *vehiculos;
@end
ListaVehiculosViewController.m
25
@synthesize dao;
@synthesize vehiculos;
- (void)viewDidLoad
{
dao = [[VehiculoDAO alloc] init];
vehiculos = [[NSMutableArray alloc] init];
vehiculos = [dao obtenerVehiculos];
[super viewDidLoad];
}
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
return 1;
}
- (NSInteger)tableView:(UITableView *)tableView
numberOfRowsInSection:(NSInteger)section
{
return [vehiculos count];
}
- (UITableViewCell *)tableView:(UITableView *)tableView
cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
static NSString *CellIdentifier = @"celda";
UITableViewCell *cell = [tableView
dequeueReusableCellWithIdentifier:CellIdentifier];
cell.textLabel.text = [[vehiculos objectAtIndex:[indexPath row]]
valueForKey:@"nombreVehiculo"];
return cell;
}
- (void)tableView:(UITableView *)tableView
didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
ModVehiculoViewController *destino = [self.storyboard
instantiateViewControllerWithIdentifier:@"visualizacion"];
Vehiculo *tmp = [vehiculos objectAtIndex:[indexPath row]];
destino.vehiculo = tmp;
[self.navigationController pushViewController:destino animated:YES];
}
Como podemos ver en el cdigo, le indicaremos que slo tendr una seccin y el nmero de filas
ser el tamao del array que nos devuelva la consulta. Tambin hemos implementado el mtodo
didSelectRowAtIndexPath para hacer la transicin desde la celda hasta el ViewController que nos
ensear los datos del vehculo.
26
Por ltimo, nos centraremos en el ViewController de destino. Para ello, vamos a aprovecharnos de
la clase ViewController que se crea por defecto cuando creamos el proyecto. Primero de todo, la
renombramos a ModVehiculoViewController y se la asignamos en el storyboard al ViewController.
Una vez hecho esto, en la clase definiremos los IBOutlet necesarios, un objeto de
tipo VehiculoDAO y otro objeto de tipo Vehiculo. Por ltimo, definiremos tambin un mtodo para
ocultar el teclado. La clase quedar como puede verse en el siguiente cdigo:
ModVehiculoViewController.h
@interface ModVehiculoViewController : UIViewController{
IBOutlet UILabel *etqNombre;
IBOutlet UILabel *etqRuedas;
IBOutlet UITextField *txtNombre;
IBOutlet UITextField *txtRuedas;
VehiculoDAO *dao;
Vehiculo *vehiculo;
}
@property
@property
@property
@property
@property
@property
(nonatomic,
(nonatomic,
(nonatomic,
(nonatomic,
(nonatomic,
(nonatomic,
strong)
strong)
strong)
strong)
strong)
strong)

Vehiculo *vehiculo;
VehiculoDAO *dao;
- (IBAction) ocultarTeclado:(id)sender;
@end
ModVehiculoViewController.m
@synthesize etqNombre;
@synthesize etqRuedas;
@synthesize txtNombre;
@synthesize txtRuedas;
@synthesize dao;
@synthesize vehiculo;
-(void) touchesBegan :(NSSet *) touches withEvent:(UIEvent *)event{
[txtNombre resignFirstResponder];
[txtRuedas resignFirstResponder];
[super touchesBegan:touches withEvent:event ];
}
- (IBAction)ocultarTeclado:(id)sender{
}
- (void)viewDidLoad
{
[txtNombre setText:vehiculo.nombreVehiculo];
27
[txtRuedas setText:[NSString stringWithFormat:@"%d",

vehiculo.numeroRuedas]];
[txtRuedas setKeyboardType:UIKeyboardTypeNumberPad];
}
Y con esto ya tenemos la primera parte del ejercicio. Bastar con ejecutar el simulador para ver el
resultado:
28
Ahora vamos a hacer va completar la clase VehiculoDAO aadindole los mtodos necesarios
para realizar el resto de operaciones. El cdigo fuent e a aadir es el siguient e:
VehiculoDAO.h
- (void) crearVehiculo: (NSString *)nombre ruedas:(NSInteger) ruedas;
- (void) actualizarVehiculo: (NSInteger) vehiculoID nombre:(NSString
*)nombre ruedas:(NSInteger) ruedas;
- (void) borrarVehiculo: (NSInteger) vehiculoID;
VehiculoDAO.m
- (void) crearVehiculo:(NSString *)nombre ruedas:(NSInteger)ruedas{
NSString *ubicacionDB = [self obtenerRutaBD];
if(!(sqlite3_open([ubicacionDB UTF8String], &bd) == SQLITE_OK)){
return;
} else {
NSString *sqlInsert = [NSString stringWithFormat:@"INSERT INTO
vehiculo (nombre_vehiculo, numero_ruedas) VALUES ('%@', %d)", nombre,
ruedas];
const char *sql = [sqlInsert UTF8String];
if(sqlite3_prepare_v2(bd, sql, -1, &sqlStatement, NULL) !=
SQLITE_OK){
NSLog(@"Problema al preparar el statement");
return;
} else {
if(sqlite3_step(sqlStatement) == SQLITE_DONE){
sqlite3_finalize(sqlStatement);
sqlite3_close(bd);
}
}
}
}
- (void) actualizarVehiculo:(NSInteger) vehiculoID nombre:(NSString
*)nombre ruedas:(NSInteger)ruedas{
NSString *ubicacionBD = [self obtenerRutaBD];
if(!(sqlite3_open([ubicacionBD UTF8String], &bd) == SQLITE_OK)){
return;
} else {
NSString *sqlUpdate = [NSString stringWithFormat:@"UPDATE vehiculo
SET nombre_vehiculo = '%@', numero_ruedas = %d WHERE id = %d", nombre,
ruedas, vehiculoID];
const char *sql = [sqlUpdate UTF8String];
SQLITE_OK){
NSLog(@"Problema al preparar el statement.");
return;
} else {
29
sqlite3_close(bd);
}
}
}
}
- (void) borrarVehiculo:(NSInteger) vehiculoID{
NSString *ubicacionBD = [self obtenerRutaBD];
if(!(sqlite3_open([ubicacionBD UTF8String], &bd) == SQLITE_OK)){
return;
} else {
NSString *sqlDelete = [NSString stringWithFormat:@"DELETE FROM
vehiculo WHERE id = %d", vehiculoID];
const char *sql = [sqlDelete UTF8String];
SQLITE_OK){
NSLog(@"Problema al preparar el statement.");
return;
} else {
sqlite3_close(bd);
}
}
}
}
Como podemos ver, en estos mtodos se hacen prcticamente los mismos pasos que en el
mtodo de consulta, lo nico que cambia es qu sentencia SQL se lanza y el procesamiento final.
Ahora vamos a dirigirnos al storyboard y aadiremos un nuevo ViewController. A este
ViewController le aadiremos dos UILabel, dos UITextField y un UIButton. El ViewController
deber quedar as:
30
A continuacin vamos a crear una nueva clase en nuestro proyecto y la llamaremos

AltaVehiculoViewController y se la asignamos en el storyboard a este nuevo ViewController. Una
vez renombrada, definimos los IBOutlet necesarios y definimos el IBAction correspondiente al alta
de un nuevo elemento. Tambin definiremos un objeto de tipo VehiculoDAO, el cual nos
permitir conectar con la base de datos y lanzar las operaciones necesarias. En el mtodo
viewDidLoad inicializaremos el dao y ya estar listo para utilizarse. Ahora slo queda programar el
proceso de alta y ste es el cdigo que nos permitir hacerlo:
AltaVehiculoViewController.h
@interface AltaVehiculoViewController : UIViewController{
IBOutlet UIButton *btnCrear;
31
VehiculoDAO *dao;
}
@property
@property
@property
@property
@property
@property
(nonatomic,
(nonatomic,
(nonatomic,
(nonatomic,
(nonatomic,
(nonatomic,
strong)
strong)
strong)
strong)
strong)
strong)

IBOutlet UIButton *btnCrear;
VehiculoDAO *dao;
- (IBAction) ocultarTeclado:(id)sender;
- (IBAction) crearNuevoVehiculo:(id)sender;
@end
AltaVehiculoViewController.m
@synthesize etqNombre;
@synthesize etqRuedas;
@synthesize txtNombre;
@synthesize txtRuedas;
@synthesize btnCrear;
@synthesize dao;
-(void) touchesBegan :(NSSet *) touches withEvent:(UIEvent *)event{
[txtNombre resignFirstResponder];
[txtRuedas resignFirstResponder];
[super touchesBegan:touches withEvent:event ];
}
- (void)viewDidLoad{
[txtRuedas setKeyboardType:UIKeyboardTypeNumberPad];
}
- (IBAction)ocultarTeclado:(id)sender{
}
- (IBAction) crearNuevoVehiculo:(id)sender{
NSString *nombre = [NSString stringWithFormat:txtNombre.text];
NSInteger ruedas = [txtRuedas.text integerValue];
[dao crearVehiculo:nombre ruedas:ruedas];
}
Hacemos los enlaces correspondientes en el storyboard, acordndonos de asociar todos los

mtodos (incluido el de ocultar el teclado) y ya tendremos lista esta clase. Nos volvemos a ir al
storyboard y en el TableViewController aadiremos un botn del tipo Bar Button Item en la barra
de navegacin. Uniremos este botn con el ViewController que acabamos de aadir mediante un
segue de tipo Push. Para ello, seleccionamos el botn y, con la tecla Control apretada, arrastramos
32
el ratn hacia el controller de destino. En el men desplegable que aparece, seleccionamos Push y
ya tendremos unidos el TableViewController y el ViewController de altas.
Nos dirigimos al ViewController que utilizamos en la primera parte como detalle de datos y le
aadiremos dos UIButton, uno para modificar y otro para borrar. Tambin hemos de editar la
clase ModVehiculoViewController para aadirle estos dos botones y los dos nuevos mtodos,
uno para borrar y otro para modificar un vehculo. Esto lo podemos ver en el siguiente cdigo:
ModVehiculoViewController.h
@interface ModVehiculoViewController : UIViewController{
<CODIGO ANTERIOR>
IBOutlet UIButton *btnModificar;
IBOutlet UIButton *btnBorrar;
}
<CODIGO ANTERIOR>
@property (nonatomic, strong) IBOutlet UIButton *btnModificar;
@property (nonatomic, strong) IBOutlet UIButton *btnBorrar;
- (IBAction) modificarVehiculo:(id)sender;
- (IBAction) borrarVehiculo:(id)sender;
ModVehiculoViewController.m
@synthesize btnModificar;
@synthesize btnBorrar;
- (IBAction)modificarVehiculo:(id)sender{
NSInteger vehiculoID = vehiculo.vehiculoID;
NSString *nombre = txtNombre.text;
NSInteger numRuedas = [txtRuedas.text integerValue];
[dao actualizarVehiculo:vehiculoID nombre:nombre
ruedas:numRuedas];
}
- (IBAction)borrarVehiculo:(id)sender{
NSInteger vehiculoID = vehiculo.vehiculoID;
[dao borrarVehiculo:vehiculoID];
}
Hacemos los enlaces correspondientes en el storyboard, incluyendo los actions que lanzar cada
botn y con esto ya tendremos listo nuestro ViewController para modificar y borrar datos. Una vez
hecho este montaje, el storyboard quedar as:
33
Una vez hechas todas estas acciones, ya tenemos lista nuestra aplicacin para hacer altas, bajas,
modificaciones y consultas contra una base de datos SQLite. Para aportar ms informacin,
podemos aadir una alerta cuando se haga cada operacin que suponga persistencia sobre la base
de datos. Slo nos queda ejecutar el simulador para ver el resultado:
34
Multitouch, Tap, y Gestos
Gestos, Taps y Touches
Un reconocedor de gesto (gesture) es en realidad un objeto de la clase abstracta

UIGestureRecognizer. Tal objeto se relaciona con una vista, y con monitores para gestos
predefinidos que existen en la vista. Yendo un nivel ms profundo, se puede decir que los gestos
son en realidad toques (touch) y movimientos de uno o ms dedos que suceden en un rea
especfica de la pantalla, donde existe una vista. En las primeras versiones de iOS SDK, los
reconocedores de gestos no fueron proporcionados a los desarrolladores, por lo que la aplicacin
de esas formas de interaccin requiere mucho trabajo manual. Afortunadamente, Apple ha
envuelto todo ese trabajo manual y se lo dio a los desarrolladores como una sola herramienta, y
de esa manera el trabajo con gestos se convirti en una parte realmente fcil de la programacin
iOS.
La clase UIGestureRecognizer en resumen, no se puede utilizar directame nte. Hay subclases
especficas que se proporcionan para su uso, y cada uno de ellos se ocupa para un tipo especfico
de gesto. Vamos a revisar cada uno de ellos y sabremos que hace cada uno:
UITapGestureRecognizer: Esta clase se refiere a los tap(golpecito) gestos realizados en una vista.
Se puede utilizar para manejar simples o multiples taps, ya sea con uno o ms dedos. Tapping es
uno de los gestos ms habituales que los usuarios hacen.
UISwipeGestureRecognizer: Otro gesto importante es el swipe (golpe), y existe esta clase slo
para l. Swiping sucede al arrastrar un dedo hacia una direccin (derecha, izquierda, arriba y
abajo). Existe un ejemplo caracterstico del gesto de deslizar en la aplicacin Fotos, donde
utilizamos nuestros dedos a deslizarse de una foto a otra.
UIPanGestureRecognizer: El gesto pan es en realidad un gesto de arrastrar. Se utiliza cuando es
necesario para arrastrar vistas desde un punto a otro.
UIPinchGestureRecognizer: Al ver las fotos en la aplicacin Fotos y utiliza sus dos dedos para
acercar o alejar a una foto, esto es realizar un gesto de pellizco. Como ustedes comprendern,
pellizcos requiere dos dedos. Un objeto de esta clase es generalmente til para cambiar la
transformacin de una vista, y ms especficamente su escala. Usando gestos de pellizco por
ejemplo, se puede aplicar el zoom dentro y fuera de las fotos en sus propias aplicaciones.
UIRotationGestureRecognizer: De acuerdo con el gesto anterior, la rotacin se utiliza para girar
una vista usando dos dedos.
35
UILongPressGestureRecognizer: Una clase que monitorea un gesto de prensa que tarda mucho en
una vista. El prensado debe durar lo suficiente para ser detectado, y el dedo o dedos no deben
moverse mucho alrededor del punto pulsado de lo contrario el gesto falla.
UIScreenEdgePanGestureRecognizer: ste es similar al gesto de golpe, pero con una gran
diferencia: el movimiento de los dedos debe comenzar siempre desde un borde de la pantalla.
Todos los objetos de tipo gesto realizan una accin una vez que se detecta un gesto vlido. Este
puede ser en un mtodo IBAction en caso de que se aada el gesto a travs de la Interface Builder,
o un mtodo privado o pblico en caso de implementacin programtica. Cuando se llama a una
accin de un mtodo despus de que un gesto ha sucedido, el objeto gesto siempre enva a s
mismo informacin adicional que se requiere cuando se manipule el gesto. Algunas de las
siguientes firmas de los mtodos son vlidos:
-(void)handleMyTapGesture;
-(void)handleMyTapGestureWithGestureRecognizer:(UITapGestureRecognizer
*)gestureRecognizer;
En el segundo caso, el argumento gestureRecognizer le puede proporcionar informacin adicional
que pueda necesitar, como en qu lugar se ejecuto el gesto.
Mirando ahora desde otro punto, una vista puede contener ms de un reconocedor de gesto. Por
ejemplo, puede agregar dos reconocedores de pellizco y gesto de rotacin a un imageview, por lo
que se puede hacer zoom in / out y girar la imagen presentada. Sin embargo, puede ocurrir un
solo gesto en un momento dado. Los Reconocedores de Gesto que estn relacionados con una
vista se aaden a una matriz, para que puedan acceder a ellos como lo hara para cualquier objeto
a una matriz normal.
36
Crear una aplicacin con Gestos.
Vamos a comenzar por la creacin de un nuevo proyecto en Xcode. Seleccionaremos una

aplicacin por pestaas(Tabs) como plantilla para el proyecto.
A continuacin, estableceremos como nombre GesturesDemo como al proyecto, y asegurarnos de

que este seleccionado iPhone como dispositivo
37
.
Seleccionaremos el directorio donde se almacenar el proyecto y es todo.
Ahora que el proyecto est listo, vamos a configurar la interfaz con la que trabajaremos mas tarde
para el reconocimiento de gestos. De clic sobre el archivo Main.storyboard, y con ello aparecer la
diseador de interfaz (Interface Builder). Como se observa, hay dos controladores de vista
conectados al controlador barra de pestaas, as que tenemos que aadir tres ms. Desde la
biblioteca de objetos, arrastre y suelte tres nuevos objetos View Controller al canvas IB.
Antes de conectamos a los controladores de vista de la barra de pestaas, debemos crear las clases
de controlador necesarias. Comencemos por seleccionar las clases FirstViewController y
SecondViewController (tanto el .h y archivos .m) en el Navegador de proyectos, y luego pulsa la
tecla Supr del teclado. No vamos a utilizar estos archivos, vamos a crear nuevas clases para los
reconocedores de gesto que vamos a trabajar.
38
En el cuadro de dilogo de confirmacin que aparece, haga clic en el botn Mover a la Papelera.
A continuacin, aadimos las nuevas clases al proyecto. El procedimiento que se presenta se debe
repetir cinco veces en total, hasta que todas las clases necesarias se hayan aadido al proyecto.
Vamos a ver los detalles de la primera:
Abra el men File> New> File ... y seleccione crear una nueva clase de Objective -C.
39
Da clic en Next y en el campo Subclass, asegrate que este seleccionado el valor UIViewController.
En seguida coloca el nombre a la clase TapViewController en el campo clase
40
Procede al ltimo paso, y haz clic en el botn Crear para poder terminar con el asistente y dejar
que Xcode cre y agregue la nueva clase al proyecto.
Generar los siguientes controladores con los siguientes nombres de las clases:
SwipeViewController
PanViewController
PinchViewController
RotationViewController
Despus de haber agregado todos ellos, as es como el Navegador de proyectos debe aparecer:
Ahora podemos volver al Interface Builder. En primer lugar, asegrese de que el panel Utili ties
est activo, ya que lo necesitar. A continuacin, seleccione el primer view controller creado
(vamos a empezar desde arriba hacia abajo), y se muestra el Inspector de identidad(Identity
Inspector) en el panel de Utilidades. All, en el campo Clase de la seccin de clase personalizada,
defina el nombre de la primera clase que ha aadido al proyecto, el * TapViewController:
41
Repita el paso anterior hasta que establezca todas las clases personalizadas a los controladores de
vista restantes.
Nuestro prximo paso es conectar todos los controladores de vista al controlador de la barra de
pestaas. Esto se puede hacer muy fcilmente, si se selecciona el controlador de la barra de
pestaas y luego se abre el Inspector Conexiones en el panel Utilidades. La seccin Segues Se
activa, haga clic en el crculo de la derecha de la opcin de los controladores de vista y arrastre en
la parte superior de cada controlador de vista que no est conectado, y proceder al conectarlos
uno por uno.
42
Una vez que se han realizado todas las conexiones, puede establecer los ttulos de los elementos
de los botones de barras de los controladores de vista. Empieza de la parte superior a la inferior,
seleccione el elemento de la barra de pestaas y abra el inspector de atributos en el panel de
Utilidades. All, establezca el ttulo propiamente para cada controlador de vista, y establecer la
primera como la imagen de todos los controladores de vista.
43
Los ttulos de los elementos de la barra de pestaas debe estar en el siguiente orden:
Tap
Swipe
Pan
Pinch
Rotation
Por ltimo, eliminar el contenido existente en los dos primeros controladores de vista pre -hechos.
Todo est listo ahora. Opcionalmente, se puede aadir una etiqueta como un ttulo para cada
controlador de vista. Si te gustara hacer eso tambin, a continuacin, arrastre un objeto UILabel a
cada controlador de vista y establecer los siguientes atributos:
Frame : X=20, Y=40, Width=280, Height=40

Font: System Bold, 20pt
Alignment: Center
Los textos de las etiquetas deben ser (siguiendo el mismo orden que antes):
44
Tap Gesture
Swipe Gesture
Pan Gesture
Pinch Gesture
Rotation Gesture
Ahora que tenemos la configuracin, podemos pasar directamente al corazn de nuestro tema.
Sin embargo, vamos a regresar varias veces aqu al Interface Builder con el objetivo de crear los
puntos de vista de las pruebas necesarias para cada reconocedor de gesto.
Detectar Gestos dentro de la pantalla
Empezamos la exploracin real del tema con el tap gesture recognizer. En la parte anterior, se ha
aadido todos los controladores de vista necesarios para el proyecto y estn conectados con el
controlador de la barra de pestaas. Ahora, en esta parte, vamos a aadir un objeto de vista
(UIView) al controlador de vista Tap, que usaremos como una vista de prueba con el fin de hacer
nuestro trabajo en el cdigo.
45
En primer lugar, asegrese de que usted tiene el Interface Builder todava haciendo clic en el
archivo Main.storyboard en el Navegador de proyectos. A continuacin, llevar la escena del
controlador de vista al Tap View Controller, y luego seleccionar un objeto UIView de la Biblioteca
de objetos y arrastrarlo a la vista. Establezca las siguientes propiedades:

Background Color: R=215, G=116, B=52
Ahora que la vista est en su lugar, tenemos que crear una propiedad IBOutlet y conectarlo con la
vista. Abra el archivo TapViewController.h y declarar la siguiente propiedad:
@interface TapViewController : UIViewController
@property (weak, nonatomic) IBOutlet UIView *testView;
@end
Regrese al archivo Main.storyboard de nuevo, vaya al panel Esquema del documento, y Ctrl Arrastre desde el punto de vista Toque escena controlador de objeto a la vista, como se muestra a
continuacin:
46
En la ventana emergente, slo tienes que seleccionar la propiedad TestView, y ya est todo.
47
Nota: Nosotros vamos a utilizar el procedimiento anterior para aadir objetos de prueba y para
conectarlos con propiedades IBOutlet.
Ahora, abra el archivo TapViewController.m. Lo primero que debemos hacer, es crear un objeto de
la clase UITapGestureRecognizer, que luego aadiremos a la vista TestView. En realidad, vamos a
crear dos objetos de esa clase, uno para pruebas de taps individuales, y uno para probar dobles
taps. Nuestro trabajo se llevar a cabo inicialmente con el mtodo viewDidLoad, as que vamos a
empezar con la primera.
El siguiente segmento de cdigo muestra claramente cmo inicializamos un objeto gesto
reconocedor:
UITapGestureRecognizer *singleTapGestureRecognizer = [[UITapGestureRecogn
izer alloc] initWithTarget:self
action:@selector(handleSingleTapGesture :)];
Al usarlo de esta forma, se puede inicializar cualquier objeto de las subclases del gesture, siempre
y cuando se sustituye el nombre de la clase. Como ves, especificamos un objetivo y una acci n. La
accin en este caso es un mtodo privado que estamos a punto de crear.
Para asignar el gesto anterior al test view, esto es lo que debemos escribir:
[self.testView addGestureRecognizer:singleTapGestureRecognizer];
El addGestureRecognizer: es l nico mtodo para aadir un objeto de tipo gesto a una vista.
Ve ahora a la seccin privada de la interfaz, y para declarar el mtodo privado de la siguiente
manera:
@interface TapViewController ()
-(void)handleSingleTapGesture:(UITapGestureRecognizer *)tapGestureRecognizer;
@end
Como se menciono en la introduccin, el objeto reconocedor de gestos hace pasar al mtodo de

seleccin, y mediante el uso de esta firma de mtodo se puede usar posteriormente en la
aplicacin.
Hacemos ms que el doble de la anchura de la vista de prueba cuando hacemos tapping en l una
vez, y vamos a revertir el valor de la anchura original tras el segundo toque:
-(void)handleSingleTapGesture:(UITapGestureRecognizer *)tapGestureRecognizer{
CGFloat newWidth = 100.0;
if (self.testView.frame.size.width == 100.0) {
newWidth = 200.0;
}
CGPoint currentCenter = self.testView.center;
48
self.testView.frame = CGRectMake(self.testView.frame.origin.x,
self.testView.frame.origin.y, newWidth, self.testView.frame.size.height);
self.testView.center = currentCenter;
}
Comprobamos si el ancho inicial de la vista es igual a 100,0 puntos, y si es as lo hacemos 200.0, si

no mantenemos el valor asignado inicial (100,0). A continuacin, nos atenemos a una variable de
estructura CGPoint el punto central actual, cambiamos el ancho de la vista y nos centramos de
nuevo.
Ahora es el momento de probar el tap del gesto. Ejecutar la aplicacin, y una vez que se puso en
marcha ya sea al simulador o un dispositivo, asegrese de que usted est en la primera ficha. Pulse
sobre la vista una vez, y su tamao va a cambiar. Toque una vez ms, y ver que volver a su estado
original.
Volvamos a nuestro trabajo de nuevo. Como se ha mencionado, un tap gesture se puede realizar
con uno o ms dedos, y el gesto podra requerir uno o ms taps. As que, veremos un ejemplo ms,
donde esta vez vamos a "decirle" al objeto reconocedor gesto que queremos dos taps que
49
sucedan, y que dos dedos se requieren para llevar a cabo la accin predefinida. En el mtodo
viewDidLoad, agregue las siguientes:
- (void)viewDidLoad
{
...
UITapGestureRecognizer *doubleTapGestureRecognizer = [[UITapGestureRecogn

action:@selector(handleDoubleTapGesture :)];
doubleTapGestureRecognizer.numberOfTapsRequired = 2;
doubleTapGestureRecognizer.numberOfTouchesRequired = 2;
[self.testView addGestureRecognizer :doubleTapGestureRecognizer ];
}
Aqu inicializamos un objeto nuevo reconocedor de tap gesture y especificamos otro mtodo de
accin que vamos a poner en prctica. Lo nuevo aqu es sin embargo el uso de las dos propiedades
que nos permiten establecer el nmero de los grifos y toques necesarios (o en otras palabras, el
nmero de dedos). Finalmente, aadimos el objeto reconocedor a la vista TestView.
Tenga en cuenta que nuestra visin de prueba ahora contiene dos objetos gesto reconocedor.
Ahora, vamos a poder terminar con las tareas pendientes. Vaya a la seccin inte rfaz privada y
declarar el nuevo mtodo privado:
@interface TapViewController ()
...
(void)handleDoubleTapGesture:(UITapGestureRecognizer *)tapGestureRecogni
zer;
@end
En su definicin, vamos a cambiar la anchura y la altura de la vista al duplicar su tamao. Vamos a

seguir la misma lgica que antes:
(void)handleDoubleTapGesture:(UITapGestureRecognizer *)tapGestureRecogniz
er{
CGSize newSize = CGSizeMake(100.0, 100.0);
if (self.testView.frame.size.width == 100.0) {
newSize.width = 200.0;
50
newSize.height = 200.0;
}
CGPoint currentCenter = self.testView.center;
self.testView.frame = CGRectMake(self.testView.frame.origin.x,
self.testView.frame.origin.y, newSize.width, newSize.height);
self.testView.center = currentCenter;
}
Ejecutar la aplicacin una vez ms. Esta vez, tocar dos veces y usar dos dedos, de lo contrario el
gesto fallar. Adems, trate tanto de los reconocedores gestos que hemos creado aqu:
51
Swipe Gesture Recognizer

Otra reconocedor gesto bastante comn es el golpe. Swiping se puede hacer hacia cualquiera de
las cuatro direcciones bsicas (derecha, izquierda, arriba, abajo), pero no en una forma diagonal.
La clase UISwipeGestureRecongnizer proporciona un mtodo que nos permite especificar la
direccin, y si no se establece, entonces la direccin correcta se utiliza por defecto. Un objeto
reconocedor gesto de golpe puede supervisar y motivar acciones de una sola direccin. Eso
significa que si quieres una vista en su aplicacin para apoyar a deslizar hacia dos o ms
direcciones, a continuacin, debe crear dos o ms objetos gesto reconocedor respectivamente.
Ms all de todo eso, tenga en cuenta que la accin que ha sido provocado por el movimiento de
golpe comienza justo despus de la birlar ha terminado (cuando el dedo en realidad deja de
deslizamiento).
En esta parte vamos a trabajar con la clase SwipeViewController que previamente hemos aadido
al proyecto. En la escena correspondiente en el Interface Builder, vamos a aadir tres visin
(UIView) objetos. La anchura de las tres vistas ser igual a la anchura de la pantalla. El primer
punto de vista se colocar en la pantalla, mientras que los otros dos puntos de vista sern
colocados en el lado derecho de la primera vista de la izquierda y, y, obviamente, estar fuera de
la zona visible. Nuestro objetivo es hacer que estas opiniones se mueven horizontalmente usando
gestos banda magntica, y dejar que las opiniones ocultas sean revelados deslizando hacia la
izquierda o derecha.
Main.storyboard. Ir a la escena del controlador de vista Swipe y aadir los prximos tres
subventanas definiendo al mismo tiempo las propiedades del marco y el color de fondo:
Primer View
Segundo View
Frame: X=320, Y=234, Width=320, Height=100
Background Color: Black Color

Third View
Frame: X=-320, Y=234, Width=320, Height=100
52
A continuacin, cree las siguientes propiedades IBOutlet al archivo SwipeViewController.h:
@interface SwipeViewController : UIViewController

@property (weak, nonatomic) IBOutlet UIView *viewOrange;
@property (weak, nonatomic) IBOutlet UIView *viewBlack;
@property (weak, nonatomic) IBOutlet UIView *viewGreen;
@end
Despus de haberlo hecho, volver a la escena del Swipe view controller, y hacer las conexiones
adecuadas. Obviamente, la propiedad viewOrange coincide con el primer punto de vista, la
propiedad viewBlack coincide con el segundo punto de vista, y la propiedad viewGreen coincide
con el tercer punto de vista.
Ahora, vamos a la cabeza en el fichero SwipeViewController.m, y vamos a empezar a crear el
reconocedor gesto que necesitamos uno por uno. Ir al mtodo viewDidLoad, e inicializar un
53
objeto, por primera vista (el que est en el medio de estar en el rea visible de la pantalla). Vamos
a ver que:
- (void)viewDidLoad
{
// Do any additional setup after loading the view.

UISwipeGestureRecognizer *swipeRightOrange = [[UISwipeGestureRecognizer
alloc] initWithTarget:self
action:@selector(slideToRightWithGestureRecognizer:)];
swipeRightOrange.direction = UISwipeGestureRecognizerDirectionRight;
}
Lo que hemos hecho con este segmento es muy claro: A la inicializacin de objetos especificamos
el mtodo de accin que se debe llamar cuando ocurrir el birlar, y luego nos pusimos en la
direccin del gesto de deslizar hacia la derecha.
Ahora, vamos a crear una mayor gesto objeto reconocedor que nos permi ta deslizar hacia la
izquierda:
- (void)viewDidLoad
{
...
UISwipeGestureRecognizer *swipeLeftOrange = [[UISwipeGestureRecognizer

action:@selector(slideToLeftWithGestureRecognizer:)];
swipeLeftOrange.direction = UISwipeGestureRecognizerDirectionLeft;
}
Ahora solo se aaden estos dos reconocedores gesto a la vista viewOrange exactamente como se
muestra a continuacin:
- (void)viewDidLoad
{
...
[self.viewOrange addGestureRecognizer:swipeRightOrange];
[self.viewOrange addGestureRecognizer:swipeLeftOrange];
}
54
Los mtodos de accin que se propusieron a los reconocedores de arriba, deben realizar una
accin simple: Para deslizar todos los puntos de vista, ya sea hacia la izquierda o hacia la derecha,
por lo que cuando una vista deja el rea visible de la pantalla, otro que se apareci. Vamos a
declarar a ellos primero y vamos a hacer la aplicacin siguiente. En la seccin de interfaz privada
aadir las siguientes lneas:
@interface SwipeViewController ()
(void)slideToRightWithGestureRecognizer :(UISwipeGestureRecognizer *)gestu
reRecognizer;
(void)slideToLeftWithGestureRecognizer:(UISwipeGestureRecognizer *)gestur
eRecognizer;
@end
Observaremos la aplicacin del primer mtodo de inmediato:

(void)slideToRightWithGestureRecognizer :(UISwipeGestureRecognizer *)gestu
reRecognizer{
[UIView animateWithDuration:0.5 animations:^{
self.viewOrange.frame = CGRectOffset(self.viewOrange.frame, 320.0, 0.0);
self.viewBlack.frame = CGRectOffset(self.viewBlack.frame, 320.0, 0.0);
self.viewGreen.frame = CGRectOffset(self.viewGreen.frame, 320.0, 0.0);
}];
}
Como se observa, cuando nos acercamos hacia la derecha, queremos que el punto de vista de
cada origen X a incrementarse en 320,0 pxeles y manejar de esa manera para mover nuestros
puntos de vista a la derecha. Hacemos este movimiento se vea natural simplemente envolviendo
todo en un bloque de animacin. Ntese tambin que la velocidad de movimiento depende de la
duracin de la animacin, as que si quieres un efecto ms lento diapositiva que debe aumentar la
duracin de la animacin, mientras que si los necesita para avanzar ms rpido, a continuacin,
slo disminuir la duracin.
El segundo mtodo de accin va a ser similar a este, con una diferencia solamente: El
desplazamiento en el eje X ser un nmero negativo (igual, por supuesto, a 320,0 pxeles), as que
las vistas se mueve hacia la izquierda. Veamos esta aplicacin, as:
(void)slideToLeftWithGestureRecognizer:(UISwipeGestureRecognizer *)gestur
eRecognizer{
[UIView animateWithDuration:0.5 animations:^{
55
self.viewOrange.frame = CGRectOffset(self.viewOrange.frame, 320.0, 0.0);

self.viewBlack.frame = CGRectOffset(self.viewBlack.frame, 320.0, 0.0);
self.viewGreen.frame = CGRectOffset(self.viewGreen.frame, 320.0, 0.0);
}];
}
Ejecutar la aplicacin una vez ms, y esta vez mostrar el contenido de la segunda pestaa. Deslice
el dedo hacia la derecha o hacia la izquierda, y ver los puntos de vista se deslizan dentro y fuera
usando una manera animada. Sin embargo, cuando una nueva vista aparece en pantalla, se
observara que ningn gesto de deslizar funciona ms. Esto sucede por el hecho de que no se ha
creado y aadido reconocedores gesto de golpe a los otros dos puntos de vista.
Volver al mtodo viewDidLoad, y empezar aadiendo el siguiente segmento:
- (void)viewDidLoad
{
...
UISwipeGestureRecognizer *swipeRightBlack = [[UISwipeGestureRecognizer

action:@selector(slideToRightWithGestureRecognizer:)];
swipeRightBlack.direction = UISwipeGestureRecognizerDirectionRight;
[self.viewBlack addGestureRecognizer:swipeRightBlack];
}
Los mtodos de accin que se postulo a los reconocedores de arriba, deben realizar una cosa
simple: Para deslizar todos los puntos de vista, ya sea hacia la izquierda o hacia la derecha, por lo
que cuando una vista deja el rea visible de la pantalla, otro que se apareci. Vamos a declarar a
ellos primero y vamos a hacer la aplicacin siguiente. En la seccin de interfaz privada aadir las
siguientes lneas:
- (void)viewDidLoad
{
...
UISwipeGestureRecognizer *swipeLeftGreen = [[UISwipeGestureRecognizer
action:@selector(slideToLeftWithGestureRecognizer:)];
swipeLeftGreen.direction = UISwipeGestureRecognizerDirectionLeft;
[self.viewGreen addGestureRecognizer:swipeLeftGreen];
}
56
57
58
Tenga en cuenta que por cada gesto de deslizar desea apoyarnos, debe crear un nuevo objeto
gesto reconocedor. Creacin de un solo objeto y agregarlo a ms de un punto de vista no se va a
trabajar. Si realmente quieres una prueba de ello, slo tiene que ir con el mtodo viewDidLoad y
aadir el swipeRightOrange y los reconocedores gesto swipeLeftOrange a las otras dos vistas
respectivamente. Ejecutar la aplicacin de nuevo, y luego pasar el dedo (o con el ratn en
simulador) al igual que antes. Por desgracia, esta vez no va a funcionar, as que ponga todo de
nuevo a su estado original.
Pan Gesture Recognizer
Este gesto es til cuando se desea permitir a sus usuarios arrastrar puntos de vista alrededor de la
pantalla. En esta parte, a excepcin de la aplicacin del cdigo necesario que permitir a nuestra
aplicacin para apoyar el gesto pan, nos encontraremos con un mtodo especial de la clase
59
UIPanGestureRecognizer, llamado velocityInView :. Este mtodo devuelve un valor CGPoint, y nos

informa sobre la cantidad de puntos por segundo la vista arrastrado viaja tanto en el eje horizontal
y vertical mientras arrastra. Esta informacin podra ser til en algunos casos, as que veremos
cmo acceder a ella.
Al igual que antes, vamos a empezar por la adicin de una vista de prueba para el Interface
Builder. Ir al archivo Main.storyboard, a continuacin, arrastre un objeto de vista (UIView) a la
escena del controlador de vista Pan. Establezca los siguientes dos atributos de la misma:
Background Color: R=215, G=116, B=52 (o cualquier otro color)
A continuacin, vaya al archivo PanViewController.h y declarar una propiedad IBOutlet que usted
va despus de conectar a la vista:
@interface PanViewController : UIViewController

@end
Volver al archivo Main.storyboard y conecte la propiedad IBOutlet a la vista.

Una vez que haya terminado de trabajar con el Interface Builder, haga clic en el archivo
PanViewController.m en el Navegador de proyectos. El primer paso que debemos hacer, es crear
un gesto de reconocimiento de la cacerola y aadirlo a nuestra visin de prueba.A continuacin
vamos a ver es el siguiente:
- (void)viewDidLoad
{
...
UIPanGestureRecognizer *panGestureRecognizer = [[UIPanGestureRecognizer

action:@selector(moveViewWithGestureRecognizer:)];
[self.testView addGestureRecognizer :panGestureRecognizer];
}
Ahora, declararemos e implementara el mtodo que establecimos como la accin que se debe
tomar cuando el gesto pan va a suceder. En la seccin de interfaz privada, aadir lo siguiente:
@interface PanViewController ()
(void)moveViewWithGestureRecognizer:(UIPanGestureRecognizer *)panGestureR
60
ecognizer;
@end
Anteriormente, el objetivo es arrastrar la vista de prueba mientras movemos el dedo en la

pantalla. El enfoque ms fcil de que sera actualizar el punto de centro de la vista, siempre y
cuando se produce la panoramizacin.La traduccin de este cdigo es la siguiente:
ecognizer{
CGPoint touchLocation = [panGestureRecognizer
locationInView:self.view];
self.testView.center = touchLocation;
}
Cada gesto reconocedor contiene un mtodo llamado locationInView. Este mtodo devuelve un
valor CGPoint que representa el punto de la opinin de que el usuario afectado. En nuestro caso,
llamando a este mtodo logramos obtener el punto tocado durante el arrastre, y para que nuestra
aplicacin consciente del movimiento del dedo. Por lo tanto, lo que slo necesitamos es establecer
esa ubicacin tctil como el valor para el punto central de la vista de la prueba, y eso es
exactamente realizo utilizando el segundo comando anterior.
Ejecutar la aplicacin ahora y coloque el dedo o el puntero del ratn en la vista de prue ba. Luego
empiece a arrastrar alrededor y observe cmo la vista sigue el movimiento que realice.
61
El enfoque que present anteriormente es simple para el bien del tutorial. En una aplicacin real,
es posible que desee enriquecer el movimiento de la vista mediante la adicin de aceleracin o
deceleracin cuando empieza o deja arrastrar, o cualquier otra cosa que usted necesita. Todo
depende de usted para aplicar la lgica propia en el mtodo de accin a implementar.
Al comienzo de esta seccin, he dicho que no es un mtodo especial de la clase
UIPanGestureRecognizer llamado velocityInView. Hasta este punto hemos totalmente ignorado,
pero ahora vamos a ver cmo podemos acceder a ella y obtener los datos que proporciona. En
aras de la demo, vuelva a la Interface Builder, haga clic en el archivo Main.storyboard. Localice la
escena controlador de vista Pan, y aadir dos etiquetas con los siguientes atributos:
Label #1
62
Text: Nothing (vacio)
Font size: 14pt

Label #2
Text: Nothing (vacio)
Font size: 14pt
Como se puede observar, se utilizaran estas dos etiquetas para mostrar la velocidad en el eje
horizontal y vertical respectivamente. Pero antes de hacerlo, debemos crear y conectar dos
propiedades IBOutlet a estas etiquetas. As, abra el archivo PanViewController.h y aadir las dos
lneas siguientes:
@interface PanViewController : UIViewController
...
@property (weak, nonatomic) IBOutlet UILabel *horizontalVelocityLabel;
@property (weak, nonatomic) IBOutlet UILabel *verticalVelocityLabel;
@end
Vulva a la Interface Builder, y realizar las conexiones adecuadas.

Ahora, abra el archivo PanViewController.m, e ir al mtodo de accin privada denominada
moveViewWithGestureRecognizer. Vamos a aadir algo de cdigo aqu que nos permitir obtener
la velocidad del arrastre como un valor CGPoint, y luego vamos a extraer la velocidad en cada eje
de sta. Recuerde que la velocidad se expresa en puntos por segundo. Vamos a ver el mtodo:
ecognizer{
...
CGPoint velocity = [panGestureRecognizer velocityInView:self.view];
self.horizontalVelocityLabel.text = [NSString stringWithFormat:@"Horizont

al Velocity: %.2f points/sec", velocity.x];
self.verticalVelocityLabel.text = [NSString stringWithFormat:@"Vertical
Velocity: %.2f points/sec", velocity.y];
63
El valor devuelto por el velocityInView: mtodo se almacena a una estructura CGPoint. Luego
simplemente accediendo a las propiedades X e Y de esa estructura, obtenemos para conseguir la
velocidad horizontal y vertical. Para simplificar el desarrollo, slo mostramos estos valores, pero
en una aplicacin real de la velocidad sera til si slo se necesita realizar clculos basados en ella.
Al ejecutar la aplicacin de nuevo se puede ver cmo se mueve la vista de prueba "rpida" por la
pantalla mientras lo arrastra.
64
Pinch Gesture Recognizer
El gesto de pellizco es til para cambiar la transformacin de una vista al escalar hacia arriba o
hacia abajo. El ejemplo ms caracterstico de ese gesto se puede encontrar en la aplicacin Fotos,
donde se pellizca para acercar y alejar.Slo se utilizara una vista simple. Sin embargo, lo que
haremos aqu se aplican a todas las vistas (incluidas las vistas de imagen) en los que desea cambiar
su valor de escala. La gran diferencia de que el gesto de pellizco ha en comparacin con los
reconocedores gesto anterior, es el hecho de que requiere dos dedos para ser u tilizado con el fin
de realizar el gesto.
65
Comenzaremos por la adicin de una vista de prueba para el Interface Builder. En el Navegador de
proyectos, haga clic en el archivo Main.storyboard y busque la escena controlador de vista Pinch.
A continuacin, desde la biblioteca de objetos de arrastre un objeto de vista (UIView) a la lona, y
establece los siguientes atributos:
Ahora abre el archivo PinchViewController.h, y declarar una propiedad IBOutlet:

@interface PinchViewController : UIViewController
@end
Por ltimo, en el Interface Builder seconecta esa propiedad a la vista de prueba que acaba de
aadir.
Al igual que en los casos anteriores, vamos a comenzar la ejecucin en el mtodo viewDidLoad en
el archivo PinchViewController.m. Lo que slo tenemos que hacer es inicializar un objeto
reconocedor gesto de pellizco y, a continuacin, agregarlo a la vista de la prueba:
- (void)viewDidLoad
{
...
66
UIPinchGestureRecognizer *pinchGestureRecognizer = [[UIPinchGestureRecogn

action:@selector(handlePinchWithGestureRecognizer:)];
[self.testView addGestureRecognizer :pinchGestureRecognizer];
}
Ahora, hay que declarar el handlePinchWithGestureRecognizer: mtodo, y luego definirlo. En

primer lugar, vaya a la seccin de clase privada:
} @interface PinchViewController ()
(void)handlePinchWithGestureRecognizer:(UIPinchGestureRecognizer *)pinchG
estureRecognizer;
@end
De acuerdo al objtetivo, vamos a modificar la transformacin de la vista prueba cambiando el

valor de la escala. Esa accin se traducir en un efecto de zoom in / out, y como se ver, es slo
una cuestin de una sola lnea:
estureRecognizer{
self.testView.transform = CGAffineTransformScale(self.testView.transform,
pinchGestureRecognizer.scale, pinchGestureRecognizer.scale);
}
En este ejemplo, sabemos que es la opinin de que el gesto de pellizco se aplic a (la vista
TestView), por lo que se accede directamente. Sin embargo, habr ocasiones en que usted
necesita para acceder a la vista pinzamiento de un modo ms genrico. En ese caso, se puede
evitar el uso directo de la la vista que se pellizc como se muestra arriba, si usted slo tiene que
utilizar la propiedad vista del parmetro objeto pinchGestureRecognizer. Esta propiedad es en
realidad la opinin de que el gesto de pellizcar sucedi. Por lo tanto, el comando anterior se puede
escribir de la siguiente manera tambin:
pinchGestureRecognizer.view.transform = CGAffineTransformScale(pinchGestu
reRecognizer.view.transform, pinchGestureRecognizer.scale,
pinchGestureRecognizer.scale);
67
Para poder realizar prueba, antes se tendr que aadir un comando ms pero entender que lo
necesite despus de haber probado lo anterior, al menos una vez. Por lo tanto, completar el
mtodo anterior, aadiendo lo siguiente:
estureRecognizer{
...
pinchGestureRecognizer.scale = 1.0;
}
Es necesario restablecer el valor de la escala del objeto reconocedor gesto de pellizco, de lo

contrario el resultado no ser el esperado; la escala se ver catico. Con esta lnea simple, nos las
arreglamos para conseguir un comportamiento ms suave.
Ahora se puede ejecutar la aplicacin y probar el gesto de pellizcar. Actuar como usted lo hace a
las fotografas al zoom dentro y fuera, y ver cmo nuestra visin de prueba reacciona a tus
movimientos.
68
69
Rotation Gesture Recognizer

El reconocedor gesto rotacin tiene grandes similitudes con el reconocedor gesto de pellizco, ya
que requiere de dos dedos para que el gesto sea un xito, y cambia la transformacin de la
opinin de que se aplica a modificando su rotacin. Por lo general, el gesto de rotacin se utiliza
en combinacin con otros gestos, pero no slo.
En esta parte vamos a realizar casi los mismos pasos que hicimos en la seccin de reconocimiento
de gesto de pellizcar. Por lo tanto, abrir el Interface Builder, e ir a la escena del controlador de
vista de rotacin. Desde la biblioteca de objetos, arrastre y suelte una vista a la lona con los
siguientes atributos:
70
A continuacin, en el archivo RotationViewController.h declarar la siguiente propiedad IBOutlet y

luego regresar a la Interface Builder para conectarlo a la view
@interface RotationViewController : UIViewController

@end
En el archivo RotationViewController.m, en la cabezera a la viewDidLoad directamente. Aqu, se

limitaremos a crear un objeto nuevo gesto de rotacin reconocedor y lo aadiremos a la prueba
de la vista.
- (void)viewDidLoad
{
...
UIRotationGestureRecognizer *rotationGestureRecognizer = [[UIRotationGest

ureRecognizer alloc] initWithTarget:self
action:@selector(handleRotationWithGestureRecognizer:)];
[self.testView addGestureRecognizer :rotationGestureRecognizer];
}
El siguiente paso es declarar el mtodo privado:

@interface RotationViewController ()
(void)handleRotationWithGestureRecognizer:(UIRotationGestureRecognizer *)
rotationGestureRecognizer;
@end
A continuacin se utilizara el mtodo CGAffineTransformRotate para cambiar el valor de giro de la

transformada de la vista de prueba. Como se ver en el siguiente cdigo, la propiedad de rotacin
de la rotationGestureRecognizer toma su valor inicial a fin de evitar un comportamiento
inesperado.
(void)handleRotationWithGestureRecognizer:(UIRotationGestureRecognizer *)
rotationGestureRecognizer{
self.testView.transform = CGAffineTransformRotate(self.testView.transform
, rotationGestureRecognizer.rotation);
71
rotationGestureRecognizer.rotation = 0.0;
}
Ejecutar la aplicacin ahora, y asegrese de seleccionar la ltima pestaa de la barra de pestaas

controlador. A continuacin, utilice dos dedos para girar la vista a cualquiera de sentido horario o
antihorario.
72
Integracin de Mapas
Los mapas son parte importante de nuestra vida. Los usamos a diario para encontrar lugares y
direcciones. El marco MapKit facilita a los desarrolladores implementar aplicaciones que pueden
hacer uso de los mapas en las aplicaciones.
Hay varios conceptos que debemos aprender primero antes de sumergirse en el cdigo.
MKMapView: MKMapView es un control de interfaz de usuario que se utiliza para mostrar el mapa
de los dispositivos IOS.
Anotation: Anotaciones es la informacin relacionada con un determinado lugar en el mapa. Estos
incluyen tiendas de comestibles, gasolineras, centros comerciales o incluso informacin
personalizada introducido por el usuario.
AnnotationView: El aspecto visual de las anotaciones se define utilizando la clase
MKAnnotationView. Por defecto, las anotaciones se muestran con la vista de anotacin pin.
Adicionar Mapa
En primer lugar, cree un nuevo proyecto de Xcode usando la plantilla Single View. Vamos a
nombrar el proyecto como "MyLocationMap" y establezca el proyecto con los siguientes
parmetros:
Una vez que ha creado con xito su proyecto, vaya al guin grfico y el diseo de la interfaz de
usuario. Queremos integrar el controlador de vista en un controlador de navegacin. Primero,
73
seleccione el controlador de vista y seleccione "Editor" -> "Insertar en" -> "regulador de la
navegacin".
Opcionalmente, se puede establecer el ttulo de la barra de navegacin. Introduciendo el nombre

"Mis mapas". Finalmente, arrastre un mapa de Biblioteca de objetos para el controlador de vista.
En el Atributo Inspector de mapa, seleccione la opcin "Mostrar Usuario Ubicacin". Al permitir la
ubicacin del usuario, el mapa muestra automticamente la ubicacin actual del usuario.
74
A medida que la aplicacin hace uso de los Core Ubicacin y MapKit marcos, aadir estos dos
marcos para nuestro proyecto. Seleccione "MyLocationMap" en el Navegador de proyectos,
seguido por el "MyLocationMap" en Destinos. A continuacin, seleccione "Build Phases" y ampliar
"Enlace binario con las Bibliotecas". Haga clic en el botn "+" para aadir tanto los frameworks
"MapKit" y "CoreLocation" .
75
Hasta ahora, no se ha escrito una sola lnea de cdigo. Antes de continuar, vamos a ejecutar la
aplicacin y ver cmo se ve.
Tan pronto como la aplicacin de lanza, se le pedir para acceder al servicio de localizacin. Slo
tienes que pulsar en "Aceptar" para permitir que se utilice la ubicacin actual. Usted ya ha
construido una aplicacin de mapas.
76
El simulador de iOS le permite "fingir" una ubicacin, puede seleccionar "Depuracin" ->
"Ubicacin" en la barra de men. Cambiar la ubicacin de "Ninguno" para "Apple". A continuacin,
ver un punto azul que indica la ubicacin actual en el mapa.
77
No se ha cubierto la parte de codificacin. Lo que se ha realizado hasta ahora es simplemente

arrastrar y soltar del componente de interfaz de usuario y hemos muestra la ubicacin actual en el
mapa.
Ubicar posicin
Est ahora mostrando al mundo entero. Normalmente usted no desea mostrar la ubicacin actual
de tal escala, pero el zoom en el rea en particular.
En primer lugar, se realizo una salida en "MyLocationViewController.h" y establecer una conexin
con el mapa. En "MyLocationViewController.h", declara la propiedad "MAPview" e implementa el
protocolo MKMapViewDelegate. El cdigo deber ser, como a continuacin:
#import <MapKit/MapKit.h>
@interface MyLocationViewController : UIViewController
<MKMapViewDelegate>
@property (nonatomic, strong) IBOutlet MKMapView *mapView;
@end
A continuacin, vaya al archivo "MyLocationViewController.m" y aadir la declaracin de sntesis:

@interface MyLocationViewController ()
@end
@implementation MyLocationViewController
78
@synthesize mapView;
.
.
.
Por ltimo, volver a la Storyboard y conectar la variable MAPview con el componente de mapa.
(Pulse y mantenga pulsada la tecla Control del teclado, haga clic en el icono de "El dueo del
archivo" y arrastre para el mapa)
Ahora, volvamos al protocolo MKMapViewDelegate. Tcnicamente, el protocolo

MKMapViewDelegate define un conjunto de mtodos opcionales que puede utilizar para recibir
mensajes de actualizacin relacionadas con los mapas. Por ejemplo, usted va a correr con tu
iPhone. Su ubicacin no deja de cambiar durante la carrera. Para recibir el cambio de ubicacin /
actualizacin, puede aplicar el protocolo. El MAPview: mtodo didUpdateUserLocation se llama
cada vez que una nueva actualizacin de la localizacin es recibida por la vista del mapa.
Este es uno de los ejemplos que podrs aplicar el Protocolo MKMapViewDelegate. Tambin puede
hacer uso de ella para cambiar la vista de anotacin que demostraremos en tutoriales posteriores.
79
Volver a la "MyLocationViewController.m" y actualizar el mtodo "viewDidLoad" para asignar el

delegado de MAPview:
- (void)viewDidLoad
{
self.mapView.delegate = self;
}
Adems, agregue el mtodo didUpdateUserLocation:

- (void)mapView:(MKMapView *)mapView
didUpdateUserLocation:(MKUserLocation *)userLocation
{
MKCoordinateRegion
region = MKCoordinateRegionMakeWithDistance(userLocation.coordinate, 800,
800);
[self.mapView setRegion:[self.mapView
regionThatFits:region] animated:YES];
}
Las lneas anteriores de cdigo indica la vista de mapa para hacer zoom en una regin que es de
800 por 800 metros alrededor de la ubicacin del usuario.
Ejecutar la aplicacin, defina la ubicacin de la sede de Apple. Ahora, el mapa se actualiza
automticamente a nuestra escala preferida:
80
Como puedes ver en las imgenes anteriores, la ubicacin del usuario actual se indica como un
punto azul. Queremos cambiar y colocar un alfiler en el mapa.
81
De acuerdo con iOS , con el fin de mostrar una anotacin en un mapa, su aplicacin debe
proporcionar dos objetos distintos:
Un objeto que cumpla con el protocolo MKAnnotation y gestiona los datos de la

anotacin. (Este objeto es el objeto de anotacin.)
Una vista (derivada de la clase MKAnnotationView) utilizado para dibujar la
representacin visual de la anotacin en la superficie mapa. (Esta es la vista de anotacin.)
El iOS viene con un objeto de anotacin incorporado - MKPointAnnotation. Este objeto ya prev la
aplicacin concreta del protocolo MKAnnotation. Usted puede hacer uso de estos sencillos
objetos, en lugar de definir su propio, siempre que desee asociar un punto en el mapa con un
ttulo.
Dentro de esta aplicacin utilizamos el objeto MKPointAnnotation asociar con la ubicacin del
usuario. Actualizar el mtodo de "didUpdateUserLocation" a lo siguiente:
- (void)mapView:(MKMapView *)mapView
didUpdateUserLocation:(MKUserLocation *)userLocation
{
MKCoordinateRegion
region = MKCoordinateRegionMakeWithDistance(userLocation.coordinate, 800,
800);
[self.mapView setRegion:[self.mapView
regionThatFits:region] animated:YES];
// Add an annotation
MKPointAnnotation *point = [[MKPointAnnotation alloc] init];
point.coordinate = userLocation.coordinate;
point.title = @"Where am I?";
point.subtitle = @"I'm here!!!";
[self.mapView addAnnotation:point];
}
Para colocar un pin en el lugar correcto en el mapa, primero creamos un objeto

MKPointAnnotation y asignamos con la coordenada de la ubicacin del usuario. Tambin
asignamos el ttulo y subttulo de la llamada que aparece cuando toca en el pasador. Por ltimo,
llamamos a la addAnnotation: mtodo para agregar el objeto de anotacin a la vista del mapa.
Calcular distancias
El clculo de dos distancias se realiza por medio del objeto CLLocation
Un objeto CLLocation representa los datos de localizacin generados por un objeto
CLLocationManager. Este objeto incorpora las coordenadas geogrficas y altitud de la ubicacin
del dispositivo junto con los valores que indica la precisin de las medidas y en que efectu dichas
mediciones. En iOS, esta clase tambin reporta informacin sobre la velocidad y el rumbo en el
que el dispositivo se est moviendo.
82
Normalmente, se utiliza un objeto CLLocationManager para crear instancias de esta clase basado
en la ltima ubicacin conocida del dispositivo del usuario. Puede crear instancias de s mismo, sin
embargo, si desea almacenar en cach los datos de localizacin personalizados o lleve a la
distancia entre dos puntos.
Esta clase est diseada para ser utilizada como es y no debera tener subclases.
Para inicializar este objeto se hace de la siguiente forma:
(instancetype)initWithLatitude:(CLLocationDegrees)latitude
longitude:(CLLocationDegrees)longitude
Ya por medio de este objeto podemos obtener la distancia en metros por medio del siguiente
mtodo:
(CLLocationDistance)distanceFromLocation:(const CLLocation *)location
Donde sus parmetros son:

Location
Otra localizacin
Este mtodo mide la distancia entre las dos ubicaciones mediante el trazado de una lnea entre
ellos que sigue la curvatura de la Tierra. El arco resultante es una curva suave y no toma en cuenta
los cambios especficos de altitud entre los dos lugares.
Cmara
Crear Aplicacin con cmara.
Se realizara una app para usar la cmara incorporada del iPhone (o iPod o iPad, si lo tiene) para
tomar una foto. Adems, veremos cmo acceder a la biblioteca de fotos interior y permite al
usuario elegir una foto. La biblioteca iOS ofrece la UIImagePickerController clase que es la interfaz
de usuario para la gestin de la interaccin del usuario con la cmara o con la biblioteca de fotos.
Como de costumbre, la UIImagePickerController requiere el uso de un delegado a responder a las
interacciones.
Para entender mejor el uso de UIImagePickerController, construiremos una sencilla aplicacin de
la cmara. El ejemplo de aplicacin es muy simple: vamos a tener una ventana principal con un
gran UIImageView para mostrar la foto seleccionada, y dos botones: uno para tomar una nueva
foto, y el otro para seleccionar una foto de la biblioteca de fotos.
83
Abra Xcode y crear un nuevo proyecto, elija la plantilla Ver solicitud nica que se muestra a
continuacin:
84
En la siguiente pantalla ingrese CameraApp como el nombre del producto y establecer

com.appcoda en el campo identificador de la compaa. Seleccione la opcin "Usar Tratamiento
automatizado de referencia Conteo", pero no seleccionar la opcin "Usar Storyboard" ya que no
vamos a utilizar guiones grficos para este proyecto. Pulse siguiente y caja.
85
Seleccione el archivo AppViewController.xib de Navigator de Xcode para mostrar el controlador

Ver en el panel Editor. Seleccione una UIImageView de la biblioteca y arrastrar y soltar en la parte
superior de la UIView. Cambiar el tamao del UIImageView tomar el ancho de pantalla completa y
ms de la mitad de la altura. A continuacin, arrastre y suelte una UIButton debajo del
UIImageView, centrado, y cambie su ttulo a "Tomar foto". Por ltimo, arrastrar y soltar otro
UIButton debajo de la anterior, de nuevo centrado y cambie su ttulo a "Seleccionar foto". El Vista
Controlador resultante debe ser algo como:
86
Seleccione de nuevo el UIImageView. En el Inspector, seleccione la ficha Archivo y desactive la

opcin Usar diseo automtico, porque no queremos que el UIImageView para cambiar el tamao
con el tamao de la imagen creada con la cmara, ya que eso dejara casi ningn espacio libre para
los botones.
87
El siguiente paso es crear las conexiones. Con el fin de hacer eso, cambiar el editor para el modo
de asistente mientras tanto se selecciona el archivo AppViewController.xib. El archivo
AppViewController.h debe abrirse. Control y arrastre desde la UIImageView al
AppViewController.h y crear una nueva IBOutlet.
En el campo de la conectividad tenemos que elegir Outlet, como el uso Nombre imageView, como
tipo seleccione UIImageView, y finalmente, como almacenamiento seleccionar Strong. Eso debe
crear el siguiente cdigo IBOutlet:
@property (strong, nonatomic) IBOutlet UIImageView *imageView;
De la misma manera, el control y arrastre desde el botn "Tomar foto". En este caso en el campo
Conexin elegir Accin, como Nombre escribir takePhoto, el tipo es UIButton, el evento que
dispara las acciones es "Touch Up Inside", y el argumento pasado al mtodo es del remitente.
Hazlo de nuevo para el botn "Seleccionar fotos", pero en este caso el nombre de la sele ctphoto
accin.
88
Si has hecho todo correctamente, el APPViewController.h debe ser algo como:

#import
@interface APPViewController : UIViewController
@property (strong, nonatomic) IBOutlet UIImageView *imageView;
- (IBAction)takePhoto: (UIButton *)sender;
- (IBAction)selectPhoto:(UIButton *)sender;
@end
Se necesita un delegado para hacer frente a la interaccin del usuario con la cmara o la biblioteca
de fotos. Para hacer eso tenemos que cumplir con el protocolo UIImagePickerControllerDelegate.
Tambin, ya que vamos a presentar la cmara (o la biblioteca de fotos) de forma modal, tenemos
que aplicar el protocolo UINavigationControllerDelegate tambin. Aadir los dos protocolos en el
archivo AppViewController.h:
@interface APPViewController : UIViewController
<UIImagePickerControllerDelegate, UINavigationControllerDelegate>
Cuando el botn "Tomar foto" clics el usuario (retocar el interior), tenemos que crear un
UIImagePickerController y establecer su delegado a nuestra clase AppViewController. Adems,
tenemos que especificar qu tipo de imagen Recogedor queremos mostrar, la cmara con
UIImagePickerControllerSourceTypeCamera,
o
una
biblioteca
de
fotos
con
UIImagePickerControllerSourceTypePhotoLibrary; en este caso seleccionamos la cmara. Una vez
que el selector se ha embalado, tenemos que presentarlo de forma modal con el mtodo
presentViewController.
Escriba el siguiente mtodo acton takePhoto:
(IBAction)takePhoto:(UIButton *)sender {
UIImagePickerController *picker = [[UIImagePickerController
alloc] init];
picker.delegate = self;
picker.allowsEditing = YES;
picker.sourceType = UIImagePickerControllerSourceTypeCamera;
[self presentViewController:picker animated:YES completion:NULL];
}
Por ltimo, hacemos lo mismo para el mtodo de accin selectphoto, pero cambiando el
sourceType a UIImagePickerControllerSourceTypePhotoLibrary.
89
- (IBAction)selectPhoto:(UIButton *)sender {
UIImagePickerController *picker = [[UIImagePickerController
alloc] init];
picker.delegate = self;
picker.allowsEditing = YES;
picker.sourceType = UIImagePickerControllerSourceTypePhotoLibrary;
[self presentViewController:picker animated:YES completion:NULL];
Cuando el usuario toma una foto con la cmara y cambia el tamao de la imagen (no se permite
cambiar el tamao de la foto ya dijimos allowsEditing = S cuando creamos el selector de
imgenes) se llama al mtodo didFinishPickingMediaWithInfo. Como el primer argumento
tenemos el selector que llama al mtodo, algo muy til si tenemos ms de un selector de
imgenes en nuestra aplicacin, pero no es nuestro caso, y as, ignoramos este parmetro. El
segundo argumento es ms interesante. Es un NSDictionary que contiene, entre otras cosas, la
imagen original y la imagen editada (accesible a travs de la etiqueta
UIImagePickerControllerEditedImage).
- (void)imagePickerController:(UIImagePickerController *)picker
didFinishPickingMediaWithInfo:(NSDictionary *)info {
UIImage *chosenImage = info[UIImagePickerControllerEditedImage ];
self.imageView.image = chosenImage;
[picker dismissViewControllerAnimated:YES completion:NULL];
}
Puede ocurrir que el usuario cancele la operacin pulsando el botn "Cancelar" de la vista de la
imagen selector. En ese caso, el selector llamar al mtodo imagePickerControllerDidCancel. La
implementacin de este mtodo es muy simple, ya que lo que tenemos que hacer es quitar
(despedir) al controlador selector.
(void)imagePickerControllerDidCancel:(UIImagePickerController *)picker {
[picker dismissViewControllerAnimated:YES completion:NULL];
}
La aplicacin est lista y se puede probar en un dispositivo fsico. Sin embargo, si se corre la
aplicacin en el simulador, que se colgar existir un problema, el cual es que el simulador no
tiene cmara. Si queremos, podemos controlar explcitamente ese caso y mostrar al usuario un
90
mensaje de error (que es mucho mejor solucin que un accidente). Y hacer lo que es una buena
idea, ya que podra suceder que alguien va a ejecutar nuestra aplicacin en un antiguo iPod Touch
o iPad sin una cmara. El UIImagePickerController tiene un mtodo de clase llamado
isSourceTypeAvailable que nos permite comprobar si el dispositivo tiene una cmara incorporada
(UIImagePickerControllerSourceTypeCamera constante).
Por ejemplo, agregue el siguiente cdigo al mtodo viewDidLoad del controlador:
if (![UIImagePickerController
isSourceTypeAvailable:UIImagePickerControllerSourceTypeCamera]) {
UIAlertView *myAlertView = [[UIAlertView
alloc] initWithTitle:@"Error"
message:@"Device
has no camera"
delegate:nil
cancelButtonTitle:@"OK"
otherButtonTitles: nil];
[myAlertView show];
}
Manejo de imgenes.
No hay aplicacin que no controle imgenes. Para ello deberemos conocer y saber manejar
el UIImageView que es la vista principal para el manejo de imgenes.
Este componente principal nos permite arrastrarlo a una escena como siempre. En principio ser
una View aun poco sosa:
91
Lo importante son las propiedades que tenemos disponible para esta vista:
En las imgenes disponemos de dos estados, normal y highlighted. Podemos elegir una imagen
que asignar a cada uno de los estados. De normal, con asignar una al atributo image sera
suficiente para presentarla en el ImageView.
El atributo principal es image.
Tambin disponemos de las propiedades tpicas de UIView:
Hidden
Opaque
alpha
tag
etc...
Crearemos un IBOutlet para el UIImageView de la manera habitual en el fichero de cabecera del
ViewController.h:
92
Como siempre ser necesario incluir en el proyecto alguna imagen. Esto podemos hacerlo
arrastrando cualquier imagen desde el finder hasta las carpetas de proyecto. Esto nos sacar un
dilogo similar a este:
Debemos recordar de dejar marcada la opcin de copiar los tems al proyecto y que est marcada
la opcin de Add to targets del proyecto de la aplicacin que estamos realizando.
As nos aparecern las imgenes en el proyecto:
Y una vez aadidas nos permitir colocarlas en los atributos del objeto:
Carpeta ArtWork
93
Esta es el tpico grupo (como se llaman las carpetas dentro de Xcode) que se suele crear para
guardar las imgenes que se vana distribuir con el proyecto. Para crearlo deberemos pulsar botn
derecho sobre la carpeta del proyecto, la que contiene el cdigo fuente del proyecto y pulsar en l a
opcin New Group, o sobre la opcin New Group with Selection teniendo seleccionadas las
imgenes que queremos incluir en el nuevo grupo y nos saldr una nueva carpeta en el proyecto
donde podremos escribir el nombre:
Una vez cambiado el nombre nos debera aparecer ms o menos as:
En este caso como ya habamos seleccionado las imgenes al crear el grupo y hemos pulsado en
New Group with Selection nos ha metido las imgenes directamente dentro del grupo.
Si no hubiera sido as slo sera necesario seleccionar las imgenes y hacer un Drag and Drop sobre
la carpeta en el Navegador del proyecto.
Mtodos principales
Veamos ahora los mtodos principales con los que podemos trabajar con el UIImageView:
initWithImage: este mtodo nos permite inicializar un objeto indicando cual es el UIImage que
queremos cargar.
setImage: permite pasar como parmetro un UIImage que tenga ya la imagen cargada.
startAnimation: permite iniciar una animacin
stopAnimation: para la animacin que estemos realizando
UIImage: Una imagen en memoria
Como podemos ver lo principal el el objeto UIImage, que es el que nos permite inicializar el Objeto
de vista. Los formatos permitidos para el objeto de imagen son:
PNG
JPEG
GIF
TIFF
BMP
94
ICO
CUR
XBM
Ahora veamos cmo podemos llegar a inicializar una imagen con los ficheros de imagen que
hemos incluido en el proyecto. Para ello ser necesario hacer uso del mtodo imageNamed del
objeto UIImage:
Una vez cargada la imagen slo deberamos pasarla a la vista:
Carga de una Imagen desde Internet

Para ello es necesario que dispongamos al menos de una una direccin URL que nos permita saber
donde est la imagen que queremos cargar. Esta URL ser un literal de una NSString.
Una vez se sabe desde que URL tenemos que descargar la imagen, debemos rellenar un objeto
NSURL que es el formato principal de acceso a URL's de la biblioteca Fundation.
Una vez inicializado el objeto NSURL cebemos crear un nuevo objeto NSData, que el que dispone
del mtodo dataWithContentsOfURL:objetoUrl que es el que permite realizar la peticin web para
descargar la imagen y dejarla en el objeto de datos.
Una vez se ha descargado la imagen podemos inicializar el objeto UIImage con los datos
descargados mediante el mtodo initWithData:datos .
Lo cual ya nos permite disponer en memoria de un objeto con el contenido de la Imagen de
internet. Por lo tanto ya podemos asignarlo al UIImageView mediante el
mtodo setImage:imagen2 .
95
Este tipo de procesos que pueden llevar bastante tiempo, suele convenir llevarlos a hilos paralelos
de ejecucin, como explicaremos en posteriores temas.
Carga de una imagen desde la Galera de fotos
Para cargar una imagen desde la galera de fotos en iOS es necesario hacer uso de un tipo especial
de UIPicker es elUIImagePickerController. Este picker nos permitir escoger entre las fotos que
tenemos en la galera y nos la devolver a nuestro ViewController mediante un mtodo definido
en el delegado de dicho UIImagePickerController:
(void)imagePickerController:(UIImagePickerController *)picker
didFinishPickingMediaWithInfo:(NSDictionary *)info
De esta manera podremos manejar la imagen que nos devuelvan y hacer lo que queramos con
ella.
Llamando al Picker de Imgenes
Para ello hemos colocado un botn en la escena y hemos creado un IBAction que es llamado con
el evento Touch Up Inside y hemos indicado en el fichero de cabecera del controlador que
queremos
implementar
dos
protocolos
UIImagePickerControllerDelegate,
UINavigationControllerDelegate. El primero de ellos es el que nos permite gestionar las funciones
necesarias para que funcione el picker el segundo nos permite manejar las llamadas entre
escenas, ya que vamos a llamar a un escena de sistema que es la que permite escoger la imagen
de la galera.
Dentro del flujo de nuestra aplicacin al hacer el salto a la escena del picker, perderemos el
control momentneamente cedindolo al sistema. Y luego volveremos a ejecutar cdigo de
nuestro controlador cuando volvamos del picker.
Veamos el cdigo de llamada al picker de imgenes dentro del IBaction creado:
96
Como vemos en la captura:
Inicializamos el picker de la manera habitual

Indicamos que el delegado del picker es la clase del controlador
Indicamos que queremos permitir la edicin de la imagen
Indicamos la fuente, desde donde vamos a coger la imagen, en este caso
es UIImagePickerControllerSourceTypeSavedPhotosAlbum es decir la galera.
Lanzamiento del picker con el mtodo resentViewController:picker animated:YES
De esta manera nos saldr una pantalla de seleccin de imagen de la galera.
Ejercicio subir imgenes a servicio

Este es un cliente de Objective-C que subir una imagen PNG con el servicio Web describir aqu.
Este cliente funciona con cualquier iPhone, iPad o Mac OS X cliente.
Comenzamos leyendo el archivo de imagen y convertir la imagen a un bfer de bytes (NSData).
UIImage *image = [UIImage imageNamed:@"myimage.png"];

NSData *data = UIImagePNGRepresentation(image);
Ahora necesitamos configurar nuestro solicitud de conexin.
NSString *urlString = [NSString
stringWithFormat:@"http://localhost:8080/imgupload?filename=myimage"];
NSMutableURLRequest *request = [[[NSMutableURLRequest alloc] init] autorelease];
[request setURL:[NSURL URLWithString:urlString]];
[request setHTTPMethod:@"POST"];
[request addValue:@"image/png" forHTTPHeaderField:@"Content-Type"];
97
Ahora subir la imagen (buffer byte) para el servicio Web.

NSMutableData *body = [NSMutableData data];
[body appendData:[NSData dataWithData:data]];
[request setHTTPBody:body];
En este punto, la imagen debe ser cargado en el servidor, pero va a tener que comprobar si la
carga se ha realizado correctamente mediante la lectura de lo que enva el servicio de nuevo a
nosotros.
NSData *returnData = [NSURLConnection sendSynchronousRequest:request
returningResponse:nil error:nil];
NSString *returnString = [[NSString alloc] initWithData:returnData
encoding:NSUTF8StringEncoding];
NSLog(@"Ret: %@",returnString);
El cdigo para el cliente completo est aqu:

UIImage *image = [UIImage imageNamed:@"myimage.png"];
NSData *data = UIImagePNGRepresentation(image);
NSLog(@"size: %d", [data length]);
NSString *urlString = [NSString
stringWithFormat:@"http://localhost:8080/imgupload?filename=myimage"];
NSMutableURLRequest *request = [[[NSMutableURLRequest alloc] init] autorelease];
[request setURL:[NSURL URLWithString:urlString]];
[request setHTTPMethod:@"POST"];
[request addValue:@"image/png" forHTTPHeaderField:@"Content-Type"];
NSMutableData *body = [NSMutableData data];
[body appendData:[NSData dataWithData:data]];
[request setHTTPBody:body];
NSData *returnData = [NSURLConnection sendSynchronousRequest:request
returningResponse:nil error:nil];
NSString *returnString = [[NSString alloc] initWithData:returnData
encoding:NSUTF8StringEncoding];
NSLog(@"Ret: %@",returnString);
El usuario ahora tiene dos opciones:

Elegir una foto
Cancelar la seleccin
En ambos casos volveremos a nuestro controlador cuando termine.
En el caso de que el usuario haya elegido una foto se ejecutar uno de los mtodos del
protocoloUIImagePickerControllerDelegate:
98
Como podemos ver el mtodo didFinishPickingMediaWithInfo nos pasar toda la informacin del
objeto seleccionado llamado info.
Lo primero que hacemos es quitar el Picker de la vista y luego obtenemos desde el objeto info la
imagen original guardada en la galera. Como es un diccionario lo hacemos a travs del
mtodo objectForKey y
le
pasamos
como
parmetro
su
clave @"UIImagePickerControllerOriginalImage" . Esto nos devolver la UIImage que luego
pasamos a la vista.
En el caso de que nos hayan cancelado la seleccin de la imagen deberamos implementar un

mtodo que nos permite capturar esta accin:
De esta manera podemos asociar cualquier accin por si el usuario cancela.

Otra de la funciones tpicas con imgenes es la necesidad de guardar imgenes dentro de la
galera. Para ello deberemos utilizar el UIImageWriteToSavedPhotosAlbum que es una de las
funciones definidas en el UIKit.h.
Veamos un ejemplo de funcionamiento:
99
Los parmetros de llamada a la funcin son los siguientes:
El objeto UIImage que queremos guardar, en este caso le pasamos la imagen del
UIImageView que tenemos puesta en ese momento.
La clase responsable de implementar los mtodos que necesitamos para funcionar, en
este caso el controlador
El mtodo responsable de manejar por si hay algn error en el guardado:
didFinishSavingWithError:contextInfo
La informacin del contexto, por si es necesaria, en este caso no lo es De esta manera si
hay algn problema intentar ejecutar el mtodo que le hemos indicado a atrvs del
selector:
Comprobamos si ha habido algn error con un if y actuamos en consecuencia.

En la carpeta especial Images.xcassets del proyecto permite manejar las imgenes de Iconos de
lanzamiento y las Imgenes de Lanzamiento del proyecto:
100
al pulsar sobre l nos da acceso a dos categoras principales:
AppIcon nos permitir seleccionar los iconos de lanzamiento de la aplicacin. Los iconos que
tendremos disponibles desde el Home de iOS:
LaunchImage por su parte nos permitir colocar las imgenes de lanzamiento de la aplicacin:
101
Como podemos ver en ambos casos disponemos de varios tamaos, las explicaciones necesarias
para el diseo de los iconos las tenemos disponibles desde la propia ayuda de Apple.
Redes Sociales
Tras el apoyo de Twitter en iOS 5, Apple agreg el apoyo de Facebook en iOS 6. En el pasado, los
desarrolladores tienen que hacer uso de la API de Facebook y Twitter para integrar la funcin de
compartir en sus aplicaciones. Con el apoyo integrado, es mucho ms fcil agregar estas
caractersticas sociales para su propia aplicacin.
En este apartado se mostrara cmo construir Twitter y Facebook compartir caracterstica en su
aplicacin.
Uso de SL Request.
El iOS 6 introduce un nuevo marco conocido como el "Marco Social". El marco social le permite
integrar su aplicacin con los servicios de redes sociales compatibles. Actualmente, es compatible
con Facebook, Twitter y Sina Weibo. El marco proporciona una interfaz estndar para interactuar
con diferentes redes sociales y te protege de aprender el funcionamiento interno. Usted no tiene
que preocuparse acerca de las API de Twitter / Facebook, cmo manejar la conexin de red,
manija de sesin nico, etc. El marco social simplifica todo. Slo tiene que escribir unas pocas
lneas de cdigo para abrir el compositor y usuarios puede tweet / publicar mensaje de Facebook
dentro de su aplicacin.
El marco viene con una clase muy til llamado SLComposeViewController. La clase
SLComposeViewController presenta un controlador de vista estndar para los usuarios componer
tweet o mensaje de Facebook. Tambin permite a los desarrolladores para preestablecer el texto
inicial, adjuntar imgenes y aadir URL para el puesto. Si lo que desea es poner en prctica
caracterstica de uso compartido simple, esta es la nica clase que usted necesita saber y que
vamos a ir a travs de la actualidad.
Si usted no est familiarizado con el SLComposeViewController, esto es lo que parece en su
aplicacin.
102
Ahora usted debera tener una idea bsica sobre el marco. Vamos a empezar y construir una
aplicacin sencilla con Twitter y Facebook integracin.
En primer lugar, cree un nuevo proyecto de Xcode usando la plantilla Single View. Vamos a
nombrar el proyecto como "SocialSharing" y establezca el proyecto con los siguientes parmetros:
103
Una vez que hayas creado con xito su proyecto, vaya al StoryBoard y el diseo de la interfaz de
usuario. En la vista, agregue dos botones. Nombre uno como "Tweet" y el otro como "Facebook":
104
A continuacin, vamos a conectar los elementos de interfaz de usuario, con nuestro cdigo. En el
guin grfico, seleccione el controlador de vista y cambiar al Editor Adjunto.
Mantenga oprimida la tecla de control, haga clic en el botn "Tweet" y arrastrarlo hacia la
"SocialSharingViewController.h". Crear un mtodo de accin y el nombre como "postToTwitter".
Este mtodo se invoca cuando el botn detecta un evento Touch Up Inside.
105
Repita los mismos procedimientos en el botn "Facebook" y el nombre del mtodo de accin
como "postToFacebook". A continuacin se muestra el cdigo final para
"SocialSharingViewController.h":
@interface SocialSharingViewController : UIViewController
- (IBAction)postToTwitter:(id)sender;
- (IBAction)postToFacebook:(id)sender;
@end
Integrar Twitter.
Abra el "SocialSharingViewController.m" y aada el siguiente cdigo para el mtodo

"postToTwitter":
- (IBAction)postToTwitter:(id)sender {
if ([SLComposeViewController
isAvailableForServiceType:SLServiceTypeTwitter])
{
SLComposeViewController *tweetSheet = [SLComposeViewController
composeViewControllerForServiceType:SLServiceTypeTwitter];
[tweetSheet setInitialText:@"Great fun to learn iOS programming
at appcoda.com!"];
[self presentViewController:tweetSheet
animated:YES completion:nil];
106
}
}
Como "SLComposeViewController" es una clase proporcionada por el marco social, recuerde que
debe importar el archivo Social.h en la parte superior de la "SocialSharingViewController.m":
#import <Social/Social.h>
Lnea # 2 - En primer lugar, se utiliza el mtodo "isAvailableForServiceType" para verificar si el

servicio de Twitter es accesible. Una de las razones por qu los usuarios no pueden acceder al
servicio de Twitter es que no han iniciado sesin en el servicio en el iOS.
Lnea # 4 - Si el servicio es accesible, entonces creamos una instancia de la
SLComposeViewController para el servicio de Twitter.
Lnea # 5 - Hemos establecido el texto inicial en el compositor.
Lnea # 6 - Por ltimo, invocamos presentViewController: tweetSheet para abrir el compositor
Twitter.
Por defecto, el marco social no est incluido en el proyecto de Xcode. Para compilar
correctamente la aplicacin, aadir el "Social.framework" en el proyecto. En el Navegador de
proyectos, seleccione el proyecto "SocialSharing". En el rea de contenido, seleccione
"SocialSharing" bajo Objetivos y haga clic en "Build Phases". Ampliar el "Link Binary con
bibliotecas" y haga clic en el botn "+" para aadir la "Social.framework".
Ahora, est listo para probar la aplicacin. Haga clic en el botn "Ejecutar" para probar la
aplicacin en simulador. Cuando se inicia la aplicacin, toque el botn "Tweet" y usted debera ver
una pantalla similar a la de abajo:
107
En caso de que no haya registrado su cuenta de Twitter en el simulador, que va a terminar con el
siguiente. Slo tienes que ir a Ajustes -> Twitter y firmar con su cuenta de Twitter.
Integrar Facebook.
A continuacin, vamos a implementar el botn para publicar publicacin en el muro de Facebook.
En el "SocialSharingViewController.m", agregue el cdigo siguiente en el mtodo
"postToFacebook":
108
- (IBAction)postToFacebook:(id)sender {
if([SLComposeViewController
isAvailableForServiceType:SLServiceTypeFacebook]) {
SLComposeViewController *controller = [SLComposeViewController
composeViewControllerForServiceType:SLServiceTypeFacebook];
[controller setInitialText:@"First post from my iPhone app"];
[self presentViewController:controller
animated:YES completion:Nil];
}
}
Eso es todo. El cdigo es muy similar al cdigo que hemos usado en el mtodo "postToTwitter". El
nico cambio es el tipo de servicio. En lugar de utilizar SLServiceTypeTwitter, le decimos
SLComposeViewController utilizar SLServiceTypeFacebook.
Vamos a ejecutar la aplicacin de nuevo y haga clic en el botn de "Facebook". Su aplicacin debe
abrir el compositor para la publicacin posterior de Facebook.
El SLComposeViewController viene con algunos mtodos incorporados para que pueda fcilmente
hacer la subida. Vamos a modificar el cdigo del botn de Facebook y hacer el trabajo de carga.
109
En primer lugar, descargar esta imagen y aadirla al proyecto Xcode. (Se puede utilizar cualquier
imagen, pero asegrese de que lo nombra como "-socialsharing facebook-imagen.jpg")
Usted puede simplemente utilizar el mtodo "addImage" para adjuntar una el mtodo "AddURL"
imagen e incluir un enlace.
[controller addURL:[NSURL URLWithString:@"http://www.appcoda.com"]];
[controller addImage:[UIImage imageNamed:@"socialsharingfacebook-image.jpg"]];
Persistencia de datos usando Archiving.
De uno u otro modo, en prcticamente la totalidad de apps que hagamos, vamos a necesitar
guardar los datos que proporciona el usuario, para que stos se conserven entre diferentes
ejecuciones de la misma.
En iOS existen mltiples mtodos de persistencia, que nos van a ayudar con esta tarea. Entre ellos
estan, la utilizacin de NSUserDefaults, escribir la informacin en ficheros de tipo Property List,
implementar Archiving en nuestras clases, etc. stos mtodos, aunque para algunas apps pueden
ser mas que suficientes, tienen ciertas carencias, que vamos a resumir a continuacin:
Permiten unicamente trabajar con volmenes relativamente pequeos de datos
No permiten establecer relaciones o dependencias entre diferentes entidades
No permiten la realizacin de consultas complejas o filtros sobre la informacin
Para todas aquellas apps en las que necesitemos salvar estas carencias, y contar con una serie de
herramientas que nos permitan definir modelos de datos con mayor complejidad, Apple pone a
nuestra disposicin Core Data.
Core Data no es una simple base de datos, sino mucho ms. Incluye muchos comportamientos
tpicos de un ORM, as como otras muchas funcionalidades que nos van a ayudar en el da a da.
Core Data esta compuesto de una serie de clases, que orquestadas unas con otras, conforman un
framework para persistencia avanzada.
Con Core Data, escribiendo muy pocas lneas de cdigo, vamos a poder crear complejos modelos
de datos, con relaciones entre los diferentes elementos que los componen, establecer
validaciones de datos, posibilidad de undo y redo, lazy loading (permite cargar cierta informacin
solo cuando es solicitada, con la finalidad de mejorar el rendimie nto de las consultas), bsquedas,
etc.
El trabajo con Core Data dentro de nuestra app se va a apoyar principalmente en tres conceptos:
Modelado de datos
110
Guardar informacin
Recuperar informacin
Para ello, debemos conocer cuales son las tres principales clases que utilizaremos en Core Data:
NSManagedObjectModel: es el modelo de nuestra app, y se ve representado por un archivo con
extensin .xcdatamodeld.
NSManagedObjectContext: es el contexto en el cual se van a realizar todas las operaciones de
lectura y escritura en el modelo. Ser el objeto que mas utilicemos a lo largo del desarrollo, ya que
es el que nos da acceso a la generacin de nuevas instancias de las entidades del modelo, o a
realizar consultas sobre los datos ya existentes.
NSPersistentStoreCoordinator: es el encargado de hacer la persistencia real a disco, por defecto a
una base de datos SQLite.
A lo largo de los diferentes artculos que componen este monogrfico, vamos a ir viendo con todo
detalle, cmo y cuando utilizaremos cada uno de ellos.
Disear interface de usuario.
Al crear determinados tipos de proyectos en Xcode, se ofrecen una serie de posibilidad en modo
de checkbox: Use Storyboard, Use Automatic Reference Counting, Use Core Data.
111
Pues bien, que a nadie le lleve esto a pensar que aquellos tipos de proyecto donde no aparezca
dicho checkbox de Use Core Data, o bien si hemos creado una app y se nos ha olvidado activar
dicha casilla, ya no sea posible utilizar Core Data. Xcode lo unico que hace con estas casillas, es
ayudarnos autogenerando ciertas archivos, mtodos y configuracin, para evitar que tengamos
que hacerlo nosotros manualmente. Sin embargo, en cualquier proyecto nuevo o existente es
posible incluir Core Data sin ningn problema.
En el caso de activar esta casilla al crear nuestro proyecto, Xcode generar por nosotros los
siguientes elementos:
Un fichero con extensin .xcdatamodeld que corresponde al modelo de datos de nuestra app. Este
modelo de datos se puede crear, modificar y configurar visualmente desde el propio Xcode.
Una serie de mtodos en la clase AppDelegate, que toda app que utilice Core Data deber tener
en uno u otro lugar.
Dentro de los elementos que genera por nosotros la plantilla de Xcode, se encuentran tres
propiedades y dos mtodos en el AppDelegate para poder trabajar con Core Data:
@property (readonly, strong, nonatomic) NSManagedObjectContext *managedObjectContext;
@property (readonly, strong, nonatomic) NSManagedObjectModel *managedObjectModel;
112
@property (readonly, strong, nonatomic) NSPersistentStoreCoordinator

*persistentStoreCoordinator;
- (void)saveContext;
- (NSURL *)applicationDocumentsDirectory;
Las propiedades no creo que requieran ningn tipo de explicacin con lo comentario
anteriormente. Los mtodos son para recoger la lgica de guardado del contexto y un mtodo de
utilidad para recuperar el directorio Documents del usuario rpidamente.
Adicionalmente, incluye tres mtodos getters que hacen uso de lazy instantiation para cada una
de las propiedades vistas anteriormente, dentro de un bloque que denomina Core Data Stack:
Un getter personalizado para la propiedad managedObjectContext donde el contexto solo se crea
la primera vez, y en las siguientes invocaciones se obtiene del NSPersistentStoreCoordinator.
- (NSManagedObjectContext *)managedObjectContext
{
if (_managedObjectContext != nil) {
return _managedObjectContext;
}
NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];

if (coordinator != nil) {
_managedObjectContext = [[NSManagedObjectContext alloc] init];
[_managedObjectContext setPersistentStoreCoordinator:coordinator];
}
return _managedObjectContext;
}
Un getter personalizado para la propiedad managedObjectModel que recupera el modelo de datos
de nuestro fichero con extensin .xcdatamodeld, haciendo una comprobacin previa para
garantizar que la lectura a disco del fichero se haga una nica vez.
113
- (NSManagedObjectModel *)managedObjectModel
{
if (_managedObjectModel != nil) {
return _managedObjectModel;
}
NSURL *modelURL = [[NSBundle mainBundle] URLForResource:@"Prueba"
withExtension:@"momd"];
_managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
return _managedObjectModel;
}
Un getter personalizado para la propiedad persistentStoreCoordinator que genera una nica
instancia de esta propiedad, y la inicializa al tipo NSSQLiteStoreType (SQLite).
- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
{
if (_persistentStoreCoordinator != nil) {
return _persistentStoreCoordinator;
}
NSURL *storeURL = [[self applicationDocumentsDirectory]

URLByAppendingPathComponent:@"Prueba.sqlite"];
NSError *error = nil;

_persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc]
initWithManagedObjectModel:[self managedObjectModel]];
if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType
configuration:nil URL:storeURL options:nil error:&error]) {
114
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);

abort();
}
return _persistentStoreCoordinator;
}
Por ltimo, incluye un mtodo de utilidad para recuperar rpidamente el directorio Documents de
nuestro Sandbox:
- (NSURL *)applicationDocumentsDirectory
{
return [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory
inDomains:NSUserDomainMask] lastObject];
}
Realizar "testing" a la aplicacin
Si nuestra intencin es utilizar Core Data en una app que ya tenemos hecha, basta con crear un
nuevo fichero de tipo Data Model (en la seccin Core Data).
115
A continuacin incluiremos las propiedades y mtodos que hemos visto anteriormente, y ya

estamos preparados para comenzar a utilizar Core Data. Para asegurarse de que todo es correcto,
conviene verificar que el nombre utilizado para el fichero del modelo en el mtodo
managedObjectModel, coincida con el que hemos creado en el parrafo anterior.
Sin duda el primer paso que debemos dar cuando implementamos Core Data en una app, es
definir el modelo de datos. Para ello basta con seleccionar el fichero con extensin .xcdatamodeld
y veremos que en la parte derecha de la pantalla se muestra un editor visual.
116
Tambin es posible visualizar nuestro modelo de forma grfica en lugar de como tablas.
Para ello basta con cambiar la opcin Editor Style en la barra inferior en la parte lateral derecha.
117
XML & JSON.

Crear, modificar, eliminar archivos XML & JSON.
JSON es un formato ligero para intercambiar informacin, similiar a XML pero con una
considerable reduccin en cuanto al tamao de los archivos.
A continuacin vamos a ver dos ejemplos en XML y JSON para que podis apreciar la diferencia:
XML
<recetas>
<receta>
<nombre>Huevos fritos</nombre>
<puntuacion>5</puntuacion>
<ingredientes>Huevos, aceite, sal</ingredientes>
<fecha>20/12/2011</fecha>
</receta>
</recetas>
JSON
recetas: [
{
nombre : Huevos fritos
puntuacin: 5
ingredientes: Huevos, aceite, sal
fecha: 20/12/2011
}
Como se puede observar en este ejemplo, el tamao en el archivo JSON es notablemente inferior.
Quizs esto pueda ser un matiz sin importante para este ejemplo, pero imaginemos que tenemos
que descargar de internet 20.000 recetas.
118
Pues bien, como comentbamos antes, para este ejemplo deberemos inscribirnos en la web
PunchFork para obtener gratuitamente una API KEY que podamos utilizar para este ejemplo. La
API KEY ofrecida gratuitamente por esta empresa, esta limitada a un total de 500 peticiones al da.
Si queris utilizar esta API de forma comercial sin lmite, podis consultar los plantes de precios en
la propia web.
El cdigo que aqu se presenta es til tanto si se utiliza PunchFork, como para cualquier otra
fuente de datos JSON.
Incluir la librera de JSON en nuestro proyecto
En primer lugar deberemos incluir en nuestro proyecto la librera de JSON, y que esta formada por
dos directorios:
JSON
JSON-URL
Para ello, haremos clic con el botn secundario en nuestro proyecto y pulsaremos la opcin Add
Files to XXXXXX. Seleccionaremos los dos directorio indicados anteriormente y pulsaremos el
botn Add. (Para facilitar la posterior distribucin de nuestra App, recordar seleccionar la opcin
Copy tems to destination group si se tiene esta librera en un directorio distinto al proyecto).
Creacin de una clase Receta
Para poder obtener y recorrer la informacin obtenida de JSON, necesitaremos una clase
especifica que albergue la informacin de cada receta.
Crearemos una nueva clase mediante el botn secundario en nuestro proyecto New file.
La nueva clase deber ser un Objective-C class, y su clase padre deber ser NSObject.
Para el ejemplo la llamaremos Receta.
Receta.h
#import
@interface Receta : NSObject
@property (nonatomic, retain) NSString *nombre;
119
@property (nonatomic, retain) NSString *imagen;

@property (nonatomic) int contadorTwitter;
@end
Receta.m
#import "Receta.h"
@implementation Receta
@synthesize nombre, imagen, contadorTwitter;
@end
Creamos un mtodo que recupere la lista de recetas del servicio;en primer lugar importaremos la
librera en la cabecera de nuestro ViewController:
#import myJson.h
A continuacin creamos el mtodo:
// Mtodo que obtiene la lista de recetas de la API de PunchFork
-(void) cargarRecetas
NSString *url =
@"http://api.punchfork.com/recipes?key=VUESTRA_API_KEY&q=";
Json *jsonParser = [[Json alloc] init];
[jsonParser startLoadingObjectWithUrl:url andDelegate:self];

}
120
// Mtodo que es llamado una vez se ha descargado el fichero JSON (dele gado)
-(void)dataRequestCompletedWithJsonObject:(id)jsonObject {
NSDictionary *recetasDictionary = (NSDictionary *)jsonObject;

NSArray *recetasArray = (NSArray *)[recetasDictionary objectForKey:@"recipes"];
for (NSDictionary * dic in recetasArray) {

Receta *receta = [[Receta alloc] init];
[receta setNombre:[dic objectForKey:@"title"]];
[receta setImagen:[dic objectForKey:@"thumb"]];
[receta setContadorTwitter:[[dic objectForKey:@"twc"] intValue]];
NSLog(receta.nombre);
}
}
La librera que estamos utilizando requiere que nuestro ViewController implemente un Delegate
denominado myJsonDelegate.
De este modo, una vez se descargue correctamente el fichero JSON de internet, el segundo
mtodo ser llamado automticamente.
Recordar que para declarar nuestro ViewController como delegado de la clase, es necesario incluir
el siguiente cdigo en la definicin de la cabecera de nuestra clase:
@interface XXXXXX : UIViewController

En el ejemplo mostrado anteriormente, se describe como obtener diferentes tipos de atributos de
la receta como son NSString o Integer.
Si se ejecuta el Simulador con el cdigo aqu indicado podris comprobar que en la Consola de
vuestro Xcode se pinta algo similar a esto:
121
Baked Potato Soup

Parmesan Roasted Potatoes
Bacon & Cheese Wrapped Tater Tots with Tabasco
El parseo del fichero JSON depender de la propia estructura del fichero y por tanto, la
informacin aqu recogida solo aplica a nuestro ejemplo.
Subir archivos a Web Service o FTP.

Una de las tareas ms importantes que un desarrollador tiene que hacer frente a la hora de crear
aplicaciones es la entrega y manipulacin de datos. Los datos pueden ser expresados en muchos
formatos diferentes, y el dominio de al menos los ms conocidos de ellos consiste en una
caracterstica clave de cada programador. Hablando especficamente para aplicaciones mviles, es
muy comn hoy en da para que puedan intercambiar datos con aplicaciones web. En tales casos,
la forma en que los datos se expresa puede variar, pero generalmente se prefiere, ya sea el
formato XML JSON.
iOS SDK ofrece clases para el manejo de los dos. Para la gestin de datos JSON, no es la clase
NSJSONSerialization. ste permite convertir fcilmente un datos JSON en un objeto de
infraestructura (NSArray, NSDictionary), y al revs. Para analizar los datos XML, iOS ofrece la clase
NSXMLParser, que se encarga de hacer todo el trabajo duro, ya travs de algunos mtodos de
delegado tiles nos da las herramientas que necesitamos para manejar cada paso del anlisis.
Crear certificados y aprovisionar perfiles.

Tipos de licencias de desarrollo
Es bien sabido por todos que nuestros colegas de Apple no publican cualquier aplicacin de iOS en
su AppStore y que no cualquiera puede intentar publicar su aplicacin. Por este motivo Apple
tiene varios tipos de licencia que se ajustan a los requerimientos de sus clientes. Se comentaran
los tipos de licencia que Apple ofrece y para qu sirve cada una.
Apple Developer
No tiene ningn costo, unicamente puedes descargar Xcode (software con el que se desarrollan las
applicaciones de apple) y te da acceso a las versiones finales de sus herramientas de desarrollo en
el mercado. Con esta licencia no puedes subir aplicaciones al AppStore ni puedes subir tus propias
aplicaciones a tu iphone o ipad; nicamente puedes usarlas en un simulador que proporciona
Xcode.
122
iOS University Program

Esta licencia es gratuita pero slo aplica con universidades participantes. Con este tipo de licencia
ya se puede probar las aplicaciones en dispositivos pero no permite subir aplicaciones al AppStore.
Es nicamente para fines educativos.
iOS Developer Program
Esta licencia tiene un costo de 99 dlares al ao. Al pagar esta licencia se tiene acceso a las
versiones beta que van sacando de Xcode y iOS antes de que estn en el mercado. Esta licencia
permite probar aplicaciones de desarrollo en 100 dispositivos que tienen que ser previamente
registrados a travs de la Web de Apple. Con esta licencia se pueden publicar aplicaciones en el
AppStore y pueden comercializarse con beneficios del 70% sobre el precio de venta que se
establece. Esta licencia nicamente puede registrarse en dos computadoras para desarrollo y
nicamente se puede subir al AppStore desde una computadora, es decir, no permite publicar
aplicaciones desde dos computadoras distintas con una misma licencia.
iOS Developer Enterprise Program
Esta licencia tiene un costo de 299 dlares anuales y funciona para aplicaciones corporativas
privadas. Esto sirve para crear una aplicacin e instalarla en varios dispositivos sin necesidad de
publicarla en el AppStore. Pero este tipo de licencia tiene una limitante; ya que un mismo
dispositivo no puede tener dos aplicaciones instaladas que fueron creadas con diferentes licencias
del iOS Enterprise Program.
Crear un certificado de desarrollo

Una vez obtengamos la licencia, tendremos acceso al IOS Provisioning portal, desde ah nos
dirigiremos a "Certificates" >> "Development" y pulsaremos en "Request Certificate" para solicitar
un nuevo certificado. Nos pedir que subamos un archivo CSR.
123
Por eso en "Aplicaciones" >> "Utilidades" y se accedera a "Acceso a Llaveros". Una vez ah vamos
al men "Acceso a Llaveros" en "Asistente para Certificados" y hacemos clic a "Solicitar un
certificado de una autoridad de certificacin...".
Rellenamos nuestra direccin de correo y nombre, luego hacemos clic en "Guardado en el disco".
Esto nos generar el archivo CSR (certSigningRequest), que deberemos subir en el IOS Provisioning
portal.
Si volvemos al IOS Provisioning portal veremos que nuestro certificado se encuentra en el estado
"Pending Issuance".
124
En cuestin de varios segundos recibiremos un correo electrnico notificndonos que un miembro

del equipo ha solicitado un certificado.
A partir de ese instante nuestro estado habr cambiado a "Issued", eso significa que ya podremos
descargar nuestro certificado. Para instalarlo solo tendremos que arrastrarlo al "Acceso a Llaveros"
o hacer doble clic.
Instalar un App dentro de un dispositivo.
125
El siguiente paso ser aadir un dispositivo que utilizaremos para probar nuestras aplicaciones
(podemos aadir hasta un total de 100 dispositivos distintos), para ello abriremos el "Organizer"
(que lo encontraremos abriendo el Xcode, vamos al men "Windows" y seleccionamos
"Organizer"). En la seccin "Devices" copiaremos el identificador (conocido tambin como token)
del dispositivo, una cadena alfanumrica de 40 caracteres.
Luego nos dirigimos de nuevo al IOS Provisioning portal, en la seccin "Devices" y pulsamos en
"Add Devices". Introducimos el nombre como queramos nombrar al dispositivo, pegamos el
identificador que hemos copiado antes y le damos a "Submit".
Crear un App ID
Una vez hemos aadido el dispositivos, a continuacin crearemos un identificador de aplicacin.
Para ello iremos a la seccin "App IDs" y pulsamos en "New App ID".
126
En el campo "Bundle identifier" Apple nos recomienda que utilizemos el estilo invertido usado en
un nombre de dominio. Por ejemplo si disponemos de un dominio llamado "midominio.com", y a
nuestra aplicacin la queremos llamar "miaplicacion", podemos aadir un subdominio a nuestro
dominio de tal forma que pase a llamarse "miaplicacion.midominio.com". Ahora si invertimos el
dominio
podemos
utilizar
este
nombre
como
identificador
de
paquete
com.midominio.miaplicacion", es una buena forma de mantener organizada y ordenada los
nombres de aplicaciones, cuando tengamos muchas aplicaciones agradecereis haber seguido las
recomendaciones de Apple.
Podemos tambin usar el carcter comodn (asterisco '*') para que un nico identificador de
aplicacin se puede utilizar para construir e instalar varias aplicaciones.
Asociar un App ID con un APP.

Ahora podremos solicitar un perfil de aprovisionamiento, que no es ms que una coleccin de
entidades digitales que vincula desarrolladores con dispositivos permitiendo a un dispositivo
utilizarlo para testear las aplicaciones. Para ello nos dirigiremos a la seccin "Provisioning" y
hacemos clic en "New Profile".
127
Crear un aprovisionamiento de perfil de desarrollo.

Capturamos el nombre que deseemos dar para el perfil, seleccionamos el certificado que
deseamos usar (en este caso slo hay uno), escogemos la aplicacin, los dispositivos que
queremos incluir para efectuar las pruebas y pulsamos en "Submit". Regresaremos en la seccin
anterior y podremos ver que aparecer nuestro nuevo perfil en estado "pending", pero en breves
instantes ya estar disponible para su descarga.
Descargamos el perfil, para instalarlo tan slo tendremos que arrastrarlo al "Organizer" que se
encuentra abriendo el Xcode, vamos al men "Windows" y seleccionamos "Organizer".
128
Compatibilidad de versiones.
Debemos acceder a los ajustes del proyecto, en "Build Settings", vamos a "Code Signing Identity",
tanto en el caso de "Debug" (desarrollo) como para "Release" (para publicar al AppStore)
indicaremos que firma utilizaremos para incrustar en la aplicacin.
129
Si nos aparece uno de los siguientes errores, significar que algo no hemos hecho bien. Una
recomendacin seria repetir todo el proceso desde el principio.
Code Sign error: The identity 'iPhone Developer' doesn't match any valid
certificate/private key pair in the default keychain
CodeSign error: code signing is required for product type 'Application' in SDK 'iOS X.X'
Anexo
Agregar icono a la aplicacin
Para agregar un icono a la app en xcode se realizara lo siguiente:
1. Se abrira el Xcode .
2. Una vez Abierta la aplicacin, por medio del la Barra de Menu. Abriremos la aplicacin que
se le cambiara el icon en la ruta en la que este guardada.
130
3. En la ventana que se apertura buscar la carpeta del proyecto , se procede a abrir la

carpeta y buscar el archivo con el nombre del proyecto con extensin (Hola
mundo).xcodeproj. Si ese que tiene un icono de una A en blanco con fondo azul.
Y damos clik en el para seleccionarlo.
131
Inmediatamente se abre nuestra aplicacin, dentro de Xcode.
4. En el panel de Groups & Files. Seleccionaremos la carpeta Resources
132
Despues hacemos click derecho, para obtener el menu Contextual.
Posicionamos el puntero del mouse sobre la opcin Add y se desplegar, su submenu, del cual
clickaremos la opcin Existing Files
133
5. Buscamos la imagen deseada como la que se muestra a continuacin.
Despues solo presiono el botn Add
Y aparecer la ventana siguiente.
134
Da un click en el cuadro de seleccin de Copy items into destination groups folder (if
needed).
Al darle click en el botn Add, se agrega al Panel Groups & Files, el icono recien ingresado.
135
6. Ahora procederemos a agregarlo a nuestra aplicacin iPhone. As que para ello,

seleccionamos el archivo HolaMundo-Info.plist.
Una vez seleccionado debemos de estar viendo el siguiente cdigo:
136
Lo relevante de este paso es que se asigne el elemento agreagado como imagen en Groups &
Files, sea asignado aqu en ele elemento Icon File, escribiendo el nombre del archivo de
imagen, tal y como aparece en el Groups & Files. En mi caso se llama: 179-notepad.png.
Quedando el elemento como se muestra a continuacin.
7. Por ultimo, se guardaran los cambios en el archivo de Xcode. Y se presiona Build and Run.
137
Archivar aplicacin para distribucin

Una vez que haya terminado de crear su app puede distribuir las apps internas alojando su app en
un servidor web creado internamente, configurando su propio catlogo de apps internas o usando
una solucin de administracin de dispositivos mviles de un tercero.
La mejor solucin para usted depende de sus requisitos especficos, su infraestructura y el nivel
deadministracin de apps que necesita.
Proceso de distribucin inalmbrica de apps

La forma ms simple de distribuir su app es alojarla en un servidor web. Slo tiene que seguir
estos pasos:
1. Aloje su app en un servidor web al que puedan acceder sus empleados.
2. Notifique a sus usuarios sobre la disponibilidad de la app a travs de correo electrnico,
SMS,notificacin push u otros mtodos que los usuarios puedan recibir en un dispositivo iOS;
asegrese de incluir la URL de la app.
3. Toque en la URL para instalar la app. Una ventana le preguntar si quiere continuar con la
instalacin.
Para ms detalles sobre cmo establecer su propio servicio de distribucin inalmbrica de apps,
visite
http://developer.apple.com/library/ios/#featuredarticles/FA_Wireless_Enterprise_App_Distributi
on/.
Catlogo de apps internas
Su equipo tambin puede crear un catlogo de apps internas que brinde un portal para la
distribucin inalmbrica de sus apps de iOS. Este modelo de autoservicio requiere un esfuerzo
mnimo de descarga e instalacin por parte de los empleados. El catlogo puede proveer URL de
descarga de apps directamente, lo cual permite instalar y actualizar varias apps, as como
implementar y configurar rpidamente. Un sitio web o app nativa -optimizada para iPhone o iPades un mtodo an ms sencillo de proveer URL en una manera organizada y familiar. Para ver un
138
ejemplo de un catlogo de apps internas, consulte el Estudio de caso: El App Store interno de
GE, a la derecha.
Administracin de actualizaciones
Las apps internas que son distribuidas internamente no se actualizan automticamente. Deber
notificar a los empleados sobre la actualizacin y pedirles que instalen la app. Si el identificador de
la aplicacin asignado a la app en Xcode no es alterado, reconocer a la app como una app
existente e instalar la actualizacin mientras conserva las preferencias o los datos de la app
almacenados localmente. Para una mayor comodidad, considere el desarrollo de una funcin
dentro de la app que contacte al servidor para buscar actualizaciones en ejecucin.
Con la distribucin inalmbrica de apps puede proporcionar un enlace a la app actualizada
directamente desde dentro de la app. Si crea una aplicacin de catlogo de apps nativas,
considere el uso de Servicios de notificacin push con un alerta o indicador para que los usuarios
conozcan las actualizaciones disponibles.
Administracin de dispositivos mviles
Muchas soluciones de administracin de dispositivos mviles de terceros brindan capacidades de
distribucin inalmbrica de apps de forma predeterminada. Los beneficios de administrar apps
internas de un entorno administrado incluyen la capacidad de hacer el control de versiones y ver
qu versin de su app estn ejecutando los usuarios. Muchas soluciones de administracin de
dispositivos tambin brindan servicios de Notificacin push para que los usuarios sepan cundo
hay apps nuevas y actualizadas disponibles. Adems, como las soluciones de administracin de
dispositivos mviles pueden establecer configuraciones de red y polticas de seguridad, es una
manera genial de proveer ajustes directamente en el dispositivo en el momento en que es
instalada la app (por ejemplo, certificados de VPN o Wi-Fi). Para ms informacin sobre soluciones
de
administracin
de
dispositivos
mviles,
visite
www.apple.com/iphone/business/integration/mdm.
Configurar la aplicacin en ITunes.

El App Store se perfila junto al de Google Play como los dos ms importantes mercados actuales
de software. Prcticamente se podra decir que si no est en el AppStore o no es accesible como
una WebApp, no es un software que llegue al gran pblico.
La publicacin en el AppStore puede ser un tanto complicada, ya que implica varios pasos por
parte del desarrollador. A continuacin explicamos una perspectiva general de todo el proceso.
Registrarse como Apple Developer
El primer paso es registrarse como desarrollador de Apple desde

http://developer.apple.com/devcenter/ios/index.action pudiendo enlazar nuestro Apple ID
existente a una cuenta de desarrollador o crear una nueva.
Una vez rellenados nuestros datos y verificada la cuenta, deberemos entrar dentro de ella.
139
Entrando en el programa iOS Developer Program

Cuando estemos dentro de nuestra cuenta de Apple Developer, entraremos en nuestra cuenta y
veremos en el panel de control la opcin Join the Developer Program que nos dar acceso a
programar apps para iOS (hay que prestar atencin a sto ya que cada tipo de app/aplicacin
Apple es diferente y no es el mismo este programa que el de aplicaciones de MacOS X)
Durante este proceso deberemos prestar atencin a varios puntos:
En el resgistro, nuestro nombre, apellidos o cualquier otro dato no deber contener tildes
o si no recibiremos una llamada desde Apple diciendo que nuestra cuenta no puede ser
completada hasta que los eliminemos del proceso de registro.
Deberemos pagar la cuota anual de desarrollador de Apple, existen varios planes segn si
por ejemplo queremos que nuestras apps se distribuyan slo a travs del Apple Store o
tambin queremos que puedan ser instaladas directamente en el dispositivo sin pasar por
l. En nuestro caso vamos a elegir la cuota bsica que ronda unos 99$.
Deberemos aportar los datos acreditativos de empresa en el proceso o como individual,
esto vara segn el pas
Tras realizar el pago, el proceso de registro quedar en espera para que Apple valide el nuevo
usuario. Esta espera puede ser de unos pocos das, durante los cuales Apple puede ponerse en
contacto con nosotros por telfono para verificar o pedir aclaraciones sobre algn dato.
Instalando Xcode: entorno de desarrollo
En estos momentos de espera es un buen momento para instalar el entorno de desarrollo Xcode
(tipo Eclipse, Netbeans, Visual Studio, ...) desde https://developer.apple.com/xcode/ que
depender de las ltimas versiones de MacOS X (no se haba dicho antes, pero s, para programar
apps de iOS necesitamos un MacOS X).
Es importante que mantengamos Xcode actualizado a su ltima versin si queremos que nuestras
aplicaciones sean vlidas en las ltimas versiones de iOS.
iOS Provisioning portal: certificados
Cuando se tenga la verificacin por parte de Apple, volveremos a entrar en el portal Apple
Developer y veremos que nuestro usuario tiene nuevas opciones que antes no tena.
El rea iOS Provisioning portal nos permite correr apps en entorno de pruebas en dispositivos
reales (iPhone, iPad, iPod, ...) que todava no han sido publicadas. Este proceso se hace a travs de
software firmado con certificados digitales, que existen de dos tipos:
Development profiles: slo vlidos para desarrollo
Distribution profiles: para distribucin
140
Para que podamos empezar a probar, entraremos en el enlace de iOS Provisioning portal y en su
men principal en Certificates donde veremos las pestaas de Development y Distribution.
Haremos una peticin de certificado mediante el botn de Request Certificate.
Antes de seguir, dejaremos la pgina web un momento y prepararemos el certificado de
desarrollo/distribucin. En Spotlight buscaremos el programa Keychain access y pulsaremos sobre
el men Keychain Access -> Certificate assistant -> Request a Certificate from a Certificate
Authority y a continuacin rellenaremos con nuestros datos marcando la opcin Saved to disk que
nos generar un certificado X.509 con nuestros datos.
Volveremos al navegador web y subiremos el nuevo archivo generado. Nos devolver a la pgina
principal de certificados que el estado de nuestro certificado puede estar pendiente de
aprobacin. Esta peticin se resuelve automticamente en poco tiempo (mximo en algunos
minutos), y cuando est lista nos aparecer un botn que nos permitir la descarga del certificado.
Una vez descargado, haremos doble click sobre el archivo y se importar a nuestro Keychain.
iOS Provisioning portal: dispositivos de entorno de pruebas
En el paso anterior creamos los certificados necesarios para autenticarnos como desarrollador iOS,
pero tambin deberemos especificar los dispositivos que pueden estar en el entorno de pruebas.
Para aadir nuevos, en iOS Provisioning portal -> Devices -> Add devices desde donde tendremos
que aadir cada UDID de cada uno de los dispositivos del entorno de pruebas. El UDID es un
identificador nico para cada dispositivo. Una manera sencilla de verlo es desde iTunes, desde la
pestaa de dispositivo se refleja una serie de caracteres alfanumricos.
iOS Provisioning portal: App ID y Provisioning
Por cada app, deberemos crear un App ID que identificar exclusivamente a dicha app. Para ello
en iOS Provisioning portal -> Devices -> App ID crearemos el identificador nico de nuestra app.
A continuacin, en Provisioning haremos click en New profile donde crearemos un perfil para
nuestro App ID. Entre las opciones deberemos prestar atencin al Distribution Method: App Store
o Ad-Hoc.
Nos devolver a la pantalla principal de Provisioning y veremos un botn de descarga del profile,
lo descargaremos e instalaremos en nuestro PC.
Para ver que est correctamente instalado en nuestro ordenador, abriremos Xcode y en Organizer,
veremos que en sus Provisioning profiles tenemos ya preparado el perfil para nuestra App.
Programar la aplicacin en Objective C

Este paso se realiza en base a lo que se aprendio durante el curso,se programara mediante Xcode
y probara en el simulador.
141
Probar en iPhone/iPad/iPod
Conectaremos el dispositivo que hemos introducido el UDID y nos aparecer la ventana de
Organizer. Si es la primera vez que lo conectamos deberemos hacer click en el botn Use for
development. Podemos echarle un vistazo a los Provisioning profiles, si esos perfiles estn
asignados al dispositivo actual, si no tuviera ninguno seleccionaremos iOS Team Provisioning
Profile.
Ahora en la pantalla principal de Xcode y se seleccionara el primer icono de proyecto (de color
azul) y en el submen en Target. A continuacin especificaremos segn la pestaa:
Summary: dispositivos, identificadores y versiones.
Info: Bundle identifier, como parte de nuestra App ID
Build Settings: buscaremos el Code Signing Identity, eligiendo para cada perfil el
certificado de desarrollo o distribucin, segn necesitemos.
Esto nos permitir a ejecutar a travs de Xcode la app en nuestro dispositivo.

Subiendo la App a App Store con iTunes Connect
Este es el portal donde se suben las apps y se especifica su informacin: nombre, capturas de
pantalla, precio, etc. Deberemos entrar en https://itunesconnect.apple.com/ y con nuestras
credenciales de desarrollador iOS.
En este punto deberemos tener bien preparado lo siguiente:
Nombre
142
Descripcin
Icono 512x512px
Capturas de pantalla: al menos una para iPhone y otra para iPad en los siguientes
formatos 320x460 (sin barra de estado); 320x480; 640x920 (retina, sin barra de estado);
640x960 (retina); para orientacin paisaje 480x300 (sin barra de estado); 480x320;
960x600 (retina, sin barra de estado); o 960640 (retina).
Antes de mandar la app, deberemos tener claro cuales son los App Review Guidelines, sobre el
buen uso de las apps que van a ser publicadas en cuanto a funcionamiento y contenido. Es
importante que revisemos la gua https://developer.apple.com/appstore/guidelines.html y
estemos seguros para que la app no sea rechazada.
Dentro de iTunes Connect darle a Manage your applications y Add new app donde rellenaremos
los datos de app, entre ellos seleccionaremos el App ID creado para el app.
143
Tienes que seleccionar la fecha en la que estar disponible tu aplicacin en AppStore una vez se
apruebe por Apple. Tambin el precio de la aplicacin y haremos click en Continue.
Introducimos el nmero de versin, Copyright y 2 categoras que describan la aplicacin

desarrollada.
Seleccionamos para cada tipo el nivel de frecuencia:
144
Introducimos una descripcin para la aplicacin y una serie de palabras que describan tu
aplicacin para la bsqueda de ella en el AppStore.
Tambin hay que introducir una web de support.
Introducir informacin de contacto.
145
Hay que subir imgenes de la aplicacin.
Large App Icon: es el icono de tu aplicacin. Tamao: 1024x1024

3.5-Inch Retina Display Screeenchots: Puedes subir hasta 5 imgenes que describen tu app. Suelen
ser pantallas de la aplicacin. Son para iPhone 4, tamao: 960x640, 960x600, 640x960 o 640x920
formato JPG o PNG.
4-Inch Retina Display Screenshots: Pantallas para iPhone 5, tamao: 1136x640, 1136x600,
640x1136 o 640x1096 formato JPG o PNG.
iPad Screenshots: Pantallazos para iPad, tamao: 1024x768, 1024x748,768x1024, 768x1004,
2048x1536, 2048x1496, 1536x2048 o 1536x2008 en formato jpeg,jpg,tif,tiff o png.
Hacemos click en save y aparecer el icono con un crculo naranja como el siguiente:
146
Tras rellenar todos los datos, haremos click en Ready to Upload Binary.
La subida de los archivos binarios se har a travs de Xcode, como Scheme elegiremos iOS Device y
despues Product Archive. Se abrir una ventana de Organizer donde haremos click en Submit y tras
subir la app, volveremos a iTunes connect viendo que la app ya est recibi da y pendiente de
revisin.
1. Esta prepared to Upload. Ahora hay que subirla desde xcode.
2. Abrimos nuestro proyecto de X-Code (xcodeproj) .
Comprobamos que nuestro bundle Id es el mismo que hemos creado en Apple Developer
identifier (Paso A).
En el proyecto de xcode carpeta (supporting Files) -> info.plist introducir Bundle
identifier.
3. Seleccionamos nuestro provisioning profile.
En las opciones generales del proyecto en la pestaa Build Settings, buscamos Code Signing
Identity, y seleccionamos el provisioning creado en paso A para el campo Release.
147
4. Hacemos click en la pestaa Product y -> Archive. Si no detecta ningn error generar
nuestro archivo correctamente
Seleccionamos la opcin Validate.

Aparecer una ventana con los datos que ha cargado de nuestra cuenta de iTunes
Connect, o tendremos que meter nosotros el usuario y la contrasea.
El primero es el nombre de la aplicacin y el segundo es quien firma la aplicacin.
148
Si nuestra aplicacin pasa la prueba correctamente nos mostrar una ventana cmo esta.
149
Con nuestra aplicacin validada correctamente pulsamos en la opcin -> Distribute y nos
aparecer una ventana como la siguiente. En la que le indicamos Submit to the iOS App Store y
pulsamos Siguiente.
150
Seguidamente nos aparecer una ventana como esta indicando que la aplicacin se ha subido
correctamente y que est en proceso de revisin por el equipo de Apple.
151
As aparece ahora si la vamos a ver a nuestra cuenta de iTunes Connect. (waiting for Review)
152
153

Manual IOS Avanzado v1.2 (V Final)

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Manual IOS Avanzado v1.2 (V Final)

Caricato da

Copyright:

Formati disponibili

Contenido del curso

Gestos, Taps y Touches..................................................................................................... 35

Crear un aprovisionamiento de perfil de desarrollo. .............................................................128

La clase NSFileManager contiene un mtodo llamado defaultManager podemos obtener la

Definir el directorio actual

directorioActual = [raiz currentDirectoryPath];

Crear Leer y Borrar Directorios

El mtodo createDirectoryAtURL regresa un valor booleano indicando si la operacin fue exitosa o

Renombrar o mover un directorio

Listar contenido de un directorio

raiz= [NSFileManager defaultManager];

Obtener atributos de un archivo o directorio

Los atributos de un archivo o directorio se pueden obtener usando el mtodo

Verificar si existe un archivo

Comparacin de dos archivos

raiz= [NSFileManager defaultManager];

Verificando los permisos del archivo

Mover o renombrar un archivo

Crear un link simblico

Leer y escribir archivos con NSFileManager

databuffer = [raiz contentsAtPath: @"/tmp/archivo.txt" ];

Proceso de desplazamiento (Offsets) y bsqueda (Seeking)

Leer datos en un archivo

La informacin leda es enc apsulada dentro de un objeto NS Data:

archivo = [NSFileHandle fileHandleForUpdatingAtPath:

[archivo seekToFileOffset: 10];

Abra con un editor el archivo para ver el cambio.

La base de datos completa se encuentra en un solo archivo.

Soporta texto en formato UTF-8 y UTF-16, as como datos numricos de 64 bits.

Windows 95, 98, ME, 2000, XP y Vista

Prepara y Ejecutar sentencias SQL

Con esto terminan nuestras operaciones con el gestor de base de datos.

Extraer informacin de una BD.

NSFileManager *fileMgr = [NSFileManager defaultManager];

Tambin seleccionamos la celda del TableViewController y le ponemos como identificador el

IBOutlet UILabel *etqNombre;

[txtRuedas setText:[NSString stringWithFormat:@"%d",

A continuacin vamos a crear una nueva clase en nuestro proyecto y la llamaremos

IBOutlet UILabel *etqNombre;

Hacemos los enlaces correspondientes en el storyboard, acordndonos de asociar todos los

Multitouch, Tap, y Gestos

Gestos, Taps y Touches

Un reconocedor de gesto (gesture) es en realidad un objeto de la clase abstracta

Crear una aplicacin con Gestos.

Vamos a comenzar por la creacin de un nuevo proyecto en Xcode. Seleccionaremos una

A continuacin, estableceremos como nombre GesturesDemo como al proyecto, y asegurarnos de

Frame : X=20, Y=40, Width=280, Height=40

Detectar Gestos dentro de la pantalla

Frame : X=110, Y=234, Width=100, Height=100

Como se menciono en la introduccin, el objeto reconocedor de gestos hace pasar al mtodo de

Comprobamos si el ancho inicial de la vista es igual a 100,0 puntos, y si es as lo hacemos 200.0, si

UITapGestureRecognizer *doubleTapGestureRecognizer = [[UITapGestureRecogn

En su definicin, vamos a cambiar la anchura y la altura de la vista al duplicar su tamao. Vamos a

Swipe Gesture Recognizer

Frame : X=0, Y=234, Width=320, Height=100

Background Color: R=215, G=116, B=52

Frame: X=320, Y=234, Width=320, Height=100

Background Color: Black Color

Frame: X=-320, Y=234, Width=320, Height=100

Background Color: R=0, G=128, B=0

A continuacin, cree las siguientes propiedades IBOutlet al archivo SwipeViewController.h:

@interface SwipeViewController : UIViewController

// Do any additional setup after loading the view.