Inizia a utilizzare NDK
Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
Il Native Development Kit (NDK) è un insieme di strumenti che consente di utilizzare
e C++ con Android e fornisce librerie di piattaforma che puoi usare per gestire
le attività native e l'accesso a componenti fisici dei dispositivi, come sensori e
input tocco. L'NDK potrebbe non essere appropriato per la maggior parte dei neofiti di Android
programmatori che devono usare solo API di framework e di codice Java per sviluppare
le loro app. Tuttavia, l'NDK può essere utile nei casi in cui sia necessario farlo
uno o più dei seguenti elementi:
- Riduci le prestazioni di un dispositivo per ottenere una bassa latenza o eseguire
applicazioni ad alta intensità di calcolo, come giochi o simulazioni di fisica.
- Riutilizza i tuoi strumenti o quelli di altri sviluppatori C o C++.
Con Android Studio 2.2 e versioni successive puoi:
usa NDK per compilare il codice C e C++ in una libreria nativa e pacchettizzarla
nell'APK usando Gradle, il sistema di build integrato dell'IDE. Il tuo codice Java
può quindi chiamare le funzioni nella tua libreria nativa tramite il framework Java Native Interface (JNI). Per ulteriori informazioni
per saperne di più su Gradle e sul sistema di build Android, leggi l'articolo Configura la tua build.
Lo strumento di creazione predefinito di Android Studio per compilare le librerie native è CMake. Anche Android Studio
supporta ndk-build a causa delle grandi
di progetti esistenti che usano il toolkit di creazione. Tuttavia, se
creando una nuova libreria nativa, dovresti usare CMake.
Questa guida ti fornisce le informazioni necessarie per iniziare a utilizzare il
NDK su Android Studio. Se non hai l'ultima versione di Android
Studio, scaricalo e installalo ora.
Attenzione agli utenti Gradle sperimentali: prendi in considerazione
migrazione al plug-in versione 2.2.0 o successiva e all'utilizzo di CMake o ndk-build
per creare le tue librerie native se una delle seguenti condizioni si applica al tuo caso:
il progetto nativo utilizza già CMake o ndk-build; preferiresti utilizzare una versione stabile
del sistema di compilazione Gradle; o se hai bisogno di assistenza
per strumenti aggiuntivi,
ad esempio CCache.
Altrimenti, puoi continuare a utilizzare
la versione sperimentale di Gradle e il plug-in Android.
Scarica l'NDK e gli strumenti
Per compilare ed eseguire il debug di codice nativo per la tua app, devi avere quanto segue
componenti:
- Android Native Development Kit (NDK), una serie di strumenti che ti consente
per utilizzare il codice C e C++ con Android.
- CMake: uno strumento di creazione esterno che funziona insieme a Gradle per creare
libreria nativa. Non ti serve questo componente se prevedi di utilizzarlo
ndk-build.
-
LLDB: il debugger utilizzato da Android Studio per eseguire il debug del codice nativo.
Per informazioni sull'installazione di questi componenti, consulta l'articolo Installare e configurare NDK e CMake.
Creare o importare un progetto nativo
Dopo aver configurato Android Studio, puoi semplicemente creare un nuovo progetto con
C/C++. Tuttavia, se vuoi aggiungere o importare codice nativo in una
progetto Android Studio esistente, devi seguire questa procedura di base:
-
Crea nuovo
nativi di origine e aggiungili al tuo progetto Android Studio.
- Puoi saltare questo passaggio se hai già del codice nativo o se vuoi
importare una libreria nativa predefinita.
-
Crea
uno script di build CMake per indicare a CMake come creare le tue origini native
in una biblioteca. Questo script di compilazione è necessario anche se importi e
il collegamento a librerie
predefinite o della piattaforma.
- Puoi saltare questo passaggio se la tua libreria nativa esistente ha già un
CMakeLists.txt oppure utilizza ndk-build e include
Android.mk
di compilazione.
-
Collega Gradle a
tua libreria nativa fornendo un percorso per CMake o ndk-build
del file di script. Gradle utilizza lo script di build per importare il codice sorgente
progetto Android Studio e pacchettizza la tua libreria nativa (il file SO) in
l'APK.
Nota:se il progetto esistente utilizza il modello deprecato
ndkCompile, dovresti aprire
build.properties e rimuovi la seguente riga di codice
prima di configurare Gradle per l'utilizzo di CMake o ndk-build:
// Remove this line
android.useDeprecatedNdk = true
-
Crea ed esegui la tua app facendo clic su
Esegui
. Aggiunte da Gradle
il tuo processo CMake o ndk-build come dipendenza per compilare,
pacchettizzare la tua libreria nativa con il tuo APK.
Quando l'app è in esecuzione su un dispositivo fisico o sull'emulatore, puoi usare
Android Studio per eseguire il debug dell'app.
In caso contrario, per saperne di più sull'NDK e sui suoi componenti, leggi la pagina Concetti.
I campioni di contenuti e codice in questa pagina sono soggetti alle licenze descritte nella Licenza per i contenuti. Java e OpenJDK sono marchi o marchi registrati di Oracle e/o delle sue società consociate.
Ultimo aggiornamento 2025-07-26 UTC.
[[["Facile da capire","easyToUnderstand","thumb-up"],["Il problema è stato risolto","solvedMyProblem","thumb-up"],["Altra","otherUp","thumb-up"]],[["Mancano le informazioni di cui ho bisogno","missingTheInformationINeed","thumb-down"],["Troppo complicato/troppi passaggi","tooComplicatedTooManySteps","thumb-down"],["Obsoleti","outOfDate","thumb-down"],["Problema di traduzione","translationIssue","thumb-down"],["Problema relativo a esempi/codice","samplesCodeIssue","thumb-down"],["Altra","otherDown","thumb-down"]],["Ultimo aggiornamento 2025-07-26 UTC."],[],[],null,["# Get started with the NDK\n\nThe Native Development Kit (NDK) is a set of tools that allows you to use C\nand C++ code with Android, and provides [platform libraries](/ndk/guides/stable_apis) you can use to manage\nnative activities and access physical device components, such as sensors and\ntouch input. The NDK may not be appropriate for most novice Android\nprogrammers who need to use only Java code and framework APIs to develop\ntheir apps. However, the NDK can be useful for cases in which you need to do\none or more of the following:\n\n- Squeeze extra performance out of a device to achieve low latency or run computationally intensive applications, such as games or physics simulations.\n- Reuse your own or other developers' C or C++ libraries.\n\n\nUsing [Android Studio 2.2 and higher](/studio), you can\nuse the NDK to compile C and C++ code into a native library and package it\ninto your APK using Gradle, the IDE's integrated build system. Your Java code\ncan then call functions in your native library through the [Java Native Interface (JNI)](http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) framework. To learn\nmore about Gradle and the Android build system, read [Configure Your Build](/studio/build).\n\n\nAndroid Studio's default build tool to compile native libraries is [CMake](https://cmake.org/). Android Studio also\nsupports [ndk-build](/ndk/guides/ndk-build) due to the large\nnumber of existing projects that use the build toolkit. However, if you are\ncreating a new native library, you should use CMake.\n\n\nThis guide gives you the information you need to get up and running with the\nNDK on Android Studio. If you don't have the latest version of Android\nStudio, [download and install it now](/studio).\n\n\n**Attention experimental Gradle users:** Consider [migrating to plugin version 2.2.0 or higher](http://tools.android.com/tech-docs/new-build-system/gradle-experimental/migrate-to-stable), and using CMake or ndk-build\nto build your native libraries if any of the following apply to you: Your\nnative project already uses CMake or ndk-build; you would rather use a stable\nversion of the Gradle build system; or you want support for add-on tools,\nsuch as [CCache](https://ccache.samba.org/).\nOtherwise, you can continue to [use\nthe experimental version of Gradle and the Android plugin](http://tools.android.com/tech-docs/new-build-system/gradle-experimental).\n\nDownload the NDK and tools\n--------------------------\n\n\nTo compile and debug native code for your app, you need the following\ncomponents:\n\n- The Android Native Development Kit (NDK): a set of tools that allows you to use C and C++ code with Android.\n- CMake: an external build tool that works alongside Gradle to build your native library. You do not need this component if you only plan to use ndk-build.\n- *LLDB*: the debugger Android Studio uses to debug native code.\n\n\nFor information on installing these components, see [Install and configure the NDK and CMake](/studio/projects/install-ndk).\n\nCreate or import a native project\n---------------------------------\n\n\nOnce you set up Android Studio, you can simply [Create a New Project with\nC/C++ Support](/studio/projects/add-native-code#new-project). However, if you want to add or import native code to an\nexisting Android Studio project, you need to follow this basic process:\n\n1. [Create new\n native source files](/studio/projects/add-native-code#create-sources) and add them to your Android Studio project.\n - You can skip this step if you already have native code or want to import a prebuilt native library.\n2. [Create\n a CMake build script](/studio/projects/configure-cmake#create_script) to tell CMake how to build your native sources into a library. You also require this build script if you are importing and linking against prebuilt or platform libraries.\n - You can skip this step if your existing native library already has a `CMakeLists.txt` build script, or uses ndk-build and includes an [`Android.mk`](/ndk/guides/android_mk) build script.\n3. [Link Gradle to\n your native library](/studio/projects/gradle-external-native-builds) by providing a path to your CMake or ndk-build script file. Gradle uses the build script to import source code into your Android Studio project and package your native library (the SO file) into the APK.\n\n\n **Note:** If your existing project uses the deprecated\n `ndkCompile` tool, you should open your\n `build.properties` file and remove the following line of code\n before configuring Gradle to use CMake or ndk-build: \n\n ```\n // Remove this line\n android.useDeprecatedNdk = true\n ```\n4. [Build and run your app](/studio/run) by clicking **Run** . Gradle adds your CMake or ndk-build process as a dependency to compile, build, and package your native library with your APK.\n\n\nOnce your app is running on a physical device or the emulator, you can use\nAndroid Studio to [Debug your app](/studio/debug).\nOtherwise, to learn more about the NDK and its components, read the [Concepts](/ndk/guides/concepts) page."]]
