Koleksiyonlar ile düzeninizi koruyun
İçeriği tercihlerinize göre kaydedin ve kategorilere ayırın.
Başlamadan önce
Bu kılavuzda, dijital ortamda yerleşik olarak bulunan kavramları zaten bildiğiniz varsayılarak
yerel programlama ve Android geliştirme.
Giriş
Bu bölümde, NDK'nın nasıl çalıştığı hakkında ileri düzey bir açıklama sunulmaktadır. Android NDK,
araçları sayesinde Android uygulamalarınıza C veya C++ ("yerel kod") yerleştirebilirsiniz. Bir projeyi
Android uygulamalarındaki yerel kod, özellikle şunlardan en az birini yapmak isteyen geliştiriciler için yararlı olabilir:
şu:
Uygulamalarını platformlar arasında taşımalıdır.
Mevcut kitaplıkları yeniden kullanın veya yeniden kullanım için kendi kitaplıklarını sağlayın.
Özellikle yoğun işlem gerektiren belirli durumlarda performansı artırır.
oyunlar için de geçerlidir.
İşleyiş şekli
Bu bölümde, yerel reklam oluştururken kullanılan ana bileşenler açıklanmaktadır
ve Android için uygulama oluşturma ve oluşturma sürecini
çok önemlidir.
Ana bileşenler
Projenizi oluştururken aşağıdaki bileşenleri iyice anlamış olmalısınız:
uygulama:
Yerel paylaşılan kitaplıklar: NDK, bu kitaplıkları veya .so dosyalarını
C/C++ kaynak kodunuza gider.
Yerel statik kitaplıklar: NDK ayrıca statik kitaplıklar da oluşturabilir veya .a
diğer kitaplıklara bağlayabileceğiniz dosyalar.
Java Native Interface (JNI): JNI, Java ve programlamanın üzerinden
C++ bileşenleri birbirleriyle iletişim kurar. Bu kılavuzda JNI hakkında bilgi sahibi olduğu varsayılır;
hakkında bilgi için Java Yerel Arayüz Spesifikasyonu'na bakın.
Uygulama İkili Arabirimi (ABI): ABI, uygulamanızın özelliklerinin tam olarak nasıl
makine kodunun çalışma zamanında sistemle etkileşime geçmesi beklenir. NDK
bu tanımlara göre .so dosyası oluşturur. Farklı ABI'ler
NDK, 32 bit ARM, AArch64,
x86 ve x86-64. Daha fazla bilgi için Android
ABI'ler.
Manifest: Java bileşeni olmayan bir uygulama yazıyorsanız
NativeActivity sınıfını
manifest dosyası olarak kaydedin. Bkz.
Native_activity.h arayüzünü ziyaret ederek bunu nasıl yapacağınızla ilgili daha fazla bilgi edinebilirsiniz.
Akma
Android için yerel uygulama geliştirmeye ilişkin genel akış aşağıdaki gibidir:
Uygulamanızı tasarlayın, Java'da hangi bölümlerin uygulanacağına ve hangi bölümlerin uygulanacağına karar verin
yerel kod olarak uygulanacak.
Diğer Android projelerinde yaptığınız gibi bir Android uygulaması projesi oluşturun.
Yerel kitaplığı açıklayan bir Android.mk dosyası oluşturun. Bu dosya, dosyanın adı ve
"JNI" içinde derlenecek flag'ler, bağlı kitaplıklar ve kaynak dosyaları
dizin.
İsteğe bağlı olarak, hedefi yapılandıran bir Application.mk dosyası oluşturabilirsiniz
ABI'ler, araç zinciri, yayınlama/hata ayıklama modu ve STL. Bunlardan herhangi biri için
belirtilmezse sırasıyla aşağıdaki varsayılan değerler kullanılır:
ABI: kullanımdan kaldırılmamış tüm ABI'lar
Mod: Bırak
STL: sistem
Yerel kaynağınızı projenin jni dizinine yerleştirin.
Yerel (.so, .a) kitaplıkları derlemek için ndk-build'i kullanın.
Her şeyi .so, .dex ve diğer öğeleri içeren bir APK dosyasında paketle
uygulamanızın çalışması için gereken dosyalar.
Yerel etkinlikler ve uygulamalar
Android SDK'sı, şunları yapmanızı sağlayan bir yardımcı sınıf olan NativeActivity'yi sağlar.
tamamen yerel bir etkinlik yazmanız gerekir. NativeActivity, iletişimi yönetir
yerel kodunuz arasında gidip gelir. Böylece,
veya yöntemlerini çağırabilir. Tek yapmanız gereken başvurunuzu beyan etmek
AndroidManifest.xml dosyanızda yerel olmasını sağlayın ve yerel dosyanızı oluşturmaya başlayın
bir uygulamadır.
NativeActivity kullanan bir Android uygulaması, kendi sanal makinesinde çalışmaya devam ediyor.
diğer uygulamalardan korumalı alana alın. Bu nedenle,
JNI aracılığıyla Android çerçevesi API'leri Örneğin, sensörler için
NDK, kullanabileceğiniz yerel arayüzler sağlar.
ya da JNI'yi kullanarak arama yapmak zorunda kalmazsınız. Bu tür iletişimler için
desteği için Yerel API'ler bölümüne bakın.
Yerel bir etkinlik geliştiriyor olsanız da olmasanız da,
geleneksel Android geliştirme araçlarıyla
oluşturduğunuzu göstereceğim. İşlem devam ediyor
Android uygulamalarının doğru tarayıcıyla derlenmesini ve paketlenmesini
inceleyeceğiz.
Android NDK, yerel etkinliğinizi uygulamanız için size iki seçenek sunar:
native_activity.h başlığı
NativeActivity sınıfının yerel sürümünü tanımlar. Belge,
yerel reklam öğenizi oluşturmak için ihtiyacınız olan geri çağırma arayüzü ve veri yapıları
etkinliği'ne dokunun. Uygulamanızın ana iş parçacığı geri çağırmaları yaptığından,
geri çağırma uygulamalarınız engellenmemelidir. Kullanıcılar sizi engellerse
ana iş parçacığınız
geri arama geri gelene kadar yanıt vermez.
android_native_app_glue.h dosyası,
native_activity.h arayüzünün üst kısmında. Daha fazla iş parçacığının
Bir etkinlik döngüsündeki geri çağırma veya giriş etkinlikleri gibi işlemleri gerçekleştirir. Hareket halinde
veya başka bir ileti dizisine geri çağırmak, geri çağırmaların
iş parçacığı.
<ndk_root>/sources/android/native_app_glue/android_native_app_glue.c
kaynağı da mevcuttur ve uygulamayı değiştirmenize olanak tanır.
Bu statik kitaplığın nasıl kullanılacağıyla ilgili daha fazla bilgi için
yerel etkinlik örnek uygulaması ve belgeleri. Daha fazla bilgi:
buradaki yorumlar bölümünde de
<ndk_root>/sources/android/native_app_glue/android_native_app_glue.h.
dosyası olarak kaydedebilirsiniz.
meta-data etiketinin android:value özelliği
uygulamaya giriş noktasını içeren paylaşılan kitaplık (örneğin,
C/C++ main), lib öneki ve .so son eki kitaplıktan çıkarılır
dokunun.
Yerel etkinliğiniz için bir dosya oluşturun ve
ANativeActivity_onCreate değişkeni.
yerel etkinlik başlar. C/C++ işlevindeki main işlevine benzer şekilde bu işlev,
işlev işaretçileri içeren bir ANativeActivity yapısının işaretçisi
geri çağırma uygulamalarına göz atalım. Ayarlayın:
ANativeActivity->callbacks içindeki geçerli geri çağırma işlevi işaretçileri
uygulama süreci hakkında
bilgi edineceksiniz.
ANativeActivity->instance alanını
verileri seçin.
Başlangıçta etkinliğinizin yapmasını istediğiniz diğer şeyleri uygulayın.
Aşağıdaki işlemler için projenizin jni/ dizininde bir Android.mk file oluşturun:
yerel modülünüzü derleme sistemine açıklayın. Daha fazla bilgi için bkz.
Android.mk.
Android projenizi her zamanki gibi derleyip yükleyin. Yerel kodunuz
jni/ dizinini seçerseniz derleme komut dosyası .so öğesini otomatik olarak paketler
dosyalardan derlemenizi sağlar.
Ek örnek kod
NDK örneklerini indirmek için NDK Örnekleri bölümüne bakın.
Bu sayfadaki içerik ve kod örnekleri, İçerik Lisansı sayfasında açıklanan lisanslara tabidir. Java ve OpenJDK, Oracle ve/veya satış ortaklarının tescilli ticari markasıdır.
Son güncelleme tarihi: 2025-07-27 UTC.
[[["Anlaması kolay","easyToUnderstand","thumb-up"],["Sorunumu çözdü","solvedMyProblem","thumb-up"],["Diğer","otherUp","thumb-up"]],[["İhtiyacım olan bilgiler yok","missingTheInformationINeed","thumb-down"],["Çok karmaşık / çok fazla adım var","tooComplicatedTooManySteps","thumb-down"],["Güncel değil","outOfDate","thumb-down"],["Çeviri sorunu","translationIssue","thumb-down"],["Örnek veya kod sorunu","samplesCodeIssue","thumb-down"],["Diğer","otherDown","thumb-down"]],["Son güncelleme tarihi: 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)."]]
