Scrcpy

# Conectar dispositivo por USB
# Verificar que aparece
adb devices

# Verificar que tienes instalado
pacman -Q ffmpeg sdl2 adb libusb

sudo pacman -S ffmpeg sdl2 android-tools libusb

# scrcpy está en los repositorios oficiales de Arch
sudo pacman -S scrcpy

scrcpy --version
# Debe mostrar: scrcpy 3.3.4 o superior

# Si quieres la versión más reciente (desarrollo)
yay -S scrcpy-git

# O con paru
paru -S scrcpy-git

# 1. Instalar dependencias de compilación
sudo pacman -S base-devel meson ninja pkg-config \
  ffmpeg libusb sdl2 \
  jdk17-openjdk

# 2. Clonar repositorio
git clone https://github.com/Genymobile/scrcpy.git
cd scrcpy

# 3. Compilar
meson setup x --buildtype=release --strip -Db_lto=true
ninja -Cx

# 4. Instalar
sudo ninja -Cx install

# 5. Verificar
scrcpy --version

# Verificar que adb funciona
adb --version

# Iniciar servidor adb
adb start-server

# Listar dispositivos conectados
adb devices

# Debe mostrar algo como:
# List of devices attached
# 0123456789ABCDEF    device

# Verificar si estás en el grupo
groups | grep adbusers

# Si no estás, agregarte
sudo usermod -aG adbusers $USER

# Cerrar sesión y volver a iniciar
# O ejecutar:
newgrp adbusers

# Crear archivo de reglas
sudo nano /etc/udev/rules.d/51-android.rules

sudo udevadm control --reload-rules
sudo udevadm trigger

# Conectar dispositivo por USB
# En el dispositivo, autorizar la computadora (popup que aparece)

# Verificar conexión
adb devices

# Iniciar scrcpy
scrcpy

# Duplicar pantalla del dispositivo
scrcpy

# Limitar resolución (mejor rendimiento)
scrcpy -m1920        # máximo 1920px de ancho
scrcpy -m1024        # máximo 1024px (más fluido)

# Solo video, sin audio
scrcpy --no-audio

# Solo audio, sin video
scrcpy --no-video --no-control

# Ventana siempre visible
scrcpy --always-on-top

# Pantalla completa
scrcpy -f

# Mantener dispositivo despierto (conectado a corriente)
scrcpy -w

# Apagar pantalla del dispositivo (ahorra batería)
scrcpy -S

# Presentación fluida (baja resolución, alta velocidad)
scrcpy -m1024 --max-fps=60 --no-audio

# Grabación de alta calidad
scrcpy --video-codec=h265 -m1920 --max-fps=60 -r tutorial.mp4

# Solo audio (como dictáfono)
scrcpy --audio-source=mic --no-video --no-control -r grabacion.opus

# Control sin duplicación (ahorra recursos)
scrcpy --no-video --no-audio

scrcpy  # Se conecta automáticamente

# Listar dispositivos
adb devices

# Conectar por serial
scrcpy --serial=0123456789ABCDEF
scrcpy -s 0123456789ABCDEF  # versión corta

# Conectar al único dispositivo USB
scrcpy --select-usb
scrcpy -d  # versión corta

# Conectar al único dispositivo TCP/IP
scrcpy --select-tcpip
scrcpy -e  # versión corta

# En Fish
set -gx ANDROID_SERIAL 0123456789ABCDEF
scrcpy

# En Bash/Zsh
export ANDROID_SERIAL=0123456789ABCDEF
scrcpy

# Seleccionar códec
scrcpy --video-codec=h264  # Por defecto, menor latencia
scrcpy --video-codec=h265  # Mejor calidad
scrcpy --video-codec=av1   # Muy nueva, pocos dispositivos

# Listar codificadores disponibles
scrcpy --list-encoders

# Orientación de captura (en el dispositivo)
scrcpy --capture-orientation=0      # Sin rotación
scrcpy --capture-orientation=90     # 90° horario
scrcpy --capture-orientation=180    # 180°
scrcpy --capture-orientation=270    # 270° horario

# Bloquear orientación (no rota aunque gires el dispositivo)
scrcpy --capture-orientation=@90    # Bloqueada a 90°

# Orientación de visualización (en la computadora)
scrcpy --orientation=90             # Rotar visualización 90°

# Rotar contenido por ángulo personalizado
scrcpy --angle=23                   # Rotar 23° horario

# Recortar región específica
scrcpy --crop=1224:1440:0:0   # Ancho:Alto:OffsetX:OffsetY

# Ejemplo: recortar solo la mitad superior
scrcpy --crop=1080:960:0:0    # Para un dispositivo 1080x1920

# Agregar buffer para compensar fluctuaciones de red (WiFi)
scrcpy --video-buffer=50    # 50ms de buffer
scrcpy --video-buffer=200   # 200ms (más suave, más latencia)

# Sin buffer (por defecto, menor latencia)
scrcpy

# Solo grabar, sin mostrar (útil para grabaciones largas)
scrcpy --no-playback --record=archivo.mp4

# O solo desactivar reproducción de video
scrcpy --no-video-playback --record=archivo.mp4

# Crear nueva pantalla virtual (no duplica la principal)
scrcpy --new-display=1920x1080

# Con DPI personalizado
scrcpy --new-display=1920x1080/420

# Iniciar app en pantalla virtual
scrcpy --new-display=1920x1080 --start-app=org.videolan.vlc

# Sin decoraciones del sistema
scrcpy --new-display --no-vd-system-decorations --start-app=org.mozilla.firefox

# Sin audio (por defecto está habilitado)
scrcpy --no-audio

# Solo audio, sin video
scrcpy --no-video --no-control

# Audio sin ventana
scrcpy --no-window  # implica --no-video --no-control

# Salida de audio del dispositivo (por defecto)
scrcpy --audio-source=output

# Micrófono del dispositivo
scrcpy --audio-source=mic

# Otras fuentes:
scrcpy --audio-source=playback            # Reproducción (apps pueden optar por no capturar)
scrcpy --audio-source=mic-unprocessed     # Micrófono sin procesar
scrcpy --audio-source=mic-camcorder       # Optimizado para video
scrcpy --audio-source=mic-voice-recognition
scrcpy --audio-source=mic-voice-communication
scrcpy --audio-source=voice-call
scrcpy --audio-source=voice-call-uplink
scrcpy --audio-source=voice-call-downlink

scrcpy --audio-source=mic --no-video --no-playback --record=grabacion.opus

# Reproducir audio en dispositivo Y en la computadora
scrcpy --audio-dup

# Equivalente a:
scrcpy --audio-source=playback --audio-dup

# Seleccionar códec
scrcpy --audio-codec=opus  # Por defecto
scrcpy --audio-codec=aac
scrcpy --audio-codec=flac
scrcpy --audio-codec=raw   # PCM 16-bit sin comprimir

# Ejemplo: grabar audio en FLAC de alta calidad
scrcpy --no-video --audio-codec=flac --record=audio.flac

# Opciones adicionales de códec
scrcpy --audio-codec=flac --audio-codec-options=flac-compression-level=8

# Cambiar bitrate (por defecto 128 Kbps)
scrcpy --audio-bit-rate=64K
scrcpy --audio-bit-rate=64000  # equivalente
scrcpy --audio-bit-rate=320K   # Alta calidad

# Ajustar buffer de audio (por defecto 50ms)
scrcpy --audio-buffer=40    # Menor latencia
scrcpy --audio-buffer=100   # Más estable
scrcpy --audio-buffer=200   # Muy estable, más latencia

# Buffer de salida de audio (por defecto 5ms)
# Solo cambiar si hay audio robótico/entrecortado
scrcpy --audio-output-buffer=10

# Grabar video y audio
scrcpy --record=archivo.mp4
scrcpy -r archivo.mkv  # versión corta

# Solo video
scrcpy --no-audio --record=video.mp4

# Solo audio
scrcpy --no-video --record=audio.opus
scrcpy --no-video --audio-codec=aac --record=audio.aac
scrcpy --no-video --audio-codec=flac --record=audio.flac
scrcpy --no-video --audio-codec=raw --record=audio.wav

scrcpy --record=archivo --record-format=mkv

# Grabar sin mostrar en pantalla (ahorra recursos)
scrcpy --no-playback --record=archivo.mp4

# Sin ventana (modo background)
scrcpy --no-window --record=archivo.mp4
# Interrumpir con Ctrl+C

# Solo grabar video, seguir escuchando audio
scrcpy --no-video-playback --record=archivo.mp4

# Grabar por 20 segundos
scrcpy --record=archivo.mp4 --time-limit=20

# También funciona sin grabar
scrcpy --time-limit=30  # Duplicar por 30 segundos y cerrar

# Configuración óptima
scrcpy -m1920 \
  --max-fps=60 \
  --video-bit-rate=8M \
  --no-audio \
  --always-on-top \
  --stay-awake \
  -f

# Grabación profesional
scrcpy --video-codec=h265 \
  -m1920 \
  --max-fps=60 \
  --video-bit-rate=8M \
  --audio-source=mic \
  --audio-codec=aac \
  --audio-bit-rate=192K \
  --record=tutorial-app-estadistica.mp4 \
  --stay-awake \
  --show-touches

# Configurar como webcam (Linux)
scrcpy --video-source=camera \
  --camera-size=1920x1080 \
  --camera-facing=front \
  --v4l2-sink=/dev/video2 \
  --no-playback

# 1. Conectar por USB una vez
scrcpy --tcpip

# 2. Desconectar cable
# 3. Ahora funciona inalámbrico
scrcpy -m1024 --max-fps=30

# Grabar sesión completa
scrcpy --video-codec=h265 \
  -m1920 \
  --max-fps=30 \
  --record=documentacion-flujo.mkv \
  --no-audio \
  --show-touches

# Luego extraer frames con ffmpeg:
ffmpeg -i documentacion-flujo.mkv -vf fps=1/5 captura_%04d.png

scrcpy --audio-source=mic \
  --audio-codec=flac \
  --audio-buffer=200 \
  --no-video \
  --no-window \
  --record=entrevista-$(date +%Y%m%d).flac

# 1. Verificar cable USB (usar cable de datos, no solo carga)

# 2. Verificar depuración USB en dispositivo
# Ajustes → Opciones de desarrollador → Depuración USB

# 3. Autorizar computadora en dispositivo (popup)

# 4. Reiniciar servidor adb
adb kill-server
adb start-server
adb devices

# 5. Verificar permisos
groups | grep adbusers
# Si no estás: sudo usermod -aG adbusers $USER

# 6. Verificar reglas udev
ls /etc/udev/rules.d/51-android.rules
# Si no existe, crearla (ver sección Configuración Inicial)

# 7. Probar con sudo (temporal, para descartar permisos)
sudo adb devices

# 1. Limpiar archivos temporales en dispositivo
adb shell rm -rf /data/local/tmp/scrcpy-server*

# 2. Verificar espacio
adb shell df -h /data

# 3. Si falta espacio, limpiar caché
# En dispositivo: Ajustes → Almacenamiento → Limpiar caché

# 4. Intentar de nuevo
scrcpy

# 1. Reducir resolución
scrcpy -m1024

# 2. Cambiar códec
scrcpy --video-codec=h264  # Más compatible

# 3. Listar codificadores disponibles
scrcpy --list-encoders

# 4. Probar con otro codificador
scrcpy --video-codec=h264 --video-encoder=OMX.qcom.video.encoder.avc

# 5. Verificar FFmpeg
ffmpeg -version

# 1. Aumentar buffer de audio
scrcpy --audio-buffer=200

# 2. Aumentar buffer de salida
scrcpy --audio-output-buffer=10

# 3. Cambiar códec
scrcpy --audio-codec=aac  # En lugar de opus

# 4. Reducir calidad de video (libera CPU)
scrcpy -m1024 --max-fps=30

# 5. Conexión por cable (en lugar de WiFi)

# 1. Usar cable USB
# WiFi siempre tendrá más latencia que USB

# 2. Reducir calidad
scrcpy -m1024 --max-fps=30 --video-bit-rate=2M

# 3. Agregar buffer
scrcpy --video-buffer=100 --audio-buffer=200

# 4. Verificar red WiFi (2.4 GHz vs 5 GHz)
# 5 GHz tiene menor latencia pero menor alcance

# 5. Reducir interferencias (cerrar otras apps de red)

# 1. Verificar versión de Android
adb shell getprop ro.build.version.release

# 2. Usar atajos correctos
# MOD+c (copiar), MOD+v (pegar)

# 3. Si no funciona, usar modo legacy
scrcpy --legacy-paste

# 4. Pegar como eventos de teclas
# MOD+Shift+v

# Habilitar opción adicional en Opciones de desarrollador:
# "Depuración USB (Configuración de seguridad)"

# Reiniciar dispositivo

# Verificar
adb devices
scrcpy

# Usar OTG requiere que adb NO esté corriendo
adb kill-server

# Luego usar OTG
scrcpy --otg

# Nota: En OTG no hay duplicación de pantalla

# Básico
scrcpy                          # Duplicar pantalla
scrcpy -m1024                   # Limitar a 1024px
scrcpy -f                       # Pantalla completa
scrcpy -w                       # Mantener despierto
scrcpy -S                       # Apagar pantalla

# Selección de dispositivo
scrcpy -s 0123456789ABCDEF      # Por serial
scrcpy -d                       # USB (único)
scrcpy -e                       # TCP/IP (único)
scrcpy --tcpip=192.168.1.100    # TCP/IP directo

# Calidad
scrcpy -m1920 --max-fps=60 -b 8M
scrcpy --video-codec=h265
scrcpy --audio-codec=aac

# Video y audio
scrcpy -r archivo.mp4
scrcpy --record=archivo.mkv

# Solo video
scrcpy --no-audio -r video.mp4

# Solo audio
scrcpy --no-video -r audio.opus

# Sin mostrar
scrcpy --no-playback -r grabacion.mp4

# Límite de tiempo
scrcpy -r archivo.mp4 --time-limit=60

# Sin audio
scrcpy --no-audio

# Fuentes de audio
scrcpy --audio-source=mic       # Micrófono
scrcpy --audio-source=output    # Salida (default)

# Solo audio
scrcpy --no-video --no-control

# Duplicar audio (dispositivo + PC)
scrcpy --audio-dup

# Sin control
scrcpy -n

# Sin video ni audio
scrcpy --no-video --no-audio

# Mostrar toques
scrcpy --show-touches
scrcpy -t

# Simulación física (HID)
scrcpy -K                       # Teclado UHID
scrcpy -M                       # Mouse UHID
scrcpy -KM                      # Ambos

# Modo OTG (sin adb)
scrcpy --otg
scrcpy --otg -G                 # Con gamepad

# Crear display virtual
scrcpy --new-display=1920x1080

# Con app
scrcpy --new-display --start-app=org.videolan.vlc

# Sin decoraciones
scrcpy --new-display --no-vd-system-decorations

# Duplicar cámara
scrcpy --video-source=camera

# Seleccionar cámara
scrcpy --video-source=camera --camera-facing=front
scrcpy --video-source=camera --camera-id=0

# Webcam (Linux)
scrcpy --video-source=camera \
  --camera-size=1920x1080 \
  --v4l2-sink=/dev/video2 \
  --no-playback

# Presentación fluida
scrcpy -m1024 --max-fps=60 --no-audio -f -w

# Grabación profesional
scrcpy --video-codec=h265 -m1920 --max-fps=60 \
  --audio-codec=aac -r tutorial.mp4

# Control inalámbrico ligero
scrcpy --tcpip -m1024 --max-fps=30

# Demo con toques visibles
scrcpy -m1920 --show-touches --stay-awake

# Solo grabar micrófono
scrcpy --audio-source=mic --no-video \
  --no-playback -r grabacion.opus

# =============================================================================
# ALIAS DE SCRCPY
# =============================================================================

# Uso básico
alias scr="scrcpy"
alias scrf="scrcpy -f"
alias scrw="scrcpy -w"

# Presentaciones
alias scr-present="scrcpy -m1920 --max-fps=60 --no-audio -f -w"
alias scr-demo="scrcpy -m1920 --show-touches --stay-awake -f"

# Grabación
alias scr-rec="scrcpy --video-codec=h265 -m1920 --max-fps=60 --record"
alias scr-rec-audio="scrcpy --audio-source=mic --no-video --no-playback --record"

# WiFi
alias scr-wifi="scrcpy --tcpip"

# Control
alias scr-control="scrcpy --no-video --no-audio -KM"

source ~/.config/fish/config.fish

#!/bin/bash

# Script para conectar scrcpy automáticamente

# Verificar dispositivos
DEVICES=$(adb devices | grep -w device | wc -l)

if [ "$DEVICES" -eq 0 ]; then
    echo "No hay dispositivos conectados."
    echo "Conecta un dispositivo por USB o configura WiFi."
    exit 1
elif [ "$DEVICES" -eq 1 ]; then
    echo "Conectando al único dispositivo..."
    scrcpy -m1920 --max-fps=60 "$@"
else
    echo "Múltiples dispositivos detectados:"
    adb devices
    echo ""
    echo "Usa: scrcpy -s SERIAL"
fi

chmod +x ~/bin/scrcpy-auto

scrcpy-auto
scrcpy-auto --record=video.mp4

sudo pacman -S ffmpeg kdenlive obs-studio

sudo pacman -S flameshot

sudo pacman -S obs-studio

scrcpy -m1920 --max-fps=60 --no-audio --always-on-top --stay-awake -f

scrcpy --video-codec=h265 -m1920 --max-fps=60 \
  --audio-codec=aac --show-touches \
  --record=archivo.mp4

# Primera vez (USB)
scrcpy --tcpip

# Siguientes veces (WiFi)
scrcpy -m1024 --max-fps=30

scrcpy -m1920 --show-touches --stay-awake --record=doc.mkv