Android 14 incluye excelentes funciones y APIs para desarrolladores. A continuación, encontrarás información sobre las funciones de tus apps y cómo comenzar a usar las APIs relacionadas.
Para obtener una lista detallada de las APIs agregadas, modificadas y quitadas, lee el informe de diferencias de API. Para obtener detalles sobre las APIs agregadas, consulta la referencia de la API de Android. Para Android 14, busca las APIs que se agregaron en el nivel de API 34. Para obtener información sobre las áreas en las que los cambios de la plataforma podrían afectar a tus apps, asegúrate de revisar los cambios en el comportamiento de Android 14 para apps orientadas a Android 14 y para todas las apps.
Internacionalización
Preferencias de idioma de las apps
Android 14 expands on the per-app language features that were introduced in Android 13 (API level 33) with these additional capabilities:
Automatically generate an app's
localeConfig
: Starting with Android Studio Giraffe Canary 7 and AGP 8.1.0-alpha07, you can configure your app to support per-app language preferences automatically. Based on your project resources, the Android Gradle plugin generates theLocaleConfig
file and adds a reference to it in the final manifest file, so you no longer have to create or update the file manually. AGP uses the resources in theres
folders of your app modules and any library module dependencies to determine the locales to include in theLocaleConfig
file.Dynamic updates for an app's
localeConfig
: Use thesetOverrideLocaleConfig()
andgetOverrideLocaleConfig()
methods inLocaleManager
to dynamically update your app's list of supported languages in the device's system settings. Use this flexibility to customize the list of supported languages per region, run A/B experiments, or provide an updated list of locales if your app utilizes server-side pushes for localization.App language visibility for input method editors (IMEs): IMEs can utilize the
getApplicationLocales()
method to check the language of the current app and match the IME language to that language.
API de Grammatical Inflection
Tres mil millones de personas hablan idiomas con género, es decir, idiomas en los que las categorías gramaticales, como sustantivos, verbos, adjetivos y preposiciones, inflexionan según el género de las personas y los objetos con las que te comunicas o sobre los que hablas. Tradicionalmente, muchos idiomas con género usan el género gramatical masculino como el género predeterminado o genérico.
Dirigirse a usuarios con un género gramatical incorrecto, por ejemplo, a mujeres con género gramatical masculino, puede tener un impacto negativo en su rendimiento y actitud. Por el contrario, una IU con un lenguaje que refleja, de forma correcta, el género gramatical del usuario puede mejorar su participación y proporcionar una experiencia más personalizada y más natural.
Para ayudarte a compilar una IU centrada en el usuario para idiomas con inflexión de género, Android 14 introduce la API de Grammatical Inflection, que te permite agregar compatibilidad con el género gramatical sin refactorizar la app.
Preferencias regionales
Las preferencias regionales permiten que los usuarios personalicen las unidades de temperatura, el primer día de la semana y los sistemas de numeración. Una persona europea que vive en los Estados Unidos podría preferir que las unidades de temperatura estén en Celsius en lugar de Fahrenheit y que las apps consideren el lunes como comienzo de la semana en lugar de los domingos, la opción predeterminada en EE.UU.
Los nuevos menús de configuración de Android para estas preferencias les proporcionan a los usuarios una ubicación detectable y centralizada para cambiar las preferencias de las apps. Estas preferencias también se mantienen en copias de seguridad y restablecimientos. Varias APIs y algunos intents, como getTemperatureUnit
y getFirstDayOfWeek
, le otorgan a tu app acceso de lectura a las preferencias de los usuarios, por lo que tu app puede ajustar la forma en que muestra la información. También puedes registrar un BroadcastReceiver
en ACTION_LOCALE_CHANGED
para controlar los cambios de configuración regional cuando cambien las preferencias regionales.
Para encontrar esta configuración, abre la app de Configuración y dirígete a Sistema > Idiomas y entrada > Preferencias regionales.
![](https://developer.android.com/static/about/versions/14/images/regional-preferences.png?authuser=0000&hl=es)
![](https://developer.android.com/static/about/versions/14/images/regional-preferences-temperature.png?authuser=0000&hl=es)
Accesibilidad
Escalamiento de fuente no lineal al 200%
Starting in Android 14, the system supports font scaling up to 200%, providing low-vision users with additional accessibility options that align with Web Content Accessibility Guidelines (WCAG).
To prevent large text elements on screen from scaling too large, the system applies a nonlinear scaling curve. This scaling strategy means that large text doesn't scale at the same rate as smaller text. Nonlinear font scaling helps preserve the proportional hierarchy between elements of different sizes while mitigating issues with linear text scaling at high degrees (such as text being cut off or text that becomes harder to read due to an extremely large display sizes).
Test your app with nonlinear font scaling
![](https://developer.android.com/static/images/about/versions/14/accessibility-font-options.png?authuser=0000&hl=es)
If you already use scaled pixels (sp) units to define text sizing, then these additional options and scaling improvements are applied automatically to the text in your app. However, you should still perform UI testing with the maximum font size enabled (200%) to ensure that your app applies the font sizes correctly and can accommodate larger font sizes without impacting usability.
To enable 200% font size, follow these steps:
- Open the Settings app and navigate to Accessibility > Display size and text.
- For the Font size option, tap the plus (+) icon until the maximum font size setting is enabled, as shown in the image that accompanies this section.
Use scaled pixel (sp) units for text-sizes
Remember to always specify text sizes in sp units. When your app uses sp units, Android can apply the user's preferred text size and scale it appropriately.
Don't use sp units for padding or define view heights assuming implicit padding: with nonlinear font scaling sp dimensions might not be proportional, so 4sp + 20sp might not equal 24sp.
Convert scaled pixel (sp) units
Use TypedValue.applyDimension()
to convert from sp units
to pixels, and use TypedValue.deriveDimension()
to
convert pixels to sp. These methods apply the appropriate nonlinear scaling
curve automatically.
Avoid hardcoding equations using
Configuration.fontScale
or
DisplayMetrics.scaledDensity
. Because font scaling is
nonlinear, the scaledDensity
field is no longer accurate. The fontScale
field should be used for informational purposes only because fonts are no longer
scaled with a single scalar value.
Use sp units for lineHeight
Always define android:lineHeight
using sp units instead
of dp, so the line height scales along with your text. Otherwise, if your text
is sp but your lineHeight
is in dp or px, it doesn't scale and looks cramped.
TextView automatically corrects the lineHeight
so that your intended
proportions are preserved, but only if both textSize
and lineHeight
are
defined in sp units.
Cámara y contenido multimedia
Ultra HDR para imágenes
![](https://developer.android.com/static/images/about/versions/14/SDR-HDR-compare.png?authuser=0000&hl=es)
Android 14 adds support for High Dynamic Range (HDR) images that retain more of the information from the sensor when taking a photo, which enables vibrant colors and greater contrast. Android uses the Ultra HDR format, which is fully backward compatible with JPEG images, allowing apps to seamlessly interoperate with HDR images, displaying them in Standard Dynamic Range (SDR) as needed.
Rendering these images in the UI in HDR is done automatically by the framework
when your app opts in to using HDR UI for its Activity Window, either through a
manifest entry or at runtime by calling
Window.setColorMode()
. You can also capture compressed Ultra
HDR still images on supported devices. With more colors recovered
from the sensor, editing in post can be more flexible. The
Gainmap
associated with Ultra HDR images can be used to render
them using OpenGL or Vulkan.
Zoom, enfoque, postview y más en extensiones de cámara
Android 14 se actualiza y mejora las extensiones de cámara, lo que permite que las apps controlen tiempos de procesamiento más largos, lo que habilita imágenes mejoradas con algoritmos de procesamiento intensivo, como fotografías con poca luz en dispositivos compatibles. Estas funciones les brindan a los usuarios una experiencia aún más sólida cuando usan las capacidades de extensión de la cámara. Estos son algunos ejemplos de estas mejoras:
- La estimación dinámica de la latencia de procesamiento de capturas estáticas proporciona estimaciones de latencia de capturas igualmente precisas basadas en la escena y las condiciones del entorno actuales. Llama a
CameraExtensionSession.getRealtimeStillCaptureLatency()
para obtener un objetoStillCaptureLatency
que tenga dos métodos de estimación de latencia. El métodogetCaptureLatency()
muestra la latencia estimada entreonCaptureStarted
yonCaptureProcessStarted()
, y el métodogetProcessingLatency()
muestra la latencia estimada entreonCaptureProcessStarted()
y el fotograma procesado final que está disponible. - Compatibilidad con devoluciones de llamada de progreso de captura para que las apps puedan mostrar el progreso actual de operaciones de procesamiento de captura y de larga duración. Puedes verificar si esta función está disponible con
CameraExtensionCharacteristics.isCaptureProcessProgressAvailable
y, si lo está, implementa la devolución de llamadaonCaptureProcessProgressed()
, que tiene el progreso (de 0 a 100) pasado como parámetro. Metadatos específicos de extensiones, como
CaptureRequest.EXTENSION_STRENGTH
, para marcar la cantidad de un efecto de extensión (por ejemplo, el desenfoque del fondo conEXTENSION_BOKEH
)Función de posvista para la captura estática en las extensiones de la cámara, que proporciona una imagen menos procesada más rápido que la imagen final. Si una extensión aumentó la latencia de procesamiento, se podría proporcionar una imagen posterior a la vista como marcador de posición para mejorar la UX y cambiarla más tarde por la imagen final. Puedes verificar si esta función está disponible con
CameraExtensionCharacteristics.isPostviewAvailable
. Luego, puedes pasar unOutputConfiguration
aExtensionSessionConfiguration.setPostviewOutputConfiguration
.La compatibilidad con
SurfaceView
, lo que permite obtener una ruta de renderización de vista previa más optimizada y con mayor eficiencia energéticaCompatibilidad con la función de presionar para enfocar y hacer zoom durante el uso de la extensión.
Zoom en el sensor
When REQUEST_AVAILABLE_CAPABILITIES_STREAM_USE_CASE
in
CameraCharacteristics
contains
SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW
, your app
can use advanced sensor capabilities to give a cropped RAW stream the same
pixels as the full field of view by using a CaptureRequest
with a RAW target that has stream use case set to
CameraMetadata.SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW
.
By implementing the request override controls, the updated camera gives users
zoom control even before other camera controls are ready.
Audio USB sin pérdida
Android 14 gains support for lossless audio formats for audiophile-level
experiences over USB wired headsets. You can query a USB device for its
preferred mixer attributes, register a listener for changes in preferred mixer
attributes, and configure mixer attributes using the
AudioMixerAttributes
class. This class represents the
format, such as channel mask, sample rate, and behavior of the audio mixer. The
class allows for audio to be sent directly, without mixing,
volume adjustment, or processing effects.
Productividad y herramientas para desarrolladores
Administrador de credenciales
Android 14 adds Credential Manager as a platform API, with additional support back to Android 4.4 (API level 19) devices through a Jetpack Library using Google Play services. Credential Manager aims to make sign-in easier for users with APIs that retrieve and store credentials with user-configured credential providers. Credential Manager supports multiple sign-in methods, including username and password, passkeys, and federated sign-in solutions (such as Sign-in with Google) in a single API.
Passkeys provide many advantages. For example, passkeys are built on industry standards, can work across different operating systems and browser ecosystems, and can be used with both websites and apps.
For more information, see the Credential Manager and passkeys documentation and the blogpost about Credential Manager and passkeys.
Health Connect
Health Connect is an on-device repository for user health and fitness data. It allows users to share data between their favorite apps, with a single place to control what data they want to share with these apps.
On devices running Android versions prior to Android 14, Health Connect is available to download as an app on the Google Play store. Starting with Android 14, Health Connect is part of the platform and receives updates through Google Play system updates without requiring a separate download. With this, Health Connect can be updated frequently, and your apps can rely on Health Connect being available on devices running Android 14 or higher. Users can access Health Connect from the Settings in their device, with privacy controls integrated into the system settings.
![](https://developer.android.com/static/images/about/versions/14/health-connect-screen.png?authuser=0000&hl=es)
![](https://developer.android.com/static/images/about/versions/14/health-connect-permissions.png?authuser=0000&hl=es)
Health Connect includes several new features in Android 14, such as exercise routes, allowing users to share a route of their workout which can be visualized on a map. A route is defined as a list of locations saved within a window of time, and your app can insert routes into exercise sessions, tying them together. To ensure that users have complete control over this sensitive data, users must allow sharing individual routes with other apps.
For more information, see the Health Connection documentation and the blogpost on What's new in Android Health.
Actualizaciones de OpenJDK 17
Android 14 continues the work of refreshing Android's core libraries to align with the features in the latest OpenJDK LTS releases, including both library updates and Java 17 language support for app and platform developers.
The following features and improvements are included:
- Updated approximately 300
java.base
classes to Java 17 support. - Text Blocks, which introduce multi-line string literals to the Java programming language.
- Pattern Matching for instanceof, which allows an object to
be treated as having a specific type in an
instanceof
without any additional variables. - Sealed classes, which allow you restrict which classes and interfaces can extend or implement them.
Thanks to Google Play system updates (Project Mainline), over 600 million devices are enabled to receive the latest Android Runtime (ART) updates that include these changes. This is part of our commitment to give apps a more consistent, secure environment across devices, and to deliver new features and capabilities to users independent of platform releases.
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
Mejoras para tiendas de aplicaciones
Android 14 introduces several PackageInstaller
APIs that
allow app stores to improve their user experience.
Request install approval before downloading
Installing or updating an app might require user approval.
For example, when an installer making use of the
REQUEST_INSTALL_PACKAGES
permission attempts to install a
new app. In prior Android versions, app stores can only request user approval
after APKs are written to the install session and the
session is committed.
Starting with Android 14, the requestUserPreapproval()
method lets installers request user approval before committing the install
session. This improvement lets an app store defer downloading any APKs until
after the installation has been approved by the user. Furthermore, once a user
has approved installation, the app store can download and install the app in the
background without interrupting the user.
Claim responsibility for future updates
The setRequestUpdateOwnership()
method allows an installer
to indicate to the system that it intends to be responsible for future updates
to an app it is installing. This capability enables update ownership
enforcement, meaning that only the update owner is permitted
to install automatic updates to the app. Update ownership enforcement helps to
ensure that users receive updates only from the expected app store.
Any other installer, including those making use of the
INSTALL_PACKAGES
permission, must receive explicit user
approval in order to install an update. If a user decides to proceed with an
update from another source, update ownership is lost.
Update apps at less-disruptive times
App stores typically want to avoid updating an app that is actively in use because this leads to the app's running processes being killed, which potentially interrupts what the user was doing.
Starting with Android 14, the InstallConstraints
API
gives installers a way to ensure that their app updates happen at an opportune
moment. For example, an app store can call the
commitSessionAfterInstallConstraintsAreMet()
method to
make sure that an update is only committed when the user is no longer
interacting with the app in question.
Seamlessly install optional splits
With split APKs, features of an app can be delivered in separate APK files,
rather than as a monolithic APK. Split APKs allow app stores to optimize the
delivery of different app components. For example, app stores might optimize
based on the properties of the target device. The
PackageInstaller
API has supported splits since its
introduction in API level 22.
In Android 14, the setDontKillApp()
method allows an
installer to indicate that the app's running processes shouldn't be killed when
new splits are installed. App stores can use this feature to seamlessly install
new features of an app while the user is using the app.
Paquetes de metadatos de app
A partir de Android 14, el instalador del paquete de Android te permite especificar metadatos de la app, como las prácticas de seguridad de los datos, para incluir en las páginas de la tienda de aplicaciones, como Google Play.
Detecta cuando los usuarios toman capturas de pantalla del dispositivo
To create a more standardized experience for detecting screenshots, Android 14 introduces a privacy-preserving screenshot detection API. This API lets apps register callbacks on a per-activity basis. These callbacks are invoked, and the user is notified, when the user takes a screenshot while that activity is visible.
Experiencia del usuario
Acciones personalizadas y clasificación mejorada de Sharesheet
Android 14 updates the system sharesheet to support custom app actions and more informative preview results for users.
Add custom actions
With Android 14, your app can add custom actions to the system sharesheet it invokes.
![](https://developer.android.com/static/images/training/sharing/sharesheet_custom_actions.png?authuser=0000&hl=es)
Improve ranking of Direct Share targets
Android 14 uses more signals from apps to determine the ranking of the direct share targets to provide more helpful results for the user. To provide the most useful signal for ranking, follow the guidance for improving rankings of your Direct Share targets. Communication apps can also report shortcut usage for outgoing and incoming messages.
![](https://developer.android.com/static/training/sharing/direct-share-targets.png?authuser=0000&hl=es)
Compatibilidad con animaciones integradas y personalizadas para el gesto atrás predictivo
En Android 13, se introdujo la animación de atrás predictivo a la página principal detrás de una opción para desarrolladores. Cuando se usa en una app compatible que tiene habilitada la opción para desarrolladores, al deslizar hacia atrás, se muestra una animación que indica que el gesto de retroceso permite cerrar la app y regresar a la pantalla principal.
Android 14 incluye varias mejoras y orientación nueva para el gesto atrás predictivo:
- Puedes configurar
android:enableOnBackInvokedCallback=true
para habilitar las animaciones del sistema de atrás predictivo por actividad en lugar de para toda la app. - Agregamos nuevas animaciones del sistema para acompañar la animación de regreso a la pantalla principal de Android 13. Las nuevas animaciones del sistema son las de cambio de actividad y cambio de tarea, que obtienes automáticamente después de la migración al gesto atrás predictivo.
- Agregamos nuevas animaciones de componentes de material para las hojas inferiores, las hojas laterales y la búsqueda.
- Creamos una guía de diseño para crear transiciones y animaciones personalizadas en la app.
- Agregamos nuevas APIs para admitir animaciones de transición en la app:
handleOnBackStarted
,handleOnBackProgressed
yhandleOnBackCancelled
in
OnBackPressedCallback
onBackStarted
,onBackProgressed
yonBackCancelled
in
OnBackAnimationCallback
- Usa
overrideActivityTransition
en lugar deoverridePendingTransition
para las transiciones que responden cuando el usuario desliza el dedo hacia atrás
Con esta versión preliminar de Android 14, todas las funciones de atrás predictivo permanecen detrás de una opción para desarrolladores. Consulta la guía para desarrolladores para migrar tu app al gesto atrás predictivo, así como la guía para desarrolladores para crear transiciones personalizadas en la app.
Anulaciones por app del fabricante de dispositivos con pantallas grandes
Per-app overrides enable device manufacturers to change the behavior of apps on large screen devices. For example, the FORCE_RESIZE_APP
override instructs the system to resize the app to fit display dimensions (avoiding size compatibility mode) even if resizeableActivity="false"
is set in the app manifest.
Overrides are intended to improve the user experience on large screens.
New manifest properties enable you to disable some device manufacturer overrides for your app.
Anulaciones de usuario de pantalla grande por app
Per-app overrides change the behavior of apps on large screen devices. For example, the OVERRIDE_MIN_ASPECT_RATIO_LARGE
device manufacturer override sets the app aspect ratio to 16:9 regardless of the app's configuration.
Android 14 QPR1 enables users to apply per‑app overrides by means of a new settings menu on large screen devices.
Compartir pantalla de una app
La función para compartir pantalla de la app permite que los usuarios compartan una ventana de la app en lugar de toda la pantalla del dispositivo durante la grabación del contenido de la pantalla.
Cuando se comparte la pantalla de la app, la barra de estado, la barra de navegación, las notificaciones y otros elementos de la IU del sistema se excluyen de la pantalla compartida. Solo se comparte el contenido de la app seleccionada.
La función para compartir pantalla en las apps mejora la productividad y la privacidad, ya que permite que los usuarios ejecuten varias apps, pero limita el uso compartido de contenido a una sola app.
Respuesta inteligente potenciada por LLM en Gboard en el Pixel 8 Pro
On Pixel 8 Pro devices with the December Feature Drop, developers can try out higher-quality smart replies in Gboard powered by on-device Large Language Models (LLMs) running on Google Tensor.
This feature is available as a limited preview for US English in WhatsApp, Line, and KakaoTalk. It requires using a Pixel 8 Pro device with Gboard as your keyboard.
To try it out, first enable the feature in Settings > Developer Options > AiCore Settings > Enable Aicore Persistent.
Next, open a conversation in a supported app to see LLM-powered Smart Reply in Gboard's suggestion strip in response to incoming messages.
Gráficos
Las rutas de acceso se pueden consultar e interpolar
La API de Path
de Android es un mecanismo potente y flexible para crear y renderizar gráficos vectoriales, con la capacidad de trazar o rellenar una ruta, construir una ruta a partir de segmentos de líneas o curvas cuadráticas o cúbicas, realizar operaciones booleanas para obtener formas aún más complejas, o todo esto simultáneamente. Una limitación es la capacidad de descubrir lo que en realidad hay en un objeto Path; los componentes internos del objeto son opacos para los llamadores después de su creación.
Para crear un Path
, debes llamar a métodos, como moveTo()
, lineTo()
y cubicTo()
, para agregar segmentos de ruta. Sin embargo, no hay forma de preguntarle a esa ruta cuáles son los segmentos, por lo que debes conservar esa información en el momento de la creación.
A partir de Android 14, puedes consultar rutas de acceso para descubrir su contenido.
Primero, debes obtener un objeto PathIterator
con la API de Path.getPathIterator
:
Kotlin
val path = Path().apply { moveTo(1.0f, 1.0f) lineTo(2.0f, 2.0f) close() } val pathIterator = path.pathIterator
Java
Path path = new Path(); path.moveTo(1.0F, 1.0F); path.lineTo(2.0F, 2.0F); path.close(); PathIterator pathIterator = path.getPathIterator();
A continuación, puedes llamar a PathIterator
para iterar a través de los segmentos uno por uno y recuperar todos los datos necesarios de cada segmento. En este ejemplo, se usan objetos PathIterator.Segment
, que agrupan los datos por ti:
Kotlin
for (segment in pathIterator) { println("segment: ${segment.verb}, ${segment.points}") }
Java
while (pathIterator.hasNext()) { PathIterator.Segment segment = pathIterator.next(); Log.i(LOG_TAG, "segment: " + segment.getVerb() + ", " + segment.getPoints()); }
PathIterator
también tiene una versión de next()
no asignable en la que puedes pasar un búfer para contener los datos de puntos.
Uno de los casos de uso importantes para consultar datos de Path
es la interpolación. Por ejemplo, es posible que quieras animar (o transformar) entre dos rutas diferentes. Para simplificar aún más ese caso de uso, Android 14 también incluye el método interpolate()
en Path
. Si suponemos que las dos rutas de acceso tienen la misma estructura interna, el método interpolate()
crea un nuevo objeto Path
con ese resultado interpolado. En este ejemplo, se muestra una ruta cuya forma está a mitad de camino (una interpolación lineal de 0 .5) entre path
y otherPath
:
Kotlin
val interpolatedResult = Path() if (path.isInterpolatable(otherPath)) { path.interpolate(otherPath, .5f, interpolatedResult) }
Java
Path interpolatedResult = new Path(); if (path.isInterpolatable(otherPath)) { path.interpolate(otherPath, 0.5F, interpolatedResult); }
La biblioteca graphics-path de Jetpack también habilita APIs similares para versiones anteriores de Android.
Mallas personalizadas con vértices y sombreadores de fragmentos
Android has long supported drawing triangle meshes with custom shading, but the input mesh format has been limited to a few predefined attribute combinations. Android 14 adds support for custom meshes, which can be defined as triangles or triangle strips, and can, optionally, be indexed. These meshes are specified with custom attributes, vertex strides, varying, and vertex and fragment shaders written in AGSL.
The vertex shader defines the varyings, such as position and color, while the
fragment shader can optionally define the color for the pixel, typically by
using the varyings created by the vertex shader. If color is provided by the
fragment shader, it is then blended with the current Paint
color using the blend mode selected when
drawing the mesh. Uniforms can be passed
into the fragment and vertex shaders for additional flexibility.
Renderizador del búfer de hardware para Canvas
To assist in using Android's Canvas
API to draw with
hardware acceleration into a HardwareBuffer
, Android 14
introduces HardwareBufferRenderer
. This API is
particularly useful when your use case involves communication with the system
compositor through SurfaceControl
for low-latency
drawing.