Capturar la ubicación del celular (Android) desde Linux.

Me tome unos días para realizar la actualización de mi Milestone a Froyo gracias a la gente de androive que liberaron una versión venezolanizada de froyo que se llama FroyoVE.

Hoy escribire sobre como sacar la información que maneja el GPS desde Linux.

Lo primero que se necesita hacer es iniciar la localización, se captura la información y luego se detiene la localización.

A continuación el código del programa:

#!/usr/bin/env python2.6
# -*- coding: utf-8 -*-
#Script que permite capturar la localización GPS del celular (ANDROID) desde Linux.
#Autor: Ernesto Crespo
#Correo:ecrespo@gmail.com
#Licencia: GPLv3
#Versión:0.1


#Importando el módulo android
import android
from time import sleep




#Función de envio de mensajes
def localizacion():
    #Se crea la instancia de la clase Android
    droid = android.Android()
    #Se inicia la localizacion
    droid.startLocating()
    #Se espera 15 segunfos
    sleep(15)
    #Se presenta en la consola la información de la localización
    #Se maneja la información de un diccionario.
    print "Altitud: ",droid.readLocation().result["network"]["altitude"]
    print "Proveedor: ",droid.readLocation().result["network"]["provider"]
    print "Latitud: ",droid.readLocation().result["network"]["latitude"]
    print "Longitud: ",droid.readLocation().result["network"]["longitude"]
    print "Tiempo: ",droid.readLocation().result["network"]["time"]
    print "Velocidad: ",droid.readLocation().result["network"]["speed"]
    print "Precisión: ",droid.readLocation().result["network"]["accuracy"]
    #Se detiene la localización
    droid.stopLocating()


#Ejecución del programa principal.
if __name__ == "__main__":
    #Ejecución de la función
    localizacion()

La ejecución desde la consola muestra lo siguiente:
localizacion.py

Altitud:  0
Proveedor:  network
Latitud:  8.65770805
Longitud:  -71.11786675
Tiempo:  1292944124223
Velocidad:  0
Precisión:  65

Con ayuda de google map reviso que la latitud y longitud que devuelve el GPS del celular está cerca de la troncal 7 en Mérida.

Obtener información del estado de la bateria de un celular con Android desde Linux

En este post se mostrará las funciones que permiten obtener información del estado de la bateria del celular con Android desde Linux.

Para poder monitorear el estado de la bateria primero se inicia la función de inicio de monitoreo y luego se puede obtener la información siguiente:

• Salud de la batería
• Tipo de conexión que se usa para cargar la batería
• Estatus de la batería
• Tipo de tecnología usada en la batería
• Temperatura de la batería
• Voltaje de la batería

El programa es el siguiente:

#!/usr/bin/env python2.6
# -*- coding: utf-8 -*-
#Script que muestra la información de la bateria del celular con Android.
#Autor: Ernesto Crespo
#Correo:ecrespo@gmail.com
#Licencia: GPLv3
#Versión:0.1


#Importando el módulo android
import android


def Bateria():
    
    droid = android.Android()
    #Se inicia el monitoreo de la bateria
    droid.batteryStartMonitoring()
    #Se captura la información de la salud de la bateria y se presenta un 
    #mensaje por la consola.
    bateriaSalud = droid.batteryGetHealth()[1]
    if bateriaSalud == 2:
        print "La bateria está bien"
    elif bateriaSalud == 1:
        print "Salud de la Bateria desconocido"
    elif bateriaSalud == 3:
        print "La bateria tiene sobrecarga"
    elif bateriaSalud == 4:
        print "La bateria está muerta"
    elif bateriaSalud == 5:
        print "La bateria tiene sobrevoltaje"
    else:
        print "falla desconocida"
    #Se captura la información del tipo de conexión que usa el celular
    #Se despliega la información por la consola.
    tipoConexion = droid.batteryGetPlugType()[1]
    if tipoConexion == 0:
        print "Cable desconectado"
    elif tipoConexion == 1:
        print "Fuente de alimentación: cargador AC"
    elif tipoConexion == 2:
        print "Fuente de alimentación: cable USB"
    else:
        print "Desconocido"
    #Se captura la información del estatus de la bateria y se presenta en la
    #consola.
    estatus = droid.batteryGetStatus()[1]
    if estatus == 2:
        print "Bateria cargandose"
    elif estatus == 3:
        print "Bateria descargandose"
    elif estatus == 4:
        print "Bateria no se está cargando"
    elif estatus == 5:
        print "Bateria full de carga"
    print "Tipo de tecnología de la bateria: ",droid.batteryGetTechnology()[1]
    print "Temperatura de la bateria: ",droid.batteryGetTemperature()[1]
    print "voltaje de la bateria: ",droid.batteryGetVoltage()[1]
    #Se detiene el monitoreo de la bateria
    droid.batteryStopMonitoring()
    
    
if __name__ == "__main__":
    #Ejecución de la función
    Bateria()

Al ejecutar el programa se muestra lo siguiente:

bateria.py
La bateria está bien
Fuente de alimentación: cable USB
Bateria cargandose
Tipo de tecnología de la bateria:  Li-ion
Temperatura de la bateria:  370
voltaje de la bateria:  4003

Con respecto a la temperatura espero sea 37 grados y el voltaje sea medido en miliVoltios.

Manejar los mensajes de Texto del celular desde Linux (Android)

Para continuar con los scripts que se ejecutan de forma remota en el celular, ahora mostraré como se maneja los mensajes de texto, buscar mensajes y borrarlos.

La idea es buscar todos los mensajes de un número celular dado, presentar el mensaje en la consola y borrar dichos mensajes.
Se sigue el procedimiento de ejecución remota explicado en el post anterior.

El código es el siguiente:

#!/usr/bin/env python2.6
# -*- coding: utf-8 -*-
#Script que permite manejar los SMS del celular con android desde Linux.
#Autor: Ernesto Crespo
#Correo:ecrespo@gmail.com
#Licencia: GPLv3
#Versión:0.1


#Importando el módulo android,sys y re
import android


#Función de envio de mensajes
def Contactos():
    #Se crea la instancia de la clase Android
    droid = android.Android()
    #Se captura la cantidad de mensajes de texto )como en mi caso todos los 
    #mensajes han sido leídos coloco 0, si quiero los no leídos coloco 1.
    cantidad = droid.smsGetMessageCount(0)[1]
    #El número de celular a buscar
    numero = "0xxxyyyzzww"
    #Se recorren todos los mensajes.
    for i in range(cantidad):
        #Si el mensaje es del número dado se captura el identificador
        #del mensaje, se imprime un mensaje  en pantalla con la información:
        #read:Si mensaje ya fue leído
        #date: la fecha del mensaje
        #_id:identificador del mensaje.
        #address: número celular.
        #body:cuerpo del mensaje.
        #Toda está información se maneja desde un diccionario.
        #Si el celular no es de la persona buscada se continua con la 
        #siguiente iteración. 

        #A la función de borrar se le pasa el identificador del mensaje
        if droid.smsGetMessages(0)[1][i]["address"] == numero:
            identificador = droid.smsGetMessages(0)[1][i]["_id"]
            print "Borrando mensaje\t",i,droid.smsGetMessages(0)[1][i]["read"],droid.smsGetMessages(0)[1][i]["date"],droid.smsGetMessages(0)[1][i]["address"],droid.smsGetMessages(0)[1][i]["body"]
            droid.smsDeleteMessage(identificador)
        else:
            continue
if __name__ == "__main__":
    #Ejecución de la función
    Contactos()

La salida del programa es la siguiente:
 Devuelve el mensaje que se ha borrado el SMS, el número del mensaje, si está leído, la fecha, el número y el cuerpo del mensaje.

Borrando mensaje 296 1 1285030227398 0xxxyyyzzww Ah bueno... Yo les aviso.
Borrando mensaje 358 1 1283635867054 0xxxyyyzzww Ok. Ahi voy.

Ejecución remota de scripts python desde Linux a un celular con Android (versión conectado el celular por USB)

En el post anterior explique como ejecutar script python en un celular con Android de forma remota desde Linux por wifi, ahora explicaré como hacerlo por cable USB, en realidad es más sencillo que el artículo anterior.
Me basaré en lo explicado en el post anterior y en el post sobre envío de mensajes de texto.

Lo primero que se necesita hacer es conectar el celular al computador por USB, activar el modo depuración y la conexión USB a Portal y Herramientas.

Se debe iniciar el servidor de SL4A. Menú->Ver->Interpretes->Menú->Iniciar Servidor->Privado.

Luego se averigua en los mensajes de notificiación que puerto abre el servidor. En mí caso fue el 58825.

Desde la consola de Linux se ejecutan los siguientes comandos:
Redirecciona toda petición al puerto 9999 al puerto 58825.
./adb forward tcp:9999 tcp:58825

Se exporta una variable de ambiente.
export AP_PORT=9999

El programa es el siguiente:

#!/usr/bin/env python2.6
# -*- coding: utf-8 -*-
#Script que permite enviar mensaje de texto a un celular android desde Linux.
#Autor: Ernesto Crespo
#Correo:ecrespo@gmail.com
#Licencia: GPLv3
#Versión:0.1

#Importando el módulo android,sys y re
import android,sys,re


#Función de envio de mensajes
def Enviomensaje():
    #Se averigua si se le pasa al script el número celular y el mensaje, y que el número sea válido para venezuela.
    if len(sys.argv) == 3:
        numero = sys.argv[1]
        mensaje = sys.argv[2]
    else:
        print "error enviando mensaje, se necesita pasar el número y mensaje"
        sys.exit
    if Validar(numero) == 0:
        print "Número invalido"
        sys.exit
    #Creando la instancia droid del objeto Android
    droid = android.Android()
    #Enviando el mensaje de texto
    droid.smsSend(numero,mensaje)
    #Se presenta un mensaje de notificación en el celular.
    droid.makeToast('Mensaje enviado')


#Función que válida si el número es de movilnet, digitel o movistar.
def Validar(numero):
    #Valida si los numeros tienen 11 digitos y que sean de los proveedores movilnet, digitel y movistar
    if len(numero) == 11 and ((re.search("041[2|4|6]\d\d\d\d\d\d\d",numero)) or (re.search("042[4|6]\d\d\d\d\d\d\d",numero))) :
        return 1
    else:
        return 0
#Ejecución del programa.
if __name__ == "__main__":
    Enviomensaje()

Ejecutar el script.
enviomensajes.py 0xxxyyyzzww  "2da prueba, avisame si te llega el sms"

Ejecución remota de scripts python desde Linux a un celular con Android

Existe la forma  de ejecutar scripts así sea de python,perl, ruby, bash,etc de forma remota (desde Linux) a un celular con Android.

Al instalar SL4A y python se tiene la posibilidad de iniciar un servicio de SL4A para escuchar en un puerto específico del celular Android, se tiene la opción pública o privada, para el primer caso se tiene que tener conectado el celular a una red wifi donde levanta el servicio en un puerto específico, para el caso de conexión privada el celular debe estar conectado vía puerto USB con la opción de depuración USB conectada y el celular en modo Portal y Herramientas.

Este post se basa en el artículo de control remoto de SL4A que se encuentra aquí .

En este momento explicaré la conexión remota pública, primero se tiene que conectar el celular a una red wifi.

En el equipo que estoy utilizando le asigno la IP 192.168.10.19.

Luego ejecutar SL4A en el celular, luego se le da menú, se selecciona ver, luego a interpretes, luego otra vez al menú, se selecciona iniciar servidor, en este momento se le pide seleccionar entre servidor público o privado, se selecciona al primero.

El celular coloca un mensaje en el área de notificación de Android mencionando que el servidor se ha iniciado, se despliega la información y este dice se arranco un servidor SL4A en la IP 192.168.10.19 con puerto 52834.

A continuación se utilizará el sdk de android en Linux ejecutando adb.
Se inicia el servidor adb.

./adb start-server
* daemon not running. starting it now on port 5037 *
* daemon started successfully *

Note que el servidor levanta en el puerto 5037.

Ahora se redirecciona los puertos del servicio adb.

./adb forward tcp:9999 tcp:52834

Donde el puerto 9999 se redirecciona al puerto donde escucha el celular que es el 52834 en este caso.

A continuación se configura la variable de ambiente de la IP y puerto del celular con Android que tiene funcionan el servidor SL4A.

export AP_PORT=52834

export AP_HOST=192.168.10.19

Asegurarse que tiene en el path de python2.6 la ruta del módulo de python para android. Este lo puede bajar en este enlace.

A continuación se muestra un script en python que pide escriba el nombre de usuario en el celular y lo muestra en Linux y en el celular:

#Importar módulo android

import android

#Se crea el objeto droid de la clase Android con la IP y puerto del servicio iniciado en el celular.

droid = android.Android(('192.168.10.19', 52834))

#Se solicita al usuario que escriba su nombre

texto = droid.getInput("Escriba su nombre","Nombre:")

#Se imprime el nombre del usuario en la consola de Linux

print "El nombre escrito en el celular es: %s" %texto[1]

#Se presenta un saludo al usuario en el celular

droid.makeToast('Hola %s' %texto[1])

Para ejecutar el programa se coloca el script prueba-remota.py donde se encuentra el módulo de SL4A android.py en el mismo directorio o se coloca en el path de python2.6.

Se ejecuta con python2.6:

$ python2.6 prueba-remota.py 

El nombre escrito en el celular es: ernesto

Charla del día Debian en Barquisimeto

Ya publique en slideshare la charla que dicte en el día  Debian en Barquisimeto.
Lo pueden bajar por acá: http://www.slideshare.net/ecrespo/empaquetar-un-paquete-debian-por-medio-de-mercurial

Crear un paquete python de un programa

Este artículo explicará el proceso de creación de un tar.gz o tar.bz2 del programa de configuración de los accesos rápidos de teclado por medio de gconf con python.
La siguiente imagen muestra el repositorio del proyecto en google code.

Como muestra la figura se tiene una serie de archivos en el repositorio, a continuación se explicará cada uno de ellos:

• COPYING: Contiene la Licencia del proyecto.
• MANIFEST.in: Es una plantilla que contiene la lista de archivos que se incluirán en el paquete del programa.
• README: Contiene información del programa, una descripción de uso y requerimientos.
• TODO: Lista de cosas por hacer para las siguientes versiones del programa.
• Archivos *.py: Son los programas desarrollados.
• pyconfig-accessgnome-ui.desktop: Archivo que define la información de la aplicación en el menú del escritorio.
• pyconfig-accessgnome.glade : Archivo xml glade que contiene la interfaz gráfica.
• setup.py: Archivo de configuración del proceso de instalación y creación de paquetes.

Para fines prácticos se explicará MANIFEST.in y setup.py.

MANIFEST.in es un archivo plantilla de entra que define que archivos se van a colocar en el archivo MANIFEST, este archivo final le dira a setup.py cuales serán los archivos que se incluirán en el paquete .tar.gz o .tar.bz2.
El archivo tiene una directiva include donde se le dirá los archivos que se quieren incluir.
Por ejemplo:
include COPYING pyconfig-accessgnome.glade pyconfig-accessgnome-ui.desktop README TODO


El archivo setup.py contiene lo siguiente:



#!/usr/bin/env python
#importar setup de distutils
from distutils.core import setup  
#Crear la variable data_files que contiene las rutas de donde se van a colocar los archivos.
data_files = [('share/applications',['pyconfig-accessgnome-ui.desktop']),
    ('share/python-config-accesskey-gnome',['COPYING','configGconf.py','pyconfig-accessgnome.glade','pyconfig-accessgnome-ui.py','README','TODO'])]


#se define el nombre del programa, la versión, una descripción corta, el autor y su correo, 
#el url del proyecto, la licencia, los scripts principales del programa, los archivos de datos adicionales,
#La plataforma soportadas,los módulos que se requieren para el funcionamiento del programa.
#Y el módulo que se desarrollo y necesita el programa principal.


setup(name='python-gconf-keybinding',
      version='0.4',
      description='Allow config keyboard access application with gconf',
      author='Ernesto Nadir Crespo Avila', 
      author_email='ecrespo@gmail.com',
      url = 'http://code.google.com/p/python-config-accesskey-gnome/',
      license = "GPL v3",
      scripts = ['pyconfig-accessgnome-ui.py', 'configGconf.py'],
      data_files =data_files,
      platforms=['i386','AMD64'],
      requires = ['gtk','gconf','pygtk','gtk.glade'],
      py_modules = ['configGconf']
      )

Al tener los archivos necesarios para instalar el programa y para crear los paquetes sólo queda ejecutar los comandos:

Listar los archivos existentes:

ls -l

total 92

-rwxr-xr-x 1 ernesto ernesto  8036 ago  7 17:49 configGconf.py

-rw-r--r-- 1 ernesto ernesto 33353 jul 27 20:41 COPYING

-rw-r--r-- 1 ernesto ernesto    88 ago  8 18:15 MANIFEST.in

-rw-r--r-- 1 ernesto ernesto 14729 jul 27 20:45 pyconfig-accessgnome.glade

-rwxr-xr-x 1 ernesto ernesto   315 jul 27 20:41 pyconfig-accessgnome-ui.desktop

-rwxr-xr-x 1 ernesto ernesto  8420 ago  8 17:06 pyconfig-accessgnome-ui.py

-rw-r--r-- 1 ernesto ernesto  4260 jul 27 20:41 README

-rwxr-xr-x 1 ernesto ernesto  1021 ago  8 18:12 setup.py

-rw-r--r-- 1 ernesto ernesto     0 jul 27 20:41 TODO

Probar la instalación del programa:

Se ejecuta el install para el setup.

sudo python setup.py install

running install

running build

running build_py

creating build

creating build/lib.linux-i686-2.6

copying configGconf.py -> build/lib.linux-i686-2.6

running build_scripts

creating build/scripts-2.6

copying and adjusting pyconfig-accessgnome-ui.py -> build/scripts-2.6

copying and adjusting configGconf.py -> build/scripts-2.6

changing mode of build/scripts-2.6/pyconfig-accessgnome-ui.py from 644 to 755

changing mode of build/scripts-2.6/configGconf.py from 644 to 755

running install_lib

running install_scripts

copying build/scripts-2.6/pyconfig-accessgnome-ui.py -> /usr/local/bin

copying build/scripts-2.6/configGconf.py -> /usr/local/bin

changing mode of /usr/local/bin/pyconfig-accessgnome-ui.py to 755

changing mode of /usr/local/bin/configGconf.py to 755

running install_data

running install_egg_info

Removing /usr/local/lib/python2.6/dist-packages/python_gconf_keybinding-0.4.egg-info

Writing /usr/local/lib/python2.6/dist-packages/python_gconf_keybinding-0.4.egg-info

Esto crea un directorio build que contiene los scripts y la librerías, luego los copia en /usr/local/  tanto en bin como en share. 

ls share/python-config-accesskey-gnome/

configGconf.py  COPYING  pyconfig-accessgnome.glade  pyconfig-accessgnome-ui.py  README  TODO

ls bin/

configGconf.py  pyconfig-accessgnome-ui.py  pyloro.py

Ya en este momento se puede ejecutar el programa tanto de forma gráfica como desde la línea de comandos.

A continuación viene el proceso de construcción del tar.gz y tar.bz:

El comando para el setup.py es sdist el cual crea el paquete para ser distribuído, adicionalmente se le pasa el formato con la opción --formats=bztar, gztar. Los argumentos bztar y gztar es para crear un tar.bz2 y un tar.gz respectivamente.

El comando es el siguiente:

python setup.py sdist --formats=bztar,gztar

running sdist

reading manifest template 'MANIFEST.in'

writing manifest file 'MANIFEST'

creating python-gconf-keybinding-0.4

making hard links in python-gconf-keybinding-0.4...

hard linking COPYING -> python-gconf-keybinding-0.4

hard linking README -> python-gconf-keybinding-0.4

hard linking TODO -> python-gconf-keybinding-0.4

hard linking configGconf.py -> python-gconf-keybinding-0.4

hard linking pyconfig-accessgnome-ui.desktop -> python-gconf-keybinding-0.4

hard linking pyconfig-accessgnome-ui.py -> python-gconf-keybinding-0.4

hard linking pyconfig-accessgnome.glade -> python-gconf-keybinding-0.4

hard linking setup.py -> python-gconf-keybinding-0.4

creating dist

tar -cf dist/python-gconf-keybinding-0.4.tar python-gconf-keybinding-0.4

bzip2 -f9 dist/python-gconf-keybinding-0.4.tar

tar -cf dist/python-gconf-keybinding-0.4.tar python-gconf-keybinding-0.4

gzip -f9 dist/python-gconf-keybinding-0.4.tar

removing 'python-gconf-keybinding-0.4' (and everything under it)

Ya se tiene un directorio dist con los 2 paquetes creados:

ls -l dist/

total 40

-rw-r--r-- 1 ernesto ernesto 16539 ago  8 19:12 python-gconf-keybinding-0.4.tar.bz2

-rw-r--r-- 1 ernesto ernesto 18331 ago  8 19:12 python-gconf-keybinding-0.4.tar.gz

El contenido de un paquete es el siguiente:

tar -tvzf dist/python-gconf-keybinding-0.4.tar.gz 

drwxr-xr-x ernesto/ernesto   0 2010-08-08 19:12 python-gconf-keybinding-0.4/

-rwxr-xr-x ernesto/ernesto 8420 2010-08-08 17:06 python-gconf-keybinding-0.4/pyconfig-accessgnome-ui.py

-rw-r--r-- ernesto/ernesto 33353 2010-07-27 20:41 python-gconf-keybinding-0.4/COPYING

-rwxr-xr-x ernesto/ernesto  8036 2010-08-07 17:49 python-gconf-keybinding-0.4/configGconf.py

-rw-r--r-- ernesto/ernesto     0 2010-07-27 20:41 python-gconf-keybinding-0.4/TODO

-rwxr-xr-x ernesto/ernesto   315 2010-07-27 20:41 python-gconf-keybinding-0.4/pyconfig-accessgnome-ui.desktop

-rwxr-xr-x ernesto/ernesto  1021 2010-08-08 18:12 python-gconf-keybinding-0.4/setup.py

-rw-r--r-- ernesto/ernesto 14729 2010-07-27 20:45 python-gconf-keybinding-0.4/pyconfig-accessgnome.glade

-rw-r--r-- ernesto/ernesto  4260 2010-07-27 20:41 python-gconf-keybinding-0.4/README

-rw-r--r-- ernesto/ernesto   394 2010-08-08 19:12 python-gconf-keybinding-0.4/PKG-INFO

Sólo queda probar la instalación del paquete, primero se descomprime y luego se ejecuta el setup.py con la opción install:

tar -xvzf python-gconf-keybinding-0.4.tar.gz 

python-gconf-keybinding-0.4/

python-gconf-keybinding-0.4/pyconfig-accessgnome-ui.py

python-gconf-keybinding-0.4/COPYING

python-gconf-keybinding-0.4/configGconf.py

python-gconf-keybinding-0.4/TODO

python-gconf-keybinding-0.4/pyconfig-accessgnome-ui.desktop

python-gconf-keybinding-0.4/setup.py

python-gconf-keybinding-0.4/pyconfig-accessgnome.glade

python-gconf-keybinding-0.4/README

python-gconf-keybinding-0.4/PKG-INFO

Se cambia al directorio python-gconf-keybinding-0.4.

cd python-gconf-keybinding-0.4/ 

Instalación del paquete:

sudo python setup.py install 

running install

running build

running build_py

creating build

creating build/lib.linux-i686-2.6

copying configGconf.py -> build/lib.linux-i686-2.6

running build_scripts

creating build/scripts-2.6

copying and adjusting pyconfig-accessgnome-ui.py -> build/scripts-2.6

copying and adjusting configGconf.py -> build/scripts-2.6

changing mode of build/scripts-2.6/pyconfig-accessgnome-ui.py from 644 to 755

changing mode of build/scripts-2.6/configGconf.py from 644 to 755

running install_lib

running install_scripts

copying build/scripts-2.6/pyconfig-accessgnome-ui.py -> /usr/local/bin

copying build/scripts-2.6/configGconf.py -> /usr/local/bin

changing mode of /usr/local/bin/pyconfig-accessgnome-ui.py to 755

changing mode of /usr/local/bin/configGconf.py to 755

running install_data

running install_egg_info

Removing /usr/local/lib/python2.6/dist-packages/python_gconf_keybinding-0.4.egg-info

Writing /usr/local/lib/python2.6/dist-packages/python_gconf_keybinding-0.4.egg-info

Como ya se explico antes el programa se instala en /usr/local .

El próximo artículo explicará como crear un paquete Debian a partir del tar.gz.
Para más información pueden visitar los siguientes enlaces:
http://docs.python.org/distutils/
http://mundogeek.net/archivos/2008/09/23/distribuir-aplicaciones-python/

Actualización del programa Desarrollo de interfaz gráfica para la configuración de accesos rápidos del teclado

En el artículo anterior se explico la mejora del script que permite cambiar las configuraciones de las teclas rápidas en gnome, ahora se explicará la mejora del programa mencionado en este artículo.

La captura de pantalla de la imagen muestra con respecto al artículo anterior un combobox que está deshabilitado en este momento, dicho combobox permitirá elegir entre 3 distribuciones Debian, Ubuntu o Canaima.

La imagen se muestra en la siguiente figura:

La idea es la posibilidad de configurar los accesos rápidos de todas las aplicaciones mostradas o sólo las que se quiera.

def on_button2_clicked(self,*args):
                #Se crea el objeto config de la clase Conf
                Config = configGconf.Conf()
                #Se crea un ciclo con la lista de las aplicaciones.
                for aplicacion in self.__aplicaciones:
                        #Se modifica las aplicaciones una por una pasando la aplicación.
                        Config.modificar_opcion(aplicacion,1)


El código completo del programa lo puedes bajar pyconfig-accessgnome-ui.py la interfaz gráfica elaborada en glade se puede bajar  de pyconfig-accessgnome.glade.

En el siguiente artículo se explicará como crear el paquete python.

Mejorado el script en python que configura los accesos rápidos de teclado a aplicaciones en gnome con gconf

Para cambiar un poco la temática sobre Android volveré a tocar un programa que explique en el siguiente artículo.
El programa lo pueden bajar desde google code y tiene el nombre de configGconf.py.
Las mejoras que tiene el programa son las siguientes:

• Se puede seleccionar entre las distribuciones Debian, Ubuntu y Canaima ya que dependiendo del caso se usa iceweasel como navegador o firefox.
• Se despliega más información a la hora de ejecutar el programa.
• Se usa el módulo python-argparse para capturar los argumentos del programa.
• Se pueden modificar todas las opciones de los accesos rápidos del teclado o una sola opción.

Se tiene que tener instalado la librería para python argparse; en el caso de Debian, Ubuntu y Canaima se ejecuta:
aptitude install python-argparse

Bajar el programa del enlace ya publicado.
Es necesario darle permisos de ejecución:
chmod a+x configGconf.py

A continuación se explica el uso del programa con la mejora de la captura de los argumentos:

1. Si se ejecuta configGconf.py sin argumentos o con la opción -h devuelve la ayuda.
2. Si se ejecuta con -v devuelve el número de versión del programa.
3. Para listar la configuración que maneja las teclas rápidas con agregar la opción de acción (-a o --accion) y se pasa como argumento listar.
4. Para cambiar todas las configuraciones de los accesos rápidos de teclado se agrega la acción cambiar, la opción (-d o --distribucion) con argumentos debian, ubuntu o canaima.
5. Para cambiar una sola opción se agrega en la acción el argumento modificarOpción, la distribución que se está usando (explicado en 4) y que opción se quiere cambiar (orca,gnome-terminal,oowriter,iceweasel,nautilus,ooimpress,pidgin,oocalc,gedit,gnome-calculator,rhythmbox).

A continuación se muestra los resultados de cada procedimiento anterior:

./configGconf.py 
usage: configGconf [-h] [-a {cambiar,listar,modificarOpcion}]
                   [-d {debian,canaima,ubuntu}]
                   [-o {orca,gnome-terminal,oowriter,iceweasel,nautilus,ooimpress,pidgin,oocalc,gedit,gnome-calculator,rhythmbox}]
                   [-v]


Cambiar accesos rapidos en teclado a Gnome


optional arguments:
  -h, --help            show this help message and exit
  -a {cambiar,listar,modificarOpcion}, --accion {cambiar,listar,modificarOpcion}
                        lista gconf
  -d {debian,canaima,ubuntu}, --distribucion {debian,canaima,ubuntu}
                        seleccione entre Canaima,Debian y ubuntu
  -o {orca,gnome-terminal,oowriter,iceweasel,nautilus,ooimpress,pidgin,oocalc,gedit,gnome-calculator,rhythmbox}, --opcion {orca,gnome-terminal,oowriter,iceweasel,nautilus,ooimpress,pidgin,oocalc,gedit,gnome-calculator,rhythmbox}
                        Cambia la configuración de una opción
  -v, --version


./configGconf.py -v
configGconf 0.4


./configGconf.py -a listar
Listar accesos rapidos del teclado a gconf
________________________________________________
Aplicación:  orca o
Aplicación:  gnome-terminal t
Aplicación:  oowriter w
Aplicación:  iceweasel n
Aplicación:  nautilus h
Aplicación:  ooimpress i
Aplicación:  pidgin p
Aplicación:  oocalc x
Aplicación:  gedit e
Aplicación:  gnome-calculator c
Aplicación:  rhythmbox m


./configGconf.py  -a cambiar -d debian
Listar accesos rapidos del teclado de gconf
________________________________________________
Configurando aplicacion: orca, acceso teclado: o
Configurando aplicacion: gnome-terminal, acceso teclado: t
Configurando aplicacion: oowriter, acceso teclado: w
Configurando aplicacion: iceweasel, acceso teclado: n
Configurando aplicacion: nautilus, acceso teclado: h
Configurando aplicacion: ooimpress, acceso teclado: i
Configurando aplicacion: pidgin, acceso teclado: p
Configurando aplicacion: oocalc, acceso teclado: x
Configurando aplicacion: gedit, acceso teclado: e
Configurando aplicacion: gnome-calculator, acceso teclado: c
Configurando aplicacion: rhythmbox, acceso teclado: m


./configGconf.py  -a modificarOpcion -d debian -o oowriter
Listar accesos rapidos del teclado de gconf
________________________________________________
Configurando aplicacion: oowriter, acceso teclado: w

Para finalizar el artículo se colocará el código del programa:



#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Name: configGconf
Description: Aplicación y módulo que permite modificar los accesos rápido de teclas a programas
Version:0.4
License: GPLv3
Copyright: Copyright (C) 2009  Distrito Socialista Tecnologico AIT PDVSA Mérida
Author: Ernesto Nadir Crespo Avila
Email: ecrespo@gmail.com
Changelog:
 0.1: * Agregada multiples opciones de configuración.
 0.2: * Agregada opción de selección de distribución debian, ubuntu o canaima.
      * Agregada información adicional a la hora de desplegar en pantalla.
 0.3: * Agregado el uso del módulo argparse para simplificar la captura de argumentos del comando.
 0.4: * Agregada la posibilidad de modificar una sóla opción de las teclas rápidas de gconf.
"""
version = "0.4"
autor = "Ernesto Nadir Crespo Avila"
email = "ecrespo@gmail.com"
copyright = "GPLv3"


#Importar módulo gconf
import gconf




class Conf:
    def __init__(self):
        #Se crea la instancia de la clase de gconf
        self.__gconfClient = gconf.client_get_default()
        #Se crea la tupĺa aplicaciones        
        self.__aplicaciones = ("orca", "gnome-terminal","oowriter","iceweasel","nautilus","ooimpress","pidgin","oocalc","gedit","gnome-calculator","rhythmbox")
        #Se crea la ruta del comando del teclado y la ruta del modificador de teclado
        self.__comando = "/apps/metacity/keybinding_commands/command_"
        self.__asignacion_teclado = "/apps/metacity/global_keybindings/run_command_"
        #Se crea un diccionario teclas con la asociación entre la aplicación y su acceso rápido de teclado
        self.__teclas = {"orca":"o","gnome-terminal":"t","oowriter":"w","iceweasel":"n","nautilus":"h","ooimpress":"i","pidgin":"p","oocalc":"x","gedit":"e","gnome-calculator":"c","rhythmbox":"m"}


    def modificar_opcion(self,opciones,distribucion,interfaz=0):
        if distribucion <> "debian":
            self.__aplicaciones = ("orca", "gnome-terminal","oowriter","firefox","nautilus","ooimpress","pidgin","oocalc","gedit","gnome-calculator","rhythmbox")
            self.__teclas = {"orca":"o","gnome-terminal":"t","oowriter":"w","firefox":"n","nautilus":"h","ooimpress":"i","pidgin":"p","oocalc":"x","gedit":"e","gnome-calculator":"c","rhythmbox":"m"}
            if opciones == "iceweasel":
                opcion = "firefox"
            elif opciones == "firefox":
                opcion = opciones
            else:
                opcion = opciones
        else:
            if opciones == "firefox":
                opcion = "iceweasel"
            else:
                opcion = opciones
                
        if interfaz == 0:
            print "Listar accesos rapidos del teclado de gconf"
            print "________________________________________________"
        cont = 1
        #se genera un ciclo con las aplicaciones existentes
        for aplicacion in self.__aplicaciones:
            #Si la opción existe como aplicación se modifica el gconf, si no se sale sin resultado
            if aplicacion == opcion:
                ruta1 = "%s%s" %(self.__comando,cont)
                ruta2 = "%s%s" %(self.__asignacion_teclado,cont)
                self.__gconfClient.set_string(ruta1, "%s" %aplicacion)
                self.__gconfClient.set_string(ruta2, "%s" %self.__teclas[aplicacion])
                if interfaz == 0:
                    #Se imprime en pantalla los cambios logrados.
                    print "Configurando aplicacion: %s, acceso teclado: %s" %(aplicacion,self.__teclas[aplicacion])
                break
            cont = cont+1
    
    def modificar(self,distribucion):
        """
        modificar: Permite modificar los accesos rápidos del teclado
        Argumentos:
         * distribucion: se le pasa una distribución a utilizar entre debian,ubuntu y canaima.
        """
        cont = 1
        print "Listar accesos rapidos del teclado de gconf"
        print "________________________________________________"
        #Se la distribución no es debian se cambia iceweasel por firefox en las variables aplicaciones y teclas.
        if distribucion <> "debian":
            self.__aplicaciones = ("orca", "gnome-terminal","oowriter","firefox","nautilus","ooimpress","pidgin","oocalc","gedit","gnome-calculator","rhythmbox")
            self.__teclas = {"orca":"o","gnome-terminal":"t","oowriter":"w","firefox":"n","nautilus":"h","ooimpress":"i","pidgin":"p","oocalc":"x","gedit":"e","gnome-calculator":"c","rhythmbox":"m"}
        #Se genera un ciclo según las aplicaciones
        for aplicacion in self.__aplicaciones:
            #Definición de las rutas del gconf del comando y del modificador del teclado
            ruta1 =  "%s%s" %(self.__comando,cont)
            ruta2 = "%s%s"  %(self.__asignacion_teclado,cont)
            #Se modifica gconf
            self.__gconfClient.set_string(ruta1, "%s" %aplicacion)
            self.__gconfClient.set_string(ruta2, "%s" %self.__teclas[aplicacion])
            #Se imprime en pantalla los cambios logrados.
            print "Configurando aplicacion: %s, acceso teclado: %s" %(aplicacion,self.__teclas[aplicacion])
            cont = cont +1
    
    
    def listar(self):
        """
        listar: Permite listar los accesos rápidos de teclado de gconf
        """
        cont = 1
        print "Listar accesos rapidos del teclado a gconf"
        print "________________________________________________"
        #Se crea un ciclo según la lista de aplicaciones
        for aplicacion in self.__aplicaciones:
            #Se define la ruta del comando del teclado según gconf
            ruta1 =  "%s%s" %(self.__comando,cont)
            #Se define la ruta del modificador del teclado
            ruta2 = "%s%s"  %(self.__asignacion_teclado,cont)
            #Se desplega en pantalla 
            print "Aplicación: " ,self.__gconfClient.get_string(ruta1),self.__gconfClient.get_string(ruta2)
            cont = cont +1




if __name__ == "__main__":
    #Importar módulo argparse para capturar los argumentos del comando    
    import argparse
    #Se instancia la clase Conf en el objeto config
    config = Conf()
    #Creación del parse 
    parser = argparse.ArgumentParser(prog='configGconf',description="Cambiar accesos rapidos en teclado a Gnome")
    acciones = ["cambiar","listar","modificarOpcion"]
    distribuciones = ["debian","canaima","ubuntu"]
    aplicaciones = ["orca", "gnome-terminal","oowriter","iceweasel","nautilus","ooimpress","pidgin","oocalc","gedit","gnome-calculator","rhythmbox"]
    #Se agrega las opciones accion, distribucion y version.    
    parser.add_argument('-a','--accion',type=str,choices=acciones,default=acciones,help='lista gconf')
    parser.add_argument('-d','--distribucion',choices=distribuciones,type=str,default=distribuciones,help='seleccione entre Canaima,Debian y ubuntu')
    parser.add_argument('-o','--opcion',choices=aplicaciones,type=str,default=aplicaciones,help='Cambia la configuración de una opción')
    parser.add_argument('-v', '--version', action='version', version='%(prog)s 0.4') 
    #Se captura los argumentos del comando ejecutado.
    args = parser.parse_args()
    # ejecución de las opciones según la acción y la distribución
    if args.accion == "listar":
        #Se lista las configuraciones de los accesos del teclado
        config.listar()
    elif args.distribucion in ('debian','ubuntu','canaima') and args.accion == "cambiar":
        #Se modifican las opciones de los accesos del teclado
        config.modificar(args.distribucion)
    elif args.accion == "modificarOpcion":
        #Permite modificar una opcion
        config.modificar_opcion(args.opcion,args.distribucion)
    else:
        #Si no se pasa ningún argumento se despliega la ayuda
        parser.print_help()

En el siguiente artículo se explicará los cambios que se hicieron en la interfaz gráfica del artículo Desarrollo de interfaz gráfica para la configuración de accesos rápidos del teclado.
Luego se explicará como se crea un paquete python y como se crea un paquete para Debian a partir del paquete python.

Widgets en Android con python. Parte 7 (selección simple)

En este artículo explicaré el uso del widget de selección simple.

La idea es tener una tupla con varios colores, se abre un widget con esos colores y se selecciona uno, luego aparecerá un mensaje con el color seleccionado.

A continuación se muestra el código en python de la aplicación:

#Importar módulo android y time.
import android,time

#Se instancia el objeto Android 
droid = android.Android()

#Se crea el titulo del mensaje de alerta y se crea el widget. 
titulo = 'Color seleccionado'
droid.dialogCreateAlert(titulo)

#Se crea la tupla con la lista de colores. 
colores = ('amarillo', 'azul', 'rojo')

#Se agrega la tupla al widget de selección simple. 
droid.dialogSetItems(colores)

#Se muestra el widget. 
droid.dialogShow()

#Se captura el resultado de seleccionar un color 
respuesta  = droid.dialogGetResponse().result
#El resultado se guarda en un diccionario y se muestra en un mensaje.
droid.makeToast('El color seleccionado es: %s' %colores[respuesta['item']])

La siguiente figura muestra el widget de la lista de colores.

Luego de darle clip a un color se muestra un mensaje con el color selecionado como lo muestra la siguiente figura.

Para finalizar se muestra la figura del código QR del programa.

Widgets en Android con python. Parte 6 (Botones)

Continuando con los widgets del API de ASE para el lenguaje python se hará un script que muestra 3 botones y se mostrará el mensaje del resultado de darle clip al botón.

El código del programa es el siguiente:

#Importando el módulo android.

import android

#Crear la instancia del objeto android

droid = android.Android()

#Título y mensaje del botón.

title = 'Alerta'
message = ('Esta alerta tiene 3 botones y' 'se espera que presione uno')
 

#Crear el widget de mensaje de alerta 

droid.dialogCreateAlert(title, message)
 

#Se definen los mensajes de los botones (si, no y cancelar).

droid.dialogSetPositiveButtonText('Si')
droid.dialogSetNegativeButtonText('No')
droid.dialogSetNeutralButtonText('Cancelar')

#Mostrar el mensaje

droid.dialogShow()

#Captura del resultado de darle clip a algún botón.

#el resultado es un diccionario.

response = droid.dialogGetResponse().result
 

#Se muestra un mensaje con el resultado de darle clip.

droid.makeToast('El resultado de la ejecucion del boton es: %s'    %response['which'])

En la siguiente figura se muestra el widget de los botones.

Luego se presentará las 3 figuras de darle clip a cada botón.
Mensaje del boton Si.

Mensaje del boton Cancelar.

Mensaje del botón No.

Para finalizar se muestra la figura del código QR del script.

Widgets en Android con python. Parte 5 (Botón)

Este artículo explicará como crear un mensaje con un botón de continuar, luego de presionar el botón se presenta un mensaje del resultado del botón.

El código de la aplicación es el siguiente:

#Importar módulo android
import android
#Se crea la instancia del objeto Android
droid = android.Android()

#título y mensaje del botón 
title = 'Interfaz de usuario'
message = 'Esta es una prueba'

#Se crea la alerta con el título y mensaje 
droid.dialogCreateAlert(title, message)

#Se define el botón 
droid.dialogSetPositiveButtonText('Continuar')
 
#Se muestra el mensaje 
droid.dialogShow()

#Se captura el resultado del resultado de darle clip al botón
#El resultado es un diccionario
response = droid.dialogGetResponse().result
 
#Se muestra el resultado del clip del botón 
droid.makeToast('El resultado de la ejecucion del boton es: %s' 
                                %response['which'])

A continuación se muestra el botón.

La siguiente figura se muestra el mensaje del resultado de darle clip al botón.

Para finalizar se muestra la imagen del código qr del programa.

Widgets en Android con python. Parte 4 (notificación)

A veces se necesita crear un mensaje de notificación al celular con Android.
El siguiente post explicará como crear ese mensaje.

A continuación se muestra el código:

#importar módulos android y time

import android,time
 

#Crear la instancia de la clase Android

droid = android.Android()
 

#Se crea el mensaje de notificación.

droid.notify('Prueba' , 'Hola Mundo!')

A continuación se muestra la figura donde aparece en Android la notificación de un mensaje.

En la siguiente figura se muestra ya el mensaje de notificación.

Para finalizar les dejo el código qr del programa en python.

Widgets en Android con python. Parte 3 (barra de spinner)

A continuación se explicará como usar la barra de spinner (barra de proceso giratoria).
Básicamente el programa es el mismo que el del post anterior: Se solicitará el tiempo de ejecución y luego se inicia la barra de spiner.

A continuación se muestra el código:

#Se importa los módulos android y time
import android, time
#Se instancia el objeto Android
droid = android.Android()
#Se define un título y un mensaje
title = 'Spinner'
message = 'Este es un simple progreso spinner.'
 
#Se solicita se escriba el tiempo a ejecutar 
numero = droid.getInput("Escriba el tiempo","tiempo:")

#Se crea la barra de progreso spinner con el título y mensaje 
droid.dialogCreateSpinnerProgress(title, message)
 
#Se muestra la barra de progreso 
droid.dialogShow()

#Se genera un tiempo de espera dado el número de entrada 
time.sleep(int(numero[1]))
#Se cierra la barra de progreso spinner
droid.dialogDismiss()

A continuación se muestra la figura de la entrada del tiempo de ejecución.

A continuación se muestra la barra de progreso spinner.

Para finalizar se muestra el código qr del programa.