Android Developers
Plataforma Android Studio Google Play Jetpack Kotlin Documentos Juegos
  • English
  • Bahasa Indonesia
  • Deutsch
  • Español
  • Español – América Latina
  • Français
  • Português – Brasil
  • Tiếng Việt
  • Türkçe
  • Русский
  • ภาษาไทย
  • 中文 – 简体
  • 中文 – 繁體
  • 日本語
  • 한국어
  • Documentación
Descripción general Guías Guía de IU Referencia Ejemplos Diseño y calidad
Android Developers
  • Plataforma
  • Android Studio
  • Google Play
  • Jetpack
  • Kotlin
  • Documentos
    • Descripción general
    • Guías
    • Guía de IU
    • Referencia
    • Ejemplos
    • Diseño y calidad
  • Juegos
  • Aspectos básicos de la app
  • Introducción
  • Cómo crear tu primera app
  • Aspectos fundamentales de las apps
  • Recursos de la app
    • Descripción general
    • Cómo administrar los cambios en la configuración
    • Localización
      • Cómo localizar tu app
      • Cómo probar tu app con configuraciones regionales simuladas
      • Unicode y compatibilidad internacional
      • Resolución de idioma y configuración regional
      • Preferencias de idioma de las apps
    • Recursos XML complejos
    • Tipos de recursos
      • Descripción general
      • Animación
      • Lista de estado de colores
      • Elemento de diseño
      • Diseño
      • Menú
      • String
      • Estilo
      • Fuente
      • Más tipos
  • Archivo de manifiesto de la app
    • Descripción general
    • <action>
    • <activity>
    • <activity-alias>
    • <application>
    • <category>
    • <compatible-screens>
    • <data>
    • <grant-uri-permission>
    • <instrumentation>
    • <intent-filter>
    • <manifest>
    • <meta-data>
    • <path-permission>
    • <permission>
    • <permission-group>
    • <permission-tree>
    • <profileable>
    • <property>
    • <provider>
    • <queries>
    • <receiver>
    • <service>
    • <supports-gl-texture>
    • <supports-screens>
    • <uses-configuration>
    • <uses-feature>
    • <uses-library>
    • <uses-native-library>
    • <uses-permission>
    • <uses-permission-sdk-23>
    • <uses-sdk>
  • Dispositivos
  • Compatibilidad con dispositivos
    • Descripción general
    • Descripción general de la compatibilidad de pantallas
    • Formato letterbox mejorado
    • Cómo brindar compatibilidad con diferentes densidades de píxeles
    • Cómo declarar una compatibilidad de pantalla restringida
    • Compatibilidad con varios APK
      • Descripción general
      • Cómo crear varios APK para diferentes niveles de API
      • Cómo crear varios APK para diferentes tamaños de pantallas
      • Cómo crear varios APK para diferentes texturas GL
      • Cómo crear varios APK con numerosas dimensiones
    • Cómo brindar compatibilidad con diferentes idiomas y culturas
    • Cómo brindar compatibilidad con diferentes versiones de plataformas
    • Filtros en Google Play
    • Compatibilidad con 64 bits
  • Pantallas grandes: tablets, plegables y ChromeOS
    • Comienza a desarrollar para pantallas grandes
    • Diseños canónicos de pantalla grande
    • Preparación de las apps para pantallas grandes
      • Compatibilidad con el modo Multiventana
      • Proyección de contenido multimedia
      • Compatibilidad de entrada en pantallas grandes
    • Optimización de la app para pantallas grandes
      • Cómo brindar compatibilidad con diferentes tamaños de pantalla
      • Cómo migrar tu IU a diseños responsivos
      • Navegación para IUs responsivas
      • Incorporación de actividad
    • Diferenciación de la app para pantallas grandes
      • Más información sobre dispositivos plegables
      • Cómo hacer que tu app funcione en dispositivos plegables
      • Cómo probar tu app en dispositivos plegables
    • Guía de soluciones para pantallas grandes
  • Wear
    • Primeros pasos
    • Principios del desarrollo para Wear OS
    • Cómo actualizar a la versión más reciente de Wear OS
    • Diferencias entre el desarrollo para Wear OS y el desarrollo para dispositivos móviles
    • Interfaz de usuario de Wear OS
    • Cómo comenzar
      • Ruta para desarrolladores de Wear OS
      • Cómo crear y ejecutar una app para wearables
      • Cómo depurar una app de Wear OS
      • Cómo tomar capturas de pantalla con la IU de Wear
    • Apps
      • Descripción general
      • Apps independientes
      • Autenticación
      • Cómo solicitar permisos
      • Cómo detectar la ubicación
      • Cómo reproducir audio en wearables
      • Cómo aparecer en Recientes y Reanudación de la app
    • Cómo compilar la IU con Compose
      • Cómo usar Jetpack Compose en Wear OS
      • Rendimiento de Compose
      • Navegación
      • Botones
      • Tarjetas
      • Chips
      • Diálogos
      • Listas
      • Indicadores de página
      • Selectores
      • Indicador de posición
      • Indicador de progreso
      • Controles deslizantes
      • Stepper
      • Desliza para descartar
      • Chips de activación
      • TimeText
    • Cómo compilar IU con Views
      • Cómo compilar IU basadas en objetos View en Wear OS
      • Cómo controlar diferentes formas de reloj
      • Cómo crear listas
      • Navegación
      • Cómo salir de las actividades de pantalla completa en Wear
      • Mostrar confirmaciones
      • Cómo mantener tu app visible en Wear
    • Mosaicos y complicaciones
      • Descripción general de las tarjetas
      • Cómo comenzar a usar tarjetas
      • Actualización de tarjetas
      • Cómo interactuar con tarjetas
      • Complicaciones de caras de reloj
      • Cómo exponer datos a complicaciones
    • Notificaciones
      • Notificaciones en Wear OS
      • Cómo unir opciones para las notificaciones
      • Actividades continuas
    • Cómo controlar datos
      • Cómo enviar y sincronizar datos en Wear OS
      • Acceso a la red y sincronización en Wear OS
      • Cómo acceder a Data Layer para wearables
      • Transferencia de recursos
      • Envío y recepción de mensajes
      • Administración de eventos de Data Layer
      • Cómo sincronizar elementos de datos con la API de Data Layer
    • Entrada del usuario
      • Botones físicos
      • Entrada rotativa
      • Cómo crear editores de métodos de entrada en Wear
      • Voz
    • Servicios de salud
      • Descripción general
      • Ejercicio y datos activos
      • Actualizaciones de datos pasivos
      • Cómo usar proveedores de datos sintéticos
      • Cómo mejorar la compatibilidad con apps
    • Diseño
      • Principios de diseño
      • Cómo comenzar
      • Tipos de interacción
      • Formas de la pantalla
      • Notificaciones
      • Complicaciones
      • Azulejos
      • Sistema de diseño de tarjetas
      • Apps
      • Actividades continuas
      • App de confirmación
      • Indicadores de desconexión
      • Mensajes de permisos
      • Controles de selección
      • Inicio y latencia
      • Navegación
      • Permisos
      • Acceder
      • Botones de hardware
      • Color
      • Tipografía
      • Íconos
      • Descargas
      • Temas de material de Wear
    • Cómo crear caras de reloj
      • Descripción general
      • Cómo diseñar caras de reloj
      • Cómo crear un servicio para caras de reloj
      • Cómo dibujar caras de reloj
      • Cómo agregar complicaciones a una cara de reloj
      • Cómo crear caras de reloj interactivas
      • Cómo proporcionar actividades de configuración
      • Cómo resolver problemas comunes
      • Cómo mejorar el rendimiento con la aceleración de hardware
      • Cómo optimizar el rendimiento y la duración de batería
    • Watch Face Studio
      • Watch Face Studio
      • Combinaciones de teclas
      • Cómo administrar un proyecto de Watch Face Studio
      • Cómo crear una cara de reloj con Watch Face Studio
      • Complicaciones de compilación en Watch Face Studio
      • Expresiones de etiqueta
      • Configuración de idioma
      • Siempre encendida en Watch Face Studio
      • Efectos de giroscopio
      • Cómo crear y subir contenido desde Watch Face Studio
      • Cómo probar la cara de reloj
      • Preguntas frecuentes
      • Sugerencias sobre el rendimiento
    • Calidad de las apps para Wear
    • Cómo empaquetar apps de Wear OS
    • Cómo distribuir a Wear OS
    • Cómo crear apps de Wear OS para China
    • Notas de la versión para Wear OS
  • Android TV
    • Descripción general
    • Cómo crear apps para TV
      • Descripción general
      • Cómo comenzar a usar apps para TV
      • Bibliotecas de AndroidX TV
      • Cómo controlar hardware de TV
      • Cómo administrar controladores de TV
      • Cómo crear diseños de TV
      • Teclado en pantalla
      • Cómo desarrollar la navegación para TV
      • Prácticas recomendadas para aumentar las interacciones con Google TV
    • Cómo crear apps de reproducción para TV
      • Descripción general
      • Guía de la IU y API de Leanback
        • Cómo crear un navegador de catálogos
        • Cómo proporcionar una vista de tarjetas
        • Cómo crear una vista de detalles
        • Cómo usar los controles de transporte
        • Controles de reproducción en TV
        • Modo ambiente
        • Cómo agregar un paso guiado
        • Cómo presentar tu app a los usuarios que acceden por primera vez
      • Cómo implementar una sesión multimedia
      • Reproducción en segundo plano en una tarjeta de Está sonando
      • Capacidades de audio
      • Cómo igualar velocidad de fotogramas del contenido
    • Cómo ayudar a los usuarios a encontrar contenido en la TV
      • Descripción general
      • Cómo recomendar contenido de TV
        • Descripción general
        • Canales en la pantalla principal
        • Atributos de programación de video
        • Atributos de programación de audio
        • Atributos de programación de juegos
        • Ver siguiente
          • Cómo agregar programas
          • Atributos
          • Lineamientos para desarrolladores de apps
          • Lineamientos para proveedores de TV
        • Cómo obtener vistas previas de videos
        • Recomendaciones para Android N y versiones anteriores
      • Cómo permitir las búsquedas en apps para TV
      • Cómo realizar búsquedas en apps para TV
    • Cómo crear juegos para TV
      • Descripción general
      • Cómo usar Stream Protect para las apps de transmisión sensibles a la latencia
    • Compila servicios de entrada de TV
      • Descripción general
      • Cómo desarrollar un servicio de entrada de TV
      • Cómo trabajar con datos del canal
      • Cómo administrar la interacción del usuario con la TV
      • Compatibilidad con time-shifting
      • Compatibilidad con la grabación de contenido
    • Lista de verificación de apps para TV
    • Accesibilidad en TVs
      • Prácticas recomendadas sobre accesibilidad
      • Ejemplos de evaluación de TalkBack
      • Cómo adoptar la configuración de subtítulos del sistema
      • Compatibilidad con accesibilidad de vistas personalizada
      • Muestra de accesibilidad de vistas personalizada
    • Versiones
      • Android 12 para TV
      • Android 13 para TV (beta)
        • Descripción general
        • Novedades de TV
  • Android para vehículos
    • Descripción general
    • Cómo compilar apps multimedia para vehículos
      • Cómo compilar apps multimedia para vehículos
      • Cómo agregar compatibilidad con Android Auto
      • Cómo agregar compatibilidad con el SO Android Automotive
    • Cómo compilar apps de mensajería para Android Auto
    • Cómo compilar apps de navegación y lugares de interés para autos
      • Cómo usar la biblioteca de apps de Android para vehículos
      • Cómo compilar apps de lugares de interés para autos
      • Cómo compilar apps de navegación para autos
      • Cómo agregar compatibilidad con Android Auto
      • Cómo agregar compatibilidad con el SO Android Automotive
    • Compilación de apps de video para el SO Android Automotive
    • Cómo probar apps de Android para vehículos
    • Distribuye apps para Android en vehículos
    • Servicios de Google Play para vehículos
    • Notificaciones en el SO Android Automotive
  • Dispositivos ChromeOS
    • Descripción general
    • Cómo crear apps para ChromeOS
    • Cómo optimizar apps para ChromeOS
    • Cómo preparar tu entorno de desarrollo
    • Compatibilidad con manifiestos de apps para Chromebooks
    • Compatibilidad de dispositivos con ChromeOS
    • Diferencias en el renderización de apps en Chromebooks
    • Administración de ventanas
    • Cómo adaptar juegos para ChromeOS
    • Animación fluida en ChromeOS
    • Casos de prueba de apps para Android en ChromeOS
  • Android (edición Go)
    • Descripción general
    • Desarrollo para Android (edición Go)
    • Cómo probar apps para Android Go
    • Optimiza para Android (edición Go)
      • Enfoque
      • Cómo optimizar la memoria de la app
      • Cómo mejorar la latencia de inicio
      • Cómo reducir el tamaño de la app
    • Prácticas recomendadas
  • Arquitectura de la app
  • Introducción
  • Guía de arquitectura de apps
    • Descripción general
    • Capa de la IU
      • Descripción general
      • Eventos de la IU
      • Contenedores de estado y estado de la IU
      • Producción de estado
    • Capa de dominio
    • Capa de datos
      • Descripción general
      • Primero sin conexión
    • Recomendaciones de arquitectura
    • Ruta de aprendizaje
  • Modularización
    • Descripción general
    • Patrones comunes
    • Recetas
      • Navegación
  • Componentes de la arquitectura
    • Bibliotecas de capas de IU
      • Vinculación de vista
        • Descripción general
        • Cómo migrar de sintéticos de Kotlin para ver los enlaces
      • Biblioteca de vinculación de datos
        • Descripción general
        • Primeros pasos
        • Diseños y expresiones vinculantes
        • Cómo trabajar con objetos de datos observables
        • Clases de vinculación generadas
        • Adaptadores de vinculación
        • Cómo vincular vistas de diseño con componentes de arquitectura
        • Vinculación de datos en dos direcciones
      • Componentes optimizados para ciclos de vida
        • Cómo controlar ciclos de vida
        • ViewModel
          • Descripción general de ViewModel
          • Cómo crear ViewModels con dependencias
          • APIs de alcance de ViewModel
          • Módulo de estado guardado para ViewModel
        • LiveData
        • Cómo guardar estados de la IU
        • Cómo usar las corrutinas de Kotlin con componentes optimizados para ciclos de vida
      • Biblioteca de Paging
        • Descripción general
        • Cómo cargar y mostrar datos paginados
        • Página de la red y la base de datos
        • Cómo transformar transmisiones de datos
        • Cómo administrar y presentar estados de carga
        • Cómo probar tu implementación de Paging
        • Cómo migrar a Paging 3
        • Paging 2
          • Descripción general
          • Cómo visualizar listas paginadas
          • Cómo cargar datos paginados
    • Bibliotecas de capas de datos
      • DataStore
      • WorkManager
        • Descripción general
        • Cómo comenzar
        • Guías prácticas
          • Cómo definir tus WorkRequests
          • Estados de trabajos
          • Cómo administrar trabajos
          • Cómo observar el progreso intermedio de un trabajador
          • Cómo concatenar el trabajo
          • Cómo probar una implementación de trabajadores
          • Pruebas de integración con WorkManager
          • Cómo depurar WorkManager
        • Conceptos avanzados
          • Inicialización y configuración
          • Cómo ejecutar subprocesos en WorkManager
            • Descripción general
            • Cómo ejecutar subprocesos en Worker
            • Cómo ejecutar subprocesos en CoroutineWorker
            • Cómo ejecutar subprocesos en RxWorker
            • Cómo ejecutar subprocesos en ListenableWorker
          • Asistencia para trabajadores de larga ejecución
        • Cómo migrar desde Firebase JobDispatcher
        • Cómo migrar desde GCMNetworkManager
  • Puntos de entrada de la app
    • Actividades
      • Introducción a las actividades
      • Ciclo de vida de la actividad
      • Cambios en el estado de la actividad
      • Cómo probar las actividades de tu app
      • Tareas y la pila de actividades
      • Procesos y el ciclo de vida de la app
      • Objetos parcelables y paquetes
      • Cargadores
      • Pantalla de Recientes
      • Restricciones sobre el inicio de actividades en segundo plano
    • Accesos directos a aplicaciones
      • Descripción general
      • Cómo crear accesos directos
      • Cómo agregar funciones
      • Cómo administrar accesos directos
      • Prácticas recomendadas para accesos directos
  • Navegación en la app
    • Principios de navegación
    • Cómo diseñar para diferentes factores de forma
    • Cómo administrar los cambios en la configuración
    • Componente Navigation
      • Descripción general
      • Cómo comenzar
      • Cómo crear destinos
      • Cómo diseñar gráficos de navegación
      • Gráficos anidados
      • Acciones generales
      • Cómo navegar a un destino
      • Cómo brindar compatibilidad con varias pilas de actividades
      • Navegación condicional
      • Cómo pasar datos entre destinos
      • Cómo crear un vínculo directo para un destino
      • Cómo animar las transiciones entre destinos
      • Cómo actualizar los componentes de IU con NavigationUI
      • DSL de Kotlin
      • Navegación de seguridad de tipos con Compose
      • Cómo interactuar de manera programática
      • Cómo navegar con módulos de funciones
      • Prácticas recomendadas para proyectos con varios módulos
      • Cómo probar la navegación
      • Cómo agregar nuevos tipos de destinos
      • Cómo migrar al componente Navigation
    • Fragmentos
      • Descripción general
      • Cómo crear un fragmento
      • Administrador de fragmentos
      • Transacciones de fragmentos
      • Cómo animar transiciones entre fragmentos
      • Ciclo de vida de los fragmentos
      • Cómo guardar un estado con fragmentos
      • Cómo comunicarse con fragmentos
      • Cómo trabajar con la barra de la app
      • Cómo mostrar diálogos con DialogFragment
      • Cómo depurar fragmentos
      • Cómo probar tus fragmentos
    • Vínculos de apps
      • Descripción general
      • Cómo habilitar vínculos al contenido de la app
      • Cómo verificar los vínculos de la app
      • Cómo crear vínculos de apps para apps instantáneas
    • Cómo crear vistas deslizantes con pestañas mediante ViewPager
    • Cómo crear vistas deslizantes con pestañas mediante ViewPager2
    • Cómo agregar compatibilidad con la navegación hacia atrás
      • Navegación hacia atrás personalizada
      • Gesto de retroceso predictivo
  • Inserción de dependencias
    • Descripción general
    • Inserción manual de dependencias
    • Inserción de dependencias con Hilt
    • Hilt en apps con varios módulos
    • Cómo usar Hilt con otras bibliotecas de Jetpack
    • Guía de prueba de Hilt
    • Hoja de referencia de anotaciones de Hilt y Dagger
    • Dagger
      • Conceptos básicos de Dagger
      • Cómo usar Dagger en apps para Android
      • Cómo usar Dagger en apps de varios módulos
  • Inicio de apps
  • Interfaces de usuario
  • Cómo compilar interfaces de usuario de Android
  • Cómo crear IU retrocompatibles
    • Descripción general
    • Cómo abstraer las nuevas APIs
    • Cómo crear conexiones proxy con las APIs nuevas
    • Cómo crear una implementación con APIs anteriores
    • Cómo usar componentes de compatibilidad de versiones
  • Temas principales
  • Compatibilidad con apps
    • Descripción general
    • Herramientas de marco de compatibilidad
    • Restricciones en interfaces que no pertenecen al SDK
  • Cómo interactuar con otras apps
    • Descripción general
    • Cómo enviar al usuario a otra app
    • Cómo obtener un resultado de una actividad
    • Cómo permitir que otras apps inicien tu actividad
    • Visibilidad del paquete
      • Descripción general
      • Cómo saber qué paquetes son visibles automáticamente
      • Cómo declarar necesidades de visibilidad de paquetes
      • Cómo entregar casos de uso habituales
      • Cómo probar la visibilidad del paquete
  • Intents y filtros de intents
    • Descripción general
    • Intents comunes
  • Audio y video
    • Descripción general de audio y video
    • Reproducción de video HDR
    • Media3
      • Descripción general
      • Cómo comenzar
        • Cómo usar una sesión multimedia para administrar la reproducción
        • Cómo reproducir contenido multimedia en segundo plano
      • ExoPlayer
        • ExoPlayer y Media3
        • Asignaciones de ExoPlayer a Media3
      • Guía de migración
    • Controles multimedia
    • Formatos multimedia compatibles
    • Códecs de archivos multimedia
    • Arquitectura de apps multimedia
      • Descripción general de la arquitectura de apps multimedia
      • Cómo usar sesiones multimedia
      • Cómo crear una app de audio
        • Descripción general de las apps de audio
        • Cómo crear servicios para el navegador multimedia
        • Cómo crear actividad de clientes para el navegador multimedia
        • Devoluciones de llamadas de sesiones multimedia
        • Cómo usar la app de prueba del control multimedia
      • Cómo crear una app de video
        • Descripción general de las apps de video
        • Cómo crear una actividad del reproductor de video
        • Devoluciones de llamadas de sesiones multimedia
        • Transcodificación de contenido multimedia compatible
      • Cómo responder a los botones multimedia
      • Cómo controlar cambios en la salida de audio
      • Cómo administrar el foco de audio
    • Asistente de Google
      • Apps multimedia y de Asistente de Google
      • Apps de contenido multimedia en el modo en automóvil de Asistente de Google
    • Enrutamiento entre dispositivos
      • Descripción general del enrutamiento
      • Descripción general de MediaRouter
      • Descripción general de MediaRouteProvider
    • Audio espacial
    • Cómo controlar la amplitud con VolumeShaper
    • Descripción general de MediaPlayer
    • Descripción general de MediaRecorder
    • ExoPlayer
    • Cómo compartir entradas de audio
    • Cómo capturar la reproducción de audio y video
    • Velocidad de fotogramas
    • Prácticas recomendadas para compartir video
    • Recursos adicionales para contenido multimedia
  • Servicios
    • Descripción general
    • Servicios en primer plano
    • Servicios vinculados
    • Descripción general de AIDL
  • Tareas en segundo plano
    • Descripción general
    • Subprocesos en segundo plano
    • Optimizaciones en segundo plano
    • Transmisiones
      • Descripción general
      • Excepciones de transmisiones implícitas
    • Cómo administrar el estado activo del dispositivo
      • Descripción general
      • Cómo mantener activo el dispositivo
      • Cómo programar alarmas
    • Cómo usar un objeto ListenableFuture
  • Permisos
    • Descripción general
    • Cómo evaluar si tu app necesita permisos
    • Cómo declarar permisos de la app
    • Cómo solicitar permisos de la app
    • Cómo explicar el acceso a información más sensible
    • Prácticas recomendadas de permisos de la app
    • Permisos que solo se usan en controladores predeterminados
    • Restringe las interacciones con otras apps
    • Cómo definir permisos personalizados
  • Archivos y datos de la app
    • Descripción general
    • Descripción general del almacenamiento
    • Cómo guardar contenido en el almacenamiento específico de la app
    • Cómo guardar contenido en el almacenamiento compartido
      • Descripción general
      • Multimedia
      • Selector de fotos
      • Documentos y otros archivos
      • Conjuntos de datos
    • Cómo administrar todos los archivos de un dispositivo de almacenamiento
    • Cómo guardar datos de pares clave-valor
    • Cómo guardar contenido en una base de datos local
      • Descripción general
      • Cómo definir datos mediante entidades
      • Cómo acceder a datos mediante DAO
      • Cómo definir relaciones entre objetos
      • Escribe consultas DAO asíncronas
      • Cómo implementar vistas en una base de datos
      • Cómo autocompletar el contenido de tu base de datos
      • Cómo migrar tu base de datos
      • Cómo probar y depurar tu base de datos
      • Cómo hacer referencia a datos complejos
      • Cómo migrar de SQLite a Room
      • Cómo guardar datos con SQLite
    • Prácticas recomendadas y casos prácticos de almacenamiento
    • Cómo compartir datos simples
      • Descripción general
      • Cómo enviar datos simples a otras apps
      • Cómo recibir datos simples de otras apps
    • Cómo compartir archivos
      • Descripción general
      • Cómo configurar el uso compartido de archivos
      • Cómo compartir un archivo
      • Cómo solicitar un archivo compartido
      • Cómo recuperar información de archivos
    • Cómo compartir archivos con NFC
      • Descripción general
      • Cómo enviar archivos a otro dispositivo
      • Cómo recibir archivos de otro dispositivo
    • Cómo imprimir archivos
      • Descripción general
      • Cómo imprimir fotos
      • Cómo imprimir documentos HTML
      • Cómo imprimir documentos personalizados
    • Proveedores de contenido
      • Descripción general
      • Conceptos básicos sobre proveedores de contenido
      • Cómo crear un proveedor de contenido
      • Cómo abrir archivos con el marco de trabajo de acceso al almacenamiento
      • Cómo crear un proveedor de documentos personalizado
    • Ubicación de la instalación de la app
  • Identidad y datos del usuario
    • Descripción general
    • Cómo agregar un flujo de trabajo de acceso
    • Cómo mostrar un diálogo de autenticación biométrica
    • Autofill Framework
      • Descripción general
      • Cómo optimizar tu app para el autocompletado
      • Cómo crear servicios de autocompletado
      • Cómo integrar el autocompletado con teclados
    • Cómo identificar apps que son propiedad de los desarrolladores
    • Consulta cómo tu app recopila y comparte los datos de los usuarios
    • Cómo auditar el acceso a datos
    • Cómo obtener un ID de publicidad que el usuario puede restablecer
    • Descripción general del proveedor de calendario
    • Proveedor de contactos
      • Descripción general
      • Cómo recuperar una lista de contactos
      • Cómo recuperar los detalles de un contacto
      • Cómo modificar contactos con intents
      • Cómo mostrar la insignia de Contacto rápido
    • Transferencia de cuentas
    • Copia de seguridad de datos
      • Descripción general
      • Cómo crear una copia de seguridad de los datos del usuario
      • Cómo crear copias de seguridad de pares clave-valor
      • Cómo probar copias de seguridad y restablecimiento
    • Prácticas recomendadas para identificadores únicos
    • Cómo recordar y autenticar usuarios
      • Descripción general
      • Cómo recordar a tus usuarios
      • Autenticación en servicios OAuth2
      • Cómo crear un tipo de cuenta personalizado
  • Ubicación del usuario
    • Descripción general
    • Cómo solicitar permisos de ubicación
    • Cómo obtener la última ubicación conocida
    • Cómo cambiar la configuración de la ubicación
    • Cómo solicitar actualizaciones de ubicación
    • Cómo acceder a la ubicación en segundo plano
    • Cómo crear y supervisar el geovallado
    • Cómo detectar cuándo un usuario inicia una actividad
    • Cómo optimizar la ubicación para ahorrar batería
    • Cómo probar los flujos de trabajo de ubicación
    • Cómo migrar a APIs de ubicación y contexto
    • Cómo agregar mapas
  • Cámara
    • Elige una biblioteca de cámaras
    • Intents de cámara
    • Extensiones de la cámara
      • Descripción general
      • Dispositivos compatibles
    • CameraX
      • Descripción general
      • Arquitectura
      • Configuración
      • Casos de uso
        • Vista previa
        • Captura de imágenes
        • Análisis de imágenes
        • Captura de video
      • Temas avanzados
        • API de Extensions
        • Analizador de ML Kit
        • Rotaciones
        • Resultado de la transformación
      • Dispositivos
    • Camera2
      • Descripción general
      • Solicitudes y sesiones de capturas de la cámara
      • Capacidades y lentes de cámara
      • Cómo usar varias transmisiones de cámara a la vez
      • Vista previa de cámara
      • Captura de video HDR
      • API de Multi-Camera
      • API de Extensions
    • Cámara (obsoleta)
      • Descripción general
      • Cómo tomar fotos
      • Cómo grabar videos
      • Cómo controlar la cámara
      • API de Camera
  • Sensores
    • Descripción general
    • Información general de sensores
    • Sensores de movimiento
    • Sensores de posición
    • Sensores de entorno
    • Dimensiones GNSS sin procesar
  • Conectividad
    • Descripción general
    • SDK multidispositivo
      • Descripción general
      • Primeros pasos
      • API de detección de dispositivos
      • API de conexión segura
      • API de sesiones
      • Cómo probar y depurar
      • Referencia de la API
    • Cómo llevar a cabo operaciones de red
      • Descripción general
      • Cómo conectarse a la red
      • Cómo administrar el uso de la red
      • Cómo leer el estado de la red
      • Cómo optimizar el acceso a la red
      • Cómo optimizar el uso de datos de red
      • Cómo supervisar el estado de conectividad y la medición de la conexión
      • Cómo analizar datos XML
    • Cómo realizar operaciones de red con Cronet
      • Descripción general
      • Cómo enviar una solicitud simple
      • Ciclo de vida de solicitud de Cronet
      • Cómo usar Cronet con otras bibliotecas
      • Referencia
        • org.chromium.net
          • Descripción general
          • CallbackException
          • CronetEngine
            • Descripción general
            • CronetEngine.Builder
              • Descripción general
              • LibraryLoader
          • CronetException
          • InlineExecutionProhibitedException
          • NetworkException
          • QuicException
          • UploadDataProvider
          • UploadDataProviders
          • UploadDataSink
          • URLRequest
            • Descripción general
            • Builder
            • Callback
            • Status
            • StatusListener
          • UrlResponseInfo
        • org.chromium.net.apihelpers
          • Descripción general
          • ByteArrayCronetCallback
          • CronetRequestCompletionListener
          • CronetResponse
          • ImplicitFlowControlCallback
          • InMemoryTransformCronetCallback
          • JsonCronetCallback
          • RedirectHandler
          • RedirectHandlers
          • StringCronetCallback
          • UploadDataProviders
          • UrlRequestCallbacks
            • Descripción general
            • CallbackAndResponseFuturePair
    • Mejora tus apps con 5G
    • Cómo crear aplicaciones cliente-servidor con gRPC
    • Cómo transferir datos sin consumir la batería
      • Descripción general
      • Cómo optimizar las descargas para lograr un acceso de red eficiente
      • Cómo minimizar el efecto de las actualizaciones regulares
      • Cómo evitar las descargas no optimizadas
    • Cómo reducir el consumo de batería de la red
      • Descripción general
      • Cómo recopilar datos del tráfico de red
      • Cómo analizar el tráfico de datos
      • Cómo optimizar el acceso a la red
      • Cómo optimizar el uso de red iniciado por el usuario
      • Cómo optimizar el uso de red iniciado por la app
      • Cómo optimizar el uso de red iniciado por el servidor
      • Cómo optimizar el uso general de redes
    • Cómo transferir datos mediante adaptadores de sincronización
      • Descripción general
      • Cómo crear un autenticador auxiliar
      • Cómo crear un proveedor de contenido auxiliar
      • Cómo crear un adaptador de sincronización
      • Cómo ejecutar un adaptador de sincronización
    • Bluetooth
      • Descripción general
      • Configurar Bluetooth
      • Cómo buscar dispositivos Bluetooth
      • Cómo conectar dispositivos Bluetooth compatibles
      • Cómo transferir datos por Bluetooth
      • Permisos de Bluetooth
      • Perfiles de Bluetooth
      • Sincronización de dispositivos complementarios
    • Bluetooth de bajo consumo
      • Descripción general
      • Buscar dispositivos BLE
      • Conectarse con un servidor GATT
      • Cómo transferir datos de BLE
    • Audio BLE
      • Descripción general
      • Llamadas autoadministradas del Administrador de audio
      • Llamadas administradas de la API de Telecom
      • Grabación de audio
    • NFC
      • Descripción general
      • Conceptos básicos de NFC
      • NFC avanzadas
      • Descripción general de la emulación de tarjetas basadas en el host
    • Telecomunicaciones
      • Descripción general
      • Cómo crear una app de llamadas
      • Cómo evitar la falsificación de identidad del identificador de llamada
      • ID de telefonía
    • Wi-Fi
      • Cómo solicitar permiso para acceder a dispositivos Wi-Fi cercanos
      • Descripción general de la búsqueda de Wi-Fi
      • Wi-Fi entre pares
      • Descripción general del reconocimiento de Wi-Fi
      • Ubicación de Wi-Fi con RTT
      • Hotspot solo local
      • Detección y conexión
        • Descripción general
        • Cómo usar la detección del servicio de red
        • Cómo crear conexiones P2P con Wi-Fi directo
        • Cómo usar Wi-Fi directo para detectar servicios
        • Easy Connect para Wi-Fi
      • Infraestructura de Wi-Fi
        • Descripción general de la infraestructura de Wi-Fi
        • API de sugerencia de Wi-Fi para la conexión a Internet
        • API de solicitud de red Wi-Fi para la conectividad entre pares
        • Passpoint
        • Cómo guardar redes y configuraciones de Passpoint
    • USB
      • Descripción general
      • Descripción general de los accesorios
      • Descripción general del host
    • UWB
    • VPN
    • Descripción general del protocolo de inicio de sesión
    • Compatibilidad con el lector de la API de Open Mobile
  • RenderScript
    • Descripción general
    • RenderScript avanzado
    • Cómo migrar desde RenderScript
    • Referencia de la API en tiempo de ejecución
      • Descripción general
      • Tipos numéricos
      • Tipos de objetos
      • Funciones de conversión
      • Funciones y constantes matemáticas
      • Funciones matemáticas de vector
      • Funciones de matriz
      • Funciones de cuaternión
      • Funciones de actualizaciones atómicas
      • Tipos y funciones de tiempo
      • Funciones de acceso a datos de asignación
      • Funciones de características de objetos
      • Tipos y funciones de invocación de kernel
      • Funciones de entrada y salida
      • Funciones de depuración
      • Tipos y funciones de gráficos
      • Índice
  • Contenido basado en la Web
    • Descripción general
    • Creación de aplicaciones web en WebView
    • Cómo administrar objetos WebView
    • Cómo cargar contenido local
    • Cómo oscurecer contenido web
    • Privacidad del usuario en los informes de WebView
    • Compatibilidad con diferentes pantallas en apps web
    • Depuración de aplicaciones web
    • Prácticas recomendadas para aplicaciones web
    • Cómo probar versiones futuras de WebView
  • Paquetes Android App Bundle
    • Descripción general
    • Cómo configurar el módulo base
    • Cómo compilar y probar tu paquete de aplicación
    • Cómo agregar transparencia de código
    • Formato del paquete de aplicación
    • Preguntas frecuentes
  • Google Play
    • Facturación Google Play
    • Bibliotecas de Google Play Core
    • Play Points
      • Descripción general
      • Crea productos y promociones
      • Detecta y entrega productos
      • Productos de prueba
    • Play Asset Delivery
      • Descripción general
      • Cómo integrar Asset Delivery (Kotlin y Java)
      • Cómo integrar Asset Delivery (nativo)
      • Cómo integrar Asset Delivery (Unity)
      • Cómo seleccionar los objetivos para los formatos de compresión de texturas
      • Cómo probar la entrega de recursos
    • Entrega de funciones en Play
      • Descripción general
      • Cómo configurar la entrega durante la instalación
      • Cómo configurar la entrega condicional
      • Cómo configurar la entrega a pedido
      • Prácticas recomendadas de la entrega on demand
      • Cómo configurar la entrega instantánea
      • Recursos adicionales
    • Opiniones integradas en la app
      • Descripción general
      • Cómo realizar la integración con Kotlin o Java
      • Cómo realizar la integración con código nativo
      • Cómo realizar la integración con Unity
      • Cómo probar las opiniones integradas en la app
    • Actualizaciones integradas en la app
      • Descripción general
      • Compatibilidad con las actualizaciones integradas en la app (Kotlin o Java)
      • Compatibilidad con actualizaciones de la app (nativas)
      • Compatibilidad con actualizaciones dentro de la app (Unity)
      • Cómo probar las actualizaciones integradas en la app
    • Google Play Instant
      • Descripción general de Google Play Instant
      • Cómo comenzar a usar las apps instantáneas
        • Cómo crear un paquete de aplicación instantánea
        • Recomendaciones de UX para apps
      • Cómo comenzar a crear juegos instantáneos
        • Descripción general
        • Complemento para Unity
        • Prácticas recomendadas de UX para juegos
        • Cómo migrar a paquetes Android App Bundle
        • Cómo implementar la entrega de recursos en la nube
        • Compatibilidad con los Servicios de juego de Google Play
        • Juegos instantáneos de Play
        • Lista de tareas de juegos instantáneos de Play
      • Cómo reducir el tamaño de tu app o juego instantáneo
      • Cómo agregar anuncios en tu app o juego instantáneo
      • Cómo brindar varios puntos de entrada
      • Cómo realizar la integración con Firebase
        • Cómo agregar Google Analytics para Firebase a tu app instantánea
        • Cómo usar Firebase Dynamic Links con apps instantáneas
      • Lista de verificación de requisitos técnicos
      • Política de Google Play Instant
      • Recursos
        • Referencia
        • Muestras de código
        • Notas de la versión del SDK
        • Intents de Apps instantáneas
      • Asistencia
        • Errores conocidos
        • StackOverflow
    • APIs de Play Developer
    • Referente de instalación de Play
      • Descripción general
      • Biblioteca de referencia de instalación de Play
        • Descripción general
        • Referencia
        • Notas de la versión
      • API de Play Install Referrer
    • API de Play Integrity
    • Requisitos de Play
      • Políticas de Play
      • Nivel de API objetivo
      • Compatibilidad con arquitecturas de 64 bits
    • Servicio de licencias para aplicaciones
      • Descripción general
      • Descripción general sobre las licencias
      • Cómo realizar la configuración para licencias
      • Cómo agregar la verificación del servidor
      • Cómo agregar la verificación del cliente
      • Referencia sobre licencias
    • Archivos de expansión de APK
    • Actualizaciones de apps
  • Asistente de Google
    • Descripción general
    • Compilación
      • Descripción general de Acciones en apps
      • Cómo implementar intents integrados
      • Cómo crear shortcuts.xml
      • Cómo enviar accesos directos dinámicos al Asistente
      • Notas de la versión
    • Prueba
      • Complemento de Asistente de Google
    • Crecimiento
      • Descripción general
      • SDK de promoción de acceso directo en la app
    • Cómo agregar más funciones
      • Intents personalizados
      • Widgets de Android
      • Invocación de apps en primer plano
      • Inventario intercalado
      • Inventario web
      • Uso compartido de Asistente
      • Leer
    • Actions.xml
      • Guía de migración de actions.xml
      • Descripción general de actions.xml
      • Cómo crear Acciones en apps
      • Cómo crear actions.xml
      • Inventario web
      • Herramienta de prueba de Acciones en apps
      • Android Slices
      • Solución de problemas
    • Asistencia
  • Búsqueda en el dispositivo
  • Juegos
  • Diseño
    • Descripción general
    • Compatibilidad con dispositivos de juego
      • Arquitecturas de 64 bits
      • Tipos de pantalla
      • Rotación previa de Vulkan
    • Diseño de elementos 3D
    • Administración de datos de Vertex
  • Implementación
    • Descripción general
    • Cómo usar un motor de juego
      • Descripción general
      • Cómo desarrollar con Defold
        • Cómo instalar y configurar proyectos para Android
        • Compatibilidad con varios factores de forma y tamaños de pantalla
        • Cómo exportar a Android
      • Cómo desarrollar con Godot
        • Cómo instalar y configurar proyectos para Android
        • Opciones de renderización de Godot
        • Compatibilidad con varios factores de forma y tamaños de pantalla
        • Cómo exportar a Android
      • Cómo desarrollar con Unity
        • Descripción general
        • Cómo crear un Android App Bundle con Unity
        • Cómo integrar Play Asset Delivery
        • Iluminación de Unity en juegos para dispositivos móviles
        • Cómo usar Android Performance Tuner
          • Descripción general
          • Cómo habilitar la API
          • Cómo integrar el complemento
          • Cómo inicializar la biblioteca y verificar la operación
          • Cómo definir anotaciones, parámetros de fidelidad y niveles de calidad
          • Cómo agregar funciones de grabación durante el tiempo de carga
          • Cómo incluir escenas Addressable
          • Cómo ejecutar la app de supervisión
          • Revisar y publicar
          • Cómo solucionar los problemas comunes
          • Referencia
        • Simboliza las fallas de Android y ANR para los juegos de Unity
        • Cómo comenzar a usar la API de Memory Advice para juegos de Unity
      • Cómo desarrollar con Unreal
      • Cómo solicitar permisos de usuario
      • Cómo proteger tu juego
    • Cómo crear o extender un motor de juego
      • Descripción general
      • Cómo comenzar
        • Cómo integrar GameActivity
          • Descripción general
          • Primeros pasos
          • Cómo usar game text input
          • Cómo migrar desde NativeActiviy
        • Cómo configurar gráficos
        • Cómo entender los bucles de juego de Android
      • Cómo procesar eventos de entrada
        • Cómo agregar compatibilidad táctil
        • Cómo admitir entradas de texto
        • Cómo brindar compatibilidad con controles de juegos
          • Descripción general
          • Cómo usar la biblioteca de controles para juegos
          • Cómo usar asignaciones de dispositivos de control personalizados
        • Cómo agregar compatibilidad con un mouse
        • Cómo admitir la entrada del sensor
      • Logra una alternación de fotogramas correcta
        • Descripción general
        • Ritmo de fotogramas en OpenGL ES
          • Cómo integrar
          • Cómo actualizar tu configuración de compilación
          • Cómo agregar funciones de ritmo de fotogramas
          • Cómo verificar la mejora del ritmo de fotogramas
        • Ritmo de fotogramas en Vulkan
          • Cómo integrar
          • Cómo actualizar tu configuración de compilación
          • Cómo agregar funciones de ritmo de fotogramas
          • Cómo verificar la mejora del ritmo de fotogramas
        • Referencia
      • Integra Android Performance Tuner
        • Descripción general
        • Cómo ejecutar la app de demostración
        • Cómo habilitar la API
        • Cómo actualizar tu configuración de compilación
        • Cómo definir anotaciones, parámetros de fidelidad y opciones de configuración
        • Cómo agregar funciones de latencia de fotogramas
        • Cómo agregar funciones de grabación durante el tiempo de carga
        • Cómo validar, empaquetar y publicar el APK
        • Cómo solucionar los problemas comunes
        • Uso avanzado
        • Referencia
      • Audio de salida
        • Descripción general
        • Cómo actualizar la configuración de compilación
        • Cómo usar Oboe
        • Muestras de código
        • Guía completa de Oboe
      • Cómo administrar la memoria
        • Descripción general
        • Cómo depurar el uso de la memoria nativa
      • Cómo enviar elementos
      • Cómo detectar y diagnosticar fallas
    • Android Game Development Kit (AGDK)
      • Descripción general
      • Descarga
      • Notas de la versión
    • Android Game Development Extension para Visual Studio
      • Descripción general
      • Guía de inicio rápido
      • Cómo configurar un proyecto
      • Depurador
      • Cómo medir el rendimiento de la app
      • Cómo modificar archivos build.gradle para Android Studio
      • Ejemplos
      • Notas de la versión
    • Tareas de Android Studio
  • Optimización
    • Descripción general
    • Prácticas recomendadas
    • Cómo reducir el tamaño de un juego
    • Inspector de GPU para Android
      • Descripción general
      • Guía de inicio rápido
      • Dispositivos compatibles
      • Generación de perfiles del sistema
        • Descripción general
        • Cómo ver un perfil del sistema
        • Contadores de rendimiento de GPU
        • Cómo analizar un perfil del sistema
          • Períodos de procesamiento de fotogramas
          • Eficiencia de la memoria
          • Uso de ancho de banda de memoria de textura
          • Uso de ancho de banda de memoria de Vertex
          • Programación de subprocesos
      • Generación de perfiles
        • Descripción general
        • Cómo analizar un perfil de fotogramas
          • Pases de renderización más costosos
          • Formatos de Vertex
          • Rendimiento de sombreadores
        • IU del generador de perfiles
          • Panel de rendimiento
          • Panel de comandos
          • Panel del búfer de fotogramas
          • Panel de geometría
          • Panel del informe
          • Panel del sombreador
          • Panel de memoria
          • Panel de estado
          • Panel de texturas
          • Panel de textura
          • Panel de vista de canalizaciones
      • Extensiones de Vulkan compatibles
      • Soluciona problemas
    • Android Performance Tuner
    • Administra el rendimiento térmico y de CPU
    • API de Memory Advice
      • Descripción general
      • Primeros pasos
    • Game Mode
      • Descripción general
      • Cómo optimizar con la API de Game Mode
      • Intervenciones de modo de juego
  • Entrega
    • Descripción general
    • Servicios de juego de Google Play
      • Descripción general
      • Primeros pasos
      • Descargas
      • Configura Play Console
        • Configura los Servicios de juego de Play
        • Habilitar funciones
        • Administración de proyectos de Cloud
        • Lleva a cabo la publicación
      • Cómo administrar funciones
        • Acceso
        • Logros
        • Tablas de clasificación
        • Eventos
        • Juegos guardados
        • Amigos
      • Cómo usar las APIs
        • C y C++
        • Unity
          • Descripción general
          • Primeros pasos
          • Cómo agregar elementos
            • Logros
            • Tablas de clasificación
            • Juegos guardados
            • Eventos
            • Amigos
            • Estadísticas del jugador
        • Java
          • Primeros pasos
          • Acceso
          • Habilitar acceso por parte del servidor
          • Antipiratería
          • Cómo agregar elementos
            • Logros
            • Tablas de clasificación
            • Amigos
            • Juegos guardados
            • Eventos
            • Estadísticas del jugador
          • Solución de problemas
        • API de Publishing
          • Descripción general
          • Primeros pasos
          • Cómo subir imágenes
        • API de Management
      • Requisitos y lineamientos
        • Lista de verificación de calidad
        • Lineamientos de desarrollo de la marca
        • Cuota y límite de frecuencia
        • Requisitos de divulgación de datos
        • Condiciones del Servicio
      • Asistencia
    • Google Play Juegos para PC
      • Descripción general
      • Primeros pasos
      • Lista de tareas para el lanzamiento
      • Configuración
        • Compatibilidad con PC
        • Configuración de gráficos
        • Entrada del dispositivo
          • Configuración de entrada
          • Entrada del mouse
          • SDK de entrada
            • Descripción general
            • Guía de inicio rápido
        • Juego en varios dispositivos
          • Descripción general
          • Requisitos
          • Verificación de requisitos
          • Soluciones de identidad existentes
      • Prueba
        • Cómo probar tu juego
        • Cómo usar el emulador
        • Cómo usar dispositivos ChromeOS
        • Cómo verificar la compatibilidad
      • Cómo publicar e implementar contenido
        • Paquete
        • Enviar
        • Actualizar
        • Protección de la integridad
      • Preguntas frecuentes
    • Cómo jugar durante la descarga
      • Descripción general
      • Prácticas recomendadas
  • Apps de salud y fitness
  • Health Connect
    • Introducción
    • Descripción general de la plataforma
      • Arquitectura
      • Funcionalidad del desarrollador
    • Primeros pasos
    • Datos y tipos de datos
      • Introducción
      • Tipos de datos
      • API de Differential Changes
    • Flujos de trabajo comunes
      • Cómo escribir datos
      • Cómo leer datos
      • Cómo borrar datos
      • Datos agregados
      • Cómo trabajar con sesiones
      • Excepciones
    • Prácticas recomendadas
    • Preguntas frecuentes
  • Lineamientos de Health Connect
    • Orientación para desarrolladores de UX
    • Migración
      • Guía de comparación de la API de Health Connect
      • Guía de migración de la API de Fit de Android a Health Connect
  • Prácticas recomendadas
  • Prueba
    • Cómo probar apps en Android
    • Aspectos básicos
      • Aspectos básicos de las pruebas de apps para Android
      • Qué probar en Android
      • Cómo usar pruebas dobles en Android
    • Pruebas locales
      • Cómo compilar pruebas locales
    • Pruebas instrumentadas
      • Cómo compilar pruebas instrumentadas
      • Cómo automatizar las pruebas de IU
      • Bibliotecas de prueba de AndroidX
        • Cómo configurar el proyecto para AndroidX Test
        • Reglas de JUnit4 con AndroidX Test
        • AndroidJUnitRunner
    • Espresso
      • Espresso
      • Conceptos básicos de Espresso
      • Instrucciones de configuración de Espresso
      • Hoja de referencia de Espresso
      • Recursos inactivos de Espresso
      • Espresso-Intents
      • Listas de Espresso
      • Multiprocess Espresso
      • Recetas de Espresso
      • Espresso Web
      • Comprobación de accesibilidad
      • Recursos adicionales de Espresso
    • Cómo probar otros componentes
      • Cómo probar proveedores de contenido
      • Cómo probar tu servicio
      • Cómo escribir pruebas automatizadas con UI Automator
  • Rendimiento
    • Descripción general
    • Cómo inspeccionar el rendimiento
      • Descripción general
      • Generadores de perfiles de Android Studio
      • Generación de perfiles y registros
        • Registro del sistema
          • Descripción general
          • Cómo capturar un registro
            • Cómo capturar un registro en Android Studio
            • Cómo capturar un registro en un dispositivo
            • Cómo capturar un registro de la línea de comandos
          • Cómo navegar por un informe
          • Eventos personalizados
            • Cómo definir eventos personalizados
            • Eventos de seguimiento personalizados en código nativo
        • Cómo inspeccionar la renderización de GPU
      • Comparativas
        • Descripción general
        • Macrocomparativas
          • Cómo escribir una comparativa
          • Cómo capturar las métricas
          • Cómo controlar tu app
          • Cómo agregar argumentos de instrumentación
        • Microcomparativas
          • Descripción general
          • Cómo escribir una comparativa
          • Cómo crear el perfil de una comparativa
          • Cómo agregar argumentos de instrumentación
          • Cómo compilar sin Gradle
        • Comparativas en CI
      • Cómo medir el rendimiento
        • Descripción general
        • Ejemplos
    • Cómo mejorar el rendimiento
      • Descripción general
      • Perfiles de Baseline
        • Descripción general
        • Cómo crear un perfil de Baseline
        • Cómo realizar mediciones con la biblioteca de Macrobenchmark
        • Crea y mide perfiles de Baseline manualmente
      • Biblioteca de inicio de apps
      • Guías
        • Trabajo en segundo plano
        • Clase de rendimiento
        • Intervalos de App Standby
        • Hibernación de apps
        • Cómo verificar el comportamiento de la app en Android Runtime (ART)
      • Cómo resolver problemas comunes
        • Inicio de apps
        • Renderización
          • Descripción general
          • Cómo reducir la superposición
          • Jerarquías de vista y rendimiento
          • Cómo hacer un análisis con Profile GPU Rendering
          • Renderización lenta
            • Cómo mantener la capacidad de respuesta de tu app
            • Cómo mejorar el rendimiento del diseño
        • Memoria
          • Descripción general de la administración de memoria
          • Asignación de memoria entre propiedades
          • Cómo administrar la memoria de tu app
          • Procesos y subprocesos
        • Batería y alimentación
          • Cómo optimizar tu app para Descanso y App Standby
          • Cómo supervisar el nivel de batería y el estado de carga
          • Cómo supervisar el estado de conectividad y la medición de la conexión
          • Cómo determinar y supervisar el tipo y el estado de conexión
          • Cómo generar perfiles del uso de batería con Batterystats y Battery Historian
          • Cómo analizar el uso de batería con Battery Historian
          • Cómo realizar pruebas en torno a problemas relacionados con la batería
          • Optimizaciones en segundo plano
        • Cómo reducir el tamaño de la app
        • Aceleración de hardware
    • Control del rendimiento
      • Descripción general
      • Android vitals
        • Descripción general
        • ANR
        • Fallas
        • Renderización lenta
        • Fotogramas congelados
        • Bloqueos de activación parciales sostenidos
        • Demasiadas activaciones
        • Búsqueda excesiva de redes Wi-Fi en segundo plano
        • Uso excesivo de redes en segundo plano
        • Denegaciones de permisos
        • Tiempo de inicio de la app
        • Seguimiento de bloqueos
        • Biblioteca de JankStats
  • Accesibilidad
    • Descripción general
    • Cómo crear y probar apps para accesibilidad
      • Cómo mejorar la accesibilidad de las apps
      • Principios para mejorar la accesibilidad de la app
      • Prueba la accesibilidad de tu app
    • Temas avanzados
      • Mejora la accesibilidad de las vistas personalizadas
      • Cómo crear tu propio servicio de accesibilidad
    • Recursos adicionales
  • Privacidad
    • Prácticas recomendadas sobre privacidad
  • Seguridad
    • Recomendaciones sobre seguridad de apps
    • Sugerencias de seguridad
    • Cómo mitigar los riesgos de seguridad en tu app
      • Descripción general
      • Agentes de resolución de contenido
      • Redireccionamiento de intents
      • Recorrido de ruta
      • Intents pendientes
      • Transmisión persistente
      • Inyección de SQL
      • Tapjacking
      • Recorrido de la ruta del archivo ZIP
    • Seguridad con datos
    • Seguridad con HTTPS y SSL
    • Configuración de seguridad de la red
    • Cómo actualizar tu proveedor de seguridad para protegerte contra vulnerabilidades de SSL
    • Protección contra amenazas de seguridad con SafetyNet
      • Descripción general
      • API de SafetyNet Attestation
      • Descontinuación de la certificación de SafetyNet
      • API de Play Integrity
      • API de Navegación segura de SafetyNet
      • API de reCAPTCHA de SafetyNet
      • API de Verificar aplicaciones de SafetyNet
    • Criptografía
    • Sistema Android Keystore
    • Verificación de la copia de seguridad en hardware de pares de claves con certificación de claves
    • Confirmación de protección de Android
    • Cómo brindar compatibilidad con inicio directo
    • Cómo ejecutar código DEX incorporado
    • Programa de mejora de la seguridad de las apps
  • SDK
    • Prácticas recomendadas sobre el SDK
  • Cómo crear contenido para miles de millones
    • Descripción general
    • Conectividad
    • Capacidad del dispositivo
    • Costo de los datos
    • Consumo de la batería
    • IU y contenido
  • Cómo crear contenido para empresas
    • Descripción general
    • Guía para desarrolladores
    • Perfiles de trabajo
    • Cómo establecer configuraciones administradas
    • Comentarios sobre la app
      • Cómo enviar comentarios sobre la app a EMM
      • Cómo probar los comentarios sobre la app
    • Contactos laborales
    • Políticas de administración de dispositivos
    • Administración del dispositivo
      • Descripción general
      • Cómo compilar un controlador de política de dispositivo
      • Dispositivos exclusivos
        • Descripción general
        • Modo de tareas bloqueadas
        • Varios usuarios
        • Guía de soluciones
      • Control de dispositivos
      • Redes y telefonía
      • Seguridad
      • Actualizaciones del sistema
      • Registro de actividad de red
    • Versiones de Android
      • Descripción general
      • Android 13
      • Android 12
      • Android 11
      • Android 10
      • Android 9
      • Android 8.0
      • Android 7.0
    • Administración del dispositivo
  • Desarrolladores de Android
  • Documentos
  • Guías

Sensores

Usa sensores en el dispositivo para agregar funciones de ubicación y movimiento enriquecidas a tu app, desde el GPS o la ubicación de la red hasta el acelerómetro, el giroscopio, la temperatura, el barómetro y más.

Documentación

  • Descripción general de sensores
  • Sensores de movimiento
  • Sensores de posición
  • Sensores del entorno
  • Dimensiones GNSS sin procesar

Videos

El contenido y las muestras de código que aparecen en esta página están sujetas a las licencias que se describen en la Licencia de Contenido. Java y OpenJDK son marcas registradas de Oracle o sus afiliados.

Última actualización: 2019-12-27 (UTC)

  • WeChat WeChat
    Sigue a Google Developers en WeChat
  • Twitter Twitter
    Sigue a @AndroidDev en Twitter
  • YouTube YouTube
    Busca Android Developers en YouTube
  • Más Android

    • Android
    • Enterprise
    • Seguridad
    • Código abierto
  • Asistencia

    • Informar sobre un error en la plataforma
    • Informar sobre un error en la documentación
    • Google Play support
    • Participar en los estudios de investigación
  • Documentación

    • Guías para desarrolladores
    • Guías de diseño
    • Referencia de API
    • Muestras
    • Android Studio
Google Developers
  • Android
  • Chrome
  • Firebase
  • Google Cloud Platform
  • Todos los productos
  • Privacidad
  • Licencia
  • Lineamientos de marca
  • ICP证合字B2-20070004号
  • Recibe noticias y sugerencias por correo electrónico Suscribirse
  • English
  • Bahasa Indonesia
  • Deutsch
  • Español
  • Español – América Latina
  • Français
  • Português – Brasil
  • Tiếng Việt
  • Türkçe
  • Русский
  • ภาษาไทย
  • 中文 – 简体
  • 中文 – 繁體
  • 日本語
  • 한국어