Como nas versões anteriores, o Android 15 inclui mudanças de comportamento que podem afetar seu app. As seguintes mudanças de comportamento se aplicam exclusivamente a apps direcionados ao Android 15 ou mais recente. Caso seu app seja destinado ao Android 15 ou mais recente, modifique-o para que ele ofereça suporte a esses comportamentos, quando aplicável.
Consulte também a lista de mudanças de comportamento que afetam todos os apps
executados no Android 15, independente da targetSdkVersion
do app.
Principal recurso
O Android 15 modifica ou expande vários recursos principais do sistema Android.
Mudanças nos serviços em primeiro plano
We are making the following changes to foreground services with Android 15.
- Data sync foreground service timeout behavior
- New media processing foreground service type
- Restrictions on
BOOT_COMPLETED
broadcast receivers launching foreground services - Restrictions on starting foreground services while an app holds the
SYSTEM_ALERT_WINDOW
permission
Data sync foreground service timeout behavior
O Android 15 apresenta um novo comportamento de tempo limite para dataSync
em apps destinados
ao Android 15 (nível 35 da API) ou mais recente. Esse comportamento também se aplica ao novo
tipo de serviço em primeiro plano mediaProcessing
.
O sistema permite que os serviços dataSync
de um app sejam executados por um total de 6 horas
em um período de 24 horas. Depois disso, o sistema chama o método
Service.onTimeout(int, int)
do serviço em execução (introduzido no Android
15). No momento, o serviço tem alguns segundos para chamar
Service.stopSelf()
. Quando Service.onTimeout()
é chamado, o
serviço não é mais considerado um serviço em primeiro plano. Se o serviço não
chamar Service.stopSelf()
, o sistema vai gerar uma exceção interna. A
exceção é registrada no Logcat com a seguinte mensagem:
Fatal Exception: android.app.RemoteServiceException: "A foreground service of
type dataSync did not stop within its timeout: [component name]"
Para evitar problemas com essa mudança de comportamento, é possível fazer uma ou mais das seguintes:
- Faça com que o serviço implemente o novo método
Service.onTimeout(int, int)
. Quando o app receber o callback, chamestopSelf()
em alguns segundos. Se você não parar o app imediatamente, o sistema vai gerar uma falha. - Os serviços
dataSync
do app não podem ser executados por mais de 6 horas em um período de 24 horas (a menos que o usuário interaja com o app, redefinindo o timer). - Só inicie serviços em primeiro plano
dataSync
como resultado da interação direta do usuário. Como o app está em primeiro plano quando o serviço é iniciado, ele tem seis horas completas após o app ir para o segundo plano. - Em vez de usar um serviço em primeiro plano
dataSync
, use uma API alternativa.
Se os serviços em primeiro plano dataSync
do app tiverem sido executados por seis horas nas últimas
24 horas, não será possível iniciar outro serviço em primeiro plano dataSync
a menos que o usuário
tenha trazido o app para o primeiro plano, o que redefine o timer. Se você tentar
iniciar outro serviço em primeiro plano dataSync
, o sistema vai gerar
ForegroundServiceStartNotAllowedException
com uma mensagem de erro como "O limite de tempo já foi esgotado para o tipo de serviço
em primeiro plano dataSync".
Teste
Para testar o comportamento do app, é possível ativar tempos limite de sincronização de dados mesmo que o app
não seja destinado ao Android 15, desde que esteja em execução em um dispositivo
Android 15. Para ativar os tempos limite, execute o comando adb
:
adb shell am compat enable FGS_INTRODUCE_TIME_LIMITS your-package-name
Você também pode ajustar o período de tempo limite para facilitar o teste do comportamento
do app quando o limite for atingido. Para definir um novo período de tempo limite, execute o seguinte comando adb
:
adb shell device_config put activity_manager data_sync_fgs_timeout_duration duration-in-milliseconds
New media processing foreground service type
Android 15 introduces a new foreground service type, mediaProcessing
. This
service type is appropriate for operations like transcoding media files. For
example, a media app might download an audio file and need to convert it to a
different format before playing it. You can use a mediaProcessing
foreground
service to make sure the conversion continues even while the app is in the
background.
The system permits an app's mediaProcessing
services to run for a total of 6
hours in a 24-hour period, after which the system calls the running service's
Service.onTimeout(int, int)
method (introduced in Android
15). At this time, the service has a few seconds to call
Service.stopSelf()
. If the service does not
call Service.stopSelf()
, the system throws an internal exception. The
exception is logged in Logcat with the following message:
Fatal Exception: android.app.RemoteServiceException: "A foreground service of
type mediaProcessing did not stop within its timeout: [component name]"
To avoid having the exception, you can do one of the following:
- Have your service implement the new
Service.onTimeout(int, int)
method. When your app receives the callback, make sure to callstopSelf()
within a few seconds. (If you don't stop the app right away, the system generates a failure.) - Make sure your app's
mediaProcessing
services don't run for more than a total of 6 hours in any 24-hour period (unless the user interacts with the app, resetting the timer). - Only start
mediaProcessing
foreground services as a result of direct user interaction; since your app is in the foreground when the service starts, your service has the full six hours after the app goes to the background. - Instead of using a
mediaProcessing
foreground service, use an alternative API, like WorkManager.
If your app's mediaProcessing
foreground services have run for 6 hours in the
last 24, you cannot start another mediaProcessing
foreground service unless
the user has brought your app to the foreground (which resets the timer). If you
try to start another mediaProcessing
foreground service, the system throws
ForegroundServiceStartNotAllowedException
with an error message like "Time limit already exhausted for foreground service
type mediaProcessing".
For more information about the mediaProcessing
service type, see Changes to
foreground service types for Android 15: Media processing.
Testing
To test your app's behavior, you can enable media processing timeouts even if
your app is not targeting Android 15 (as long as the app is running on an
Android 15 device). To enable timeouts, run the following adb
command:
adb shell am compat enable FGS_INTRODUCE_TIME_LIMITS your-package-name
You can also adjust the timeout period, to make it easier to test how your
app behaves when the limit is reached. To set a new timeout period, run the
following adb
command:
adb shell device_config put activity_manager media_processing_fgs_timeout_duration duration-in-milliseconds
Restrictions on BOOT_COMPLETED
broadcast receivers launching foreground services
There are new restrictions on BOOT_COMPLETED
broadcast receivers launching
foreground services. BOOT_COMPLETED
receivers are not allowed to launch the
following types of foreground services:
dataSync
camera
mediaPlayback
phoneCall
mediaProjection
microphone
(this restriction has been in place formicrophone
since Android 14)
If a BOOT_COMPLETED
receiver tries to launch any of those types of foreground
services, the system throws ForegroundServiceStartNotAllowedException
.
Testing
To test your app's behavior, you can enable these new restrictions even if your
app is not targeting Android 15 (as long as the app is running on an Android 15
device). Run the following adb
command:
adb shell am compat enable FGS_BOOT_COMPLETED_RESTRICTIONS your-package-name
To send a BOOT_COMPLETED
broadcast without restarting the device,
run the following adb
command:
adb shell am broadcast -a android.intent.action.BOOT_COMPLETED your-package-name
Restrictions on starting foreground services while an app holds the SYSTEM_ALERT_WINDOW
permission
Anteriormente, se um app tivesse a permissão SYSTEM_ALERT_WINDOW
, ele poderia iniciar
um serviço em primeiro plano mesmo que estivesse em segundo plano (conforme
discutido em isenção de restrições de início em segundo plano).
Se um app for destinado ao Android 15, essa isenção será mais restrita. Agora o app precisa
ter a permissão SYSTEM_ALERT_WINDOW
e também ter uma janela de sobreposição
visível. Ou seja, o app precisa primeiro abrir uma
janela TYPE_APPLICATION_OVERLAY
e a janela
precisa estar visível antes de iniciar um serviço em primeiro plano.
Se o app tentar iniciar um serviço em primeiro plano em segundo plano sem
atender a esses novos requisitos (e não tiver outra isenção), o
sistema vai gerar uma ForegroundServiceStartNotAllowedException
.
Se o app declarar a permissão SYSTEM_ALERT_WINDOW
e iniciar serviços em primeiro plano em segundo plano, ele poderá ser afetado por essa
mudança. Se o app receber uma ForegroundServiceStartNotAllowedException
, verifique
a ordem das operações e verifique se ele já tem uma janela de sobreposição
ativa antes de tentar iniciar um serviço em primeiro plano em segundo
plano. Você pode conferir se a janela de sobreposição está visível
chamando View.getWindowVisibility()
ou
substituir View.onWindowVisibilityChanged()
para receber uma notificação sempre que a visibilidade mudar.
Teste
Para testar o comportamento do app, ative essas novas restrições mesmo que ele
não seja direcionado ao Android 15, desde que esteja sendo executado em um dispositivo
Android 15. Para ativar essas novas restrições na inicialização de serviços em primeiro plano
em segundo plano, execute este comando adb
:
adb shell am compat enable FGS_SAW_RESTRICTIONS your-package-name
Mudanças na hora em que os apps podem modificar o estado global do modo "Não perturbe"
Os apps direcionados ao Android 15 (nível 35 da API) e mais recentes não podem mais mudar o
estado global ou a política de Não perturbe (DND, na sigla em inglês) em um dispositivo, seja modificando
as configurações do usuário ou desativando o modo DND. Em vez disso, os apps precisam contribuir com um
AutomaticZenRule
, que o sistema combina em uma política global com o
esquema de política mais restritiva. As chamadas para APIs que
afetam o estado global (setInterruptionFilter
,
setNotificationPolicy
) resultam na criação ou atualização de um
AutomaticZenRule
implícito, que é ativado e desativado dependendo do ciclo de chamadas
dessas chamadas de API.
Essa mudança só afeta o comportamento observável se o app estiver chamando
setInterruptionFilter(INTERRUPTION_FILTER_ALL)
e esperar que essa chamada desative uma AutomaticZenRule
que foi ativada anteriormente pelos proprietários.
Mudanças na API do OpenJDK
Android 15 continues the work of refreshing Android's core libraries to align with the features in the latest OpenJDK LTS releases.
Some of these changes can affect app compatibility for apps targeting Android 15 (API level 35):
Changes to string formatting APIs: Validation of argument index, flags, width, and precision are now more strict when using the following
String.format()
andFormatter.format()
APIs:String.format(String, Object[])
String.format(Locale, String, Object[])
Formatter.format(String, Object[])
Formatter.format(Locale, String, Object[])
For example, the following exception is thrown when an argument index of 0 is used (
%0
in the format string):IllegalFormatArgumentIndexException: Illegal format argument index = 0
In this case, the issue can be fixed by using an argument index of 1 (
%1
in the format string).Changes to component type of
Arrays.asList(...).toArray()
: When usingArrays.asList(...).toArray()
, the component type of the resulting array is now anObject
—not the type of the underlying array's elements. So the following code throws aClassCastException
:String[] elements = (String[]) Arrays.asList("one", "two").toArray();
For this case, to preserve
String
as the component type in the resulting array, you could useCollection.toArray(Object[])
instead:String[] elements = Arrays.asList("two", "one").toArray(new String[0]);
Changes to language code handling: When using the
Locale
API, language codes for Hebrew, Yiddish, and Indonesian are no longer converted to their obsolete forms (Hebrew:iw
, Yiddish:ji
, and Indonesian:in
). When specifying the language code for one of these locales, use the codes from ISO 639-1 instead (Hebrew:he
, Yiddish:yi
, and Indonesian:id
).Changes to random int sequences: Following the changes made in https://bugs.openjdk.org/browse/JDK-8301574, the following
Random.ints()
methods now return a different sequence of numbers than theRandom.nextInt()
methods do:Generally, this change shouldn't result in app-breaking behavior, but your code shouldn't expect the sequence generated from
Random.ints()
methods to matchRandom.nextInt()
.
The new SequencedCollection
API can affect your app's compatibility
after you update compileSdk
in your app's build configuration to use
Android 15 (API level 35):
Collision with
MutableList.removeFirst()
andMutableList.removeLast()
extension functions inkotlin-stdlib
The
List
type in Java is mapped to theMutableList
type in Kotlin. Because theList.removeFirst()
andList.removeLast()
APIs have been introduced in Android 15 (API level 35), the Kotlin compiler resolves function calls, for examplelist.removeFirst()
, statically to the newList
APIs instead of to the extension functions inkotlin-stdlib
.If an app is re-compiled with
compileSdk
set to35
andminSdk
set to34
or lower, and then the app is run on Android 14 and lower, a runtime error is thrown:java.lang.NoSuchMethodError: No virtual method removeFirst()Ljava/lang/Object; in class Ljava/util/ArrayList;
The existing
NewApi
lint option in Android Gradle Plugin can catch these new API usages../gradlew lint
MainActivity.kt:41: Error: Call requires API level 35 (current min is 34): java.util.List#removeFirst [NewApi] list.removeFirst()To fix the runtime exception and lint errors, the
removeFirst()
andremoveLast()
function calls can be replaced withremoveAt(0)
andremoveAt(list.lastIndex)
respectively in Kotlin. If you're using Android Studio Ladybug | 2024.1.3 or higher, it also provides a quick fix option for these errors.Consider removing
@SuppressLint("NewApi")
andlintOptions { disable 'NewApi' }
if the lint option has been disabled.Collision with other methods in Java
New methods have been added into the existing types, for example,
List
andDeque
. These new methods might not be compatible with the methods with the same name and argument types in other interfaces and classes. In the case of a method signature collision with incompatibility, thejavac
compiler outputs a build-time error. For example:Example error 1:
javac MyList.java
MyList.java:135: error: removeLast() in MyList cannot implement removeLast() in List public void removeLast() { ^ return type void is not compatible with Object where E is a type-variable: E extends Object declared in interface ListExample error 2:
javac MyList.java
MyList.java:7: error: types Deque<Object> and List<Object> are incompatible; public class MyList implements List<Object>, Deque<Object> { both define reversed(), but with unrelated return types 1 errorExample error 3:
javac MyList.java
MyList.java:43: error: types List<E#1> and MyInterface<E#2> are incompatible; public static class MyList implements List<Object>, MyInterface<Object> { class MyList inherits unrelated defaults for getFirst() from types List and MyInterface where E#1,E#2 are type-variables: E#1 extends Object declared in interface List E#2 extends Object declared in interface MyInterface 1 errorTo fix these build errors, the class implementing these interfaces should override the method with a compatible return type. For example:
@Override public Object getFirst() { return List.super.getFirst(); }
Segurança
O Android 15 inclui mudanças que promovem a segurança do sistema para ajudar a proteger apps e usuários contra apps maliciosos.
Versões restritas do TLS
Android 15 限制了对 TLS 版本 1.0 和 1.1 的使用。这些版本之前已在 Android 中被弃用,但现在不允许面向 Android 15 的应用使用。
A atividade em segundo plano segura é iniciada
Android 15 protects users from malicious apps and gives them more control over their devices by adding changes that prevent malicious background apps from bringing other apps to the foreground, elevating their privileges, and abusing user interaction. Background activity launches have been restricted since Android 10 (API level 29).
Other changes
In addition to the restriction for UID matching, these other changes are also included:
- Change
PendingIntent
creators to block background activity launches by default. This helps prevent apps from accidentally creating aPendingIntent
that could be abused by malicious actors. - Don't bring an app to the foreground unless the
PendingIntent
sender allows it. This change aims to prevent malicious apps from abusing the ability to start activities in the background. By default, apps are not allowed to bring the task stack to the foreground unless the creator allows background activity launch privileges or the sender has background activity launch privileges. - Control how the top activity of a task stack can finish its task. If the top activity finishes a task, Android will go back to whichever task was last active. Moreover, if a non-top activity finishes its task, Android will go back to the home screen; it won't block the finish of this non-top activity.
- Prevent launching arbitrary activities from other apps into your own task. This change prevents malicious apps from phishing users by creating activities that appear to be from other apps.
- Block non-visible windows from being considered for background activity launches. This helps prevent malicious apps from abusing background activity launches to display unwanted or malicious content to users.
Intents mais seguras
Android 15 introduces new optional security measures to make intents safer and more robust. These changes are aimed at preventing potential vulnerabilities and misuse of intents that can be exploited by malicious apps. There are two main improvements to the security of intents in Android 15:
- Match target intent-filters: Intents that target specific components must accurately match the target's intent-filter specifications. If you send an intent to launch another app's activity, the target intent component needs to align with the receiving activity's declared intent-filters.
- Intents must have actions: Intents without an action will no longer match any intent-filters. This means that intents used to start activities or services must have a clearly defined action.
In order to check how your app responds to these changes, use
StrictMode
in your app. To see detailed
logs about Intent
usage violations, add the following method:
Kotlin
fun onCreate() { StrictMode.setVmPolicy(VmPolicy.Builder() .detectUnsafeIntentLaunch() .build() ) }
Java
public void onCreate() { StrictMode.setVmPolicy(new VmPolicy.Builder() .detectUnsafeIntentLaunch() .build()); }
Experiência do usuário e interface do sistema
O Android 15 inclui algumas mudanças que têm como objetivo criar uma experiência do usuário mais consistente e intuitiva.
Mudanças no encarte da janela
Há duas mudanças relacionadas aos engastes de janela no Android 15: o engaste de borda a borda é forçado por padrão, e também há mudanças de configuração, como a configuração padrão das barras do sistema.
全面实施政策
Os apps são exibidos de borda a borda por padrão em dispositivos com o Android 15 se o app for direcionado para o Android 15 (nível 35 da API).

Essa é uma mudança importante que pode afetar negativamente a interface do seu app. As mudanças afetam as seguintes áreas da interface:
- Barra de navegação do identificador de gestos
- Transparente por padrão.
- O deslocamento inferior está desativado para que o conteúdo seja mostrado por trás da barra de navegação do sistema, a menos que os insets sejam aplicados.
setNavigationBarColor
eR.attr#navigationBarColor
foram descontinuados e não afetam a navegação por gestos.setNavigationBarContrastEnforced
eR.attr#navigationBarContrastEnforced
continuam sem efeito na navegação por gestos.
- Navegação com três botões
- Opacidade definida como 80% por padrão, com a cor possivelmente correspondendo ao plano de fundo da janela.
- O deslocamento da parte de baixo foi desativado para que o conteúdo seja mostrado por trás da barra de navegação do sistema, a menos que os insets sejam aplicados.
setNavigationBarColor
eR.attr#navigationBarColor
são definidos para corresponder ao plano de fundo da janela por padrão. O plano de fundo da janela precisa ser um drawable de cor para que esse padrão seja aplicado. Essa API foi descontinuada, mas continua afetando a navegação com três botões.setNavigationBarContrastEnforced
eR.attr#navigationBarContrastEnforced
são verdadeiros por padrão, o que adiciona um plano de fundo opaco de 80% à navegação com três botões.
- Barra de status
- Transparente por padrão.
- O deslocamento superior está desativado para que o conteúdo seja renderizado atrás da barra de status, a menos que os encartes sejam aplicados.
setStatusBarColor
eR.attr#statusBarColor
foram descontinuados e não têm efeito no Android 15.setStatusBarContrastEnforced
eR.attr#statusBarContrastEnforced
foram descontinuados, mas ainda têm efeito no Android 15.
- Recorte da tela
- O
layoutInDisplayCutoutMode
de janelas não flutuantes precisa serLAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
.SHORT_EDGES
,NEVER
eDEFAULT
são interpretados comoALWAYS
para que os usuários não vejam uma barra preta causada pelo recorte da tela e apareçam de borda a borda.
- O
O exemplo a seguir mostra um app antes e depois de segmentar o Android 15 (nível 35 da API) e antes e depois de aplicar insets.



Como verificar se o app já ocupa toda a tela
Se o app já ocupa toda a tela de ponta a ponta e aplica insets, ele não será afetado, exceto nos seguintes cenários. No entanto, mesmo que você ache que não foi afetado, recomendamos testar o app.
- Você tem uma janela não flutuante, como uma
Activity
que usaSHORT_EDGES
,NEVER
ouDEFAULT
em vez deLAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
. Se o app falhar na inicialização, isso pode ser devido à tela de apresentação. É possível fazer upgrade da dependência da tela de inicialização do núcleo para 1.2.0-alpha01 ou versões mais recentes ou definirwindow.attributes.layoutInDisplayCutoutMode = WindowManager.LayoutInDisplayCutoutMode.always
. - Talvez haja telas com menos tráfego e uma interface obstruída. Verifique se essas
telas menos visitadas não têm uma interface obstruída. As telas com menos tráfego incluem:
- Telas de integração ou de login
- Páginas de configurações
O que verificar se o app ainda não ocupa toda a tela
Se o app ainda não ocupa toda a tela, é provável que você seja afetado. Além dos cenários para apps que já ocupam toda a tela, considere o seguinte:
- Se o app usar componentes do Material 3 (
androidx.compose.material3
) no Compose, comoTopAppBar
,BottomAppBar
eNavigationBar
, esses componentes provavelmente não serão afetados porque processam encartes automaticamente. - Se o app estiver usando componentes do Material 2 (
androidx.compose.material
) no Compose, eles não vão processar encartes automaticamente. No entanto, você pode conseguir acesso aos encartes e aplicá-los manualmente. Na androidx.compose.material 1.6.0 e versões mais recentes, use o parâmetrowindowInsets
para aplicar os encartes manualmente paraBottomAppBar
,TopAppBar
,BottomNavigation
eNavigationRail
. Da mesma forma, use o parâmetrocontentWindowInsets
paraScaffold
. - Caso o app use visualizações e componentes do Material
(
com.google.android.material
), a maioria dos componentes do Material baseados em visualizações, comoBottomNavigationView
,BottomAppBar
,NavigationRailView
ouNavigationView
, processa encartes e não exige trabalho extra. No entanto, você precisa adicionarandroid:fitsSystemWindows="true"
se estiver usandoAppBarLayout
. - Para elementos combináveis personalizados, aplique os encartes manualmente como padding. Se o
conteúdo estiver em um
Scaffold
, você poderá consumir insets usando os valores de paddingScaffold
. Caso contrário, aplique o padding usando um dosWindowInsets
. - Se o app estiver usando visualizações e
BottomSheet
,SideSheet
ou contêineres personalizados, aplique padding usandoViewCompat.setOnApplyWindowInsetsListener
. ParaRecyclerView
, aplique padding usando esse listener e também adicioneclipToPadding="false"
.
O que verificar se o app precisa oferecer proteção personalizada em segundo plano
Se o app precisar oferecer proteção em segundo plano personalizada para a navegação de três botões ou
a barra de status, ele precisará colocar um elemento combinável ou uma visualização atrás da barra do sistema
usando WindowInsets.Type#tappableElement()
para conseguir a altura da barra de navegação
de três botões ou WindowInsets.Type#statusBars
.
Outros recursos de ponta a ponta
Consulte os guias Visualizações de borda a borda e Composição de borda a borda para mais considerações sobre como aplicar insets.
APIs descontinuadas
As APIs a seguir foram descontinuadas, mas não foram desativadas:
R.attr#enforceStatusBarContrast
R.attr#navigationBarColor
(para navegação com três botões, com 80% de alfa)Window#isStatusBarContrastEnforced
Window#setNavigationBarColor
(para navegação com três botões, com 80% de alfa)Window#setStatusBarContrastEnforced
As APIs a seguir foram descontinuadas e desativadas:
R.attr#navigationBarColor
(para navegação por gestos)R.attr#navigationBarDividerColor
R.attr#statusBarColor
Window#setDecorFitsSystemWindows
Window#getNavigationBarColor
Window#getNavigationBarDividerColor
Window#getStatusBarColor
Window#setNavigationBarColor
(para navegação por gestos)Window#setNavigationBarDividerColor
Window#setStatusBarColor
稳定配置
If your app targets Android 15 (API level 35) or higher, Configuration
no
longer excludes the system bars. If you use the screen size in the
Configuration
class for layout calculation, you should replace it with better
alternatives like an appropriate ViewGroup
, WindowInsets
, or
WindowMetricsCalculator
depending on your need.
Configuration
has been available since API 1. It is typically obtained from
Activity.onConfigurationChanged
. It provides information like window density,
orientation, and sizes. One important characteristic about the window sizes
returned from Configuration
is that it previously excluded the system bars.
The configuration size is typically used for resource selection, such as
/res/layout-h500dp
, and this is still a valid use case. However, using it for
layout calculation has always been discouraged. If you do so, you should move
away from it now. You should replace the use of Configuration
with something
more suitable depending on your use case.
If you use it to calculate the layout, use an appropriate ViewGroup
, such as
CoordinatorLayout
or ConstraintLayout
. If you use it to determine the height
of the system navbar, use WindowInsets
. If you want to know the current size
of your app window, use computeCurrentWindowMetrics
.
The following list describes the fields affected by this change:
Configuration.screenWidthDp
andscreenHeightDp
sizes no longer exclude the system bars.Configuration.smallestScreenWidthDp
is indirectly affected by changes toscreenWidthDp
andscreenHeightDp
.Configuration.orientation
is indirectly affected by changes toscreenWidthDp
andscreenHeightDp
on close-to-square devices.Display.getSize(Point)
is indirectly affected by the changes inConfiguration
. This was deprecated beginning in API level 30.Display.getMetrics()
has already worked like this since API level 33.
O atributo "elegantTextHeight" tem como padrão "true"
Em apps destinados ao Android 15 (nível 35 da API), o atributo
elegantTextHeight
TextView
passa a ser true
por padrão, substituindo a fonte compacta usada por padrão por alguns
scripts com métricas verticais grandes por uma que é muito mais legível.
A fonte compacta foi introduzida para evitar a quebra de layouts. O Android 13 (nível
33 da API) evita muitas dessas quebras, permitindo que o layout de texto
estique a altura vertical usando o atributo
fallbackLineSpacing
.
No Android 15, a fonte compacta ainda permanece no sistema. Assim, o app pode definir
elegantTextHeight
como false
para ter o mesmo comportamento de antes, mas é
improvável que haja suporte a ele nas próximas versões. Portanto, se o app oferecer suporte aos
seguintes scripts: árabe, lao, birmanês, tâmil, gujarati, canarês, malaiala,
odia, télugo ou tailandês, teste o app definindo elegantTextHeight
como true
.

elegantTextHeight
comportamento para apps destinados ao Android 14 (nível 34 da API) e versões anteriores.
elegantTextHeight
para apps destinados ao Android 15.A largura do TextView muda para formas de letras complexas
In previous versions of Android, some cursive fonts or languages that have
complex shaping might draw the letters in the previous or next character's area.
In some cases, such letters were clipped at the beginning or ending position.
Starting in Android 15, a TextView
allocates width for drawing enough space
for such letters and allows apps to request extra paddings to the left to
prevent clipping.
Because this change affects how a TextView
decides the width, TextView
allocates more width by default if the app targets Android 15 (API level 35) or
higher. You can enable or disable this behavior by calling the
setUseBoundsForWidth
API on TextView
.
Because adding left padding might cause a misalignment for existing layouts, the
padding is not added by default even for apps that target Android 15 or higher.
However, you can add extra padding to preventing clipping by calling
setShiftDrawingOffsetForStartOverhang
.
The following examples show how these changes can improve text layout for some fonts and languages.

<TextView android:fontFamily="cursive" android:text="java" />

<TextView android:fontFamily="cursive" android:text="java" android:useBoundsForWidth="true" android:shiftDrawingOffsetForStartOverhang="true" />

<TextView android:text="คอมพิวเตอร์" />

<TextView android:text="คอมพิวเตอร์" android:useBoundsForWidth="true" android:shiftDrawingOffsetForStartOverhang="true" />
Altura da linha padrão com suporte a localidade para EditText
Nas versões anteriores do Android, o layout de texto estendia a altura do
texto para atender à altura da linha da fonte que correspondia à localidade atual. Por
exemplo, se o conteúdo estivesse em japonês, a altura da linha da fonte japonesa
seria um pouco maior do que a de uma fonte latina, e a altura do texto
ficaria um pouco maior. No entanto, apesar dessas diferenças nas alturas das linhas, o elemento
EditText
foi dimensionado de maneira uniforme, independentemente
da localidade usada, conforme ilustrado na imagem a seguir:

EditText
que
podem conter texto em inglês (en), japonês (ja) e birmanês (my). A
altura do EditText
é a mesma, mesmo que esses idiomas
tenham alturas de linha diferentes.Para apps direcionados ao Android 15 (nível 35 da API), uma altura mínima de linha agora é
reservada para EditText
para corresponder à fonte de referência da localidade especificada, conforme
mostrado na imagem a seguir:

EditText
que
podem conter texto em inglês (en), japonês (ja) e birmanês (my). A
altura do EditText
agora inclui espaço para acomodar a
altura da linha padrão das fontes desses idiomas.Se necessário, o app pode restaurar o comportamento anterior especificando o atributo
useLocalePreferredLineHeightForMinimum
para false
e definir métricas verticais mínimas personalizadas usando a
API setMinimumFontMetrics
em Kotlin e Java.
Câmera e mídia
O Android 15 faz as seguintes mudanças no comportamento da câmera e da mídia para apps direcionados ao Android 15 ou mais recente.
Restrições ao solicitar o foco de áudio
Os apps direcionados ao Android 15 (nível 35 da API) precisam ser o app principal ou executar um
serviço em primeiro plano para solicitar o foco de áudio. Se um app
tentar solicitar o foco quando não atender a um desses requisitos, a
chamada vai retornar AUDIOFOCUS_REQUEST_FAILED
.
Saiba mais sobre o foco de áudio em Gerenciar o foco de áudio.
Atualização das restrições não SDK
O Android 15 inclui listas atualizadas de interfaces não SDK restritas com base na colaboração de desenvolvedores do Android e nos testes internos mais recentes. Antes de restringirmos interfaces não SDK, sempre que possível, garantimos que haja alternativas públicas disponíveis.
Caso seu app não seja destinado ao Android 15, é possível que algumas dessas mudanças não afetem você imediatamente. No entanto, embora seja possível que o app acesse algumas interfaces não SDK dependendo do nível da API de destino do app, o uso de qualquer método ou campo não SDK sempre apresenta um alto risco de corromper o app.
Se você não sabe se o app usa interfaces não SDK, teste-o para descobrir. Se o app depende de interfaces não SDK, comece a planejar uma migração para alternativas SDK. No entanto, entendemos que alguns apps têm casos de uso válidos para interfaces que não são do SDK. Se você não encontrar uma alternativa para deixar de usar uma interface externa ao SDK em um recurso no app, solicite uma nova API pública.
Para saber mais sobre as mudanças dessa versão do Android, consulte Atualizações para restrições de interfaces não SDK no Android 15. Para saber mais sobre interfaces não SDK em geral, consulte Restrições para interfaces não SDK.