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
eSe 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?
Seu 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 usar o Android NDK, ele usa código nativo.
- Seu app é vinculado a bibliotecas ou dependências nativas de terceiros que os utilizam.
- Seu app é 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:
- Abra o Android Studio, clique em File > Open e escolha um projeto.
Na barra de menus, clique em Build > Analyze APK....
Escolha o APK que você quer analisar.
Procure na pasta
lib
, que hospeda arquivos de objeto compartilhado (.so
), se houver algum. Se houver algum arquivo de objeto compartilhado, o app usará código nativo. Se nenhum arquivo de objeto compartilhado estiver presente ou não houver uma pastalib
, o app não usa código nativo.
Criar seu 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 para o AGP versão 8.3 ou mais recente
Os dispositivos de 16 KB exigem que apps que vêm com bibliotecas compartilhadas não compactadas sejam alinhadas em um limite de 16 KB alinhado no formato zip. Para fazer isso, você precisa fazer upgrade para o Plug-in do Android para Gradle (AGP) versão 8.3 ou mais recente. Consulte a seção Assistente de upgrade do Plug-in do Android para Gradle para saber mais sobre o processo de upgrade.
Recomendamos que você use bibliotecas compartilhadas descompactadas. No entanto, se não for possível fazer upgrade do AGP para a versão 8.3 ou mais recente, a alternativa será mudar para bibliotecas compartilhadas compactadas. Atualize a configuração do Gradle para que ele compacte as bibliotecas compartilhadas ao empacotar o app para evitar problemas de instalação com bibliotecas compartilhadas desalinhadas.
Groovy
No arquivo build.gradle
, adicione a seguinte opção:
android {
...
packagingOptions {
jniLibs {
useLegacyPackaging true
}
}
}
Kotlin
No arquivo build.gradle.kts
, adicione a seguinte opção:
android {
...
packagingOptions {
jniLibs {
useLegacyPackaging = true
}
}
}
Compile seu app usando o alinhamento ELF de 16 KB.
Os dispositivos de 16 KB exigem que os segmentos de ELF das bibliotecas compartilhadas sejam alinhados corretamente usando o alinhamento de ELF de 16 KB para que o app seja executado.
Para compilar seu app usando o alinhamento ELF de 16 KB, conclua as etapas em uma das seções a seguir, dependendo da versão do Android NDK que você está usando.
Android NDK r26 e anteriores
Para oferecer suporte à compilação de bibliotecas compartilhadas alinhadas de 16 KB com o Android NDK
versão r26 ou anterior, é necessário atualizar a configuração ndk-build
ou cmake
da seguinte maneira:
ndk-build
Atualize o Android.mk
para permitir o alinhamento de ELF de 16 KB:
LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"
CMake
Atualize o CMakeLists.txt
para permitir o alinhamento de ELF de 16 KB:
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, você precisa atualizar as flags ndk-build
, build.gradle
,
build.gradle.kts
ou do vinculador da seguinte maneira:
ndk-build
No seu Application.mk
:
APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true
Groovy
No arquivo build.gradle
, defina o argumento
-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 "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
}
}
}
}
Kotlin
No arquivo build.gradle.kts
, defina o argumento
-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")
}
}
}
}
Outros sistemas de build
Especifique as seguintes sinalizações do vinculador:
-Wl,-z,max-page-size=16384
Verifique 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 os locais no código presumirem que um dispositivo está usando um tamanho de página específico. Para evitar isso, siga estas etapas:
Remova todas as dependências codificadas que fazem referência à constante
PAGE_SIZE
ou às instâncias na lógica do código que presumem que o tamanho da página de um dispositivo é de 4 KB (4096
).Use
getpagesize()
ousysconf(_SC_PAGESIZE)
.Procure 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 para dispositivos de 16 KB, teste o app em um ambiente de 16 KB para ver se ele passa por alguma regressão. Para fazer isso, configure um dos ambientes de teste a seguir e faça um teste completo do app, concentrando-se nas áreas que podem ser afetadas pela alteração das 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 do Android 15 baseada em 16 KB
- Usar o Cuttlefish com tamanho de página de 16 KB em ARM64
- Simular o Cuttlefish com tamanho de página de 16 KB em x86-64
Configurar o Android Emulator com uma imagem do sistema do Android 15 baseada em 16 KB
Para configurar um ambiente de 16 KB usando o Android Emulator, siga estas etapas:
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.
No Android Studio, clique em Tools > SDK Manager.
Na guia SDK Platforms, expanda a seção Android VanillaIceCream Preview e selecione uma das seguintes imagens do sistema do emulador, dependendo dos dispositivos virtuais que você quer criar:
- Imagem experimental das APIs do Google de 16k com tamanho de página ARM 64 v8a
- Google APIs experimental 16k tamanho de página Intel x86_64 Imagem do sistema Atom
Clique em Apply > OK para fazer o download das imagens do sistema selecionadas.
Siga as etapas para configurar um dispositivo virtual para o Android 15 e, quando for solicitado que você selecione uma imagem do sistema, escolha a imagem do sistema de 16 KB que você transferiu por download. Se ela não for recomendada automaticamente, você poderá encontrar a imagem do sistema de 16 KB na guia Other Images.