You are on page 1of 37

01 iOS

Introducción a iOS
iOS 01

Índice

OBJETIVOS ........................................................................................................ 3
INTRODUCCIÓN ................................................................................................. 4
1.1. Introducción a Objective-C ....................................................................... 5
1.1.1. Comentarios ........................................................................................ 5
1.1.2. Estructura ............................................................................................ 6
1.1.3. Instanciación de objetos ...................................................................... 7
1.1.4. Mensajes a objetos .............................................................................. 7
1.1.5. Interfaz e implementación .................................................................... 8
1.1.6. Importación de código........................................................................ 12
1.1.7. Clases más usadas ........................................................................... 12
1.1.8. Protocolos y categorías ..................................................................... 13
1.2. Introducción a iOS ................................................................................... 15
1.2.1. Cocoa touch ...................................................................................... 15
1.2.2. Media ................................................................................................. 16
1.2.3. Core services ..................................................................................... 17
1.2.4. Core OS............................................................................................. 18
1.3. Introducción a Xcode .............................................................................. 19
1.3.1. Navegador de archivos del Proyecto ................................................. 24
1.3.2. Editor de código principal ................................................................... 25
1.3.3. Visor de utilidades ............................................................................. 27
1.3.4. Menú principal ................................................................................... 29
1.3.5. Estructuración de un proyecto ........................................................... 30
RESUMEN......................................................................................................... 35

Introducción al IOS 1
iOS 01

Objetivos

Dar una definición del sistema operativo iOS.

Comprender la arquitectura de iOS y las capas que la componen.

Descubrir la historia del lenguaje de programación Objective-C.

Familiarizarse a la sintaxis de Objective-C.

Conocer cómo se instanciar objetos en Objective-C y cómo invocar sus


métodos.

Entender como están compuestas las clases en Objective-C.

Saber declarar en Objective-C los distintos tipos de variables y métodos, e


importar código nuestro o de terceros.

Conocer las clases más usadas en Objective-C y la creación de protocolos y


categorías.

Crear, paso a paso, un proyecto iOS desde cero en Xcode.

Comprender la interfaz y funcionalidades de Xcode

Introducción al IOS 3
Formación Abierta

Introducción

Esta es la primera unidad del libro, dónde se tratará de introducir las partes más
importantes del desarrollo de aplicaciones para iOS.

Daremos una introducción a iOS, qué es y por qué está compuesto. Conoceremos
el lenguaje Objective-C que se usa para desarrollar aplicaciones en iOS, explicando
las facetas más básicas del mismo para comprenderlo bien. Por ultimo realizaremos
los primeros pasos en el IDE (entorno de desarrollo) Xcode, para crear una
aplicación desde cero.

4 Introducción al IOS
iOS 01

1.1. Introducción a Objective-C


Objective-C es el lenguaje de programación utilizado para la creación de
aplicaciones en el sistema operativo iOS (iPhone - iPad) y Mac OS X (SO de
escritorio de los ordenadores de Apple).

Es un lenguaje de programación orientado a objetos creado por Brad Cox y Tom


Love en la primeros años de los 80 al pretender añadir la funcionalidad del lenguaje
Smalltalk al conocido C. La participación de este lenguaje en el mundo de Apple
comienza cuando NeXT, la empresa creada por Steve Jobs, lo utiliza para la
creación de su sistema operativo NeXTSTEP. Objective-C fue liberado bajo licencia
GPL en 1992.

Se trata de un superconjunto de C, por lo que cualquier código escrito en C o C++


funcionaría integrado con código Objective-C., pero su sintaxis es diferente. Para
entender dicha sintaxis no hay mejor forma que explicar, mediante pseudocódigo, la
forma de programar en este lenguaje.

1.1.1. Comentarios
Debido a que se van a utilizar a lo largo de este tema, se comienza indicando la
forma de escribir comentarios entre el código Objective-C.

Se puede añadir comentarios de dos formas distintas:


 Mediante //
 Encapsulando todo el comentario entre /* y */

// Esto es un comentario
/* Esto también es un comentario */

Introducción al IOS 5
Formación Abierta

1.1.2. Estructura
Tanto en la programación para Mac OS X como en la programación para iOS, las
aplicaciones comienzan en una función main:

#import <Foundation/Foundation.h>
#import “miLibreria.h”

int main(int argc, const char * argv[])


{
@autoreleasepool {
NSLog(@"Hola, Mundo");
}
return 0;
}

Los ficheros importados mediante < y > se refieren a aquellos que pertenecen a
librerías del sistema, normalmente del núcleo / core del sistema operativo o de sus
APIs.

En cuanto a aquellos que se encuentran entre comillas, suelen ser ficheros creados
por uno mismo o por terceros.

Las instrucciones que comienzan con el símbolo @ son directivas de Objective-C.


En este caso @autoreleasepool se refiere a una instrucción de gestión de memoria.

Objective-C es un lenguaje case sensitive, es decir, es sensible a mayúsculas y


minúsculas. Esto quiere decir que por ejemplo, las variables miVariable y mivariable
son consideradas distintas.

NSLog es la instrucción que permite escribir en la consola y es muy útil para temas
de depuración.

6 Introducción al IOS
iOS 01

1.1.3. Instanciación de objetos


Cuando se desea instanciar una clase debe ser alojada en memoria de forma
previa:

MiClase *referenciaAObjeto = [[MiClase alloc] init];

El método alloc reserva la memoria necesaria para el objeto (y sus variables)


siendo el método init aquel que instancia el objeto y que puede ser sobrescrito o
modificado por uno propio:

- (id) init {
self = [super init];
if (self) {
variableInstancia1 = valor1;
variableInstancia2 = valor2;
.
.
.
}
return self;
}

En otros lenguajes orientados a objetos como Java la instanciación, a diferencia


que aquí, se realizaría de este modo:

MiClase objecto = new MiClase();

Haciendo una comparación mayor, el método alloc coincidiría con el new de Java
(es un método de clase) y el método init coincidiría con el constructor (método de
instancia).

En Objective-C no se utilizan objetos directamente, sino referencias a objetos, ya


que los mismos se crean en memoria dinámica. Es decir, se utilizará MiClase
*referenciaAObjeto y no MiClase objeto.

1.1.4. Mensajes a objetos


Como lenguaje de programación orientado a objetos, se utiliza el envío de
mensajes a los objetos ya instanciados. Este envío se realiza mediante la
invocación a los métodos de dicho objeto:

[referenciaAObjeto metodo:parametro];

Introducción al IOS 7
Formación Abierta

Como puede verse, el envío de mensajes se realiza encapsulando la llamada entre


corchetes “[“ y “]”, quedando en la parte izquierda el objeto al que se invoca y en la
derecha el método y sus parámetros.

En Objective-C suelen utilizarse distintos nombres de métodos cuando se quiere


tener una misma funcionalidad con distinto número de parámetros:

[objeto metodoConEsteParametro:parametro];
[objeto metodoConEsteParametro:parametro
yEsteOtro:otroParametro];

Los métodos en Objective-C están formados por dos elementos:

- El nombre en sí del método. Especifica normalmente la acción (en este


ejemplo sería: “metodoConEsteParametro”).

- Las etiquetas. Son parte del método y sirven para sobrecargar métodos, es
decir, para que un mismo nombre de método pueda usarse con distintos
parámetros (en este ejemplo sería “yEsteOtro”).

Tanto el nombre del método como los “:” son obligatorios siempre. En cambio las
etiquetas son opcionales, pero se recomienda su uso porque facilita el
entendimiento.

En Java esta invocación sería de la siguiente forma:

objeto.metodo(parametro);
objeto.metodo(parametro, otroParametro);

1.1.5. Interfaz e implementación


En Objective-C las clases se dividen en dos archivos:

 Interfaz (extensión .h): define las variables y métodos de la clase y sus


objetos:
@interface NombreDeLaClase : SuperClase
{
// variables de instancia
}
+metodoDeClase;
+(tipoRetorno)metodoDeClase2:(tipoParametro1)parametro1;
-
(tipoRetorno)metodoDeInstancia:(tipoParametro1)parametro1
:(tipoParametro2)parametro2;

@end

La SuperClase es la clase de la que hereda la clase NombreDeLaClase que


aquí se muestra. Todas las clases heredan al final de la clase abstracta
NSObject.

8 Introducción al IOS
iOS 01

Cuando los métodos van precedido del signo “+” significa que son métodos
de clase. En cambio, cuando van con un signo “-“ es porque se trata de un
método de instancia. En otros lenguajes como Java, los métodos de clase
son aquellos con el identificador static.

Introducción al IOS 9
Formación Abierta

El tipoRetorno puede ser:


 Cualquier tipo estándar de C (int, double, float, char, BOOL, etc.)
 Un puntero a objeto (NSString *, MiClase *, …)

Las variables de instancia o ivars pueden tener modificadores de acceso:


 @public
 @protected (por defecto)
 @private

No es necesario añadir el modificador a cada variable, sino que se aplica a


todas las variables que le siguen hasta que aparezca otro modificador:

@public
tipo1 variablePublica1
tipo2 variablePublica2
@private
tipo3 variablePrivada

Los métodos, en cambio, son públicos o privados según donde aparezcan:


 Métodos públicos: deben estar definidos en la interfaz (.h) e
implementados en el fichero .m
 Métodos privados: sólo aparecen en el fichero .m

Algunos ejemplos de declaración de métodos pueden ser:

- (void) guardarNombre:(NSString *)nombre;


+ (NSString*) saludame;

Además, en el fichero de interfaz pueden utilizarse propiedades que


permiten añadir getters y setters para los atributos:

@property (nonatomic, strong) NSString *variable;


@property (nonatomic, strong) MiClase *variable2;

Estas propiedades pueden tener atributos:


 readwrite (por defecto): se les puede asignar valores fuera de la clase.
 readonly: sólo se les puede asignar valor a través de su variable de
instancia
 atomic (por defecto): permite asignar u obtener su valor de forma
atómica, sin ser afectado por hilos que acceden a la variable de forma
simultánea.
 nonatomic: no asegura lo anterior.
 strong: indica que el valor debe ser mantenido

10 Introducción al IOS
iOS 01

 assign: utilizado para tipos básicos como int, float, etc.


 copy: cuando en las asignaciones debe realizarse una copia
 Implementación (extensión .m): incluye el código de los métodos
nombrados en el archivo de cabecera (interfaz):
@implementation NombreDeLaClase
+metodoDeClase {
// Implementación del método
}
+(tipoRetorno)metodoDeClase2:(tipoParametro1)parame
tro1 {
// implementation con retorno
return unValor;
}
-
(tipoRetorno)metodoDeInstancia:(tipoParametro1)parametro
1 :(tipoParametro2)parametro2 {
// implementación con retorno
return unValor;
}

@end

Un método siempre debe devolver algún tipo de valor. El tipo de retorno por
defecto es el tipo genérico “id”, una especie de tipado dinámico de
Objective-C. Si no se desea que se devuelva el mismo es necesario indicar
un retorno “void”.

Continuando con los ejemplos de la interfaz:

- (void) guardarNombre:(NSString *)nombre {


nombreGuardado = nombre;
}
+ (NSString*) saludame {
return [NSString stringWithFormat:@“Hola
%@”,nombreGuardado];
}

Con la creación de propiedades creada en la interfaz, se podría acceder a


las variables con el símbolo _ delante. En el ejemplo, mediante _variable y
_variable2.

Si se desea hacer lo mismo pero sin necesidad de utilizar el guión es


necesario sintetizar la propiedad de la siguiente forma:

@synthesize variable, variable2

Este procedimiento permite acceder directamente a una variable sin necesidad de


utilizar métodos getters y setters (para devolver y modificar su valor
respectivamente).

Introducción al IOS 11
Formación Abierta

A partir de iOS 6 existe una auto-sintetización por lo que ya sólo sería falta en el
caso de que se trate de un protocolo. La forma de acceder sería a través del
nombre de la variable precedido de un guión bajo “_”.

1.1.6. Importación de código


Muchas veces es necesario utilizar clases o librerías externas. Para ello existen las
directivas #include e #import, que se usan al comienzo de los ficheros y que
prácticamente hacen lo mismo, pero se recomienda el uso de esta última ya que
evita que un mismo fichero se incluya más de una vez.

1.1.7. Clases más usadas


A continuación se van a enumerar algunas de las clases propias de Objective-C
más utilizadas:

 NSString: cadena de texto.


NSString *cadena = @“Esto es una cadena de texto”;

 NSMutableString: cadena de texto que se puede modificar.


NSMutableString *cadena = [NSMutableString
stringWithFormat:@"Hola "];
[cadena appendString:@“mundo"];

 NSNumber: números como clase (a diferencia de los tipos primitivos int,


double, etc.)
NSNumber *numeroEntero = [NSNumber numberWithInt:10];
NSNumber *numeroConDecimal = [NSNumber
numberWithFloat:10.2f];

 NSArray: array de elementos:


NSArray *array = [[NSArray alloc] objeto1, objeto2,
objeto3, nil];
MiClase *objeto = [array objectAtIndex:2];

 NSMutableArray: array modificable de elementos:


NSMutableArray *array = [[NSMutableArray alloc]
initWithObjects:objeto1, objeto2, nil];
[array addObject:objeto3];

12 Introducción al IOS
iOS 01

 NSDictionary: colección de elementos clave-valor:


NSDictionary *diccionario = @{
@"clave 1": valor1,
@"clave 2": valor2,
@"clave 3": valor3
@"clave 4": valor4
};
MiClase *objeto = [diccionario objectForKey:@“clave 3”];

 NSMutableDictionary: diccionarios modificables


NSMutableDictionary *diccionario =
[[NSMutableDictionary alloc]
initWithDictionary:otroDiccionario];
[diccionario setValue:valor5 forKey:@"clave 2"];

1.1.8. Protocolos y categorías


Los protocolos son las interfaces de Objective-C. Permiten declarar métodos y
propiedades que luego serán implementadas y sintetizadas en las clases que
“implementen” dicho protocolo.

Por ejemplo, si tenemos el siguiente protocolo:

@protocol MiProtocolo <NSObject>

@property (nonatomic, assign) tipo1 miVariable;

- (void)metodoDeProtocolo;
- (int)metodoDeProtocolo2;

@end

La clase que implemente el protocolo debe ser del siguiente modo:

#import “MiProtocolo.h"

@interface MiClase : NSObject <MiProtocolo>

@synthesize miVariable // Sintetizamos la variable

- (void)metodoDeProtocolo {
// Aquí se implementaría el código de este
método
}
- (int)metodoDeProtocolo2 {
// Aquí se implementaría el código de este
método
return 0;
}

Introducción al IOS 13
Formación Abierta

Como puede observarse, es necesario importar la interfaz del protocolo e indicar


que la clase MiClase implementa MiProtocolo añadiéndolo entre < y >.

Las categorías permiten añadir métodos a una clase sin necesidad de extender de
ella:

 Interfaz de categoría (Clase+Categoria.h):


#import “Clase.h”

@interface Clase (Categoria)

-(void) nuevoMetodo;

@end

 Implementación de categoría (Clase+Categoria.m):


#import “Clase+Categoria.h”

@implementation Clase (Categoria)

- (void) nuevoMetodo {
// Implementación
}

@end

14 Introducción al IOS
iOS 01

1.2. Introducción a iOS


iOS es el sistema operativo de los dispositivos iPhone, iPad y iPod. Dicho sistema
se deriva de Mac OS X, que a su vez está basado en Darwin BSD, y por lo tanto es
un sistema operativo tipo Unix.

El sistema operativo iOS maneja el hardware y lo provee de la tecnología necesaria


para desarrollar aplicaciones en su ecosistema. El sistema operativo también posee
varias aplicaciones como pueden ser el calendario, el marcador de teléfono, la app
de mensajes, etc. Todas proveen al usuario de diferentes servicios.

La arquitectura de iOS está basada en capas. El sistema operativo proporciona a


las distintas aplicaciones, tanto aquellas del sistema como las que desarrollemos,
las interfaces necesarias para hablar con el hardware del dispositivo, evitando que
nosotros tengamos que comunicarnos con el hardware directamente, logrando que
no construyamos aplicaciones específicas para cada dispositivo y abstrayendo al
programador de dichas dificultades.

La arquitectura se divide en las siguientes capas:

 Cocoa touch.
 Media.
 Core services.
 Core OS.

Estas capas están ordenadas por el nivel más alto de abstracción del hardware.
Ahora las analizaremos una a una.

1.2.1. Cocoa touch


La capa Cocoa touch posee los frameworks necesarios para construir aplicaciones
en el sistema iOS. Estos frameworks serán los que nos proporcionan variados
servicios como: multitarea, personalización del aspecto de la aplicación, métodos
de entrada de escritura, recepción de notificaciones remotas, obtención de los
contactos de la agenda del sistema, etc. Dicho de otro modo, son las tecnologías
que necesitamos conocer cuando estamos construyendo una aplicación.

Algunas funcionalidades importantes de esta capa son:

 AirDrop.
 TextKit.
 UIDinaymics.

Introducción al IOS 15
Formación Abierta

 Multitasking.
 Notificaciones Locales/Remotas.
 Reconocedores de gestos.
 Storyboards.
 ViewControllers del sistema.
Los principales frameworks de esta capa son :
 AddressBookUI
 EventKitUI
 GameKit
 MapKit
 MessageUI
 Twitter
 UIKit

1.2.2. Media
En esta capa tenemos las tecnologías de video, imagen y audio para poder
desarrollar aplicaciones multimedia, poder reproducir vídeo tanto en streaming
como desde un fichero, grabar y reproducir sonidos, aplicar filtros a una imagen,
embellecer nuestra UI con animaciones o crear juegos en 3d con OpenGL.

 Tecnologías de gráficos:
 Core image.
 Core animation.
 OpenGL.
 Tecnologías de video:
 AvFoundation.
 CoreMedia.
 Media player.
 Tecnologías de sonido:
 Avfoundation.
 Coreaudio.
 OpenAL.

16 Introducción al IOS
iOS 01

1.2.3. Core services


La capa de Core Services posee los servicios y funcionalidades necesarias que
usan las aplicaciones. Estos servicios se encuentran englobados en los frameworks
CoreFoundation y Foundation, los cuales definen los tipos de datos básicos que
toda aplicación utiliza. Esta capa también posee el soporte para otras tecnologías
como localización a través de Core Location/MapKit, acceso a los servicios de
iCloud, los API del sistema para interactuar con las redes sociales, frameworks que
nos proporcionan conexión a Internet, se encarga del almacenamiento persistente
de datos a través de iCloud, etc.

Algunas funcionalidades importantes de esta capa son:

 Peer-to-peer.
 Sqlite.
 XML.
 iCloud storage.
 Arc.
 File sharing.

Los principales frameworks que construyen esta capa son:

 Address.framework.
 CFNetwork.framework.
 CoreLocation.
 CoreFoundation.
 CoreMedia.
 Foundation.
 CoreData.
 JavaScript.
 CoreTelephony.

Introducción al IOS 17
Formación Abierta

1.2.4. Core OS
La capa de Core OS contiene las funcionalidades de bajo nivel sobre las que están
construidas las demás tecnologías. Es muy posible que no se usen de forma directa
en la aplicación, pero los frameworks que se incluyen las usarán. La utilización del
Core OS está supeditada a situaciones que hay que pelear con la seguridad,
comunicarse con un accesorio externo de hardware, usar frameworks con
operaciones matemáticas complejas (álgebra lineal, procesado complejo de
imágenes) o si necesitas usar las interfaces de UNIX que proveen funcionalidades a
bajo nivel (BSD sockets, POSIX threads), en esos casos usarás los frameworks de
esta capa.

 Accelerate.framework.
 CoreBluetooth.framework.
 Security.framework.
 ExternalAccesory.framework.
 System (no esta englobado como un framework, los headers se encuentran
en la siguiente ruta /usr/include)

18 Introducción al IOS
iOS 01

1.3. Introducción a Xcode


Xcode es el entorno de desarrollo (IDE) oficial para el desarrollo de aplicaciones
iOS. Es necesario tenerlo instalado, no sólo para desarrollar, ya que integra otras
características para el desarrollo cómo puede ser el gcc. Aunque Xcode es el IDE
oficial, existe otro que tiene buena aceptación por la comunidad, appCode, aunque
tiene una pega: es necesario tener el Xcode instalado.

Centrándonos en Xcode, vamos a contar un poco dónde lo podemos obtener y


cómo usar sus características más básicas.

El IDE es gratuito y se puede descargar tanto del AppStore como del programa de
desarrolladores de Apple. Una vez descargado, procederemos a hacer doble click
en la aplicación o a descomprimir y arrastrar a las aplicaciones (según donde lo
hayamos bajado).

Cuando lo abramos nos aparecerá la siguiente ventana (Figura 1.1):

Figura 1.1. Introducción al Scode.

Introducción al IOS 19
Formación Abierta

Esta es la ventana de bienvenida. En la parte de la derecha nos muestra los


proyectos que hemos abierto recientemente y en el texto de la izquierda nos ofrece
varias opciones: crear un proyecto o conectar con un repositorio de código para
bajarnos de ahí el proyecto.

Como no tenemos ningún proyecto es hora de crear uno pulsando en Crear nuevo
proyecto, nos aparecerá la siguiente ventana (Figura 1.2).

Figura 1.2. Ventana para crear un nuevo proyecto.

Aquí seleccionaremos en la parte izquierda la plataforma en la que queremos


desarrollar, si para iOS o para Mac OS X. Elegiremos aplicación para iOS,
apareciéndonos a la derecha las plantillas de los proyectos en blanco que podemos
seleccionar:

Master-Detail Application

 Esta es una plantilla para aplicaciones de iPad donde nos configura una
aplicación con 2 controladores en la misma vista una tabla a la izquierda y
una vista vacía en la derecha.

OpenGL Game

 Plantilla para empezar a crear un juego OpenGL.

Page-based Application

 Plantilla para aplicaciones basadas en controladores PageView.

20 Introducción al IOS
iOS 01

Single View Application

 Plantilla de una aplicación con una única vista.

Tabbed application

 Plantilla de una aplicación con un menú de pestañas en la parte inferior.

Utility Application

 Plantilla de una aplicación con una vista principal y una vista alternativa.

Empty Application

 Plantilla de aplicación vacía. Sirve para empezar cualquier tipo de


aplicación.

SpriteKit Game

 A partir de iOS7 aparece esta nueva plantilla que nos facilita un punto de
comienzo para crear un juego con el framework SpriteKit.

Para explicar este tema, seleccionaremos Single View Application que nos creará
una aplicación nueva con un controlador de inicio. A continuación (Figura 1.3) nos
aparecerá la pantalla para dar el nombre al proyecto y algunas opciones más:

Figura 1.3. Pantalla para dar nombre al proyecto y otras opciones.

Introducción al IOS 21
Formación Abierta

En esta pantalla introduciremos los siguientes datos, por orden:

El nombre al nuestra aplicación.

El nombre de la organización o empresa.

El identificador de la organización o compañía (normalmente será la dirección


de la página web de la compañía a la inversa: seas.es —> es.seas)

Podremos también especificar un prefijo que se añada al nombre de nuestras


clases

Los dispositivos en los que queremos que funcione nuestra aplicación, iPhone,
iPad o ambos (Universal).

Si vamos a usar Core Data (más adelante veremos que es exáctamente).

Los datos introducidos en este punto se pueden cambiar más adelante. Todas las
aplicaciones iOS tienen un identificador único (BundleID o Bundle Identifier)
compuesto por el identificador de la compañía y el nombre de la aplicación. Este
identificador único debe ser único en la AppStore y será necesario validarlo antes
de una publicación en la misma. Si ya existiera, habría que cambiarlo.

En versiones anteriores a la 5 de Xcode existen 2


opciones más:

 Automatic Reference Counting


 Use storyboards

Estas propiedades en las últimas versiones de Xcode


son marcadas por defecto de forma interna, pero en
versiones anteriores debe hacerse de forma manual,
siendo recomendable marcarlas ya que aportan
funcionalidades importantes que explicaremos en los
siguientes temas.

Una vez completados los datos nos aparecerá la pantalla para seleccionar la
ubicación de nuestro proyecto. Aparecerá también un check que nos permite crear
un repositorio de código en nuestro ordenador de manera local (como no es algo
obligatorio podremos seleccionarlo o no según nos convenga). Una vez lleguemos
al directorio donde queremos guardar el proyecto pulsaremos en guardar.

Dentro del directorio nos creará una carpeta con el nombre de nuestra aplicación, la
cual contiene los ficheros de configuración y el código inicial del proyecto.

22 Introducción al IOS
iOS 01

Los ficheros para abrir de manera correcta un proyecto


en Xcode, son aquellos con extensión .xcodeproj. Nunca
deberemos modificarlos de manera manual.

Ahora nos aparecerá la ventana principal de nuestro proyecto (Figura 1.4):

Figura 1.4. Ventana principal del proyecto.

Vamos a explicar por partes la interfaz que nos muestra este IDE. En la parte
izquierda tenemos una vista de los archivos que tiene nuestro proyecto. En la parte
central será donde editaremos los archivos de código, los de propiedades (como
este que nos muestra al crear el proyecto) y donde diseñaremos las ventanas. Por
último, en la parte derecha podremos ver las propiedades de los archivos que
estemos editando.

Introducción al IOS 23
Formación Abierta

1.3.1. Navegador de archivos del Proyecto

Figura 1.5. Navegador de archivos del Proyecto.

Como hemos dicho anteriormente, este navegador (Figura 1.5) de proyecto nos
muestra todos los archivos que lo componen, además de permitirnos crear/añadir
archivos en la zona de la jerarquía que queramos (pulsando el botón derecho del
ratón, arrastrar archivos como imágenes, sonidos, archivos de código fuente, etc.).
En la parte superior tenemos unas pestañas que nos permiten navegar en esta
ventana ofreciendo distintas funcionalidades:

 Ver la jerarquía de clases que componen el proyecto.

 Buscar un archivo concreto.

 Buscar un texto en los ficheros.

 Ver los warnings y errores de compilación.

 Ver el estado de los test de nuestra aplicación.

 Ir a los breakpoints (puntos de ruptura de debug) marcados en el código.

 Ver el rastreo de pila de la ejecución de nuestra aplicación.

24 Introducción al IOS
iOS 01

1.3.2. Editor de código principal


En la parte central tendremos, por así decirlo, el editor de código que nos permite
editar los ficheros de código, propiedades, interfaces gráficas y vista previa de
imágenes.

Cuando estamos editando código, la parte central (Figura 1.6) quedaría así:

Figura 1.6. Editor de código.

Introducción al IOS 25
Formación Abierta

Si nos fijamos sobre el código fuente, en la parte superior, tenemos la jerarquía de


carpetas que hay hasta el archivo que estamos editando, con lo cual podremos
cambiar rápidamente de archivo.

Para diseñar la interfaz grafica tenemos varias opciones (que explicaremos en


profundidad mas adelante):

 XIB: son archivos de estilo “drag&drop” que nos permiten crear la interfaz
grafica de manera visual de una pantalla o vista.
 Storyboard: es un archivo que nos permite crear/editar de manera grafica la
interfaz de usuario y definir el flujo de la aplicación.Es la evolución de los
XIB

Cuando estemos diseñando la interfaz gráfica mediante los Storyboard o archivos


XIB, quedaría de la siguiente manera (Figura 1.7):

Figura 1.7. Diseño de la interfaz gráfica mediante los Storyboard o archivos XIB.

26 Introducción al IOS
iOS 01

La parte central se nos ha divido en los 2 partes, una parte más grande a la
derecha donde tenemos una vista y podemos añadir elementos a las vistas. Otra
parte más pequeña a la izquierda donde podemos ver la jerarquía de elementos
que componen el controlador seleccionado.

1.3.3. Visor de utilidades


El visor de utilidades (Figura 1.8) nos permite ver las propiedades configurables de
los archivos y elementos seleccionados en cada momento, y que aparecen en la
parte central de la ventana. Estas propiedades varían según sea el archivo o la
parte de la vista que tengamos seleccionada en ese momento.

En el siguiente ejemplo se pueden ver las propiedades que tiene una clase UIView.
Podemos configurar la transparencia de la vista (alpha), el color de fondo que esta
tiene (background) y muchas propiedades más.

Introducción al IOS 27
Formación Abierta

Figura 1.8. Visor de utilidades.

En este visor también existen unas pestañas en la parte superior que permiten
cambiar distintos tipos de propiedades. Para el ejemplo del UIView se pueden ver
las siguientes:

 Un inspector del fichero el cual nos da información del fichero como su ruta,
el tipo de fichero que es y si está bajo un control de versiones de código.

 Una parte de ayuda donde nos ofrece ayuda sobre el elemento


seleccionado. En este caso nos daría la documentación de la clase UIView.

28 Introducción al IOS
iOS 01

 Una parte donde podemos especificar la identidad de la clase. Si creáramos


una clase para realizar determinadas funciones que heredase de UIView,
deberíamos indicarlo ahí. Aquí especificaremos también los atributos de
accesibilidad.

 El inspector de atributos donde podremos dar valores a los atributos del


elemento seleccionado, sería lo que vemos en la imagen superior

 El inspector de tamaño donde tendremos las medidas y posición de nuestro


elemento y algunas propiedades más del AutoLayout (que explicaremos
más adelante)

 El inspector de conexiones, donde veríamos las conexiones que tiene


nuestra vista con el código de nuestra aplicación.

1.3.4. Menú principal

Figura 1.9. Menú Scode.

En el menú superior de Xcode (Figura 1.9) es desde donde haremos algunas de las
operaciones más importantes, como por ejemplo ejecutar nuestra aplicación,
pararla o ver la interfaz del IDE de otra forma.

Figura 1.10. Imagen detalle de “play” y “stop”.

Como vemos en esta imagen (Figura 1.10) tenemos los botones de “Play” y “Stop” .
Si pulsamos sobre el primero, nos compilaría la aplicación, ejecutándose después
en el destino que seleccionemos más a la derecha (en este caso simulador iPhone
Retina 3.5-inch). Si pulsamos sobre el nombre de aplicación podríamos indicar la
forma en la que la aplicación va a compilarse (lo que se conoce como schemes). Si
hacemos lo mismo en los iconos de dispositivo podríamos seleccionar el destino de
instalación de la aplicación, entre los distintos simuladores instalados en Xcode o
en un dispositivo conectado al ordenador en el que se esté programando.

Si mantenemos pulsado el botón de “Play" nos aparecerán una serie de opciones


para ejecutar nuestra aplicación como son el “Profiling” (para medir el rendimiento),
ejecución de test o análisis del código.

Figura 1.11. Panel de mensajes.

Introducción al IOS 29
Formación Abierta

En la parte superior central del Xcode (Figura 1.11) nos aparecerán mensajes
informativos del estado de las acciones en proceso. Por ejemplo, al ejecutar la
aplicación, nos irán apareciendo mensajes de la compilación, los errores, cuando
ha terminado, etc.

Figura 1.12. Selección de ventana.

En esta parte superior derecha (Figura 1.12) podremos configurar como deseamos
ver el editor principal o las partes de la interfaz que queremos ver en cada
momento.

En la primera parte tenemos tres botones que realizan las siguientes acciones:

 Si pulsamos el botón del asistente de código (el botón con forma de traje)
nos dividirá el editor de código principal en 2 editores para poder modificar 2
archivos a la vez.

 Si pulsamos el editor de versiones (el botón con forma de río) nos mostrará
las distintas versiones del archivo (esto estará disponible si el archivo tiene
configurado un repositorio de código).

 Si pulsamos el que esta azul en la imagen veremos el editor principal de


nuevo.

Después de la línea separadora tenemos otros tres botones que realizan las
siguientes acciones:

 Mostrar/Ocultar el navegador de archivos del proyecto.

 Mostrar/Ocultar la zona de debug.

 Mostrar/Ocultar el visor de utilidades.

1.3.5. Estructuración de un proyecto


Cuando estamos creando nuestro proyecto es aconsejable seguir el patrón de
diseño MVC (Modelo Vista Controlador). Dicho patrón nos dice que tenemos que
separar en distintas capas las diferentes clases y archivos que componen nuestro
proyecto. Para aplicar dicho patron en iOS consideraremos la parte del modelo y los
controladores son clases (archivos .h y .m), en cambio la parte de las vistas serán
los archivos XIB y lo relacionado con ellos (clases inclusive).

30 Introducción al IOS
iOS 01

Para ayudarnos a separar estos archivos lo que vamos a hacer es crear carpetas,
pulsaremos el botón derecho sobre la carpeta raíz y seleccionaremos “New Group”
(Figura 1.13):

Figura 1.13. Menú de opciones para crear una carpeta.

Introducción al IOS 31
Formación Abierta

A continuación se nos creará de forma automática una carpeta llamada “New


Group” (Figura 1.14):

Figura 1.14. Creación de una carpeta.

Para añadir ficheros a las carpetas lo haremos arrastrando y soltando los ficheros
en la carpeta. Si necesitamos renombrar las carpetas con hacer un clic sobre el
nombre, se nos hará editable el nombre.

32 Introducción al IOS
iOS 01

Veamos como quedaría la estructura de un proyecto siguiendo el patrón MVC


(Figura 1.15):

Figura 1.15. Creación de una carpeta.

La clase AppDelegate se suele dejar a parte de las capas


para un acceso mas rápido, pero podría encasillarse en
la parte del modelo. Lo mismo ocurre con los archivos de
Stroyboard lo único que estos irían en la parte de la vista.

Introducción al IOS 33
iOS 01

Resumen

A lo largo de esta unidad unidad hemos dado las pautas fundamentales que hay
que tener en cuenta para entender los principios básicos a la hora de crear
aplicaciones en iOS. Se ha explicado los conceptos básicos y necesarios para
empezar a programar en Objective-C. También se ha ilustrado una introducción
a Xcode para poder crear una aplicación. En definitiva, al finalizar esta unidad,
hemos de ser capaces de:

 Entender que iOS es un sistema operativo basado en capas y conocer


básicamente el contenido de cada capa.
 Poder leer y escribir código simple en Objetive-C, ya que hemos visto que
las clases están compuestas por interfaz e implementación, la instanciación
de objetos, mandar mensajes a los objetos, la estructura de las clases y la
importación de código.
 Poder crear un proyecto nuevo en el IDE oficial de Apple Xcode y entender
la interfaz del IDE para poder desarrollar.

Introducción al IOS 35