Android NDK Download 21: Como instalar e usar a versão mais recente
Se você é um desenvolvedor Android que deseja melhorar o desempenho, a segurança e a compatibilidade de seu aplicativo, considere o uso do Android Native Development Kit (NDK). O Android NDK é um conjunto de ferramentas que permite implementar partes do seu aplicativo em código nativo, usando linguagens como C e C++. Neste artigo, mostraremos como baixar e instalar a última versão do Android NDK, que é a 21, e como utilizá-la em seu aplicativo Android. Também abordaremos alguns problemas comuns que você pode encontrar ao usar o Android NDK e como corrigi-los.
O que é o Android NDK e por que você precisa dele?
O Android NDK é um conjunto de ferramentas que permite acessar bibliotecas de código nativo do seu código Java ou Kotlin. As bibliotecas de código nativo são compiladas para uma arquitetura de processador específica, como ARM ou x86, e podem ser executadas com mais rapidez e eficiência do que o código Java ou Kotlin. As bibliotecas de código nativo também podem fornecer recursos que não estão disponíveis na estrutura do Android, como acesso de baixo nível a hardware, gráficos, áudio e rede.
android ndk download 21
Os benefícios de usar código nativo em seu aplicativo Android
Usar código nativo em seu aplicativo Android pode ter várias vantagens, como:
Desempenho: O código nativo pode ser executado mais rapidamente e usar menos memória do que o código Java ou Kotlin, especialmente para tarefas computacionais intensivas, como processamento de imagem, criptografia ou aprendizado de máquina.
Segurança: O código nativo pode ser mais difícil de fazer engenharia reversa ou adulterar do que o código Java ou Kotlin, que pode proteger seu aplicativo contra hackers ou piratas.
Compatibilidade: O código nativo pode ajudá-lo a oferecer suporte a dispositivos mais antigos ou dispositivos com arquiteturas diferentes daquelas compatíveis com a estrutura do Android.
Os desafios de usar código nativo em seu aplicativo Android
O uso de código nativo em seu aplicativo Android também pode ter algumas desvantagens, como:
Complexidade: O código nativo pode ser mais difícil de escrever, depurar e manter do que o código Java ou Kotlin, especialmente se você não estiver familiarizado com as linguagens ou ferramentas nativas.
Portabilidade: O código nativo pode ser menos portátil do que o código Java ou Kotlin, o que significa que você pode ter que escrever diferentes versões de sua biblioteca nativa para diferentes arquiteturas ou plataformas.
Estabilidade: O código nativo pode causar falhas ou vazamentos de memória se não for escrito corretamente ou se interagir mal com o código Java ou Kotlin.
Como baixar e instalar o Android NDK 21
Para usar o Android NDK em seu aplicativo, você precisa baixá-lo e instalá-lo em sua máquina de desenvolvimento. Existem duas maneiras de fazer isso: usando o Android Studio ou manualmente.
Os pré-requisitos para instalar o Android NDK 21
Antes de instalar o Android NDK 21, você precisa se certificar de que possui os seguintes pré-requisitos:
Um IDE: Você precisa de um ambiente de desenvolvimento integrado (IDE) que suporte o desenvolvimento nativo, como , que é o IDE oficial para desenvolvimento Android.
um JDK : Você precisa de um Java Development Kit (JDK) que corresponda à versão mínima exigida pelo Android Studio, que é o JDK 11. Você pode baixá-lo em ou use o que acompanha o Android Studio.
Um CMake: Você precisa de uma ferramenta CMake que possa gerar scripts de compilação nativos para seu projeto de biblioteca nativa. Você pode baixá-lo de ou use o que acompanha o Android Studio.
Um NDK: Você precisa de um Android NDK que corresponda à versão mínima exigida pelo seu aplicativo, que é NDK 21. Você pode baixá-lo em ou use o que acompanha o Android Studio.
As etapas para instalar o Android NDK 21 usando o Android Studio
A maneira mais fácil de instalar o Android NDK 21 é usar o Android Studio, que pode baixar e configurar automaticamente o NDK para você. Aqui estão os passos a seguir:
Abra o Android Studio e crie um novo projeto ou abra um existente.
Vá para Arquivo > Estrutura do Projeto > Localização do SDK.
Sob Localização do Android NDK, clique Download.
Selecione NDK (lado a lado) e escolha 21.4.7075529, que é a versão estável mais recente do NDK 21.
Clique OK e aguarde o download terminar.
Clique Aplicar e OK.
Parabéns, você instalou com sucesso o Android NDK 21 usando o Android Studio!
As etapas para instalar o Android NDK 21 manualmente
Se preferir instalar o Android NDK 21 manualmente, siga estes passos:
Vá para e baixe o pacote NDK para seu sistema operacional.
Extraia o pacote NDK para um local de sua escolha, como C:\Android\ndk\21.4.7075529.
Adicione o local do NDK às variáveis de ambiente do sistema, como ANDROID_NDK_HOME=C:\Android\ndk\21.4.7075529.
Adicione o local do NDK ao arquivo local.properties do seu projeto, como ndk.dir=C\:\Android\ndk\21.4.7075529.
Parabéns, você instalou com sucesso o Android NDK 21 manualmente!
Como usar o Android NDK 21 em seu aplicativo Android
Para usar o Android NDK 21 em seu aplicativo, você precisa criar um projeto de biblioteca nativa, vinculá-lo ao módulo de seu aplicativo e chamar métodos nativos de seu código Java ou Kotlin.
Como criar um projeto de biblioteca nativa usando CMake
Um projeto de biblioteca nativa é uma pasta que contém seus arquivos de origem nativa, como arquivos C ou C++, e um arquivo CMakeLists.txt que define como construir sua biblioteca nativa. Aqui estão as etapas para criar um projeto de biblioteca nativa usando o CMake:
Crie uma pasta chamada jniLibs sob o módulo do seu aplicativo origem/principal pasta.
Crie uma subpasta chamada cpp debaixo de jniLibs pasta.
Crie um arquivo chamado CMakeLists.txt debaixo de jniLibs/cpp pasta.
Edite o CMakeLists.txt arquivo e adicione o seguinte conteúdo:
# Defina a versão mínima do CMake necessária cmake_minimum_required(VERSION 3.10.2) # Defina o nome do seu projeto de biblioteca nativa project("my-native-lib") # Adicione seus arquivos de origem nativa add_library(my-native-lib SHARED my-native-lib.cpp) # Encontre e vincule a biblioteca de log find_library(log-lib log) target_link_libraries(my-native-lib $log-lib)
Crie um arquivo chamado minha-nativa-lib.cpp debaixo de jniLibs/cpp pasta.
Edite o minha-nativa-lib.cpp arquivo e adicione o seguinte conteúdo:
# # Inclua o arquivo de cabeçalho JNI #include
# Inclua o arquivo de cabeçalho de log do Android #include
# Defina uma macro para registro #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "my-native-lib", __VA_ARGS__)) # Defina um método nativo que retorne uma string extern "C" JNIEXPORT jstring JNICALL Java_com_example_mynativelib_MainActivity_stringFromJNI( JNIEnv* env, jobject /* this */) LOGI(" Olá do código nativo"); std::string olá = "Olá do C++"; return env->NewStringUTF(hello.c_str());
Parabéns, você criou com sucesso um projeto de biblioteca nativa usando o CMake!
Como vincular sua biblioteca nativa ao módulo do aplicativo
Para vincular sua biblioteca nativa ao módulo do aplicativo, você precisa editar o arquivo build.gradle do módulo do aplicativo e adicionar o seguinte conteúdo:
android ... # Enable CMake support externalNativeBuild cmake path "src/main/jniLibs/cpp/CMakeLists.txt" version "3.10.2" # Especifique os ABIs que você deseja suportar defaultConfig ... externalNativeBuild cmake abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
Após editar o arquivo build.gradle, sincronize seu projeto com os arquivos Gradle e aguarde a construção da biblioteca nativa.
Como chamar métodos nativos do seu código Java ou Kotlin
Para chamar métodos nativos do seu código Java ou Kotlin, você precisa fazer o seguinte:
Declare os métodos nativos em sua classe Java ou Kotlin usando o nativo palavra-chave e o @JvmStatic anotação (somente para Kotlin).
Carregue sua biblioteca nativa usando o System.loadLibrary() método em um bloco estático ou um iniciar bloco (somente para Kotlin).
Chame seus métodos nativos de seu código Java ou Kotlin como você chamaria qualquer outro método.
Por exemplo, se você quiser chamar o stringFromJNI() método da sua classe MainActivity, você pode escrever algo assim:
// Para Java public class MainActivity extends AppCompatActivity // Declara o método nativo public static native String stringFromJNI(); // Carrega a biblioteca nativa static System.loadLibrary("my-native-lib"); @Override protected void onCreate(Bundle saveInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Chame o método nativo e exiba o resultado TextView tv = findViewById(R.id.sample_text); tv.setText(stringFromJNI()); // Para classe Kotlin MainActivity : AppCompatActivity() // Declare o objeto companheiro do método nativo @JvmStatic external fun stringFromJNI(): String // Carrega a biblioteca nativa init System.loadLibrary("my-native-lib") override fun onCreate(savedInstanceState: Bundle?) super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // Chamada o método nativo e exibir o resultado sample_text.text = stringFromJNI()
Parabéns, você chamou com sucesso os métodos nativos do seu código Java ou Kotlin!
Como solucionar problemas comuns com o Android NDK 21
Às vezes, você pode encontrar alguns problemas ao usar o Android NDK 21 em seu aplicativo, como erros durante a compilação, vinculação ou tempo de execução.Aqui estão alguns problemas comuns e como corrigi-los:
Como corrigir erros de ABIs incompatíveis
Se você vir uma mensagem de erro como esta:
Erro: as seguintes ABIs são incompatíveis com o dispositivo de destino: armeabi-v7a. Remova esses ABIs de build.gradle ou use um dispositivo compatível.
Isso significa que você está tentando executar seu aplicativo em um dispositivo que não oferece suporte às ABIs especificadas em seu arquivo build.gradle. Para corrigir isso, você pode:
Remova as ABIs incompatíveis do arquivo build.gradle: Por exemplo, se o seu dispositivo suporta apenas arm64-v8a, você pode remover armeabi-v7a, x86 e x86_64 de seus abiFilters.
Use um dispositivo ou emulador compatível: Por exemplo, se quiser testar seu aplicativo em todas as ABIs, você pode usar um dispositivo ou emulador compatível com todas as ABIs, como um Pixel 4 XL ou um Nexus 5X.
Como corrigir erros de referência indefinidos
Se você vir uma mensagem de erro como esta:
Erro: referência indefinida a 'some_function'
Isso significa que você está tentando usar uma função que não está definida em sua biblioteca nativa ou em qualquer uma das bibliotecas às quais você vinculou. Para corrigir isso, você pode:
Defina a função em sua biblioteca nativa: Por exemplo, se você estiver chamando uma função chamada alguma_função de seu código nativo, você precisa ter certeza de que o definiu em seu arquivo de origem nativo ou arquivo de cabeçalho.
Link para a biblioteca que contém a função: Por exemplo, se você estiver usando uma função de outra biblioteca nativa, como libpng, você precisa ter certeza de que o adicionou ao seu target_link_libraries comando em seu arquivo CMakeLists.txt.
Como corrigir erros de arquivos de cabeçalho ausentes
Se você vir uma mensagem de erro como esta:
Erro: erro fatal: arquivo 'some_header.h' não encontrado
Isso significa que você está tentando incluir um arquivo de cabeçalho que não foi encontrado em sua biblioteca nativa ou em nenhum dos diretórios que você especificou. Para corrigir isso, você pode:
Adicione o arquivo de cabeçalho à sua biblioteca nativa: Por exemplo, se você estiver incluindo um arquivo de cabeçalho chamado some_header.h de seu código nativo, você precisa certificar-se de que o adicionou à pasta ou subpasta do projeto da biblioteca nativa.
Adicione o diretório que contém o arquivo de cabeçalho ao seu arquivo CMakeLists.txt: Por exemplo, se você estiver usando um arquivo de cabeçalho de outra biblioteca nativa, como libpng, você precisa ter certeza de que adicionou seu diretório ao seu include_directories comando em seu arquivo CMakeLists.txt.
Conclusão
Neste artigo, aprendemos como baixar e instalar o Android NDK 21, como usá-lo em nosso aplicativo Android e como solucionar alguns problemas comuns com ele. Vimos que o Android NDK pode nos ajudar a melhorar o desempenho, a segurança e a compatibilidade de nosso aplicativo usando bibliotecas de código nativas. No entanto, também vimos que o uso de código nativo pode introduzir alguns desafios de complexidade, portabilidade e estabilidade. Portanto, devemos usar o Android NDK com sabedoria e somente quando necessário.
Esperamos que este artigo tenha sido útil e informativo para você. Se você tiver alguma dúvida ou feedback, sinta-se à vontade para deixar um comentário abaixo. Obrigado por ler!
perguntas frequentes
Aqui estão algumas perguntas frequentes sobre o Android NDK 21 e suas respostas:
Qual é a diferença entre o Android NDK e o Android SDK?
O Android SDK (Software Development Kit) é um conjunto de ferramentas que permite desenvolver aplicativos Android usando código Java ou Kotlin. O Android SDK fornece acesso à estrutura do Android, que é uma coleção de bibliotecas e APIs que fornecem funcionalidade comum para aplicativos Android, como interface do usuário, rede, mídia, localização etc.
O Android NDK (Native Development Kit) é um conjunto de ferramentas que permite desenvolver partes do seu aplicativo usando código nativo, como C ou C++.O Android NDK fornece acesso a bibliotecas de código nativo, que são compiladas para uma arquitetura de processador específica e podem ser executadas com mais rapidez e eficiência do que o código Java ou Kotlin. As bibliotecas de código nativo também podem fornecer recursos que não estão disponíveis na estrutura do Android, como acesso de baixo nível a hardware, gráficos, áudio e rede.
Quando devo usar o Android NDK?
Você deve usar o Android NDK somente quando precisar:
Melhore o desempenho do seu aplicativo: Se seu aplicativo tiver algumas tarefas computacionais intensivas que exigem alta velocidade ou baixo uso de memória, como processamento de imagem, criptografia ou aprendizado de máquina, convém usar código nativo para otimizá-las.
Melhore a segurança do seu aplicativo: Se seu aplicativo tiver alguns dados ou lógica confidenciais que você deseja proteger contra engenharia reversa ou adulteração, convém usar o código nativo para ofuscar.
Melhore a compatibilidade do seu aplicativo: Se seu aplicativo precisar oferecer suporte a dispositivos mais antigos ou dispositivos com arquiteturas diferentes daquelas compatíveis com a estrutura do Android, como dispositivos de baixo custo ou personalizados, convém usar o código nativo para oferecer suporte a eles.
No entanto, você não deve usar o Android NDK se não precisar, porque ele pode introduzir alguns desafios de complexidade, portabilidade e estabilidade. Para a maioria dos aplicativos Android, o Android SDK é suficiente e recomendado.
Como posso atualizar o Android NDK?
Para atualizar o Android NDK, você pode usar o Android Studio ou baixar e instalar manualmente a versão mais recente do NDK. Aqui estão os passos a seguir:
Usando o Android Studio:
Abra o Android Studio e vá para Ferramentas > SDK Manager.
Selecione Ferramentas do SDK e verifique NDK (lado a lado).
Selecione a versão mais recente do NDK que deseja instalar, como 23.0.7599858.
Clique OK e aguarde o download e a instalação terminarem.
Vá para Arquivo > Estrutura do Projeto > Localização do SDK.
Sob Localização do Android NDK, selecione a versão mais recente do NDK que você instalou.
Clique Aplicar e OK.
Manualmente:
Vá para e baixe a versão mais recente do pacote NDK para seu sistema operacional.
Exclua ou renomeie sua pasta antiga do NDK, como C:\Android\ndk\21.4.7075529.
Extraia o novo pacote NDK para o mesmo local da pasta antiga do NDK, como C:\Android\ndk\23.0.7599858.
Adicione o novo local do NDK às variáveis de ambiente do sistema, como ANDROID_NDK_HOME=C:\Android\ndk\23.0.7599858.
Adicione o novo local do NDK ao arquivo local.properties do projeto, como ndk.dir=C\:\Android\ndk\23.0.7599858.
Como posso saber mais sobre o Android NDK?
Se quiser saber mais sobre o Android NDK, confira os seguintes recursos:
: esta é a documentação oficial do Android NDK, onde você pode encontrar guias, tutoriais, materiais de referência e amostras para usar o NDK em seu aplicativo.
: esta é uma série de codelabs que ensinam como criar apps Android usando código Java ou Kotlin e bibliotecas de código nativas.
: Este é um curso online gratuito que ensina como criar aplicativos Android usando código Kotlin e bibliotecas de código nativas.
: Este é um tutorial que ensina como usar o CMake para criar e construir projetos de biblioteca nativa para seu aplicativo Android.
Espero que você tenha gostado de ler este artigo e aprendido algo novo. Se você tiver alguma dúvida ou feedback, sinta-se à vontade para deixar um comentário abaixo. Obrigado por ler! 0517a86e26
Comments