Continuar leyendo]]> Tras la primera jornada del Google I/O los desarrolladores nos hemos llevado una sorpresa mayúscula, al menos yo, con la presentación de este nuevo IDE. Google nos presenta Android Studio, un IDE basado en IntelliJ IDEA Community Edition y que promete simplificar las tareas de desarrollo.

Hace tiempo que muchos desarrolladores android me hablaron de las bondades de IntelliJ IDEA pero no fue hasta hace poco cuando me decidí a empezar a usarlo.

Sobra decir que la experiencia ha sido buenísima y así lo he trasladado cada vez que he tenido la oportunidad. No merece la pena entrar en comparaciones Eclipse / IntelliJ, simplemente juegan en otra liga (que no se sientan ofendidos los amantes del IDE creado por IBM). Pero vayamos por partes, ¿qué tiene este Android Studio que lo hace mejor?

Sistema de construcción

¡Por fin! gritarán algunos y es que si has programado en Eclipse habrás sentido el dolor de cabeza que puede causar empaquetar un proyecto android con este IDE. Android necesitaba un nuevo sistema de construcción y los chicos de Google han decidido optar por Gradle. Tengo que decir que no tengo gran experiencia con este sistema de construcción pero hay varias características que me gustan bastante:

• Utiliza un DSL (Lenguaje Específico de Dominio) basado en Groovy (nada de XMLs complejos)
• Nos permite añadirlo a nuestros servidores de integración continua
• Construcción por convención (al estilo Maven)
• Compatible con dependencias Maven

La construcción de android se consigue gracias a un plugin del que podemos consultar toda la documentación a través del siguiente enlace.

Ayudas para la codificación

Cuando te haces con el manejo descubres que el editor de código de Android Studio tiene unas características únicas que facilitan considerablemente el desarrollo. La edición es más fluida, la refactorización más potente y un análisis de código que nos ayudará a mejorar considerablemente nuestro código.

Hay que decir que muchas de las características del IDE Android Studio ya estaban incluidas en IntelliJ IDEA pero de ahora en adelante hablaremos de Android Studio.

Previsualización de recursos

Una de las características que más me gustan es la de poder previsualizar los recursos. Por ejemplo si estamos en un drawable, podemos poner el cursor sobre el identificador, pulsar Ctrl + Q (comando para ver la documentación) y visualizar de un plumazo los drawables a distintos recursos.

Algo parecido ocurre con los colores en el editor XML. Si ponemos un color nos aparecerá en la parte izquierda dicho color y al pulsar sobre él se nos mostrará un selector de color.

Generación de recursos

Android Studio incluye diálogos para facilitar la generación de recursos para distintas configuraciones. Uno de los mejores ejemplos es a la hora de crear un string. Podemos seleccionar el cualificador de región y se nos mostrará una lista de países que podemos ir seleccionando. Esto resulta tremendamente útil porque incorpora todos los cualifiadores con sus variantes así que no tendremos que recordarlos de memoria.

Detección de errores

Este IDE incorpora de forma transparente una herramienta de análisis de código que nos ayuda a mejorar la calidad del mismo. Además se realiza de forma automática, de forma que conforme vas escribiendo te va indicando posibles fallos o mejoras que puedes corregir en el código. Métodos sin utilizar, lógica demasiado compleja o condiciones que nunca van a darse serán detectadas por el IDE y nos permitirá con un “par de clicks” corregir dichos problemas.

Además este sistema de análisis lo han personalizado para que trabaje también sobre partes específicas de Android. Por ejemplo, el método getSystemService recibe un String como parámetro, así que en principio podríamos poner cualquier cadena. Si hacemos esto, el entorno nos mostrará un aviso de los posibles valores que deberían pasarse a dicho método.

Refactorización

La refactorización es mucho más potente en Android Studio. Ahora podemos cambiar el nombre de una imagen y automáticamente se cambiará el nombre del identificador. A la inversa funcionaría exactamente igual. IntelliJ posee un sistema de refactorización muy avanzado y Android Studio se beneficia de eso.

Ayudas para el diseño

La parte de diseño es quizás la que pueda quedarse algo más corta con respecto al IDE anterior. No obstante es una herramienta con muchas posibilidades y que en el estado actual cubre la mayoría de las opciones de las que disponíamos antes e incluye cosas que mejoran lo anterior.

La previsualización de los layouts está bastante cuidada, marcando los elementos sobre los que estamos trabajando y permitiendo elegir entre distintos dispotivos, configuraciones, temas, etc.

Acceso a los servicios de Google

Google ha hecho especial hincapié en facilitar el uso de sus servicios en nuestras aplicaciones. Lo hemos podido ver en las presentaciones del  Google Cloud Messaging (GCM) o en la presentación de Google Play Games. Con Android Studio quieren facilitar el acceso a todas estas herramientas desde nuestro entorno de desarrollo. Han empezado integrando los servicios del GCM y han introducido un nuevo plugin (ADT Translation Manager Plugin) para la traducción de nuestras aplicaciones e integrado con el servicio de traducción de la Google Play Developer Console.

Para finalizar, ¿qué mejor que Tor Norbye mostrándonos las principales características del Android Studio?

Por supuesto existen muchas más características que no hemos visto pero que iremos descubriendo con el uso por tanto os recomiendo que lo probéis y decidáis por vosotros mismos.

Importante: Como puede verse en la imagen que encabeza el artículo se trata de una versión preview. Esto quiere decir que no será todo lo estable que deseamos y que esta versión no se recomienda para un entorno de producción. En Windows por ejemplo da problemas, pero podemos solucionarlo (gracias a @DavidGNavas por el enlace) con lo que proponen en esta página.

Continuar leyendo]]> Cada dos años se celebran en Sevilla las jornadas de Imaginática en la Escuela de Ingeniería Informática, en las que se organizan charlas y actividades relacionadas con nuevas tecnologías. Este año Androcode estará allí. Mi compañero Fede y yo mismo daremos una charla sobre buenas prácticas en el desarrollo con Android.

Repasaremos las principales recomendaciones para hacer aplicaciones coherentes con el ecosistema Android, aprovechando todos los recursos a nuestra disposición, y que resulten en una experiencia de usuario lo más placentera posible. Básicamente, os conteremos las claves para hacer buenas aplicaciones. No será de alto nivel técnico, por lo que puede ser apta para cualquiera interesado en el mundo de las aplicaciones móviles.

La charla será en la ETSII el sábado 4 de mayo, en el aula A1.16 de 10:00 a 11:30. Podéis inscribiros en esta página para confirmar vuestra asistencia. La inscripción no es obligatoria pero sí recomendable, pues los inscritos tendrán preferencia en cuanto a aforo, recibirán una mochila del evento, entrarán en el sorteo de un iPod Shuffle y, si sois estudiantes de la escuela, es necesario para que os den créditos de libre configuración (aún no confirmado). Además, desde el jueves hay gran cantidad de charlas, muchas relacionadas con tecnologías móviles. Echad un ojo al horario oficial aquí.

Según nos han dicho la charla la grabarán en vídeo, aunque no nos han confirmado si se retransmitirán en directo o no. En cualquier caso nos aseguraremos de facilitaros todo el material que podamos tras la charla.

No lo dudéis, pasad a vernos si estáis cerca. Esperamos que lo que os enseñemos os ayude a hacer vuestras aplicaciones más geniales. Estaremos por allí el resto de la mañana y podemos extender la conversación si alguno quisiera

Enlaces:
Presentación de nuestra charla
Horario de charlas y talleres de las jornadas
Página de inscripción (opcional)

Continuar leyendo]]> Y ya estamos de vuelta después de las vacaciones de Semana Santa con la segunda parte del post sobre herramientas interesantes para trabajar con android desde fuera de Eclipse. Prometí 10 herramientas, divididas en dos partes, pero hoy os voy a presentar 6, para qué veaís lo generoso que soy…

Android Bootstrap

Con Android bootstrap puedes obtener un paquete con una base para tu aplicación ya preparado con sólo decirle el nombre que quieres para tu app y el nombre de paquete que le vas a dar, después te genera un zip donde ya viene integrada una implementación de Fragments, Fragment Pager, Account Manager, android-maven-plugin,Dagger, ActionBarSherlock 4,ViewPagerIndicator, http-request, GSON,Robotium para tests de integración, API Consumption con una API en Parse.com y mucho más.

http://www.androidbootstrap.com/

Android Kickstartr

Android kicktstartr es otra herramienta similar a la anterior con la diferencia de que en este caso podemos seleccionar las librerías que incluirá el paquete que nos descarguemos, desde una interfaz web, listas para ser usadas directamente. Cabe destacar que nos permite elegir si usamos Eclipse como IDE o no, si queremos una configuración de ProGuard para ofuscar el código o si queremos usar Maven. Entre las librerías que podemos incluir se encuentran AndroidAnnotations, ActionBarSherlock, NineOldAndroids, ACRA o Roboguice. Incluso el tipo de navegación de la action bar entre pestañas, desplegable o nada.

http://androidkickstartr.com/

Fluid UI

Fluid UI es una herramienta web para diseñar interfaces gráficos de usuario con plantillas para diversas plataformas móviles, incluyendo android 2 y android 4. Mediante el ratón podemos arrastrar y soltar componentes que son practicamente idénticos a los que encontraremos en la plataforma correspondiente. Tenemos la posibilidad de personalizar textos, colores y alineamientos, así como crear enlaces entre pantallas para luego, en el modo interactivo, poder hacer clic en los componentes y que nos lleven a otras pantallas. Tiene varios planes de precios y una cuenta gratuita que incluye un proyecto de hasta 10 pantallas y 10 Mb de subida de archivos.

http://www.fluidui.com/

Sensor simulator

Sensor simulator es otra herramienta que debería venir por defecto con Eclipse y el ADT. Nos permite simular los sensores del teléfono en un emulador, que obviamente no tiene estos sensores, de modo que podemos probar aplicaciones que los requieran y ver si funcionan correctamente gracias a esta útil herramienta. Entre los sensores que se pueden simular están el accelerómetro, giroscopio, temperatura, presión, proximidad, campo magnético, etc. Además también permite grabar los valores de un dispositivo real y luego reproducirlos en el emulador. Es de código abierto por lo que podemos ver cómo está hecho o aportar nuestro granito de arena al proyecto.

https://code.google.com/p/openintents/wiki/SensorSimulator

NinePatchEditor

¿No te gusta la herramienta draw9patch que viene con las herramientas de android? ¿Buscas algo más potente? Entonces Nine Patch Editor es lo que buscas. Es una aplicación en java para crear nuestros nine patch  a partir de imágenes png normales pero vitaminado con una serie de gías visuales tales como reglas, guías y dimensiones que junto a la previsualización libre nos dan mucha flexibilidad a la hora de conseguir que nuestros nine patch se vean perfectamente en cualquier tamaño y con cualquier contenido, sin que se nos deformen las partes que queremos conservar. Sin duda un gran avance respecto a la herramienta que viene por defecto con las Android Developer Tools

http://weblookandfeel.com/nine-patch-editor/

ShareKM

ShareKM es un descubrimiento reciente y me ha cambiado la vida, te permite escribir y usar el ratón en tu android conectado al PC de forma tan sencilla que sólo hay que llevar el ratón a un borde del monitor para que “entre” en tu teléfono y puedas manejarlo con el ratón o escribir con el teclado del ordenador. Además puedes usar los botones del ratón como si fueran las teclas atrás o menú. Mirad el siguiente vídeo y alucinad…

https://sites.google.com/site/droidskm/

LogCat beautifier

LogCat beautifier es una pequeña herramienta que hice un día de locura y que es bastante simple. Muchas veces te mandan o tienes que mandar una traza del logcat por email y te sale todo en negro y no se distingue fácilmente qué lineas son error, cuales son warnings, cuales no importan… así que con esta herramienta puedes colorear las líneas del log otra vez y así puedes enviarlas coloreadas o verlas mejor.

http://forgottenprojects.com/tools/android/logcat/

Y hasta aquí unas cuantas herramientas que ayudan en el desarrollo de aplicaciones, seguro que hay más utilidades interesantes o aparecen más en el futuro. Y si conocés más dignas de ser mencionadas, sólo tenéis que añadirlas a los comentarios de esta entrada.

Continuar leyendo]]> Hace poco tuve que pelearme con la generación de un ID único para el dispositivo o la instalación que estoy ejecutando de mi aplicación y tras buscar mucho por Internet encontré varias opciones pero siempre con algún inconveniente que hacía imposible su uso real.

Las distintas opciones que encontré (y sus inconvenientes) son estas:

• IMEI: Sólo disponible en dispositivos con SIM disponible. Necesita declarar permiso en el manifest.
• Secure.ANDROID_ID: Sólo existe desde Android 2.2 y con posibles valores duplicados entre dispositivos.
• MAC del WiFi/BT: Sólo funciona si está activo el receptor. Necesitamos pedir permiso en el manifest.
• Build.SERIAL: Disponible a partir de Android 2.3. Sólo obligatorio para dispositivos sin SIM.

Como podéis ver no hay nada que directamente nos identifique el dispositivo o la instalación de forma única y, por tanto, que podamos usar como ID de la misma.

Tras mucho pelearme me crucé con un snippet de código que Reto Meier indicó en el Google I/O de 2011 como mejor aproximación para obtener dicha identificación y que no tiene ninguno de los inconvenientes que sí veíamos en las opciones anteriores.

El snippet en concreto es este que os copio aquí debajo y que podéis pegar en cualquier clase de vuestro proyecto directamente ya que no necesita ningún permiso especial a declarar en el manifest y es compatible incluso con Android 1.0…

private static String uniqueID = null;
private static final String PREF_UNIQUE_ID = "PREF_UNIQUE_ID";

public synchronized static String id(Context context) {
	if (uniqueID == null) {
		SharedPreferences sharedPrefs = context.getSharedPreferences(PREF_UNIQUE_ID, Context.MODE_PRIVATE);
		uniqueID = sharedPrefs.getString(PREF_UNIQUE_ID, null);
		if (uniqueID == null) {
			uniqueID = UUID.randomUUID().toString();
			Editor editor = sharedPrefs.edit();
			editor.putString(PREF_UNIQUE_ID, uniqueID);
			editor.commit();
		}
	}
	return uniqueID;
}

Y para obtener el código desde cualquier punto de nuestro proyecto tan solo debemos llamar al método id() pasándole un objeto de tipo Context, por ejemplo:

String deviceID = id(Activity.this);

Y hasta aquí este pequeño snippet que seguro le dais un buen uso…

Continuar leyendo]]> Probablemente en las últimas semanas habréis oído hablar del widget DashClock, y no es para menos. Este widget pensado para usar en la pantalla de bloqueo de Android Jelly Bean 4.2 fue sacado al público recientemente por Roman Nurik, uno de los diseñadores del equipo de Google. Es una muestra de como hacer aprovechar la nueva función de widgets en la pantalla de bloqueo, de forma útil, minimalista y atractiva.

Pero hay una característica de este widget que a nosotros nos interesa especialmente: se pueden crear extensiones. Con relativamente poco esfuerzo podemos añadir funcionalidad al widget mediante aplicaciones externas, usando un sistema de módulos que el usuario puede añadir y quitar a su antojo. Hoy vamos a ver cómo podemos aprovechar la API de este magnífico widget.

Qué podemos hacer

La API de extensiones del widget es bastante simple y está muy bien documentada. Pero veamos un resumen de lo que podremos hacer. Aunque como todo widget puede colocarse en el escritorio, vamos a considerar durante todo el tutorial que lo usamos en la pantalla de bloqueo, pues es para lo que está diseñado.

Partes del widget y las extensiones

El widget tiene 2 modos: contraído y expandido. Cuando está contraído muestra la hora y a su derecha un máximo de 3 extensiones, con su icono y un (muy) breve texto. Al expandirlo se mostrará en su lugar un botón para abrir las preferencias, y debajo de la hora saldrán todas las extensiones activas en una lista vertical con el icono, un título y un mensaje opcional.

Las extensiones por lo tanto están compuestas por:

• Un icono, sencillo y monocolor.
• Un estado, una cadena de pocos caracteres (3-4 aprox.). Si contiene un y sólo un salto de línea, el estado usará una fuente más pequeña y ocupará 2 líneas. Aunque el autor recomienda evitarlo si es posible.
• Un título, que se usará en la forma expandida. Similar al estado, pero más largo. Puede contener varias líneas, aunque el widget limitará las que se muestran.
• Un cuerpo o mensaje, que se mostrará debajo del título en la forma expandida. Su función es mostrar información secundaria o adicional. Puede contener múltiples líneas, aunque el widget limitará las que se muestran.
• Un Intent, que se lanzará para abrir una actividad cuando se pulse en la extensión, tanto en la forma expandida como la contraída.
• Una actividad de ajustes, para personalizar parámetros de la extensión si lo necesitamos. Se abre desde la propia pantalla de configuración del widget.

Todos estos parámetros (salvo la actividad de ajustes) se recogen en la clase ExtensionData, que se usa para actualizar la información mostrada por el widget.

Por otra parte, los métodos y acciones más importantes que podemos usar y sobreescribir del widget son:

• onInitialize(boolean isReconect): Se llama cuando la extensión establece conexión con el widget. Aquí debemos hacer cualquier tarea de inicialización antes de que el widget empiece a pedir información a la extensión.
• onUpdateData(int reason): Se llama cuando el widget solicita información actualizada a la extensión. Aquí haremos las operaciones oportunas y le pasaremos al widget la información actualizada que queramos mostrar. Por defecto se llama aproximadamente una vez cada hora, pero puede llamarse en otras circunstancias. El motivo de la petición se indica mediante una constante que se le pasa como parámetro.
• publishUpdate(ExtensionData data): A través de este método actualizamos la información mostrada en el Widget. Como parámetro le pasamos la información que vimos en el apartado anterior.
• Dos métodos que en la mayoría de casos no serán necesarios: setUpdateWhenScreenOn y addWatchContentUris. El primero hace que se ejecute el onUpdateData al encender la pantalla, y el segundo lo hace cuando el contenido en una URI ha cambiado.

Con esto deberíamos tener una idea general de lo que nos permite hacer el Widget y cómo podemos aprovecharlo en nuestra aplicación.

Ejemplo: monitor de Twitter

Veamos un ejemplo sencillo de cómo desarrollaríamos una extensión para DashClock. Haremos una extensión que consulte periódicamente los resultados de una búsqueda en Twitter concreta para monitorizar lo que se habla de ello: el nombre de nuestra web, de nuestra aplicación, una marca, una persona…

Queremos que cuando encuentre nuevos Tweets nos aparezca una entrada en DashClock avisándonos. Lo ideal sería tener una aplicación completa haciendo las tareas y que ésta actualice el Widget cuando sea necesario, pero para el ejemplo nos limitaremos a hacerlo todo en la propia extensión.

El código completo de la aplicación está en un repositorio de GitHub, donde podéis consultar todos los detalles. A continuación voy a explicar las partes más significativas del código.

1. Importar librería

La API de DashClock viene en forma de librería jar que debemos importar en nuestro proyecto. Sólo hay que bajarla de la página de descargas alojada en Google Code, y añadirla a la carpeta libs del proyecto. Automáticamente debería añadirse al Build Path y ya estaremos listos para empezar a programar.

2. Registrar la extensión en el AndroidManifest.xml

En nuestro omnipresente AndroidManifest.xml añadimos una entrada de tipo service, pues eso es la extensión, como se muestra a continuación. Debemos asegurarnos de requerir el permiso READ_EXTENSION_DATA para que sólo DashClock pueda hacer uso de la extensión, además de varios campos meta-data para la versión del protocolo (de momento sólo hay 1), la descripción de la extensión (para mostrarse en la configuración del Widget), y la Activity de configuración de nuestra extensión (opcional).

<service
            android:name=".TwitterSearchExtension"
            android:icon="@drawable/ic_extension"
            android:label="@string/extension_title"
            android:permission="com.google.android.apps.dashclock.permission.READ_EXTENSION_DATA" >
            <intent-filter>
                <action android:name="com.google.android.apps.dashclock.Extension" />
            </intent-filter>

            <meta-data
                android:name="protocolVersion"
                android:value="1" />
            <meta-data
                android:name="description"
                android:value="@string/extension_description" />
            <!-- A settings activity is optional -->
            <meta-data
                android:name="settingsActivity"
                android:value=".ConfigActivity" />
        </service>

3. Extender DashClockExtension e implementar métodos

Ahora debemos extender la clase DashClockExtension y sobreescribir, como mínimo, el método onUpdateData. En nuestra clase también sobreescribiremos el onInitialize, pero sólo lo haremos para inicialización de propiedades.

@Override
    protected void onInitialize(boolean isReconnect) {
        /*
         * Aquí llamaríamos a setUpdateWhenScreenOn(boolean) o addWatchContentUris(String[]) si quisiéramos usar dichas funciones.
         * En este caso no lo hacemos
         */
        mPrefs = PreferenceManager.getDefaultSharedPreferences(this);
    }

    @Override
    protected void onUpdateData(int reason) {
        String busqueda = mPrefs.getString(QUERY, "androcode");

        // Creamos el objeto ExtensionData que rellenaremos con los datos que queremos mostrar en el Widget
        ExtensionData data = new ExtensionData();
        data.icon(R.drawable.ic_extension);
        data.clickIntent(new Intent(ACTION_RESULTS));

        try {
            // Hacemos la búsqueda en Twitter. Esto es independiente de nuestra extensión
            JSONArray tweets = getNewTweets(busqueda);
            Integer cantidad = tweets.length();
            String cantidadMostrar = (cantidad <= MAX_TWEETS) ? cantidad.toString() : MAX_TWEETS + "+";

            // Ahora sí, configuramos los datos del Widget
            data.status(cantidadMostrar);
            data.expandedTitle(getResources().getQuantityString(R.plurals.extension_content_title, cantidad, cantidadMostrar));
            data.expandedBody(String.format(getString(R.string.extension_content_body), busqueda));
            if (cantidad < 1) {
                data.visible(false); // Mientras no haya información ocultamos la extensión para dejar sitio a otras
            } else {
                data.visible(true);
            }
        } catch (Exception e) {
            // Normalmente haríamos otra cosa al capturar la excepción, pero esto viene bien para debug
            data.visible(true)
                    .expandedTitle(e.getClass().getCanonicalName())
                    .expandedBody(e.getMessage())
                    .status("ERROR");
        }

        // Y finalmente le decimos al Widget que actualice los datos
        publishUpdate(data);
    }

El método onUpdateData es bastante auto explicativo y está comentado. Pero repasemos brevemente lo que hace:

• Crea un nuevo objeto de tipo ExtensionData, que es el que debemos rellenar con los datos que queremos mostrar en el Widget y que ya vimos al principio del artículo. Le asigna el icono y un clickIntent, que se llamará cuando pulsemos la entrada de la extensión en el Widget. Más adelante veremos para qué.
• Obtiene un array de JSON que contiene los Tweets resultantes de la búsqueda. El método encargado de esta tarea no se muestra arriba porque no es relevante en cuanto a lo que quiero enseñar con este ejemplo, pero puedes consultarlo completo aquí.
• En el campo de estado de la extensión escribe el número de tweets nuevos encontrados. Recordad que éste debe ser un texto muy breve, debemos poner algo corto y relevante que se mostrará junto al icono de la extensión.
• En el título y cuerpo expandidos escribe un texto indicando el número de resultados y la cadena que se buscó, respectivamente. Estos textos pueden ser más largos y descriptivos que el estado. Podríamos incluso poner en el cuerpo el contenido de los primeros Tweets si quisiéramos.
• Establece como visible la extensión si hay más de 1 tweet nuevo. De lo contrario la oculta para no estorbar, siguiendo la premisa de “si no tienes nada bueno que decir, cállate”.
• Además captura las posibles excepciones (lanzadas por los métodos de consulta de Twitter), y de ocurrir alguna la mostramos en la propia extensión. Esto NO lo deberíamos hacer jamás para una extensión de verdad. En este caso es útil para hacer debug durante el desarrollo, pero en producción deberíamos tratar la excepción de forma más cuidadosa.
• Finalmente actualiza la información del Widget enviando los datos recogidos en nuestro ExtensionData mediante el método publishUpdate. Ahora el Widget se encarga del resto, y mostrará lo que le hemos mandado.

4. Activity de configuración y de respuesta

Por último, y de forma opcional, vamos a crear dos actividades: una para configurar la extensión y otra para abrirla cuando pulsemos sobre la extensión en el Widget.

La primera es muy simple, solamente tendrá un campo de texto donde configuraremos el texto que queremos que la extensión busque en Twitter. Haremos que automáticamente se guarde al salir de la Activity.

public class ConfigActivity extends Activity {

    private SharedPreferences mPrefs;
    private TextView mQuery;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_config);
        getActionBar().setDisplayHomeAsUpEnabled(true);

        mPrefs = PreferenceManager.getDefaultSharedPreferences(this);
        mQuery = (TextView) findViewById(R.id.query);

        // Coloca el texto que actualmente está guardado
        mQuery.setText(mPrefs.getString(TwitterSearchExtension.QUERY, "androcode"));
    }

    @Override
    protected void onPause() {
        super.onPause();
        mPrefs.edit()
                .putString(TwitterSearchExtension.QUERY, mQuery.getText().toString().trim()) //Guarda el texto para las búsquedas
                // Y elimina las referencias al último tweet consultado y último visto, puesto que la búsqueda es distinta.
                .putLong(TwitterSearchExtension.ULTIMO_TWEET_CONSULTADO, 0)
                .putLong(TwitterSearchExtension.ULTIMO_TWEET_VISTO, 0)
                .commit();
    }

    //...

}

La segunda Activity será más bien de pega. Si este fuera un caso real y estuviésemos integrando nuestra aplicación ya existente con DashClock seguramente querríamos mostrar una Activity de nuestra aplicación donde mostremos la lista de resultados, para llevar control de los resultados leídos y no leídos, entre otras cosas. Pero en nuestro ejemplo, lo único que haremos será abrir el navegador con la página de Twitter correspondiente a la búsqueda. Además, guardamos el valor del último Tweet consultado por la extensión como “visto”, para hacer las próximas buscas a partir de él.

public class ResultsActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        finish();

        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

        // Marcamos el último tweet consultado como último visto
        long ultimoConsultado = prefs.getLong(TwitterSearchExtension.ULTIMO_TWEET_CONSULTADO, 0);
        prefs.edit().putLong(TwitterSearchExtension.ULTIMO_TWEET_VISTO, ultimoConsultado).commit();

        // Abrimos la página de twitter, por hacer algo
        String query = prefs.getString(TwitterSearchExtension.QUERY, "androcode");
        startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://twitter.com/search?q=" + query)));
    }
}

Por suerte DashClock lanza una petición de actualización sobre las extensiones tanto al pulsar sobre la extensión como al salir de los ajustes, por lo que no tenemos que preocuparnos de reiniciar los datos mostrados en ambos casos. Cuando justo después se ejecute el onUpdateData ya estaremos preparados para devolver los datos correctos.

5. Resultado

Y con esto podemos instalar la aplicación y añadir nuestra extensión a DashClock para conseguir lo que veis en la captura del principio. ¿A que no ha sido para tanto?

Como dije antes, el código completo de la aplicación se encuentra publicado en este repositorio de GitHub. Además, si quieres probarla sin tener que compilar el código, puedes descargarla desde el Play Store aquí mismo.

Conclusión

DashClock nos ofrece grandes posibilidades a lo desarrolladores, puesto que ningún usuario en su sano juicio pondrá un widget completo en su pantalla de bloqueo (o incluso en el escritorio) para algo tan simple como lo que hemos visto en el ejemplo, pero quizás sí les gustaría centralizar pequeños fragmentos de información en un sitio. Es la gran ventaja que nos ofrece la barra de notificaciones de Android frente a mostrar un cuadro de diálogo modal interrumpiendo nuestro trabajo, pero llevado al área de la pantalla de bloqueo. Personalmente, habría preferido que Android 4.2 trajera por defecto algo como DashClock (con una API un poco más potente), en vez de eso de poner widgets completos.

Espero que con este artículo os animéis a crear extensiones de utilidad. Y sobre todo, si tenéis aplicaciones que podrían hacer uso del Widget, integrarlas. Es una buena forma darle visibilidad a tu aplicación frente al resto, y seguro que tus usuarios agradecen tener esta opción.

Enlaces: Descarga DashClock | Documentación oficial | Repositorio ejemplo

Continuar leyendo]]> Hola a todos, en este post voy a tratar de explicar qué es NFC, algunos usos que tiene y una explicación fácil para programar un editor de textos en NFC muy sencillo. Además, estad atentos al final porque regalaremos unos tags NFC para que probéis cómo hacerlo

El futuro y el presente de las microcomunicaciones. ¿Qué es NFC y de dónde viene?

Near Field Communication(NFC) es una tecnología de comunicación inalámbrica, de corto alcance y alta frecuencia que permite intercambio de datos entre dispositivos a menos de 10 cm.
Funciona en la banda de 16.56MHz, la cuál es una frecuencia libre que se puede usar sin licencias con distintas velocidades de 106kbit/s, 212kbit/s o 424kbit/s.

Es una evolución del anterior RFID(ISO 14443), un dispositivo NFC puede comunicarse con cualquier tarjeta inteligente y lector existentes dentro del estándar ISO/IEC 14443. La principal diferencia es que el alcance es mucho menor, por lo que se necesita que los dispositivos estén a escasos centímetros durante un instante para la transmisión de información. Aunque podría parecernos una limitación, más bien es una ventaja ya que el usuario es consciente del acto que está haciendo y refleja la voluntad de usar este servicio.

Su desarrollo comienza en 2002 y sus promotores fueron Philips y Sony para conseguir compatibilidad con sus tecnologías Mifare y FeliCa respectivamente. A finales de 2003 se aprueba como el estándar ISO 18092 y ECMA-340. En 2004 Nokia, Philips y Sony crearon NFC Forum. En 2006 salió al mercado el primer dispositivo con NFC desarrollado por Nokia , el Nokia 6131. En 2010 Samsung lanzó el primer dispositivo con Android y NFC, el Samsung Nexus S.

Usos de NFC

• Conexión entre dispositivos: Podemos vincular nuestro dispostivo Android con un altavoz inalámbrico, la TV, o el ordenador.
• Pago por NFC: Un ejemplo de esta aplicación puede ser Google Wallet. Una vez configurada tu tarjeta e identificada, sólo tenemos que realizar el pago acercando el dispositivo al lector y aceptar el pago. Esta opción la probé gracias a la MWC 2013 y me pareció de lo más simple, cómodo y eficaz para no tener que estar sacando la tarjeta, escribir el PIN… El dispositivo lo tenemos en la mano casi todo el día y es un simple gesto.
• Compartir archivos: Con la nueva versión de Android 4.1 Jelly Bean compartir archivos es fácil, simplemente con acercar dos dispositivos estos se vinculan automáticamente y podemos compartir fotos o información en general.
• Tags de Información: Durante la MWC nos encontramos muchos de estos Tags, con sólo acercar el dispositvo se nos abría la aplicación de GSMA con la información a tiempo real o una página web dónde encontrábamos la información, práctico y sencillo.
• Más usos: La posibilidad de usar NFC en la vida diaria es probablemente algo que haremos no en un tiempo muy lejano, esta tecnología tiene muchisimas posibilidades de uso común por su facilidad en el uso y la gran aceptación que está teniendo por los usuarios que poseen dispositivos con esta tecnología.

Desarrollo de un editor de etiquetas simple de NFC

Ahora voy a explicar un simple código para poder crear mensajes en Tags. En un tutorial más avanzado hablaré de compartir entre dispositivos y otros ejemplos que surjan. Este es un “tuto” introductorio para que veáis qué fácil es el desarrollo de un editor de Tag NFC

Creamos un nuevo proyecto llamado “es.androcode.nfc” con una simple Activity llamada MainActivity.
La parte más importante de nuestro proyecto además del Activity se encuentra en nuestro Manifest. La línea señalada es la que da permisos a la aplicación para usar el NFC de nuestro dispositivo.

Nuestro AndroidManifest.xml será como sigue:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.androcode.nfc"
    android:versionCode="1"
    android:versionName="1.0" >
    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="17" />
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.androcode.nfc.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
    <uses-permission android:name="android.permission.NFC" />
</manifest>

Una vez creado el Manifest, vamos a crear el layout activity_main que será nuestra simple interfaz.

Un simple LinearLayout con un TextView, un EditText donde escribiremos el mensaje que queremos que almacene nuestro Tag y un botón para crear la acción de escribir en el Tag.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Write you message: ">
    </TextView>

    <LinearLayout
        xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_marginTop="20sp" >

        <EditText
            android:id="@+id/edit_message"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_weight="2"
            android:hint="message" />

        <Button
            android:id="@+id/button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="Write!!" />
    </LinearLayout>

</LinearLayout>

Ahora estamos listos para crear la Activity que explico a continuación del código.

package com.androcode.nfc;

import java.io.IOException;
import java.io.UnsupportedEncodingException;

import android.nfc.FormatException;
import android.nfc.NdefMessage;
import android.nfc.NdefRecord;
import android.nfc.NfcAdapter;
import android.nfc.Tag;
import android.nfc.tech.Ndef;
import android.os.Bundle;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

@SuppressLint("NewApi")
public class MainActivity extends Activity {
	NfcAdapter adapter;
	PendingIntent pendingIntent;
	IntentFilter writeTagFilters[];
	boolean writeMode;
	Tag myTag;
	Context context;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //Definimos el layout a usar
        setContentView(R.layout.activity_main);
        context = this;
        //Los elementos que vamos a usar en el layout
        Button btnWrite = (Button)findViewById(R.id.button);
        final TextView message = (TextView)findViewById(R.id.edit_message);
        //setOnCLickListener hará la acción que necesitamos
        btnWrite.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
	  try{
              //Si no existe tag al que escribir, mostramos un mensaje de que no existe.
              if(myTag == null){
		Toast.makeText(context, context.getString(R.string.error_notag), Toast.LENGTH_LONG).show();
	      }else{
               //Llamamos al método write que definimos más adelante donde le pasamos por
               //parámetro el tag que hemos detectado y el mensaje a escribir.
		write(message.getText().toString(),myTag);
	        Toast.makeText(context, context.getString(R.string.ok_write), Toast.LENGTH_LONG).show();
	     }
	   }catch(IOException e){
	Toast.makeText(context, context.getString(R.string.error_write),Toast.LENGTH_LONG).show();
		e.printStackTrace();
	}catch(FormatException e){
       Toast.makeText(context, context.getString(R.string.error_write), Toast.LENGTH_LONG).show();
	e.printStackTrace();
	}
     }
  });

        adapter = NfcAdapter.getDefaultAdapter(this);
        pendingIntent = PendingIntent.getActivity(this, 0, new Intent(this,getClass()).addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP), 0);
        IntentFilter tagDetected = new IntentFilter(NfcAdapter.ACTION_TAG_DISCOVERED);
        tagDetected.addCategory(Intent.CATEGORY_DEFAULT);
        writeTagFilters = new IntentFilter[]{tagDetected};
    }
    //El método write es el más importante, será el que se encargue de crear el mensaje 
    //y escribirlo en nuestro tag.
    private void write(String text, Tag tag) throws IOException, FormatException{
      //Creamos un array de elementos NdefRecord. Este Objeto representa un registro del mensaje NDEF	
      //Para crear el objeto NdefRecord usamos el método createRecord(String s)
      NdefRecord[] records = {createRecord(text)};
      //NdefMessage encapsula un mensaje Ndef(NFC Data Exchange Format). Estos mensajes están 
      //compuestos por varios registros encapsulados por la clase NdefRecord      
      NdefMessage message = new NdefMessage(records);
      //Obtenemos una instancia de Ndef del Tag
      Ndef ndef = Ndef.get(tag);
      ndef.connect();
      ndef.writeNdefMessage(message);
      ndef.close();
    }
    //Método createRecord será el que nos codifique el mensaje para crear un NdefRecord
    @SuppressLint("NewApi") private NdefRecord createRecord(String text) throws UnsupportedEncodingException{
    	String lang = "us";
    	byte[] textBytes = text.getBytes();
    	byte[] langBytes = lang.getBytes("US-ASCII");
    	int langLength = langBytes.length;
    	int textLength = textBytes.length;
    	byte[] payLoad = new byte[1 + langLength + textLength];

    	payLoad[0] = (byte) langLength;

    	System.arraycopy(langBytes, 0, payLoad, 1, langLength);
    	System.arraycopy(textBytes, 0, payLoad, 1+langLength, textLength);

    	NdefRecord recordNFC = new NdefRecord(NdefRecord.TNF_WELL_KNOWN, NdefRecord.RTD_TEXT, new byte[0], payLoad);

    	return recordNFC;

    }
    //en onnewIntent manejamos el intent para encontrar el Tag
    @SuppressLint("NewApi") protected void onNewIntent(Intent intent){
    	if(NfcAdapter.ACTION_TAG_DISCOVERED.equals(intent.getAction())){
    		myTag = intent.getParcelableExtra(NfcAdapter.EXTRA_TAG);
    		Toast.makeText(this, this.getString(R.string.ok_detected) + myTag.toString(), Toast.LENGTH_LONG).show();

    	}
    }

    public void onPause(){
    	super.onPause();
    	WriteModeOff();
    }
    public void onResume(){
    	super.onResume();
    	WriteModeOn();
    }

    @SuppressLint("NewApi") private void WriteModeOn(){
    	writeMode = true;
    	adapter.enableForegroundDispatch(this, pendingIntent, writeTagFilters, null);
    }

    @SuppressLint("NewApi") private void WriteModeOff(){
		writeMode = false;
		adapter.disableForegroundDispatch(this);
    }
}

Como Adapter usamos el NfcAdapter que viene por defecto en nuestro dispositivo con NFC.

El PendingIntent que usamos, le pasamos como Flag el Intent.FLAG_ACTIVITY_SINGLE_TOP para que la Activity no se cree de nuevo y se reutilice si ya está presente en la pila de actividades.
Luego definimos el IntentFilter. Este IntentFilter será el que nos indique si un Tag es encontrado. Y a nuestro array de IntentFilters le añadimos éste que hemos creado.
Al método write le pasamos por parámetros el mensaje a escribir y el Tag. En createRecord creamos el NdefRecord. Con el objeto Ndef obtenemos el tag, escribimos el mensaje NdefRecord y cerramos.

Comprendiendo los mensajes NFC

Un mensaje NDEF está representado por la clase NdefMessage, que está compuesto por varios registros encapsulados de tipo NdefRecord. El primer registro de un mensaje NDEF determina cómo interpretar el conjunto del mensaje. Un registro NdefRecord tiene los siguientes campos:

• 3-bit TNF(Type Name Format) Campo que indicará cómo se interpretará el mensaje.
• length type: Formato del registro.
• length ID: Identificador único del registro.
• length payload: Datos.

Tipos de formato. Los TNFs vienen definidos por los siguientes tipos: TNF_EMPTY (Mensaje vacío), TNF_WELL_KNOWN(Mensaje bien definido.), TNF_MIME_MEDIA(Registro definido con un MIME-type), TNF_ABSOLUTE_URI(URI), TNF_EXTERNAL_TYPE(Tipo especial), TNF_UNKNOWN(Desconocido), TNF_UNCHANGED(Trozo del mensaje).
Cuando el TNF es del tipo TNF_WELL_KNOWN significa que el mensaje NDEF  tiene alguno de los siguientes RTDs: RTD_TEXT(Texto plano con ISO del idioma correspondiente), RTD_URI(Contiene una URI), RTD_SMART_POSTER(Contiene varios registros como URI, acciones,…)

Es un simple ejemplo de cómo hacer un editor de texto para un tag. Como véis no es nada complicado y bastante efectivo en un simple código de no más de 100 lineas tenemos una aplicación completa para poder interactuar con nuestro NFC Tag y probar así la API relacionada con NFC.

En próximos posts contaré más sobre NFC y algún ejemplo de nivel más avanzado.

Espero que os haya gustado

Sorteo de pines con Tag NFC

Aprovechando los pines con NFC que nos dieron en la MWC de Barcelona, vamos a sortear algunos de estos entre nuestros lectores. Participar es muy fácil, sólo queremos oir vuestras ideas para usos de los Tags. Aquí tenéis las bases del concurso y a continuación el formulario para participar.

Bases del concurso

• Para participar debes publicar un mensaje en Google+, Twitter o Facebook contando brevemente para qué usarías los pines NFC, con un enlace directo a esta publicación y el hashtag #AndrocodeNFC.
• Debes seguir la cuenta de Androcode de la red social que uses para participar. Aquí están nuestra cuenta de Google+, Twitter y Facebook.
• Introduce en el formulario los enlaces a cada publicación que escribas para participar. Tiene que ser un enlace directo a ésta, no a tu perfil.
• La publicación debe ser visible desde cualquier cuenta. De lo contrario no contará como válida.
• De entre todos los participantes el equipo del blog elegirá la idea más original, que recibirá 3 pines NFC. Entre los demás se elegirán aleatoriamente 4 ganadores y cada uno recibirá 2 pines.
• Sólo se puede participar 1 vez por persona. Si detectamos cualquier indicio de trampa el participante quedará fuera del sorteo. Sin embargo, por cada medio que se utilice para participar se tendrá una oportunidad de ganar. Por tanto si usas las tres redes sociales tendrás más posibilidad que usando sólo una.
• Se podrá participar hasta el domingo día 21 de abril, a las 12 de la noche. Descartaremos las participaciones inválidas y el miércoles siguiente publicaremos aquí los nombres de los ganadores y contactaremos con ellos por correo electrónico para concretar el envío.
• Si pasadas las 48 horas del envío del correo electrónico no obtenemos respuesta, el premio queda anulado y se lo pasaremos a otro participante escogido al azar.
• Por motivos de envío, el sorteo sólo es válido para España.

¡Mucha suerte a todos!

Continuar leyendo]]> Conseguir hacer un buen diseño para una aplicación a veces es complicado. Pequeños detalles como un color, un bordeado o la forma de un icono pueden cambiar drásticamente la impresión del usuario. Si bien es cierto que desde la incursión del estilo Holo en Android cada vez vemos más aplicaciones bien diseñadas, algunas se resisten al cambio. Por suerte tenemos las guías de diseño oficiales, y un número creciente de herramientas y recursos para ayudarnos en el desarrollo.

Para los iconos tenemos los incluídos en el sistema, que a veces no son la mejor opción ya que no son los mismos en todas las versiones de Android. También podemos generarlos sobre la marcha con Asset Studio (vía web o Eclipse) e incluirlos en nuestra aplicación. Pero a alguien se le ha ocurrido una forma aún más sencilla de usarlos: mediante tipografías.

Las fuentes o tipografías son poco más que paquetes de imágenes vectoriales en los que a cada una se le asigna un código de carácter. ¿Por qué no poner iconos en vez de letras, para poder insertarlos en cualquier campo de texto que permita elegir la fuente? Es lo que hacen los Android Dev Icons que han publicado Spiderfly Apps. 

Se trata de dos paquetes de fuentes en que los que cada letra usa un icono de diseño estándar para Android, que podemos descargar libremente desde su web. Podemos simplemente instalarlos en nuestro ordenador para usar en nuestra herramienta de diseño favorita, o insertarla en nuestra aplicación para sustituir las imágenes.

Con esta curiosa idea nos ahorramos lidiar con diferentes tamaños, varios colores, multitud de archivos… Sólo hay que cambiar las propiedades del texto y listo. Por supuesto hay cosas para las que se nos quedará corta, y habrá muchos otros iconos que simplemente no están en el pack y tendremos que añadir por nuestra cuenta. Pero sin duda se agradece toda la ayuda recibida, especialmente los que no contamos con un diseñador gráfico en nuestros proyectos.

Esperamos que con esto lo tengáis más fácil para crear magníficas aplicaciones.

Enlace: Descarga de las fuentes

Continuar leyendo]]> Gracias a la comunidad de Android existen multitud de herramientas para facilitarnos el diseño y desarrollo de aplicaciones en Android, y dado que el entorno de Eclipse es limitado y las herramientas que nos ofrece a veces no son muy prácticas, hay gente que se ha dedicado a desarrollar otras utilidades fuera de Eclipse que hay que reconocer que vienen muy bien, y en este artículo vamos a ver unas cuantas de ellas.

Android design preview

Es una herramienta para poder ver una parte del escritorio del ordenador directamente en nuestro dispositivo Android, como un escritorio remoto, sólo que en este caso seleccionamos una región de la pantalla, que puede ser un diseño que hayamos hecho en Photoshop con el tamaño de la pantalla del teléfono o tablet y así ver cómo quedaría, pudiendo cambiar partes del diseño y verlas reflejadas en el dispositivo sin tener que implementar el diseño o ni siquiera guardar la imagen, pasarla al teléfono y abrirla con el visor de imágenes. De esta manera agilizamos el proceso de prototipado de la interfaz hasta que esté a nuestro gusto y entonces pasemos a implementarla en xml.

http://code.google.com/p/android-ui-utils/

Android holo colors generator

Es otra herramienta online que nos facilita la tarea de crear temas y estilos con colores personalizados para interfaces tipo Holo, sólo tenemos que indicar el nombre, el color y qué componentes queremos personalizar, nos generará un zip con los archivos necesarios en varias densidades y con los diferentes estados, que sólo hay que poner en la carpeta de recursos de nuestro proyecto para poder usar el tema que acabamos de crear o seguir personalizando a partir de ahí.

http://android-holo-colors.com/

Android asset studio 

Ofrece una colección de generadores de iconos para diversas partes de nuestra app, por ejemplo, podemos generar iconos para el launcher, action bar, pestañas, notificaciones o items de menú para versiones anteriores a Honeycomb. En cualquier caso, empezamos eligiendo una imagen, o bien de nuestro disco duro o bien una imagen prediseñada de su colección de iconos sacados de Android o incluso podemos definir un texto como si fuera una imagen. Después podemos elegir el padding de la imagen. Dependiendo del tipo de icono que estemos generando nos permitirá elegir si queremos usar el tema Holo Dark o el Holo Light, o qué colores queremos para el icono y el fondo, etc. Al final podremos bajar el icono generado para distintas resoluciones o versiones de Android en caso de que sean diferentes (como los iconos de notificación).

http://android-ui-utils.googlecode.com/hg/asset-studio/dist/index.html

Device art generators

En este caso hay un par de generadores que son muy útiles para dar un toque más profesional a nuestras capturas de pantalla, añadiendo un marco de teléfono alrededor de ellas de modo que parece que es una foto de un smartphone corriendo nuestra aplicación. El más completo lo encontraremos en la web anterior, ya que no solo permite elegir teléfonos nexus sino que además podemos elegir otros dispositivos Samsung, HTC o Motorola, mientras que en cambio, Google ofrece también una herramienta para generar estos marcos para los screenshots pero en este caso sólo permite elegir dispositivos Nexus 

Completo: http://android-ui-utils.googlecode.com/hg/asset-studio/dist/device-frames.html
Oficial (menos completo): http://developer.android.com/distribute/promote/device-art.html

Action Bar style generator 

Éste generador merece ir aparte porque es un completísimo generador de estilos para la action bar. Incluso es compatible con estilos para ActionBarSherlock lo que lo hace aún más flexible. Empezamos eligiendo el tema base, sea Holo Dark, Holo Light, o Holo Dark con la ActionBar en color claro, como en ICS, luego si la queremos sólida o transparente, y a partir de ahi tiene un selector de colores para cada una de las partes personalizables, a saber: la propia action bar, las pestañas que aparecen debajo si usamos los “tabs” como método de navegación, el color de los menús emergentes, el color destacado o accent (es el que aparece en la pestaña seleccionada), luego, si vamos a usar la action bar contextual (la que aparece con las herramientas de copiar, cortar, etc. cuando seleccionas un elemento) también podemos definir el color de fondo y el color destacado. Una vez hemos personalizado la action bar y nos gusta como queda en la previsualización, podemos descargar en un zip los archivos que tenemos que poner en nuestro proyecto. Esta es una herramienta que nos ahorra mucho trabajo a la hora de personalizar el tema por defecto de Android 3.0 en adelante.

http://jgilfelt.github.com/android-actionbarstylegenerator/

Parcelabler 

Es una herramienta online para generar fácilmente clases java que implementen la interfaz Parcelable. En otro post explicamos cómo implementar la interfaz parcelable manualmente, pero ésta herramienta nos permite pegar el código de nuestra clase y nos genera el código necesario para implementar la interfaz, que no es difícil pero si un poco coñazo, de todos modos, parece un poco limitado y no soporta arrays o tipos complejos así que tendremos que añadir éstos a mano, pero aún así nos simplifica escribir bastante código. 

http://devk.it/proj/parcelabler/

Y esta ha sido la primera mitad de un gran post sobre herramientas fuera de Eclipse que ayudan bastante en el desarrollo de aplicaciones, tanto a nivel de código, de presentación o incluso de márketing. Espero que os haya gustado y nos vemos de nuevo la semana que viene con la segunda parte de este post.

Continuar leyendo]]> Cuando uno asiste a una feria de tecnología como es el Mobile World Congress, no espera que sea muy interesante para desarrolladores, más allá de los nuevos terminales y prototipos de dispositivos que se presentan. Afortunadamente, existe un evento paralelo de un día de duración llamado WIP Jam y organizado por Wireless Industry Partnership, que viene siendo habitual cada año y en el cual los developers tenemos nuestro día de charlas, concursos y hackathones. Competiciones donde conocer a otros compañeros y formar equipo para conseguir algunos de esos nuevos dispositivos tan codiciados.

Empresas como Facebook, PayPal o Intel estuvieron presentes para hablarnos de sus APIs y de cómo sacar provecho a sus tecnologías. Pese a ser un poco de autobombo, siempre puedes descubrir algo interesante, hacer esa pregunta que te tiene atascado o ganar algún juguetito. Cómo si no tuviéramos ya pocas tonterías que hemos ido recolectando por todos los stands…

De este año destacaría la charla de los ingenieros android de Facebook que estuvieron explicando un poco cómo usar el Facebook SDK 3.0 y cómo conseguir más instalaciones de tu app mediante anuncios. Intel también nos explicó cómo usar sus servicios en la nube y nos propuso utilizarlos para ganar un Ultrabook en su hackathon. En la sala principal pudimos oir a PayPal hablar de cómo integrar pagos en tus apps o mozilla hablando de HTML5 (que lo teníamos hasta en la sopa).

Ya que Google y su stand de android brillaron por su ausencia, al menos el GDG de Barcelona organizó un barcamp de android donde se pudo discutir algunos aspectos del SO móvil de Google.

Si eres desarrollador y asistes al MWC, sin duda este evento es para ti, una pena que sea el último día de congreso cuando uno está ya agotado de tanto caminar por los stands y de tanta fiesta cada día después del evento pero merece la pena hacerle un hueco ya que es de lo más interesante para nosotros los programadores.

Y de regalo un vídeo 

Continuar leyendo]]> Lo parezca o no, trabajar cómodo con nuestro entorno de desarrollo es muy importante de cara a la productividad. Es por eso que nos cuesta tanto cambiarnos a otro IDE cuando estamos acostumbrados a uno concreto. Nos sentimos perdidos, todo lo que es diferente nos parece peor. Porque no hay nada como escribir código cómodamente.

El post de hoy no es tan exclusivo para el desarrollo Android, pero como también nos afecta a nosotros me ha parecido bien tratarlo. Vamos a ver algunos trucos y consejos para escribir código aún más fácilmente, si estamos usando Eclipse.

Todo lo que se comenta en esta entrada son opiniones a título personal y como orientación Para gustos colores, si no te parecen buenos consejos o tienes otros mejores, cuéntanoslo en los comentarios

Como la lista es larga y variada os dejo un índice para localizar más rápidamente cada cosa:

Preparación del entorno

• Cambiar la codificación de caracteres
• Desactivar compilado automático y compilar todo
• Desactivar corrección ortográfica
• Explorador de paquetes en vista jerárquica

Ayuda para escribir código

• Punto y coma siempre al final
• Autocompletado de métodos mejorado
• Escapar Strings al pegar texto
• Acciones al guardar
• Formateo de código
• Etiquetas
• Plantillas de código
• Plantillas de ADT

Preparación del entorno

Lo primero que vamos a ver son algunos cambios en la configuración de Eclipse que podemos hacer para facilitarnos el trabajo. Aunque opciones hay muchas, éstas son las que me han parecido más útiles. Mi “must have” personal, lo primero que tengo que cambiar si hago una instalación nueva.

Cambiar la codificación de caracteres

Es un tema por el que me he echado las manos a la cabeza más de una vez. Y más de dos, y de trés… Trabajar con diferentes codificaciones es un infierno, sólo causará problemas. Eclipse por defecto en Windows utiliza una codificación, en Linux otra, y en OSX otra distinta. Si trabajas siempre en la misma máquina el problema puede pasar desapercibido, pero en cuanto migras un proyecto de sistema, se lo pasas a alguien, etc. verás como los caracteres especiales se han convertido en símbolos extraños.

Los angloparlantes no suelen tener graves problemas con esto, pues la mayoría de codificaciones respetan sus símbolos. Pero nosotros, con tanta tilde y símbolo raro, vamos a encontrarnos en apuros. Lo mejor es curarse en salud y cambiar desde un principio la codificación de todo el workspace, en el menú bajo Window > Preferences,  a una universal como UTF-8. 

Si lo hacéis no me lo agradeceréis porque no os daréis cuenta de que os ha servido. Pero si no, ya os arrepentiréis. 

Desactivar compilado automático y compilar todo

Por defecto Eclipse tiene activada la opción de compilar automáticamente nuestro proyecto cuando guardamos algún archivo modificado. Esto es especialmente problemático en Android cuando tenemos proyectos relativamente complejos, con varias librerías externas vinculadas y demás compilar puede llevar varios segundos o peor en ordenadores con pocos recursos (¿he oído minutos?). Y no es agradable que nos interrumpan el trabajo sólo por guardar los cambios. Por ello es de lo primero que desactivo cuando abro Eclipse por primera vez. Sólo hay que desmarcar la opción en Project > Build Automatically.

Aunque desactivando dicha opción tenemos el problema inconveniente de tener que compilar manualmente cuando lo necesitemos. Por suerte tenemos el atajo de teclado Ctrl+B para hacerlo a golpe de tecla, pero este atajo corresponde al comando Build All, es decir que nos compilará todos los proyectos de nuestro workspace. ¡Aún peor que lo anterior! Don’t panic, es tan fácil como cambiar el atajo para que ejecute el comando Build Project en su lugar, de esa forma la combinación te teclas sólo compilará el proyecto en el que nos encontremos en ese momento. En el apartado Keys de las preferencias buscamos el comando Build All y le anulamos el atajo de teclado con Unbind Command, luego seleccionamos Build Project y en Binding pulsamos la combinación Ctrl+B (u otra) para establecérsela.

Aunque para ejecutar no suele hacer falta compilar porque ya lo hace solo, ya sabemos cómo se pone de tonto a veces Eclipse. Es uno de los comandos que yo más utilizo.

Desactivar corrección ortográfica

Curiosamente Eclipse tiene corrector ortográfico para los comentarios y documentación. Pero a los hispanohablantes no nos sirve de mucho si escribimos en español porque sólo está en inglés. Podríamos descargar e instalar un diccionario en español, pero yo prefiero optar por desactivarlo por completo y quitarme las molestas líneas rojas que salen por todas partes.

Explorador de paquetes en vista jerárquica

El explorador de paquetes nos permite 2 formas básicas de visualizarlos: plana y jerárquica. Por defecto nos los muestra de forma plana, pero cuando tenemos muchos paquetes anidados la jerárquica permite verlos más claramente con su estructura de árbol. ¿No os parece?

Podéis usar la que más os guste, en cualquier caso el cambio es sencillo.

Ayuda para escribir código

Ahora veremos alguno ajustes orientados a facilitarnos la escritura de código. Eclipse permite un alto nivel de personalización, pero sólo veremos unos que me parecen muy interesantes. Como antes, recomiendo echar un ojo a todas las opciones y adaptarlo todo a nuestras necesidades.

Punto y coma siempre al final

En java las sentencias llevan un punto y coma al final. Parece una tontería, pero son incontables las veces que he tenido que desplazarme al final de la línea para poner un punto y coma. Con este cambio Eclipse colocará la puntuación correctamente al final de la línea aunque estemos editando en mitad, ahorrándonos un par de pulsaciones de tecla.

Autocompletado de métodos mejorado

El autocompletado de Eclipse es magnífico. Ctrl+Espacio es la combinación que más uso con diferencia, nos ahorra escribir una barbaridad de código. Pero algo que siempre me ha reventado es cómo al completar una variable o un método desde en medio inserta el texto en vez de modificarlo.

Pues hace poco descubrí que se podía cambiar para que sustituyera el resto del texto. De esa forma en el ejemplo anterior obtendríamos lo siguiente:

A mi me resulta muchísimo más útil la segunda transformación, y sólo hay que cambiar una opción:

Escapar Strings al pegar texto

Copiar y pegar es el recurso más utilizado. ¿Cuántas veces hemos pegado en una cadena un texto copiado de otra parte que contiene comillas y otros caracteres que necesitan ser escapados (como las comillas en un código html)? Activando esta opción no tendremos que hacerlo más, pues el texto se transformará automáticamente cuando lo peguemos para escapar dichos caracteres.

Aquí vemos cómo quedaría al pegar una cadena con comillas antes y después de activar esta opción:

Acciones al guardar

Nos puede venir bien que Eclipse haga determinadas cosas automáticamente cuando guardamos un archivo. Por ejemplo, que reorganice las importaciones de paquetes, o que formatee el código según las reglas que le digamos. Debo confesar que yo personalmente lo tengo desactivado, porque tengo la manía de guardar los cambios constantemente, y al procesar el archivo cada vez puedo notar el retraso en contadas ocasiones si el ordenador está pasando un mal rato y no lo soporto. Pero aun así, si no sois tan maníacos como yo seguro que agradecéis esta función.

Formateo de código

Otra de las funciones más útiles de Eclipse es el formateo de código automático, mediante la combinación de teclas Ctrl+Shift+F. Nosotros escribimos (o pegamos) un churro, con las identaciones mal puestas, espacios sobrantes, etc., y Eclipse nos deja un código limpio, claro y ordenado. Pero es importante para estar cómodos con nuestro IDE que nos produzca código que nos guste. Para ello viene bien echar unos minutos en revisar las opciones de personalización del formateo de código, que no son pocas. Podemos tener varios perfiles, e incluso configurar un perfil distinto para cada proyecto (modificando las preferencias del proyecto concreto, y no las globales). Para personalizarlos creamos uno nuevo o editamos el existente (habrá que guardarlo con otro nombre).

Aquí entran muy en juego los gustos de cada uno. Aconsejo mirar todas las opciones, elegir las que nos parezcan mejores, y volver a mirarlas tras llevar un tiempo con ellas para asegurarnos de que estamos cómodos con todas.

Os comento como ejemplo las que yo suelo cambiar, que son realmente pocas: En Identation pongo Tab Policy a Tabs Only, y activo Statements within switch body; en Line Wrapping pongo el Maximun line width a un valor alto como 200 para que no me divida las líneas, y activo Never join already wrapped lines por si quiero dividirlas  manualmente; y por último en Comments activo Never join lines para decidir yo los saltos de línea, y pongo el Maximun line width también a un valor como 200. 

Mucho ojo a esta función si trabajamos en grupo con repositorios, o si contribuímos a proyectos de software libre. Debemos adaptarnos a las normas comunes, así que si pensamos dejar que Eclipse formatee nuestro código debemos asegurarnos de respetar dichas normas. No queremos que Git nos marque todo el archivo “en rojo” cuando sólo hemos cambiado una línea, ¿verdad?

Etiquetas

No muy usadas, pero están ahí para ayudar a organizarnos si las necesitamos. Las etiquetas son comentarios especiales que podemos poner para marcar nuestro código. La más famosa es la etiqueta TODO, para dejar anotado algo que tenemos que hacer o cambiar en un futuro. Pero nosotros mismos podemos crear nuestras etiquetas personalizadas. Por ejemplo DEBUG para indicar algo que debemos quitar antes de sacar la aplicación a producción,  asignar tareas a determinadas personas en un grupo, etc. 

Luego podemos ver la lista de etiquetas usadas en la vista Tasks (Si no la tenemos se activa en Window > Show View > Tasks)

Plantillas de código

Eclipse nos permite usar palabras clave para generar automáticamente determinadas estructuras de código, y más aún, crearlas a nuestro gusto. Por ejemplo, uno de los métodos más utilizados en Java es System.out.println() para imprimir texto en la consola; pues nos basta con escribir en el editor “sysout” y pulsar el autocompletado (ctrl+espacio) para que nos inserte la línea completa y nos ponga el cursor en la posición del argumento. Lo mismo ocurre con “try” para insertar un bloque try-catch.

La lista completa podemos verla en las preferencias, y ahí mismo podemos añadir nuestras propias plantillas. Por ejemplo, podríamos crear una plantilla así para inicializar el método getView() típico del BaseAdapter: 

Copiar código

Y en el editor de código, poniendo la palabra clave con autocompletado, nos genera el código por el que podemos movernos mediante el tabulador. ¡Magia!

Plantillas de ADT

No hace mucho añadieron al plugin ADT la posibilidad de crear componentes de Android como Actividades para nuestras aplicaciones mediante un asistente, que podemos encontrar en el menú File > New bajo la categoría de Android, el cual nos genera el código y recursos que podemos editar fácilmente. Por ejemplo, en el caso de las Actividades nos creará un layout y menú básicos en xml, la clase Java correspondiente con el código para mostrar el layout y el menú, y la entrada necesaria en el AndroidManifest.xml. E incluso podemos decirle que nos añada elementos extra de navegación como pestañas, ViewPager y más.

Por si fuera poco, un tiempo después añadieron la posibilidad de instalar plantillas personalizadas creadas por nosotros mismos. Yo os recomiendo estas plantillas creadas por Jeff Gilfelt para crear Actividades compatibles con la magnífica librería ActionBar Sherlock, entre otras. En el repositorio tenéis más información sobre para qué es cada uno de los elementos que añade. Además, instalar las plantillas es tan sencillo como pegarlas en la carpeta /extras/templates/ del SDK.

Tenéis más información sobre cómo crear plantillas en este post de Google+. ¿Se os ocurren más plantillas útiles? ¿Os animáis a hacerlas y compartirlas?

Y hasta aquí los cambios que os sugerimos para vuestro IDE, espero que algunos os resulten tan útiles como a mi. En futuras entregas intentaremos contar otros trucos a la hora de usar Eclipse. Si tenéis más sugerencias relacionadas son bienvenidas en los comentarios 

Fuentes: Vogella y cosecha propia