Suporte a tamanhos de página de 16 KB

Historicamente, o Android oferecia suporte apenas a tamanhos de página de memória de 4 KB, o que otimizava o desempenho da memória do sistema para a quantidade média de memória total que os dispositivos Android normalmente tinham. No Android 15 e versões mais recentes, o Android oferece suporte a dispositivos configurados para usar um tamanho de página de 16 KB (dispositivos de 16 KB).

À medida que os fabricantes continuam a criar dispositivos com quantidades maiores de memória física (RAM), muitos deles provavelmente serão configurados com tamanhos de página de 16 KB (e, em algum momento, maiores) para otimizar o desempenho do dispositivo. Adicionar suporte a dispositivos de 16 KB permite que seu app seja executado nesses dispositivos e o ajuda a aproveitar as melhorias de desempenho associadas. Para ajudar você com isso, orientamos sobre como verificar se o app foi afetado, como recriar o app (se aplicável) e como testar o app em um ambiente de 16 KB usando emuladores e dispositivos físicos.

Benefícios e ganhos de desempenho

Dispositivos configurados com tamanhos de página de 16 KB usam um pouco mais de memória em média, mas também recebem várias melhorias de desempenho para o sistema e os apps:

• Menor tempo de inicialização do app enquanto o sistema está sob pressão de memória: 3,16% menor, em média, com melhorias mais significativas (até 30%) para alguns apps testados.
• Consumo de energia reduzido durante a inicialização do app: em média, 4,56% de redução
• Lançamento mais rápido da câmera: inicializações a quente 4,48% mais rápidas, em média, e inicializações a frio 6,60% mais rápidas, em média.
• Melhoria no tempo de inicialização do sistema: melhoria de 1,5% (aproximadamente 0,8 segundo) em média.

Essas melhorias são baseadas em nossos testes iniciais, e os resultados em dispositivos reais provavelmente serão diferentes. Forneceremos análises adicionais de ganhos potenciais para apps à medida que continuarmos nossos testes.

Verificar se o app vai ser afetado

Se o app usar código nativo, recrie-o com suporte a dispositivos de 16 KB. Se você não tem certeza se o app usa código nativo, use o APK Analyzer para identificar se há algum código nativo.

Se o app usa apenas código escrito na linguagem de programação Java ou Kotlin, incluindo bibliotecas ou SDKs, ele já oferece suporte a dispositivos de 16 KB. No entanto, recomendamos que você teste seu app em um ambiente de 16 KB para verificar se não há regressões inesperadas no comportamento dele.

O app usa código nativo?

O app usa código nativo se alguma das seguintes condições se aplicar:

• O app usa qualquer código C/C++ (nativo). Se o app usa o Android NDK, ele usa código nativo.
• O app é vinculado a quaisquer bibliotecas ou dependências nativas de terceiros que as usam.
• Seu app foi criado por um criador de apps de terceiros que usa bibliotecas nativas no dispositivo.

Identificar bibliotecas nativas usando o APK Analyzer

O APK Analyzer é uma ferramenta que permite avaliar vários aspectos de um APK criado. Para identificar se o app usa código nativo ou bibliotecas, siga estas etapas:

1. Abra o Android Studio, clique em File > Open e escolha um projeto.

2. Na barra de menus, clique em Build > Analyze APK....

   

3. Escolha o APK que você quer analisar.

4. Procure na pasta lib, que hospeda arquivos de objetos compartilhados (.so), se houver algum. Se houver arquivos de objeto compartilhado, o app usará código nativo. Se nenhum arquivo de objeto compartilhado estiver presente ou não houver uma pasta lib, seu app não vai usar código nativo.

   

Criar o app com suporte a dispositivos de 16 KB

Para oferecer suporte a dispositivos de 16 KB, os apps que usam código nativo precisam concluir as etapas descritas nas seções a seguir.

Atualizar o empacotamento das suas bibliotecas compartilhadas

Recomendamos que você faça upgrade para a versão 8.3 ou mais recente do AGP e use bibliotecas compartilhadas não compactadas.

AGP versão 8.3 ou mais recente.

Dispositivos de 16 KB exigem que os apps que vêm com bibliotecas compartilhadas não compactadas os alinhem em um limite alinhado em zip de 16 KB. Para fazer isso, você precisa fazer upgrade para o Plug-in do Android para Gradle (AGP, na sigla em inglês) versão 8.3 ou mais recente. Consulte a seção Assistente de upgrade do Plug-in do Android para Gradle para detalhes sobre o processo de upgrade.

AGP versão 8.2 ou anterior.

Se não for possível fazer upgrade do AGP para a versão 8.3 ou mais recente, a alternativa é usar bibliotecas compartilhadas compactadas. Atualize a configuração do Gradle para que o Gradle compacte as bibliotecas compartilhadas ao empacotar seu app para evitar problemas de instalação com bibliotecas compartilhadas desalinhadas.

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging true
      }
  }
}

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging = true
      }
  }
}

Compile seu app usando o alinhamento de ELF de 16 KB.

Dispositivos de 16 KB exigem que os segmentos ELF das bibliotecas compartilhadas sejam alinhados corretamente usando o alinhamento de ELF de 16 KB para que seu app seja executado.

Para compilar seu app usando o alinhamento de ELF de 16 KB, siga as etapas de uma das seções abaixo, dependendo da versão do Android NDK que você está usando.

Android NDK r26 e versões anteriores

Para oferecer suporte à compilação de bibliotecas compartilhadas alinhadas de 16 KB com o Android NDK versão r26 ou anterior, atualize a configuração ndk-build ou cmake da seguinte maneira:

LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"

target_link_options(${CMAKE_PROJECT_NAME} PRIVATE "-Wl,-z,max-page-size=16384")

Android NDK r27 e versões mais recentes

Para oferecer suporte à compilação de bibliotecas compartilhadas alinhadas de 16 KB com o Android NDK versão r27 e mais recentes, é necessário atualizar as flags ndk-build, build.gradle, build.gradle.kts ou do vinculador da seguinte maneira:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }
}

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments += listOf("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON")
      }
    }
  }
}

-Wl,-z,max-page-size=16384

Verificar se há instâncias de código que fazem referência a tamanhos de página específicos

Mesmo que seu app esteja alinhado a 16 KB, ele poderá encontrar erros se alguns lugares no código presumirem que um dispositivo está usando um tamanho de página específico. Para evitar isso, siga estas etapas:

1. Remova todas as dependências codificadas que fazem referência à constante PAGE_SIZE ou instâncias da lógica de código que presumem que o tamanho da página de um dispositivo é de 4 KB (4096).

   Use getpagesize() ou sysconf(_SC_PAGESIZE).

2. Procure os usos de mmap() e outras APIs que exigem argumentos alinhados à página e substitua por alternativas quando necessário.

Testar o app em um ambiente de 16 KB

Depois de criar seu app com suporte a dispositivos de 16 KB, é necessário testá-lo em um ambiente de 16 KB para ver se há regressões. Para fazer isso, configure um dos ambientes de teste abaixo e teste o app por completo, concentrando-se em áreas que podem ser afetadas pela mudança de instâncias de código que fazem referência a tamanhos de página específicos.

• Configurar o Android Emulator com uma imagem do sistema Android 15 baseada em 16 KB
• Usar o Cuttlefish com tamanho de página de 16 KB no ARM64
• Simule o Cuttlefish com tamanho de página de 16 KB em uma arquitetura x86-64.

Configurar o Android Emulator com uma imagem do sistema Android 15 baseada em 16 KB

Para configurar um ambiente de 16 KB usando o Android Emulator, siga estas etapas:

1. As imagens do sistema do emulador do Android 15 com base em 16 KB são compatíveis com o Android Studio Jellyfish | 2023.3.1 ou versões mais recentes. No entanto, para ter a melhor experiência ao trabalhar com o Android 15 Beta, faça o download da versão de pré-lançamento mais recente do Android Studio.

   Lembre-se de que você pode manter a versão atual do Android Studio instalada, já que é possível instalar diversas versões lado a lado.

2. No Android Studio, clique em Tools > SDK Manager.

3. Na guia SDK Platforms, marque Show Package Details, expanda a seção Android VanillaIceCream Preview e selecione uma ou as duas imagens do sistema do emulador abaixo, dependendo dos dispositivos virtuais que você quer criar:

   • Imagem do sistema experimental de 16 mil das APIs do Google ARM 64 v8a
   • Imagem do sistema Atom experimental 16k das APIs do Google

   

4. Clique em Aplicar > OK para fazer o download das imagens do sistema selecionadas.

5. Siga as etapas para configurar um dispositivo virtual para o Android 15 e, quando receber uma solicitação para selecionar uma imagem do sistema, selecione a imagem do sistema de 16 KB que você transferiu por download. Se não for recomendado automaticamente, você poderá encontrar a imagem do sistema de 16 KB na guia Outras imagens.