NSArray, NSDictionary, NSString, NSNumber, NSData y otros

Hay dos métodos sencillos para almacenar un objeto en un archivo y poder recuperarlo cuando nos convenga. El primero no se puede aplicar a cualquier objeto, sino a objetos de algunas clases de Objective-C que responden a dos métodos llamados writeToFile:atomically: y writeToURL:atomically:. El uso de estos métodos es muy sencillo, basta con llamarlos en el momento en el que queramos que el objeto se guarde en un archivo.

A continuación teneís un ejemplo comentado. Básicamente creamos una matriz, le añadimos algo de contenido, la imprimimos, la guardamos en un archivo y nos deshacemos de ella. A continuación creamos otra matriz que lea el contenido del archivo y comprobamos que tiene el mismo contenido que la anterior. El resultado que obtendréis será similar al de la imagen de la derecha.

NSMutableArray *array = [[NSMutableArray alloc] init]; // Creamos una matriz
	[array addObject:@"¡Hola"]; // Añadimos un objeto
	[array addObject:@"mundo!"]; // Añadimos otro objeto
	NSLog(@"Matriz original: %@", array); // Imprimimos la matriz original
	[array writeToFile:@"filename" atomically:YES]; // Escribimos en el archivo filename el contenido de la matriz
	[array release]; // Liberamos memoria
	NSMutableArray *arrayFromFile = [[NSMutableArray alloc] initWithContentsOfFile:@"filename"]; // Esta matriz tiene el mismo contenido que tenía la matriz anterior
	NSLog(@"%@", arrayFromFile); // Imprimimos la matriz recuperada del archivo
	[arrayFromFile release]; // Liberamos memoria

Del mismo modo que se puede guardar en un archivo un objeto de la clase NSArray, también se puede usar con objetos NSDictionary, NSString, NSData y NSNumber, entre otros. Sin embargo no se puede usar con objetos de una clase creada por nosotros (en la mayoría de los casos).

Clases creadas por nosotros

Para guardar en un archivo un objeto de una clase creada por nosotros, tendremos que hacer que el objeto sigua el protocolo NSCoding. Tras esto, mediante las clases NSKeyedArchiver y NSKeyedUnarchiver podremos guardar en un archivo y leer de un archivo nuestro objeto. Este protocolo tiene dos métodos necesarios: initWithCoder: y encodeWithCoder:.

Vamos a suponer que hemos creado la clase Empleado, que tiene la siguiente interfaz:

@interface Empleado : NSObject
@property (nonatomic, retain)	NSString	*nombre, *apellidos;
@property						NSUInteger	edad;
@property						BOOL		esEmpleadoDelMes;
@end

Para poder almacenar este objeto en un archivo tendremos primero que hacer que siga el protocolo NSCoding. Modficaremos la interfaz y la dejaremos así:

#define kNombre				@"Nombre"
#define kApellidos			@"Apellidos"
#define kEdad				@"Edad"
#define kEsEmpleadoDelMes	@"esEmpleadoDelMes"
@interface Empleado : NSObject
@property (nonatomic, retain)	NSString	*nombre, *apellidos;
@property						NSUInteger	edad;
@property						BOOL		esEmpleadoDelMes;
@end

Básicamente hay dos cambios: hemos indicado que la clase sigue el protocolo NSCoding y hemos definido una serie de constantes que usaremos más adelante y que entenderéis en seguida su utilidad.

Ahora pasamos a la implementación. Esta es la implementación original de la clase Empleado, antes de seguir el protocolo NSCoding:

@implementation Empleado
@synthesize nombre, apellidos;
@synthesize edad;
@synthesize esEmpleadoDelMes;
- (void)dealloc
{
	[nombre release];
	[apellidos release];
	[super dealloc];
}
@end

Ahora vamos a añadir los dos métodos que necesitamos para seguir el protocolo NSCoding. Estos métodos nos permiten archivar nuestro objeto. El método encodeWithCoder: tiene por parámetro un objeto de la clase NSCoder. En este objeto archivaremos las propiedades del nuestro, asignándole a una serie de claves las propiedades del objeto.

Por ejemplo, si queremos hacer que la propiedad nombre se archive en la clave clave, el método tendría el siguiente aspecto:

- (void)encodeWithCoder:(NSCoder *)coder {
    [coder encodeObject:self.nombre forKey:@"clave"];
}

No todas las propiedades se archivan de la misma forma. Los objeto se archivan a través del método encodeObject:forKey:, los números enteros se archivan con encodeInteger:forKey: y los valores booleanos con encodeBool:forKey:. Las claves son muy importantes, ya que el método initWithCoder: va a desarchivar el objeto usando las mismas claves para acceder a las propiedades, por eso hemos definido una serie de constantes que serán las claves que usaremos para archivar y desarchivar las propiedades.

Nota: Tenéis una lista de todos los métodos para archivar objetos, así como una explicación del proceso de archivar y desarchivar objetos en la documentación de Apple (en inglés).

Nuestro método encodeWithCoder: quedará así:

- (void)encodeWithCoder:(NSCoder *)coder {
    [coder encodeObject:self.nombre forKey:kNombre];
	[coder encodeObject:self.apellidos forKey:kApellidos];
	[coder encodeInteger:self.edad forKey:kEdad];
	[coder encodeBool:self.esEmpleadoDelMes forKey:kEsEmpleadoDelMes];
}

El método initWithCoder: es muy similar al anterior, sólo que su funcionamiento es el contrario: a partir de un objeto archivado se obtienen las propiedades y se crea un objeto de la clase Empleado (en este caso) con las propiedades que tenía el objeto al archivarse. En este caso enviaremos el mensaje decodeObjectForKey:@”clave” a coder y asignaremos el valor devuelto a la propiedad de nuestro objeto. De nuevo, se usan métodos diferentes para decodificar número enteros, valores booleanos y otros tipos de variables. Nuestro método initWithCoder: quedará así:

- (id)initWithCoder:(NSCoder *)coder {
    if ((self = [super init])) {
		self.nombre = [coder decodeObjectForKey:kNombre];
		self.apellidos = [coder decodeObjectForKey:kApellidos];
		self.edad = [coder decodeIntForKey:kEdad];
		self.esEmpleadoDelMes = [coder decodeBoolForKey:kEsEmpleadoDelMes];
	}
    return self;
}

Ahora pasemos a crear un objeto Empleado, a guardarlo en un archivo y a comprobar que funciona correctamente. Primero incluímos la interfaz de la clase Empleado en el archivo en el que vamos a crear el objeto, en mi caso, y al tratarse de una “Command Line Tool“, lo incluiré en el archivo main.m. El siguiente código comentado crea un objeto de la clase Empleado, le asigna algunos valores sus propiedades, lo archiva y después crea un nuevo objeto con el contenido del archivo en el que se ha guardado antes el objeto:

Empleado *trabajador = [[Empleado alloc] init]; // Creamos el objeto
	trabajador.nombre = @"Juan"; // Le damos un nombre
	trabajador.apellidos = @"García López"; // Unos apellidos
	trabajador.edad = 26; // Una edad
	trabajador.esEmpleadoDelMes = YES; // Y lo hacemos empleado del mes
	NSLog(@"%@ %@ tiene %lu años", trabajador.nombre, trabajador.apellidos, trabajador.edad); // Imprimimos sus datos
	[NSKeyedArchiver archiveRootObject:trabajador toFile:@"empleado"]; // Lo guardamos en el archivo empleado
	[trabajador release]; // Liberamos memoria
	Empleado *trabajadorRecuperado = [NSKeyedUnarchiver unarchiveObjectWithFile:@"empleado"]; // Creamos un objeto a partir del archivo empleado
	NSLog(@"%@ %@ tiene %lu años", trabajadorRecuperado.nombre, trabajadorRecuperado.apellidos, trabajadorRecuperado.edad); // Imprimimos sus datos

Así se puede guardar un objeto de cualquier clase en un archivo, de forma que puede ser recuperado en cualquier momento. Los objetos más complejos pueden necesitar métodos más complejos a la hora de archivarlos. Del mismo modo no se tienen por qué archivar todas las propiedades si no se quiere.

Por último dejo a vuestra disposición los archivos del proyecto que he creado mientras escribía el tutorial, por si os atascáis y necesitáis un empujoncito.

Hay cerca de 800MB de archivos "borrados" en este pendrive

Hay veces que uno se sorprende al ver ciertos comportamientos de Mac OS X. Uno de los que menos me gustan es la forma de borrar archivos de un dispositivo extraíble (por ejemplo, un pendrive). En lugar de borrar el archivo, como sería de esperar, o moverlo a la papelera del Mac, lo almacena en una carpeta oculta dentro del propio pendrive que usa a modo de papelera. Si nos fijamos en la papelera de nuestro Mac, veremos que los archivos que hemos borrado del pendrive aparecen en ella, aunque no estén almacenados en el Mac.

El problema radica en que además de no borrar realmente los archivos y dejarlos en el pendrive (ocupando parte de su preciada capacidad), no hay forma de borrar los archivos individualmente de la papelera. Si usamos la combinación Función + Retroceso lo que hacemos es devolver el archivo eliminado a su carpeta de origen en lugar de borrarlo. Estamos pues obligados a vaciar la papelera y borrar definitivamente otros archivos que tal vez no queramos perder todavía.

Así que, algo mosqueado porque esto no haya cambiado ni en Snow Leopard ni en Lion (ni tiene pinta de que vaya a cambiar), he creado una simple aplicación en Automator para “limpiar” los pendrives de archivos supuestamente eliminados.

Cómo funciona

Esto lo aclara todo

Antes de dar los enlaces para descargar la aplicación, veamos cómo funciona. Como ya he dicho, Mac OS X mueve los archivos “borrados” a una carpeta oculta que funciona a modo de papelera. Esta carpeta se llama .Trashes (como de costumbre en OS X, al llevar un punto al principio del nombre, la carpeta es oculta). Si borramos la carpeta .Trashes, borramos todos los archivos que queríamos eliminar pero, ¿cómo la borramos sin pasar por la papelera de nuevo?

Aquí es donde entra en juego el potencial de un sistema basado en Unix. Gracias al comando rm (remove) podemos eliminar archivos o carpetas sin necesidad de pasar por la papelera. Combinando esto con un par de parámetros, concretamente -R (borrar de forma recursiva) -f (sin pedir confirmación) y -d (directorios y archivos) conseguimos vaciar el pendrive de archivos que queríamos borrar.

Obviamente tener que escribir todo esto en la terminal cada vez que queremos limpiar un pendrive de archivos “borrados” no es muy cómodo. Para hacer más cómoda la tarea recurriremos a Automator, ese pobre incomprendido que si bien es capaz de hacer maravillas, la mayoría de los usuarios desconoce incluso su existencia.

Para crear la aplicación abrimos Automator y elegimos crear una aplicación. A continuación arrastramos las acciones para formar el flujo que podéis ver en la imagen de la derecha. Básicamente el flujo es el siguiente:

1. Solicitamos una carpeta. El usuario deberá seleccionar un dispositivo extraíble.
2. Establecemos el valor de una variable con la ruta de la carpeta seleccionada.
3. Leemos el valor de esta variable y se lo pasamos a un script Shell como parámetro (este paso y el anterior supongo que se pueden omitir y usar el resultado del paso 1 como argumentos para el paso 4, pero por pereza no lo he comprobado – si alguien se anima que lo comente en los comentarios).
4. En el script Shell usamos el comando cd (change dir) para ir a la ruta del pendrive.
5. A continuación, en el mismo Shell y cambiada la ruta a la que nos interesa, borramos la carpeta .Trashes con los parámetros que he expuesto antes.

Descarga

Seguidos los pasos y entendido el funcionamiento, aquí tenéis a vuestra disposición la aplicación.

• Objeto: Los objetos son el pilar fundamental en la POO. Los objetos contienen variables, responden a métodos, tienen una dirección de memoria en la que están almacenados, pertenecen a una clase y pueden implementar protocolos.
• Clases: Un objeto pertecen a una clase, y sólo a una. Por el contrario varios objetos pueden pertenecer a la misma clase. En otros lenguajes de programación los objetos pueden heredar de varias clases, pero en Objective-C no. Cuando un objeto pertecene a una clase, el objeto contiene todas las variables de la clase, y responde a todos los métodos de instancia a los que responde la clase (veremos qué es esto más adelante). A su vez, una clase puede heredar de otra clase (de hecho lo más común es que las clases que creemos hereden de NSObject, al menos a nuestro nivel), cuando esto sucede, la nueva clase responde a todos los métodos a los que respondía la clase “padre” y los objetos de esta clase también tienen las variables de instancia de la clase “padre”.
• Variables de instancia: Los objetos, a pesar de ser por sí mismos variables, pueden contener a otras variables, que pueden ser variables simples como las de C (por ejemplo, números enteros o de coma flotantes) u objetos de cualquier clase. Las variables de instancia son diferentes en cada objeto, por lo que si tenemos dos objetos de la clase rueda y accedemos a la variable presiónDeLaRueda, cada uno devolverá un valor diferente de presión.
• Métodos de instancia: Los métodos de instancia son las funciones que puede ejecutar el objeto de una clase determinada. Cada clase define unos métodos de instancia diferente. Por ejemplo, la clase coche podría tener un método que fuese encenderMotor, al que se accedería desde un objeto determinado.
• Métodos de clase: Los métodos de clase son funciones a las que sólo se puede acceder desde la propia clase. Un método de clase típico es alloc, al que sólo se puede acceder desde una case, nunca desde un objeto.

Puede que no os hayan quedado claros del todo los conceptos con esta introducción, los explicaré mejor un poco más adelante.

Creando una nueva clase

Creando una nueva clase - Paso 2

En Objective-C las clases se definen mediante dos archivos: NOMBRECLASE.h y NOMBRECLASE.m. Los archivos .h contienen la interfaz de la clase y los archivos .m su implementación. La interfaz de la clase es una especie de índice: indica todas las varibles de instancia de la clase y todos los métodos a los que responde. La implementación es donde se desarrolla el código de las funciones. No es necesario dividir las clases en dos archivos, pero es altamente recomendable para hacer más claro el código.

Para añadir un nuevo archivo a nuestro proyecto basta con ir al menú File » New file… o pulsar Comando + N. En la ventana que nos aparecerá seleccionaremos Mac OS X » Cocoa Class » Objective-C Class (Subclass of NSObject). En  File Name introduciremos el nombre de nuestra nueva clase, en este caso Coche, acabado en .m. También marcaremos la casilla Also create “Coche.h”, para mantener más limpio el código.

En el archivo Coche.h encontraremos el siguiente código:

#import <Cocoa/Cocoa.h>
@interface Coche : NSObject {
}
@end

La primera línea ya la vimos en la primera parte de los tutoriales, e importa el Framework Cocoa. En la siguiente línea comienza la interfaz de la clase. Veamos su sintaxis:

• @interface: Inicia la interfaz
• Coche: El nombre de la clase que estamos definiendo
• : : Separado entre el nombre de la clase y la clase de la que hereda.
• NSObject: La clase de la que hereda nuestra clase.
• { : Abre el bloque donde se definen las variables de instancia.
• } : Cierra este bloque.
• @end: Indica el fin de la implementación.

Como podéis ver, las clases pueden ser “hijas” de otras clases, y es algo realmente común. De hecho es muy conveniente que nuestras clases sean hijas de al menos NSObject. La clase NSObject es la clase básica e incluye las funciones esenciales de gestión de memoria (la veremos más tarde), entre otras cosas.

Si nuestra clase es hija de una clase que es hija de NSObject, esta nueva clase también tendrá acceso a los métodos de la clase NSObject.

Ahora bien, imaginemos que queremos que queremos que nuestra clase tenga alguna variable de instancia, como por ejemplo, el color del vehículo y el número de puertas. Definiremos dos variables: color y numPuertas. La primera, color, será un objeto de clase NSString (cadena de texto). La segunda, numPuertas, será una variable de tipo NSUInteger (a nuestro nivel, equivalente a un unsigned int de C, o en palabras llanas, un número entero sin signo).

#import <Cocoa/Cocoa.h>
@interface Coche : NSObject {
 NSString    *color;
 NSUInteger    numPuertas;
}
@end

Fijáos en la sintaxis para definir varibles de instancia:

NOMBRE_DE_LA_CLASE_DEL_OBJETO *NOMBRE_DEL_OBJETO;
NOMBRE_DEL_TIPO_DE_VARIABLE NOMBRE_DE_LA_VARIABLE;

Al defnir un objeto siempre antepondremos un asterisco (“*”) al nombre del objeto.

Y ahora, ¿cómo obtenemos el valor de estas variables? Pues bien, tendremos que crear un método de instancia para asignar este valor. Los métodos se definen entre el corchete de cierre (“}”) y el @end. Creemos dos métodos de instancia: getColor y getNumPuertas. Creemos otro más llamado imprimirDetalles que muestre en la consola los valores devueltos por getColor y getNumPuertas.

#import <Cocoa/Cocoa.h>
@interface Coche : NSObject {
 NSString    *color;
 NSUInteger    numPuertas;
}
- (NSString *)getColor;
- (NSUInteger)getNumPuertas;
- (void)imprimirDetalles;
@end

Fijáos de nuevo en la sintaxis:

- (CLASE_DEL_OBJETO_QUE_VAMOS_A_DEVOLVER *)NOMBRE_DE_LA_FUNCION;
- (TIPO_DE_LA_VARIABLE_QUE_SE_DEVOLVERA)NOMBRE_DE_LA_FUNCION;
- (VOID)NOMBRE_DE_LA_FUNCION_QUE_NO_DEVUELVE_NADA;

Como antes, cuando un método devuelve un objeto, se añade un asterisco al nombre de la clase del objeto que se devolverá. Cuando no es un objeto, no es necesario añadir el asterisco. Cuando una función no devuelve nada, se utiliza el valor void para indicárselo al compilador.

El guión (“-”) que precede a los métodos sirve para indicar que se trata de métodos de instancia. Si se tratase de métodos de clase (que veremos más adelante), estarían precedidos por un sigo +.

Pero aún nos faltan dos métodos para establecer el valor de las dos variables de instancias. Para ello definiremos dos métodos llamados setColor y setNumPuertas que acepten un parámetro que será el nuevo valor.

#import <Cocoa/Cocoa.h>
@interface Coche : NSObject {
 NSString    *color;
 NSUInteger    numPuertas;
}
- (NSString *)getColor;
- (NSUInteger)getNumPuertas;
- (void)imprimirDetalles;
- (void)setColor: (NSString *)nuevoColor;
- (void)setNumPuertas: (NSUInteger)nuevoNumPuertas;
@end

Analicemos la sintaxis de estas funciones. Como podéis ver, ninguna de las dos devuelve ningún valor, luego en el primer paréntesis escribiremos void. Los nombres están claros, pero al final de estos hay dos puntos (“:”). Esto indica que a continuación se encuentra un parámetro. Los parámetros tienen dos partes: la clase del objeto que es el parámetro o el tipo de la variable que es el parámetro y el nombre del mismo. La sintaxis es igual que la del tipo de valor que devuelve la función: El tipo de variable o la clase de objeto entre paréntesis (si es un objeto el parámetro se añade un asterisco) y a continuación el nombre del mismo. Las funciones pueden admitir varios parámetros, y pueden haber funciones con el mismo nombre pero diferentes parámetros. A continuación tenéis un ejemplo.

- (void)miFuncion;
- (void)miFuncionConUnParametro: (NSUInteger)miParametro;
- (NSString *)miFuncionConUnParametro: (NSUInteger)miParametro queAdemasDevuelveUnaCadenaDeTextoYRequiereOtroParametro: (NSUInteger)elSegundo;

Esto presenta un problema: ¿Cómo se llaman las funciones, si puede haber dos iguales hasta el primer parámetro? Pues bien, las funciones anteriores se llamarían así:

miFuncion
miFuncionConUnParametro:
miFuncionConUnParametro:queAdemasDevuelveUnaCadenaDeTextoYRequiereOtroParametro:

De este modo no son iguales los nombres a pesar de ser bastante parecidos (al menos en principio).

Con esto hemos creado la interfaz de nuestra clase: el índice de variables y métodos a los que responde. Sin embargo aún tenemos que escribir el código de estas funciones, así que vayamos al archivo Coche.m y comencemos a implementarlas. En el archivo .m veremos el siguiente código:

#import "Coche.h"
@implementation Coche
@end

Os suena, ¿verdad? Como en el caso anterior, vemos como se importa un archivo, en este caso la interfaz de nuestra clase. También vemos como se inicia la implementación con un código similar a la interfaz. Como podéis suponer, entre @implementation Coche y @end es donde escribiremos nuestras funciones.

Antes de implementar nuestras funciones, añadid el siguiente código después de @implementation Coche. Se trata de un método para la gestión de memoria que veremos en otro tutorial. Así de forma rápida, el método dealloc se llama cuando un objeto va a ser eliminado de la memoria. Los objetos tienen un contador interno que se aumenta con el método retain y se disminuye con el método release. Cuando el contador llega a 0, se llama automáticamente al método dealloc y se elimina el objeto de la memoria. De momento basta con que lo copiéis sin preguntar, ya lo explicaré más adelante.

- (void)dealloc
{
 [color release];
 [super dealloc];
}

Aprovechando este código os explicaré cómo se sobreescriben funciones ya existentes en la clase padre. Como he comentado, una clase que hereda de otra recibe las funciones de la clase padre, pero ¿qué sucede si queremos que en la clase hija la función heredada sea diferente? Pues nada, escribimos la nueva función como cualquier otra. La sintaxis es sencilla:

- (TIPO_DE_VALOR_QUE_SE_DEVUELVE)NOMBRE_DE_LA_FUNCION
{
// Código de la función
}

¿Qué ocurre si queremos que además de ejecutarse nuestro código se ejecute también el método (por si no os habéis dado cuenta, utilizo método y función para referirme a lo mismo, tal vez no es lo más correcto, pero estoy más acostumbrado a hablar de función y no de método, así que me sale sin pensar) de la clase padre que estamos sobreescribiendo? Pues añadimos [super NOMBRE_DE_LA_FUNCION]; en el lugar en el que queramos que se ejecute.

- (TIPO_DE_VALOR_QUE_SE_DEVUELVE)NOMBRE_DE_LA_FUNCION
 {
// Podemos ejecutar el método de la clase padre antes que nuestro código
[super NOMBRE_DE_LA_FUNCION];
// Código de la función
// O después
[super NOMBRE_DE_LA_FUNCION];
}

Veamos ahora cómo quedaría la implementación de nuestra clase tras añadir todos los métodos que hemos definido en la interfaz:

#import "Coche.h"
@implementation Coche
- (void)dealloc
{
 [color release];
 [super dealloc];
}
- (NSString *)getColor
{
}
- (NSUInteger)getNumPuertas
{
}
- (void)imprimirDetalles
{
}
- (void)setColor: (NSString *)colorNuevo
{
}
- (void)setNumPuertas: (NSUInteger)nuevoNumeroDePuertas
{
}
@end

Fijáos en que he cambiado el nombre de las variables de los argumentos de las dos últimas funciones. Las variables de los argumentos no tienen por qué tener el mismo nombre en la interfaz y en la implementación, pero tampoco pasa nada porque tengan el mismo nombre.

La función getColor y getNumPuertas tan sólo devuelven el valor de las variables correspondientes, así que añadiremos return VARIABLE; para que el método devuelva el valor de la variable. return no requiere asterisco si se devuelven objetos, se usa exactamente igual con objetos que con variables sencillas.

En la función imprimirDetalles utilizaremos la función NSLog para imprimir en la consola los valores de las variables. La función NSLog admite varios parámetros. El primero siempre es una cadena de texto (@”"), pero esta cadena admite combinaciones de caracteres específicas que indican que se deben reemplazar por otro valor. Así un %d se reemplazará por un número entero, un %f por un número decimal y un %@ por otra cadena de texto (se puede usar tranquilamente un objeto también, lo veremos más adelante). Si usamos estas combinaciones, tras la cadena de caracteres, y separadas por comas (“,”) debemos introducir las variables o los objetos que reemplazarán las combinaciones. A continuación tenéis las tres funciones que hemos explicado:

- (NSString *)getColor
{
 return color;
}
- (NSUInteger)getNumPuertas
{
 return numPuertas;
}
- (void)imprimirDetalles
{
 NSLog(@"Este coche es de color %@ y tiene %d puertas", [self getColor], [self getNumPuertas]);
}

Fijáos en la última función, concretamente en [self getColor] y [self getNumPuertas]. Esta es la sintaxis para enviar mensajes a los objetos. Enviar un mensaje a un objeto es, básicamente, pedirle a un objeto que ejecute el método con ese nombre. Así, cuando escribimos [self funcion] le pedimos al objeto self que ejecute el método funcion. El objeto self es un objeto especial y hace referencia al objeto actual, de modo que lo que hacemos en esta última función es pedirle al objeto de clase Coche que ejecuta el método imprimirDetalles que ejecute el método getColor y getNumPuertas.

Las funciones setColor y setNumPuertas son bastante sencillas. Simplemente asignaremos (mediante “=”) el valor que se pasa como parámetro (o argumento) a la variable correspondiente. Aquí los tenéis completos:

- (void)setColor: (NSString *)colorNuevo
{
 color = colorNuevo;
}
- (void)setNumPuertas: (NSUInteger)nuevoNumeroDePuertas
{
 numPuertas = nuevoNumeroDePuertas;
}

Y este es el aspecto final de la implementación de nuestra clase Coche:

#import "Coche.h"
@implementation Coche
- (void)dealloc
{
 [color release];
 [super dealloc];
}
- (NSString *)getColor
{
 return color;
}
- (NSUInteger)getNumPuertas
{
 return numPuertas;
}
- (void)imprimirDetalles
{
 NSLog(@"Este coche es de color %@ y tiene %d puertas", [self getColor], [self getNumPuertas]);
}
- (void)setColor: (NSString *)colorNuevo
{
 color = colorNuevo;
}
- (void)setNumPuertas: (NSUInteger)nuevoNumeroDePuertas
{
 numPuertas = nuevoNumeroDePuertas;
}
@end

Ahora modificaremos nuestra aplicación para que cree un objeto de clase coche, establezca su color en azul y su número de puertas en 5 y que a continuación imprima en la consola la información sobre el mismo.

Vamos al archivo NOMBREPROYECTO.m, que debería tener el siguiente código:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) {
 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 // insert code here…
 NSLog(@"Hello, World!");
 [pool drain];
 return 0;
}

E importamos el archivo Coche.h justo después de importarse Foundation:

#import "Coche.h"

A continuación añadimos, entre NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; y [pool drain];:

Coche *miCoche = [[Coche alloc] init];
 [miCoche setColor:@"Azul"];
 [miCoche setNumPuertas:5];
 [miCoche imprimirDetalles];
 [miCoche release];

Vayamos línea a línea:

Coche *miCoche = [[Coche alloc] init];

En esta línea creamos el objeto miCoche, de clase Coche. Fijáos como se le envía a  la clase Coche el mensaje alloc y al objeto resultante de ese mensaje se le envía el mensaje init. Los mensajes se pueden encadenar tanto como se quiera, aunque esto hace más complicado de leer el código, así que no es muy recomendable.

[miCoche setColor:@"Azul"];
[miCoche setNumPuertas:5];

En estas dos líneas se envía el método setColor: y setNumPuertas: al objeto miCoche, con el parámetro @”Azul” como nuevo color y 5 como número de puertas.

[miCoche imprimirDetalles];

En esta línea se le manda al objeto el mensaje imprimirDetalles, lo que hará que muestre por terminal los valores de las variables.

 [miCoche release];

Por último esta línea elimina el objeto. En realidad es algo más complejo, y lo explicaré más adelante en otro tutorial. De momento con saber que se elimina el objeto nos vale.

El código resultante de MIPROYECTO.m será:

#import <Foundation/Foundation.h>
#import "Coche.h"
int main (int argc, const char * argv[]) {
 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 // insert code here…
 NSLog(@"Hello, World!");
 Coche *miCoche = [[Coche alloc] init];
 [miCoche setColor:@"Azul"];
 [miCoche setNumPuertas:5];
 [miCoche imprimirDetalles];
 [miCoche release];
 [pool drain];
 return 0;
}

Y si compilamos y ejecutamos la aplicación veremos el siguiente resultado:

Esto no está mal, pero, ¿para qué llamar a dos métodos para establecer las variables y otro más para iniciar el objeto (init)? ¿No podríamos juntar esos tres métodos en uno? Sí, podemos. Vayamos al archivo Coche.h y añadamos el siguiente método:

- (Coche *)initWithColor: (NSString *)nuevoColor andNumPuertas: (NSUInteger)nuevoNumPuertas;

Quedando así la interfaz:

#import <Cocoa/Cocoa.h>
@interface Coche : NSObject {
 NSString    *color;
 NSUInteger    numPuertas;
}
- (Coche *)initWithColor: (NSString *)nuevoColor andNumPuertas: (NSUInteger)nuevoNumPuertas;
- (NSString *)getColor;
- (NSUInteger)getNumPuertas;
- (void)imprimirDetalles;
- (void)setColor: (NSString *)nuevoColor;
- (void)setNumPuertas: (NSUInteger)nuevoNumPuertas;
@end

En la implementación añadiremos lo siguiente:

- (Coche *)initWithColor: (NSString *)nuevoColor andNumPuertas: (NSUInteger)nuevoNumPuertas
{
 if (self = [super init])
 {
 [self setColor:nuevoColor];
 [self setNumPuertas:nuevoNumPuertas];
 }
 return self;
}

Analicemos este código. La primera línea de la función, if (self = [super init]) sirve para comprobar que el objeto se ha creado correctamente. Es posible (aunque raro) que por algún motivo el objeto no pueda crearse correctamente (por ejemplo, por falta de memoria), así que en caso de que no se cree correctamente, no estableceremos el valor de ninguna variable (pues de otra manera haríamos fallar la aplicación). Dentro de la condición se envía los mensajes que ya conocemos al objeto y finalmente se devuelve el objeto self. Como podéis ver, esta función devuelve un objeto de clase Coche.

El código final de nuestra implementación será:

#import "Coche.h"
@implementation Coche
- (Coche *)initWithColor: (NSString *)nuevoColor andNumPuertas: (NSUInteger)nuevoNumPuertas
{
 if (self = [super init])
 {
 [self setColor:nuevoColor];
 [self setNumPuertas:nuevoNumPuertas];
 }
 return self;
}
- (void)dealloc
{
 [color release];
 [super dealloc];
}
- (NSString *)getColor
{
 return color;
}
- (NSUInteger)getNumPuertas
{
 return numPuertas;
}
- (void)imprimirDetalles
{
 NSLog(@"Este coche es de color %@ y tiene %d puertas", [self getColor], [self getNumPuertas]);
}
- (void)setColor: (NSString *)colorNuevo
{
 color = colorNuevo;
}
- (void)setNumPuertas: (NSUInteger)nuevoNumeroDePuertas
{
 numPuertas = nuevoNumeroDePuertas;
}
@end

¿Cómo aplicamos estos cambios a nuestra aplicación? Vayamos al archivo NOMBREPROYECTO.m y reemplacemos el siguiente código:

Coche *miCoche = [[Coche alloc] init];
 [miCoche setColor:@"Azul"];
 [miCoche setNumPuertas:5];

Por este otro:

Coche *miCoche = [[Coche alloc] initWithColor:@"Azul" andNumPuertas:5];

Como veis, hemos convertido tres líneas de código en sólo una, y el resultado es idéntico.

Esto tan sólo es una breve introducción al paradigma de la programación orientada a objetos. Espero que os haya aclarado un poco los conceptos. En los próximos tutoriales iremos viendo más características de la POO en Objective-C.

En este serie de tutoriales voy a suponer que se tienen unos conocimientos básicos de programación, que se entiende el significado de términos como “código fuente”, “función” o “variable”. Cualquiera que haya programado antes en cualquier lenguaje de programación conocerá su significado. El único término nuevo que puede que no conozcan aquellos que sólo han programado en lenguajes interpretados (como PHP) es el de “compilar”. Para simplificar, podríamos decir que compilar un programa es traducir el código que nosotros escribimos en un código que la máquina pueda entender.

Ahora bien, queda diferenciar cuatro conceptos:

• Objective-C: Es el lenguaje de programación que se suele usar en Mac OS X. Digo se suele usar porque también se pueden programar aplicaciones en C, C++, Objective-C++, etc.
• Cocoa: Es un Framework, un conjunto de funciones que facilitan la tarea al programador. Tareas como modificar una cadena de caracteres, descargar archivos de Internet, gestionar matrices o la memoria se hacen mucho más sencillas con este Framework. De hecho programar en Objective-C sin usar Cocoa es algo poco usual y no lo veremos en este tutorial (yo, por ejemplo, no he programado nada en Objective-C sin tener vinculado Cocoa). Cocoa Touch es la versión de Cocoa para iPhone, iPod Touch y iPad.
• Programación Orientada a Objetos: Es un paradigma de programación del que hablaremos más adelante. Objective-C es un lenguaje de Programación Orientada a Objetos. En Objective-C prácticamente todo es un objeto, cosa que veremos más adelante.
• Modelo Vista y Controlador: Es una arquitectura en la que se separa la parte lógica de la aplicación de la interfaz y de los datos que se gestionan. Realmente no es imprescindible hacer uso de esta arquitectura, pero hacerlo es una buena idea, simplifica la tarea y hace las aplicación más fáciles de extender. En nuestros primeros pasos no haremos uso de esta arquitectura, pero a medida que vayamos avanzando iremos viendo en qué consiste y qué beneficios aporta.

Menú Archivo

Plantillas del proyecto de Xcode

Dicho esto, pasemos a presentar a los sospechosos habituales. Cuando programemos en Mac OS X trabajeros con Xcode, el Entorno de Desarrollo Integrado de Apple. Xcode viene en los discos de instalación de Mac OS X, y se puede descargar de forma gratuita (previo registro) desde la web de Apple. Durante estos tutoriales usaremos como plantilla del proyecto la plantilla de aplicación para la línea de comandos, ya que así evitamos tener que preocuparnos de elementos más complejos como la interfaz gráfica de la aplicación. Crear un nuevo proyecto es sencillo: Basta con ir al menú File » New project… . Aparecerá una ventana en la que podremos seleccionar la plantilla para el proyecto que vamos a crear. En estos tutoriales elegiremos la plantilla Mac OS X » Application » Command Line Tool.

Veremos una ventana como la que tenéis en la izquierda. En la parte izquierda de la ventana tenemos acceso a los archivos del proyecto. De los archivos que se pueden ver en la imagen, el que nos interesa ahora es NOMBREPROYECTO.m. Veréis un código como el siguiente:

#import <Foundation/Foundation.h>
int main (int argc, const char * argv[]) {
 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 // insert code here…
 NSLog(@"Hello, World!");
 [pool drain];
 return 0;
}

La almohadilla introduce instrucciones para el preprocesador. Las que más comúnmente se usan con #import y #define. #import incluye otros archivos y Frameworks en el archivo actual. #define permite declarar constantes. Las constantes sirven para definir un valor que es fijo en toda la aplicación, pero que si nos interesa cambiar, podemos hacerlo modificando una sóla línea. Imaginad, por ejemplo, que queremos definir nuestra edad. Si sólo la ponemos en una línea no hay ningún problema, pero ¿y si la incluímos en 5, 10, 200 ó 5000 líneas? Es una faena tener que ir buscando cada lugar en el que hemos puesto ese valor. Con las constantes basta con poner la constante en lugar de nuestra edad, y definir el valor de la constante con el valor de nuestra edad. Cuando queramos modificar el valor de nuestra edad, sólo lo cambiaremos una vez, en lugar de tantas veces como uso se haga de ella.

A la hora de importar archivos, hay dos tipos de archivos que podemos importar: Frameworks del sistema y otros archivos de nuestro proyecto. Cuando importamos Frameworks del sistema, usamos los signos mayor e igual que (<>). Si importamos archivos de nuestro proyecto, usamos comillas (“).

La siguiente línea define la función main. La función main es la función principal de la aplicación, la única función que siempre se ejecuta. La estructura de la función es la misma estructura que C, sin embargo en Objective-C la mayoría de las funciones (métodos) se definen con una sintaxis diferente, así que no me voy a parar a explicarla.

Centrémonos en el siguiente bloque:

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 // insert code here…
 NSLog(@"Hello, World!");
 [pool drain];
 return 0;

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

A continuación vemos una línea que comienza con dos barras (//). Cuando una línea va introducida por dos barras, se trata de un comentario. Los comentarios se eliminan de la aplicación al compilarla: son sólo una ayuda al programador durante la programación, para saber qué hace cada cosa o para qué se usa una variable. Los comentarios también se pueden introducir con /* Comentario */.

[c]

// Con dos barras el comentario ocupa toda la línea

/* Con barra y asterisco es necesario terminar el comentario con asterisco barra, así que el comentario

aún no ha acabado en esta línea,

sino que acaba en esta otra */

[/c]

La siguiente línea es la llamada a una función.

NSLog(@"Hello, World!");

Objective-C es un superconjunto de C, con lo cual comparte algunas características con el anterior. Esta forma de llamar a la función es típica de C. Las funciones tienen dos partes: La primera (NSLog en este caso) es el nombre de la función. La segunda, que se encuentra entre paréntesis (“()”), son los argumentos de la función. En este caso, el argumento es: @”Hello, World!”. Cuando unas comillas están precedidas por un arroba (@), sabemos que se trata de una cadena de texto, un objeto de clase NSString (lo trataremos más adelante). Tras los paréntesis encontramos un punto y coma (;). Esto indica el final de una instrucción (todas las instrucciones en C y Objective-C van sucedidas por un punto y coma (;), a excepción de aquellas instrucciones que son argumentos de funciones (como el @”Hello, World!”)  o de mensajes (lo veremos más adelante).

La función NSLog() muestra el texto que se le envía como argumento en la terminal. Durante el desarrollo de la aplicaciones es una función muy útil, como veréis a medida que avancemos en los tutoriales, para saber el valor de una variable en cada momento o para recibir un aviso cuando se ejecuta un método.

[pool drain];

Esta línea le envía el mensaje drain al objeto pool, creado anteriormente. Veremos más adelante todo esto, en otro tutorial de esta serie. A continuación vemos:

return 0;

Esta línea le devuelve el valor 0 al Sistema Operativo. La función main tiene que devolver un valor que indica si la aplicación se ha ejecutado correctamente o si ha encontrado errores durante su ejecución. El valor 0 indica que todo ha ido bien.

Nuestra primera aplicación ejecutándose

Para probar la aplicación hay que pulsar el botón Build and Run, o pulsar Comando + Enter. La aplicación se compilará y se ejecutará. Como la aplicación no tiene interfaz, se ejecutará sin ver nosotros nada. Para poder ver el texto enviado por nuestra aplicación (Hello, World!), tenemos que mostrar la consola (Menú Run » Console o Comando + Mayus + R). Veremos algo como la imagen de la izquierda.

Y esto es todo por este primer tutorial. En los próximos comenzaré a tratar la Programación Orientada a Objetos en Objective-C e introduciré los conceptos de clase, objeto y método.

Antes (izquierda) y después (derecha)

Cuando se lleva algún tiempo programando se acaban cogiendo manías y estilos a la hora de escribir el código, una de las más comunes es escribir las llaves ({ y }) en la línea siguiente, en lugar de en la línea en la que acaba la sentencia, manía que además suele considerarse como buena práctica.

// Con las llaves en la misma línea
- (void)funcionDePrueba {
     if (condicion) {
          [self otraFuncion];
     }
}
// Con las llaves en la línea siguiente
- (void)funcionDePrueba
{
     if (condicion)
     {
          [self otraFuncion];
     }
}

La cuestión es que ahora que estoy programando en Objective-C y utilizo Xcode, se me hace muy molesto que el autocompletado de código me añada las llaves en la misma línea que la sentencia, en lugar de la siguiente (cuando programo en PHP, el editor que uso no autocompleta el código). Sin embargo hay una forma sencilla de hacer que añada las llaves en la línea siguiente: tan sólo tenemos que escribir el siguiente código en la terminal y reiniciar Xcode.

defaults write com.apple.Xcode XCCodeSenseFormattingOptions '{ "BlockSeparator" = "\n" ; }' 

Esto sólo afecta al autocompletado de código, no a las plantillas que vienen con Xcode.

Dropbox es un gran alternativa para este problema. Se trata de una aplicación que crea una carpeta en nuestro equipo que se sincroniza con una carpeta en un servidor remoto. Cada vez que añadimos algo en nuestra carpeta, se añade en la carpeta del servidor remoto, de modo que podemos acceder a los archivos de dicha carpeta desde cualquier ordenador conectado a Internet, a través de la web de Dropbox. También podemos instalar la aplicación en todos nuestros equipos, y al modificar un archivo de la carpeta de Dropbox en un equipo, se modifica en todos los demás equipos que tengan la aplicación instalada, sin necesidad de estar todos encendidos a la vez, ya que se sincronizan con el servidor remoto.

La aplicación es gratuita y está disponible tanto para Windows como para Mac OS X y Linux, además de móviles con Android, iPhone, iPad y próximamente Blackberry.  Ofrece un espacio de 2GB de forma totalmente gratuita, aunque por 9.99$ al mes podemos ampliar este espacio a 50GB y por 19.99$ disponemos de 100GB. También podemos ampliar nuestro espacio disponible de forma gratuita invitando a nuestros amigos a Dropbox de modo que por cada amigo que se registre en Dropbox ampliaremos en 250MB la capacidad de nuestra cuenta, hasta llegar al límite de 8GB.

Afortunadamente tenemos una alternativa: podemos convertir nuestros PDF en ePub. Hay muchas aplicaciones para hacer esto, tanto online como offline, pero en este artículo sólo me centraré en una aplicación. Calibre (así es como se llama la utilidad que nos permitirá convertir nuestros PDF en ePub) es totalmente gratutia y está disponible tanto para Windows como para Linux y Mac OS X.

Instalar Calibre es realmente fácil. El primer paso (imagen de la izquierda) nos dejará seleccionar el idioma de la aplicación y la carpeta en la que almacenaremos la colección de libros (no lo he comentado antes, pero Calibre permite gestionar toda nuestra biblioteca digital además de convertir nuestros archivos PDF en ePub – entre otros formatos). El siguiente paso (imagen de la derecha) consiste en seleccionar el lector de libros que usaremos, este tutorial está orientado al iPhone, iPod y iPad, así que seleccionaremos de la primera lista “Apple” y de la segunda “iPad or iPhone/iTouch + Stanza“.

El tercer paso es opcional (imagen de la izquierda) y permite crear un servidor para almacenar información acerca de nuestra lectura si usamos la aplicación Stanza, pero el objectivo del tutorial es leer los libros con iBooks, así que podemos dejar desmarcada esta opción. Con esto habremos terminado de configurar Calibre (imagen de la derecha).

Convertir un documento PDF a ePub no es tampoco nada complicado. Lo primero que tenemos que hacer es añadir el documento en cuestión a Calibre, en Mac OS X basta con arrastrar el archivo a su icono en el dock, aunque también podemos añadirlo haciendo clic en la imagen del libro rojo (la primera imagen del menú superior). Cuando tengamos añadido el libro veremos algo similar a la imagen de la izquierda. A continuación tenemos que seleccionar el libro que queramos convertir y hacer clic en la imagen del libro marrón (la tercera del menú superior, en la imagen de la izquierda está indicada). Nos aparecerá una ventana con opciones para configurar el nuevo documento (imagen de la derecha), como seleccionar la portada, la tabla de contenidos, metadatos, formato del nuevo documento, etc. Las opciones que vienen por defecto nos valen (a no ser que queramos personalizar más el documento), así que le damos a “Aceptar” y continuamos.

Ahora tendremos que esperar unos minutos (dependiendo del tamaño del archivo) hasta que esté listo el documento convertido (veréis una ventana como la de la imagen de la izquierda). Cuando acabe la exportación, veremos que en nuestra biblioteca de Calibre ahora hay dos archivos más: la portada del libro exportado y el libro en formato ePub. Ahora ya sólo nos queda importar el libro en iTunes (de nuevo en Mac OS X basta con arrastrar el archivo al icono de iTunes en el dock) y sincronizar nuestro iPhone/iPod/iPad.

Lamentablemente, el archivo que obtendremos no será idéntico al PDF, y puede que haya variaciones en el color y en la estructura en general. De hecho el documento que he convertido yo en el tutorial perdía los colores y la estructura del documento variaba ligeramente. A cambio ganaremos la posiblidad de poder aumentar el tamaño de la letra.

Buscando FileMerge

FileMerge es una de las aplicaciones que vienen con el disco de instalación de Mac OS X, y se instala juntamente con Xcode y todo el entorno de desarrollo de Mac OS X, así que por defecto no la encontraréis instalado. Una vez tengáis instalado Xcode bastará con que busquéis con Spotlight “FileMerge” y lo ejecutéis.

Interfaz de FileMerge

La interfaz es muy intuitiva: se arrastra un archivo al recuadro de la izquierda y otro al recuadro de la derecha y a continuación se hace clic en “Compare”. Esperamos unos segundos (dependiendo de los archivos) a FileMerge acabe de encontrar las diferencias y finalmente veremos una ventana dividida en dos partes. Cada parte tiene el contenido de un archivo y las diferencias aparecen marcadas en ambos lados. También nos ofrece un recuento de diferencias.

Es realmente útil para comparar dos versiones diferentes de un archivo y ver qué cambios se han realizado de forma más cómoda y rápida. Se acabó el tener que ir línea a línea buscando diferencias, con FileMerge el trabajo se hace mucho más sencillo.

En la keynote del lunes se presentó el nuevo iPhone 4, se dio un repaso al iPhone OS 4, iOS4 a partir de ahora y se mostró por primera vez iMovie para el iPhone. Además durante la sesión de “Safari, Internet adn Web State of the Union” se presentó Safari 5, que ya está disponible para Mac OS X y Windows. Por último, algunas operadoras han confirmado que la exclusividad del iPhone se ha acabado en España. Pero veamos de una en una las novedades.

iPhone 4 y iOS4

Comencemos por el nuevo iPhone 4. En abril Gizmodo consiguió un prototipo del iPhone 4 que supuestamente había perdido un empleado de Apple en un bar de Redwood. Pues bien, el diseño del iPhone 4 es el mismo que el del prototipo: Gizmodo no mentía para nada.

Los dos colores del iPhone 4

El iPhone 4 se venderá en dos colores diferentes: blanco y negro. La pantalla tiene una resolución de 960×640 con una densidad de 326 píxels por pulgada y un contraste 800:1 (a todo esto Apple lo ha llamado Retina Display). Se ha añadido una cámara frontal de 3mpx y un segundo micrófono para eliminar el ruido en las videollamadas (hablaré de ellas más adelante), mientras que la cámara trasera ha pasado de los 3mpx a 5mpx, ganando además flash LED y un sensor retroiluminado. A partir de ahora el iPhone podrá grabar vídeo en HD (720p) y editarlo con iMovie (del que también hablaré más adelante).

iPhone 4

El cuanto a los componentes, el nuevo diseño tiene un razón de ser, y es que varios componentes internos han cambiado. Para comenzar la antena se encuentra ahora en el borde metálico del dispositivo. Realmente el borde se divide en dos trozos diferentes, cada uno para una antena dedicada a funciones diferentes. El iPhone 4 pasa a tener un procesador A4 de Apple (el mismo que el iPad) y una batería de mayor duración, aguantando 10 horas más de reproducción de audio, 1 hora más de conexión a Internet por Wi-Fi o 3G y 2 horas más de tiempo durante las conversaciones sobre redes 2G y 3G. La duración de la batería en reposo es aparentemente la misma que en el iPhone 3GS.

Se le ha añadido un giroscopio, dotando al iPhone 4 de un total de 9 ejes de movimientos de los que sacar datos para nuevas aplicaciones y juegos. Para algunos esta novedad no tendrá nada de especial, pero seguramente aparecerán de aquí a un par de meses algunas aplicaciones que hagan usos interesantes del giroscopio. Las tarjetas para el iPhone tendrán que ser MicroSim y se venderán modelos de 16GB y de 32GB.

Estas son todas las novedades en lo que respecta al hardware del iPhone 4: nuevo diseño, nuevo procesador, mejor cámara trasera y cámara frontal, dos micrófonos y mejor pantalla.

FaceTime

En lo que respecta al iPhone OS 4, hay dos novedades. La primera es que pasa a llamarse iOS4. La segunda, que se suma a las novedades que ya comenté en su día es la videollamada. La idea no es nueva, y está bastante bien adaptada al iPhone, pero me ha decepcionado bastante al final. FaceTime (así se llama la videoconferencia del iPhone 4) te permite establecer videoconferencia y enviar tanto el vídeo captado por la cámara frontal como el que capta la cámara trasera, de hecho se puede alternar durante la propia videollamada. También tiene un diseño bastante atractivo, pero le encuentro dos pegas.

La primera es que sólo funciona en el iPhone 4, es decir: videollamada de iPhone 4 a iPhone 4 (FaceTime está abierto a cualquier compañía que quiera integrarlo en sus dispositivos, pero la decisión última es de estas compañías: si no quieren, con el iPhone 4 sólo podrás hacer videoconferencias con otros iPhone 4. ¡Menos mal que si que puedes recibir llamadas de cualquier dispositivo, porque sino mal iríamos!).

La segunda pega es que sólo funciona bajo redes Wi-Fi, en teoría para no sobrecargar las redes 3G. Así que para hacer videoconferencia hay dos requisitos: que tu contacto tenga un iPhone 4 y que ambos estéis bajo cobertura de una red Wi-Fi abierta o de la que conozcáis la contraseña.

iMovie para el iPhone

Fuera de FaceTime la principal novedad en cuanto a software para el iPhone es la versión de iMovie para iOS 4. Básicamente se trata de una versión ligera del iMovie (un software sencillo de edición de vídeo) adaptada para el iPhone. Según comentan aquellos que lo han probado, es realmente rápido e intuitivo, y permite exportar nuestras creaciones en HD. iMovie para el iPhone se vende por separado a 4.99$ (véase 3.99€). Sería mucho pedir que lo pusieran de serie en iOS 4…

Tan sólo me queda por comentar el tema de las operadoras. Hasta ahora el iPhone lo vendía únicamente Movistar. Pues bien, a partir de ahora ya no será así. En Estados Unidos parece que sigue la permanencia con AT&T, pero en España tanto Movistar como Orange como Vodafone venderán el iPhone 4. Lo que no se sabe aún son las tarifas bajo las que lo venderán, pero al menos sabemos que no dependeremos de una única operadora.

Y esto es todo respecto al iPhone 4: novedades en hardware, en diseño y en software (aunque muchas ya las conocíamos). Son novedades muy interesantes, aunque pienso que aún le falta un gestor de archivos, dejar de limitar el bluetooth (para darle algún uso, como compartir archivos) y añadir flash (que aunque no me guste demasiado, es necesario en algunas ocasiones).

Os dejo a continuación dos vídeos del iPhone 4.

Safari 5

Safari Reader

No se ha presentado durante la keynote, pero la quinta versión del navegador de Apple incluye unas cuantas novedades muy interesantes, comenzando por las mejoras que han realizado en el motor de Javascript, Nitro, que ahora es el doble de rápido que Firefox 3.6 y un 3% más rápido que Chrome 5.0 (aunque no se yo si notaremos esa pequeña diferencia).

Se ha añadido Safari Reader, una función que elimina el contenido adicional de cualquier página, haciendo que nos centremos con más facilidad en el contenido propiamente dicho. Eso sí, esta función sólo está disponible en las páginas que se basan en texto (como por ejemplo, un artículo de Sumolari.com, no la página principal del blog). Para activarlo basta con pulsar el botón “Lector” que aparece a la derecha de la barra de direcciones cuando está disponible la función.

También se ha añadido como buscador Bing. Hay que tener en cuenta que Safari no permite añadir nuestros propios motores de búsqueda, tan sólo nos deja escoger entre los que tiene por defecto, así que hasta ahora no podíamos seleccionar Bing como buscador.

Extensiones en Safari 5

En cuanto a estándares, Safari 5 soporta la reproducción de vídeos a pantalla completa, los subtítulos, la geolocalización, la validación de formularios y algunas etiquetas de HTML 5 como <header>, <footer>, <nav>, <section>, <aside> o <article>. Sin embargo la novedad más interesante es el soporte de extensiones, basadas en HTML 5, CSS3 y Javascript, lo que las hace un objetivo muy atractivo para los desarrolladores. Además para mayor estabilidad se ejecutarán de forma independiente.

Y estas son todas las novedades de Safari 5.

Os dejo las imágenes a continuación.