Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
Prima di iniziare
Questa guida presuppone che tu abbia già familiarità con i concetti relativi ai
programmazione nativa e nello sviluppo Android.
Introduzione
Questa sezione fornisce una spiegazione generale del funzionamento dell'NDK. Android NDK è un insieme
che consentono di incorporare C o C++ ("codice nativo") nelle app per Android. Possibilità di utilizzare
il codice nativo nelle app per Android può essere particolarmente utile per gli sviluppatori che vogliono eseguire una o più delle
le seguenti:
Trasferire le app tra piattaforme.
Riutilizza le librerie esistenti o fornisci le proprie librerie per il riutilizzo.
Aumentare le prestazioni in alcuni casi, in particolare ad alta intensità di calcolo
come i giochi.
Come funziona
Questa sezione introduce i componenti principali utilizzati per creare un
per Android, oltre a descrivere il processo di creazione e
pacchettizzazione.
Componenti principali
Durante la creazione dei tuoi annunci, dovresti aver compreso i seguenti componenti
dell'app:
Librerie condivise native: NDK crea queste librerie, o file .so, da
codice sorgente C/C++.
Librerie statiche native: NDK può anche creare librerie statiche oppure .a
che puoi collegare ad altre librerie.
Java Native Interface (JNI): JNI è l'interfaccia attraverso la quale le interfacce Java e
I componenti C++ comunicano tra loro. Questa guida presuppone la conoscenza di JNI;
Per informazioni al riguardo, consulta la Specifica dell'interfaccia nativa Java.
Application Binary Interface (ABI): l'ABI definisce esattamente il modo in cui
il codice della macchina deve interagire
con il sistema in fase di runtime. NDK
crea file .so in base a queste definizioni. ABI diverse corrispondono
diverse architetture: NDK include il supporto ABI per ARM a 32 bit, AArch64,
x86 e x86-64. Per ulteriori informazioni, vedi Android
ABI.
Crea un file Android.mk che descriva la libreria nativa, inclusi nome,
tramite flag, librerie collegate e file sorgente da compilare nel file
.
Se vuoi, puoi creare un file Application.mk configurando il target
ABI, toolchain, modalità di rilascio/debug e STL. Per qualsiasi attività che
non viene specificato, vengono utilizzati, rispettivamente, i seguenti valori predefiniti:
ABI: tutte le ABI non deprecate
Modalità: pubblicazione
STL: sistema
Inserisci l'origine nativa nella directory jni del progetto.
Utilizza ndk-build per compilare le librerie native (.so, .a).
Crea il componente Java, producendo il file eseguibile .dex.
Pacchettizza tutto in un file APK, contenente .so, .dex e altri
necessari per l'esecuzione dell'app.
Attività e applicazioni native
L'SDK Android fornisce una classe helper, nativeActivity, che ti consente di:
scrivere un'attività completamente nativa. nativeActivity gestisce la comunicazione
tra il framework Android e il codice nativo,
o chiamarne i metodi. Devi solo dichiarare la tua richiesta
in modo che sia nativo nel file AndroidManifest.xml e iniziare a creare
un'applicazione.
Un'app Android che utilizza nativeActivity viene ancora eseguita nel proprio
sandbox da altre applicazioni. Pertanto, puoi continuare ad accedere
API framework Android tramite JNI. In alcuni casi, ad esempio per i sensori,
eventi di input e asset, l'NDK fornisce interfacce native che puoi utilizzare
invece di dover chiamare attraverso la JNI. Per ulteriori informazioni su
vedi API native.
Che tu stia sviluppando o meno un'attività nativa,
di creare progetti con gli strumenti
di build Android tradizionali. In questo modo
aiuta a garantire lo sviluppo e la pacchettizzazione delle app Android con il corretto
alla struttura del centro di costo.
L'NDK di Android offre due opzioni per implementare l'attività nativa:
L'intestazione native_activity.h.
definisce la versione nativa della classe NativeActivity. Contiene i parametri
l'interfaccia di callback e le strutture di dati necessarie per creare il tuo
attività. Poiché il thread principale dell'applicazione gestisce i callback,
le implementazioni dei callback non devono bloccare. Se vengono bloccati,
ricevono errori ANR (L'applicazione non risponde) perché il thread principale è
non risponde finché non viene restituito il callback.
Il file android_native_app_glue.h definisce una libreria helper statica basata su
in alto nell'interfaccia native_activity.h. Genera un altro filo, che
gestisce elementi come i callback o gli eventi di input in un loop di eventi. In movimento
a questi eventi in un thread separato, impedisce ai callback di bloccare
thread principale.
<ndk_root>/sources/android/native_app_glue/android_native_app_glue.c
è disponibile anche un codice sorgente, che consente di modificare l'implementazione.
Per ulteriori informazioni su come utilizzare questa libreria statica, esamina le
un'applicazione di esempio di attività nativa e la relativa documentazione. Per approfondire l'argomento
disponibile anche nei commenti nella
<ndk_root>/sources/android/native_app_glue/android_native_app_glue.h
.
Usa l'interfaccia native_activity.h
Per implementare un'attività nativa con l'interfaccia native_activity.h:
Crea una directory jni/ nella directory root del progetto. Questa directory
memorizza tutto il tuo codice nativo.
Dichiara la tua attività nativa nel file AndroidManifest.xml.
Poiché l'applicazione non ha codice Java, imposta android:hasCode su false.
L'attributo android:value del tag meta-data specifica il nome di
la libreria condivisa contenente il punto di accesso all'applicazione (come
C/C++ main), omettendo il prefisso lib e il suffisso .so dalla raccolta
nome.
Crea un file per l'attività nativa e implementa la funzione denominata in
la variabile A NativeActivity_onCreate. L'app chiama questa funzione quando
l'attività nativa. Questa funzione, analoga a main in C/C++, riceve
Un puntatore a una struttura A NativeActivity, che contiene puntatori di funzione
alle varie implementazioni di callback che devi scrivere. Imposta il parametro
puntatori delle funzioni di callback applicabili in ANativeActivity->callbacks a
le implementazioni dei callback.
Imposta il campo ANativeActivity->instance sull'indirizzo di qualsiasi istanza di
i dati specifici che vuoi utilizzare.
Implementa qualsiasi altra cosa che vuoi venga eseguita dalla tua attività all'avvio.
Implementa gli altri callback impostati in
ANativeActivity->callbacks. Per ulteriori informazioni su quando i callback vengono
consulta la sezione Gestione del ciclo di vita delle attività.
Sviluppa il resto dell'applicazione.
Crea un Android.mk file nella directory jni/ del tuo progetto per
per descrivere il modulo nativo al sistema di compilazione. Per ulteriori informazioni, vedi
Android.mk.
Una volta creato il file Android.mk, compila il codice nativo utilizzando
Comando ndk-build.
cd<path>/<to>/<project>
$NDK/ndk-build
Crea e installa il tuo progetto Android come di consueto. Se il codice nativo è in
nella directory jni/, lo script di build pacchettizza automaticamente .so
integrati nell'APK.
Codice campione aggiuntivo
Per scaricare i campioni NDK, consulta la sezione Campioni NDK.
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-27 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-27 UTC."],[],[],null,["# Concepts\n\nBefore you begin\n----------------\n\nThis guide assumes that you are already familiar with concepts inherent in\nnative programming and in [Android development](/develop).\n\nIntroduction\n------------\n\nThis section provides a high-level explanation of how the NDK works. The Android NDK is a set of\ntools allowing you to embed C or C++ (\"native code\") into your Android apps. The ability to use\nnative code in Android apps can be particularly useful to developers who wish to do one or more of\nthe following:\n\n- Port their apps between platforms.\n- Reuse existing libraries, or provide their own libraries for reuse.\n- Increase performance in certain cases, particularly computationally intensive ones like games.\n\nHow it works\n------------\n\nThis section introduces the main components used in building a native\napplication for Android, and goes on to describe the process of building and\npackaging.\n\n### Main components\n\nYou should have an understanding of the following components as you build your\napp:\n\n- Native shared libraries: The NDK builds these libraries, or `.so` files, from\n your C/C++ source code.\n\n- Native static libraries: The NDK can also build static libraries, or `.a`\n files, which you can link into other libraries.\n\n- Java Native Interface (JNI): The JNI is the interface via which the Java and\n C++ components talk to one another. This guide assumes knowledge of the JNI;\n for information about it, consult the [Java Native Interface Specification](http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html).\n\n- Application Binary Interface (ABI): The ABI defines exactly how your app's\n machine code is expected to interact with the system at runtime. The NDK\n builds `.so` files against these definitions. Different ABIs correspond to\n different architectures: The NDK includes ABI support for 32-bit ARM, AArch64,\n x86, and x86-64. For more information, see [Android\n ABIs](/ndk/guides/abis).\n\n- Manifest: If you are writing an app with no Java component to it, you must\n declare the [NativeActivity](/reference/android/app/NativeActivity) class in the\n [manifest](/guide/topics/manifest/manifest-intro). See [Use the\n native_activity.h interface](#na) for more detail on how to do this.\n\n### Flow\n\nThe general flow for developing a native app for Android is as follows:\n\n1. Design your app, deciding which parts to implement in Java, and which parts\n to implement as native code.\n\n | **Note:** While it is possible to completely avoid Java, you are likely to find the Android Java framework useful for tasks including controlling the display and UI.\n2. Create an Android app Project as you would for any other Android project.\n\n3. If you are writing a native-only app, declare the [NativeActivity](/reference/android/app/NativeActivity) class in\n `AndroidManifest.xml`. For more information, see the [Native activities and\n applications](#naa).\n\n4. Create an `Android.mk` file describing the native library, including name,\n flags, linked libraries, and source files to be compiled in the \"JNI\"\n directory.\n\n5. Optionally, you can create an `Application.mk` file configuring the target\n ABIs, toolchain, release/debug mode, and STL. For any of these that you do\n not specify, the following default values are used, respectively:\n\n - ABI: all non-deprecated ABIs\n - Mode: Release\n - STL: system\n6. Place your native source under the project's `jni` directory.\n\n7. Use ndk-build to compile the native (`.so`, `.a`) libraries.\n\n8. Build the Java component, producing the executable `.dex` file.\n\n9. Package everything into an APK file, containing `.so`, `.dex`, and other\n files needed for your app to run.\n\nNative activities and applications\n----------------------------------\n\nThe Android SDK provides a helper class, [NativeActivity](/reference/android/app/NativeActivity), that allows you to\nwrite a completely native activity. [NativeActivity](/reference/android/app/NativeActivity) handles the communication\nbetween the Android framework and your native code, so you do not have to\nsubclass it or call its methods. All you need to do is declare your application\nto be native in your `AndroidManifest.xml` file, and begin creating your native\napplication.\n\nAn Android application using [NativeActivity](/reference/android/app/NativeActivity) still runs in its own virtual\nmachine, sandboxed from other applications. You can therefore still access\nAndroid framework APIs through the JNI. In certain cases, such as for sensors,\ninput events, and assets, the NDK provides native interfaces that you can use\ninstead of having to call across the JNI. For more information about such\nsupport, see [Native APIs](/ndk/guides/stable_apis).\n\nRegardless of whether or not you are developing a native activity, we recommend\nthat you create your projects with the traditional Android build tools. Doing so\nhelps ensure building and packaging of Android applications with the correct\nstructure.\n\nThe Android NDK provides you with two choices to implement your native activity:\n\n- The [native_activity.h](/ndk/reference/native__activity_8h) header defines the native version of the [NativeActivity](/reference/android/app/NativeActivity) class. It contains the callback interface and data structures that you need to create your native activity. Because the main thread of your application handles the callbacks, your callback implementations must not be blocking. If they block, you might receive ANR (Application Not Responding) errors because your main thread is unresponsive until the callback returns.\n- The `android_native_app_glue.h` file defines a static helper library built on top of the [native_activity.h](/ndk/reference/native__activity_8h) interface. It spawns another thread, which handles things such as callbacks or input events in an event loop. Moving these events to a separate thread prevents any callbacks from blocking your main thread.\n\nThe `\u003cndk_root\u003e/sources/android/native_app_glue/android_native_app_glue.c`\nsource is also available, allowing you to modify the implementation.\n\nFor more information on how to use this static library, examine the\nnative-activity sample application and its documentation. Further reading is\nalso available in the comments in the\n`\u003cndk_root\u003e/sources/android/native_app_glue/android_native_app_glue.h`\nfile.\n\n### Use the native_activity.h interface\n\nTo implement a native activity with the [native_activity.h](/ndk/reference/native__activity_8h) interface:\n\n1. Create a `jni/` directory in your project's root directory. This directory\n stores all of your native code.\n\n2. Declare your native activity in the `AndroidManifest.xml` file.\n\n Because your application has no Java code, set `android:hasCode` to `false`. \n\n \u003capplication android:label=\"@string/app_name\" android:hasCode=\"false\"\u003e\n\n You must set the `android:name` attribute of the activity tag to\n [NativeActivity](/reference/android/app/NativeActivity). \n\n \u003cactivity android:name=\"android.app.NativeActivity\"\n android:label=\"@string/app_name\"\u003e\n\n | **Note:** You can subclass [NativeActivity](/reference/android/app/NativeActivity). If you do, use the name of the subclass instead of [NativeActivity](/reference/android/app/NativeActivity).\n\n The `android:value` attribute of the `meta-data` tag specifies the name of\n the shared library containing the entry point to the application (such as\n C/C++ `main`), omitting the `lib` prefix and `.so` suffix from the library\n name. \n\n \u003cmanifest\u003e\n \u003capplication\u003e\n \u003cactivity\u003e\n \u003cmeta-data android:name=\"android.app.lib_name\"\n android:value=\"native-activity\" /\u003e\n \u003cintent-filter\u003e\n \u003caction android:name=\"android.intent.action.MAIN\" /\u003e\n \u003ccategory android:name=\"android.intent.category.LAUNCHER\" /\u003e\n \u003c/intent-filter\u003e\n \u003c/activity\u003e\n \u003c/application\u003e\n \u003c/manifest\u003e\n\n3. Create a file for your native activity, and implement the function named in\n the [ANativeActivity_onCreate](/ndk/reference/group___native_activity#ga02791d0d490839055169f39fdc905c5e) variable. The app calls this function when the\n native activity starts. This function, analogous to `main` in C/C++, receives\n a pointer to an [ANativeActivity](/ndk/reference/struct_a_native_activity) structure, which contains function pointers\n to the various callback implementations that you need to write. Set the\n applicable callback function pointers in `ANativeActivity-\u003ecallbacks` to\n the implementations of your callbacks.\n\n4. Set the `ANativeActivity-\u003einstance` field to the address of any instance of\n specific data that you want to use.\n\n5. Implement anything else that you want your activity to do upon starting.\n\n6. Implement the rest of the callbacks that you set in\n `ANativeActivity-\u003ecallbacks`. For more information on when the callbacks are\n called, see [Managing the Activity Lifecycle](/training/basics/activity-lifecycle).\n\n7. Develop the rest of your application.\n\n8. Create an `Android.mk file` in the `jni/` directory of your project to\n describe your native module to the build system. For more information, see\n [Android.mk](/ndk/guides/android_mk).\n\n9. Once you have an [Android.mk](/ndk/guides/android_mk) file, compile your native code using the\n `ndk-build` command.\n\n cd \u003cpath\u003e/\u003cto\u003e/\u003cproject\u003e\n $NDK/ndk-build\n\n10. Build and install your Android project as usual. If your native code is in\n the `jni/` directory, the build script automatically packages the `.so`\n file(s) built from it into the APK.\n\nAdditional sample code\n----------------------\n\nTo download NDK samples, see [NDK Samples](https://github.com/android/ndk-samples)."]]
