Suporte a tamanhos de página de 16 KB

Historicamente, o Android só oferece suporte a tamanhos de página de memória de 4 KB, o que desempenho de memória do sistema otimizado para a quantidade média de memória total que dispositivos Android normalmente tiveram. A partir do Android 15, o AOSP oferece suporte dispositivos configurados para usar um tamanho de página de 16 KB (16 KB) dispositivos). Se o app usa alguma biblioteca NDK diretamente ou indiretamente por meio de um SDK, você precisará recriar seu aplicativo para que ele funcionam nesses dispositivos de 16 KB.

À medida que os fabricantes continuam a construir dispositivos com quantidades na memória física (RAM), a maioria desses dispositivos adotará 16 KB tamanhos de página maiores) para otimizar o desempenho do dispositivo. Adicionando o suporte a dispositivos com tamanho de página de 16 KB permite que seu app seja executado nesses dispositivos. e ajuda seu app a se beneficiar do desempenho associado melhorias. Sem a recompilação, os apps podem não funcionar em dispositivos de 16 KB quando forem colocados em produção em versões futuras do Android.

Para ajudar você a adicionar a compatibilidade com seu app, oferecemos orientações sobre como verificar caso seu app seja afetado, como recriar o app (se aplicável) e como testá-lo na em um ambiente de 16 KB usando emuladores (incluindo o Android 15); imagens do sistema para o Android Emulator).

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). Caso seu app use a plataforma NDK, o app usará código nativo.
  • O app é vinculado a quaisquer bibliotecas ou dependências nativas de terceiros que usá-los.
  • Seu app foi feito por um criador de apps de terceiros que usa bibliotecas nativas em dispositivo.

Identificar bibliotecas nativas usando o APK Analyzer

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

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

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

    Opção de menu "Build" do Studio para iniciar o APK Analisador

  3. Escolha o APK que você quer analisar.

  4. Procure na pasta lib, que hospeda arquivos de objetos compartilhados (.so), se houver estão presentes. Se houver arquivos de objeto compartilhado, o app vai usar arquivos o código-fonte é alterado. Se nenhum arquivo de objeto compartilhado estiver presente ou não houver uma pasta lib: o app não vai usar código nativo.

    Visualização do APK Analyzer mostrando que os arquivos de objetos compartilhados estão presente

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 a 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 o comando bibliotecas compartilhadas.

AGP versão 8.3 ou mais recente.

Em dispositivos de 16 KB, os apps vêm com bibliotecas compartilhadas não compactadas. alinhe-as em um limite alinhado em zip de 16 KB. Para isso, você precisa fazer upgrade ao Plug-in do Android para Gradle (AGP, na sigla em inglês) versão 8.3 ou mais recente. Consulte a documentação Seção "Assistente de upgrade do plug-in do Gradle" para mais 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 é mudar para bibliotecas compartilhadas compactadas. Atualizar a configuração do Gradle para faça com que o Gradle compacte as bibliotecas compartilhadas ao empacotar seu aplicativo para evitar que ele problemas de instalação com bibliotecas compartilhadas desalinhadas.

Groovy

No seu arquivo build.gradle, adicione esta opção:

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

Kotlin

No seu arquivo build.gradle.kts, adicione esta opção:

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

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

Os dispositivos de 16 KB exigem a versão da biblioteca compartilhada Segmentos do ELF a serem alinhados corretamente usando o alinhamento ELF de 16 KB para que seu app seja executado.

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

Android NDK r26 e versões anteriores

Para oferecer compatibilidade com a compilação de bibliotecas compartilhadas alinhadas de 16 KB com o Android NDK versão r26 ou anterior, é necessário atualizar seu ndk-build ou cmake da seguinte maneira:

ndk-build

Atualize o Android.mk para ativar o alinhamento do ELF de 16 KB:

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

CMake

Atualize o CMakeLists.txt para ativar o alinhamento do 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 compatibilidade com a compilação de bibliotecas compartilhadas alinhadas de 16 KB com o Android NDK versão r27 e superior, é necessário atualizar o ndk-build, build.gradle, build.gradle.kts ou sinalizações 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

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

Mesmo que seu aplicativo esteja alinhado a 16 KB, ele pode encontrar erros se os lugares no seu código presumem 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 ao PAGE_SIZE. ou instâncias na lógica do código que pressupõem que a página de um dispositivo é 4 KB (4096).

    Use getpagesize() ou sysconf(_SC_PAGESIZE).

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

Em alguns casos, se o app usa PAGE_SIZE como um valor conveniente que não é vinculado ao tamanho da página subjacente, isso não causará falhas no aplicativo quando usada no modo de 16 KB. No entanto, se esse valor for passado para o kernel, com mmap sem MAP_FIXED, o kernel ainda usa uma página inteira, que desperdiça um pouco de memória. Por esses motivos, PAGE_SIZE é indefinido quando 16 KB está ativado no NDK r27 e versões mais recentes.

Se o app usar PAGE_SIZE dessa maneira e nunca transmitir esse valor diretamente para o kernel e, em vez de usar PAGE_SIZE, crie uma nova variável com um novo para indicar que ele é usado para outros fins e não reflete uma identidade real na página "Memória".

Testar o app em um ambiente de 16 KB

Depois de criar seu app com suporte a dispositivos de 16 KB, você vai querer testar o app em um ambiente de 16 KB para saber se ele é compatível regressões. Para isso, siga estas etapas:

  1. Configurar o SDK do Android 15.

  2. Configure um dos seguintes ambientes de teste:

  3. Inicie o dispositivo de teste e execute o seguinte comando para verificar se ele usa um ambiente de 16 KB:

    adb shell getconf PAGE_SIZE

    O comando precisa retornar um valor 16384.

  4. Para as bibliotecas compartilhadas, verifique se o arquivo Os segmentos de ELF são corretamente alinhados com o alinhamento ELF de 16 KB. É possível usar esse script para ajudar com esse processo:

    #!/bin/bash

# usage: alignment.sh path to search for *.so files

dir="$1"

RED="\e[31m"
GREEN="\e[32m"
ENDCOLOR="\e[0m"

matches="$(find $dir -name "*.so" -type f)"
IFS=$'\n'
for match in $matches; do
  res="$(objdump -p ${match} | grep LOAD | awk '{ print $NF }' | head -1)"
  if [[ $res =~ "2**14" ]] || [[ $res =~ "2**16" ]]; then
    echo -e "${match}: ${GREEN}ALIGNED${ENDCOLOR} ($res)"
  else
    echo -e "${match}: ${RED}UNALIGNED${ENDCOLOR} ($res)"
  fi
done

    1. Salve o script em um arquivo, como alignment.sh.

    2. Extraia o arquivo APK do seu app:

      unzip APK_NAME.apk -d /tmp/my_apk_out

    3. Execute o script nos arquivos extraídos no /tmp/my_apk_out diretório:

      alignment.sh /tmp/my_apk_out | grep "arm64-v8a"

      O script gera ALIGNED ou UNALIGNED para todos os arm64-v8a bibliotecas compartilhadas.

    4. Se alguma biblioteca compartilhada arm64-v8a for UNALIGNED, você precisará atualize o empacotamento dessas bibliotecas e recompile seu e teste novamente seguindo as etapas desta seção.

  5. Execute o comando zipalign a seguir para verificar se o app está 16 KB alinhado, em que APK_NAME é o nome do arquivo APK do seu app:

    zipalign -c -P 16 -v 4 APK_NAME.apk

  6. Testar minuciosamente seu app, concentrando-se em todas as áreas que podem ser afetadas alterar 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

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

  1. Imagens do sistema do emulador do Android 15 de 16 KB são compatíveis com Android Studio Jellyfish | 2023.3.1 ou mais recente. No entanto, para que as melhores ao trabalhar com o Android 15 Beta, baixe a versão mais recente versão de pré-lançamento do Android Studio.

    Vale lembrar 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 e expanda na seção Android VanillaIceCream Preview e selecione uma as seguintes imagens do sistema do emulador, dependendo dos dispositivos virtuais que você que queremos 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
    .

    Fazer o download de imagens do sistema do emulador de 16 KB usando o SDK Manager no Android Estúdio

  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 for solicitado que você escolha uma imagem do sistema, escolha a imagem de 16 KB que você fez o download. Se ele não for recomendado automaticamente, Imagem do sistema de 16 KB na guia Outras imagens.

    Encontre a imagem do emulador de 16 KB em "Other Images" .

.
  1. No Gerenciador de dispositivos, clique nos três pontos ao lado da imagem de 16 KB e clique em Mostrar no disco.
  2. Nela, localize o arquivo config.ini.

  3. Adicione a linha abaixo ao arquivo config.ini e salve as mudanças:

    kernel.parameters = androidboot.page_shift=14

  4. Para verificar as alterações, execute o comando a seguir, que deve retornar 16384:

    adb shell getconf PAGE_SIZE
Anterior
Suporte a versões de 64 bits