Curso de iOS7: IBOutlet e IBAction

Introducción

Unos de los patrones principales que ya comentamos en el tema de Patrones de Diseño fue el de Target-Action. Este concepto puede ejemplificarse con el uso de los IBOutlet e IBAction. Veremos a continuación cómo utilizarlos en el Xcode5 en una aplicación iOS7.

IBOutlet

Este tipo de patrón nos va a permitir relacionar objetos que hay definidos en la vista, con propiedades que definamos en el código de la clase del ViewController que tengamos asignada a dicha Escena.

Empezaremos como siempre con una Simple View Applicaction, si tienes dudas consulta el tema de Mi Primera Aplicación iOS y nos encontraremos con un View Controller vacío:

A continuación buscamos una label en el inspector de objetos:

Escribimos label en el filtrador de objetos:

y nos aparecerá la label en el inspector:

La arrastramos al View Controller de nuestra aplicación:

De esta manera aparecerá la etiqueta dentro de nuestra escena.
Seleccionamos la etiqueta y nos aparecerán sus atributos en el inspector:

Ahora es cuando debemos relacionar esta vista con el código. Para empezar debemos asegurarnos de que el View Controller del storyboard tiene asignado una clase View Controller. Para ello deberemos seleccionar el View Controller desde el Storyboard, bien desde los detalles de la escena:

O bien desde la vista de la escena, huso debajo de la pantalla de la escena, en el botón amarillo:

de ambas maneras podemos ver que en la vista de la escena el view controller nos aparece seleccionado en color azul:

Así en la parte de la derecha en el Identity Inspector tendremos lo siguiente:

Com podemos ver en la captura veremos que el campo class está rellenado y nos indica el nombre de la clase ViewController, por lo que es cierto que esta escena tiene un ViewController asignado y podemos relacionar esta escena con su código.

A continuación deberemos cambiar el modo de vista de edición para poder disponer al lado izquierdo la escena y a la derecha el código de la clase, preferiblemente el fichero de cabecera de la misma. Para ello pulsamos en el botón del Assistant Editor, que tenemos arriba a la izquierda de la ventana:

Esto nos permitirá dividir la pantalla de edición en dos:

Com podemos ver en la parte derecha está seleccionado el fichero de implementación por lo que deberemos cambiarlo al fichero de cabecera para ello seleccionaremos en la parte superior de la ventana del código para cambiar de fichero:

Como podemos ver en la captura la parte superior funciona como un selector de ficheros, dependiendo del que seleccionemos así nos parecerá en el editor uno u otro fichero. En este caso seleccionamos en de cabecera por lo que debería aparecernos algo similar a esto:

Como puede verse es el fichero de cabecera vacío.

Ahora es cuando debemos relacionar la vista, en este caso una label, una etiqueta como una propiedad de la clase ViewController. Para ello con a vista seleccionada y con el control pulsado arrastramos y soltamos la vista en el código:

Como puede verse en la captura nos aparece una línea de color azul cuando la arrastramos y debemos situarla entre el @interface y el @end. Nos aparece dentro del código una linea azul con un círculo en la parte izquierda de la línea, indicándonos donde se colocará el código generado. Al soltar nos debería aparecer el siguiente diálogo contextual:

Veamos los campos en detalle:

  • Connection: indicamos el tipo de conexión con la vista, en este caso nos interesa Outlet, pero podemos encontrar también Action (que veremos más adelante)
  • Objecto: nos aparece ya seleccionado View Controller
  • Name: el nombre que queremos darle a la propiedad, por ejemplo etiqueta
  • Type: tipo de vista del objeto
  • Storage: atributo que le asignaremos a la propiedad, aquí podemos dejar Strong.

Una vez puesto el nombre de la propiedad pulsamos en el botón Connect y debería aparecernos lo siguiente en el código de la clase:

@property (strong, nonatomic) IBOutlet UILabel *etiqueta;

Como puede verse se ha declarado automáticamente una nueva propiedad del tipo UILabel. Todas las Vistas empezarán por UI, con el nombre indicado. Además nos coloca la palabra reservada IBOutlet  delante del tipo del dato. Esta palabra permite a esa propiedad ser relacionada con un elemento en la vista.
Pongo captura para que veamos un pequeño detalle:

Como puede verse en la captura aparece un círculo al lado de la línea de la propiedad de la clase y si pasamos el ratón por encima de ella veremos que se selecciona la etiqueta relacionada.

Otra manera de comprobar que esta relación existe es desde la vista de conexiones. Por ejemplo si seleccionamos la label desde la escena, veremos lo siguiente:

Como puede verse la propiedad etiqueta aparece conectada con el ViewController. Si pulsáramos en la X que sale a la derecha del View Controller quitaríamos esa conexión.

Si seleccionamos el View Controller desde la escena, veremos lo siguiente en el Inspector de Conexiones:

Como puede verse hay un resumen de Outlets relacionados con propiedades dentro del View Controller. Nos aparecen tanto la propiedad de la etiqueta relacionada con la Label de la escena, como la view, propiedad intrínseca de todo View Controller relacionada con el View de la Escena.

Debemos tener mucho cuidado con que las vistas estén relacionadas correctamente con las propiedades de la clase, porque si esto no lo realizamos correctamente, puede darse el caso de que la aplicación no arranque correctamente. Sobre todo debemos tener mucho cuidado si cambiamos los nombres de las propiedades de la clase sin haber cambiado también la relación con la vista.

Existe otra manera a la hora de relacionar propiedades con elementos en la vista, pero esta manera explicada es la más rápida.

Nota: Toda vista que tengamos que modificar desde código deberá ser un IBOutlet

IBAction

De la misma manera que hemos creado un Outlet vamos a intentar generar un IBAction. Los IBAction será la manera que tengamos de modificar comportamientos ante eventos que se puedan disparar en la pantalla. Por ejemplo pulsar en un botón. El comportamiento por defecto al pulsar un botón en iOS es no hacer nada. Pero si queremos modificar ese comportamiento debemos asociar una funcionalidad al Evento de pulsar el botón.

Para poner un ejemplo debemos seguir los mismos pasos que hemos realizado anteriormente para añadir un botón.

Busca el botón en el inspector de objetos:

Arrastralo a la Escena:

Cambiale el title (texto que sale en el botón) en sus atributos y ponle por ejemplo, Pulsame:

Quedará algo similar a esto:

Ahora con la Vista dividida, y teniendo seleccionado en la derecha el fichero de cabecera de la clase, arrastra con el control pulsado el botón a la vista de código:

De la misma manera que hicimos con el IBOutlet nos sale una línea azul cese la vista hasta el código, según lo arrastramos y nos sale una línea azul indicando donde aparecerá el código generado dentro del fichero de la clase. Una vez soltamos nos sale el diálogo de creación de una conexión:

Veamos en detalle los campos, una vez seleccionamos en el Connection-> Action:

  • Connection: dejamos selecionado Action
  • Object: vemos que esta puesto View Controller
  • Name: nombre del método que crearemos en la clase para que se ejecute cada vez que se dispare el evento sobre esa vista, en este caso pulsa
  • Type: tipo del dato que nos envían al invocar el método, en este caso id. Como ya vimos en el Curso de Objective C, id representa un puntero a un objeto.
  • Event: Evento que queremos relacionar con el método. O dicho de otro modo el evento que va a disparar el comportamiento especial que estamos programando. En este caso dejaremos Touch Up Inside, que es lo más parecido al Click del botón.
  • Arguments: aquí dejaremos seleccionado Sender, que será el nombre del objeto que nos pasen por parámetro al método.
Después pulsaremos en Connect y nos aparecerá lo siguiente en el fichero de cabecera:
– (IBAction)pulsado:(id)sender;

Como en el anterior caso pongo captura del código generado y su conexión.

Como puede verse al pasar el ratón por encima del círculo de la línea de código del IBAction también se resalta en la escena la Vista conectada.
Y seleccionando el View Controller en la escena, en el inspector de Conexiones sale lo siguiente:
Como puede verse se relaciona el nombre del método con el botón Pulsame con el Evento Touch Up Inside.
Para cambiar al modo normal de edición sólo debemos seleccionar el botón de Editor Standart:
También se nos ha debido generar una nueva implementación del método en el fichero de implementación de la clase, si lo seleccionamos, ahora debería aparecer en el editor algo similar a esto:
– (IBAction)pulsado:(id)sender {
}
Pongo captura porque aquí también aparece el círculo al lado de la implementación:
Ahora es cuando tocaría realizar algo con esta implementación. Por ejemplo saquemos un mensaje por consola, con un NSLog:
– (IBAction)pulsado:(id)sender {
    NSLog(@”Ha pulsado el botón!”);
}
De esta manera si ejecutamos la aplicación con Comando + R, veríamos algo similar al esto cuando pulsemos el botón:

Curso de iOS7: Instruments

Instruments

Instruments es la herramienta de profiling (análisis de rendimiento) integrada en Xcode. Esta herramienta nos permitirá optimizar el rendimiento de nuestra aplicación así como detectar fallos en la aplicación.

Funcionalidades

Las funcionalidades principales de la aplicación Instruments son las siguientes:
  • Recolectar información de la aplicación
  • Analizar los procesos de asignación de memoria
  • Realizar búsquedas de fugas de memoria (memory leaks).
  • Localizar problemas de rendimiento.
  • Medir la Entrada/Salida.
  • Automatizar pruebas de interfaz.

Como entrar a Instruments

Desde la ventana principal de Xcode pulsamos Comando+I o desde el menú Product->Profile y nos aparecerá la siguiente pantalla:
Como puede verse lo que nos pregunta es el tipo de análisis que queremos realizar. Una vez elegido pulsamos en el botón profile y nos aparece una pantalla similar a la siguiente:

Partes de la interfaz

Empezaremos por los controles principales:
Como puede verse es una pantalla similar en interfaz a la que tenemos en el Xcode. De esta manera podemos ver los controles de arranque y parada del análisis:
El principal será el botón de grabación que es el que nos permitirá arrancar y parar la aplicación para empezar el análisis.
En la parte izquierda podemos ver el área de perfiles:
En esta caso como sólo estamos analizando los tiempos de ejecución sólo disponemos de un perfil seleccionado:
En la parte inferior en donde podemos ver en detalles cada uno de los elementos que tienen que ver con el perfil seleccionado:
En este caso podemos ver las distintas llamadas a función que hacemos en la aplicación, ordenadas por su tiempo de ejecución en la parte derecha y en la parte izquierda los menús de selección de llamadas.
Por otra parte nos permite ver también el detalle de dichas llamadas en la parte de la derecha:
En posteriores tema veremos como utilizar esta herramienta para distintos usos.

Referencias

Curso de iOS7: El Storyboard

Introducción

El Storyboard es lo más parecido que tiene Xcode para la definición y configuración de la Vista de nuestra aplicación. En anteriores versiones de iOS cada pantalla se configuraba independientemente. De una manera bastante similar a lo que hacemos a día de hoy en Android con los Layout.
Pero a partir de ahora los proyectos nuevos de iOS7 se configuran automáticamente para hacer uso del Storyboard como medio principal de configuración de la Vista de nuestra aplicación.

El Storyboard nos va a permitir gestionar una serie de elementos:

  • Escenas (Scenes): cada escena será la configuración de una pantalla de nuestra aplicación.
  • Escena Inicial: la Escena que esté indicada con una flecha que no parte de ningún sitio será la primera que se ejecute al lanzar la aplicación.
  • Segues: Son las flechas que conectan las distintas escenas, que nos permitirán realizar saltos entre entre escenas. Normalmente al pulsar sobre un elemento.
  • Storyboard id: identificativos que nos permiten distinguir entre distintos elementos dentro del Storyboard. Dichos identificativos deben de ser únicos dentro de cada tipo de elemento.
  •  Vista (view): Cada escena tendrá una vista principal asociada, donde podremos colocar todos aquellos elementos que conformen la escena.
  • Subvistas: otras vistas que están integradas o “están dentro” de la vista principal. De esta manera podemos disponer de una jerarquía de objetos vista, dependiendo de quienes sean los hijos de la vista principal.
  • View Controller: Clase controladora de una Escena.

Interface Builder

El interface Builder es la herramienta integrada en el Xcode que nos permitirá editar tanto el Storyboard como cada una de las escenas individuales. Cuando pulsamos sobre el Main.storyboard de un proyecto recién creado, veamos como se ve:

El area de edición

Veamos las distintas partes con más detalle. Empezando por el área de edición:

Como podemos ver en la captura, en la parte izquierda tenemos la jerarquía de objetos de la escena:

En el primer nivel tenemos la escena y dentro de ella tenemos una serie de elementos, el principal de todos ellos es el View Controller, que es el que contiene la estructura de la escena a nivel de vistas, incluida la View principal que es la que contendrá todas aquellas subvistas que queramos que se visualicen en la vista principal de la escena.

En el ejemplo hemos incluido una Label, una etiqueta que puede contener un texto en pantalla y una serie de Constraints que permiten definir parámetros de presentación.

Esta jerarquía puede mostrarse u ocultarse a través de un botón presente en la parte inferior derecha de la representación visual de la Escena:

 Pulsando el botón puedes ocultar o mostrar el panel lateral de la jerarquía.

Centremonos ahora en la vista de representación de la escena:

Aquí es donde podremos gestionar visualmente todas las vistas que tenemos dentro de la escena.
Veamos un poco en detalle las opciones que tenemos en la parte inferior derecha, empezando por:

Este botón nos permitirá cambiar el tamaño de la visualización de la escena para ir cambiando alternativamente el tamaño de la pantalla de un iphone de 4 pulgadas a uno de 3,5 pulgadas. De esta manera seremos capaces de ver cómo se verá el diseño de la escena en ambos tamaños de pantalla.

En estas opciones que podemos ver en esta captura tenemos las que nos permiten resolver, de izquierda a derecha, la alineación, el espaciado, temas que tengan que ver con el autolayout y la redimensión de vistas dependiendo de la resolución de pantalla.

Y por último tenemos las opciones de zoom:

Que nos permitirán ampliar igualar o reducir el área visualizada.

El área de propiedades

En la parte de la derecha podemos observar lo siguiente:
Com podemos ver en la captura tenemos dos partes, empezando por el área de atributos de la vista seleccionada:
Como se puede observar disponemos de los atributos del objeto seleccionado.
Por otra parte tenemos la biblioteca de objetos:

Desde aquí podremos añadir nuevos elementos a la escena y al Storyboard.
Todos aquellos que se denominen Controller manejarán escenas nuevas. Los demás representarán vistas que podremos añadir a las escenas.
El View controller es el que nos permitirá añadir una nueva escena vacía similar a la que tenemos cuando creamos un proyecto del tipo Single View Application.

Referencias 

Curso de iOS7: Patrones de Diseño

Una de las cualidades de cualquier framework o SDK es que debemos utilizar los patrones de diseño que nos ofrecen, para así facilitarnos la vida a la hora de implementar una app.

Dentro del SDK de iOS no es una excepción, tenemos unos patrones de desarrollo claros, pasemos a enumerarlos:

MVC 

El Modelo Vista Controlador: es uno de los principales paradigmas actuales en la programación, se trata de separar el código según su funcionalidad:

    • Modelo: clases y objetos encargados de gestionar el acceso a la información.
    • Vista: Clases, objetos y configuraciones dedicados a la interfaz del usuario.
    • Controlador: clases y objetos que permiten realizar el control del la aplicación.

Reglas de codificación

Este modelo permite la separación del código y tenemos que seguir una serie de reglas en la codificación:
  • El controlador carga la vista y el modelo.
  • La Vista no puede acceder directamente al modelo.
  • La Vista no tiene porque conocer quien es su controlador, para que se puede reutilizar mejor.
  • El controlador debe manejar los eventos que se generen desde la vista. 

Eventos

Cualquiera de las interacciones realizadas por el usuario generará un evento en la aplicación. Por ejemplo que el usuario haga click sobre un botón, esto generará un evento. 
Existirá un comportamiento predeterminado por parte del sistema.  en el ejemplo del click de botón, es no hacer nada 🙂
Como programadores podemos cambiar los comportamientos ante un evento disparado, esto en programación se suelen llamar manejadores(handlers).

Target-Action

Este patrón es uno de los que permitirá que desde la vista se se puedan invocar manejadores del eventos presentes en el controlador.  Es decir relacionar un evento de un objeto de la vista con una acción o método de un controlador. La relación será entre el objeto-el evento(target)-y la acción (action).


Como se puede ver en la imagen prestada, se relaciona el botón de save (guardar) con una función de un controlador en el código.
En el presente curso indicaremos cómo relacionar el target y la acción.

Delegación

Una de las cuestiones a la hora de programar interfaces gráficas en la necesidad de la definición de “cómo funcionan las cosas”. Como ya estuvimos comentando en el Curso básico de Objective C, tenemos dos elementos en la programación que debemos tener en cuenta, los protocolos y los delegados.
Los protocolos son un conjunto de funcionalidades que deben ser implementadas para poder hacer que un componente software pueda funcionar tal como se diseñó. 
En la programación Cocoa y. específicamente en Cocoa Touch, la biblioteca gráfica de iOS, hay muchos componentes visuales pertenecientes a la biblioteca UIKit, que definen esos protocolos y deberemos de ser nosotros los que debemos implementar dichas funcionalidades en nuestros Controladores. 
Así mismo en los proyectos deberemos configurar que clase o componente será el responsable de la implementación de dicho protocolo para un componente visual, esta clase que implemente dichas funcionalidades será el Delegado.
Licencia Creative Commons

Suscríbete al Boletín

Si quieres estar al tanto de las novedades del blog, ya sabes :)
* = campo obligatorio

powered by MailChimp!

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información. ACEPTAR

Aviso de cookies