קל לארגן דפים בעזרת אוספים
אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.
לפני שמתחילים
המדריך הזה מניח שאתם כבר מכירים את המושגים שטבועים ב-
בתכנות נייטיב ובפיתוח Android.
מבוא
בקטע הזה יש הסבר כללי על אופן הפעולה של ה-NDK. Android NDK הוא קבוצה של
שיעזרו לכם להטמיע את C או C++ ("קוד מקורי") באפליקציות שלכם ל-Android. היכולת להשתמש
קוד מקורי באפליקציות Android יכול להיות שימושי במיוחד למפתחים שרוצים לבצע אחת או יותר
הבאים:
לנייד את האפליקציות בין פלטפורמות.
עשו שימוש חוזר בספריות קיימות, או מספקים ספריות משלהן לשימוש חוזר.
שיפור הביצועים במקרים מסוימים, בייחוד באופן מחשוב
כמו משחקים.
איך זה עובד
החלק הזה מציג את הרכיבים העיקריים שמשמשים לפיתוח
ל-Android, ואמשיך לתאר את תהליך הבנייה
אריזה.
רכיבים עיקריים
אתם צריכים להבין את הרכיבים הבאים בזמן שאתם יוצרים את
app:
ספריות משותפות מקוריות: ה-NDK יוצר את הספריות האלה, או .so קבצים, מ-
את קוד המקור C/C++
ספריות סטטיות נייטיב: ה-NDK יכול גם ליצור ספריות סטטיות, או .a
קבצים, שאותם ניתן לקשר לספריות אחרות.
Java Native Interface (JNI): ה-JNI הוא הממשק שדרכו ה-Java
רכיבי C++ מדברים זה עם זה. המדריך הזה מבוסס על ההנחה שיש לכם ידע על ה-JNI.
כדי לקבל מידע נוסף, אפשר לעיין במפרט ממשק ה-Native של Java.
Application Binary Interface (ABI): ה-ABI מגדיר בדיוק את האופן שבו האפליקציה
הוא אמור לקיים אינטראקציה עם המערכת בזמן הריצה. ה-NDK
יוצרת .so קבצים בהתאם להגדרות האלה. ממשקי ABI שונים מתאימים
ארכיטקטורות שונות: ה-NDK כולל תמיכת ABI עבור 32-bit ARM, AArch64,
x86 ו-x86-64. אפשר למצוא מידע נוסף במאמר Android
ממשקי ABI.
התהליך הכללי לפיתוח אפליקציה מותאמת ל-Android הוא:
לעצב את האפליקציה ולקבוע אילו חלקים להטמיע ב-Java ואילו חלקים
להטמעה כקוד Native.
יוצרים פרויקט של אפליקציה ל-Android כמו שעושים לכל פרויקט אחר ב-Android.
אם אתם כותבים אפליקציה מותאמת בלבד, צריך להצהיר על הכיתה NativeActivity ב
AndroidManifest.xml. אפשר לקרוא מידע נוסף בקטע פעילויות מותאמות
.
יוצרים קובץ Android.mk שמתאר את ספריית הנייטיב, כולל השם,
דגלים, ספריות מקושרות וקובצי מקור שיקודמו ב-"JNI"
אפשר גם ליצור קובץ Application.mk להגדרת היעד
ממשקי ABI , Toolchain, מצב גרסה/ניפוי באגים ו-STL. בכל אחת מהפעולות האלה
לא לציין, נעשה שימוש בערכי ברירת המחדל הבאים, בהתאמה:
ABI: כל ממשקי ה-ABI שלא הוצאו משימוש
מצב: השקה
STL: מערכת
מציבים את המקור המקורי בספריית jni של הפרויקט.
צריך להשתמש ב-ndk-build כדי להדר את ספריות ה-Native (.so, .a).
יוצרים את רכיב ה-Java ומפיקים את קובץ ההפעלה .dex.
אפשר לאחסן הכול בקובץ APK שמכיל את .so, .dex ועוד
הקבצים הדרושים להפעלת האפליקציה.
פעילויות ואפליקציות מקוריות
ב-Android SDK יש מחלקה עוזרת, NativeActivity, שמאפשרת לכם:
לכתוב פעילות מקומית לחלוטין. NativeActivity מטפל בתקשורת
בין ה-framework של Android לבין קוד ה-Native, כך שאתם לא צריכים
לתת לו סיווג משנה או לקרוא לשיטות שלו. כל מה שצריך לעשות הוא להצהיר על הבקשה
להיות מקורי בקובץ AndroidManifest.xml שלך, ולהתחיל ליצור
תרגום מכונה.
אפליקציה ל-Android שמשתמשת ב-NativeActivity עדיין פועלת בסביבה וירטואלית משלה
במחשב, בארגז חול מאפליקציות אחרות. לכן אתם עדיין יכולים לגשת
ממשקי API של Android framework דרך ה-JNI. במקרים מסוימים, למשל במקרה של חיישנים,
אירועי קלט ונכסים, ה-NDK מספק ממשקים מותאמים שאפשר להשתמש בהם
במקום להתקשר אל ה-JNI. לקבלת מידע נוסף על
תמיכה, ראו ממשקי API נייטיב.
לא משנה אם אתם מפתחים פעילות מקומית, מומלץ
שאפשר ליצור פרויקטים באמצעות כלי ה-build המסורתיים של Android. אם עושים את זה
עוזר להבטיח יצירה ואריזה של אפליקציות ל-Android
שלנו.
ב-Android NDK יש שתי אפשרויות להטמעת הפעילות המותאמת:
הכותרת native_activity.h
מגדיר את הגרסה המקורית של המחלקה NativeActivity. הוא מכיל את
ממשק קריאה חוזרת ומבני נתונים שנדרשים כדי ליצור את
פעילות. מכיוון שה-thread הראשי של האפליקציה מטפל בקריאות החוזרות (callback),
אסור שההטמעות של הקריאה החוזרת חוסמות. אם הוא יחסום, ייתכן
לקבל שגיאות ANR (האפליקציה לא מגיבה) כי ה-thread הראשי
התגובה לא מגיבה עד שהקריאה החוזרת תחזור.
הקובץ android_native_app_glue.h מגדיר ספריית עזרה סטטית שמבוססת על
בחלק העליון של הממשק native_activity.h. זה יצר שרשור נוסף,
מטפל בדברים כמו קריאות חוזרות (callback) או אירועי קלט בלולאת אירועים. מעבר
השרשורים האלו בשרשור נפרד מונעים קריאות חוזרות (callback) וחסימה של
ה-thread הראשי.
<ndk_root>/sources/android/native_app_glue/android_native_app_glue.c
זמין גם הוא, כדי שתוכלו לשנות את ההטמעה.
לקבלת מידע נוסף על אופן השימוש בספרייה הסטטית הזו, כדאי לעיין
של האפליקציה לדוגמה והתיעוד שלה. קריאה נוספת היא
זמין גם בתגובות
<ndk_root>/sources/android/native_app_glue/android_native_app_glue.h
חדש.
המאפיין android:value של התג meta-data מציין את השם של
לספרייה המשותפת שמכילה את נקודת הכניסה לאפליקציה (למשל
C/C++ main), ללא הקידומת lib והסיומת .so מהספרייה
שם.
צרו קובץ לפעילות המקורית שלכם והטמיעו את הפונקציה ששמה
המשתנה ANativeActivity_onCreate. האפליקציה מפעילה את הפונקציה הזו כאשר
הפעילות של הנייטיב מתחילה. הפונקציה הזו, שמקבילה ל-main ב-C/C++, מקבלת
מצביע למבנה של ANativeActivity, שמכיל סמנים של פונקציות.
לאפליקציות השונות של קריאה חוזרת (callback) שצריך לכתוב. מגדירים את
המצביעים הרלוונטיים של פונקציית הקריאה החוזרת ב-ANativeActivity->callbacks אל
של הקריאות החוזרות (callback).
מגדירים את השדה ANativeActivity->instance לכתובת של כל מופע של
של הנתונים הספציפיים שבהם רוצים להשתמש.
ישם כל דבר נוסף שאתם רוצים שהפעילות שלכם תבצע כשמתחילים.
הטמעה של שאר הקריאות החוזרות שהגדרת
ANativeActivity->callbacks כדי לקבל מידע נוסף על המועדים של הקריאות החוזרות (callback)
שנקראו במאמר ניהול מחזור החיים של פעילות.
מפתחים את שאר האפליקציות.
צריך ליצור Android.mk file בספרייה jni/ של הפרויקט כדי
לתאר את המודול המקורי למערכת ה-build. מידע נוסף זמין במאמר הבא:
Android.mk
לאחר שיש לך קובץ Android.mk, הידור את קוד ה-Native שלך באמצעות
הפקודה ndk-build.
cd<path>/<to>/<project>
$NDK/ndk-build
יוצרים ומתקינים את פרויקט Android כרגיל. אם קוד ה-Native שלכם הוא
הספרייה jni/, סקריפט ה-build מקבץ באופן אוטומטי את קובץ ה-.so
קבצים שנוצרו ממנו ב-APK.
דוגמאות התוכן והקוד שבדף הזה כפופות לרישיונות המפורטים בקטע רישיון לתוכן. Java ו-OpenJDK הם סימנים מסחריים או סימנים מסחריים רשומים של חברת Oracle ו/או של השותפים העצמאיים שלה.
עדכון אחרון: 2025-07-27 (שעון UTC).
[null,null,["עדכון אחרון: 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)."]]
