miércoles, 10 de abril de 2013

Ejemplo con Layout Animation Y Android

Hola que tal, en esta ocasión quiero compartir un pequeño ejemplo sobre como Animar fácilmente vistas en un layout usando Android. Este pequeño ejemplo esta basado en el articulo que publico Chet Haase en Androide Dev Bites. En realidad el ejemplo es muy sencillo y tratare de explicarlo lo mejor posible extendiendo un poco mas para hacerlo un poco mas atractivo. Con esto espero poder hacer una serie de artículos acerca de animaciones en Android.

Con la entrada de la android API versión 11 (Android 3.0) la clase LayoutTransition nos permite ejecutar animaciones cuando haya algun cambio en el layout de un contenedor. Como puede ser un LinearLayout, RelativeLayout, etc.

Muy bien vayamos al ejemplo. Lo primero que tenemos es un simple layout con dos botones y un contenedor. El contenido de nuestro main_layout xml es como el que sigue:


Es muy simple, nuestro main layout es LinearLayout con orientación vertical. Luego un botón para agregar una vista (Add View), un botón para remover una vista (Remove View) y al final otro LinearLayout el cual tomara el resto de la pantalla para el también con orientación vertical. El punto interesante en este ultimo contenedor es la propiedad android:animateLayoutChanges="true"; esta propiedad es la que nos dirá que cada vez que haya un cambio en este layout estos cambios deberán de animarse. Por defecto solo los cambios de entrada y salida de vistas serán animadas pero eso lo arreglaremos mas tarde.

Ahora si en nuestra actividad principal


public class MainActivity extends Activity {
LinearLayout container = null;
private static LayoutParams mParams = new LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
   ViewGroup.LayoutParams.WRAP_CONTENT);
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
container = (LinearLayout) findViewById(R.id.layout_container);
}
public void btnAddViewClicked(View view){
 Button btn = new Button(view.getContext());
 btn.setLayoutParams(mParams); btn.setText("Useless Button");
container.addView(btn,0);
}
public void btnRemoveViewClicked(View view){
if (container != null && container.getChildCount() > 0){
container.removeViewAt(
(int)(Math.random()  * (container.getChildCount())) 
);
}else{
Toast.makeText(view.getContext(), "No views to remove", Toast.LENGTH_LONG).show();
}
}
}

Lo primero que haremos en onCreate sera establecer nuestro xml como el contenido y luego vamos a retraer el contenedor que definimos para almacenarlo en la variable container. Este objeto container ya tiene las animaciones establecidas. Luego los dos métodos para agregar y eliminar vistas, como lo definimos en nuestro xml cuando el botón Add View es presionado el metodo btnAddViewClicked se ejecuta; en este método lo que haremos sera crear un nuevo botón  asignarle las propiedades y el texto correspondiente y luego agregarlo al contenedor con el método container.addView.

De la misma manera el método btnRemoveViewClicked sera ejecutado cuando el botón Remove View es presionado; este método lo único que se encarga es de remover una vista del contenedor de una posición alternativa si el contenedor ni tiene ninguna vista asociada (esto es su childCount no es mayor que 4) simplemente mostramos un mensaje con Toast.

Y eso es todo como pueden ver no tenemos ningún código extra sobre animaciones, efectos, etc. El sistema se encargara de hacer las animaciones automáticamente al momento de que se agreguen y remuevan vistas. Como pueden ver es un ejemplo muy sencillo pero nos ayudara a darle un poco mas de presentación a nuestras aplicaciones.

Aquí abajo les dejo una muestra de como se comporta la aplicación y en un post futuro veremos como extender esta aplicación para hacerla mas dinámica. Como siempre pueden obtener el codigo fuente de este y otros proyectos visitando mi perfil de github.

P.S estoy extrayendo el vídeo para que vean como se ve pero aun estoy probando distintas apps para screencast. En cuanto lo tenga actualizo el post. (No creo que sea de mucha ayuda si subo fotos :P). Saludos

Update: Aqui les dejo el video, no muy buena calidad pero pasa.

martes, 5 de marzo de 2013

Opciones de Desarrollador en Android Jellybean (4.2)

Hola que tal a todos, este es un pequeño comentario sobre la ultima actualización que se envió a Android Jelly-Bean (4.2). Puede ser que ya lo hayan notado pero a partir de la ultima actualización de Jelly Bean  el menú de opciones de desarrollador no se encuentra disponible en el menú configuraciones. Google consolido todas las opciones de desarrollador dentro de una sección en el menú de configuraciones, la mayoría de las veces lo único que realizábamos en este menú es activar o desactivar el USB Debugging para que al conectar el cable USB el teléfono nos mostraba una carita de Android en la barra de notificaciones (hace mas que eso pero no quiero hacerla larga).
Para poder activar este menú de nuevo en la nueva versión de Android es necesario decirle al teléfono que su usuario es un desarrollador, hay que ir al menú de Configuraciones -> Acerca del Teléfono -> Numero de Build. Hay que tocar varias veces este ítem después de varias ocasiones veremos un mensaje diciendo "estas a X clicks de ser desarrollador", luego de sobrepasar este numero el menu se hará visible en las configuraciones donde anteriormente estaba.
Esta movida fue publicada por google ya que en los teléfonos mas comerciales como el Galaxy S3 o One X, etc el usuario común no quiere ver este menú. Por lo tanto nuevos teléfonos con Jelly Bean no desplegaran este menú hasta que sean activados como desarrollador. He probado esta opción en mi Nexus Galaxy, Galaxy S4 y HTC One X+ y en todos me ha funcionado. Así que si eres desarrollador y extrañas este menú en tu dispositivo ya sabes el por que y como volver a activarlo.

Saludos a todos

lunes, 4 de marzo de 2013

Ejemplo Con ViewPager Extendido

En esta ocasión vamos a continuar un poco mas con ejemplos de Android. Hace algún tiempo publique un post sobre como utilizar ViewPager en Android y hace algunos días recibí una pregunta de un lector sobre como hacer cosas mas avanzadas en el View Pager. Para recordar un poco aquel ejemplo desplegaba dos vistas similares (el reloj de Android) pero con un color de fondo diferente. Al deslizar la vista hacia la derecha o izquierda el View Pager cambiaba la vista a desplegar en pantalla y se puede observar el cambio en el color de fondo. La pregunta de Oscar Sanchez (gracias por leer el blog) es, como acceder al reloj dentro de cada uno de los fragmentos y realizar operaciones con el ?.

Bueno en Android como en casi todas las plataformas existen varias maneras de hacer las cosas, solo es cuestión de seleccionar la que mas te guste y analizar los pros y contras. Así que para contestar esta pregunta la primera aproximación que utilizaremos sera el manejo interno.  Como ya habíamos visto en nuestro ejemplo anterior habíamos creado un PageAdapter que nos manejaba los diferentes fragmentos que agregábamos en una lista y añadiamos  3 fragmentos iguales pero con diferente color de fondo. Como la documentación de Android lo dice, un fragmento es una poción de una actividad que cuenta con su propio ciclo de vida y espacio para dibujar vistas. Por lo tanto en nuestro fragmento podemos manejar nuestras vistas y eventos internamente. Entonces vamos a extender nuestra clase fragmento para que se vea de esta manera.


public class PlainColorFragment extends Fragment {

int color = Color.GREEN;
View view = null;
AnalogClock clock = null;
public PlainColorFragment(int color){
this.color = color;
}

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
view = inflater.inflate(R.layout.color_layout, null); 
clock = (AnalogClock) view.findViewById(R.id.analogClock1);
clock.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startAnimationOnClock();
}
});
view.setBackgroundColor(this.color);
return view; 
}
public void startAnimationOnClock(){
Animation anim = 
AnimationUtils.loadAnimation(getActivity(), android.R.anim.fade_out);
clock.startAnimation(anim);
}
}

Lo que hicimos, es simplemente tener una variable que apunte a nuestro AnalogClock llamada clock y en el evento onCreateView asignar esa variable a la vista analogClock1 que se encuentra dentro de nuestro layout. Y ya con nuestra variable clock le asignamos un evento OnClickListener para que cuando el usuario toque la pantalla una simple animación se ejecute, esto es llamar al método startAnimationOnClock ( vean que el método es publico y visible para otras clases, por que luego lo usaremos para otras cosas). Ahora si, al modificar nuestra aplicación previa de esta manera veremos al tocar el reloj de cualquier fragmento seleccionado la animación se ejecutara. 

Nuestra segunda aproximación, en algunas ocasiones es necesario mandar una señal desde fuera de nuestros fragmentos hacia el interior para ejecutar ciertas instrucciones; como por ejemplo la selección de algún ítem del menú o algún otro evento externo . En esta ocasión, haremos que la animación del reloj del fragmento seleccionado se ejecute cuando se seleccione desde el menú. Lo primero que tendríamos que hacer es saber cual fragmento es el que esta actualmente seleccionado; cual reloj de los varios disponibles tendremos que animar para que el usuario lo vea (no tendría caso animar un reloj que este invisible para el usuario, obvias razones). Por lo tanto crearemos una clase que nos guarde el indice del fragmento que el usuario selecciona. La clase se ve de esta manera:


public class PageChangeListener implements OnPageChangeListener {
int currentIndex = 0;
@Override
public void onPageScrollStateChanged(int arg0) {
//Do Nothing
}
@Override
public void onPageScrolled(int arg0, float arg1, int arg2) {
//No Nothing
}
@Override
public void onPageSelected(int arg0) {
currentIndex = arg0;
}
public int getCurrentIndex() {
return currentIndex;
}
}


Hace nada, nomas que guardar el numero de indice de la pagina seleccionada en una variable y exponerla por medio de un getter. Esta clase se va a relacionar con el ViewPager con el método setOnPageChangeListener para que cada vez que se haga un cambio de pagina el indice sea almacenado en nuestra variable currentIndex. Y por ultimo en nuestra actividad principal agregaremos métodos para que cuando el botón del menú sea presionado el fragmento visible sea retraído desde nuestro Adapter y llamar al metodo startAnimationOnClock (es por esto que nuestro método es públicamente visible). Asi que nuestra actividad principal se ve de esta manera: 


public class MainActivity extends FragmentActivity {
ViewPager pager = null;
PageChangeListener pageChangeListener = null;
/** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        pager = (ViewPager) findViewById(R.id.pager);
        
        MyFragmentPagerAdapter adapter = 
        new MyFragmentPagerAdapter(getSupportFragmentManager());
        adapter.addFragment(new PlainColorFragment(Color.RED));
        adapter.addFragment(new PlainColorFragment(Color.GREEN));
        adapter.addFragment(new PlainColorFragment(Color.BLUE));
        pageChangeListener = new PageChangeListener();
        pager.setOnPageChangeListener(pageChangeListener);
        pager.setAdapter(adapter);
    }
        private void startAnimationOnCurrentPage(){
        MyFragmentPagerAdapter adapter =  
         (MyFragmentPagerAdapter) pager.getAdapter();
        PlainColorFragment fragment = 
    (PlainColorFragment) adapter.getItem(pageChangeListener.getCurrentIndex());
        fragment.startAnimationOnClock();
        }
@Override
public boolean onCreateOptionsMenu(Menu menu) {
MenuInflater inflater = new MenuInflater(this);
inflater.inflate(R.menu.main_menu, menu);
return super.onCreateOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch(item.getItemId()){
case R.id.main_menu_start_anim_current_item:
startAnimationOnCurrentPage();
default:
return super.onOptionsItemSelected(item);
}
}    
}

El método importante en esta actividad es startAnimationOnCurrentPage, ya que dentro de el retraemos nuestro adaptador y utilizamos el indice de nuestro pageChangeListener para así poder obtener el fragmento que esta siendo desplegado al usuario. Una vez que tenemos nuestro fragmento lo único que hacemos es llamar startAnimationOnClock() para que la animación en el reloj sea ejecutada. De esta manera logramos propagar un evento ocurrido en el menú de nuestra actividad hacia dentro de las vistas localizadas dentro de nuestro ViewPager.

En esta ocasión vimos como ejecutar una simple operación de animación en la pagina actual de nuestro ViewPager pero en su lugar podríamos  realizar cualquier otro tipo de operación. Retraer las vistas internas, hacerlas invisibles, eliminarlas, cambiarles colores, fondos, etc. Este pequeño post es simplemente para ejemplificar un poco mas como trabajar con ViewPagers en Android. 

Espero y el ejemplo les sea de utilidad y como siempre, el código fuente esta a su disposición en mi pagina de github https://github.com/ti3r/view_pager_test. Pueden descargar, revisar y utilizar el código a su conveniencia. Si este post les gusto por favor dejen sus comentarios, compartan el blog o escriban un e-mail o comentario con dudas  o recomendaciones para poder mejorar este espacio.

Un Saludo a todos y gracias por leer.













miércoles, 27 de febrero de 2013

BDD con Cucumber y Java 2/2

Ya vimos en la primera parte de este post como un escenario puede ser especificado y usado por un desarrollador para dirigir sus desarrollos. Normalmente estos escenarios serán escritos por algún agente externo al desarrollo y podrán ser usados para validar la aplicación en cuestión. La parte importante es que en determinadas aplicaciones un agente puede escribir cientos de escenarios diferentes y el validar cada uno de estos después del desarrollo puede llegar a ser una tarea bastante compleja. Es aquí donde entra en juego la automatización de estos escenarios con la ayuda de Cucumber.

Como ya habiamos descrito BDD esta definido en escenarios que describen el comportamiento deseado. Estos escenarios serán escritos en archivos .feature en cucumber. Cucumber framework permite la integración de muchos lenguajes naturales para escribir el comportamiento, lo que nos permite describir comportamientos en muchos de las lenguas mas utilizadas en el mundo. Un ejemplo de un archivo .feature seria el siguiente.


# language: es
Característica: Calculator ops

Background:
 Dado Ejecuto Limpiar la Calculadora

@calculadora
Escenario: Probar suma
 Cuando escribo 2 en la calculadora
 Y presiono la tecla +
 Y escribo 5 en la calculadora
 Y presiono la tecla =
 Entonces El resultado sera 7
Las etiquetas que se definen sobre cada escenario definen un punto de entrada para la ejecución de las instrucciones. Por cada ejecución de Cucumber-jvm se puede definir una etiqueta la cual ejecutara el o los escenarios marcados y por lo tanto las pruebas correspondientes.

En Cucumber como en todos los lenguajes de programación nada es echo por arte de magia. Por lo tanto Cucumber necesita saber como interpretar las instrucciones en español (en este caso) o en el lenguaje que seleccionamos y ejecutar las tareas determinadas. A esto se le llama "glue code" o código de pegamento. Este código puede ser escrito en varios lenguajes de programación. Cucumber-jvm es tan robusto que acepta varios lenguajes de programación entre ellos: Java, Groovy, JRuby, Cloujure, y mas. Para este ejemplo escribiremos una clase Java que contendrá el código de pegado y la cual se vera mas o menos así.


public class CalculadoraStepDef {

  Calculadora calc = new Calculadora();
  
  @Dado(value="^Ejecuto Limpiar la Calculadora$")
  public void I_reset_the_calculator() throws Throwable{
    calc.reset();
  }
  
  @Cuando(value="^escribo (\\d+) en la calculadora$")
  public void I_add_to_the_calculator(int number) throws Throwable{
    calc.escribirDigito(number);
  }
  
  @Cuando(value="^presiono la tecla (.?)$")
  public void I_press_key(String key) throws Throwable{
    if ("+".equalsIgnoreCase(key)){
      calc.setOperacion(OPERACIONES.SUMA);
    }else if ("-".equalsIgnoreCase(key)){
      calc.setOperacion(OPERACIONES.RESTA);
    }else if ("*".equalsIgnoreCase(key)){
      calc.setOperacion(OPERACIONES.MULTIPLICACION);
    }else if ("/".equalsIgnoreCase(key)){
      calc.setOperacion(OPERACIONES.DIVISION);
    } else if ("=".equalsIgnoreCase(key)){
      
      if (calc.getOperacion() != null){
        calc.ejecutarOperacion();
      }else{
        calc.setOperacion(OPERACIONES.IGUAL);
      }
      
    }
  }
  
  @Entonces(value="^El resultado sera (.*)$")
  public void result_should_be(double number) throws Throwable {
    Assert.assertEquals(number, calc.getTotal());
  }
  
}


Como se puede observar la clase contiene expresiones regulares las cuales corresponden a los escenarios que definimos anteriormente. Este es el código que hace el trabajo pesado y lleva a cabo las pruebas que se definieron en los archivos feature. Las anotaciones que se encuentran el cada método definen que método de esta clase debe de ser ejecutado cuando un paso de cada escenario es interpretado en el archivo feature.

Por ultimo solo es necesario decirle a Cucumber-jvm que se ejecute. El framework Cucumber-jvm cuenta con varias maneras de ejecución. Una es vinculando la ejecución con una Prueba JUnit. Otra es ejecutando la clase Main (cucumber.api.cli.Main) con los parámetros correspondientes. Esto es lo que nosotros realizaremos en este ejemplo al vincular la ejecución de esta clase con la fase de pruebas de un proyecto maven. Lo que se tiene que hacer es vincular el plugin de Java Execution en nuestro archivo pom.xml como se muestra abajo. Una vez que tengamos nuestro archivo pom correctamente configurado solo sera necesario ejecutar en nuestra consola mvn clean test y nuestras pruebas de Comportamiento se ejecutaran automaticamente.



org.codehaus.mojo
exec-maven-plugin
1.2.1


test

exec


java

-Xms512M
-Xmx1024M
-XX:MaxPermSize=512M
-classpath

cucumber.api.cli.Main
features/
--glue
com.bestbuy.test.cucumber_test
--tags
@calculadora/argument>
--format
pretty






Este articulo formado por dos partes es un poco largo y técnico mas sin embargo espero y les sea de utilidad. Como siempre pongo a disposición un link a mi repositorio de github (https://github.com/ti3r/cucumber-tests) donde pueden descargar, modificar, actualizar y jugar con el código que hemos desarrollado en este ejemplo. Cualquier cosa que no este clara no duden en dejar su comentario en el blog o escribirme un correo personal, siempre tratare de ayudar lo mas posible. Si también lo desean pueden agregarme a sus círculos en Google+.

Saludos a todos y gracias por leer.




BDD con Cucumber y Java 1/2

En esta ocasión me voy a salir un poco del tema habitual de Android y celulares, en mi trabajo hemos estado un bastante ocupados y me pareció una buena oportunidad para hablarles sobre como hacer pruebas de comportamiento usando Java y Cucumber usando el framework (cucumber for jvm). Primero que nada durante el desarrollo de software es muy importante realizar la mayoría de pruebas posibles sobre tu código para asegurar la calidad, no mencionare las diferentes ideas y metodologías que existen sobre desarrollo y prueba de software ya que no es la finalidad de este articulo, cada equipo y/o desarrollador es responsable de como manejar su ciclo y asegurar que su aplicación no falle horriblemente.

Dentro de las diferentes técnicas de desarrollo de software; BDD (Behavior Driven Development) o desarrollo basado en comportamiento, se ha vuelto muy popular en varios proyectos de software grandes. Esta técnica complementa muy bien a la metodología ágil y TDD (Test Driven Development) las cuales son la forma y técnicas mas populares de desarrollar software en la actualidad (a mi parecer). Primero una poca de explicación sobre lo que es BDD. Como el nombre en ingles lo dice, este desarrollo se centra en el comportamiento de las cosas; basándose en que el modulo es una caja negra para el usuario. Esto quiere decir que el comportamiento se evalúa de acuerdo a las salidas que este presenta basado en determinadas entradas. En pocas palabras es describir el comportamiento y asegurarse que este comportamiento sea cumplido. La finalidad es que estos escenarios de comportamiento sean escritos por un agente externo, como un business user o un usuario avanzado, en su propio lenguaje (sin necesidad de un lenguaje de programación) y que estos comportamientos se prueben automáticamente en cierto punto del desarrollo.

Cuando iniciemos el desarrollo tendremos una lista de escenarios escritos por nuestro agente los cuales describirán los puntos a considerar para marcar el desarrollo como éxito o fracaso. Por ejemplo digamos que estamos escribiendo un programa que imite a una calculadora. Nuestro agente podría decir para que una calculadora sea efectiva debe de sumar, restar, multiplicar y dividir correctamente, por lo tanto nuestro usuario nos daría una lista de escenarios parecida a esta:

Escenario: Probar suma Escenario: Probar resta
Cuando escribo 2 en la calculadora Cuando escribo 5 en la calculadora
Y presiono la tecla + Y presiono la tecla -
Y escribo 5 en la calculadora Y escribo 2 en la calculadora
Y presiono la tecla = Y presiono la tecla =
Entonces El resultado sera 7 Entonces El resultado sera 3

Como se puede ver no es necesario ningún lenguaje de programación, nuestro agente puede especificar cualquier numero de escenarios y en cualquier formato (siempre y cuando siga algún tipo de regla que re pueda programar). Si estos pasos se cumplen al momento de ejecutar nuestra calculadora podemos decir que nuestro código ha sido exitoso.

Vean la segunda parte de este articulo para saber como utilizar Behavior Driven Development (BDD) con Cucumber y Java.

miércoles, 23 de enero de 2013

Android Screenshot

Hola que tal a todos, Muy feliz año 2013 en esta ocasión les quiero compartir una pequeña aplicación para demostrar como obtener un screenshot o una captura de pantalla de nuestra aplicación. Antes que nada una disculpa por no haber escrito tan constantemente como en anteriores ocasiones pero me he enfocado en mi trabajo y otros proyectos personales.

El como obtener una copia de una vista en android es muy sencillo, básicamente cualquier componente que nosotros necesitemos podemos copiar su bitmap en un punto determinado lo cual nos dará una imagen de este componente en el tiempo. Esta función es aplicable para nuestra vista principal también la cual nos dará el screenshot completo. El método se llama getDrawingCache(), lo que en realidad pasa es que esta vista regresa el cache que se utiliza para ser dibujada en pantalla en un objeto Bitmap, normalmente este cache esta des-habilitado y la función regresara null pero lo unico que tenemos que hacer antes de llamar al método es habilitarlo con la función: setDrawingCacheEnabled(true). Este bitmap luego puede ser transformado a algún otro formato compreso como PNG o JPEG  y guardado en nuestra SD card o cualquier otra locación.

Nota no hay que olvidarnos que luego de terminar es bueno des-habilitar el cache de nuestra vista ya que si no estaremos utilizando memoria en nuestra aplicación que no es necesaria. Muy bien a continuación el código de las funciones para tomar la imagen, transformarla a formato JPEG y guardarla en la carpeta de la Camara.


public void takeScreenshot(){
View v = findViewById(R.id.rootLayout);
v.setDrawingCacheEnabled(true);
Bitmap bitmap  = v.getDrawingCache();
String dest = Environment.getExternalStoragePublicDirectory( Environment.DIRECTORY_DCIM )
+File.separator+"Camera"+File.separator+"IMG_"+
new DateFormat().format("yyyyMMdd_hhmmss", new Date())
+".jpg";
Log.d(APP_TAG, "Writing to: "+dest);
File file = new File(dest);
try {
FileOutputStream stream = new FileOutputStream(file);
bitmap.compress(CompressFormat.JPEG, 100, stream);
stream.flush();
stream.close();
} catch (IOException e) {
Log.e(APP_TAG, "Error taking screenshot.",e);
}finally{
v.setDrawingCacheEnabled(false);
}
}

Este pequeño tutorial lo desarrolle a petición de un compañero desarrollador que tenia algunas dudas con esta tarea. Espero y les sea de utilidad. Si tienen alguna otra duda o quieren que publique algún otro tipo de tutorial siempre son bien recibidos los comentarios o pueden mandarme un email a cualquier hora. Un saludo a todos y espero ya poder volver a escribir con un poco mas de regularidad.

P.D si desean el codigo completo de esta aplicacion pueden clonar el repositorio de github donde esta almacenada el link es: git://github.com/ti3r/screenshot-android.git

viernes, 23 de noviembre de 2012

Android 4.2 Jelly Bean Update para Nexus Galaxy

  Hola que tal a todos, hoy les quiero compartir mi opinión acerca de Android 4.2 (todavía llamado Jelly Bean) que se ha estado enviando a varios celulares desde la semana pasada. Hace dos días recibí la actualización vía OTA y al instalarla lo primero en notar es el icono de la cámara. Así es en esta versión de android Google puso mucho empeño en la cámara de los dispositivos y en darnos la opción de sphere photo (foto esférica) así es que normal que sea el primer punto a notar. Esta opción permite tomar fotografías no solo panorámicas pero en todas direcciones y ensamblarlas en una esfera para dar una ilusión de 3D. Una gran característica si te apasiona la fotografía y tienes tiempo de fabricar una buena foto de un paisaje que te guste (por que toma bastante tiempo hacer una buena foto).

La segunda característica y la cual me encanta es la escritura por desliz. Esta característica ya estaba disponible en versiones anteriores de Android como en los Motorola Droid o utilizando aplicaciones externas como TouchPal, lo que permite es arrastrar el dedo por el teclado hacia diferentes teclas y escribir sin necesidad de estar haciendo clic en las diferentes teclas. Creanme es una opción que me encanta, al principio tal vez se les haga complejo escribir algunas palabras o si quieren usar algunas palabras fuera del diccionario (como wey, o hijola :) ) el teclado no las reconoce; pero una vez que llevan tiempo escribiendo y su diccionario ha crecido no podrán regresar al modo antiguo de presionar y presionar botones en pantalla.

La aplicación de reloj y alarma. Se que suena un poco tonto pero me encanta esta nueva versión, el diseño es genial y en esta ocasión cuenta con timer, que se pueden programar unos con otros. Es una gran ventaja para cuando estoy en el gimnasio. Jejejeej solo falta que se puedan programar uno después del otro para los ejercicios de rutina. Estoy tentado a descargar el código fuente de esta aplicación y modificar la para que se pueda hacer. Si tengo tiempo libre lo haré rápidamente y la compartiré con ustedes.

Las animaciones son otra característica que cambio un poco, al iniciar y salir del menú y cambiar de una aplicación a otra se pueden notar algunas variaciones en las animaciones, las cuales se ven esplendidas pero en ocasiones hacen que las transiciones no sean tan suaves como anteriormente lo eran. Tal vez sea por el hardware de mi Nexus Galaxy ya que este sistema esta optimizado para las nexus 7, 10 y el nuevo Nexus 4. Aunque es una pena ya que si esto persiste hará que la experiencia en el Galaxy Disminuya. Aun y cuando Google dice que con el project Butter las animaciones son mas suaves y las transiciones son mejor crean me después del update podrán notas uno o dos glitches que en la versión anterior no se notaban.

Aun y cuando las mejores características de este update solo se pueden ver en las Tablet Nexus esta actualización trae muy buenos features al Galaxy Nexus. Espero que comenten sus experiencias con esta nueva versión en sus dispositivos.