jueves, 27 de agosto de 2026

Cómo compilar ScreenCast desde cero en antiX Linux

📱 ¿Qué es ScreenCast y para qué sirve?

ScreenCast es una aplicación Android de código abierto que permite transmitir la pantalla de un dispositivo Android hacia uno o varios Chromecast a través de la red Wi-Fi local.

¿Para qué sirve?
Imagina que tienes un dispositivo Android TV (como un stick DGO) reproduciendo contenido en SmartTube, y quieres ver ese mismo contenido en otro televisor que tiene un Chromecast conectado. ScreenCast captura la pantalla del dispositivo Android, la codifica y la envía directamente al Chromecast mediante el protocolo Google Cast V2.

Características principales

  • Captura la pantalla completa mediante MediaProjection
  • Codifica el vídeo en H.264 mediante MediaCodec
  • Dos modos de transmisión:
    • HLS: latencia de 5–10 segundos, permite pausa/seek
    • WebRTC: latencia inferior a 1 segundo
  • Soporta hasta 4 Chromecast simultáneamente
  • No requiere root
  • Código abierto bajo licencia Apache 2.0

🛠️ Requisitos previos

  • Sistema: antiX Linux (o cualquier distribución Debian-based)
  • Espacio en disco: ~1 GB para herramientas y dependencias
  • Conexión a Internet: para descargar dependencias
  • Dispositivo Android: con Android 8.0+ (API 26+) para instalar la APK

📦 Paso 1: Verificar e instalar Java y ADB

1.1 Verificar qué tenemos instalado

Abre una terminal y ejecuta los siguientes comandos:

java -version
javac -version
git --version
which adb

✅ Salida esperada en tu sistema:
git version 2.47.3

Nota: En mi caso, Java y ADB no estaban instalados inicialmente.

1.2 Instalar Java 21 y ADB

Actualicé los repositorios e instalé los paquetes:

sudo apt update
sudo apt install openjdk-21-jdk adb

Cuando aparezca Continue? [S/n], presiona Enter (equivale a S).

1.3 Verificar las instalaciones

java -version
javac -version
adb version

✅ Salida esperada:
openjdk version "21.0.12.1"
javac 21.0.12.1
Android Debug Bridge version 1.0.41
Version 37.0.1

📁 Paso 2: Crear la estructura de directorios

Crea un directorio para el código fuente en tu partición de datos:

mkdir -p /mnt/otros/backup/src/Android/proyectos
cd /mnt/otros/backup/src/Android/proyectos

📥 Paso 3: Clonar el repositorio de ScreenCast

git clone https://github.com/ddagunts/ScreenCast.git
cd ScreenCast
pwd

✅ Salida esperada de pwd:
/mnt/otros/backup/src/Android/proyectos/ScreenCast

🧰 Paso 4: Instalar Android SDK Command Line Tools

4.1 Crear el directorio del SDK

cd /mnt/otros/backup/src/Android
mkdir -p sdk/cmdline-tools
cd sdk

4.2 Descargar las Command Line Tools

wget -O commandlinetools-linux.zip \
https://dl.google.com/android/repository/commandlinetools-linux-14742923_latest.zip

ls -lh commandlinetools-linux.zip

4.3 Descomprimir el archivo

unzip commandlinetools-linux.zip -d cmdline-tools
mv cmdline-tools/cmdline-tools cmdline-tools/latest
ls -la cmdline-tools/latest/bin

✅ Verifica que aparezca sdkmanager:
-rwxr-xr-x ... sdkmanager

⚙️ Paso 5: Configurar variables de entorno

5.1 Configuración temporal (para esta sesión)

export ANDROID_HOME=/mnt/otros/backup/src/Android/sdk
export ANDROID_SDK_ROOT=$ANDROID_HOME
export PATH=$PATH:$ANDROID_HOME/cmdline-tools/latest/bin
export PATH=$PATH:$ANDROID_HOME/platform-tools

⚠️ Importante: Estas variables son temporales. Si cierras la terminal, deberás volver a ejecutarlas.

5.2 Verificar sdkmanager

sdkmanager --version

✅ Salida esperada:
20.0

5.3 Ver qué paquetes están disponibles

sdkmanager --list | grep -E 'platforms;android-36|build-tools;|platform-tools'

✅ Salida esperada (debe incluir):
platforms;android-36 | 2 | Android SDK Platform 36
build-tools;36.0.0 | 36.0.0 | Android SDK Build-Tools 36
platform-tools | 37.0.1 | Android SDK Platform-Tools

📦 Paso 6: Instalar el SDK necesario

Instala la plataforma y herramientas de compilación que necesita ScreenCast:

sdkmanager "platforms;android-36" "build-tools;36.0.0"

⚠️ Importante: Cuando aparezcan las licencias, responde y (yes) a cada una.

6.1 Verificar la instalación

ls -la $ANDROID_HOME/platforms
ls -la $ANDROID_HOME/build-tools
ls $ANDROID_HOME/platforms/android-36/android.jar

🔨 Paso 7: Volver al proyecto y compilar

7.1 Navegar al proyecto

cd /mnt/otros/backup/src/Android/proyectos/ScreenCast

7.2 Verificar variables de entorno

echo $ANDROID_HOME

✅ Salida esperada:
/mnt/otros/backup/src/Android/sdk

7.3 Iniciar la compilación

./gradlew assembleDebug

📌 ¿Qué hace este comando?

  • Descarga automáticamente Gradle 9.6.0
  • Descarga las dependencias del proyecto
  • Compila la aplicación en modo debug
  • Genera la APK en la carpeta de salida

⏳ La primera compilación puede tardar unos minutos. Verás mensajes como:

Downloading ...
> Configure project
> Task :app:compileDebugKotlin

✅ Salida esperada al final:
BUILD SUCCESSFUL in 4m 57s
36 actionable tasks: 36 executed

📄 Paso 8: Localizar la APK generada

ls -lh app/build/outputs/apk/debug/
file app/build/outputs/apk/debug/app-debug.apk

✅ Salida esperada:
-rw-rw-r-- 1 antix1 antix1 64M ago 27 14:42 app-debug.apk
Android package (APK), with gradle app-metadata.properties

📲 Paso 9: Transferir e instalar la APK

Método recomendado: LocalSend

Si tienes LocalSend instalado tanto en antiX como en tu dispositivo Android TV:

  1. En antiX: Abre LocalSend y envía el archivo: 
    /mnt/otros/backup/src/Android/proyectos/ScreenCast/app/build/outputs/apk/debug/app-debug.apk
  2. En el DGO / Android TV:
    • Acepta la transferencia
    • Localiza el archivo recibido
    • Haz clic en app-debug.apk
    • Acepta la instalación
    • Si aparece "instalar aplicaciones desconocidas", activa el permiso para el gestor de archivos

Método alternativo: ADB por red

Si prefieres usar ADB, necesitas la IP del dispositivo Android TV:

/mnt/otros/backup/src/Android/sdk/platform-tools/adb connect IP_DEL_DGO:5555
/mnt/otros/backup/src/Android/sdk/platform-tools/adb devices

Cuando aparezca device, instala:

/mnt/otros/backup/src/Android/sdk/platform-tools/adb install -r \
app/build/outputs/apk/debug/app-debug.apk

🎉 ¡Listo!

Ya tienes ScreenCast compilado e instalado en tu dispositivo Android TV.

Próximos pasos para probar:

  1. Abre ScreenCast en el DGO
  2. Asegúrate de que SmartTube esté reproduciendo contenido
  3. Selecciona el Chromecast de destino (TV2)
  4. Elige el modo de transmisión (recomendamos HLS para empezar)
  5. Acepta el diálogo de MediaProjection
  6. ¡Verifica que la imagen aparece en TV2!

📋 Resumen de comandos útiles

Comando Descripción
git clone https://github.com/ddagunts/ScreenCast.git Clonar el repositorio
sdkmanager "platforms;android-36" "build-tools;36.0.0" Instalar SDK necesario
./gradlew assembleDebug Compilar la APK
ls -lh app/build/outputs/apk/debug/ Ver la APK generada
adb install -r app-debug.apk Instalar por ADB

⚠️ Solución de problemas comunes

❌ Error: java: orden no encontrada
Instala Java: sudo apt install openjdk-21-jdk

❌ Error: Gradle no descarga dependencias
Verifica tu conexión a Internet y que las variables ANDROID_HOME estén configuradas.

❌ Error: sdkmanager no encontrado
Asegúrate de haber configurado el PATH correctamente:

export PATH=$PATH:/mnt/otros/backup/src/Android/sdk/cmdline-tools/latest/bin

❌ Error al instalar en Android TV
Activa "Instalar aplicaciones desconocidas" para la aplicación desde la que abres el APK.

📌 Notas técnicas

Componente Versión
ScreenCast 0.14.1
Java 17 o 21
Android SDK Platform 36, Build Tools 36.0.0
Gradle 9.6.0 (descargado automáticamente)
Android Gradle Plugin 9.2.1
Kotlin 2.4.0
APK generada ~64 MB (incluye WebRTC nativo)

🔗 Enlaces útiles

Publicadas por a la/s No hay comentarios.:
Suscribirse a: Entradas (Atom)