Contenido del documento
+ ++ El SDK de la versión preliminar de Android M incluye herramientas de desarrollo, archivos de sistema de Android y archivos de biblioteca que lo ayudarán a probar su aplicación y las nuevas API que se incluirán en la próxima versión de la plataforma. + En este documento, se describe la manera de obtener los componentes que se pueden descargar de la versión preliminar para probar su aplicación. + +
+ + +SDK de la versión preliminar
+ ++ El SDK de la versión preliminar se encuentra disponible para descargarlo a través del Administrador de SDK de Android. Para obtener más información sobre cómo descargar y configurar el SDK de la versión preliminar, consulte la sección Configurar el SDK de la versión preliminar. + +
+ + +Documentación para desarrolladores
+ ++ El paquete de descarga de documentación para desarrolladores brinda información detallada de referencia sobre las API y un informe de diferencias de las API para la versión preliminar. +
+ +| Descripción | +Descarga/sumas de comprobación | +
|---|---|
| Versión preliminar de Android M Documentos para desarrolladores |
+ m-preview-1-developer-docs.zip + MD5: b65201b0d35416f5a1b7a071b52854a7 + SHA-1: d47e856aa65e06897e6edd902ad8d2b1f05ac3ec + |
+
| Dispositivo | +Descarga/sumas de comprobación | +
|---|---|
| Nexus 5 (GSM/LTE) "hammerhead" |
+ hammerhead-MPZ44Q-preview-55d76d3a.tgz + MD5: 9e2631b06c6525e401ceaae3677ff320 + SHA-1: 55d76d3a379b18f3363f28d8a462c236ab96fc36 + |
+
| Nexus 6 "shamu" |
+ shamu-MPZ44Q-preview-c1d6506a.tgz + MD5: 307cbf9dab0a38df4ab2639d02be12aa + SHA-1: c1d6506a74094bdb2f4b8677c7fe4967334f9ea8 + |
+
| Nexus 9 "volantis" |
+ volantis-MPZ44Q-preview-d15ad483.tgz + MD5: fae40377fd999d2b09128665c915264d + SHA-1: 7ab05f96093b2cb370b226f65931202714cbc2ca + |
+
| Nexus Player "fugu" |
+ fugu-MPZ44Q-preview-2406ba05.tgz + MD5: 815902141a85cc65e7725f005cad31d5 + SHA-1: 2406ba0598dea1e69110497ac0bc8e16789bc8fb + |
+
Instalar una imagen en un dispositivo
+ ++ Si desea utilizar una imagen del dispositivo para realizar pruebas, debe instalarla en un dispositivo compatible. Siga las instrucciones que se ofrecen a continuación para instalar una imagen del sistema: + +
+ +-
+
- Descargue y descomprima uno de los paquetes de imágenes del sistema que se enumeran aquí. +
- Realice una copia de seguridad de los datos del dispositivo que desee conservar. +
- Siga las instrucciones que se describen en el sitio developers.google.com/android + para actualizar la imagen en su dispositivo. + +
+ Nota: Cuando haya actualizado un dispositivo de desarrollo con la imagen del sistema de la versión preliminar, se actualizará automáticamente con la próxima versión preliminar a través de actualizaciones OTA. + +
+ +Restablecer las especificaciones de fábrica en un dispositivo
+ ++ Si desea desinstalar la versión preliminar y restablecer las especificaciones de fábrica en un dispositivo, visite el sitio developers.google.com/android y descargue la imagen con la que desea actualizar su dispositivo. + + Siga las instrucciones que se describen en esa página para actualizar la imagen en su dispositivo. + +
+ + + + + + + + diff --git a/docs/html-intl/intl/es/preview/features/app-linking.jd b/docs/html-intl/intl/es/preview/features/app-linking.jd new file mode 100644 index 0000000000000..bd635591d3b52 --- /dev/null +++ b/docs/html-intl/intl/es/preview/features/app-linking.jd @@ -0,0 +1,123 @@ +page.title=Vínculos de la aplicación +page.image=images/cards/card-app-linking_2x.png +page.keywords=vínculo de la aplicación, vínculos profundos, intentos +@jd:body + +Contenido del documento
+ ++ El sistema Android Intent es un mecanismo flexible para permitir a las aplicaciones controlar contenido y solicitudes. + Es posible que múltiples aplicaciones declaren modelos URI coincidentes en sus filtros de intento. Cuando un usuario hace clic en un vínculo web que no tiene un controlador de inicio predeterminado, la plataforma puede mostrar un diálogo para que el usuario seleccione una opción de una lista de aplicaciones que han declarado filtros de intento coincidentes. + + +
+ ++ Android M Developer Preview ofrece soporte para los vínculos de la aplicación, lo que mejora los controles de vínculos existentes al permitir a los desarrolladores de la aplicación asociar una aplicación con un dominio web propio. + Cuando los desarrolladores crean esta asociación, la plataforma puede determinar automáticamente la aplicación predeterminada utilizada para controlar un vínculo web particular y omitir el paso de solicitarles esta información a los usuarios. + + +
+ + +Declarar una asociación de sitio web
+ ++ Los propietarios de un sitio web deben declarar las asociaciones con las aplicaciones a fin de establecer el vínculo de una aplicación. El propietario del sitio declara la relación con una aplicación al alojar un archivo JSON, denominado {@code statements.json}, en la ubicación conocida del domino: + + +
+ +http://<domain>:<optional port>/.well-known/statements.json+ +
+ Nota: + Durante el período de M Developer Preview, el archivo JSON se verifica vía el protocolo http. Para la versión oficial de la plataforma, el archivo se verifica mediante el protocolo https cifrado. + +
+ ++ Este archivo JSON indica la aplicación Android que se debe utilizar como el controlador predeterminado para las URL de este dominio. + Identifica la aplicación según estos campos: +
+ +-
+
- {@code package_name}: El nombre de paquete declarado en el manifiesto de la aplicación. + +
- {@code sha256_cert_fingerprints}: La huella dactilar SHA256 del certificado de firma de su aplicación.
+ Puede usar la herramienta Keytool de Java para generar la huella dactilar mediante el siguiente comando:
+
keytool -list -v -keystore my-release-key.keystore
+
+
+ El siguiente listado de archivo muestra un ejemplo de los contenidos y del formato de un archivo +{@code statements.json}: +
+ +
+[{
+ "relation": ["delegate_permission/common.handle_all_urls"],
+ "target": {
+ "namespace": "android_app",
+ "package_name": "<package name>",
+ "sha256_cert_fingerprints": ["6C:EC:C5:0E:34:AE....EB:0C:9B"]
+ }
+}]
+
+
+
+Solicitar verificación del vínculo de la aplicación
+ ++ Una aplicación puede solicitar que la plataforma verifique automáticamente cualquier vínculo de aplicación definido por los nombres de host en los elementos de datos de sus filtros de intento, comparando con los archivos {@code statements.json} alojados en los respectivos dominios web. + + Para solicitar la verificación del vínculo de la aplicación, agregue un atributo {@code android:autoVerify} a cada filtro de intento deseado en el manifiesto, como se muestra en el siguiente fragmento de código de manifiesto: + + +
+ ++<activity ...> + <intent-filter android:autoVerify="true"> + <action android:name="android.intent.action.VIEW" /> + <category android:name="android.intent.category.DEFAULT" /> + <category android:name="android.intent.category.BROWSABLE" /> + <data android:scheme="http" android:host="www.android.com" /> + <data android:scheme="https" android:host="www.android.com" /> + </intent-filter> +</activity> ++ +
+ Cuando el atributo {@code android:autoVerify} está presente en un manifiesto de aplicación, la plataforma intenta verificar los vínculos de la aplicación al instalar la aplicación. + Si la plataforma no puede verificar exitosamente los vínculos de la aplicación, la aplicación no se configura como la aplicación preferida para controlar los vínculos web. + La próxima vez que un usuario abra uno de estos vínculos, la plataforma recurrirá a mostrar al usuario un diálogo. + + +
+ ++ Nota: Durante la prueba, existe la posibilidad de un falso positivo si la verificación falla, pero el usuario ha habilitado explícitamente la aplicación para que abra los vínculos compatibles sin preguntar, utilizando la aplicación de Configuraciones del sistema. En este caso, no se muestra el diálogo y el vínculo se dirige directamente a su aplicación, pero solo debido a la configuración del usuario y no porque la verificación se haya realizado correctamente. + + + +
+ + +Gestionar las configuraciones del vínculo de la aplicación
+ ++ Los usuarios pueden cambiar las configuraciones del vínculo de la aplicación de manera que las URL se controlen como ellos lo prefieran. Puede revisar y gestionar los vínculos de la aplicación en la aplicación de Configuraciones del sistema, en Settings > Apps > App Info > Open by default. + + +
diff --git a/docs/html-intl/intl/es/preview/index.jd b/docs/html-intl/intl/es/preview/index.jd new file mode 100644 index 0000000000000..35b578de157c2 --- /dev/null +++ b/docs/html-intl/intl/es/preview/index.jd @@ -0,0 +1,67 @@ +page.title=Android M Developer Preview +page.tags="preview", +meta.tags="preview, M preview", androidm +fullpage=true +section.landing=true +header.hide=1 +footer.hide=1 +@jd:body + +
+ Android M Developer Preview
++ Prepárese para la próxima versión de Android. Pruebe sus aplicaciones en Nexus 5, 6, 9 y Player. + Explore las novedades en los— permisos de ejecución, las características de ahorro de energía Doze y App Standby, la nueva tecnología de asistencia y mucho más. + + +
+ + + + ¡Empiece hoy mismo! ++
Recursos
+-
+
- + + + Informe los problemas + + +
- + + Únase a la comunidad en G+ + + +
+Para comenzar con la versión preliminar del SDK de Android, debe aceptar los términos y las condiciones que se describen a continuación. +Como se describe a continuación, tenga en cuenta que esta es una versión preliminar del SDK de Android, que está sujeta a cambios y que usted utiliza bajo su cuenta y riesgo. La versión preliminar del SDK de Android no es una versión estable y puede contener errores y defectos que pueden provocar daños graves a sus sistemas informáticos, dispositivos y datos. +
+ ++Este es el Contrato de licencia de la versión preliminar del SDK de Android (el “Contrato de licencia”). +
++ Los siguientes códigos de ejemplo se proporcionan para M Developer Preview. Para descargar los ejemplos en Android Studio, seleccione la opción del menú File > Import Samples. + +
+ ++ Nota: Estos proyectos que se pueden descargar están diseñados para usarlos con Gradle y Android Studio. + +
+ + +Permisos de tiempo de ejecución
+ ++ Android M modifica la manera en que funcionan los permisos del sistema. Los usuarios deben aprobar solicitudes de permiso durante la ejecución, en lugar de durante la instalación. + Este ejemplo muestra cómo solicitar estos permisos. + +
+ + + +Confirmar credencial
+ ++ Este ejemplo muestra cómo usar las credenciales del dispositivo como método de autenticación en su aplicación. +
+ + + +Diálogo de huellas dactilares
+ ++ Este ejemplo muestra cómo reconocer huellas dactilares registradas para autenticar al usuario en su aplicación. + +
+ + + +Copia de seguridad automática para aplicaciones
+ ++ Android M incorpora la copia de seguridad automática para las configuraciones de la aplicación. Este ejemplo muestra cómo agregar reglas de filtrado en una aplicación para administrar la copia de seguridad de las configuraciones. + +
+ + + +Camera 2 Raw
+ +
+ Muestra cómo usar la API Camera2 para capturar imágenes fotográficas RAW y guardarlas como archivos DNG.
+
+
Notificación activa
+ +
+ Este ejemplo muestra cómo NotificationManager puede indicarle cuántas notificaciones está mostrando actualmente su aplicación.
+
+
+
Contenido del documento
+ +M Developer Preview SDK se encuentra disponible desde Android SDK Manager. En este documento, se asume que usted está familiarizado con el desarrollo de aplicaciones de Android, como el uso de Android SDK Manager y la creación de proyectos. + + Si no está familiarizado con Android, consulte primero la sección de capacitación Desarrollo de su primera aplicación. + +
+ +Obtener Android Studio 1.3
+ +La versión preliminar para desarrolladores funciona mejor con Android Studio 1.3, que es una versión preliminar. + Se recomienda que instale la versión preliminar de Android Studio 1.3 para trabajar con el SDK de la versión preliminar. +
+ +Advertencia: La versión preliminar Canary de Android Studio 1.3 aún se encuentra en desarrollo activo. + Si utiliza su equipo de desarrollo principal para probar la versión preliminar para desarrolladores, puede instalar una segunda instancia de Android para realizar las pruebas. + +
+ +Para instalar la versión preliminar de Android Studio 1.3:
+ +-
+
- Descargue y ejecute Android Studio + + + +
- Abra la ventana Settings (en Windows, puede hacerlo desde File > Settings).
+ Seleccione el panel Appearance & Behavior > System Settings > Updates.
+
+
+
+
En OSX, puede encontrar el panel Appearance & Behavior en la ventana Preferences de Android Studio. + +
+
+
+ - En el panel Updates, elija la opción Automatically check updates for: + Canary Channel. + + +
- En el panel Updates, elija Check Now para verificar la última compilación de Canary. + Descargue e instale la compilación cuando se lo pida. + + +
Obtener el SDK de la versión preliminar
+ +Para añadir los componentes del SDK de la versión preliminar a su entorno de desarrollo:
+ +-
+
- Ejecute la versión preliminar de Android Studio 1.3. + + +
- Abra la ventana Settings (en Windows, puede hacerlo desde File > Settings).
+ Seleccione el panel Appearance & Behavior > System Settings > Updates.
+
+
+
+
En OSX, puede encontrar el panel Appearance & Behavior en la ventana Preferences de Android Studio. + +
+
+
+ - En el panel Updates, elija las opciones Automatically check updates for: + Canary Channel y Automatically check updates for Android SDK: + Preview Channel. + + +
- Ejecute Android SDK Manager. (En Android Studio 1.3, SDK Manager está integrado a Android Studio, en lugar de ser una aplicación independiente). + + + + +
- En la sección Platforms, elija Android MNC Preview. + + + +
- En la sección Tools, elija las últimas SDK Tools, Platform-tools y Build-tools de Android. + + + + +
- Seleccione Install packages y acepte el contrato de licencia para todos los paquetes. + + + +
- Verifique que M Developer Preview esté instalado; para hacerlo, abra la ventana Settings y elija el panel Appearance & Behavior > System Settings > Android SDK. + + + +
- En el panel Android SDK, elija la pestaña SDK Platforms. + Android MNC Preview deberá figurar como Installed. + Luego, abra la pestaña SDK Tools para verificar que estén instaladas las últimas herramientas. + + + +
Después de completar estos pasos, los componentes de la versión preliminar ya estarán disponibles en su entorno de desarrollo. +
+ + +Crear o actualizar un proyecto
+ ++ Si desea utilizar las API de la versión preliminar, debe crear o actualizar un proyecto de desarrollo para utilizar los componentes de la versión preliminar. + +
+ + +Crear un proyecto nuevo
+ ++ Recomendamos que utilice Android Studio para crear un proyecto con la versión preliminar. Siga los pasos que se describen en Crear un proyecto hasta que llegue a la pantalla Form Factors en el asistente. + + Luego, realice los siguientes pasos para crear un proyecto configurado para la versión preliminar. + +
+ +-
+
- Seleccione Phone and Tablet. +
- Seleccione MNC: Android M (Preview) en Minimum SDK. + +
Actualizar un proyecto existente
+ +
+ Para proyectos existentes, debe modificar la configuración del proyecto para habilitar las API de la versión preliminar. En su entorno de desarrollo, abra el archivo
+build.gradle para su módulo y configure estos valores de la siguiente manera:
+
+
-
+
compileSdkVersionse configura en'android-MNC'
+ minSdkVersionse configura en'MNC'
+ targetSdkVersionse configura en'MNC'
+
Configurar para realizar pruebas
+ ++ Probar una aplicación con la versión preliminar requiere un dispositivo o un dispositivo virtual configurado con la versión preliminar de la plataforma. + Si tiene un dispositivo compatible, puede instalar la plataforma de la versión preliminar para realizar la prueba. + De lo contrario, puede configurar un dispositivo virtual para realizar la prueba. +
+ +Configurar un dispositivo físico
+ ++ Si tiene un Nexus 5, Nexus 6, Nexus 9 o Android TV, puede instalar una imagen de sistema de la versión preliminar en estos dispositivos para probar su aplicación. Con la herramienta Android Virtual Device Manager, puede configurar un dispositivo virtual con la versión preliminar de la plataforma desde Android Studio + + + +
+ ++ Importante: El proceso de instalación de una imagen preliminar en un dispositivo elimina todos los datos del dispositivo, por lo que debe hacer una copia de seguridad de los datos antes de instalar una imagen preliminar. + +
+ +Configurar un dispositivo virtual
+ ++ Con la herramienta Android Virtual Device, puede configurar un dispositivo virtual para la versión preliminar de la plataforma desde Android Studio. + +
+ +Crear un AVD (dispositivo virtual de Android) con AVD Manager:
+ +-
+
- Instale el SDK de la versión preliminar en su entorno de desarrollo, como se detalla en Configurar el SDK de la versión preliminar. + + +
- Siga los pasos en Administración de los ADV con ADV Manager.
+
+ Utilice las siguientes configuraciones:
+
-
+
- Dispositivo: Nexus 5, Nexus 6, Nexus 9 o Android TV +
- Destino: + Android M (versión preliminar) - Nivel de API M +
- ABI: x86 +
+
+ Para obtener más información sobre cómo crear dispositivos virtuales para realizar pruebas, consulte Administración de dispositivos virtuales. +
diff --git a/docs/html-intl/intl/es/preview/support.jd b/docs/html-intl/intl/es/preview/support.jd new file mode 100644 index 0000000000000..85f0f38bbcf1a --- /dev/null +++ b/docs/html-intl/intl/es/preview/support.jd @@ -0,0 +1,67 @@ +page.title=Soporte +page.image=images/cards/card-support_16-9_2x.png + +@jd:body + ++ Si ha encontrado errores o tiene comentarios sobre M Developer Preview, inicie un problema en nuestro seguimiento de problemas. + + +
+ ++ Para obtener soporte adicional, únase a la comunidad M Developer Preview en Google+ para analizar sus experiencias de desarrollo. + + +
+ +Notas de la versión
+ + + +
+ 
M Developer Preview, Revisión 1 (Mayo de 2015)
+
-
+
- Versión inicial. +
Contenido del documento
+ ++ Android M Developer Preview le brinda la oportunidad de garantizar que sus aplicaciones funcionen con la próxima versión de la plataforma. + Esta versión preliminar incluye diversas API y cambios en los comportamientos que pueden tener impactos en su aplicación, como se describe en las secciones Información general de la API y Cambios en los comportamientos. + + Al probar su aplicación con la versión preliminar, se debe centrar en algunos cambios específicos del sistema para garantizar que los usuarios disfruten de una buena experiencia. + + +
+ ++ En esta guía, se describen qué y cómo probar las características preliminares con su aplicación. Debe priorizar la prueba de estas características específicas preliminares, puesto que podrían tener un alto impacto en el comportamiento de su aplicación: + + +
+ +-
+
- Permisos + +
- Modos Doze y App Standby + +
- Copia de seguridad automática e identificadores de dispositivos +
+ Para obtener más información sobre cómo configurar dispositivos o dispositivos virtuales con una imagen del sistema de la versión preliminar para realizar pruebas, consulte la sección Configurar el SDK de la versión preliminar. + +
+ + +Prueba de los permisos
+ ++ El nuevo modelo de permisos cambia el modo en que el usuario asigna permisos a su aplicación. + En lugar de conceder todos los permisos durante el procedimiento de instalación, su aplicación debe solicitar al usuario los permisos individuales en el tiempo de ejecución. + + Para los usuarios, este comportamiento ofrece más control granular sobre las actividades de cada aplicación, así como un mejor contexto para comprender por qué la aplicación está solicitando un permiso específico. + Los usuarios pueden conceder o revocar los permisos concedidos a una aplicación de forma individual en cualquier momento. + Es muy probable que esta característica de la versión preliminar tenga un impacto en el comportamiento de su aplicación y puede hacer que algunas características de su aplicación no funcionen o funcionen en un estado degradado. + + +
+ ++ Este cambio afecta a todas las aplicaciones que se ejecutan en la nueva plataforma, incluso a aquellas que no tienen como destino la nueva versión de la plataforma. + La plataforma ofrece un comportamiento de compatibilidad limitada para las aplicaciones heredadas, pero usted debe comenzar a planificar ahora la migración de su aplicación al nuevo modelo de permisos, con el objetivo de publicar una versión actualizada de su aplicación cuando se lance la plataforma oficial. + + +
+ + +Consejos para pruebas
+ ++ Use los siguientes consejos para pruebas como ayuda para planificar y ejecutar las pruebas de su aplicación con el nuevo comportamiento de permisos. + +
+ +-
+
- Identifique los permisos actuales de su aplicación y las rutas de códigos relacionadas. +
- Pruebe los flujos del usuario en los datos y servicios protegidos por permisos. +
- Realice pruebas con varias combinaciones de permisos concedidos/revocados. +
- Use la herramienta {@code adb} para administrar permisos desde la línea de comando:
+
-
+
- Enumere los permisos y estados por grupo:
+
adb shell pm list permissions -d -g
+
+ - Conceda o revoque un permiso o más permisos utilizando la siguiente sintaxis:
+adb shell pm [grant|revoke] <permission.name> ...
+
+
+ - Enumere los permisos y estados por grupo:
+
- Analice su aplicación para detectar servicios que utilizan permisos. +
Estrategia de prueba
+ ++ El cambio en los permisos afecta la estructura y el diseño de su aplicación, además de la experiencia del usuario y los flujos que usted proporciona a los usuarios. + Debe evaluar el uso de los permisos actuales de su aplicación y comenzar a planificar los nuevos flujos que desea ofrecer. + La versión oficial de la plataforma proporciona un comportamiento de compatibilidad, pero debe prever la actualización de su aplicación y no depender de estos comportamientos. + + +
+ ++ Identifique los permisos que su aplicación verdaderamente necesita y utiliza, y luego busque las diversas rutas de códigos que utilizan los servicios protegidos por permisos. + Puede realizar esto mediante una combinación de pruebas en la plataforma nueva y análisis de códigos. + Al realizar las pruebas, debe centrarse en incluir permisos de tiempo de ejecución cambiando {@code targetSdkVersion} de la aplicación a la versión preliminar. + Para obtener más información, consulte la sección Configurar el SDK de la versión preliminar. + +
+ ++ Realice pruebas con diversas combinaciones de permisos revocados y agregados, a fin de destacar los flujos del usuario que dependen de permisos. + Cuando una dependencia no sea obvia ni lógica, debe considerar la opción de refactorizar o compartimentar ese flujo para eliminar la dependencia o aclarar por qué se necesita el permiso. + + +
+ ++ Para obtener más información sobre el comportamiento de los permisos de tiempo de ejecución, las pruebas y las mejores prácticas, consulte la página Permisos de la versión preliminar para desarrolladores. + + +
+ + +Prueba de los modos Doze y App Standby
+ ++ Las características de ahorro de energía de los modos Doze y App Standby limitan la cantidad de procesamiento en segundo plano que puede realizar su aplicación cuando un dispositivo se encuentra en estado inactivo o mientras su aplicación no está en foco. + Entre las restricciones que el sistema puede imponer en las aplicaciones se incluyen el acceso limitado a la red o denegación de acceso, suspensión de las tareas en segundo plano, suspensión de notificaciones, y alarmas y solicitudes de reactivación ignoradas. + + Para garantizar que su aplicación tenga un comportamiento correcto con estas optimizaciones de ahorro de energía, debe probar su aplicación simulando estos estados de bajo consumo. + + +
+ +Cómo probar la aplicación en modo Doze
+ +Para probar el modo Doze con su aplicación, realice lo siguiente:
+ +-
+
- Configure un dispositivo de hardware o un dispositivo virtual con una imagen del sistema de la versión preliminar de Android M. +
- Conecte el dispositivo a su equipo de desarrollo e instale la aplicación. +
- Ejecute su aplicación y déjela activa. +
- Simule la activación del modo Doze en el dispositivo ejecutando los siguientes comandos:
+
+
+$ adb shell dumpsys battery unplug +$ adb shell dumpsys deviceidle step +$ adb shell dumpsys deviceidle -h +
+ +
+ - Observe el comportamiento de su aplicación cuando se reactive el dispositivo. Asegúrese de que se recupere correctamente cuando el dispositivo salga del modo Doze. + +
Cómo probar aplicaciones en modo App Standby
+ +Para probar el modo App Standby con su aplicación, realice lo siguiente:
+ +-
+
- Configure un dispositivo de hardware o un dispositivo virtual con una imagen del sistema de la versión preliminar de Android M. +
- Conecte el dispositivo a su equipo de desarrollo e instale su aplicación. +
- Ejecute su aplicación y déjela activa. +
- Simule la activación del modo App Standby en la aplicación ejecutando los siguientes comandos:
+
+
+$ adb shell am broadcast -a android.os.action.DISCHARGING +$ adb shell am set-idle <packageName> true +
+ +
+ - Simule la activación de su aplicación con el siguiente comando:
+
$ adb shell am set-idle <packageName> false
+
+ - Observe el comportamiento de su aplicación al reactivarse. Asegúrese de que se recupere correctamente del modo App Standby. + En particular, debe comprobar si los trabajos en segundo plano y las notificaciones de su aplicación continúan funcionando de la manera esperada. + +
Copia de seguridad automática para aplicaciones e identificadores específicos del dispositivo
+ +Si su aplicación continúa teniendo algún identificador específico del dispositivo, como la Id. de registro de Google Cloud Messaging, en el almacenamiento interno, asegúrese de seguir las mejores prácticas para excluir la ubicación de almacenamiento de la copia de seguridad automática, como se describe en la sección Copia de seguridad automática para aplicaciones. + + + +
diff --git a/docs/html-intl/intl/es/preview/testing/performance.jd b/docs/html-intl/intl/es/preview/testing/performance.jd new file mode 100644 index 0000000000000..734697676b973 --- /dev/null +++ b/docs/html-intl/intl/es/preview/testing/performance.jd @@ -0,0 +1,656 @@ +page.title=Prueba de rendimiento de video +page.image=images/cards/card-test-performance_2x.png +page.keywords=rendimiento, fotogramas por segundo, herramientas + +@jd:body + + +Contenido del documento
+ ++ La prueba de rendimiento de la UI le garantiza que su aplicación no solo cumpla con los requisitos funcionales sino que la interacción del usuario con su aplicación sea fluida y funcione constantemente a 60 fotogramas por segundo (Why 60fps?) sin disminuir o retrasar fotogramas (lo que llamamos “jank”). + + + Este documento explica las herramientas disponibles para medir el rendimiento de la UI y establece un enfoque para integrar las medidas de rendimiento de la UI en sus prácticas de prueba. + + +
+ + +Medición del rendimiento de la UI
+ ++ Para mejorar el rendimiento, primero necesita poder medir el rendimiento de su sistema y, luego, diagnosticar e identificar los problemas que puedan surgir debido a las varias secciones de su canalización. + + +
+ ++ dumpsys es una herramienta de Android que se ejecuta en el dispositivo y vuelca información útil sobre el estado de los servicios del sistema. + + Al pasar el comando gxinfo a dumsys, se obtiene una salida de logcat con información de rendimiento en relación con los fotogramas de animación que ocurren durante la fase de grabado. + + +
+ ++> adb shell dumpsys gfxinfo <PACKAGE_NAME> ++ +
+ Este comando puede crear múltiples variantes diferentes de datos del intervalo del fotograma. +
+ +Incorporación de Frame Stats
+ ++ En la versión preliminar de Android M, el comando emite un análisis adicional a logcat sobre los datos del fotograma. Estos datos se recopilan en toda la duración del proceso. + Por ejemplo: +
+ ++Stats since: 752958278148ns +Total frames rendered: 82189 +Janky frames: 35335 (42.99%) +90th percentile: 34ms +95th percentile: 42ms +99th percentile: 69ms +Number Missed Vsync: 4706 +Number High input latency: 142 +Number Slow UI thread: 17270 +Number Slow bitmap uploads: 1542 +Number Slow draw: 23342 ++ +
+ Estas estadísticas de alto nivel representan, en un nivel avanzado, el rendimiento de representación de la aplicación y su estabilidad en muchos fotogramas. + +
+ + +Información precisa del intervalo del fotograma
+ ++ La versión preliminar de Android M ofrece un nuevo comando para gfxinfo, es framestats que brinda información extremadamente detallada sobre el intervalo del fotograma reciente, de manera que usted puede localizar y depurar errores de manera más precisa. + + +
+ ++>adb shell dumpsys gfxinfo <PACKAGE_NAME> framestats ++ +
+ Este comando emite información sobre el intervalo del fotograma, medida en nanosegundos, de los últimos 120 fotogramas que produjo la aplicación. A continuación, se muestra un ejemplo sin formato de adb dumpsys gxinfo <PACKAGE_NAME> framestats: + + +
+ ++0,49762224585003,49762241251670,9223372036854775807,0,49762257627204,49762257646058,49762257969704,49762258002100,49762265541631,49762273951162,49762300914808,49762303675954, +0,49762445152142,49762445152142,9223372036854775807,0,49762446678818,49762446705589,49762447268818,49762447388037,49762453551527,49762457134131,49762474889027,49762476150120, +0,49762462118845,49762462118845,9223372036854775807,0,49762462595381,49762462619287,49762462919964,49762462968454,49762476194547,49762476483454,49762480214964,49762480911527, +0,49762479085548,49762479085548,9223372036854775807,0,49762480066370,49762480099339,49762481013089,49762481085850,49762482232152,49762482478350,49762485657620,49762486116683, ++ +
+ Cada línea de esta salida representa un fotograma producido por la aplicación. Cada línea tiene un número fijo de columnas que describen el tiempo transcurrido en cada etapa de la canalización de producción de fotogramas. + En la siguiente sección, se describe este formato en detalle y se explica qué representa cada columna. + +
+ + +Formato de datos de framestats
+ ++ Debido a que el bloque de datos se emite en formato CSV, es muy sencillo pegarlo en su herramienta de hoja de cálculo preferida, o recopilar y redistribuir con un script. + La siguiente tabla explica el formato de las columnas de los datos de salida. + Las marcas de tiempo están en nanosegundos. +
+ +-
+
- FLAGS
+
-
+
- El tiempo total del fotograma de las filas con “0” en la columna FLAGS se puede calcular restando la columna INTENDED_VSYNC a la columna FRAME_COMPLETED. + + + +
- Si el resultado no es cero, la fila se debe ignorar, ya que se ha determinado que el fotograma contiene un valor atípico de rendimiento, donde se espera que el diseño y la imagen tomen más de 16 ms.
+
+ Razones por las que esto puede suceder:
+
-
+
- Se cambió el diseño de la ventana (ya sea el primer fotograma de la aplicación o luego de una rotación) + + + +
- También es posible que se haya omitido el fotograma. En ese caso, alguno de los valores tendrán marcas de tiempo no utilizables. + Se puede omitir un fotograma si, por ejemplo, supera los 60 fotogramas por segundo o si no había nada desfasado en pantalla. Esto no necesariamente indica que la aplicación tenga algún problema. + + + +
+
+
+ - INTENDED_VSYNC
+
-
+
- El punto de partida previsto del fotograma. Si este valor es diferente de VSYNC, el subproceso de la interfaz de usuario se encontraba ocupado, lo que evitó la respuesta a la señal vsync de manera oportuna. + + + +
+
+ - VSYNC
+
-
+
- El valor de tiempo que se utilizó en todas las escuchas vsync y las imágenes para el fotograma (devolución de llamada del fotograma Choreographer, animaciones, View.getDrawingTime(), etc.). + + + +
- Para obtener más información sobre VSYNC y cómo influye en su aplicación, consulte el video +Understanding VSYNC. + + +
+
+ - OLDEST_INPUT_EVENT
+
-
+
- La marca de tiempo del evento de entrada más antiguo de la cola de entrada, o Long.MAX_VALUE en caso de que el fotograma no tengan ninguna entrada. + + + +
- Este valor está diseñado principalmente para trabajar en la plataforma y tiene utilidad limitada para los desarrolladores de aplicaciones. + + +
+
+ - NEWEST_INPUT_EVENT
+
-
+
- La marca de tiempo del evento de entrada más reciente de la cola de entrada, o 0 en caso de que el fotograma no contenga ninguna entrada. + + + +
- Este valor está diseñado principalmente para trabajar en la plataforma y tiene utilidad limitada para los desarrolladores de aplicaciones. + + + +
- Sin embargo, puede obtener una idea general sobre la cantidad de latencia que la aplicación está añadiendo consultando (FRAME_COMPLETED - NEWEST_INPUT_EVENT). + + +
+
+ - HANDLE_INPUT_START
+
-
+
- La marca de tiempo en que el evento de entrada se distribuye a la aplicación. + + +
- Al observar el tiempo entre esto y ANIMATION_START, se puede medir cuánto tiempo dedicó la aplicación a la administración de eventos de entrada. + + + +
- Si este valor es alto (mayor a 2 ms), esto significa que la aplicación dedica tiempo poco común al proceso de los eventos de entrada, como View.onTouchEvent(), lo que indica que este proceso se debe optimizar o descargar a otro subproceso. + + Tenga en cuenta que, en algunas ocasiones, como cuando al hacer clic en un evento que lanza nuevas actividades o algo parecido, se espera y es aceptable que este valor sea alto. + + + +
+
+ - ANIMATION_START
+
-
+
- La marca de tiempo en la que se ejecutaron las animaciones registradas con Choreographer. + + +
- Al observar el tiempo entre esto y PERFORM_TRANVERSALS_START, se puede determinar cuánto tiempo llevó evaluar todos los mecanismos de animación (los más comunes son ObjectAnimator, ViewPropertyAnimator y Transitions) que se estén ejecutando. + + + + +
- Si este valor es alto (mayor a 2 ms), controle si su aplicación escribió alguna animación personalizada o qué campos está animando ObjectAnimators y asegúrese de que su animación sea adecuada. + + + + +
- Para obtener más información sobre Choreographer, consulte el video For Butter or Worse. + + +
+
+ - PERFORM_TRAVERSALS_START
+
-
+
- Si a este valor le resta DRAW_START, puede saber cuánto tardaron en completarse las fases de medición y diseño. (Durante el desplazamiento o la animación, este número deberá ser cercano a cero). + + + + +
- Para obtener más información sobre las fases de medición y diseño de la canalización de representación, consulte el video +Invalidations, Layouts and Performance. + + +
+
+ - DRAW_START
+
-
+
- El momento en que comenzó la fase de dibujo de performTraversals. Este es el punto inicial de grabación de la listas de visualización de cualquier vista invalidada. + + + +
- El tiempo entre esto y SYNC_START muestra cuánto se tardó en llamar a View.draw() en todas las vistas invalidadas en el árbol. + + + +
- Para obtener más información sobre el modelo de dibujo, consulte los videos Hardware Acceleration + o +Invalidations, Layouts and Performance. + +
+
+ - SYNC_START
+
-
+
- El momento en que comenzó la fase de sincronización del dibujo. + + +
- Si el tiempo entre esto e ISSUE_DRAW_COMMANDS_START es muy alto (mayor a 0,4 ms o similar), generalmente esto significa que se dibujaron muchos mapas de bits que se deben subir a GPU. + + + + +
- Para obtener más información sobre la fase de sincronización, consulte el video +Profile GPU Rendering. + +
+
+ - ISSUE_DRAW_COMMANDS_START
+
-
+
- El momento en que el representador de hardware comenzó a enviar comandos de dibujo a GPU. + + +
- El tiempo entre esto y FRAME_COMPLETED permite obtener una idea general sobre cuánto trabajo le genera la aplicación a GPU. + Aquí aparecen los problemas como el exceso de dibujos o efectos de representación ineficientes. + + +
+
+ - SWAP_BUFFERS
+
-
+
- El momento en que se llamó a eglSwapBuffers, generalmente de poca importancia fuera del trabajo en plataforma. + + +
+
+ - FRAME_COMPLETED
+
-
+
- ¡Todo listo! El tiempo total dedicado al trabajo en este fotograma se puede calcular al hacer FRAME_COMPLETED - INTENDED_VSYNC. + + +
+
+
+ Puede utilizar esta información de distintas maneras. Un método de visualización simple pero eficaz es el histograma que muestra la distribución de los tiempos del fotograma (FRAME_COMPLETED - INTENDED_VSYNC) en distintos bloques de latencia; vea la siguiente figura. + + Este gráfico indica brevemente que la mayoría de los fotogramas estuvieron muy bien, es decir, por debajo del límite de 16 ms (marcado en rojo). Sin embargo, algunos fotogramas estuvieron muy por arriba del límite. + + En el histograma, podemos observar los cambios con el correr del tiempo para ver la creación de los cambios totales o los nuevos valores atípicos. + También puede graficar la latencia de entrada, el tiempo dedicado al diseño o cualquier otra medición interesante similar sobre las marcas de tiempo en los datos. + + +
+ +
+
+
+Volcado simple del intervalo del fotograma
+ +
+ Si, en las Opciones de Desarrollador, Profile GPU rendering se configura en In adb shell dumpsys gfinfo, el comando adb shell dumpsys gfxinfo emite sobre el tiempo de los 120 fotogramas más recientes y los agrupa en algunas categorías diferentes con valores separados por tabulación.
+
+
+ Esta información puede resultar útil para indicar qué partes de la canalización del dibujo podrían funcionar lento en un nivel alto.
+
+
+ Al igual que framestats, es muy sencillo pegar esta información en su herramienta de hoja de cálculo preferida, o recolectar y redistribuir con un script. + + El siguiente gráfico detalla dónde pasaron tiempo muchos de los fotogramas generados por la aplicación. + +
+ +
+
++ El resultado de ejecutar gfxinfo, copiar la salida, pegar en una aplicación de hoja de cálculo y graficar la información en forma de barras apiladas. + +
+ ++ Cada barra vertical representa un fotograma de animación, su altura representa la cantidad de milisegundos que le llevó calcular ese fotograma de animación. + Cada segmento de color de la barra representa una etapa diferente de la canalización de representación, de manera que usted pueda observar qué partes de su aplicación pueden estar creando un cuello de botella. + + Para obtener más información sobre la canalización de representación y cómo optimizarla, consulte el video +Invalidations Layouts and Performance. + +
+ + +Control del período de recopilación de datos
+ ++ Los intervalos de framestats y del fotograma simple recopilan datos durante un período muy breve: aproximadamente dos segundos que valen la pena representar. + Para poder controlar este período con precisión, por ejemplo para limitar los datos a una animación en particular, puede restablecer todos los contadores y agregar los datos recopilados. + + +
+ ++>adb shell dumpsys gfxinfo <PACKAGE_NAME> reset ++ +
+ Esto se puede usar junto con los comandos de volcado para recopilar y restablecer a una cadencia normal a fin de capturar continuamente períodos de fotogramas de menos de dos segundos. + + +
+ + +Diagnóstico de regresiones de rendimiento
+ ++ La identificación de regresiones es un buen primer paso para localizar los problemas y mantener la aplicación funcionando correctamente. + Sin embargo, dumpsys solo identifica la existencia y la gravedad relativa de los problemas. + Usted todavía debe diagnosticar la causa particular de los problemas de rendimiento y encontrar las soluciones adecuadas. + Para esto, es sumamente recomendable que utilice la herramienta systrace. + +
+ + +Recursos adicionales
+ ++ Para obtener más información sobre el funcionamiento de la canalización de representación de Android, los problemas comunes que puede encontrar y cómo solucionarlos, es posible que algunos de los siguientes recursos le resulten útiles: + + +
+ +-
+
- Rendering Performance 101 + +
- Why 60fps? + +
- Android UI and the GPU + +
- Invalidations Layouts and performance + +
- Analyzing UI Performance with Systrace + +
Pruebas automatizadas de rendimiento de la UI
+ ++ Un enfoque para realizar la prueba de rendimiento de la UI es solicitar a un evaluador que realice una serie de operaciones de usuario en la aplicación objetivo para identificar visualmente jank, o bien, pasar mucho tiempo utilizando un enfoque basado en alguna herramienta para encontrar jank. + + Sin embargo, este enfoque manual tiene sus riesgos, la habilidad humana para percibir cambios en los índices de los fotogramas varía de manera alarmante. Además, este proceso lleva mucho tiempo, es tedioso y propenso a errores. + + +
+ ++ Un método más eficiente es registrarse y analizar las mediciones de rendimiento clave a partir de pruebas automatizadas de UI. + Android M Developer Preview incluye nuevas capacidades de registro que facilitan la determinación de la cantidad y gravedad de jank en las animaciones de su aplicación y pueden utilizarse para crear un proceso estricto a fin de determinar su rendimiento actual y realizar un seguimiento de futuros objetivos de rendimiento. + + + +
+ ++ Este artículo lo guía a través de un enfoque recomendado para utilizar esa información a fin de automatizar su prueba de rendimiento. + +
+ ++ Esto se divide básicamente en dos acciones clave. Primero, identificar qué está probando y cómo lo prueba. Segundo, configurar y mantener un entorno de prueba automatizado. + + +
+ + +Configuración de pruebas de UI
+ ++ Antes de comenzar con las pruebas automatizadas, es importante establecer algunas decisiones de alto nivel para entender correctamente el espacio de prueba y las necesidades que puede tener. + +
+ ++ Identifique flujos/animaciones clave que desea probar +
+ ++ Recuerde que el usuario visualiza el rendimiento negativo cuando una animación fluida se interrumpe. + Por lo tanto, al identificar qué tipo de acciones de UI desea probar, se recomienda centrarse en aquellas animaciones clave que el usuario ve más o que son más importantes para su experiencia. + + Por ejemplo, a continuación, se mencionan situaciones comunes que es útil identificar: +
+ +-
+
- Desplazamiento por ListView o RecyclerView principales + + +
- Animaciones durante ciclos de espera no sincronizados + + +
- Animaciones que puedan contener manipulación o carga de mapa de bits + + +
- Animaciones que incluyan combinación alfa + + +
- Dibujos personalizados con Canvas + +
+ Trabaje con los ingenieros, diseñadores y gerentes de productos de su equipo a fin de priorizar estas animaciones clave para la cobertura de la prueba. + +
+ ++ Establezca sus objetivos futuros y realice un seguimiento en virtud de ellos +
+ ++ Desde un nivel alto, puede ser crítico identificar sus metas de rendimiento específicas y concentrarse en escribir pruebas y recopilar datos sobre ellas. + Por ejemplo: +
+ +-
+
- ¿Simplemente desea comenzar a realizar un seguimiento del rendimiento de la UI por primera vez para obtener más información? + + +
- ¿Desea evitar regresiones que podrían aparecer en el futuro? + + +
- ¿Se encuentra hoy en un 90 % de fluidez de fotogramas y quiere alcanzar un 98 % en este trimestre? + + +
- ¿Se encuentra en un 98 % de fluidez de fotogramas y no quiere retroceder? + + +
- ¿Tiene como objetivo mejorar el rendimiento en dispositivos de gama baja? + +
+ Para todas estas situaciones, es recomendable realizar un seguimiento que muestre el rendimiento en múltiples versiones de su aplicación. + +
+ ++ Identifique los dispositivos en los que desea realizar la prueba +
+ ++ El rendimiento de la aplicación varía según el dispositivo en el que se ejecuta. Algunos dispositivos pueden tener menos memoria, GPU menos potentes o CPU más lentos. + Esto significa que las animaciones que funcionan bien en un conjunto de hardware pueden no hacerlo en otros, o peor, pueden provocar un cuello de botella en diferentes secciones de la canalización. + + Por lo tanto, para justificar esta variación en lo que un usuario puede ver, seleccione una serie de dispositivos, tanto de alta gama como de baja, tablets, etc., en los que ejecutará las pruebas. + + Busque variedad en rendimiento de CPU, memoria RAM, resolución de pantalla, tamaño, etc. + Las pruebas exitosas en un dispositivo de alta gama pueden fallar en uno de baja gama. + +
+ ++ Marcos básicos para pruebas de UI +
+ ++ Algunos conjuntos de herramientas, como UI Automator y Espresso, están diseñados para ayudar a automatizar el desplazamiento de un usuario por su aplicación. + + Estos son marcos simples que imitan la interacción del usuario con el dispositivo. + Para utilizar estos marcos, debe crear con éxito scripts únicos que se ejecuten en un conjunto de acciones de usuarios y reproducirlos en el dispositivo en sí. + + +
+ +
+ Al combinar estas pruebas automatizadas junto con dumpsys gfxinfo, puede crear rápidamente un sistema reproducible que le permite ejecutar una prueba y medir la información de rendimiento de esa condición particular.
+
+
+
Configurar pruebas automatizadas de UI
+ ++ Una vez que pueda ejecutar una prueba de UI y una canalización para recopilar datos de una sola prueba, el próximo paso importante es elegir un marco que pueda ejecutar esa prueba muchas veces en múltiples dispositivos y agregar los datos de rendimiento resultantes para que su equipo de desarrollo los analice mejor. + + + +
+ ++ Un marco para la automatización de pruebas +
+ ++ Vale la pena mencionar que los marcos para pruebas de UI (como UI Automator) se ejecutan directamente en el emulador/dispositivo objetivo. + A la recopilación de información de rendimiento realizada por +dumpsys gfxinfo la impulsa un equipo de host que envía comandos por ADB. Para ayudar a unir la automatización de estas entidades separadas, se diseñó el marco MonkeyRunner. Un sistema de scripts que se ejecuta en su equipo de host y que puede emitir comandos a un conjunto de dispositivos conectados y recibir datos de ellos. + + + +
+ ++ Al crear un conjunto de scripts para la automatización adecuada de las pruebas de rendimiento de UI, usted podrá, como mínimo, utilizar MonkeyRunner para realizar con éxito las siguientes tareas: + +
+ +-
+
- Cargar e iniciar un APK deseado en un dispositivo objetivo, en múltiples dispositivos o en un emulador. + + +
- Iniciar una prueba de UI automatizada y permitir que se ejecute. + + +
- Recopilar información de rendimiento mediante dumpsys gfxinfo. + + +
- Añadir información y presentársela de manera útil al desarrollador. + +
Clasificar y solucionar problemas detectados
+ ++ Una vez que se identifican los patrones de problemas o las regresiones, el paso siguiente es identificar y aplicar la solución. + Si su marco de pruebas automatizadas preserva detalles precisos del intervalo para los fotogramas, puede ayudarlo a investigar cambios sospechosos de código o diseño (en el caso de una regresión), o delimitar la parte del sistema que está analizando al cambiar a una investigación manual. + + + Para realizar una investigación manual, systrace es un buen lugar para comenzar, ya que muestra información precisa sobre cada etapa de la canalización de representación, cada subproceso y núcleo del sistema, además de cualquier marca de evento personalizada que usted defina. + + +
+ ++ Descripción adecuada de intervalos temporales +
+ ++ Es importante mencionar las dificultades para obtener y medir los intervalos que son producto del rendimiento de la representación. + Estos números son, por naturaleza, no deterministas y, a menudo, fluctúan según el estado del sistema, la cantidad de memoria disponible, el límite térmico y la última vez que un rayo solar tocó el área de la tierra donde se encuentra. + + El punto es que puede ejecutar la misma prueba dos veces y obtener números apenas diferentes que pueden estar cerca pero no ser iguales. + + +
+ ++ Para recopilar y definir datos correctamente de esta manera, deberá ejecutar la misma prueba muchas veces y acumular los resultados como un promedio o un valor promedio (para que resulte más fácil, lo llamaremos un “lote”). Esto le ofrece una aproximación estimada del rendimiento de la prueba, sin requerir intervalos exactos. + + + +
+ ++ Los lotes se pueden usar entre cambios de código para verificar el impacto relativo que esos cambios tienen en el rendimiento. + Si el índice de fotograma promedio para el lote previo al cambio es que el lote después del cambio, entonces, generalmente está en presencia de un incremento general en relación con el rendimiento para ese cambio particular. + + +
+ ++ Esto significa que cualquier prueba automatizada de UI que lleve a cabo debería tener en cuenta este concepto, además de justificar cualquier anomalía que pudiera surgir durante una prueba. + Por ejemplo, si el rendimiento de su aplicación disminuye repentinamente debido a algún problema con el dispositivo (que no sea provocado por la aplicación), deberá volver a ejecutar el lote para obtener intervalos menos caóticos. + + + +
+ ++ Entonces, ¿cuántas veces debe ejecutar una prueba para que los resultados sean significativos? El mínimo debe ser 10 veces y con números más altos, como 50 o 100, para obtener resultados más precisos (por supuesto, ahora cambia el tiempo por la precisión). + + +