Descripción general de las funciones y APIs

Android 15 presenta excelentes funciones y APIs para desarrolladores. En las siguientes secciones, se resumen estas funciones para ayudarte a comenzar a usar las APIs relacionadas.

Cámara y contenido multimedia

Android 15 incluye una variedad de funciones que mejoran la cámara y la experiencia multimedia, y te dan acceso a herramientas y hardware para ayudar a los creadores a hacer realidad su visión en Android.

Si quieres obtener más información sobre las funciones y soluciones para desarrolladores más recientes de contenido multimedia y cámara de Android, consulta la charla Cómo crear experiencias modernas de cámara y contenido multimedia de Android de Google I/O.

Aumento con poca luz

Android 15 presenta el Intensificador de poca luz, un nuevo modo de exposición automática disponible para la Cámara 2 y la extensión de la cámara en modo nocturno. La mejora con poca luz ajusta la exposición de la transmisión de la vista previa en condiciones de poca luz. Esto se diferencia de la manera en que la extensión de la cámara del modo nocturno crea imágenes estáticas, ya que el modo nocturno combina una ráfaga de fotos para crear una imagen única mejorada. Si bien el modo nocturno funciona muy bien para crear imágenes estáticas, no puede crear un flujo continuo de fotogramas, pero la potencia baja sí puede hacerlo. Por lo tanto, la potenciación con poca luz habilita funciones nuevas de la cámara, como las siguientes:

• Proporcionar una vista previa de imagen mejorada, de modo que los usuarios puedan enmarcar mejor sus fotos con poca luz
• Escaneo de códigos QR con poca luz

Si habilitas la amplificación de poca luz, se activará automáticamente cuando haya un nivel de luz tenue y se desactivará cuando haya más luz.

Las apps pueden grabar fuera de la transmisión de la versión preliminar en condiciones de poca luz para guardar un video iluminado.

Para obtener más información, consulta Potenciación del modo noche.

Controles de cámara en la app

Android 15 adds a new extension for more control over the camera hardware and its algorithms on supported devices:

• Advanced flash strength adjustments enabling precise control of flash intensity in both SINGLE and TORCH modes while capturing images.

Control del margen de HDR

Android 15 chooses HDR headroom that is appropriate for the underlying device capabilities and bit-depth of the panel. For pages that have lots of SDR content, such as a messaging app displaying a single HDR thumbnail, this behavior can end up adversely influencing the perceived brightness of the SDR content. Android 15 lets you control the HDR headroom with setDesiredHdrHeadroom to strike a balance between SDR and HDR content.

Control de volumen

Android 15 presenta compatibilidad con el estándar de volumen CTA-2075 para ayudarte a evitar incoherencias en el volumen del audio y garantizar que los usuarios no tengan que ajustar el volumen constantemente cuando cambien de contenido. El sistema aprovecha las características conocidas de los dispositivos de salida (auriculares y bocina), junto con los metadatos de intensidad disponibles en el contenido de audio AAC, para ajustar de forma inteligente el volumen del audio y los niveles de compresión de rango dinámico.

Para habilitar esta función, debes asegurarte de que los metadatos de volumen estén disponibles en tu contenido AAC y habilitar la función de plataforma en tu app. Para ello, llama a su método de fábrica create con el ID de sesión de audio del AudioTrack asociado a fin de crear una instancia de un objeto LoudnessCodecController. Puedes pasar un OnLoudnessCodecUpdateListener para modificar o filtrar los parámetros de volumen antes de que se apliquen en MediaCodec.

// Media contains metadata of type MPEG_4 OR MPEG_D
val mediaCodec = …
val audioTrack = AudioTrack.Builder()
                                .setSessionId(sessionId)
                                .build()
...
// Create new loudness controller that applies the parameters to the MediaCodec
try {
   val lcController = LoudnessCodecController.create(mSessionId)
   // Starts applying audio updates for each added MediaCodec
}

AndroidX media3 ExoPlayer también se actualizará para usar las APIs de LoudnessCodecController con el objetivo de lograr una integración fluida de la app.

Dispositivos MIDI virtuales 2.0

Android 13 agregó compatibilidad para conectarse a dispositivos MIDI 2.0 mediante USB, que se comunican mediante paquetes MIDI universales (UMP). Android 15 extiende la compatibilidad con UMP a apps MIDI virtuales, lo que permite que las apps de composición controlen las apps de sintetizador como un dispositivo MIDI 2.0 virtual, al igual que lo harían con un dispositivo MIDI USB 2.0.

Decodificación de software AV1 más eficiente

dav1d, the popular AV1 software decoder from VideoLAN is now available for Android devices that don't support AV1 decode in hardware. dav1d is up to 3x more performant than the legacy AV1 software decoder, enabling HD AV1 playback for more users, including some low and mid tier devices.

For now, your app needs to opt-in to using dav1d by invoking it by name "c2.android.av1-dav1d.decoder". dav1d will be made the default AV1 software decoder in a subsequent update. This support is standardized and backported to Android 11 devices that receive Google Play system updates.

Productividad y herramientas para desarrolladores

Si bien la mayor parte de nuestro trabajo para mejorar la productividad se centra en herramientas como Android Studio, Jetpack Compose y las bibliotecas de Android Jetpack, siempre buscamos formas en la plataforma que te ayuden a hacer realidad tu visión con mayor facilidad.

Actualizaciones de OpenJDK 17

Android 15 continues the work of refreshing Android's core libraries to align with the features in the latest OpenJDK LTS releases.

The following key features and improvements are included:

• Quality-of-life improvements around NIO buffers
• Streams
• Additional math and strictmath methods
• util package updates including sequenced collection, map, and set
• ByteBuffer support in Deflater
• Security updates such as X500PrivateCredential and security key updates

These APIs are updated on over a billion devices running Android 12 (API level 31) and higher through Google Play System updates, so you can target the latest programming features.

Mejoras en los archivos PDF

Android 15 includes substantial improvements to the PdfRenderer APIs. Apps can incorporate advanced features such as rendering password-protected files, annotations, form editing, searching, and selection with copy. Linearized PDF optimizations are supported to speed local PDF viewing and reduce resource use.

The PdfRenderer has been moved to a module that can be updated using Google Play system updates independent of the platform release, and we're supporting these changes back to Android 11 (API level 30) by creating a compatible pre-Android 15 version of the API surface, called PdfRendererPreV.

We value your feedback on the enhancements we've made to the PdfRenderer API surface, and we plan to make it even easier to incorporate these APIs into your app with an upcoming Android Jetpack library.

Mejoras en el cambio automático de idioma

Android 14 added on-device, multi-language recognition in audio with automatic switching between languages, but this can cause words to get dropped, especially when languages switch with less of a pause between the two utterances. Android 15 adds additional controls to help apps tune this switching to their use case. EXTRA_LANGUAGE_SWITCH_INITIAL_ACTIVE_DURATION_TIME_MILLIS confines the automatic switching to the beginning of the audio session, while EXTRA_LANGUAGE_SWITCH_MATCH_SWITCHES deactivates the language switching after a defined number of switches. These options are particularly useful if you expect that there will be a single language spoken during the session that should be autodetected.

Se mejoró la API de OpenType Variable Font

Android 15 improves the usability of the OpenType variable font. You can now create a FontFamily instance from a variable font without specifying weight axes with the buildVariableFamily API. The text renderer overrides the value of wght axis to match the displaying text.

Using the new API, this simplifies the code for creating a Typeface considerably:

val newTypeface = Typeface.CustomFallbackBuilder(
            FontFamily.Builder(
                Font.Builder(assets, "RobotoFlex.ttf").build())
                    .buildVariableFamily())
    .build()

Typeface newTypeface = Typeface.CustomFallbackBuilder(
            new FontFamily.Builder(
                new Font.Builder(assets, "RobotoFlex.ttf").build())
                    .buildVariableFamily())
    .build();

Previously, to create the same Typeface, you would need much more code:

val oldTypeface = Typeface.CustomFallbackBuilder(
            FontFamily.Builder(
                Font.Builder(assets, "RobotoFlex.ttf")
                    .setFontVariationSettings("'wght' 400")
                    .setWeight(400)
                    .build())
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 100")
                        .setWeight(100)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 200")
                        .setWeight(200)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 300")
                        .setWeight(300)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 500")
                        .setWeight(500)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 600")
                        .setWeight(600)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 700")
                        .setWeight(700)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 800")
                        .setWeight(800)
                        .build()
                )
                .addFont(
                    Font.Builder(assets, "RobotoFlex.ttf")
                        .setFontVariationSettings("'wght' 900")
                        .setWeight(900)
                        .build()
                ).build()
        ).build()

Typeface oldTypeface = new Typeface.CustomFallbackBuilder(
    new FontFamily.Builder(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 400")
            .setWeight(400)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 100")
            .setWeight(100)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 200")
            .setWeight(200)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 300")
            .setWeight(300)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 500")
            .setWeight(500)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 600")
            .setWeight(600)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 700")
            .setWeight(700)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 800")
            .setWeight(800)
            .build()
    )
    .addFont(
        new Font.Builder(assets, "RobotoFlex.ttf")
            .setFontVariationSettings("'wght' 900")
            .setWeight(900)
            .build()
    )
    .build()
).build();

Here's an example of how a Typeface created with both the old and new APIs renders:

In this example, the Typeface created with the old API doesn't have the capability to create accurate font weights for the 350, 450, 550 and 650 Font instances, so the renderer falls back to the closest weight. So in this case, 300 is rendered instead of 350, 400 is rendered instead of 450, and so on. By contrast, the Typeface created with the new APIs dynamically creates a Font instance for a given weight, so accurate weights are rendered for 350, 450, 550, and 650 as well.

Controles detallados de salto de línea

A partir de Android 15, un TextView y el salto de línea subyacente pueden conservar la parte determinada del texto en la misma línea para mejorar la legibilidad. Puedes aprovechar esta personalización de salto de línea con la etiqueta <nobreak> en los recursos de cadenas o createNoBreakSpan. Del mismo modo, puedes conservar palabras de la separación silábica con la etiqueta <nohyphen> o createNoHyphenationSpan.

Por ejemplo, el siguiente recurso de cadenas no incluye un salto de línea y se renderiza con el texto "Pixel 8 Pro" rompiendo en un lugar no deseado:

<resources>
    <string name="pixel8pro">The power and brains behind Pixel 8 Pro.</string>
</resources>

Por el contrario, este recurso de cadenas incluye la etiqueta <nobreak>, que une la frase "Pixel 8 Pro" y evita los saltos de línea:

<resources>
    <string name="pixel8pro">The power and brains behind <nobreak>Pixel 8 Pro.</nobreak></string>
</resources>

La diferencia en la forma en que se renderizan estas cadenas se muestra en las siguientes imágenes:

Diseño de una línea de texto donde la frase "Pixel 8 Pro" no se une con una etiqueta <nobreak>.

Diseño para la misma línea de texto donde la frase "Pixel 8 Pro" está unida a la etiqueta <nobreak>.

Archivo de apps

Android y Google Play anunciaron su compatibilidad con el archivo de apps el año pasado, lo que les permite a los usuarios liberar espacio quitando parcialmente las apps que se usan con poca frecuencia del dispositivo que se publicaron con Android App Bundle en Google Play. Android 15 ahora incluye compatibilidad a nivel del SO para archivar y desarchivar apps, lo que facilita que todas las tiendas de aplicaciones lo implementen.

Las apps con el permiso REQUEST_DELETE_PACKAGES pueden llamar al método PackageInstaller requestArchive para solicitar que se archive un paquete de app instalado, lo que quita el APK y todos los archivos almacenados en caché, pero conserva los datos del usuario. Las apps archivadas se muestran como apps visibles a través de las APIs de LauncherApps. Los usuarios verán un tratamiento de la IU para destacar que esas apps están archivadas. Si un usuario presiona una app archivada, el instalador responsable recibirá una solicitud para desarchivarla, y el proceso de restablecimiento se puede supervisar con la transmisión ACTION_PACKAGE_ADDED.

Gráficos

Android 15 ofrece las mejoras de gráficos más recientes, como ANGLE y adiciones al sistema de gráficos Canvas.

Modernización del acceso a las GPU de Android

Android hardware has evolved quite a bit from the early days where the core OS would run on a single CPU and GPUs were accessed using APIs based on fixed-function pipelines. The Vulkan® graphics API has been available in the NDK since Android 7.0 (API level 24) with a lower-level abstraction that better reflects modern GPU hardware, scales better to support multiple CPU cores, and offers reduced CPU driver overhead — leading to improved app performance. Vulkan is supported by all modern game engines.

Vulkan is Android's preferred interface to the GPU. Therefore, Android 15 includes ANGLE as an optional layer for running OpenGL® ES on top of Vulkan. Moving to ANGLE will standardize the Android OpenGL implementation for improved compatibility, and, in some cases, improved performance. You can test out your OpenGL ES app stability and performance with ANGLE by enabling the developer option in Settings -> System -> Developer Options -> Experimental: Enable ANGLE on Android 15.

The Android ANGLE on Vulkan roadmap

As part of streamlining our GPU stack, going forward we will be shipping ANGLE as the GL system driver on more new devices, with the future expectation that OpenGL/ES will be only available through ANGLE. That being said, we plan to continue support for OpenGL ES on all devices.

Recommended next steps

Use the developer options to select the ANGLE driver for OpenGL ES and test your app. For new projects, we strongly encourage using Vulkan for C/C++.

Mejoras de Canvas

Android 15 continúa nuestra modernización del sistema de gráficos Canvas de Android con capacidades nuevas:

• Matrix44 proporciona una matriz de 4 × 4 para transformar las coordenadas que se deben usar cuando desees manipular el lienzo en 3D.
• clipShader realiza una intersección entre el clip actual y el sombreador especificado, mientras que clipOutShader establece el clip según la diferencia entre el clip actual y el sombreador, y cada uno trata al sombreador como una máscara alfa. Esto permite dibujar formas complejas de manera eficiente.

Rendimiento y batería

Android continúa su enfoque en ayudarte a mejorar el rendimiento y la calidad de tus apps. Android 15 presenta nuevas APIs que ayudan a que las tareas de tu app sean más eficientes de ejecutar, optimizar el rendimiento de las apps y recopilar estadísticas sobre ellas.

Si deseas conocer las prácticas recomendadas para ahorrar batería, depurar el uso de la red y la energía, y obtener detalles sobre cómo mejoramos la eficiencia de la batería del trabajo en segundo plano en Android 15 y versiones recientes de Android, consulta el artículo de Google I/O Cómo mejorar la eficiencia de la batería del trabajo en segundo plano en Android.

API de ApplicationStartInfo

In previous versions of Android, app startup has been a bit of a mystery. It was challenging to determine within your app whether it started from a cold, warm, or hot state. It was also difficult to know how long your app spent during the various launch phases: forking the process, calling onCreate, drawing the first frame, and more. When your Application class was instantiated, you had no way of knowing whether the app started from a broadcast, a content provider, a job, a backup, boot complete, an alarm, or an Activity.

The ApplicationStartInfo API on Android 15 provides all of this and more. You can even choose to add your own timestamps into the flow to help collect timing data in one place. In addition to collecting metrics, you can use ApplicationStartInfo to help directly optimize app startup; for example, you can eliminate the costly instantiation of UI-related libraries within your Application class when your app is starting up due to a broadcast.

Información detallada sobre el tamaño de la app

A partir de Android 8.0 (nivel de API 26), Android incluyó la API de StorageStats.getAppBytes que resume el tamaño instalado de una app como una sola cantidad de bytes, que es una suma del tamaño del APK, el tamaño de los archivos extraídos del APK y los archivos que se generaron en el dispositivo, como el código compilado por adelantado (AOT). Esta cifra no es muy detallada en términos de cómo tu app usa el almacenamiento.

En Android 15, se agrega la API de StorageStats.getAppBytesByDataType([type]), que te permite obtener estadísticas sobre cómo tu app usa todo ese espacio, incluidas las divisiones de archivos APK, el código relacionado con AOT y la aceleración, metadatos dex, bibliotecas y perfiles guiados.

Generación de perfiles administrada por la app

Android 15 incluye la clase ProfilingManager completamente nueva, que te permite recopilar información de generación de perfiles desde tu app. Tenemos previsto unir esto con una API de Android Jetpack que simplificará la construcción de solicitudes de generación de perfiles, pero la API principal permitirá la recopilación de volcados de montón, perfiles de montón, muestreo de pila y mucho más. Proporciona una devolución de llamada a tu app con una etiqueta proporcionada para identificar el archivo de salida, que se entrega al directorio de archivos de la app. La API establece un límite de frecuencia para minimizar el impacto en el rendimiento.

Mejoras en la base de datos SQLite

Android 15 introduce nuevas APIs de SQLite que exponen funciones avanzadas del motor SQLite subyacente que tienen como objetivo problemas de rendimiento específicos que pueden manifestarse en las apps.

Los desarrolladores deben consultar las prácticas recomendadas sobre el rendimiento de SQLite para aprovechar al máximo su base de datos SQLite, en especial cuando trabajan con bases de datos grandes o cuando se ejecutan consultas sensibles a la latencia.

• Transacciones diferidas de solo lectura: Cuando emitas transacciones de solo lectura (no incluyen instrucciones de escritura), usa beginTransactionReadOnly() y beginTransactionWithListenerReadOnly(SQLiteTransactionListener) para emitir transacciones DEFERRED de solo lectura. Estas transacciones pueden ejecutarse de forma simultánea y, si la base de datos está en modo WAL, pueden ejecutarse en simultáneo con las transacciones de IMMEDIATE o EXCLUSIVE.
• ID y recuentos de filas: Se agregaron nuevas APIs para recuperar el recuento de las filas modificadas o el ID de la última fila insertada sin emitir una consulta adicional. getLastChangedRowCount() muestra la cantidad de filas que insertó, actualizó o borró la instrucción de SQL más reciente dentro de la transacción actual, mientras que getTotalChangedRowCount() muestra el recuento de la conexión actual. getLastInsertRowId() muestra el rowid de la última fila que se insertará en la conexión actual.
• Declaraciones sin procesar: Emite una declaración de SQlite sin procesar, evitando las wrappers de conveniencia y cualquier sobrecarga de procesamiento adicional que puedan generar.

Actualizaciones del framework de rendimiento dinámico de Android

Android 15 continues our investment in the Android Dynamic Performance Framework (ADPF), a set of APIs that allow games and performance intensive apps to interact more directly with power and thermal systems of Android devices. On supported devices, Android 15 will add new ADPF capabilities:

• A power-efficiency mode for hint sessions to indicate that their associated threads should prefer power saving over performance, great for long-running background workloads.
• GPU and CPU work durations can both be reported in hint sessions, allowing the system to adjust CPU and GPU frequencies together to best meet workload demands.
• Thermal headroom thresholds to interpret possible thermal throttling status based on headroom prediction.

To learn more about how to use ADPF in your apps and games, head over to the documentation.

Privacidad

Android 15 incluye una variedad de funciones que ayudan a los desarrolladores de apps a proteger la privacidad del usuario.

Detección de grabación de pantalla

Android 15 agrega compatibilidad con apps para detectar si se están grabando. Se invoca una devolución de llamada cada vez que la app pasa de ser visible o invisible dentro de una grabación de pantalla. Una app se considera visible si se registran actividades que pertenecen al UID del proceso de registro. De esta manera, si tu app realiza una operación sensible, puedes informar al usuario que se la está grabando.

val mCallback = Consumer<Int> { state ->
  if (state == SCREEN_RECORDING_STATE_VISIBLE) {
    // We're being recorded
  } else {
    // We're not being recorded
  }
}

override fun onStart() {
   super.onStart()
   val initialState =
      windowManager.addScreenRecordingCallback(mainExecutor, mCallback)
   mCallback.accept(initialState)
}

override fun onStop() {
    super.onStop()
    windowManager.removeScreenRecordingCallback(mCallback)
}

Capacidades expandidas de IntentFilter

Android 15 compila compatibilidad con una resolución de Intent más precisa a través de UriRelativeFilterGroup, que contiene un conjunto de objetos UriRelativeFilter que forman un conjunto de reglas de coincidencia de Intent que deben cumplirse, incluidos los parámetros de consulta de URL, los fragmentos de URL y las reglas de bloqueo o exclusión.

Estas reglas se pueden definir en el archivo en formato XML AndroidManifest con la nueva etiqueta <uri-relative-filter-group>, que puede incluir una etiqueta android:allow de manera opcional. Estas etiquetas pueden contener etiquetas <data> que usan atributos de etiquetas de datos existentes, además de los nuevos atributos android:query y android:fragment.

Este es un ejemplo de la sintaxis AndroidManifest:

<intent-filter>
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.BROWSABLE" />
  <data android:scheme="http" />
  <data android:scheme="https" />
  <data android:domain="astore.com" />
  <uri-relative-filter-group>
    <data android:pathPrefix="/auth" />
    <data android:query="region=na" />
  </uri-relative-filter-group>
  <uri-relative-filter-group android:allow="false">
    <data android:pathPrefix="/auth" />
    <data android:query="mobileoptout=true" />
  </uri-relative-filter-group>
  <uri-relative-filter-group android:allow="false">
    <data android:pathPrefix="/auth" />
    <data android:fragmentPrefix="faq" />
  </uri-relative-filter-group>
</intent-filter>

Espacio privado

Private space lets users create a separate space on their device where they can keep sensitive apps away from prying eyes, under an additional layer of authentication. The private space uses a separate user profile. The user can choose to use the device lock or a separate lock factor for the private space.

Apps in the private space show up in a separate container in the launcher, and are hidden from the recents view, notifications, settings, and from other apps when the private space is locked. User-generated and downloaded content (such as media or files) and accounts are separated between the private space and the main space. The system sharesheet and the photo picker can be used to give apps access to content across spaces when the private space is unlocked.

Users can't move existing apps and their data into the private space. Instead, users select an install option in the private space to install an app using whichever app store they prefer. Apps in the private space are installed as separate copies from any apps in the main space (new copies of the same app).

When a user locks the private space, the profile is stopped. While the profile is stopped, apps in the private space are no longer active and can't perform foreground or background activities, including showing notifications.

We recommend that you test your app with private space to make sure your app works as expected, especially if your app falls into one of the following categories:

• Apps with logic for work profiles that assumes that any installed copies of their app that aren't in the main profile are in the work profile.
• Launcher apps
• App store apps

Consultar la selección más reciente del usuario para el acceso a las fotos seleccionadas

Ahora las apps pueden destacar solo las fotos y los videos seleccionados más recientemente cuando se otorga acceso parcial a los permisos de contenido multimedia. Esta función puede mejorar la experiencia del usuario para las apps que solicitan acceso a fotos y videos con frecuencia. Para usar esta función en tu app, habilita el argumento QUERY_ARG_LATEST_SELECTION_ONLY cuando consultes MediaStore a través de ContentResolver.

val externalContentUri = MediaStore.Files.getContentUri("external")

val mediaColumns = arrayOf(
   FileColumns._ID,
   FileColumns.DISPLAY_NAME,
   FileColumns.MIME_TYPE,
)

val queryArgs = bundleOf(
   // Return only items from the last selection (selected photos access)
   QUERY_ARG_LATEST_SELECTION_ONLY to true,
   // Sort returned items chronologically based on when they were added to the device's storage
   QUERY_ARG_SQL_SORT_ORDER to "${FileColumns.DATE_ADDED} DESC",
   QUERY_ARG_SQL_SELECTION to "${FileColumns.MEDIA_TYPE} = ? OR ${FileColumns.MEDIA_TYPE} = ?",
   QUERY_ARG_SQL_SELECTION_ARGS to arrayOf(
       FileColumns.MEDIA_TYPE_IMAGE.toString(),
       FileColumns.MEDIA_TYPE_VIDEO.toString()
   )
)

Uri externalContentUri = MediaStore.Files.getContentUri("external");

String[] mediaColumns = {
    FileColumns._ID,
    FileColumns.DISPLAY_NAME,
    FileColumns.MIME_TYPE
};

Bundle queryArgs = new Bundle();
queryArgs.putBoolean(MediaStore.QUERY_ARG_LATEST_SELECTION_ONLY, true);
queryArgs.putString(MediaStore.QUERY_ARG_SQL_SORT_ORDER, FileColumns.DATE_ADDED + " DESC");
queryArgs.putString(MediaStore.QUERY_ARG_SQL_SELECTION, FileColumns.MEDIA_TYPE + " = ? OR " + FileColumns.MEDIA_TYPE + " = ?");
queryArgs.putStringArray(MediaStore.QUERY_ARG_SQL_SELECTION_ARGS, new String[] {
    String.valueOf(FileColumns.MEDIA_TYPE_IMAGE),
    String.valueOf(FileColumns.MEDIA_TYPE_VIDEO)
});

Privacy Sandbox en Android

Android 15 includes the latest Android Ad Services extensions, incorporating the latest version of the Privacy Sandbox on Android. This addition is part of our work to develop new technologies that improve user privacy and enable effective, personalized advertising experiences for mobile apps. Our privacy sandbox page has more information about the Privacy Sandbox on Android developer preview and beta programs to help you get started.

Health Connect

Android 15 integra las extensiones más recientes de Health Connect de Android, una plataforma segura y centralizada para administrar y compartir los datos de salud y fitness recopilados por la app. Esta actualización agrega compatibilidad con nuevos tipos de datos de estado físico, nutrición, temperatura cutánea, planes de entrenamiento y más.

El monitoreo de la temperatura cutánea permite a los usuarios almacenar y compartir datos más precisos sobre la temperatura desde un wearable o cualquier otro dispositivo de monitoreo.

Los planes de entrenamiento son planes de entrenamiento estructurados que ayudan a un usuario a lograr sus objetivos de entrenamiento. La compatibilidad con los planes de entrenamiento incluye una variedad de objetivos de finalización y rendimiento:

• Objetivos de finalización en torno a calorías quemadas, distancia, duración, repetición y pasos.
• Objetivos de rendimiento en torno a la mayor cantidad de repeticiones como sea posible (AMRAP), cadencia, frecuencia cardíaca, potencia, frecuencia percibida de esfuerzo y velocidad.

Obtén más información sobre las actualizaciones más recientes de Health Connect en Android en la charla Cómo compilar experiencias adaptables con Android Health de Google I/O.

Compartir pantalla parcialmente

Android 15 admite el uso compartido parcial de la pantalla, de modo que los usuarios puedan compartir o grabar solo una ventana de la app en lugar de toda la pantalla del dispositivo. Esta función, habilitada por primera vez en QPR2 para Android 14, incluye devoluciones de llamada de MediaProjection que permiten que tu app personalice la experiencia de compartir pantalla de forma parcial. Ten en cuenta que, en el caso de las apps orientadas a Android 14 (nivel de API 34) o versiones posteriores, ahora se requiere el consentimiento del usuario para cada sesión de captura de MediaProjection.

IU del sistema y experiencia del usuario

Android 15 ofrece a los desarrolladores y usuarios de apps más control y flexibilidad para configurar sus dispositivos en función de sus necesidades.

Si quieres obtener más información sobre el uso de las mejoras más recientes de Android 15 para optimizar la experiencia del usuario de tu app, consulta el diálogo de Google I/O Cómo mejorar la experiencia del usuario de tu app para Android.

Vistas previas de widgets más completas con la API de Generated Previews

Before Android 15, the only way to provide widget picker previews was to specify a static image or layout resource. These previews often differ significantly from the look of the actual widget when it is placed on the home screen. Also, static resources can't be created with Jetpack Glance, so a Glance developer had to screenshot their widget or create an XML layout to have a widget preview.

Android 15 adds support for generated previews. This means that app widget providers can generate RemoteViews to use as the picker preview, instead of a static resource.

Push API

Apps can provide generated previews through a push API. Apps can provide previews at any point in their lifecycle, and don't receive an explicit request from the host to provide previews. Previews are persisted in AppWidgetService, and hosts can request them on-demand. The following example loads an XML widget layout resource and sets it as the preview:

AppWidgetManager.getInstance(appContext).setWidgetPreview(
   ComponentName(
       appContext,
       SociaLiteAppWidgetReceiver::class.java
   ),
   AppWidgetProviderInfo.WIDGET_CATEGORY_HOME_SCREEN,
   RemoteViews("com.example", R.layout.widget_preview)
)

The expected flow is:

1. At any time, the widget provider calls setWidgetPreview. The provided previews are persisted in AppWidgetService with other provider info.
2. setWidgetPreview notifies hosts of an updated preview through the AppWidgetHost.onProvidersChanged callback. In response, the widget host reloads all of its provider information.
3. When displaying a widget preview, the host checks AppWidgetProviderInfo.generatedPreviewCategories, and if the chosen category is available, calls AppWidgetManager.getWidgetPreview to return the saved preview for this provider.

When to call setWidgetPreview

Because there is no callback to provide previews, apps can choose to send previews at any point when they are running. How often to update the preview depends on the widget's use case.

The following list describes the two main categories of preview use cases:

• Providers that show real data in their widget previews, such as personalized or recent information. These providers can set the preview once the user has signed in or has done initial configuration in their app. After this, they can set up a periodic task to update the previews at their chosen cadence. Examples of this type of widget could be a photo, calendar, weather or news widget.
• Providers that show static information in previews or quick-action widgets that don't display any data. These providers can set previews once, when the app first launches. Examples of this type of widget include a drive quick actions widget or chrome shortcuts widget.

Some providers might show static previews on the hub mode picker, but real information on the homescreen picker. These providers should follow the guidance for both of these use cases to set previews.

Pantalla en pantalla

Android 15 introduces new changes in Picture-in-Picture (PiP) ensuring an even smoother transition when entering into PiP mode. This will be beneficial for apps having UI elements overlaid on top of their main UI, which goes into PiP.

Developers use the onPictureInPictureModeChanged callback to define logic that toggles the visibility of the overlaid UI elements. This callback is triggered when the PiP enter or exit animation is completed. Beginning in Android 15, the PictureInPictureUiState class includes a new state.

With this new UI state, apps targeting Android 15 will observe the Activity#onPictureInPictureUiStateChanged callback being invoked with isTransitioningToPip() as soon as the PiP animation starts. There are many UI elements that are not relevant for the app when it is in PiP mode, for example views or layout that include information such as suggestions, upcoming video, ratings, and titles. When the app goes to PiP mode, use the onPictureInPictureUiStateChanged callback to hide these UI elements. When the app goes to full screen mode from the PiP window, use onPictureInPictureModeChanged callback to unhide these elements, as shown in the following examples:

override fun onPictureInPictureUiStateChanged(pipState: PictureInPictureUiState) {
        if (pipState.isTransitioningToPip()) {
          // Hide UI elements
        }
    }

override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {
        if (isInPictureInPictureMode) {
          // Unhide UI elements
        }
    }

This quick visibility toggle of irrelevant UI elements (for a PiP window) helps ensure a smoother and flicker-free PiP enter animation.

Mejora de las reglas de No interrumpir

AutomaticZenRule lets apps customize Attention Management (Do Not Disturb) rules and decide when to activate or deactivate them. Android 15 greatly enhances these rules with the goal of improving the user experience. The following enhancements are included:

• Adding types to AutomaticZenRule, allowing the system to apply special treatment to some rules.
• Adding an icon to AutomaticZenRule, helping to make the modes be more recognizable.
• Adding a triggerDescription string to AutomaticZenRule that describes the conditions on which the rule should become active for the user.
• Added ZenDeviceEffects to AutomaticZenRule, allowing rules to trigger things like grayscale display, night mode, or dimming the wallpaper.

Cómo establecer VibrationEffect para los canales de notificaciones

Android 15 admite la configuración de vibraciones enriquecidas para notificaciones entrantes por canal con NotificationChannel.setVibrationEffect, de modo que los usuarios puedan distinguir entre diferentes tipos de notificaciones sin tener que mirar el dispositivo.

Pantallas y factores de forma grandes

Android 15 brinda a tus apps la compatibilidad para aprovechar al máximo los factores de forma de Android, incluidas las pantallas grandes, los dispositivos plegables y los dispositivos plegables.

Mejora de la realización de varias tareas a la vez en pantalla grande

Android 15 gives users better ways to multitask on large screen devices. For example, users can save their favorite split-screen app combinations for quick access and pin the taskbar on screen to quickly switch between apps. This means that making sure your app is adaptive is more important than ever.

Google I/O has sessions on Building adaptive Android apps and Building UI with the Material 3 adaptive library that can help, and our documentation has more to help you Design for large screens.

Compatibilidad con pantallas de portada

Tu app puede declarar una propiedad que Android 15 usa para permitir que tu Application o Activity se presente en las pequeñas pantallas de portada de los dispositivos que admiten la pantalla abatible. Estas pantallas son demasiado pequeñas para considerarlas como objetivos compatibles de modo que las apps para Android se ejecuten en ellas, pero tu app puede aceptar admitirlas, lo que hará que esté disponible en más lugares.

Conectividad

Android 15 actualiza la plataforma para que tu app pueda acceder a los avances más recientes en tecnologías inalámbricas y de comunicación.

Compatibilidad con satélites

Android 15 continúa ampliando la compatibilidad de plataforma para la conectividad satelital e incluye algunos elementos de la IU para garantizar una experiencia del usuario coherente en todo el panorama de conectividad satelital.

Las apps pueden usar ServiceState.isUsingNonTerrestrialNetwork() para detectar cuándo un dispositivo está conectado a un satélite, lo que les permite conocer mejor el motivo por el que los servicios de red completa podrían no estar disponibles. Además, Android 15 admite apps de SMS y MMS, así como apps de RCS precargadas para usar la conectividad satelital para enviar y recibir mensajes.

Experiencias NFC más fluidas

Android 15 está trabajando para que la experiencia de pago sin contacto sea más fluida y confiable mientras sigue admitiendo el sólido ecosistema de apps NFC de Android. En los dispositivos compatibles, las apps pueden solicitar a NfcAdapter que ingrese al modo de observación, en el que el dispositivo escucha, pero no responde a los lectores de NFC, y envía los objetos PollingFrame del servicio NFC de la app para procesarlos. Los objetos PollingFrame se pueden usar para autenticar antes de la primera comunicación con el lector de NFC, lo que permite una transacción de un toque en muchos casos.

Además, las apps ahora pueden registrar un filtro en los dispositivos compatibles para que se les notifique la actividad del bucle de sondeo, lo que permite un funcionamiento sin problemas con varias aplicaciones compatibles con NFC.

Rol de Billetera

Android 15 introduce un nuevo rol de Billetera que permite una mayor integración con la app de Billetera preferida del usuario. Este rol reemplaza la configuración predeterminada de pago sin contacto de NFC. Para administrar el titular de la función de Billetera, los usuarios pueden navegar a Configuración > Apps > Apps predeterminadas.

El rol de billetera se usa cuando se enrutan los toques de NFC para los AID registrados en la categoría de pago. Los pagos siempre se dirigen al titular del rol de la Billetera, a menos que se ejecute en primer plano otra app registrada para el mismo AID.

Este rol también se usa para determinar dónde debe ir la tarjeta de Acceso rápido a la Billetera cuando se active. Cuando la función se establece en "None", la tarjeta de QuickAccess no está disponible y los toques de NFC de la categoría de pago solo se entregan a la app en primer plano.

Seguridad

Android 15 te ayuda a mejorar la seguridad de tu app, proteger sus datos y les brinda a los usuarios más transparencia y control sobre sus datos. Consulta la charla Cómo proteger la seguridad del usuario en Android de Google I/O si deseas obtener más información sobre lo que hacemos para mejorar la protección de los usuarios y proteger tu app contra nuevas amenazas.

Cómo integrar Credential Manager con la función Autocompletar

Starting with Android 15, developers can link specific views like username or password fields with Credential Manager requests, making it easier to provide a tailored user experience during the sign-in process. When the user focuses on one of these views, a corresponding request is sent to Credential Manager. The resulting credentials are aggregated across providers and displayed in autofill fallback UIs, such as inline suggestions or drop-down suggestions. The Jetpack androidx.credentials library is the preferred endpoint for developers to use and will soon be available to further enhance this feature in Android 15 and higher.

Integra el registro y el acceso con un solo toque con instrucciones biométricas

Credential Manager integrates biometric prompts into the credential creation and sign-in processes, eliminating the need for providers to manage biometric prompts. As a result, credential providers only need to focus on the results of the create and get flows, augmented with the biometric flow result. This simplified process creates a more efficient and streamlined credential creation and retrieval process.

Administración de claves para la encriptación de extremo a extremo

Presentamos E2eeContactKeysManager en Android 15, que facilita la encriptación de extremo a extremo (E2EE) en tus apps para Android mediante una API a nivel del SO destinada al almacenamiento de claves públicas criptográficas.

El E2eeContactKeysManager está diseñado para integrarse con la app de contactos de la plataforma a fin de brindarles a los usuarios una forma centralizada de administrar y verificar las claves públicas de sus contactos.

Comprobaciones de permisos en URI de contenido

Android 15 introduces a new set of APIs that perform permission checks on content URIs:

• Context.checkContentUriPermissionFull: This performs a full permission check on content URIs.
• Activity manifest attribute requireContentUriPermissionFromCaller: This enforces specified permissions on the provided content URIs at activity launch.
• ComponentCaller class for Activity callers: This represents the app that launched the activity.

Accesibilidad

En Android 15, se agregan funciones que mejoran la accesibilidad para los usuarios.

Mejor braille

En Android 15, permitimos que TalkBack admita pantallas braille que usen el estándar HID a través de USB y Bluetooth seguro.

Este estándar, al igual que el que se usa en mouse y teclados, ayudará a Android a admitir una mayor variedad de pantallas braille con el tiempo.

Internacionalización

En Android 15, se agregan funciones y capacidades que complementan la experiencia del usuario cuando un dispositivo se usa en diferentes idiomas.

Fuente variable CJK

A partir de Android 15, NotoSansCJK, el archivo de fuente para los idiomas chino, japonés y coreano (CJK), ahora es una fuente variable. Las fuentes variables ofrecen nuevas posibilidades para la tipografía creativa en lenguajes CJK. Los diseñadores pueden explorar una gama más amplia de estilos y crear diseños visualmente atractivos que antes eran difíciles o imposibles de lograr.

Justificación entre caracteres

A partir de Android 15, se puede justificar el texto utilizando el espaciado entre letras con JUSTIFICATION_MODE_INTER_CHARACTER. La justificación entre palabras se introdujo por primera vez en Android 8.0 (nivel de API 26), y la justificación entre caracteres proporciona capacidades similares para idiomas que usan el carácter de espacio en blanco para la segmentación, como el chino, el japonés y otros.

Diseño para texto en japonés con JUSTIFICATION_MODE_NONE

Diseño para texto en inglés con JUSTIFICATION_MODE_NONE

Diseño para texto en japonés con JUSTIFICATION_MODE_INTER_WORD

Diseño para texto en inglés con JUSTIFICATION_MODE_INTER_WORD

Diseño para texto en japonés con el nuevo JUSTIFICATION_MODE_INTER_CHARACTER

Diseño para texto en inglés con el nuevo JUSTIFICATION_MODE_INTER_CHARACTER

Configuración de salto de línea automático

Android started supporting phrase-based line breaks for Japanese and Korean in Android 13 (API level 33). However, while phrase-based line breaks improve the readability of short lines of text, they don't work well for long lines of text. In Android 15, apps can now apply phrase-based line breaks only for short lines of text, using the LINE_BREAK_WORD_STYLE_AUTO option. This option selects the best word style option for the text.

For short lines of text, phrase-based line breaks are used, functioning the same as LINE_BREAK_WORD_STYLE_PHRASE, as shown in the following image:

For longer lines of text, LINE_BREAK_WORD_STYLE_AUTO uses a no line-break word style, functioning the same as LINE_BREAK_WORD_STYLE_NONE, as shown in the following image:

Nueva fuente japonesa hentaigana

En Android 15, se incluye de forma predeterminada un archivo de fuentes nuevo para el antiguo hiragana japonés (conocido como Hentaigana). Las formas únicas de los personajes de Hentaigana pueden agregar un toque distintivo al material gráfico o al diseño, y ayudar a preservar la transmisión y la comprensión exactas de los documentos japoneses antiguos.

Cono VideoLAN Copyright (c) 1996-2010 VideoLAN. Cualquier persona puede usar o modificar este logotipo o una versión modificada para hacer referencia al proyecto de VideoLAN o a cualquier producto desarrollado por el equipo de VideoLAN, pero no indica que el proyecto cuente con su respaldo.

Vulkan y el logotipo de Vulkan son marcas registradas de Khronos Group Inc.

OpenGL es una marca registrada, y el logotipo de OpenGL ES es una marca de Hewlett Packard Enterprise que Khronos utiliza con el permiso.