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

Content and code samples on this page are subject to the licenses described in the Content License. Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.

Last updated 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
  • Русский
  • ภาษาไทย
  • 中文 – 简体
  • 中文 – 繁體
  • 日本語
  • 한국어