Mit Sammlungen den Überblick behalten
Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.
Hinweis
In diesem Leitfaden wird davon ausgegangen, dass Sie bereits mit den Konzepten
native Programmierung und in der Android-Entwicklung.
Einführung
Dieser Abschnitt bietet eine allgemeine Erläuterung der Funktionsweise des NDK. Das Android-NDK ist eine Reihe von
Tools, mit denen Sie C oder C++ ("nativen Code") in Ihre Android-Apps einbetten können. Die Möglichkeit,
Nativer Code in Android-Apps ist besonders nützlich für Entwickler, die eine oder mehrere
Folgendes:
Ihre Apps auf andere Plattformen zu portieren.
Sie können vorhandene Bibliotheken wiederverwenden oder eigene Bibliotheken zur Wiederverwendung bereitstellen.
Höhere Leistung in bestimmten Fällen, besonders rechenintensiv
wie Spiele.
Funktionsweise
In diesem Abschnitt werden die Hauptkomponenten zum Erstellen nativer Anzeigen
für Android und beschreibt den Entwicklungsprozess
Verpackung.
Hauptkomponenten
Sie sollten mit den folgenden Komponenten vertraut sein, wenn Sie Ihren
App:
Native gemeinsam genutzte Bibliotheken: Das NDK erstellt diese Bibliotheken bzw. .so-Dateien aus
Ihren C/C++-Quellcode aus.
Native statische Bibliotheken: Das NDK kann auch statische Bibliotheken erstellen. .a
-Dateien, die Sie mit anderen Bibliotheken verknüpfen können.
Java Native Interface (JNI): Die JNI ist die Schnittstelle, über die die Java- und
C++-Komponenten kommunizieren miteinander. In diesem Leitfaden wird vorausgesetzt, dass Sie über JNI-Kenntnisse verfügen.
Weitere Informationen finden Sie in der Spezifikation für native Java-Schnittstellen.
Application Binary Interface (ABI): Das ABI definiert genau, wie die
dass Maschinencode zur Laufzeit
mit dem System interagiert. Das NDK
erstellt .so-Dateien anhand dieser Definitionen. Verschiedene ABIs entsprechen
verschiedene Architekturen: Das NDK unterstützt ABI für 32-Bit ARM, AArch64,
x86 und x86-64. Weitere Informationen finden Sie unter Android-Geräte
ABIs.
Der allgemeine Ablauf zur Entwicklung einer nativen App für Android sieht so aus:
Entwerfen Sie Ihre App und entscheiden Sie, welche Teile in Java implementiert werden sollen und welche Teile Sie verwenden möchten.
um sie als nativen Code zu implementieren.
Erstellen Sie ein Android-App-Projekt genau wie für jedes andere Android-Projekt.
Wenn Sie eine reine native App schreiben, deklarieren Sie die Klasse NativeActivity in
AndroidManifest.xml Weitere Informationen finden Sie unter Native Aktivitäten und
Apps.
Erstelle eine Android.mk-Datei mit einer Beschreibung der nativen Bibliothek, einschließlich des Namens,
Flags, verknüpfte Bibliotheken und Quelldateien, die in der JNI kompiliert werden.
-Verzeichnis.
Optional können Sie eine Application.mk-Datei erstellen, in der das Ziel konfiguriert wird
ABIs, Toolchain, Release-/Debug-Modus und STL. Für alle
nicht angeben, werden die folgenden Standardwerte verwendet:
ABI: alle nicht eingestellten ABIs
Modus: Loslassen
STL: System
Platzieren Sie Ihre native Quelle im Verzeichnis jni des Projekts.
Verwenden Sie ndk-build, um die nativen Bibliotheken (.so, .a) zu kompilieren.
Erstellen Sie die Java-Komponente und generieren Sie dabei die ausführbare Datei .dex.
Verpacke alles in einer APK-Datei, die .so, .dex und andere enthält
Dateien, die für die Ausführung der App erforderlich sind.
Native Aktivitäten und Anwendungen
Das Android SDK bietet die Hilfsklasse NativeActivity, mit der du Folgendes tun kannst:
eine komplett native Aktivität schreiben. NativeActivity
zwischen dem Android-Framework und Ihrem nativen Code.
erstellen oder ihre Methoden aufrufen. Du musst nur deine Bewerbung deklarieren
um in Ihrer AndroidManifest.xml-Datei nativ zu sein, und beginnen Sie damit, Ihre native
.
Eine Android-App, die NativeActivity verwendet, wird trotzdem in einer eigenen virtuellen
und von anderen Anwendungen aus in einer Sandbox ausgeführt wird. Sie können daher weiterhin auf
Android-Framework-APIs über JNI In bestimmten Fällen, z. B. bei Sensoren,
Eingabeereignissen und Assets bietet das NDK native Schnittstellen, mit denen Sie
anstatt über die JNI aufrufen zu müssen. Weitere Informationen über solche
siehe Native APIs.
Unabhängig davon, ob Sie eine native Aktivität entwickeln oder nicht,
dass Sie Ihre Projekte mit den
traditionellen Build-Tools von Android erstellen. Vorgehensweise
Android-Apps mit den richtigen
Struktur.
Das Android NDK bietet Ihnen zwei Möglichkeiten, Ihre nativen Aktivitäten zu implementieren:
Der Header native_activity.h
definiert die native Version der NativeActivity-Klasse. Es enthält die
Callback-Oberfläche und Datenstrukturen, die Sie benötigen,
Aktivitäten. Da der Hauptthread Ihrer Anwendung
die Callbacks verarbeitet,
dürfen deine Callback-Implementierungen nicht blockieren. Wenn sie blockiert werden,
ANR-Fehler ("Application Not Responding") erhalten, da Ihr Hauptthread
reagiert nicht, bis der Callback zurückkehrt.
Die Datei android_native_app_glue.h definiert eine statische Hilfsbibliothek, die auf
der Schnittstelle native_activity.h auf. Es erzeugt einen weiteren Thread,
verarbeitet Dinge wie Rückrufe oder Eingabeereignisse in einer Ereignisschleife. Umzug
diese Ereignisse in einen separaten Thread zu verlagern, verhindert, dass Callbacks Ihre
im Hauptthread.
Das <ndk_root>/sources/android/native_app_glue/android_native_app_glue.c
Quelle ist auch verfügbar, sodass Sie die Implementierung ändern können.
Weitere Informationen zur Verwendung dieser statischen Bibliothek finden Sie in der
Beispielanwendung für native Aktivität und die zugehörige Dokumentation. Weitere Lesematerialien
findet ihr auch in den Kommentaren im
<ndk_root>/sources/android/native_app_glue/android_native_app_glue.h
-Datei.
Die Schnittstelle "native_activity.h" verwenden
So implementieren Sie eine native Aktivität mit der Schnittstelle native_activity.h:
Erstellen Sie im Stammverzeichnis Ihres Projekts ein jni/-Verzeichnis. Dieses Verzeichnis
Ihren gesamten nativen Code speichert.
Deklarieren Sie Ihre native Aktivität in der Datei AndroidManifest.xml.
Da Ihre Anwendung keinen Java-Code hat, setzen Sie android:hasCode auf false.
Das Attribut android:value des meta-data-Tags gibt den Namen der
der gemeinsam genutzten Bibliothek, die den Einstiegspunkt für die Anwendung enthält (z. B.
C/C++ main), wobei das Präfix lib und das Suffix .so aus der Bibliothek weggelassen werden
Namen.
Erstellen Sie eine Datei für Ihre native Aktivität und implementieren Sie die Funktion, die in
Variable ANativeActivity_onCreate Die App ruft diese Funktion auf, wenn der
native Aktivität beginnt. Diese Funktion empfängt, analog zu main in C/C++,
einen Verweis auf eine ANativeActivity-Struktur, die Funktionszeiger enthält
Callback-Implementierungen beschrieben, die Sie schreiben müssen. Legen Sie die
geeignete Callback-Funktionszeiger in ANativeActivity->callbacks
die Implementierungen Ihrer Callbacks.
Setzen Sie das Feld ANativeActivity->instance auf die Adresse einer beliebigen Instanz von
Daten, die Sie verwenden möchten.
Implementieren Sie zu Beginn alle weiteren Aktionen, die von den Aktivitäten ausgeführt werden sollen.
Implementieren Sie die übrigen Callbacks, die Sie in
ANativeActivity->callbacks Weitere Informationen dazu, wann Callbacks eintreten,
Siehe Aktivitätslebenszyklus verwalten.
Entwickeln Sie die restliche Anwendung.
Erstellen Sie ein Android.mk file im Verzeichnis jni/ Ihres Projekts, um
das native Modul im Build-System beschreiben. Weitere Informationen finden Sie unter
Android.mk
Sobald Sie über eine Android.mk-Datei verfügen, kompilieren Sie Ihren nativen Code mithilfe der
ndk-build-Befehl.
cd<path>/<to>/<project>
$NDK/ndk-build
Erstellen und installieren Sie Ihr Android-Projekt wie gewohnt. Wenn sich der native Code
Verzeichnis jni/ enthält das Build-Skript automatisch das Paket .so
in das APK eingebaute Dateien.
Zusätzlicher Beispielcode
Informationen zum Herunterladen von NDK-Beispielen finden Sie unter NDK-Beispiele.
Alle Inhalte und Codebeispiele auf dieser Seite unterliegen den Lizenzen wie im Abschnitt Inhaltslizenz beschrieben. Java und OpenJDK sind Marken oder eingetragene Marken von Oracle und/oder seinen Tochtergesellschaften.
Zuletzt aktualisiert: 2025-07-27 (UTC).
[[["Leicht verständlich","easyToUnderstand","thumb-up"],["Mein Problem wurde gelöst","solvedMyProblem","thumb-up"],["Sonstiges","otherUp","thumb-up"]],[["Benötigte Informationen nicht gefunden","missingTheInformationINeed","thumb-down"],["Zu umständlich/zu viele Schritte","tooComplicatedTooManySteps","thumb-down"],["Nicht mehr aktuell","outOfDate","thumb-down"],["Problem mit der Übersetzung","translationIssue","thumb-down"],["Problem mit Beispielen/Code","samplesCodeIssue","thumb-down"],["Sonstiges","otherDown","thumb-down"]],["Zuletzt aktualisiert: 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)."]]
