Curso de Desarrollo de Aplicaciones para Android 4.x

Destinatarios

Personas interesadas en la programación de aplicaciones sobre dispositivos móviles con Android.

Requisitos

  • Fundamentos de programación
  • Programación Orientada a Objetos
  • Programación Java
  • Bases de datos relacionales

Temario

Curso Básico de Objetive C: 1 Introducción a Xcode 5

Introducción a XCode 5

Lo primero que debemos saber a la hora de empezar con Objetive C es conocer el entorno de programación que necesitamos para hacer los desarrollos. 
Debido a que la finalidad de este curso es prepararnos para el Curso Básico de Desarrollo de Aplicaciones para iOS. Tenemos un sólo requisito técnico sobre el entorno de desarrollo:

  • Disponer de una máquina de Apple con Mac OSX instalado al menos en la versión 10.8.4
Este será nuestro mayor problema a la hora de iniciar el desarrollo porque la herramienta principal será Xcode 5 y sólo puede instalarse oficialmente en un Mac.

Instalación de XCode 5 [1]

Para instalar el Xcode lo podemos hacer desde la App Store:
Desde el buscados podremos encontrar la página del Xcode:

Pulsaremos en el botón verde de instalar la App, nos pedirá confirmación de compra, no te preocupes es gratuita e iniciará la descarga, son unos 1,9GB así que espera a que este disponible desde el Launchpad.
Una vez descargada para podremos arrancar el Xcode:
Como puedes ver se nos darán las opciones principales de crear un nuevo proyecto, enlazar a un repositorio o abrir proyectos recientes u otro proyecto.
Al pulsar sobre el botón de crear proyecto veremos lo siguiente:
 En el apartado de la Izquierda se pueden ver los distintos proyectos que podemos desarrollar tanto para iOS como para OS X.
En la parte de la derecha se nos mostrarán las opciones particulares para cada tipo de proyecto. 
De cara al curso nos centraremos por su simplicidad en las aplicaciones para OS X:
En este apartado vemos los tres tipos disponibles, para este curso utilizaremos la Command Line Tool como base para todos los proyectos. Esto simplificará la estructura de proyecto y la introducción de código.
Tras pulsar Next nos sale la pantalla de configuración del proyecto:
En ella deberemos rellenar:
  • El nombre del proyecto
  • El nombre de la organización
  • El Identificativo de la misma (deberá ser único en el mundo)
  • y el Tipo: Fundation
Pulsamos en Next  y nos saldrá el diálogo de guardar el proyecto:
Seleccionamos el directorio donde queremos guardar la carpeta del proyecto y pulsamos en Create.
A continuación veremos el interfaz de Xcode de gestión de proyectos:
Como podemos ver nos muestra todas las opciones del proyecto en la parte izquierda veremos el menú de proyecto, en la parte central las configuraciones del mismo y en la parte de la derecha las propiedades.
Esta estructura es muy compleja, así que nos centraremos en los apartados básicos de la misma. 
Al tener seleccionado el proyecto en la parte izquierda puede verse que debajo de él existen las carpetas:
  • una carpeta con el nombre del proyecto, que dentro tiene los ficheros del mismo
  • una carpeta frameworks donde veremos las bibliotecas y frameworks relacionados con el proyecto.
  • y una carpeta Products donde veremos el resultado de la compilación del proyecto, en nuestro caso un programa de linea de comandos. 

Estructura del proyecto

Si expandimos la carpeta del con el nombre del proyecto veremos lo siguiente:
Como podemos ver tenemos el fichero principal de nuestro programa main.m al seleccionarlo con el ratón veremos que la parte central del Xcode presentará el contenido del fichero:

Hola Mundo

Nos encontraremos con el siguiente texto:
//
//  main.m
//  ejemplo001-base
//
//  Created by pepesan on 12/10/13.
//  Copyright (c) 2013 pepesan. All rights reserved.
//
#import <Foundation/Foundation.h>
int main(int argc, const char * argv[])
{
    @autoreleasepool {
        
        // insert code here…
        NSLog(@”Hello, World!”);
        
    }
    return 0;
}

Dentro de este fichero destacan 3 apartados principales:

  • La cabecera con los comentarios
  • El import de las clases fundaciones de Objective C
  • La función principal del programa, donde vemos la directiva @autorelease que es la que nos va a permitir liberar los recursos de la aplicación una vez terminada.
  • La llamada a NSLog(), que nos permite una salida por consola. 
Como detalle curioso en Objective C todos los literales de cadenas de caracteres deben ir precedidos de un @.

 Compilación y ejecución del Proyecto

Una vez realizado el desarrollo como siempre debemos compilar y ejecutar el proyecto, para lo cual tenemos varias opciones:
  • Mediante el botón de Play que está presente en la barra superior a la izquierda
  • Mediante la combinación de teclas Comando + r

 una vez compilado el proyecto debería salir en la parte superior central de la ventana un mensaje de que la compilación ha sido un éxito:

Por otro lado habrá ejecutado el proyecto y deberíamos tener una salida en la consola, en la parte inferior central de la ventana:

Donde debería aparecer el mensaje del Hola Mundo.
Si en algún momento deseas parar la ejcución de un programa puedes hacerlo pulsando en el botón de stop o con la combinación te teclas Comando + . (esto es un punto no el final de línea 🙂 ).

Depuración en Xcode

Una de la tareas típicas en la codificación es el tratar de resolver errores en la compilación o la ejecución del programa.
Xcode es una buena herramienta en este aspecto ya que nos ayuda a la resolución de estos errores de código. Para ello en la edición del fichero se nos muestran en la parte lateral izquierda del área círculos rojos o triángulos de alerta en cada línea que incluye un error o aviso respectivamente:

Como puede verse en la captura vemos que hay errores y en la misma línea nos indica el error.
Una vez arreglado el código los errores visualmente desaparecerán:

Algunas veces esto no es suficiente para arreglar los errores, ya que será debido a fallos en ejecución de la aplicación. Para ello necesitaremos el uso de los BreakPoints.
Los breakpoints nos permitirán parar la ejecución de la aplicación en un determinado punto, indicando sobre una línea de código dicho punto de ruptura.
Para ello necesitaremos  hacer click en el número de línea donde queramos colocar el breakpoint, y nos debería aparecer un resaltado en azul sobre la misma:

Al ejecutar la aplicación deberá parar en dicho breakpoint:

En la parte inferior central debería aparecer la consola y el inspector de variables con las opciones de depuración:

Como puede verse la captura en la parte de la izquierda, están representadas las variables involucradas en el método que se está ejecutando en ese momento y su valor. Y encima de las variables podemos observar los botones típicos de acción en la depuración, que continúan normalmente con la ejecución, el paso a paso, etc…
También la parte de la izquierda nos aparecerá seleccionado el tercer icono de la barra empezando por la derecha y nos indicará información sobre el uso de CPU, el consumo de memoria y los hilos en ejecución:

Ejercicios

  1. Instala en Xcode en tu ordenador.
  2. Crea un nuevo proyecto de MacOSX tipo Aplicación/Línea de Comando/Foundation.
  3. Ejecuta tu nuevo proyecto.
  4. Coloca un pequeño bucle en el código y depura la línea que muestre en pantalla el valor de la variable i que recorra el índice. 

Referencias

Licencia Creative Commons

Curso Básico de Objetive C

Curso Básico de Objective C

En este curso trataremos de explicar el funcionamiento de la plataforma Xcode y el lenguaje de programación Objetive C, desde la perspectiva de un programador de aplicaciones web con conocimientos en programación orientada a objetos (POO) y bases de datos relacionales (BBDD).

Temario

Licencia Creative Commons

Curso de desarrollo de módulos con Drupal 7 (IX): Creación y gestión de Entidades (Parte I)

Como siempre crearemos un nuevo módulo pero esta vez definiremos una entidad que manejaremos desde Drupal. Este caso es un poco más complejo que el de la creación de un nuevo tipo de contenido, debido a que deberemos realizar todas las funcionalidades de gestión de información para esta nueva entidad.
Crearemos un carpeta para el módulo llamada “entity_example” y un nuevo fichero .info con el siguiente contenido:

; $Id: ajax_example.info,v 1.3 2010/08/11 23:16:27 rfay Exp $

name = Ejemplo de Entidad
description = Módulo de ejemplo que muestra como usar el API de Entidades de Drupal
core = 7.x
package = Modulos de ejemplo
files[] = entity_example.module
files[] = entity_example.install

Definiendo el Modelo de la BBDD

Como se vió en la tercera entrega es posible definir un esquema de bbdd para que nuestro módulo disponga de un conjunto de tablas y campos sobre los que manejar la información que necesita gestionar. Generamos un nuevo fichero entity_example.install, pero esta vez sólo tendremos la implementación de hook_squema():

<?php
// $Id$

/**
 * @file
 * Install/Update/Uninstall functions for entity_example module.
 */

/**
 * Implements hook_schema().
 *
 * @see hook_schema()
 * @link schemaapi Schema API @endlink
 */
function entity_example_schema() {
  $schema[‘example_entity’] = array(
    ‘description’ => ‘The base table for example entity’,
    ‘fields’ => array(
      ‘eeid’ => array(
        ‘description’ => ‘The primary identifier for a entity.’,
        ‘type’ => ‘serial’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
      ),
      ‘title’ => array(
        ‘description’ => ‘The title of this entity, always treated as non-markup plain text.’,
        ‘type’ => ‘varchar’,
        ‘length’ => 255,
        ‘not null’ => TRUE,
        ‘default’ => ”,
      ),
      ‘perm’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘size’ => ‘tiny’,
        ‘description’ => ‘Whether the example entity is permanent(1) or not(0).’,
      ),
      ‘dstart’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘Start date of example entity. Format: Ymd’,
      ),
      ‘dend’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘End date of example entity. Format: Ymd’,
      ),
      ‘weight’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘The weight of this example entity.’,
      ),
    ),
    ‘primary key’ => array(‘eeid’),
    ‘indexes’ => array(
      ‘perm’ => array(‘perm’),
      ‘dstart’ => array(‘dstart’),
      ‘dend’ => array(‘dend’),
    ),
  );
  return $schema;
}

Como podemos ver en modelo es sencillo:

  • Campos:
    • eeid: numero entero, sin signo, no puede ser null y clave primaria de la tabla
    • title: varchar de 255 caracteres que almacenará el título
    • perm: entero pequeño (tiny) que almacena valores 0 y 1
    • dstart y dend: fecha inicio y fin 
    • weigth: peso de la entidad.
  • Clave primaria: campo eeid
  • indices:
    • perm
    • dstart
    • dend

Hasta aquí el modelo está definido, cuando se active el módulo se generará la tabla ‘example_entity’ con las especificaciones que le hemos definido.

Añadir Permisos, hook_permission()

Ahora añadiremos el fichero .module donde colocaremos el resto del código del módulo.
Debido a que estamos manejando una nueva entidad será necesario aplicar nuevos permisos con el módulo para así poder controlar mejor que operaciones pueden realizar los usuarios. Para ello utilizaremos el hook_permission().  aquí tenemos un ejemplo de uso para el módulo:
/**
 * Implements hook_permission().
 */
function entity_example_permission() {
  return array(
    ‘administer example entity’ =>  array(
      ‘title’ => t(‘Administer example entity’),
      ‘restrict access’ => TRUE,
    ),
  );
}
Como puede verse el hook debe devolver un array asociativo con un elemento para cada nuevo permiso. En este caso es “administer example entity”, donde configuramos que su valor es otro array con el título (title) y si restrigiremos el acceso a la funcionalidad (restrict access), que en este caso lo haremos.

Definición de la entidad: hook_entity_info()

La definición de la entidad se realiza a través del hook_entity_info(), veamos un ejemplo de implementación para este módulo:
/**
 * Implementa hook_entity_info().
 */
function entity_example_entity_info() {
  $return = array(
    ‘entity_example’ => array(
      ‘label’ => t(‘Example entity’),
      ‘base table’ => ‘example_entity’,
      ‘uri callback’ => ‘entity_example_uri’,
      ‘fieldable’ => TRUE,
      ‘entity keys’ => array(
        ‘id’ => ‘eeid’,
      ),
      ‘bundles’ => array(
        ‘entity_example’ => array(
          ‘label’ => t(‘Example entity’),
          ‘admin’ => array(
            ‘path’ => ‘admin/structure/entity_example’,
            ‘access arguments’ => array(‘administer example entity’),
          ),
        ),
      ),
    ),
  );
  return $return;
}
Como puede verse se devuelve un array asociativo son los datos principales de las entidades que queremos definir. En este caso se está definiendo la entidad ‘entity_example’ como índice del array principal. Dentro del array que define cada entidad nos encontramos con los siguientes campos:

  • label: etiqueta principal
  • base_table: nombre de la tabla que gestiona la entidad
  • uri callback: nombre dela función que sabe manejar las URL’s de la entidad, nos permitirá pasar por URL la entidad que manejamos.
  • fieldable: booleano que define si la entidad es manejable mediante campos (Field API)
  • entity keys: array de claves primarias de la entidad, en este caso es el campo eeid
  • bundles: conjuntos de entidades que queremos gestionar, en este caso solo daremos una de alta correspondiendo a la entidad que hemos dado de alta ‘entity_example’
    • nombre_entidad: aqui referenciamos el bundle con la entidad
      • label: etiqueta de la entidad para el bundle
      • admin: array con los datos de la administración del bundle para la entidad
        • path: rura de acceso a la administración
        • access arguments: array de permisos necesarios para la gestión de la entidad

A continuación debemos programar la función que permite manejar las rutas de la entidad para Drupal:
/**
 * Entity uri callback.
 */
function entity_example_uri($entity_example) {
  return array(
    ‘path’ => ‘entity_example/’ . $entity_example->eeid,
  );
}
Como puede verse nos pasan la entidad entera y devolvemos el path con el ID de la entidad que nos pasan en el campo “path” concatenado con la rura principal “entity_example/”.
Tambiñen deberemos sobreescribir el hook_admin_paths(), para que funcionen correctamente las rutas de edición de entidades:
/**
 * Implements hook_admin_paths().
 */
function entity_example_admin_paths() {
  $paths = array(
    ‘entity_example/*/edit’ => TRUE,
  );
  return $paths;
}
 De esta manera cambiaremos algunos paths administrativos del módulo, en concreto el que tiene que ver con la edición de elementos de la entidad.
Esto se entenderá mucho mejor cuando veamos los enlaces generados con el hook_menu().

Entradas del menú para hacer el CRUD

Como se ha mencionado anteriormente será necesario dar de alta todas las funcionalidades de la gestión de la nueva entidad y sus enlaces en el menú, como siempre, lo haremos a través del hook_menu():

/**
 * Implements hook_menu().
 */
function entity_example_menu() {
  $items[‘entity_example/%entity_example’] = array(
    ‘title’ => ‘Example entity’,
    ‘title callback’ => ‘entity_example_page_title’,
    ‘title arguments’ => array(1),
    ‘page callback’ => ‘entity_example_page’,
    ‘page arguments’ => array(1),
    ‘access arguments’ => array(‘access content’),
    ‘type’ => MENU_CALLBACK,
  );
  $items[‘entity_example/%entity_example/view’] = array(
    ‘title’ => ‘View’,
    ‘type’ => MENU_DEFAULT_LOCAL_TASK,
  );
  $items[‘entity_example/%entity_example/edit’] = array(
    ‘title’ => ‘Edit’,
    ‘page callback’ => ‘drupal_get_form’,
    ‘page arguments’ => array(‘entity_example_form_edit’, 1),
    ‘access arguments’ => array(‘administer example entity’),
    ‘type’ => MENU_LOCAL_TASK,
    ‘weight’ => 10,
  );

  $items[‘admin/structure/entity_example’] = array(
    ‘title’ => ‘Example entities’,
    ‘description’ => ‘Manage example entities on your site.’,
    ‘access arguments’ => array(‘administer example entity’),
    ‘page callback’ => ‘entity_example_page_admin’,
    ‘page arguments’ => array(‘list’),
    ‘weight’ => -10,
  );

  $items[‘admin/structure/entity_example/list’] = array(
    ‘title’ => ‘List’,
    ‘type’ => MENU_DEFAULT_LOCAL_TASK,
    ‘weight’ => -10,
  );

  $items[‘admin/structure/entity_example/create’] = array(
    ‘title’ => ‘Add example entity’,
    ‘page arguments’ => array(‘create’),
    ‘access arguments’ => array(‘administer example entity’),
    ‘type’ => MENU_LOCAL_ACTION,
  );

  return $items;
}

Como podemos ver estamos gestionando muchos enlaces, así que explicaremos uno a uno su significado para entender mejor su funcionamiento, en la siguiente entrega.

Referencias:

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!

Archivos

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