Usar Facebook-SDK cón Python-for-Android / Kivy

kivy-logo-black-512 Para un nuevo proyecto interactivo con un museo, Arnaud de devosite me pidió de mirar si se podía integrar con Facebook en una Aplicación para Android. La librería habitual en python esta pensada para aplicaciones Desktop, y abre manualmente una ventana del navegador web para capturar la autorización del usuario. Pero esto no es realmente lo que queremos, seria mejor remplazarlo por una integración 100% nativa.

Los pre requisitos:
- Kivy ( Python-for-Android )
En este Blog pueden encontrar el tutorial para instalar Py4a
- Una cuenta en Facebook ( obviamente )
- Facebook SDK 3.0

El código fuente:
Se puede clonar el repositorio del ejemplo en github:

$ git clone https://github.com/tito/p4a-facebook-example

Registrar una aplicación en Facebook:

  1. Ir a la página de Facebook para desarrolladores
  2. Hacen Click en “Create new App”
  3. Llenar la información “App Name”. no poner “FB” o “Facebook” en el titulo, o sino su aplicación se considerada inválida.:D
  4. Sélection_108

  5. Pasar el Captcha
  6. Guardar el id de su aplicación en algun lado.
  7. Ahora, necesitan activar la aplicación Nativa para Android. Es importante que el nombre de su package debe ser el mismo que el que escriben en la opción de compilación –package esto es cuando se ejecuta el build del APK. El nombre de la Clase es un nombre de package: package/Activity es siempre lo mismo para todas las aplicaciones compiladas con Python-For-Android.
  8. Sélection_109

  9. Ahora, el SDK de Facebook para Android no va a autorizar nuestra aplicacion android, porque facebbok quiere saber la firma de tipo hash que va ser utilizada en nuestro APK. Para generar este Hash, van a necesitar usar el Keytool. Aqui un ejemplo para generar una simple clave debug:
    $ keytool -exportcert -alias androiddebugkey \
       -keystore ~/.android/debug.keystore | \
       openssl sha1 -binary | openssl base64
    Enter keystore password:  android
    u+bzQmG87L298C4KGM8yODi3W/4=

    Copien esta clave generada, y la pegan en este campo:

  10. Sélection_110

Configuración Set up de nuestra aplicación:

  1. Ir a nuestro proyecto p4a-facebook-example, y editan el main.py
  2. Buscar FACEBOOK_APP_ID, y remplazen por nuestra propio ID de Aplicación.
  3. Ir a python-for-android, y crear una distribución:
    $ ./distribute.sh -m 'kivy'
  4. Ir a dist/default
  5. Generar nuestro APK una vez ( para generar todo el archivo necesitamos customizar ). Remplazen /path/to/p4a-facebook-example:
    ./build.py --name "Facebook test" --package org.test.facebook \
      --version 1 --private /path/to/p4a-facebook-example/ \
      --window --permission INTERNET debug
  6. Agregar una nueva referencia a project.properties para incluir el SDK de Facebook. El path a Facebook SDK debe ser un path relativo, sino tendran problemas para correr el siguiente build:
    android.library.reference.1=../../facebook-android-sdk-3.0.2/facebook
  7. Editar el manifiesto en: templates/AndroidManifest.xml para incluir el Activity de nuestro Login de facebook, justo despues de < application >
    <application android:label="@string/appName" android:icon="@drawable/icon">
    <activity android:name="com.facebook.LoginActivity"/>
  8. Volver a lanzar la compilacion del APK… y estamos listo para probar :D
  9. Instalar la aplicación en su dispositivo desde este comando:
    $ adb install -r bin/Facebooktest-1-debug.apk

Prueban su aplicación:

El SDK de Facebook 3.0 requiere separar permisos de lectura y escritura. Esto significa que a su usuario tienen que aceptar dos veces los diálogos de la pagina de facebook. Si quieren publicar en el stream de la aplicación, necesita tener un permiso básico ( Lectura ) aceptado por el usuario antes de publicar los permisos. Esto esta ya implementado en la aplicación de ejemplo.

Cuando inician la aplicación por la primera vez, van a tener:
device-2013-08-08-110647-1024x640

Dependiendo si se trata de una aplicación nativa o no, tendrán 2 tipos de cajas para la autentificación.

Sin la app de facebook instalada en el dispositivo:
device-2013-08-08-110834

Y con la app de facebook instalada en el dispositivo:
device-2013-08-08-111002

Después de la autentificacion, el usuario va a necesitar nuestros permisos:
device-2013-08-08-111111

Hecho !

Ahora la aplicación cuenta con los permisos para crear un Post ! El Post de ejemplo en el stream del usuario es la aplicación ella misma, y no el usuario. Se llama “publish_actions”.

Mas lejo:

Obviamente, cuando están desarrollando con el SDK de Facebook, se siente un dolor ajeno por el diseño mismo de la API, que fue diseñado para Java. Cada Callback que facebook quiera llamar, se necesita implementar una clase de Java, y definir un metodo callback. Python es realmente de una filosofía simple y lo hace mucho mas divertido para usar.

Vean ustedes mismo: hagamos un llamado a Request.newStatusUpdaterequest. Necesitamos implementar una clase GraphUserCallBack en Java. Gracias a Pyjnius, lo hacemos directamente desde Python.

class _FacebookGraphUserCallback(PythonJavaClass):
 
    __javainterfaces__ = ['com.facebook.Request$GraphUserCallback']
    __javacontext__ = 'app'
 
    def __init__(self, callback):
        self.callback = callback
        super(_FacebookGraphUserCallback, self).__init__()
 
    @java_method('(Lcom/facebook/model/GraphUser;Lcom/facebook/Response;)V')
    def onCompleted(self, user, response):
        self.callback(user, response)

La clase de Python/Java va a llamar nuestro propio python callback cuando el Callback de Java onCompleted va a ser llamado. Luego:

  @run_on_ui_thread
    def post(self, text, callback):
        req = Request.newStatusUpdateRequest(
                self._session, text, _FacebookRequestCallback(callback))
        req.executeAsync()

Todo lo que hay que hacer al final es poner el metodo post:

def fb_post(self, text):
        def callback(*args):
            from time import time
            self.post_status = 'message posted at {}'.format(time())
        self.facebook.post(text, callback=callback)

No estoy proviendo un wrapper para todos los llamados posibles que se puedan hacer con facebook. Solo tengo este ejemplo de “post” y “me”. Ambos wrapper Request.newStatusUpdaterequest y Request.newMeRequest.

Noten que a cada una de estas peticiones deben occurrir en el UI thread.

Para esto recomiendo usar el modulo de python-for-android/runnable, con el decorator @run_on_ui_thread.

El final

No era muy fácil encontrar la solución, y es siempre complejo poner todas las piezas juntas. He probado de usar nuestro propio LoginButton ( porque el cliente me decían como lo querían ), Pero no fue posible usarlo en nuestra aplicación. Más que nada porque el LoginButton es un puro Android Widget, y por la simple razón que no querríamos devolvernos al Activity después del Login. Estuve bloqueado mucho tiempo con esto.

Noten que no pueden compartir la aplicacion con un Fake facebook button, el diseño y look-and-feel tienen que ser el mismo que el original.

Espero que esto le vienen de gran ayuda para empezar!

Post original en ingles escrito por Mathieu Virbel: http://txzone.net/2013/08/using-facebook-sdk-with-python-for-android-kivy/

Publicado en kivy, Python4Android | 1 comentario

Configurar plugin de Maven para Android en Eclipse

En un Post anterior explicaba como se puede trabajar con Ant, Gradle o Maven para poder automatizar las tareas de compilación, de testing, de empaquetamiento de su aplicación Android. Desde linea de comando Maven funciona sin problema, pero tambien nos ayuda en el desarrollo de nuestra aplicación cuando estamos dentro de nuestro entorno de trabajo, por ejemplo con Eclipse.

Aqui les muestro paso a paso el proceso de instalación para tener instalado correctamente el plugin de m2e-Android y el akquinet android-archetypes dentro de su entorno de trabajo.

- Instalar el Java JDK y instalar Eclipse Indigo o Juno (versión Classic o Eclipse IDE para Developers Java).
- Luego instalar el ADT de google con “software update” y la url de Google Eclipse Plugin.
- Luego ir al marketplace. Si estas con Eclipse Classic, nos toca instalar tambien el Marketplace.
- Para instalar el Marketplace vamos “Install new Software”, y seleccionamos la url de Eclipse Juno/Indigo. Luego escribimos “MarketPlace” en el campo de búsqueda. Y seleccionamos el objeto que aparece. Luego reiniciamos nuestro IDE para que Eclipse tome en cuenta los cambios efectuados.
- Abrimos esta vez el MarketPlace, y escribimos en el campo de búsqueda “m2e android”.

marketplace

Marketplace3

Marketplace2

m2e_eclipse_plugin

- Ahora se puede crear un proyecto nuevo. No vamos a eligir un “Android Project” sino un “Maven Project”.
maven_project

- Como es la primera vez tenemos que agregar un archetype nuevo para android.
archetype_quickstart

El archetype es un template para Maven. También podríamos crear nuestro template desde la linea de comando:

mvn archetype:generate \
  -DarchetypeArtifactId=android-quickstart \
  -DarchetypeGroupId=de.akquinet.android.archetypes \
  -DarchetypeVersion=1.0.6 \
  -DgroupId=your.company \
  -DartifactId=my-android-application
cd my-android-project
mvn clean install

Pero desde el wizard de creación de proyecto del Eclipse podemos agregar el template para android de la siguiente forma.

new_archetype

Creamos nuestro proyecto. Y finalizar.
new_project

El proyecto va a venir ya preconfigurado con la API 16 de Android, y hay que corregir el path al source de Test. Creamos dos carpetas que corrige este problema “src/test/java”. Luego podemos abrir el archivo pom.xml. y agregar los siguientes tags de configuracion para que Maven encuentra el SDK de Android.

El archivo pom.xml final.

Hacemos, botón derecho sobre el proyecto, buscamos la opción maven > update project. Y actualizamos nuestro proyecto con las dependencias que se descargaran desde el repositorio de Maven.

Luego podemos hacer un : android:install para generar las clases binarias y compilar el APK en la carpeta Target.

De hecho para ejecutar cualquier comando de maven como un android:install se puede ejecutar desde el mismo menú con el botón derecho o sino accediendo a Run Configurations.

run_configurations

Y compilamos a partir de Run.
android_install

Y la clave final, es compilar su proyecto y iniciarlo directamente en un emulador que se encuentra activo ( o en el dispositivo que se encuentra conectado ). Esto es posible con este comando:

mvn install android:deploy android:run

Referencias:
http://rgladwell.github.io/m2e-android/

http://stand.spree.de/wiki_details_maven_archetypes

Publicado en Android | Deja un comentario

Tutorial de ActionBarSherlock en Android

Desde que google lanzó su versión de HoneyComb (API 11) hace unos años, la api de Android cuenta con unos componentes visuales nuevos como el ActionBar. Pero estas mejoras de los componentes UIs y de las interfaces no tienen en cuenta las versiones anteriores del sistema . Este ActionBar ya esta siendo muy usado por muchos desarrolladores en muchos proyectos, y para resolver el tema de compatibilidad con las versiones anteriores a la API 11, Jack Wharton creó una librería, ahora indispensable, que permite agregar el ActionBar a tu proyecto sin la necesidad usar Fragments y de esta forma dar la posibilidad a todas las versiones del sistema operativo de poder beneficiarse de la misma interfaz.

ActionBar

En este tutorial les muestro en pocos pasos como se instala el ActionBarSherlock para todos sus proyectos con el SDK de Android.

El primer paso consiste en descargar la librería, la cual se puede hacer desde la pagina http://actionbarsherlock.com/ o también se puede hacer clone del repositorio de github en alguna parte de su desktop.

$ git clone git@github.com:JakeWharton/ActionBarSherlock.git

Una vez que tienes descargado todo el proyecto con los ejemplos, ya podes empezar a importarlo en Eclipse.

Existing Android Code to Workspace

File > import > Existing Android Code To Workspace

Antes de importar el proyecto, se debe activar la opción de copiar el proyecto en su Workspace.

copiar el proyecto en su Workspace

Ahora bien, si nos aparecen muchos errores, no nos alarmemos, vamos directamente a las propiedades del proyecto, y seleccionamos el Compilador Compliance para este proyecto; a saber la versión 1.6.

En las propiedades de la carpeta de ActionBarSherlock hay que fijarse si eclipse importó el proyecto como una Librería. Si no es el caso entonces podemos tildar la opción “Library”.

Libreria

Luego ya podemos crear nuestro proyecto vacío como de costumbre y buscar ActionBarSherlock en la lista de librerías disponibles.

ActionBarSherlock como Libreria

Luego hay que abrir nuestro archivo AndroidManifest.xml y remplazar android:theme=”@style/AppTheme” por android:theme=”@style/Theme.Sherlock”

En nuestro Activity principal, en vez de heredar de la clase Activity del SDK de android, la remplazamos por la Clase SherlockActivity.

public class MainActivity extends SherlockActivity {

	protected Context context;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		context = getApplicationContext();
		getSupportActionBar().setTitle(R.string.app_name);
		getSupportActionBar().setLogo(R.drawable.androidda_icon);
        getSupportActionBar().setHomeButtonEnabled(true);
        getSupportActionBar().setDisplayShowHomeEnabled(true);
	}

	@Override
	public boolean onCreateOptionsMenu(com.actionbarsherlock.view.Menu menu) {
		MenuInflater inflater = getSupportMenuInflater();
		inflater.inflate(R.menu.main, menu);
		return super.onCreateOptionsMenu(menu);
	}

}
Publicado en Android | 5 comentarios

Primeros pasos con Android Studio, el nuevo IDE para desarrollar en Android

androidstudioEl nuevo IDE para desarrollar en Android que fue presentado en este Google I/O 2013, ya no es parte del proyecto Eclipse sino de IntelliJ otro entorno de desarrollo para la plataforma Java, ya muy conocido para los que trabajaron en Clojure, Scala, Groovy y tambien era una opcion para desarrollar en Android. El Android Studio no es un plugin de Intellij no hay que buscarlo en la lista de plugins. Lo tienes que descargar nuevamente desde la pagina de Google Developers.

http://developer.android.com/sdk/installing/studio.html

Instalación en Ubuntu de Android Studio

tar xzvf ~/Downloads/android-studio-bundle-130.677228-linux.tgz

Se debe tener previamente instalado el Java de Oracle:

sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update && sudo apt-get install
sudo apt-get install oracle-java8-installer

Acceptamos la licencia. y lo ejecutamos como default usando este comando:

sudo apt-get install oracle-java8-set-default

Tambien se puede descargar el JDK desde la pagina de oracle

cd android-studio/bin && ./studio.sh

Luego una vez instalado lo ejecutas normalmente, y vas a ver que el programa se pone a descargar Gradle. Esto es normal, Google ya nos había anunciado que migraría su script de compilación con Ant hacia Gradle.

Android Studio te instala de nuevo el SDK de Android
en MAC:
/Applications/Android\ Studio.app/sdk/
en Windows:
\Users\\AppData\Local\Android\android-studio\sdk\

Para instalar en windows te recomiendo este post

Cuando creamos un nuevo proyecto las cosas no cambian mucho del Asistente en Eclipse. pero si miramos en la carpeta del proyecto podemos ya encontrar un build.gradle. Que es nuestro nuevo asistente de compilación, eso NO significa que no contamos más con el AndroidManifext.xml. Esto no ha cambiado, sigue siendo un xml nuestro archivo de configuración para el package de nuestra app. Lo que ha cambiado es el build system de Android

buildscript {
    repositories {
        maven { url 'http://repo1.maven.org/maven2' }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:0.4'
    }
}
apply plugin: 'android'

dependencies {
    compile files('libs/android-support-v4.jar')
}

android {
    compileSdkVersion 17
    buildToolsVersion "17.0.0"

    defaultConfig {
        minSdkVersion 7
        targetSdkVersion 16
    }
}

importar proyectos existentes en Android Studio

Si queres importar un proyecto desde Eclipse, lo vas a poder hacer con la ultima version del ADT de Eclipse, ya ofrece la opción de generar un build.gradle para tu proyecto, busca en “Export”>”Android”>”Generate Gradle build files”. Luego Android Studio podrá reconocerlo normalmente como un proyecto compatible.

Nuevo Asistente de diseño para manejar los layouts

preview

Con IntelliJ Google nos mejoró considerablemente el asistente para la vista de diseño de tu apps et de sus componentes. En Eclipse esta parte de los layouts tenia la costumbre de generar muchos problemas, y generar errores en los xml, ahora con IntelliJ se ha mejorado mucho el rendimiento, la velocidad para acceder a las previsualizaciones es realmente performante.

Captura de pantalla 2013-05-15 a la(s) 21.56.00

Para abrir el modo de previsualizacion, uno va buscar un archivo layout xml, lo abre, y lluego va a buscar en el menu de arriba a la izquierda las opciones de previsualizaciones.

Bueno hasta aqui llegamos, ahora voy a investigar un poco más el Android Studio con un proyecto real y luego compartiré mis impresiones en un articulo que publicaré aqui. Les dejo este video de Google I/O sobre las nuevas funcionalidades de Android Studio.

Google I/O 2013 – What’s new with Android Developers Tools

Publicado en Android | 19 comentarios

Instalar Python en un dispositivo Android

Si necesitas tener el interprete python en un dispositivo Android, y sin necesidad de root, no hay más simple te recomiendo este proyecto SL4A.
Se descarga este APK sl4a_r4 en tu dispositivo android.
Luego se instala el interprete Python con el PythonForAndroid_r4.apk
En caso que no tenés un dispositivo Android, podes simplemente utilizar el emulador de Android.
Esto son los package que se van a instalar:
python_r16.zip
python_extras_r14.zip
python_scripts_r14.zip
python_scripts_r13.zip
python_extras_r13.zip

Y ya tenés el interprete python 2.6.2 instalado en tu android.

Las funcionalidades que podes acceder a traves de SL4A.

  • ActivityResultAndroid
  • ApplicationManager
  • BatteryManager
  • Camera
  • CommonIntents
  • Contacts
  • Event
  • EyesFree
  • Location
  • MediaPlayer
  • MediaRecorderPhone
  • Preferences
  • SensorManager
  • Settings
  • Sms
  • SpeechRecognition
  • ToneGenerator
  • WakeLock
  • Wifi
  • UI

Con install Modules podes instalar más modulos de Python si lo necesitas.

[UPDATE] Con QPython se puede generar un QRcode de tus escripts en python para ser leído después desde tu dispositivo:
http://qpython.com/create.php

Tutoriales para SL4A :
https://code.google.com/p/android-scripting/wiki/Tutorials

Publicado en Android, Python4Android | 3 comentarios

Como configurar un servidor Jenkins para deploys de aplicaciones en Android

Introducción
Jenkins es una herramienta de integración continua, que es open source. Podes encontrar el código fuente de Jenkins en Github.

Cuando un equipo de desarrollo se ayuda de Jenkins (basado sobre Hudson), es que la cadena de producción ya es cubierta por varias herramientas que pueden ser consultadas via un servicio web y que se encargue de los deployments de los proyectos Android que mantenemos activos. Sobre todo cuando se requiere por ejemplo un issue-tracking, un wiki, y a la vez se puede usar herramientas de control de versiones, implementar modulos como Findbugs, o con Emma o Cobertura para el code coverage como control de calidad para pruebas unitarias.

La instalación
Podes instalar Jenkins a traves del apt-get en linux, o descargarlo desde su página.
Lo corres por console con java o lanzando el programa Jenkins en windows o Mac OS.

$ java -jar jenkins.war

Luego abrimos la url:

http://localhost:8080/

Y ya se debería abrir la interfaz web de Jenkins.

Plugins
Para instalar los plugins en el directorio tools desde la página local:

http://localhost:8080/pluginManager/

O sino simplemente dejarlos en $JENKINS_HOME/plugins y iniciar jenkins. Existen un buen nombre de plugins, aquí en el wiki se puede encontrar una lista amplia.

Y aquí una Lista de plugins para el desarrollo en Android.

Control de versiones
Para agregar tus proyectos a jenkins, se puede enlazar tu proyecto a un repositorio de control de versiones.A través de la interfaz de Jenkins vas a encontrar las opciones de como usar SVN, Mercurial, GIT, y subir los códigos con tareas programadas de compilación.

Pruebas unitarias
El gran interes de crear tareas con Jenkins es poder ejecutar previamente sus proyectos con pruebas unitarias. Estas pruebas son muy útiles para validar el buen funcionamiento de su código. El hecho de tener estas tareas automatizables es el paso importante hacía una integración continua. En las configuraciones de tu proyecto vas a poder ejecutar pruebas con la API de Monkey ( api para pruebas en dispositivos) o validación de tu código con Junit.

Android Emulator Plugin
Se instala como un plugin desde la interfaz web, por ejemplo. Este plugin tiene mucho sentido en Android porque se puede interactuar con un emulador que se va a crear y ejecutar a traves de una tarea programada,  y/o de una determinada versión de tu proyecto. Los logs van a ser guardados en los históricos y accesibles via Jenkins.

Otra cosa que tienen los emuladores de Android. es que pueden ser ejecutados con el argumento sin ventana.

-no-window

En el panel de configuración de un determinado proyecto en Jenkins, vas a encontrar la opción de “show emulator window”. Desactivala. Luego todas las pruebas unitarias se pueden ejecutar a traves del shell. Y generar un reporte.

Aquí van mas capturas de pantallas de las opciones que vas a encontrar en la configuración de un proyecto:

administradores de emuladores

invoke ant en jenkins
invoke ant en jenkins

generacion de apk en jenkins
Generacion de apk

Referencias: Configuring jenkins

Publicado en Android | 2 comentarios

Crear tareas de automatización para aplicaciones Android con Ant, Maven o Gradle

Básicamente se usan scripts de automatización de tareas cuando necesitas configurar un gran número de taréas para el despliegue de tus aplicaciones y hacer las pruebas de tu proyecto en dispositivos Android.

Cuando es el momento de automatizar tus despliegues?
- Cuando ya estas en una dinámica de trabajo con un equipo de desarrolladores, y que se esta usando repositorios en Subversion, GIT o Mercurial. Por ejemplo puedes incluir automáticamente el número de revisión junto a cada uno de tus APK, o integrar directamente en alguna clase Java.
- Cuando manejas librerías externas en tu aplicación, que puedan provenir de otros de tus proyectos.
- Cuando queres hacer unit testing para cada despliegue .
- Cuando es necesario hacer una limpieza de tus archivos generados para evitar problemas y realizar pruebas exitosas.

Ant en Android

El primer paso para la automatización de tus proyectos es utilizar Ant.

Porque Ant?
- porque si usas Eclipse IDE, Ant ya viene directamente incluido.
- porque es fácil de manejar la sintaxis de XML.

Debes saber que el propio SDK de Android ya viene con un comando que permite crear fácilmente tu archivo XML de configuración, simplemente lanzas este comando desde la carpeta de tu proyecto:

$ android update project --path .

Ahora, en el directorio de tu proyecto tendras un build.xml, y el archivo local.properties se actualiza. Este template de Build.xml se encuentra en tu SDK de Android en esta ruta: $ANDROID_HOME/tools/lib/build.template

Antes de ejecutar Ant necesitas incluir la carpeta tools en tu PATH. Debes hacer un echo de $PATH para ver si estan bien presentes las carpetas del SDK tools y platform-tools para el ADT.

Si es asi, ahora ya podes probar tu build.xml. lanzando simplemente=

$ ant

Si tenes un BUILD FAILED. no se olvide de poner este parametro: sdk.dir=[ubicacion-de-mi-android-sdk] en el archivo project.properties, se borra el build.xml y se vuelve a lanzar el commando “android update project –path .”.

O desde la ventana de Ant en Eclipse, podes hacer click en Run y ver el mismo resultado. Si necesitas hacer un release de tus APKs firmados, simplemente podes agregar un build.properties incluyendo tu Key Store y tu Key Alias para que ant firme automáticamente tu APK compilada.

key.store=keystore
Key.alias=www.androidda.com
$ ant release

Con ant podras usar los comandos siguiente: clean, debug, release, instrument, test, emma, install, installd, installr, installi, installt o uninstall.

Existe un muy bueno articulo para saber más de las cosas que pueden ser implementadas con Ant en AndroidEngineer.com

Automatizaciones con Maven

Maven es mucho mas flexible que Ant. En el caso de Maven se usan plugins en lugar de importar cada vez el build.xml en cada uno de tus proyectos. Maven es también una sintaxis en XML, llamada POM ( Project Object Model ).

La gran diferencia con Ant, donde tus scripts son casi siempre iguales, es que Maven agiliza mucho el cambio de targets para cada uno de tus proyectos.

No hay nada más simple que instalar Maven en Linux: busca el package Maven en tus repositiorios APT o desde Brew si estas con Mac.

$ sudo apt-get install maven

Chequea la version, que sea la ultima 3.0.5 o 3.0.4

$ mvn -version

Si lo vas a usar dentro de tu proyecto en Eclipse hay que instalar tambien el plugin m2eclipse. Se instala con Software update agregando la sigiuente url:

http://m2eclipse.sonatype.org/sites/m2e

Primero se instala el plugin m2eclipse y tambien este otro: “m2e – Extensions Development Support (Optional)”, para ver este último se deselecciona la opción “Group Items by Category” y se selecciona los dos plugins.

Con Estos dos plugins, vas a tener el total control de tus dependencias a través de Maven, y vas a poder ejecutarlo desde una opciones que se activan haciendo click botón derecho sobre tu proyecto.

Para empezar se necesita crear un archivo pom.xml en tu proyecto Android, lo podes hacer usando el plugin de m2eclipse en eclipse busca la opción “convert to Maven”. Ahora tenes que agregar unos tags para que Maven compile correctamente tu proyecto con el Android SDK. Aqui esta un ejemplo de pom.xml.

Primero necesitas agregar la variable de entorno ANDROID_HOME en Eclipse para que el plugin pueda reconocer el sdk de Android.

environment_variables_maven

Luego podes lanzar el comando siguiente desde el directorio de tu proyecto. No te olvides de poner el pom.xml que vendría a remplazar el build.xml de ant.

$ mvn clean package

Para compilar el apk lanzamos:

$ mvn clean install

Este ultimo acción permite al compilador generar el apk pero tambien todas las clases que se necesitan para compilar su proyecto, todas las clases y el apk se encuentran en la carpeta “target”.

Si quieres hacer un deploy desde Maven hacia tu dispositivo conectado, es facil con maven usa este comando:

$ mvn android:deploy

Para ejecutar el proyecto con el emulador:

$ mvn android:emulator-start

Dejo un proyecto de ejemplo con Maven: TestMaven

Mas información aquí y si lo quieren usar en eclipse les recomiendo instalar este conector de Maven para desarrolladores Android m2e-android.

Guia del Plugin: http://maven-android-plugin-m2site.googlecode.com/svn/plugin-info.html

Automatizaciones con Gradle

Con Gradle, ya no se usa ningun XML de configuración sino que se usa Groovy.

¿Qué permite hacer Groovy? Agilizar la escritura de scripts de automatizacion: ya no se escribe en XML sino con llaves al estilo JSON. Gradle permite descargar todas las dependencias, sin tener que buscar los Jars y agregarlos a mano.

La instalación: Tenemos que buscar Gradle en nuestros repositorios APT en Linux. En Mac nos toca instalar desde Brew. Se requiere Maven para poder importar las dependencias del build.

Para hacer un deployment en Android con gradle, tenemos que buscar tambien un plugin propio para Android, encontré este gradle-android-plugin.

Aqui esta un ejemplo de build script con gradle.

buildscript {
  repositories {
    mavenCentral()
  }

  dependencies {
    classpath 'org.gradle.api.plugins:gradle-android-plugin:1.1.0'
  }
}

apply plugin: 'android'

repositories {
    mavenCentral()
}

// Sets the package version
version = &quot;x.y.z&quot;

// Signing configuration, valid for all builds (1)
androidSignAndAlign {
    keyStore = &quot;path/to/my/keystore&quot;
    keyAlias = &quot;my-key-alias&quot;
    keyStorePassword = &quot;mystorepass&quot;
    keyAliasPassword = &quot;myaliaspass&quot;
}

// Configure the filtering of resources with properties from the Gradle's project scope (2)
processResources {
  expand (project.properties)
}

// Configure a dedicated debug build (3)
task configureDebug &lt;&lt; {
  jar.classifier = &quot;debug&quot;
}

// Configure a dedicated release build (4)
task configureRelease &lt;&lt; {
  proguard.enabled = true
}

El comando para llamar el build script es simplemente:

$ gradle

Pero también tiene sus variantes con tareas como instalación y Instrumentación:

$gradle clean andInstall :test-proj:andInstr

El plugin trae las siguientes tareas:

:androidProcessResources [Genera los R.java de los archivos resources xml]
:androidPackage [Genera APK]
:androidInstall [Instala el Debug APK en un dispositivo conectado]
:androidInstrumentationTests [Corre una test suite en un dispositivo conectado]
:proguard [ejecuta las clases y los jars cón proguard]

Para más información sobre gradle con Android, el wiki de Gradle.

[UPDATE] Google pronto va a retirar Ant de su sdk y cambiarlo por Gradle en su Build System.

Publicado en Android | 2 comentarios

Introducción a la programación en Python para Android

Nos llega este interesante proyecto de la mano de Kivy, un framework basado en OpenGL escrito en python que nos permite hacer aplicaciones desktop, IOS, Windows y tambien Android.

Hace poco vimos cómo compilar con el SDK de Android desde otro lenguaje que no sea Java, por ejemplo desde Scala.
Ahora con  Kivy, que es a la vez un framework y un toolkit como PythonQT o como el GTK+ toolkit de Gnome, podemos crear botones, animaciones, elementos visuales desde Python.

Mathieu Virbel, leader programmer de Kivy nos publica hace pocos días este script en Python que permite compilar desde python con el toolchain de Android y de esta forma  obtener un APK para Android.

Introducción: Instalación del Framework Kivy

En nuestro caso no es necesario instalar a kivy, el script de python-for-android nos descaraga directemente el framework de Kivy.

Solo instalamos Kivy para tener los ejemplo Demo a Compilar, no es necesario tenerlo instalado se puede saltar al siguiente paso.

En Mac os, es simple uno se puede bajar el archivo Kivy-1.5.0-osx.dmg para snow Leopard y lo instala como de costumbre, esto instalará todas las dependencias de Python OpenGL

http://kivy.googlecode.com/files/Kivy-1.5.0-osx.dmg

[update] En Ubuntu, para instalarlo desde apt-get:

sudo apt-add-repository ppa:kivy-team/kivy
sudo apt-get install python-kivy

Para Compilar kivy desde easy_install:
Si estas en ubuntu o con Debian, se puede compilar el framework Kivy desde easy_install.

Al instalar desde easy_install, para instalarse, se requiere muchas dependencias como cython que pueden ser descargadas desde pip o easy_install.

sudo apt-get install python-setuptools python-pygame python-opengl python-gst0.10 python-enchant gstreamer0.10-plugins-good cython python-dev build-essential mesa-common-dev libgl1-mesa-dev libgles2-mesa-dev
 sudo pip install Cython==0.17.1
 sudo easy_install pyrex
 sudo easy_install kivy

Aqui inicia el paso para Python-For-Android …

Instalación del NDK y del SDK de Android

Descargar los ejemplos demos:
kivydemo-for-android.zip

Descargar y descomprimir el SDK y el NDK de Android en una carpeta opt.

http://developer.android.com/sdk/ndk/index.html

Luego hay que bien configurar los Paths del SDK y del NDK. Con un Export de ANDROIDSDK y ANDROIDNDK.

vi ~/.bashrc
export ANDROIDSDK=”/opt/android-sdk-linux_86″
export ANDROIDNDK=”/opt/android-ndk-r8″
export ANDROIDNDKVER=r8
export ANDROIDAPI=14

Debes estar seguro que tenes el PATH del SDK y del NDK en tu PATH, podes comprobar esto con un simple echo $PATH, sino agregalos a tu archivo .bashrc
cuando ya terminaste con las variables env, para tomar las variables en tu shell, ejecutas:

source ~/.bashrc

Si no tenés instalado en Ubuntu el git core build essentials Tambien hay que hacerlo:

sudo apt-get install build-essential patch git-core ccache

y vas a necesitar también cython, que es a la vez un lenguaje y una extension para usar librerias en C desde Python:

sudo pip install Cython==0.17.1

Instalación del script python-for-android

Con un simple Clone del proyecto desde github:

git clone git://github.com/kivy/python-for-android.git

Ahora creamos una distribución de la toolchain de Android incluyendo al modulo de Kivy.

./distribute.sh -m "kivy"

Y ya tenemos nuestra toolchain lista para compilar un script en Python que va a generar un APK. Buscamos la carpeta dist y buscamos un ejemplo a compilar.

Podemos mirar el codigo del ejemplo del touchtracer que está en los ejemplos demo de Kivy.

$ vi kivydemo-for-android/touchtracer/main.py
import kivy
kivy.require('1.0.6')

from kivy.app import App
from kivy.uix.floatlayout import FloatLayout
from kivy.uix.label import Label
from kivy.graphics import Color, Rectangle, Point, GraphicException
from random import random
from math import sqrt


def calculate_points(x1, y1, x2, y2, steps=5):
    dx = x2 - x1
    dy = y2 - y1
    dist = sqrt(dx * dx + dy * dy)
    if dist < steps:
        return None
    o = []
    m = dist / steps
    for i in xrange(1, int(m)):
        mi = i / m
        lastx = x1 + dx * mi
        lasty = y1 + dy * mi
        o.extend([lastx, lasty])
    return o


class Touchtracer(FloatLayout):

    def on_touch_down(self, touch):
        win = self.get_parent_window()
        ud = touch.ud
        ud['group'] = g = str(touch.uid)
        with self.canvas:
            ud['color'] = Color(random(), 1, 1, mode='hsv', group=g)
            ud['lines'] = (
                Rectangle(pos=(touch.x, 0), size=(1, win.height), group=g),
                Rectangle(pos=(0, touch.y), size=(win.width, 1), group=g),
                Point(points=(touch.x, touch.y), source='particle.png',
                      pointsize=5, group=g))

        ud['label'] = Label(size_hint=(None, None))
        self.update_touch_label(ud['label'], touch)
        self.add_widget(ud['label'])
        touch.grab(self)
        return True

    def on_touch_move(self, touch):
        if touch.grab_current is not self:
            return
        ud = touch.ud
        ud['lines'][0].pos = touch.x, 0
        ud['lines'][1].pos = 0, touch.y

        points = ud['lines'][2].points
        oldx, oldy = points[-2], points[-1]
        points = calculate_points(oldx, oldy, touch.x, touch.y)
        if points:
            try:
                lp = ud['lines'][2].add_point
                for idx in xrange(0, len(points), 2):
                    lp(points[idx], points[idx+1])
            except GraphicException:
                pass

        ud['label'].pos = touch.pos
        import time
        t = int(time.time())
        if t not in ud:
            ud[t] = 1
        else:
            ud[t] += 1
        self.update_touch_label(ud['label'], touch)

    def on_touch_up(self, touch):
        if touch.grab_current is not self:
            return
        touch.ungrab(self)
        ud = touch.ud
        self.canvas.remove_group(ud['group'])
        self.remove_widget(ud['label'])

    def update_touch_label(self, label, touch):
        label.text = 'ID: %s\nPos: (%d, %d)\nClass: %s' % (
            touch.id, touch.x, touch.y, touch.__class__.__name__)
        label.texture_update()
        label.pos = touch.pos
        label.size = label.texture_size[0] + 20, label.texture_size[1] + 20


class TouchtracerApp(App):
    title = 'Touchtracer'
    icon = 'icon.png'

    def build(self):
        return Touchtracer()

    def on_pause(self):
        return True

if __name__ in ('__main__', '__android__'):
    TouchtracerApp().run()

Nos posicionamos en la carpeta de dónde se encuentra el build, resultado de nuestra compilación.

cd dist/default

Luego lanzamos la ejecución del build:

./build.py --package org.test.touchtracer --name touchtracer --version 1.0 --dir ~/code/kivydemo-for-android/touchtracer debug

y tenemos un BUILD SUCCESSFUL

Se encuentra el resultado en un apk compilado que esta en la carpeta bin/. Lo instalamos con un simple adb install.
Aqui esta el resultado del TouchTracer en el Market de Android.

[update] el APK se ejecutará normalmente en dispositivos android que soportan GPU, OpenGPL 2.0 ES, y android Froyo minimo. Para ver si su dispositivo puede correr Kivy Python, prueban correr antes el KivyTest

Si queremos empezar con nuestro propio proyecto:

if __name__ in ('__main__', '__android__'):
    YourApp().run()

Y si queremos empezar ahora con un simple tutorial, les dejo este:”como hacer un juego Pong con kivy

La doc del Kivy Framework API

Github del proyecto: https://github.com/kivy/python-for-android para hacer el clone.

Publicado en Android, kivy, Python4Android | Tagged , , , | 24 comentarios

Programando en Scala para Android / parte I

Scala es un lenguaje de Programación Funcional orientado a Objectos con tipos propios. Difiere de java en su sintaxis, es mas elegante, y tiene la particularidad de poder crear singletons solo con reemplazar la definición Class por Object como en este ejemplo.

En el caso de Android, es interesante ver que otros lenguajes puedan generar aplicaciones como en nuestro ejemplo anterior usando un simple javascript con la ayuda del plugin phonegap o con la ayuda de python, o hasta proyectos escritos en Clojure.

Scala puede contribuir a generar menos lineas de código para su proyecto, por ejemplo es interesante ver el caso de este listener que llama a un Activity desde un botón:

btnOK = findViewById(R.id.ok).asInstanceOf[Button]

/* set listeners */
setListener

private def setListener = {
   btnOK.setOnClickListener(new View.OnClickListener() {
     override def onClick(v:View) {
     val url = "http://myurl/"
     val browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
     startActivity(browserIntent)
     finish();
   }
 })
 }

Esto nos permite evitar muchas líneas redundantes que estamos obligados a usar por el estilo de programación del  lenguaje Java.

Hay que saber que existen varias alternativas para usar Scala en Android. Vas a encontrar muchos tutoriales con distintas metodologías. En general se recomienda usar un Simple Build Tool,  Proguard y por supuesto Ant para poder ejecutar tu proyecto desde un IDE como Eclipse.

Con los últimos cambios de Ant que nos trae las más recientes versiones del SDK de Android se recomienda ahora usar este plugin Ant-Android-Scala  pero también se puede usar un SBT propio que lo vamos a ver en la segunda parte de este post. Su nombre es sbt android plugin y es especialemente para Scala, tambien existe otro proyecto conocido como gradle que me parece ser una muy buena alternativa.

Pero si queremos usar Eclipse porque es la mejor opción para tener la console de depuracion de los threads, debemos usar entonces Ant y configurar bien Proguard.

La idea con Proguard es lograr convertir las clases de nuestro proyecto en Scala en .dex files, convertiendo java bytes code en Dalvik bytes code. Proguard le inyecta las librerías de Scala que van a ser compiladas para generar un APK optimizado para la Virtual Machine de Dalvik de Android. Si no queremos compilar estas Librerías cada vez, entonces se puede bajar desde aqui el APK con las librerías y pre instalarlas directamente en tu dispositivo Android.

a continuacion en la parte II

 

 

Publicado en Android | 1 comentario

Detección de rostros con la api FaceDetector en Ice Cream Sandwich

Este articulo tiene por objetivo hacer descubrir una de las novedades que trae la API del Ice Cream Sandwich

Este tutorial esta cortado en dos partes, cuya primera parte aborde la detección de rostros desde una imagen.

Que es el FaceDetector ?

La version del ICS de Android trae una nueva clase FaceDetector con el objetivo de poder detectar los rostros desde cualquier Bitmap.

Esta clase nos permite obtener un areglo del objeto Face. Cada Objeto representa un rostro encontrado en la imagen.

Por ejemplo esta clase nos permite recuperar datos en cada rostros de la imagen, las posiciones de ojos, la distancia entre los ojos, o bien el punto entre los dos ojos.

Un pequeño ejemplo para bien entender:

Primero, requisito obligatorio: instalar la version 4.0 desde  el AVD manager, cuando se ejecuta el update seleccionamos la API 15.
Cuando este hecho, ya se puede crear un proyecto con el sdk de android 4.0.

Una vez el proyecto creado, vamos a poder modificar nuestra Activity. Tenemos que crear una simple clase que extienda el Objeto View.

 
 
 
 
 

Vamos a crear una función constructor, ahi donde cargaremos nuestro Bitmap quien se encuentra en nuestra carpeta Drawable

private Bitmap facesImg;
.....
BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
bitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;

facesImg = BitmapFactory.decodeResource(
        getResources(), R.drawable.faces, bitmapOptions);

- Empezamos por definir el tipo de nuestro Bitmap en RGB_265. Cuando es una condicion del buen funcionamiento de la clase FaceDetector.
- Cargamos nuestro Bitmap que se encuentra en nuestra carpeta Drawable con la ayuda de la Clase BitmapFactory y mas precisamente con la ayuda del metodo decodeResource.

Una vez nuestra imagen cargada, hay que recuperar el ancho, y el largo de la imagen.

private int mBitmapWidth;
private int mBitmapHeight;
....
mBitmapWidth = facesImg.getWidth();
mBitmapHeight = facesImg.getHeight();

Ahora, hay que crear una instancia de la clase FaceDetector y llamar el metodo finFaces para recuperar toda la lista de los rostros encontrados en el Bitmap.

private static final int NUM_FACES = 64;
private FaceDetector mFaceDetector;
private FaceDetector.Face mFacesArray[] = new FaceDetector.Face[NUM_FACES];
......
mFaceDetector = new FaceDetector(mBitmapWidth, mBitmapHeight, NUM_FACES);
mFaceDetector.findFaces(facesImg, mFacesArray);

- Definemos el maximo de rostros a detectar en la imagen. el valor maximo soportada es 64.
- Creamos una instancia de la clase FaceDetector, pasandole el alto y el ancho de la imagen, y el numero de rostros a detectar.
- Creamos un areglo, que nos permite donde guardar en stock la lista de los rostros encontrados.
- Luego llamamos al metodo findFaces pasandole una imagen y un areglo a llenar
Entonces recorremos la lista de rostros, y recuperamos el rostro en cuestión. En cada instancia del rostro, recuperamos las diferentes valores que que necesitamos en el resto de nuestro proyecto.

- el punto se encuentra en el medio, entre los dos ojos, con el metodo getMidPoint
- La distancia entre los dos ojos, con la ayuda del metodo eyesDistance

for (int i = 0; i < mFacesArray.length; i++)
{
    mFace = mFacesArray[i];
    try
    {
        PointF eyesMiddlePoint = new PointF();
        mFace.getMidPoint(eyesMiddlePoint);
        mEyesDistance[i] = mFace.eyesDistance();
        mEyesCenterPoints[i] = eyesMiddlePoint;
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
}

Aqui el resultado final:

public FaceView(Context context)
{
    super(context);
    BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
    bitmapOptions.inPreferredConfig = Bitmap.Config.RGB_565;

     facesImg = BitmapFactory.decodeResource(
            getResources(), R.drawable.faces, bitmapOptions);

    mBitmapWidth = facesImg.getWidth();
    mBitmapHeight = facesImg.getHeight();

    mFaceDetector = new FaceDetector(mBitmapWidth, mBitmapHeight, NUM_FACES);
    mFaceDetector.findFaces(facesImg, mFacesArray);

    for (int i = 0; i < mFacesArray.length; i++)
    {
        mFace = mFacesArray[i];
        try
        {
            PointF eyesMiddlePoint = new PointF();
            mFace.getMidPoint(eyesMiddlePoint);
            mEyesDistance[i] = mFace.eyesDistance();
            mEyesCenterPoints[i] = eyesMiddlePoint;
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

Luego, sobre escribimos el metodo onDraw para redibujar nuestra View y indicar los rostros detectados.

@Override
protected void onDraw(Canvas canvas)
{
    mXRatio = getWidth() * 1.0f / mBitmapWidth;
    mYRatio = getHeight() * 1.0f / mBitmapHeight;

    mCirclePaint.setStyle(Paint.Style.FILL);
    mCirclePaint.setColor(Color.GREEN);

    mColor.setStyle(Paint.Style.STROKE);
    mColor.setTextAlign(Paint.Align.CENTER);

    canvas.drawBitmap(
        facesImg, null, new Rect(0, 0, getWidth(), getHeight()), mColor);

    for (int i = 0; i < mEyesCenterPoints.length; i++)
        if (mEyesCenterPoints[i] != null)
            canvas.drawCircle(
            mEyesCenterPoints[i].x * mXRatio, mEyesCenterPoints[i].y * mYRatio, mEyesDistance[i] / 3,mCirclePaint);
    }
}

- Definimos un color para el dibujo de los circulos y otro para deibujar la imagen.
- Redibujamos nuestra imagen.
- Recorremos los diferentes rostros y dibujamos un circulo como centro, el punto entre los dos ojos del rostro.

Y aqui pueden ver el codigo completo de la clase en el código fuente del proyecto.

Les dejo aqui el enlace para descargarlo.

Este articulo fue escrito por Benbourahla Nazim. fuente: tutos-android.com

Publicado en Android | Deja un comentario
  • Facebook AndroidCol