Tomándole una foto a un UIView?, si!

Me encontré con un requerimiento de una aplicación para iOS que estoy haciendo:

Necesitamos mostrar una imagen, que muestre un texto, una imagen en el fondo, el texto puede cambiar, hacerse mas grande, menos grande…

Lo primero que pensé fue crear la imagen con Core Graphics, pero luego me di cuenta de algo, por que no aprovechar Auto Layout?, sobre todo con lo de que el texto puede variar, a veces calcular el tamaño de un UILabel puede ser medio tedioso, pero con Auto Layout puedo crear unas reglas que harán que el tamaño de mi UILabel se acomode a cualquier texto. Ahora, como hago para tomarle una foto a un UIView?, bueno, el primer obstáculo era que no podia presentar este UIView al usuario, es decir, no podia hacer que este UIView estuviera asociado a un UIViewController y presentarlo al usuario, tenia que ser algo por debajo, algo que la aplicación hiciera sin que el usuario se diera cuento de esto.

Lo primero fue crear una nueva escena en mi Storyboard, creé un nuevo UIViewController, lo asocie a esta escena, luego le agregue algunos controles a la vista de este controlador, un UILabel para agregar el texto, un UIImageView para el fondo…, le puse un identificador único para el Storyboard, todo listo.

UIKit provee varias formas de hacer esto (según entiendo, más rápidas), desde iOS7, pero de esta manera tengo que presentarle al usuario la vista…, volvamos a empezar, 😕.

Suponiendo, 😉, que ya sabia como capturar una imagen dependiendo del contexto, terminé pensando, como puedo hacer que se pinte la vista sin tener que presentarla?, la vista de un controlador inicia el mecanismo para pintarla cuando el controlador es presentado en pantalla, usando algo como presentViewController:animated:completion: o usando un UINavigationController, me acordé que el método setNeedsLayout junto con layoutIfNeeded inician el proceso de recalcular el tamaño de la vista, ese mecanismo también llama a los métodos encargados de agregar las reglas de Auto Layout…, así, termine con esto:

- (void)setIncomingCallImageWithThingObject:(THTThing *)aThing andPerson:(RHPerson *)aPerson
{
    // make this stuff in the background.
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        THTIncomingCallViewController *incommingCallVC = [self.storyboard instantiateViewControllerWithIdentifier:kTHTIdIncomingCallViewController];
        incommingCallVC.thing = aThing;
        // draw view in the background.
        [incommingCallVC.view setNeedsLayout];
        [incommingCallVC.view layoutIfNeeded];

<pre><code>    // start capturing the image.
    UIGraphicsBeginImageContextWithOptions(incommingCallVC.view.bounds.size, incommingCallVC.view.opaque, 0.f);
    [incommingCallVC.view.layer renderInContext:UIGraphicsGetCurrentContext()];
    UIImage *incomingCallImage = UIGraphicsGetImageFromCurrentImageContext();
    UIGraphicsEndImageContext();

    [aPerson setImage:incomingCallImage];
    [aPerson save];
});
</code></pre>

}

Como es un proceso bastante dispendioso, estoy usando GCD para pintar la vista en el fondo, lo cual hace que no se me bloquee la vista que está actualmente activa.

Herencia prototipal, o, OOP ala JavaScript

La programación orientada a objetos es el paradigma mas común para la mayoría de los programadores, estamos tan acostumbrados a utilizar este paradigma que pensamos que todos los lenguajes de programación tienen cosas como clases, métodos, atributos, etc., luego entramos en el maravilloso mundo de la programación web y nos encontramos con JavaScript, BOOM!, SyntaxError: class is a reserved identifier, class no sirve?, como heredo de otra clase?, si existen las clases en esto?, que?, todo es con funciones?, etc.

JavaScript es muy diferente de otros lenguajes orientados a objetos, JavaScript no usa el modelo clásico de herencia, en vez de eso, usa un modelo basado en prototipos.

Prototipos

No se si herencia prototipal sea el término correcto, pero, en fin, es el que voy a usar, ;-).

La herencia prototipal consiste en que un objeto es el prototipo de otro. La herencia en JavaScript es simple, es como una cadena, un objeto hereda de otro a través de un atributo que posee el objeto Object, el atributo es prototype. A prototype le podemos asignar cualquier cosa, simplemente que solo funciona cuando le asignamos un objeto, si tratamos de asignarle un primitivo, por ejemplo un número entero, JavaScript solo lo ignora. A esto se le denomina prototype chain.

Aparte de este atributo especial también tenemos los constructores, que son los encargados de crear la instancia de un objeto, por lo general en el JavaScript de este momento, me refiero a cuando escribí este artículo, la forma mas común de crear una instancia de un objeto es con la palabra new.

Todos los objetos en JavaScript heredan de Object, Object poseen una propiedad llamada prototype, esta propiedad contiene a su vez todas las propiedades de Object, así que si creamos un objeto, por ejemplo, Blah, este también posee la propiedad prototype y por consiguiente hereda todas las propiedades de Object.

Ilustremos esto con un ejemplo simple:

function Blah() { // funcin constructora, constructor o clase
    this.value = 42;
}
Blah.prototype = { // atributo 'prototype'
    method: function() {} // mtodo
};

Objetos

Que es un objeto en JavaScript?, yo creería que la forma mas simple de definir un objeto seria algo como:

Una clase con un montón de métodos y atributos.

Claaaaaro, fácil!, no?, ahora, como creamos un objeto en JavaScript?, lo primero que nos encontraremos es esto:

SyntaxError: class is a reserved identifier

En JavaScript no funciona la palabra class para definir una clase (ok, ok, ES.next/harmony/ES6 si usaría este termino, blah, blah…, CoffeeScript, blah, blah…).

Para definir una clase en JavaScript solo es necesario crear una función constructora y agregarle propiedades al atributo prototype de esta función constructora. También existe un atributo dentro de prototype que es importante, el atributo es constructor, que hace referencia a la función constructora, virtualmente es la única forma de reconocer el tipo de una variable. Nunca olvidar este atributo!.

function Blah() { // funcin constructora, constructor o clase
    this.value = 42; // atributo
}
Blah.prototype = { // atributo 'prototype'
    method: function() {} // mtodo
};

Ahora, creemos una instancia de nuestro objeto Blah:

function Blah() { // funcin constructora, constructor o clase
    this.value = 42; // atributo
}
Blah.prototype = { // atributo 'prototype'
    constructor: Blah, // atributo 'constructor'
    method: function() { // mtodo
        return "hiya!";
    }
};

// una instancia de Blah
var blah = new Blah();
// el valor de nuestro atributo 'value'
console.log(blah.value); // 42
// lo que retorna nuestro mtodo 'method'
console.log(blah.method()); // hiya!
// uno de los mtodos que heredamos de 'Object'
console.log(blah.toString()); // [object Object]
// el tipo de 'method'
console.log(typeof blah.method); // function
// constructor
console.log(blah.constructor === Blah); // true

Herencia

Ahora que sabemos como crear un objeto, como obtenemos las propiedades de otro objeto?, como heredamos?, ya aprendimos que JavaScript usa una forma de herencia diferente de la convencional, aquella en la que usamos la palabra extends, o los símbolos : o <, etc., para heredar los atributos y métodos de otro objeto o clase, en JavaScript simplemente asignamos un objeto al atributo prototype.

function Blah() { // funcin constructora, constructor o clase
    this.value = 42; // atributo
}
Blah.prototype = { // atributo 'prototype'
    constructor: Blah, // atributo 'constructor'
    method: function() { // mtodo
        return "hiya!";
    }
};

function Foo() {} // funcin constructora, constructor o clase
Foo.prototype = new Blah(); // heredamos del objeto 'Blah' asignando una instancia de este al atributo 'prototype'
Foo.prototype.constructor = Foo; // 'constructor'

// una instancia de Foo
var foo = new Foo();
// el valor de nuestro atributo 'value' que heredamos de 'Blah'
console.log(foo.value); // 42
// lo que retorna nuestro mtodo 'method' que heredamos de 'Blah'
console.log(foo.method()); // hiya!
// instanceof
console.log(Foo.prototype instanceof Blah); // true
// uno de los mtodos que heredamos de 'Object'
console.log(foo.toString()); // [object Object]
// el tipo de 'method'
console.log(typeof foo.method); // function

Es claro que nuestra función constructora, como cualquier otro constructor de cualquier lenguaje puede recibir unos argumentos, veamos un ejemplo:

function Hi(msg) {
    this.msg = msg;
}

Hi.prototype = {
    constructor: Hi,
    say: function (msg) {
        return this.msg + " " + msg;
    }
}

function MyHi() {}

MyHi.prototype = new Hi();
MyHi.prototype.constructor = MyHi;

var hi = new MyHi();
console.log(hi.say("hola")); // undefined hola

Esta forma de herencia, en la que asignamos la instancia de un objeto al atributo prototype de otra clase, implica que si el objeto padre tiene argumentos en su constructor obtendremos resultados no deseados.

Para evitar este tipo de inconvenientes lo que debemos hacer es crear una función constructora intermediaria, esta técnica permite heredar de otra clase sin afectar directamente esta, esta estrategia es descrita por Douglas Crockford en su famoso artículo Prototypal Inheritance in JavaScript.

// funcin constructora intermediaria
function inherits(Child, Parent) {
    function I(){}
    I.prototype = Parent.prototype;
    Child.prototype = new I();
    Child.prototype.constructor = Child;
    Child.prototype.<strong>super</strong> = Parent;
}

function Hi(msg) {
    this.msg = msg;
}

Hi.prototype = {
    constructor: Hi,
    say: function (msg) {
        return this.msg + " " + msg;
    }
}

function MyHi(msg) {
    // llamamos al constructor de la class padre, 'Hi' a
    // traves del atributo '<strong>super</strong>', este atributo es creado
    // en nuestra funcin 'inherits'
    this.<strong>super</strong>.call(this, msg);
}
// heredamos de la clase 'Hi'
inherits(MyHi, Hi);

var hi = new MyHi("mundo");
console.log(hi.say("hola")); // mundo hola
console.log(hi instanceof Hi); // true

Nuestra función inherits nos permite heredar de otra clase sin tener que asignarle un objeto al atributo prototype, esto permite que si la clase padre tiene argumentos en su función constructora no tengamos que crear una instancia de esta sin tener estos argumentos.

Estático

Algo muy común en el modelo clásico de orientación a objetos es tener métodos estáticos o de clase y atributos estáticos o variables de clase, la misma naturaleza dinámica de JavaScript nos permite hacer esto tan solo asignando estos métodos y variables a la función constructora.

// funcin constructora intermediaria
function inherits(Child, Parent) {
    function I(){}
    I.prototype = Parent.prototype;
    Child.prototype = new I();
    Child.prototype.constructor = Child;
    Child.prototype.<strong>super</strong> = Parent;
}

function Hi(msg) {
    this.msg = msg;
}

Hi.prototype = {
    constructor: Hi,
    say: function (msg) {
        return this.msg + " " + msg;
    }
}

// mtodo esttico o de clase
Hi.hey = function () {
    return "hey, hey, hey!";
}

function MyHi(msg) {
    // llamamos al constructor de la class padre, 'Hi' a
    // traves del atributo '<strong>super</strong>', este atributo es creado
    // en nuestra funcin 'inherits'
    this.<strong>super</strong>.call(this, msg);
}
// heredamos de la clase 'Hi'
inherits(MyHi, Hi);

var hi = new MyHi("mundo");
console.log(hi.say("hola")); // mundo hola
console.log(hi instanceof Hi); // true
console.log(Hi.hey()); // hey, hey, hey!

Conclusión

Esto cubre en gran parte la herencia prototipal clásica en JavaScript, el lenguaje ha avanzado mucho en estos últimos años, por eso mismo existen formas nuevas de crear objetos, hablo de Object.create y sus amigos Object.defineProperty, Object.defineProperties, Object.getOwnPropertyNames, Object.getOwnPropertyDescriptor, Object.getPrototypeOf y demás.

En un próximo artículo estaré escribiendo de esto, para el siguiente articulo que haga creo que escribiré de como crear namespaces, módulos y de métodos y atributos privados.

Como serializar objetos en Objective-C?, NSCoding al rescate!, /o/

Serializar un objeto es como “detener el tiempo” sobre su estado, “escribimos en piedra” los datos
que este tenga, “escribir sobre piedra” puede ser en un archivo, una base datos (CoreData) o bien, en memoria. A la hora
de serializar objetos en Objective C usamos el protocolo NSCoding.

NSCoding nos obliga a implementar dos métodos de instancia encodeWithCoder: y initWithCoder:, cada método tiene la responsabilidad de codificar y decodificar sus propiedades, ok, y como podemos implementar esto?, así:

#import <Foundation/Foundation.h>

@interface Person : NSObject <NSCoding>

@property (strong, nonatomic) NSString *name;
@property (strong, nonatomic) NSString *address;
@property (strong, nonatomic) NSString *phone;

- (id)initWithCoder:(NSCoder *)aDecoder;
- (void)encodeWithCoder:(NSCoder *)aCoder;

@end
#import "Person.h"

@implementation Person

@synthesize name = _name;
@synthesize address = _address;
@synthesize phone = _phone;

- (id)initWithCoder:(NSCoder *)aDecoder
{
    if (self = [super init]) {
        self.name = [aDecoder decodeObjectForKey:@"name"];
        self.address = [aDecoder decodeObjectForKey:@"address"];
        self.phone = [aDecoder decodeObjectForKey:@"phone"];
    }

    return self;
}

- (void)encodeWithCoder:(NSCoder *)aCoder
{
    [aCoder encodeObject:self.name forKey:@"name"];
    [aCoder encodeObject:self.address forKey:@"address"];
    [aCoder encodeObject:self.phone forKey:@"phone"];
}

@end

Esta es la forma mas sencilla de implementar el protocolo NSCoding, agregamos a nuestra
implementación los dos métodos que nos obliga el protocolo, encodeWithCoder: y initWithCoder:, cada método codifica y decodifica
las propiedades de nuestro objeto, para esto usamos una instancia de NSCoder, pero, y que tal
si tenemos un objeto con muchas variables de instacia?, como hacer esto de forma automática?, pues bien, una de las ventajas
que tiene ObjC es su forma particular de acceder las propiedades de un objeto indirectamente, usando cadenas para
identificar sus propiedades, a esto se le llama Key-Value Coding.

Como traer una lista de todas las propiedades de nuestro objeto?, ObjC por medio de su “runtime” nos permite acceder a las propiedades
de nuestro objeto por medio de varias funciones, para este caso en particular usaremos la función class_copyPropertyList, al obtener la lista de propiedades de este objeto
podemos codificar y decodificar cada una de estas usando su nombre como llave (key) y su valor (value), como lo indica Key-Value Coding.

Modifiquemos el código anterior, ;-D.

#import <Foundation/Foundation.h>
#import <objc/runtime.h>

@interface Person : NSObject <NSCoding>

@property (strong, nonatomic) NSString *name;
@property (strong, nonatomic) NSString *address;
@property (strong, nonatomic) NSString *phone;

- (id)initWithCoder:(NSCoder *)aDecoder;
- (void)encodeWithCoder:(NSCoder *)aCoder;

@end
#import "Person.h"

@implementation Person

@synthesize name = _name;
@synthesize address = _address;
@synthesize phone = _phone;

- (id)initWithCoder:(NSCoder *)aDecoder
{
    if (self = [super init]) {
        unsigned int outCount, i;
        objc_property_t *properties = class_copyPropertyList([self class], &outCount);
        for (i = 0; i < outCount; i++) {
            objc_property_t property = properties[i];
            NSString *p = [NSString stringWithFormat:@"%s", property_getName(property)];
            [self setValue:[aDecoder decodeObjectForKey:p] forKey:p];
        }

        free(properties);
    }

    return self;
}

- (void)encodeWithCoder:(NSCoder *)aCoder
{
    unsigned int outCount, i;
    objc_property_t *properties = class_copyPropertyList([self class], &outCount);
    for (i = 0; i < outCount; i++) {
        objc_property_t property = properties[i];
        NSString *p = [NSString stringWithFormat:@"%s", property_getName(property)];
        [aCoder encodeObject:[self valueForKey:p] forKey:p];
    }

    free(properties);
}

@end

En nuestro header importamos <objc/runtime.h>, encodeWithCoder: y initWithCoder: copian la lista de propiedades de nuestro
objeto, por cada una de las propiedades de este se codifica o decodifica su valor usando su nombre como un NSString. De esta forma
dinámicamente podemos serializar y deserializar un objeto en ObjC.

Y como lo guardamos?, woot!, se me olvidaba, una vez que serializamos un objeto podemos guardarlo o “archivarlo” (NSKeyedArchiver) y “desarchivarlo” (NSKeyedUnarchiver), como en el campo de una tabla en CoreData:

AnEntity *anEntity = [NSEntityDescription
                        insertNewObjectForEntityForName:@"AnEntity"
                        inManagedObjectContext:context];
anEntity.personId = person.personId;
anEntity.data = [NSKeyedArchiver archivedDataWithRootObject:person];
anEntity.createdAt = [NSDate date];
Person *person = (Person *) [NSKeyedUnarchiver unarchiveObjectWithData:aRow.data];

Codificamos o serializamos una instancia del objeto Person en la columna data de la entidad AEntity, luego podemos decodificarla o
deserializarla.

+entityForName: could not locate an NSManagedObjectModel for entity name

Recientemente implemente CoreData en una app en la cuál estoy trabajando,
una aplicación basada en pestañas, así que en uno de mis ViewController necesitaba
salvar unos datos usando NSManagedObject, al principio Xcode me devolvía este error:

+entityForName: could not locate an NSManagedObjectModel for entity name 'CMFavorite'

Al parecer un error muy común cuando lo busque en Google, leyendo acerca de esto encontre
esta entrada, entonces revice si tenia algunas entidades adentro del NSManagedObjectModel, y de pronto BOOM!, NIL!,
que hacer?, que hacer?, el NSManagedObjectModel también era NIL!, arggghhhhh!, afortunadamente podemos traer una instancia de NSManagedObject desde nuestro AppDelegate, ;-), así que añadimos el siguiente "getter" para nuestra @property managedObjectContext en nuestro ViewController:

- (NSManagedObjectContext *)managedObjectContext
{
    if ( _managedObjectContext == nil) {
        _managedObjectContext = [[[UIApplication sharedApplication] delegate] performSelector:@selector(managedObjectContext)];
    }

    return _managedObjectContext;
}

Agregando este "getter" a nuestro ViewController nos aseguramos que el @property managedObjectContext no esté vació.

Ruby 1.9.1 on Windows

Hey,

There’s an easy way to install Ruby on Windows, the One-Click Ruby Installer for Windows, but this installer comes with  an older version of ruby (1.8.6), stable one is 1.9.1, so, if you go to the Ruby’s download page there’s a zip file for the version 1.9.1, well, this package doesn’t have installed the gems command and doesn’t come with some needed libs to start working with Ruby, so I create my own package with gems command, zlib, openssl, etc … here’s the list:

  • gems (latest gems version, rake, rails, activerecord-*, postgres-pr and others)
  • zlib 1.2.3
  • openssl 0.9.8h
  • gdbm 1.8.3
  • readline 5.0
  • pdc 3.4

Download my package from here.

Setting Up Zend Framework Environment On Windows

Hey!

This a litle tutorial to work with Zend Framework on Windows, at the end we going to set Apache with mod_rewrite and a vhost for our site, I’ll use XAMPP (which is a great WAMP) to setup all things needed like Apache + PHP + MySQL, etc, XAMP is great because it has a lot of extensions, like mod_rewrite for pretty ^^ urls, Xdebug, PDO, etc.

Enable mod_rewrite

So, first you need to download XAMPP from here, run the install and then go to the folder where you install it, default is: C:xampp.

Go to the apache folder, C:\xampp\apache, open the httpd.conf file (C:\xampp\apache\conf\httpd.conf), the first thing that we going to do is enable mod_rewrite, so search for mod_rewrite most of the time that line looks like: #LoadModule rewrite_module modules/mod_rewrite.so so uncomment that line LoadModule rewrite_module modules/mod_rewrite.so now start Apache on the XAMPP control panel and now you have mod_rewrite enabled.

Set a VHOST

I like work with vhosts, so I’ll show you how to do it on Windows, first thing is create a new host on our system, so go to C:\WINDOWS\system32\drivers\etc and open the hosts file, add something like this: 127.0.0.1 app.localhost this will be the url that we going to use to access our Zend Framework application.

Now add this host as an Apache VHOST, so, go to C:\xampp\apache\conf\extra and open the httpd-vhosts.conf uncomment #NameVirtualHost *:80 and add an Apache VHOST, something like this:

<VirtualHost *:80>
    ServerName app.localhost
    ServerAdmin my@mail.com
    DocumentRoot "D:\Projects\app\public"
    AddDefaultCharset UTF-8
    <Directory "D:\Projects\app\public">
        Options MultiViews -Indexes FollowSymLinks
        AllowOverride All
        <Limit GET POST OPTIONS>
            Order allow,deny
            Allow from all
        </Limit>
        <Limit PUT DELETE PATCH PROPPATCH MKCOL COPY MOVE LOCK UNLOCK>
            Order deny,allow
            Deny from all
        </Limit>
    </Directory>
</VirtualHost>

.htaccess

Zend Framework can work with mod_rewrite to create SEO compatible urls, so we going to set our .htaccess file on Windows, you know that you can’t set a file name like that one (.htaccess) because Windows say “You must type a file name” so we going to make some trick, click on Start -> Run and type cmd then go to your public folder in your Zend Framework application (or whatever your index.php file is), cd D:Projectsapppublic and then do: edit .htaccess or if you have already an htaccess file rename htaccess.txt .htaccess, this is what I have in my .htaccess file:

RewriteEngine on
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L]

Now type in your browser http://app.localhost and you can start working with Zend Framework with this tips on Windows :).