Mudanças de comportamento: apps destinados ao Android 15 ou versões mais recentes

Como as versões anteriores, o Android 15 inclui mudanças de comportamento que podem afetar seu app. As mudanças de comportamento abaixo se aplicam exclusivamente a apps destinados ao Android 15 ou versões mais recentes. Caso o app seja destinado ao Android 15 ou versões mais recentes, modifique o app para oferecer suporte a esses comportamentos de forma adequada, 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

Estamos fazendo as seguintes mudanças nos serviços em primeiro plano com o Android 15.

Comportamento de tempo limite do serviço em primeiro plano da sincronização de dados

O Android 15 introduz um novo comportamento de tempo limite no dataSync para apps destinados a apps Android 15 ou mais recente. Esse comportamento também se aplica ao novo mediaProcessing tipo de serviço em primeiro plano.

O sistema permite que os serviços do 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 Método Service.onTimeout(int, int) (introduzido no Android) 15). No momento, o serviço tem alguns segundos para chamar Service.stopSelf(). Quando Service.onTimeout() é chamado, 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. 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, faça uma ou mais das seguintes:

  1. Peça para seu serviço implementar o novo método Service.onTimeout(int, int). Quando o app receber o callback, chame stopSelf() em um alguns segundos. Se você não parar o aplicativo imediatamente, o sistema gerará uma após uma falha.
  2. Verifique se os serviços do dataSync do seu app não são executados por mais de um total de 6 horas em qualquer período de 24 horas (a menos que o usuário interaja com o app, redefinindo o timer).
  3. Iniciar serviços em primeiro plano do dataSync apenas como resultado direto da ação do usuário interação já que seu app está em primeiro plano quando o serviço é iniciado, seu serviço tem seis horas completas após o app ficar em segundo plano.
  4. Em vez de usar um serviço em primeiro plano dataSync, use uma API alternativa.

Se os serviços em primeiro plano dataSync do seu app foram executados por seis horas nas últimas 24, não é possível iniciar outro serviço em primeiro plano dataSync, a menos que o usuário levou o app para o primeiro plano (o que reinicia o timer). Se você tentar iniciar outro serviço dataSync em primeiro plano, o sistema vai gerar ForegroundServiceStartNotAllowedException com uma mensagem de erro, como "O limite de tempo já se esgotou para o serviço em primeiro plano digite dataSync".

Teste

Para testar o comportamento do app, é possível ativar tempos limite de sincronização de dados mesmo que o app não é destinado ao Android 15 (desde que o app seja executado em um aparelho Android 15) dispositivo). Para ativar os tempos limite, execute o seguinte comando adb:

adb shell am compat enable FGS_INTRODUCE_TIME_LIMITS your-package-name

Também é possível ajustar o tempo limite para testar como seu se comporta quando o limite é 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

Novo tipo de serviço em primeiro plano de processamento de mídia

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:

  1. Have your service implement the new Service.onTimeout(int, int) method. When your app receives the callback, make sure to call stopSelf() within a few seconds. (If you don't stop the app right away, the system generates a failure.)
  2. 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).
  3. 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.
  4. 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

Restrições em BOOT_COMPLETED broadcast receivers que iniciam serviços em primeiro plano

在启动 BOOT_COMPLETED 广播接收器方面存在新限制 前台服务。BOOT_COMPLETED 接收器不能启动 以下前台服务类型：

如果 BOOT_COMPLETED 接收器尝试启动任何上述类型的前台 服务，系统会抛出 ForegroundServiceStartNotAllowedException。

测试

如需测试应用的行为，即使您的 应用并非以 Android 15 为目标平台（只要该应用在 Android 15 上运行即可） 设备）。运行以下 adb 命令：

adb shell am compat enable FGS_BOOT_COMPLETED_RESTRICTIONS your-package-name

如需在不重启设备的情况下发送 BOOT_COMPLETED 广播， 运行以下 adb 命令：

adb shell am broadcast -a android.intent.action.BOOT_COMPLETED your-package-name

Restrições para iniciar serviços em primeiro plano enquanto um app tem a permissão SYSTEM_ALERT_WINDOW

以前，如果应用拥有 SYSTEM_ALERT_WINDOW 权限，那么即使该应用当前在后台运行，它也可以启动前台服务（如不受后台启动限制的豁免中所述）。

如果应用以 Android 15 为目标平台，此豁免范围现在会更严格。该应用现在需要具有 SYSTEM_ALERT_WINDOW 权限，并且还具有可见的叠加窗口。也就是说，在您启动前台服务之前，应用需要先启动 TYPE_APPLICATION_OVERLAY 窗口，并且该窗口必须处于可见状态。

如果您的应用尝试在不满足这些新要求的情况下从后台启动前台服务（并且没有其他某些豁免），系统会抛出 ForegroundServiceStartNotAllowedException。

如果您的应用声明 SYSTEM_ALERT_WINDOW 权限并从后台启动前台服务，则可能会受到此项变更的影响。如果您的应用收到 ForegroundServiceStartNotAllowedException，请检查应用的操作顺序，并确保应用在尝试从后台启动前台服务之前已具备有效的叠加窗口。您可以通过调用 View.getWindowVisibility() 检查叠加层窗口当前是否可见，也可以替换 View.onWindowVisibilityChanged()，以便在可见性发生变化时收到通知。

Mudanças na possibilidade de os apps modificarem o estado global do modo "Não perturbe"

Os apps direcionados ao Android 15 não podem mais mudar o estado ou a política global do Não perturbe em um dispositivo, seja modificando as configurações do usuário ou desativando o modo Não perturbe. Em vez disso, os apps precisam contribuir com um AutomaticZenRule, que o sistema combina em uma política global com o esquema most-restrictive-policy-wins atual. As chamadas para APIs existentes que anteriormente afetaram o estado global (setInterruptionFilter, setNotificationPolicy) resultam na criação ou atualização de um AutomaticZenRule implícito, que pode ser ativado e desativado dependendo do ciclo de chamadas dessas chamadas de API.

Essa mudança afeta apenas o comportamento observável se o app estiver chamando setInterruptionFilter(INTERRUPTION_FILTER_ALL) e espera que essa chamada desative um AutomaticZenRule que foi ativado anteriormente pelos proprietários.

Mudanças na API OpenJDK

O Android 15 continua o trabalho de atualizar as principais bibliotecas do Android para se alinhar com os recursos das versões mais recentes do LTS do OpenJDK.

Algumas dessas mudanças podem afetar a compatibilidade dos apps destinados à segmentação Android 15 (nível 35 da API):

  • Mudanças nas APIs de formatação de strings: validação do índice de argumentos, flags A largura e a precisão agora são mais rigorosas com o uso das APIs String.format() e Formatter.format():

    Por exemplo, a exceção a seguir é gerada quando um índice de argumento de 0 é usado (%0 na string de formato):

    IllegalFormatArgumentIndexException: Illegal format argument index = 0

    Nesse caso, o problema pode ser corrigido usando um índice de argumento de 1 (%1). na string de formato).

  • Mudanças no tipo de componente de Arrays.asList(...).toArray(): ao usar Arrays.asList(...).toArray(), o tipo de componente da matriz resultante é agora um Object, e não o tipo dos elementos da matriz. Então, o O código abaixo gera uma ClassCastException:

    String[] elements = (String[]) Arrays.asList("one", "two").toArray();

    Nesse caso, para preservar String como o tipo de componente no resultado pode usar Collection.toArray(Object[]):

    String[] elements = Arrays.asList("two", "one").toArray(new String[0]);

  • Mudanças no processamento do código de linguagem: ao usar a API Locale, os códigos de idioma para hebraico, iídiche e indonésio não são mais convertidos às formas obsoletas (hebraico: iw, iídiche: ji e indonésio: in). Ao especificar o código do idioma para uma dessas localidades, use os códigos a partir da ISO 639-1 (hebraico: he, iídiche: yi e indonésio: id).

  • Mudanças em sequências int aleatórias: após as alterações feitas em https://bugs.openjdk.org/Browse/JDK-8301574, o seguinte Métodos Random.ints() agora retornam uma sequência de números diferente da os métodos Random.nextInt() fazem:

    De modo geral, essa mudança não resulta em um comportamento inapropriado para o app, mas seu o código não vai esperar que a sequência gerada pelos métodos Random.ints() corresponder a Random.nextInt().

A nova API SequencedCollection pode afetar a compatibilidade do seu app depois de atualizar compileSdk na configuração do build do app para usar Android 15 (nível 35 da API):

  • Colisão com MutableList.removeFirst() e Funções de extensão MutableList.removeLast() em kotlin-stdlib

    O tipo List (link em inglês) em Java é mapeado para o tipo MutableList em Kotlin. Como as APIs List.removeFirst() e List.removeLast() foram lançados no Android 15 (nível 35 da API), o compilador Kotlin resolve chamadas de função, por exemplo, list.removeFirst(), estaticamente para a das novas APIs List em vez das funções de extensão kotlin-stdlib.

    Se um app for recompilado com compileSdk definido como 35 e minSdk definido como 34 ou anterior, e o app é executado no Android 14 e em versões anteriores, um ambiente de execução. é gerado:

    java.lang.NoSuchMethodError: No virtual method
removeFirst()Ljava/lang/Object; in class Ljava/util/ArrayList;

    A opção de lint NewApi já existente no Plug-in do Android para Gradle pode detectar esses erros novos usos de API.

    ./gradlew lint

MainActivity.kt:41: Error: Call requires API level 35 (current min is 34): java.util.List#removeFirst [NewApi]
      list.removeFirst()

    Para corrigir a exceção de ambiente de execução e os erros de lint, removeFirst() e As chamadas de função removeLast() podem ser substituídas por removeAt(0) e removeAt(list.lastIndex), respectivamente, em Kotlin. Se você usa Android Studio Ladybug | versão 2024.1.3 ou mais recente, também fornece uma correção rápida para esses erros.

    Considere remover @SuppressLint("NewApi") e lintOptions { disable 'NewApi' } se a opção de lint tiver sido desativada.

  • Colisão com outros métodos em Java

    Novos métodos foram adicionados aos tipos existentes, por exemplo, List e Deque. Esses novos métodos podem não ser compatíveis com métodos com o mesmo nome e tipos de argumento em outras interfaces e classes. No caso de uma colisão de assinatura de método com incompatibilidade, o compilador javac vai gerar um erro de tempo de build. Por exemplo:

    Exemplo de erro 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 List

    Exemplo de erro 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 error

    Exemplo de erro 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 error

    Para corrigir esses erros de build, a classe que implementa essas interfaces deve substituir o método por um tipo de retorno compatível. Exemplo:

    @Override
public Object getFirst() {
    return List.super.getLast();
}

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.

Inicializações de atividades seguras em segundo plano

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).

Block apps that don't match the top UID on the stack from launching activities

Malicious apps can launch another app's activity within the same task, then overlay themselves on top, creating the illusion of being that app. This "task hijacking" attack bypasses current background launch restrictions because it all occurs within the same visible task. To mitigate this risk, Android 15 adds a flag that blocks apps that don't match the top UID on the stack from launching activities. To opt in for all of your app's activities, update the allowCrossUidActivitySwitchFromBelow attribute in your app's AndroidManifest.xml file:

<application android:allowCrossUidActivitySwitchFromBelow="false" >

The new security measures are active if all of the following are true:

  • The app performing the launch targets Android 15.
  • The app on top of the task stack targets Android 15.
  • Any visible activity has opted in to the new protections

If the security measures are enabled, apps might return home, rather than the last visible app, if they finish their own task.

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 a PendingIntent 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

O Android 15 apresenta novas medidas de segurança para tornar as intents mais seguras e robustas. Essas alterações têm como objetivo evitar possíveis vulnerabilidades e o uso indevido de intents que podem ser exploradas por apps maliciosos. Há duas melhorias principais na segurança das intents no Android 15:

  • Corresponder aos filtros de intent de destino:as intents que segmentam componentes específicos precisam corresponder com precisão às especificações do filtro de intent do destino. Se você enviar uma intent para iniciar a atividade de outro app, o componente da intent de destino precisará estar alinhado aos filtros de intent declarados da atividade de recebimento.
  • Intents precisam ter ações:intents que não tenham uma ação não vão mais corresponder a nenhum filtro de intent. Isso significa que as intents usadas para iniciar atividades ou serviços precisam ter uma ação claramente definida.
  • Intents pendentes:o criador da intent pendente é tratado como o remetente da intent delimitada, não como o remetente da intent pendente.

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 a encartes de janela no Android 15: de ponta a ponta é aplicada por padrão, e também há mudanças de configuração, como a configuração padrão das barras do sistema.

Aplicação de ponta a ponta

Por padrão, os apps são exibidos de ponta a ponta em dispositivos com o Android 15, se o app for destinados ao Android 15 (nível 35 da API).

Um app destinado ao Android 14 e que não é de ponta a ponta em uma Dispositivo Android 15.


Um app destinado ao Android 15 (nível 35 da API) e de ponta a ponta em um dispositivo Android 15. Este app usa principalmente componentes do Compose do Material 3 que aplicam encartes automaticamente. Esta tela não é prejudicada pelo Aplicação de ponta a ponta do Android 15.

Essa é uma mudança interruptiva que pode afetar negativamente a interface do app. O as mudanças afetam as seguintes áreas da interface:

  • Barra de navegação da alça de gestos
    • Transparente por padrão.
    • O deslocamento inferior está desativado para que o conteúdo fique atrás da navegação do sistema a menos que encartes sejam aplicados.
    • setNavigationBarColor e R.attr#navigationBarColor estão descontinuada e não afetam a navegação por gestos.
    • setNavigationBarContrastEnforced e R.attr#navigationBarContrastEnforced continuam não tendo efeito sobre e navegação por gestos.
  • Navegação com três botões
    • Opacidade definida como 80% por padrão, com cores possivelmente correspondentes à janela plano de fundo.
    • Deslocamento inferior desativado para que o conteúdo fique atrás da barra de navegação do sistema a menos que encartes sejam aplicados.
    • setNavigationBarColor e R.attr#navigationBarColor estão definida 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 é descontinuado, mas continua afetando a navegação com três botões.
    • setNavigationBarContrastEnforced e R.attr#navigationBarContrastEnforced é verdadeiro por padrão, o que adiciona uma Plano de fundo 80% opaco na navegação com três botões.
  • Barra de status
    • Transparente por padrão.
    • O deslocamento superior está desabilitado para que o conteúdo fique atrás da barra de status, a menos que encartes são aplicados.
    • setStatusBarColor e R.attr#statusBarColor estão descontinuados e não afetam o Android 15.
    • setStatusBarContrastEnforced e R.attr#statusBarContrastEnforced foram descontinuados, mas ainda têm uma efeito no Android 15.
  • Corte da tela
    • layoutInDisplayCutoutMode das janelas não flutuantes precisam ser LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS. SHORT_EDGES, NEVER e DEFAULT são interpretadas como ALWAYS para que os usuários não vejam um ícone gerada pelo corte da tela e aparecem de ponta a ponta.

O exemplo a seguir mostra um app antes e depois da segmentação. Android 15 (nível 35 da API) e antes e depois de aplicar encartes.

Um app destinado ao Android 14 e que não é de ponta a ponta em uma Dispositivo Android 15.
.
Um app destinado ao Android 15 (nível 35 da API) e de ponta a ponta em um dispositivo Android 15. No entanto, muitos elementos agora estão ocultos pelo status barra de navegação, barra de navegação com três botões ou corte da tela devido ao Android 15 restrições de ponta a ponta. A interface oculta inclui o Material 2 barra de apps superior, botões de ação flutuantes e itens de lista.
.
Um app destinado ao Android 15 (nível 35 da API) é de ponta a ponta em um dispositivo Android 15 e aplica encartes para que a interface não seja escondidos.
O que verificar se o app já está de ponta a ponta

Se o app já está de ponta a ponta e aplica encartes, você está não são afetadas, exceto nos casos a seguir. No entanto, mesmo se você achar você não é afetado, recomendamos testar o app.

  • Você tem uma janela não flutuante, como uma Activity que usa SHORT_EDGES, NEVER ou DEFAULT em vez de LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS. Se o app falhar na inicialização, pode ser devido à tela de apresentação. É possível fazer o upgrade do nível dependência da tela de apresentação para 1.2.0-alpha01 ou posterior ou defina window.attributes.layoutInDisplayCutoutMode = WindowManager.LayoutInDisplayCutoutMode.always.
  • Pode haver telas de menor tráfego com interface obstruída. Confirme estas telas menos visitadas não têm interface obstruída; Telas com menos tráfego incluem:
    • Telas de integração ou login
    • Páginas de configurações
O que verificar se o app ainda não está de ponta a ponta

Se seu app ainda não estiver de ponta a ponta, é provável que você seja afetado. Em além dos cenários para aplicativos que já são de ponta a ponta, você deve considere o seguinte:

  • Se o app usa componentes do Material 3 ( androidx.compose.material3) no Compose, como TopAppBar. BottomAppBar e NavigationBar, esses componentes provavelmente não porque elas lidam automaticamente com encartes.
  • Se o app usar componentes do Material 2 ( androidx.compose.material) no Compose, esses componentes não processam encartes automaticamente. No entanto, você tem acesso aos encartes e aplicá-las manualmente. No androidx.compose.material 1.6.0 Depois, use o parâmetro windowInsets para aplicar os encartes manualmente aos BottomAppBar e TopAppBar BottomNavigation e NavigationRail. Da mesma forma, use o parâmetro contentWindowInsets para Scaffold.
  • Se o app usa visualizações e componentes do Material Design (com.google.android.material), a maioria dos materiais baseados em visualizações. Componentes como BottomNavigationView, BottomAppBar NavigationRailView ou NavigationView lidam com encartes e não exigem nenhum trabalho adicional. No entanto, você precisa adicionar android:fitsSystemWindows="true" se estiver usando AppBarLayout.
  • Para elementos combináveis personalizados, aplique os encartes manualmente como padding. Se as o conteúdo está em um Scaffold, é possível consumir encartes usando o Scaffold valores de padding. Caso contrário, aplique o padding usando um dos WindowInsets.
  • Se o app usa visualizações e BottomSheet, SideSheet ou contêineres, aplique o padding usando ViewCompat.setOnApplyWindowInsetsListener. Para RecyclerView, aplique padding usando esse listener e também adicione clipToPadding="false".
O que verificar se o app precisa oferecer proteção personalizada em segundo plano

Se o app precisar oferecer proteção de segundo plano personalizada para navegação com três botões ou a barra de status, seu app precisa posicionar um elemento combinável ou uma visualização atrás da barra de sistema. usando WindowInsets.Type#tappableElement() para acessar o botão de três botões altura da barra de navegação ou WindowInsets.Type#statusBars.

Outros recursos de ponta a ponta

Consulte as Visualizações de ponta a ponta e Composição de borda a borda para considerações adicionais sobre a aplicação de encartes.

APIs descontinuadas

As seguintes APIs foram descontinuadas:

Configuração estável

如果您的应用以 Android 15（API 级别 35）或更高版本为目标平台，Configuration 否 不再包含系统栏。如果您使用 Configuration 类，您应将其替换为更好的 相应的 ViewGroup、WindowInsets 或 WindowMetricsCalculator，具体取决于您的需求。

Configuration 从 API 1 开始提供。它通常从 Activity.onConfigurationChanged.它提供窗口密度、 屏幕方向和尺寸窗口大小的一个重要特征 Configuration 之前会排除系统栏。

配置大小通常用于选择资源，例如 /res/layout-h500dp，这仍然是一个有效的用例。但将其用于 但一直不建议进行布局计算。如果需要，您应该将 现在离它远去。您应该使用 Configuration 具体取决于您的应用场景。

如果使用它来计算布局，请使用适当的 ViewGroup，例如 CoordinatorLayout 或 ConstraintLayout。如果使用该属性确定高度 ，请使用 WindowInsets。如果您想知道当前尺寸 ，请使用 computeCurrentWindowMetrics。

以下列表介绍了受此变更影响的字段：

O atributo eleganteTextHeight assume o padrão como verdadeiro

Em apps destinados ao Android 15, o atributo elegantTextHeight TextView se torna true por padrão, substituindo a fonte compacta usada por padrão por alguns scripts que têm métricas verticais grandes por uma 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 falhas, permitindo que o layout de texto estenda a altura vertical usando o atributo fallbackLineSpacing.

No Android 15, a fonte compacta ainda permanece no sistema. Por isso, o app pode definir elegantTextHeight como false para ter o mesmo comportamento de antes, mas é provável que ela não tenha suporte em versões futuras. Portanto, se o app oferecer suporte a estes scripts: árabe, laosiano, mianmar, tâmil, gujarati, canarês, malaiala, oriá, télugo ou tailandês, teste o app definindo elegantTextHeight como true.

Comportamento de elegantTextHeight para apps destinados ao Android 14 (nível 34 da API) e versões anteriores.
Comportamento de elegantTextHeight para apps destinados ao Android 15.

Mudanças na largura da TextView em formas de letra complexas

Nas versões anteriores do Android, algumas fontes ou linguagens cursivas com formas complexas podem desenhar as letras na área do caractere anterior ou do próximo caractere. Em alguns casos, essas letras eram cortadas na posição inicial ou final. No Android 15 e versões mais recentes, uma TextView aloca largura para mostrar espaço suficiente para essas letras e permite que os apps solicitem mais paddings para a esquerda a fim de evitar cortes.

Como essa mudança afeta como um TextView decide a largura, a TextView aloca uma largura maior por padrão se o app for direcionado ao Android 15 ou versões mais recentes. É possível ativar ou desativar esse comportamento chamando a API setUseBoundsForWidth em TextView.

Como a adição de padding à esquerda pode causar um desalinhamento para layouts existentes, o padding não é adicionado por padrão, mesmo para apps destinados ao Android 15 ou versões mais recentes. No entanto, você pode adicionar padding extra para evitar o recorte chamando setShiftDrawingOffsetForStartOverhang.

Os exemplos abaixo mostram como essas mudanças podem melhorar o layout do texto para algumas fontes e idiomas.

Layout padrão para texto em inglês com fonte cursiva. Algumas das letras estão cortadas. Confira o XML correspondente:

<TextView
    android:fontFamily="cursive"
    android:text="java" />
Layout para o mesmo texto em inglês com largura e padding adicionais. Confira o XML correspondente:

<TextView
    android:fontFamily="cursive"
    android:text="java"
    android:useBoundsForWidth="true"
    android:shiftDrawingOffsetForStartOverhang="true" />
Layout padrão para texto em tailandês. Algumas letras estão cortadas. Confira o XML correspondente:

<TextView
    android:text="คอมพิวเตอร์" />
Layout para o mesmo texto em tailandês com largura e padding adicionais. Confira o XML correspondente:

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

Altura da linha padrão com reconhecimento de localidade para EditText

Nas versões anteriores do Android, o layout do texto aumentava a altura do texto para ficar de acordo com a altura da linha da fonte correspondente à localidade atual. Por exemplo, se o conteúdo estava em japonês, como a altura da linha da fonte japonês é um pouco maior do que a da fonte latina, a altura do texto ficou um pouco maior. No entanto, apesar dessas diferenças na altura das linhas, o elemento EditText foi dimensionado de maneira uniforme, independente da localidade usada, conforme ilustrado na imagem abaixo:

Três caixas que representam elementos EditText que podem conter texto do inglês (en), japonês (ja) e birmanês (my). A altura do EditText é a mesma, embora esses idiomas tenham alturas de linha diferentes.

Para apps destinados ao Android 15, uma altura mínima de linha agora é reservada para EditText para corresponder à fonte de referência da localidade especificada, conforme mostrado na imagem abaixo:

Três caixas que representam elementos EditText que podem conter texto do 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 para as 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 mudanças abaixo no comportamento de câmera e mídia para apps destinados ao Android 15 ou versões mais recentes.

Restrições à solicitação da seleção de áudio

Os apps direcionados ao Android 15 precisam ser o principal ou executar um serviço em primeiro plano para solicitar a seleção de áudio. Se um app tentar solicitar a seleção quando não atender a um desses requisitos, a chamada retornará AUDIOFOCUS_REQUEST_FAILED.

Saiba mais sobre a seleção de áudio em Gerenciar seleção de áudio.

Atualização das restrições não SDK

O Android 15 inclui listas atualizadas de recursos não SDK restritos interfaces baseadas na colaboração com desenvolvedores Android e nos recursos para testes internos. 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, algumas destas mudanças pode não afetá-lo imediatamente. No entanto, embora seja possível acessar algumas interfaces externas ao SDK dependendo do nível desejado da API do app, é possível usar qualquer ou campo sempre apresenta um alto risco de corromper o aplicativo.

Se você não souber se o app usa interfaces externas ao SDK, será possível teste seu app para descobrir. Caso seu app dependa de ambientes externos interfaces, comece a planejar uma migração para alternativas de SDK. No entanto, entendemos que alguns aplicativos têm casos de uso válidos para o uso externas ao SDK. Se você não encontrar uma alternativa ao uso de um SDK para um recurso no seu app, você precisa solicitar 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.