Introducción e Instalación

¿Qué es Kivy?

Kivy es un framework de Python para desarrollar aplicaciones multiplataforma con interfaces táctiles. Una sola base de código funciona en:

• Windows, macOS, Linux
• Android, iOS
• Raspberry Pi

Características Principales

Característica	Descripción
Cross-platform	Un código, múltiples plataformas
GPU Accelerated	Renderizado con OpenGL ES 2
Multi-touch	Soporte nativo para gestos táctiles
Lenguaje KV	DSL para diseño de interfaces
MIT License	Open source y gratuito

Casos de Uso

• Aplicaciones móviles
• Kioscos interactivos
• Juegos 2D
• Visualización de datos
• Herramientas multimedia

Instalación

Requisitos del Sistema

# Verificar versión de Python (3.8+)
python --version

Instalación Básica

# Crear entorno virtual (recomendado)
python -m venv kivy_env

# Activar entorno
source kivy_env/bin/activate      # Linux/macOS
kivy_env\Scripts\activate         # Windows

# Instalar Kivy
pip install kivy

Instalación con Dependencias Extras

# Con soporte multimedia completo
pip install kivy[full]

# Solo audio/video
pip install kivy[media]

Verificación

# test_install.py
import kivy
print(f"Kivy version: {kivy.__version__}")

from kivy.app import App
from kivy.uix.label import Label

class TestApp(App):
    def build(self):
        return Label(text='Kivy funciona!')

if __name__ == '__main__':
    TestApp().run()

Ejecutar en Dispositivo Android

Preparar el Entorno

# Instalar Buildozer
pip install buildozer

# Dependencias Linux (Ubuntu/Debian)
sudo apt-get install -y \
    git zip unzip openjdk-17-jdk python3-pip \
    autoconf libtool pkg-config zlib1g-dev \
    libncurses5-dev libncursesw5-dev libtinfo5 \
    cmake libffi-dev libssl-dev

Crear Proyecto para Android

# Crear estructura
mkdir mi_app && cd mi_app

# Crear main.py
cat > main.py << 'EOF'
from kivy.app import App
from kivy.uix.label import Label

class MiApp(App):
    def build(self):
        return Label(text='¡Hola desde Android!')

if __name__ == '__main__':
    MiApp().run()
EOF

# Inicializar Buildozer
buildozer init

Configurar buildozer.spec

Edita buildozer.spec:

[app]
title = Mi Primera App
package.name = miapp
package.domain = com.ejemplo
source.dir = .
source.include_exts = py,png,jpg,kv,atlas
version = 0.1
requirements = python3,kivy
orientation = portrait
fullscreen = 0
android.permissions = INTERNET
android.api = 33
android.minapi = 21
android.archs = arm64-v8a

Conectar Dispositivo Android

1. Habilitar Opciones de desarrollador en tu Android:

   • Ve a Ajustes > Acerca del teléfono
   • Toca “Número de compilación” 7 veces

2. Activar Depuración USB:

   • Ajustes > Opciones de desarrollador > Depuración USB

3. Conectar por USB y verificar:

# Instalar ADB si no lo tienes
sudo apt-get install adb

# Verificar dispositivo conectado
adb devices
# Debe mostrar tu dispositivo

Compilar y Desplegar

# Primera vez (descarga SDK/NDK, toma ~20 min)
buildozer android debug deploy run

# Ver logs en tiempo real
buildozer android logcat

Alternativa: Usar Docker

Si tienes problemas de dependencias:

docker pull kivy/buildozer

docker run --rm -v "$PWD":/home/user/hostcwd \
    -v "$HOME/.buildozer":/home/user/.buildozer \
    kivy/buildozer android debug

Luego instala manualmente:

adb install bin/*.apk

Instalación por Sistema Operativo

Linux (Ubuntu/Debian)

# Dependencias del sistema
sudo apt-get install python3-pip python3-venv
sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev

# Instalar Kivy
pip install kivy

macOS

# Con Homebrew
brew install pkg-config sdl2 sdl2_image sdl2_ttf sdl2_mixer

pip install kivy

Windows

# Instalación directa (incluye dependencias)
pip install kivy

Configuración del Editor

VS Code

1. Instalar extensión “Python”
2. Instalar extensión “Kivy” para syntax highlighting de archivos .kv

// settings.json
{
    "files.associations": {
        "*.kv": "kivy"
    }
}

PyCharm

1. Configurar el intérprete del entorno virtual
2. Marcar carpeta del proyecto como Sources Root

Arquitectura de Kivy

┌─────────────────────────────────────────┐
│              Tu Aplicación              │
├─────────────────────────────────────────┤
│     Widgets │ Layouts │ Propiedades     │
├─────────────────────────────────────────┤
│          Core (Clock, Events)           │
├─────────────────────────────────────────┤
│       Graphics (OpenGL ES 2)            │
├─────────────────────────────────────────┤
│    Providers (SDL2, PyGame, etc.)       │
└─────────────────────────────────────────┘

Componentes Principales

Componente	Módulo	Función
App	kivy.app	Punto de entrada de la aplicación
Widget	kivy.uix	Elementos de interfaz
Properties	kivy.properties	Sistema reactivo de datos
Clock	kivy.clock	Programación temporal
Graphics	kivy.graphics	Dibujo y renderizado

Estructura de un Proyecto Kivy

mi_proyecto/
├── main.py              # Punto de entrada
├── main.kv              # Diseño de interfaz (opcional)
├── requirements.txt     # Dependencias
├── buildozer.spec       # Config para Android/iOS
├── assets/
│   ├── images/
│   └── fonts/
└── screens/             # Módulos de pantallas
    └── __init__.py

Testing de la Instalación

# test_instalacion.py
import unittest

class TestInstalacion(unittest.TestCase):
    def test_kivy_importable(self):
        import kivy
        self.assertIsNotNone(kivy.__version__)

    def test_app_importable(self):
        from kivy.app import App
        self.assertTrue(callable(App))

    def test_widgets_disponibles(self):
        from kivy.uix.label import Label
        from kivy.uix.button import Button
        self.assertTrue(callable(Label))
        self.assertTrue(callable(Button))

if __name__ == '__main__':
    unittest.main()

Ejecutar tests:

python -m pytest test_instalacion.py -v

Probar en Dispositivo con ADB

# Verificar dispositivo conectado
adb devices

# Instalar APK de prueba
adb install bin/miapp-0.1-debug.apk

# Ver logs de la app en tiempo real
adb logcat | grep python

# Reiniciar app sin reinstalar
adb shell am force-stop com.ejemplo.miapp
adb shell am start -n com.ejemplo.miapp/org.kivy.android.PythonActivity

# Capturar pantalla del dispositivo
adb exec-out screencap -p > screenshot.png

Resumen

• Kivy permite desarrollo multiplataforma con Python
• Usa OpenGL para renderizado acelerado por GPU
• Soporta gestos táctiles nativamente
• El lenguaje KV separa diseño de lógica
• Buildozer empaqueta apps para Android con un solo comando
• adb devices verifica la conexión USB con el dispositivo