Practica No.3: Programación en Android con Python

Actualmente los teléfonos están viviendo un boom tecnológico, lo que permite que evolucionen a un ritmo increíblemente acelerado, es por esto que la gran mayoría de lenguajes de programación han tratado de acercarse a esta nueva plataforma y poder crear aplicaciones que corran sobre ella.

Existen muchos S.O para celulares pero el gran dominador del mercado actualmente es Android, debido a esto no es raro que hayan surgido diversas librerías que permitan programar en Android. Y entre todos ellos Python no es la excepción y en la actualidad ya cuenta con varias formas de acércanos a la plataforma Android.

Algunas de las más reconocidas son Kivy, SL4A y QPython, sin embargo la opción QPython está descartada en este post debido a que está hecho para ejecutarse y programar directamente sobre un dispositivo Android, lo mismo que SL4A por lo tanto nos vamos a enfocar a la programación con Kivy al ser multiplataforma.

¿Cómo instalar Kivy?

Para instalar Kivy basta con ir a la página oficial y en ella bajar la versión adecuada de acuerdo a nuestro sistema, en este caso, la versión para Windows, después de bajarla y descomprimirla copiamos el archivo kivy-3.4.bat y lo mandamos a la carpeta Shell:sendto como acceso directo y le cambiamos el nombre a kivy-1.9.

De esta manera al tener nuestro archivo *.py le damos con click derecho y luego a “enviar a” y elegimos como opción kivy-1.9, así podemos probar nuestras aplicaciones.

Programando con Kivy

Realizaremos un ejemplo sencillo en kivy el cual simplemente desplegara el mensaje hola mundo en pantalla usando un botón, que en este ejemplo no realizara ninguna acción, el código es el siguiente:

from kivy.app import App
from kivy.uix.button import Button
 
class Hello(App):
    def build(self):
        btn = Button(text='Hello World')
        return  btn
 
Hello().run()

Como podemos observar lo único que hace esta clase es regresar un botón al que se le agrega la palabra “Hola Mundo” y ejecutar la aplicación con el método run(). Este ejemplo se puede descargar desde este link.

El siguiente ejemplo es tomado de los ejemplos de prueba de la propia herramienta Kivy, la cual obtiene la posición en pantalla cuando damos clic sobre ella, además nos indica el tipo de evento que es llamado y el número de eventos que han ocurrido, todo esto en colores generados aleatoriamente:

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()

El ejemplo se puede descargar del siguiente link. Como podemos observar Kivy es una herramienta poderosa, que nos permite hacer cosas muy interesantes, que si bien no tiene métodos tan eficientes como otras opciones al ser multiplataforma, es una buena forma de comenzar en la programación de aplicaciones para Android.