Creo que es más claro con un ejemplo:

1
2
3
4
5
6

<select id="animales">
  <option value="1" data-type="perro">Caniche</option>
  <option value="2" data-type="gato">Siamés</option>
  <option value="3" data-type="gato">Persa</option>
  <option value="3" data-type="perro">Pastor alemán</option>
</select>

En el segundo despegable mostraremos los diferentes tipos de comida según si hemos seleccionado un perro o un gato. En este caso nos da igual la raza, solo queremos saber que tipo de animal es.

Como se puede ver, he añadido el atributo data-type a cada option del select con el tipo de animal que es. Este valor personalizado lo podemos obtener fácilmente con jQuery tal que así:

1
2
3
4
5
6
7
8

$(function(){
    $('animales').change(function(){
       var seleccionado = $(this).find('option:selected');
       // 'type' es lo que va a continuación del guión en data-type
       var animal = seleccionado.data('type');
       ...
    });
});

También podemos acceder a este valor con Javascript básico:

1
2
3

var animales = document.getElementById('animales');
var seleccionado = animales.options[animales.selectedIndex];
var animal = seleccionado.getAttribute('data-type');

Ahora ya podremos generar el segundo desplegable con los diferentes tipos de comida según el tipo de animal que hemos seleccionado.

Más información sobre los atributos DATA de HTML5: HTML5 Custom Data Attributes (data-*)

Nuestro objetivo cuando llegamos a casa y hemos terminado de trabajar para la empresa, es aprender o profundizar en nuevos temas que nos llaman la atención y aprender: un nuevo lenguaje de programación, esa nueva herramienta que ha visto la luz, algún proyecto personal, etc. Pero no nos gusta que se aprovechen de nosotros en base a nuestras inquietudes. Si quieres que tu equipo técnico trabaje con una determinada herramienta o framework, quieres que las webs se maqueten en html5, etc. no te aproveches del programador de turno que se ha interesado en su tiempo libre por ello. ¿Por qué no dedicar una hora al día en aprenderlo en horario laboral?

Cuando me compré un móvil con Android (mi querida HTC Magic) no tardé ni dos días en investigar y aprender a programar para ella. No sabía mucho JAVA, así que en menos de dos meses me leí dos libros sobre JAVA y realicé muchos tutoriales y manuales de Android. Logré desarrollar alguna aplicación para Android como la de Cercanías Renfe. Todo esto por mi cuenta y en mi tiempo libre, privándome de otras cosas o actividades de ocio (que sí, que las tenemos). Mi empresa por aquel entonces se aprovechó de esta circustancia y se decidió programar una aplicación para Android. No había dedicado ni un solo segundo en horario laboral a aprender a programar para Android y jamás recibí un “gracias”, alguna palabra de motivación o beneficio (y no todo es dinero). Todo lo contrario, en una ocasión tuve que escuchar que la aplicación se había programado en Android y no en iPhone por el simple hecho de que para Android era mucho más fácil. Mentira… Si me hubiese comprado un iPhone y me hubiese puesto a programar para él (en mi tiempo libre, insisto), la app se hubiese desarrollado para iPhone. Luego dirán que no hay talento, que la gente no quiere trabajar, que los empleados no se comprometen con la empresa, etc.

¿A qué viene ahora todo esto? En mi empresa actual hay especial interés en desarrollar aplicaciones para iPhone. ¿Resultado? Me dan un MacBook Air en usufructo y yo aprendo en mi tiempo libre (además de una formación). Yo encantado (como loco por la oportunidad de aprender algo nuevo) ya que de otra forma no podría hacerlo (no me puedo permitir comprar un Mac) y la empresa más de lo mismo ya que sacará beneficio de ello, siendo un nuevo producto que se puede ofrecer a los clientes. El programador también gana en confianza y se siente más integrado en la empresa, sabiendo que se valora su trabajo y su esfuerzo no solamente durante las horas de oficina. Yo no tendría dudas en intentar proponer todas las cosas nuevas que aprenda (siempre que merezcan la pena), así como sugerir proyectos, etc.

En realidad es muy fácil hacer las cosas bien y valorar el trabajo de tus programadores. No somos “monos picateclas” que nos pueden sustituir por otro “mono”. Si la base de tu empresa es tecnologíca, no puedes descuidar a tus programadores. Después es muy fácil quejarse.

Espero pronto decir que soy un iPhone developer También supongo que escribiré algún post sobre mis comienzos con esta plataforma y el lenguaje de programación Objective-C con la idea de que le sea de utilidad a alguien.

Deberemos modificar el formulario y añadirle un par de opciones más. En este ejemplo, vamos a relacionar un usuario con su país.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

namespace Acme\MiBundle\Form;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;
 
class PerfilType extends AbstractType {
 
    public function buildForm(FormBuilder $builder, array $options)
    {
        $builder->add('pais', 'entity',
            array(
                'class' => 'AcmeMiBundle:Pais'
                'label' => 'Pais',
            )
        );
    }
}

Que no se nos olvide añadir el método __toString() a la entity Pais:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

namespace Acme\MiBundle\Entity;
 
use Doctrine\ORM\Mapping as ORM;
 
class Pais
{
 
    [...]
 
    public function __toString()
    {
        return $this->getNombre();
    }
}

Y así de sencillo, ahora en nuestra plantilla aparecerá automáticamente el campo de tipo select a la hora de seleccionar el país del usuario.

Casualmente, esta función no está disponible para arrays en Internet Explorer 8 y anteriores pero si que está disponible para utilizar con strings.

Con este sencillo “hack” podremos contar con esta función cuando manejemos arrays.

1
2
3
4
5
6
7
8
9
10

if(!Array.indexOf){
    Array.prototype.indexOf = function(obj){
        for(var i=0; i<this.length; i++){
            if(this[i]==obj){
                return i;
            }
        }
        return -1;
    }
}

El bundle ProfileBundle subsana esta limitación y otorga al usuario un perfil con su nombre, apellidos, etc. El registro se hace desde el UserBundle y, una vez logueado en la aplicación, completas tu perfil de usuario mediante el ProfileBundle.

Al terminar de completar tu perfil y pulsar el botón guardar, el usuario logueado se recarga con los nuevos datos introducidos. Al hacer esto, me aparecía el siguiente error:

You cannot refresh a user from the EntityUserProvider that does not contain an identifier. The user object has to be serialized with its own identifier mapped by Doctrine.

Y en otras ocasiones también se mostraba este otro error:

Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken::serialize() must return a string or NULL

La solución es sencilla y solo hay que fijarse en el mensaje de error. Si el usuario se va a recargar una vez ya está logueado, la entidad Usuario debe implementar la clase Serializable y definir sus métodos serialize() y unserialize().

En diferentes blogs que hablan sobre Symfony2, en los métodos serialize y unserialize hacen uso del método getUsername() lo cual puede ser un error. Lo muestro con un ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class User implements UserInterface, \Serializable
{
 
    /**
     * @var integer $id
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;
 
    /**
     * @var string $email
     *
     * @ORM\Column(name="email", type="string", length=255, unique=true)
     * @Assert\Email()
     */
    private $email;
 
    [...]
 
    function getUsername()
    {
        return $this->getEmail();
    }
 
    public function serialize()
    {
       return serialize($this->getUsername());
    }
 
    public function unserialize($data)
    {
        $this->email = unserialize($data);
    }
}

En el ejemplo anterior vemos que la propiedad $email no es la clave primaria y, aunque hayamos marcado que es única, nos seguirá apareciendo el error anterior ya que Doctrine necesita que el refresh del usuario se haga mediante su identificador único (en algún caso podría llegar a ser el email, pero no en este ejemplo).

Solamente tendremos que cambiar el código anterior por este:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class User implements UserInterface, \Serializable
{
 
    /**
     * @var integer $id
     *
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;
 
    /**
     * @var string $email
     *
     * @ORM\Column(name="email", type="string", length=255, unique=true)
     * @Assert\Email()
     */
    private $email;
 
    [...]
 
    function getUsername()
    {
        return $this->getEmail();
    }
 
    public function serialize()
    {
       return serialize($this->getId());
    }
 
    public function unserialize($data)
    {
        $this->id = unserialize($data);
    }
}

El código anterior se puede optimizar y se podrían añadir más propiedades a los métodos serialize y unserialize (se podrían utilizar en conjunto las propiedades id, email, etc.).

Así es como lo he hecho:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class RegisterFormType extends AbstractType
{
 
    public function buildForm(FormBuilder $builder, array $options)
    {
 
        $builder
            ->add('email', 'email')
            ->add('password', 'repeated', array(
                'type' => 'password',
                'invalid_message' => 'Las dos contraseñas deben coincidir',
                'options' => array('label' => 'Contraseña'),
                'required' => false))
	    ->add("accept_tos",
                "checkbox", array(
                    "property_path" => false,
                )
            );
 
 
        $builder
            ->addValidator(new CallbackValidator(function(FormInterface $form){
 
                if (!$form["accept_tos"]->getData())
                {
                    $form->addError(new FormError('Debes aceptar los términos de uso'));
                }
            })
        );
    }
 
}

Como vemos, añadimos un campo checkbox con nombre “accept_tos” y le indicamos la opción “property_path” a false, por lo que no validará este campo con el modelo. Eso sí, debemos añadir un validador para este campo para asegurarnos de que el usuario acepta las condiciones de uso.

Fuente: http://www.richsage.co.uk/2011/07/20/adding-non-entity-fields-to-your-symfony2-forms/

Hay varias formas de leer archivos XML, siendo una de ellas mediante SAX (Simple API for XML). En este post voy a explicar los pasos para leer/parsear correctamente un archivo XML disponible en Internet.

El fichero de ejemplo que queremos leer es el listado de categorías:

1
2
3
4
5
6
7
8
9
10
11
12
13

<?xml version="1.0" encoding="UTF-8"?>
<categories type="array">
  <category>
    <id type="integer">6</id>
    <name>Vida/Salud</name>
  </category>
  <category>
    <id type="integer">3</id>
    <name>Sostenibilidad</name>
  </category>
...
...
</categories>

Lo primero que necesitamos es una clase que utilizaremos para guardar los datos de cada categoría. El objetivo es devolver una lista de objetos del tipo categoría, donde se encontraran todas las categorías leídas del XML.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class ParsedCategoryDataSet {
 
    private String id = null;
    private String name = null;
 
    public String getId() {
      return id;
    }
    public void setId(String extractedString) {
     this.id = extractedString;
    }    
 
    public String getName() {
     return name;
    }
    public void setName(String extractedString) {
     this.name = extractedString;
    }
 
    public String toString(){
         return "name = " + this.name;
    }	
}

Como podemos observar, solamente se trata de una clase con setters y getters para almacenar los datos de cada categoría.

Ahora pasamos a crear la clase con la que parsearemos el archivo XML mediante SAX en Android.
El modelo SAX lee secuencialmente el fichero XML y ejecuta varios métodos (que podemos controlar) por cada elemento leído. Estos métodos son:

- startDocument(): comienza a leer el XML.
- endDocument(): ha terminado de leer XML.
- startElement(): ha encontrado el comienzo de una etiqueta XML.
- endElement(): ha encontrado el cierre de una etiqueta XML.
- characters(): texto que ha encontrado entre el comienzo y el cierre de una etiqueta

Estos métodos se encuentran en la clase org.xml.sax.helpers.DefaultHandler, de la que heredaremos nuestro propio parseador de categorías:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

import java.util.Vector;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
public class CategoryHandler extends DefaultHandler{
 
    public CategoryHandler() {
	super();
	this.myParsedCategoryDataSet = new Vector<ParsedCategoryDataSet>();
    }	
 
    // Variables de control para saber cuando estamos en el interior de cada etiqueta
    @SuppressWarnings("unused")
    private boolean in_category = false;
    private boolean in_id = false;
    private boolean in_name = false;
 
    // En esta variable guardamos el texto encontrado entre las etiquetas
    StringBuilder builder;
 
    // Aquí guardamos cada objeto categoria
    private ParsedCategoryDataSet DataSet;
 
    // Vector donde se guardaran todas las categorías encontradas
    private Vector<ParsedCategoryDataSet> myParsedCategoryDataSet; 
 
    public Vector<ParsedCategoryDataSet> getParsedCategoryDataSets() {
        return this.myParsedCategoryDataSet;
    }      
 
    public Vector<ParsedCategoryDataSet> getParsedData() {
         return this.myParsedCategoryDataSet;
    }
 
    @Override
    public void startDocument() throws SAXException {
         // Comenzamos a leer el fichero xml, creamos el vector donde se guardarán las categorías
         this.myParsedCategoryDataSet = new Vector<ParsedCategoryDataSet>();
    }
 
    @Override
    public void endDocument() throws SAXException {
         // Ha terminado de leer el fichero, en este paso no hacemos nada
    }     
 
    @Override
    public void startElement(String namespaceURI, String localName,
              String qName, Attributes atts) throws SAXException {
         if (localName.equals("category")) {
             // Ha encontrado la etiqueta principal de cada elemento "category"
             // Creamos un nuevo objeto categoría donde iremos guardando los datos
             this.in_category = true;
             DataSet = new ParsedCategoryDataSet();
         }else if (localName.equals("id")) {
             // Estamos dentro de la etiqueta "id", creamos el StringBuilder que utilizaremos
             // en el método characters para guardar el contenido
             this.in_id = true;
             builder = new StringBuilder();
         }else if (localName.equals("name")) {
             // Estamos dentro de la etiqueta "name", creamos el StringBuilder que utilizaremos
             // en el método characters para guardar el contenido
             this.in_name = true;
             builder = new StringBuilder();
         }
    } 
 
    @Override
    public void endElement(String namespaceURI, String localName, String qName)
              throws SAXException {
        if (localName.equals("category")) {
            // Hemos llegado al final de la etiqueta principal de cada elemento "category"
            // Añadimos al vector el elemento leído
            this.in_category = false;
            myParsedCategoryDataSet.add(DataSet);
        }else if (localName.equals("id")) {
            // Ha encontrado la etiqueta de cierre de "id"
            this.in_id = false;
        }else if (localName.equals("name")) {
            // Ha encontrado la etiqueta de cierre de "name"
            this.in_name = false;
        }
    } 
 
    @Override
    public void characters(char ch[], int start, int length) {
 
       // Si estamos dentro de la etiqueta "id"
       if(this.in_id){
       	   if (builder!=null) {
       	        for (int i=start; i<start+length; i++) {
                    // Añadimos al StringBuilder (definido al encontrar el comienzo de la etiqueta "id")
                    // lo que haya entre las etiquetas de inicio y fin
       	            builder.append(ch[i]);
       	        }
       	   }        	 
           // Lo asignamos al "id" del objeto categoría (DataSet)
       	   DataSet.setId(builder.toString()); 
       }
 
       // Si estamos dentro de la etiqueta "id"
       if(this.in_name){
           if (builder!=null) {
    	       for (int i=start; i<start+length; i++) {
                    // Añadimos al StringBuilder (definido al encontrar el comienzo de la etiqueta "name")
                    // lo que haya entre las etiquetas de inicio y fin
    	            builder.append(ch[i]);
    	        }
     	   }            	 
           // Lo asignamos al "name" del objeto categoría (DataSet)
           DataSet.setName(builder.toString()); 
       }   
 
   } 
}

El código está comentado y creo que se explica bastante bien. Me consta que algunos programadores leen el contenido que se encuentra entre las etiquetas de inicio y cierre, cuando llegan a esta última etiqueta en lugar de en el método characters. Yo me he encontrado con muchos problemas haciéndolo así ya que se corre el riesgo de no conseguir leer todos los caracteres que realmente hay. La propia documentación del método lo explica:

The Parser will call this method to report each chunk of character data. SAX parsers may return all contiguous character data in a single chunk, or they may split it into several chunks; however, all of the characters in any single event must come from the same external entity so that the Locator provides useful information.

Ya tenemos casi todo lo necesario para leer el fichero XML de la API. Solamente nos queda implementar el método que parseará el archivo utilizando nuestra clase.
Esto solo es el extracto del método que lee el XML, encontraréis el código completo de la activity aquí, donde también se hace uso de la combinación de ProgressDialog y Thread para mostrar un mensaje de “cargando” mientras se leen los datos (este tema da para otro post ).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

...
...
private Vector<ParsedCategoryDataSet> categories;
private String categories_url = "http://url_de_la_api/categories.xml";
...
...
 
public void loadCategories() {
 
    try {
 
        // Url del archivo XML
        URL url = new URL(categories_url);
 
        SAXParserFactory spf = SAXParserFactory.newInstance();
        SAXParser sp = spf.newSAXParser();
 
        XMLReader xr = sp.getXMLReader();
        // Utilizamos nuestro propio parseador (CategoryHandler)
        CategoryHandler myExampleHandler = new CategoryHandler();
        xr.setContentHandler(myExampleHandler);
 
        InputSource is = new InputSource(url.openStream());
        // Le indicamos la codificación para evitar errores
        is.setEncoding("UTF-8");
        xr.parse(is);
 
        // Asignamos al vector categories los datos parseados
        categories = myExampleHandler.getParsedData();
 
     } catch (Exception e) {
          // Ha ocurrido algún error
          Log.e("Ideas4All", "Error", e);
     }        
 
}

Y eso es todo, no olvidéis indicar en el AndroidManifest.xml solicitar permisos de acceso a Internet.

    <uses-permission android:name="android.permission.INTERNET"></uses-permission>

Podéis encontrar la aplicación completa en github:
Código fuente de la aplicación de Ideas4All para Android

La solución es muy sencilla, solo debemos ir a:

Preferences / File Settings - Defaults

Allí encontraremos la línea:

"word_separators": "./\\()\"'-:,.;<>~!@#$%^&*|+=[]{}`~?",

Solamente debemos quitar el símbolo $ de la línea anterior, dejándolo así:

"word_separators": "./\\()\"'-:,.;<>~!@#%^&*|+=[]{}`~?",

Si ahora cerramos y volvemos a abrir el editor, ya se seleccionará la variable completa.

Truco encontrado aquí:
http://www.sublimetext.com/forum/viewtopic.php?f=3&t=2704

Para realizar esta tarea, Android pone a nuestra disposición los llamados “Intent“. En general, utilizaremos un Intent cuando queramos movernos de una actividad a otra, permitiéndonos a su vez pasar datos desde la Activity en la que estamos hacia la nueva.

1
2
3
4
5
6

// Pasaremos de la actividad actual a OtraActivity
Intent intent = new Intent(this, OtraActivity.class);
intent.putExtra("variable_integer", objeto.getId());
intent.putExtra("variable_string", objeto.getNombre());
intent.putExtra("objeto_float", objeto.getPrecio());
startActivity(intent);

- En la segunda línea creamos un Intent, al que se le pasa como parámetros la actividad actual (this) y la actividad a la que queremos pasar (en este caso OtraActivity.class).

- En las tres líneas siguientes definimos tres variables de tres tipos diferentes. En el primer caso, estaremos creando una variable llamada “variable_integer” con el contenido de objeto.getId(). Esta variable se “envía” a OtraActivity y podremos recuperar su contenido allí para utilizarlo.

- En la última línea, iniciamos la nueva actividad pasando como parámetro el Intent que hemos creado.

El código que viene a continuación es el que se ejecutará en la actividad OtraActivity. Se muestran dos formas de recuperar las variables, se puede utilizar la que más convenga en cada ocasión.

1
2
3
4
5
6
7
8
9
10
11
12

// Estamos en OtraActivity
int recuperamos_variable_integer = getIntent().getIntExtra("variable_integer");
String recuperamos_variable_string = getIntent().getStringExtra("variable_string");
float recuperamos_variable_float = getIntent().getFloatExtra("objeto_float");
 
// O también de esta otra forma
 
// Estamos en OtraActivity
Bundle datos = this.getIntent().getExtras();
int recuperamos_variable_integer = datos.getInt("variable_integer");
String recuperamos_variable_string = datos.getString("variable_string");
float recuperamos_variable_float = datos.getFloat("objeto_float");

Es importante que sepamos de que tipo son las variables que enviamos en el Intent, ya que deberemos asignar esos valores al tipo de variable correcto.

Si nos descargamos el programa desde su propia web, descubrimos que al descomprimirlo se trata de una carpeta donde se encuentra todo lo necesario para ejecutar el programa. Cada vez que queramos abrirlo, debemos entrar en esta carpeta y ejecutar el archivo de la aplicación (también podemos crear un acceso directo en el escritorio). En esta carpeta no encontraremos ni siquiera el icono de Sublime Text 2.

¿Cómo solucionarlo?

- Primero nos descargamos el icono del programa para que el lanzador quede “bonito”

- Creamos un enlace de la aplicación a la carpeta /usr/bin/:

sudo ln -s /home/jonseg/sublime-text-2/sublime_text /usr/bin/sublime_text

- Copiamos el icono que nos hemos descargado antes al directorio donde se encuentran los iconos del sistema:

sudo cp sublime.png /usr/share/icons/

- Creamos el archivo sublime.desktop con el siguiente contenido:

[Desktop Entry]
Version=2.0
Type=Application
Name=Sublime Text 2
Comment=Editor Sublime Text 2
TryExec=sublime_text
Exec=sublime_text %F
Icon=/usr/share/icons/sublime.png
MimeType=text/plain;

Y lo copiamos al directorio /usr/share/applications/:

sudo cp sublime.desktop /usr/share/applications/

Y listo. Si pulsamos la tecla de Windows de nuestro teclado (en Unity), el resultado debe ser algo parecido a esto: