#devtutorial

SharedPreferences en Android se utilizan para guardar el estado de una actividad o para guardar los datos importantes de una aplicación. Normalmente se usan para almacenar información personal, opciones de presentación, puntajes de un juego, etc. 

La principal ventaja de usar SharedPreferences es que los datos que se almacenan alli, permanecen guardados a pesar de cerrar nuestra aplicación o de incluso reiniciar o apagar nuestro móvil. 

SharedPreferences tambien se puede utlizar para almacenar los datos de un usuario dentro de una aplicación. Aunque para ello también se pueden utilizar variables globales, el problema de esto es que los datos se pierden una vez que el usuario cierra la aplicación, por eso es recomendable almacenar datos en SharedPreferences.

¿Cómo funciona?

La gestión de estas preferencias se centraliza en la clase SharedPreferences, que representa una colección de preferencias. A la hora de instanciarlas, estas tienen un identificador, que es la clave o nombre que le hayamos puesto nosotros, y un modo de acceso.

Modo de acceso

Para obtener una referencia a una colección determinada utilizaremos el método getSharedPrefences() al que pasaremos el identificador de la colección y un modo de acceso. El modo de acceso indicará qué aplicaciones tendrán acceso a la colección de preferencias y qué operaciones tendrán permitido realizar sobre ellas. Así, tendremos tres posibilidades principales:

MODE_PRIVATE. Sólo nuestra aplicación tiene acceso a estas preferencias.

MODE_WORLD_READABLE. Todas las aplicaciones pueden leer estas preferencias, pero sólo la nuestra puede modificarlas.

MODE_WORLD_WRITABLE. Todas las aplicaciones pueden leer y modificar estas preferencias.

Siendo la primera la más recomendable. Ten en cuenta que han sido declaradas obsoletas desde la API 17 (correspondiente a Android 4.2).

Obteniendo valores de las preferencias

Teniendo todo esto en cuenta, para obtener una referencia a una colección de preferencias llamada por ejemplo “MyPreferences” y como modo de acceso exclusivo para nuestra aplicación haríamos lo siguiente:

SharedPreferences pref = getSharedPreferences("MyPreferences", Context.MODE_PRIVATE);

Una vez referenciada nuestra colección de preferencias, ahora podemos obtener sus valores mediante el método get y escribir mediante el método put.

Por ejemplo, para obtener el valor de una preferencia llamada “email” de tipo String deberíamos poner lo siguiente:

String email = pref.getString("email", "");

También podemos usar otros metodos como:

getBoolean()

getInt()

getFloat()

getLong()

Escribiendo valores en las preferencias

Para insertar un valor o actualizarlo, hay que hacerlo utilizando el objeto SharedPreferences.Editor.

Una vez referenciado el editor, se ha de realizar un put sobre el tipo de dato básico correspondiente y validamos mediante el método commit(). Siguiendo el ejemplo de email:

SharedPreferences pref = getSharedPreferences("MyPreferences", Context.MODE_PRIVATE); SharedPreferences.Editor editor = pref.edit(); editor.putString("email", “[email protected]”); editor.commit();

Y de esta manera hemos creado el valor, si no existía, o actualizado su contenido a “[email protected]” dentro de la preferencia “email”.

Pueden descargar un proyecto de ejemplo aqui y probar el funcionamiento de SharedPreferences:

Hace poco estaba trabajando en una App la cual hacia consultas REST a una web para obtener datos en formato json. En la cuál utilizaba métodos donde manualmente programa una conexión a internet y un parseador para que trasforme los datos del json en objetos java.

Se pueden encontrar muy buenos tutoriales sobre esto, pueden ver un ejemplo aquí.

La buena noticia es que hasta hace poco descubrÍ una librerÍa que se encarga de todos estos procesos, RETROFIT.

¿Qué es retrofit?

Retrofit es un cliente REST para Android y Java, desarrollada por Square, muy simple y fácil de aprender.

Permite hacer peticiones GET, POST, PUT, PATCH, DELETE y HEAD , gestionar diferentes tipos de parámetros y parsear automáticamente la respuesta a un POJO.

Instalación

compile 'com.squareup.retrofit2:retrofit:2.0.0-beta4'

Tambien utilizaremos la librería Gson para parsear documentos en json:

compile 'com.google.code.gson:gson:2.6.1'

Json de ejemplo

Como en la mayoría de tutoriales los link de los json no funcionan, les dejo la estructura del ejemplo que presentaré.

Ruta de ejemplo: 

”http://www.example.com/[email protected]&password=ejemplo″ (la cual utilizarémos más adelante).

{  "user":{    "id":236,    "name":"Luis",    "paternal":"Tijero",    "maternal":"Urbano",    "description":"lksdjkasldja",    "email":"[email protected]",    "phone":"65451321",    "sex":false,    "birthday":"1994-06-02",    "address":"46546546",    "age":22,    "full_name":"Luis Tijero Urbano",    "token":"f32c9531fd35114ea3d44d1f97c0b5f3",    "authentication":true,    "place":{     "id":77,       "name":"Centro de Ica"     },    "followers_count":3,    "following":"me"  } }

Auto-generación de los objetos Java

Debemos generar estos objetos para poder consumir los recursos del json.

Como ya tenemos la estructura del json, iremos a http://www.jsonschema2pojo.org/ , nos aseguraremos de seleccionar:

Se puede seleccionar el estilo de anotación para Gson , pero no es del todo necesario ya que el archivo de Java creado funcionará sin él. Por ahora, seleccione Ninguno como el tipo de anotación.

A continuación, pegamos el JSON en el cuadro de texto:

Haga clic en el botón de vista previa. Se debería mostar algo asi:

Descargamos el .zip con las clases generadas y las adjuntamos al proyecto. Si existe algun error por @generated podemos borrarla no nos perjudica en nada.

Pues con esto ya tenemos lo necesario, que empiece el juego.

Definiendo endpoints en una interfaz

Aquí codificamos las consultas REST que queremos realizar, por ejemplo:

public interface UserApi {    @GET("authentication.json")    Call<Person> getUser(@Query("email") String email, @Query("password") String password); }

Retrofit builder

Para enviar solicitudes de red a una API, tenemos que utilizar Retrofit builder y especificar la URL base para el servicio.

Retrofit retrofit = new Retrofit.Builder()        .baseUrl(”http://www.example.com/”)        .addConverterFactory(GsonConverterFactory.create())        .build();

Observamos también que tenemos que deserializar la respuesta utilizando la librería Gson.

Gson gson = new GsonBuilder()        .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")        .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)        .create(); Retrofit retrofit = new Retrofit.Builder()        .baseUrl(”http://www.example.com/”)        .addConverterFactory(GsonConverterFactory.create(gson))        .build();

Tuve problemas con “/” en las @URL asi que les dejo mi sugerencia (aplica solo en Retrofit 2.0):

- Base URL : siempre debe terminar con /

- @URL : no debe comenzar con /

Crear objeto de nuestra interfaz UserApi

UserApi api = retrofit.create(UserApi.class);

Crear solicitud asíncrona

Call<Person> call = api.getUser(_emailText.getText().toString(), _passwordText.getText().toString()); call.enqueue(new Callback<Person>() {    @Override    public void onResponse(Call<Person> call, Response<Person> response) {        if (response.isSuccess()) {            Person person = response.body();            Log.i("TAG", "Hola: " + person.getUser().getName());        } else {            int statusCode = response.code();            Log.i("TAG", "error " + response.code());            // handle request errors yourself            ResponseBody errorBody = response.errorBody();        }    }    @Override    public void onFailure(Call<Person> call, Throwable t) {        // handle execution failures like no internet connectivity    } });

En la ejecución debemos obtener esto:

Conclusión:

Si eres una persona vanguardista, es seguro que usarás esta librería en tus aplicaciones.

¿Cansado de escribir findViewById(R.id.view) por todas partes en tu aplicación?

ButterKnife es una librería que nos facilitará la tarea de relacionar los elementos de las vistas con el código en nuestras aplicaciones Android. Nos evitará tener que utilizar findViewById y simplificará el código.

Instalación

Podemos añadir la dependencia en el fichero build.gradle:

compile 'com.jakewharton:butterknife:7.0.1'

Usa las Anotaciones

En cada activity o fragment, tienes que remover, o poner como comentario, cada llamada del método findViewById y agregar la anotación @Bind antes de la declaración de la variable, indicando el identificador del view.

@Bind(R.id.title) TextView title;

Inyectar Views

En el método onCreate() de la activity, antes de usar cualquiera de los views, llama a bind en el objeto Butterknife.

ButterKnife.bind(this);

Si estás usando fragments, tienes que especificar la fuente de los views en el método onCreateView como se muestra abajo.

View view = inflater.inflate(R.layout.sample_fragment, null); ButterKnife.bind(this, view);

Ahora puedes empezar a usar los views en el código de tu aplicación. ButterKnife manejará la instanciación de cada view por tí.

Uso general

Un ejemplo sencillo sería asi:

class MainActivity extends Activity {    @Bind(R.id.title) TextView title;  @Bind(R.id.button) Button button;  @Override  public void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);    setContentView(R.layout.main_activity);    ButterKnife.bind(this);    title.setText("Texto de ejemplo");.  } }

Si queremos agregar un evento click al botón:

@OnClick(R.id.button) void buttonClick() {      //... }

Conclusión

Haml is love! HTML Abstraction Markup Language o Haml para abreviar, toma unos días para aprender pero es más limpio y fácil de leer en comparación con HTML, te ayudará a codear más rápido, lo digo por experiencia propia. Un ejemplo simple es el siguiente:

HTML  <div class=“container”>   <ul id=“icons”>    <li class=“plus” id=“first>Plus</li>    <li class=“minus” id=“last”>Minus</li>   </ul>  </div>  HAML  .container    %ul#icons      %li.plus#first Plus      %li{:class=>”minus”, :id=>”last”} Minus

Los tags en Haml comienzan con %, para añadir atributos se usan "{ }" pero para las clases e id’s puedes usar el “.” y “#” respectivamente, ¿familiar con css verdad? Awesome! Además, la etiqueta div es tan común que no necesitas poner %div.container %div#haml, solo .container o #haml respectivamente.

Tal vez no le encuentres sentido al !!!5 que es <!DOCTYPE html>  o :data => {'user-name' => 'Moises', 'user-age' => 19} pero ya sabes, existe stackoverflow que contiene 2843 preguntas con el tag de Haml y 500848 de HTML, entonces ¿por qué usar Haml?

Pruébalo y descúbrelo, tal vez tengas complicaciones al inicio y quieras dejarlo de lado pero en Haml también puedes colocar una línea de html y no hay problema.

%ul#icons   %li.plus#first Plus <i class=“fa fa-plus”></i>   %li.minus#last  Minus <i class=“fa fa-minus”></i>

Hola estimados developers, en el anterior capítulo hablamos sobre como realizar migraciones en nuestro primer proyecto Laravel 4, puedes verlo en el siguiente:

http://blog.devacademy.la/post/98514676446/tutorial-laravel-migraciones-para-el-manejo-de-la-bd

En este tutorial vamos a declarar las clases de nuestros modelos en Laravel 4, seguimos con nuestro proyecto devacademy-laravel, emocionad@?!!, continuemos.

Implementando Modelos

Hemos aprendido cómo configurar nuestra base de datos y cómo podemos usar el constructor de esquemas para estructurar las tablas de nuestra base de datos, pero ahora es hora de ponernos manos a la obra y aprender cómo podemos almacenar información en la base de datos utilizando el ORM Eloquent de Laravel.

Imagino que eres un programador, espero que seas un programador de PHP 5+, y que estés usando programación orientada a objetos.

Si estamos describiendo las entidades de nuestra aplicación como objetos, tiene sentido almacenarlas como tal, obtenerlas como tal, etc.

Imaginemos que estamos escribiendo nuestra tienda de libros online.

El diseño de aplicaciones orientadas a objetos nos ha enseñado que tenemos que identificar los objetos de nuestra aplicación. Necesitamos un objeto Libro que represente a un libro individual usado por nuestra aplicación. Normalmente, nos referiríamos a ellos como Modelos, teniendo en cuenta que representan parte del modelo de negocio de la aplicación. Veamos un ejemplo para el modelo Libro:

Hemos creado un libro para representar el libro de Guy Kawasaki , “El arte de cautivar”, uno de los libros que me gustó del repertorio de DevAcademy. Ahora almacenemos este libro en nuestra base de datos. Asumiremos que hemos usado el constructor del esquema y que ya tenemos una tabla llamada libros con todas las columnas necesarias.

Primero, tenemos que construir una consulta SQL. Veamos un ejemplo sencillo:

Creamos una consulta SQL para insertar nuestro objeto en la base de datos. Pero en Laravel nos evitamos tener que construir esas consultas SQL, lo ideal es algo asi:

<?php

$libro = new Libro;

$libro->nombre = 'The Colour of Magic';

$libro->descripcion = 'Rincewind and Twoflower in trouble!';

$libro->save();

El método save() gestionaría el lado SQL de las cosas por nosotros. Persistiendo el objeto en la base de datos.

Esta funcionalidad es proveída por un mapeador de objetos relacional, o simplemente ORM por sus siglas en inglés. Los ORMs pueden ser usados para permitirnos asociar los objetos de nuestra aplicación con las tablas de la base de datos, y las instancias individuales de esos objetos como las filas.

El ORM se encargará de obtener el objeto y de la persistencia por nosotros, no tendremos que escribir ni una sola línea de SQL. Eso es bueno, ¡porque no soporto el SQL! Es feo y aburrido. Los objetos son mucho más divertido.

Muchos ORMs ofrecen también la habilidad de gestionar las relaciones entre múltiples tipos de objetos. Por ejemplo, libros y autores. Autores y editoriales, etc.

Laravel viene con su propio ORM llamado ‘Eloquent’. Eloquent hace mucho honor a su nombre. Su sintaxis es bastante bonita y hace que interactuar con la capa de la base de datos de tu aplicación sea una experiencia placentera.

Cuando pienso sobre la capa de almacenamiento, la palabra CRUD me viene ala mente. Son las acciones que se pueden realizar:

C - Crear una nueva fila (create).

R - Leer filas existentes (read).

U - Actualizar filas existentes (update).

D - Borrar filas existentes (Delete).

En los proximos tutoriales vamos a interactuar más con el ORM Eloquent para declarar las relaciones.

Java es el lenguaje de programación mas usado a nivel mundial y es una plataforma informática comercializada desde 1995. Hay muchas aplicaciones y sitios web que no funcionarán a menos que tenga Java instalado y cada día se crean más. Java es rápido, seguro y fiable.

Java es popular porque tiene una máquina virtual que ejecuta el programa desarrollado independientemente del sistema operativo en que se trabaje. Además toda la documentación, el compilador de Java y la máquina virtual son libres y se encuentran por todo internet.

Con el paso del tiempo Java a dejado de ser el centro de la atención debido a que han surgido lenguajes mucho más sencillos de aprender como Python o Ruby, dejando de lado a Java por su complejidad.

Pero gracias a los dispositivos Wearables, Java esta volviendo a tomar importancia para los desarrolladores.

Los dispositivos Wearables son conjunto de dispositivos electrónicos que se incorporan en alguna parte del cuerpo interactuando continuamente con el usuario y con otros dispositivos con la finalidad de realizar una tarea especifica de manera rápida y fácil al usuario al realizar alguna función específica. Estos dispositivos son el futuro, como en su momento lo fueron los Smartphones y Tablets, y seguirán en aumento.

Ya existen en el mercado dos dispositivos wearables muy conocidos de Google: los Google Glasses y los Smartwatches. Estos dispositivos tienen como sistema operativo a Android.

Este sistema operativo es muy popular a nivel mundial, se encuentra en miles de tablets, smartphones, PC y TV. Android se caracteriza por ser de código abierto, tener un gran framework de aplicaciones y por contener múltiples librerías para el uso de sensores(acelerómetro, giroscopio, etc).

Así que Java tiene mucha vida por delante gracias a estos dispositivos que contienen Android y necesitan aplicaciones escritas en Java.