Tetap teratur dengan koleksi
Simpan dan kategorikan konten berdasarkan preferensi Anda.
Sebelum memulai
Panduan ini berasumsi bahwa Anda telah memahami berbagai konsep yang ada dalam
pemrograman native dan dalam pengembangan Android.
Pengantar
Bagian ini menyediakan penjelasan tingkat tinggi mengenai cara kerja NDK. Android NDK adalah sekumpulan alat yang memungkinkan Anda menyematkan kode C atau C++ (“kode native”) ke dalam aplikasi Android Anda. Kemampuan untuk menggunakan kode native di aplikasi Android bisa sangat berguna bagi developer yang ingin melakukan salah satu atau beberapa hal berikut:
Mengadaptasikan aplikasi di berbagai platform.
Menggunakan kembali library yang sudah ada, atau menyediakan library mereka sendiri untuk digunakan kembali.
Meningkatkan performa dalam kasus tertentu, terutama pada aplikasi yang sarat komputasi
seperti game.
Cara kerjanya
Bagian ini memperkenalkan berbagai komponen utama yang digunakan dalam mem-build aplikasi
native untuk Android, dan dilanjutkan dengan menjelaskan proses build dan
pemaketan.
Komponen utama
Anda harus memiliki pemahaman mengenai komponen berikut saat mem-build
aplikasi:
Library bersama native: NDK mem-build library ini, atau file .so, dari
kode sumber C/C++.
Library statis native: NDK juga dapat mem-build library statis, atau file .a,
yang dapat ditautkan ke library lain.
Java Native Interface (JNI): JNI adalah antarmuka bagi komponen Java dan
C++ untuk saling berkomunikasi. Panduan ini berasumsi bahwa Anda telah memahami JNI;
untuk mengetahui informasi tentang JNI, lihat Spesifikasi Java Native Interface.
Application Binary Interface (ABI): ABI menentukan secara pasti bagaimana kode mesin
aplikasi Anda diharapkan berinteraksi dengan sistem pada runtime. NDK
mem-build file .so berdasarkan definisi ini. ABI yang berbeda berkaitan dengan
arsitektur yang berbeda: NDK menyertakan dukungan ABI untuk ARM 32-bit, AArch64,
x86, dan x86-64. Untuk informasi selengkapnya, lihat ABI
Android.
Buat file Android.mk yang mendeskripsikan library native, termasuk nama,
flag, library tertaut, dan file sumber yang akan dikompilasi dalam direktori
"JNI".
Anda juga dapat membuat file Application.mk yang mengonfigurasi ABI
target, toolchain, mode rilis/debug, dan STL. Untuk semua elemen ini yang tidak
Anda tentukan, nilai default berikut akan digunakan:
ABI: semua ABI yang masih digunakan
Mode: Release
STL: system
Tempatkan sumber native Anda dalam direktori jni project.
Gunakan ndk-build untuk mengompilasi library native (.so, .a).
Build komponen Java, yang akan menghasilkan file executable .dex.
Paketkan semuanya ke dalam file APK, berisi .so, .dex, serta file lain
yang diperlukan untuk menjalankan aplikasi.
Aktivitas dan aplikasi native
Android SDK menyediakan class helper, NativeActivity, yang memungkinkan Anda
menulis aktivitas yang sepenuhnya native. NativeActivity menangani komunikasi
antara framework Android dan kode native, sehingga Anda tidak perlu membuat
subclass untuknya atau memanggil metodenya. Anda hanya perlu mendeklarasikan aplikasi
sebagai native dalam file AndroidManifest.xml, lalu mulai membuat aplikasi
native.
Aplikasi Android yang menggunakan NativeActivity tetap berjalan di mesin
virtualnya sendiri, yang di-sandbox dari aplikasi lain. Oleh karena itu, Anda masih dapat mengakses
API framework Android melalui JNI. Dalam kasus tertentu, seperti untuk sensor,
peristiwa input, dan aset, NDK menyediakan antarmuka native yang dapat Anda gunakan
sehingga tidak perlu memanggil melalui JNI. Untuk informasi selengkapnya tentang dukungan
tersebut, lihat API native.
Baik Anda sedang mengembangkan aktivitas native atau tidak, sebaiknya Anda
membuat project dengan alat build Android tradisional. Ini akan
membantu memastikan pembuatan dan pemaketan aplikasi Android dengan struktur
yang benar.
Android NDK memberikan dua pilihan untuk mengimplementasikan aktivitas native:
Header native_activity.h
menentukan versi native class NativeActivity. Class ini berisi
antarmuka callback dan struktur data yang Anda perlukan untuk membuat aktivitas
native. Karena thread utama aplikasi Anda menangani callback,
implementasi callback Anda tidak boleh memblokir. Jika memblokir, Anda mungkin akan
menerima error ANR (Aplikasi Tidak Merespons) karena thread utama
tidak merespons hingga callback tersebut kembali.
File android_native_app_glue.h menentukan library bantuan statis yang dibuat di
atas antarmuka native_activity.h. File ini menghasilkan thread lain, yang
menangani hal-hal seperti callback atau peristiwa input dalam suatu loop peristiwa. Memindahkan
peristiwa ini ke thread terpisah akan mencegah callback memblokir
thread utama Anda.
Sumber <ndk_root>/sources/android/native_app_glue/android_native_app_glue.c
juga tersedia, yang memungkinkan Anda memodifikasi implementasi.
Untuk mengetahui informasi selengkapnya tentang cara menggunakan library statis ini, periksa
aplikasi contoh aktivitas native dan dokumentasinya. Bacaan lebih lanjut
juga tersedia di komentar dalam
file <ndk_root>/sources/android/native_app_glue/android_native_app_glue.h
.
Menggunakan antarmuka native_activity.h
Untuk mengimplementasikan aktivitas native dengan antarmuka native_activity.h:
Buat direktori jni/ dalam direktori utama project Anda. Direktori ini
menyimpan semua kode native Anda.
Deklarasikan aktivitas native Anda dalam file AndroidManifest.xml.
Karena aplikasi Anda tidak memiliki kode Java, tetapkan android:hasCode ke false.
Atribut android:value tag meta-data menentukan nama
library bersama yang berisi titik entri ke aplikasi (seperti
main C/C++), dengan menghilangkan
awalan lib dan akhiran .so dari nama
library.
Buat file untuk aktivitas native Anda, dan implementasikan fungsi yang dinamai dalam
variabel ANativeActivity_onCreate. Aplikasi memanggil fungsi ini saat
aktivitas native dimulai. Fungsi ini, yang serupa dengan main di C/C++, menerima
pointer ke struktur ANativeActivity, yang berisi pointer fungsi
ke berbagai implementasi callback yang perlu Anda tulis. Tetapkan
pointer fungsi callback yang berlaku di ANativeActivity->callbacks ke
implementasi callback Anda.
Tetapkan kolom ANativeActivity->instance ke alamat instance
data tertentu yang ingin Anda gunakan.
Implementasikan semua hal lainnya yang Anda ingin aktivitas lakukan saat memulai.
Implementasikan callback lain yang ditetapkan di
ANativeActivity->callbacks. Untuk mengetahui informasi selengkapnya tentang kapan callback
dipanggil, lihat Mengelola Siklus Proses Aktivitas.
Kembangkan bagian lain aplikasi.
Buat Android.mk file dalam direktori jni/ project untuk
mendeskripsikan modul native ke sistem build. Untuk informasi selengkapnya, lihat
Android.mk.
Setelah Anda memiliki file Android.mk, kompilasikan kode native menggunakan
perintah ndk-build.
cd<path>/<to>/<project>
$NDK/ndk-build
Buat dan instal project Android Anda seperti biasa. Jika kode native Anda berada dalam
direktori jni/, skrip build akan otomatis memaketkan file .so
yang dibuat darinya ke dalam APK.
Konten dan contoh kode di halaman ini tunduk kepada lisensi yang dijelaskan dalam Lisensi Konten. Java dan OpenJDK adalah merek dagang atau merek dagang terdaftar dari Oracle dan/atau afiliasinya.
Terakhir diperbarui pada 2025-07-27 UTC.
[[["Mudah dipahami","easyToUnderstand","thumb-up"],["Memecahkan masalah saya","solvedMyProblem","thumb-up"],["Lainnya","otherUp","thumb-up"]],[["Informasi yang saya butuhkan tidak ada","missingTheInformationINeed","thumb-down"],["Terlalu rumit/langkahnya terlalu banyak","tooComplicatedTooManySteps","thumb-down"],["Sudah usang","outOfDate","thumb-down"],["Masalah terjemahan","translationIssue","thumb-down"],["Masalah kode / contoh","samplesCodeIssue","thumb-down"],["Lainnya","otherDown","thumb-down"]],["Terakhir diperbarui pada 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)."]]
