Esta página foi traduzida pela API Cloud Translation.

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 entanto, à medida que os fabricantes continuam a criar dispositivos com quantidades maiores de memória física (RAM), muitos desses dispositivos provavelmente serão configurados com tamanhos de página de 16 KB (e, em algum momento, maiores) para otimizar o desempenho do dispositivo. Esperamos que os fabricantes otimizem ainda mais o desempenho em dispositivos futuros de 16 KB da mesma forma que fazem com dispositivos de 4 KB. Adicionar suporte a dispositivos de 16 KB permite que seu app seja executado nesses dispositivos e aproveite as melhorias de desempenho associadas.

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% menor em média
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 tiver certeza se o app usa código nativo, use o APK Analyzer para identificar se há código nativo presente.

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.

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 qualquer biblioteca nativa de terceiros.
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 pasta lib, 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 o 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

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() ou sysconf(_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, use um dos seguintes ambientes de teste:

Suporte a versões de 64 bits