Konsep

Sebelum Memulai

Panduan ini mengasumsikan bahwa Anda sudah memahami berbagai konsep dalam pemrograman native dan dalam pengembangan Android.

Pengantar

Bagian ini menyediakan penjelasan tingkat tinggi mengenai cara kerja NDK. Android NDK adalah sekumpulan fitur yang memungkinkan Anda menyematkan kode C atau C++ (“kode native”) ke dalam aplikasi Android. 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-kasus tertentu, terutama pada aplikasi yang sarat komputasi seperti game.

Cara Kerja

Bagian ini memperkenalkan berbagai komponen utama yang digunakan dalam membuat aplikasi native untuk Android, dan dilanjutkan dengan menjelaskan proses pembuatan dan pengemasan.

Komponen utama

Anda harus memiliki pemahaman mengenai komponen berikut saat membuat aplikasi:

  • Library bersama native: NDK membuat library ini, atau file .so, dari kode sumber C/C++ Anda.
  • Library statis native: NDK juga dapat membuat library statis, atau file .a, yang dapat Anda tautkan ke library lain.
  • Java Native Interface (JNI): JNI adalah antarmuka bagi komponen Java dan C++ untuk saling berkomunikasi. Panduan ini mengasumsikan Anda telah memiliki pengetahuan tentang JNI; untuk informasi tentang JNI, lihat Spesifikasi Java Native Interface.
  • Application Binary Interface (ABI): ABI mendefinisikan secara pasti bagaimana kode mesin aplikasi Anda diharapkan berinteraksi dengan sistem pada waktu proses. NDK membuat 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 Pengelolaan ABI.
  • Manifes: Jika menulis aplikasi tanpa komponen Java, Anda harus mendeklarasikan class NativeActivity pada manifes. Aktivitas dan Aplikasi Native memberikan penjelasan lebih lanjut tentang cara melakukannya, di bagian "Menggunakan antarmuka native_activity.h."

Alur

Alur umum untuk mengembangkan aplikasi native Android adalah seperti berikut:

  1. Desainlah aplikasi Anda, tentukan bagian mana saja yang akan diimplementasikan di Java, dan bagian mana yang akan diimplementasikan sebagai kode native.

    Catatan: Walaupun bisa saja untuk menghindari Java sepenuhnya, Anda mungkin akan merasakan kegunaan framework Java di Android untuk berbagai tugas, termasuk mengontrol tampilan dan UI.

  2. Buat Project aplikasi Android seperti yang Anda lakukan untuk project Android lainnya.
  3. Jika Anda menulis aplikasi khusus native, deklarasikan class NativeActivity di AndroidManifest.xml. Untuk informasi selengkapnya, lihat Aktivitas dan Aplikasi Native.
  4. Buat file Android.mk yang mendeskripsikan library native, termasuk nama, tanda, library tertaut, dan file sumber yang akan dikompilasi di direktori "JNI".
  5. Jika ingin, Anda 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
    • Toolchain: Clang
    • Mode: Release
    • STL: system
  6. Tempatkan sumber native Anda di bagian direktori jni project.
  7. Gunakan ndk-build untuk mengompilasi library native (.so, .a).
  8. Buat komponen Java, yang akan menghasilkan file executable .dex.
  9. Kemas semuanya menjadi file APK, yang memuat .so, .dex, dan file lain yang diperlukan untuk menjalankan aplikasi Anda.

Aktivitas dan Aplikasi Native

Android SDK menyediakan class pembantu, 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. Yang perlu Anda lakukan hanyalah mendeklarasikan aplikasi Anda sebagai native dalam file AndroidManifest.xml, dan mulai membuat aplikasi native.

Aplikasi Android yang menggunakan NativeActivity tetap berjalan di mesin virtualnya sendiri, yang di-sandbox dari aplikasi lain. Karena itu, Anda masih dapat mengakses API framework Android melalui JNI. Namun, pada kasus tertentu–seperti untuk sensor, peristiwa input, dan aset–NDK menyediakan antarmuka native yang dapat Anda gunakan sebagai ganti melakukan panggilan melalui JNI. Untuk informasi selengkapnya tentang dukungan tersebut, lihat API Native Android NDK.

Entah Anda sedang mengembangkan aktivitas native atau tidak, kami merekomendasikan agar Anda membuat project dengan fitur build Android tradisional. Hal itu akan memastikan pembuatan dan pengemasan aplikasi Android dengan struktur yang benar.

Android NDK memberi Anda dua pilihan untuk mengimplementasikan aktivitas native:

  • Header native_activity.h menentukan versi native class NativeActivity. Class ini memuat 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 (Application Not Responding) karena thread utama tidak merespons sampai callback tersebut kembali.
  • File android_native_app_glue.h menentukan library pembantu 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 tersendiri 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 untuk memodifikasi implementasi.

Untuk informasi selengkapnya mengenai cara menggunakan library statis ini, periksa aplikasi sampel aktivitas native ini dan dokumentasinya. Bacaan lebih lanjut juga tersedia pada komentar dalam file <ndk_root>/sources/android/native_app_glue/android_native_app_glue.h.

Menggunakan antarmuka native_activity.h

Untuk menerapkan aktivitas native dengan antarmuka native_activity.h:

  1. Buat direktori jni/ dalam direktori utama project Anda. Direktori ini menyimpan semua kode native Anda.
  2. Deklarasikan aktivitas native Anda dalam file AndroidManifest.xml.
  3. Karena aplikasi Anda tidak memiliki kode Java, tetapkan android:hasCode ke false.

        <application android:label="@string/app_name" android:hasCode="false">
        

    Anda harus menetapkan atribut android:name tag aktivitas ke NativeActivity.

        <activity android:name="android.app.NativeActivity"
                    android:label="@string/app_name">
        

    Catatan: Anda dapat membuat subclass NativeActivity. Jika itu yang Anda lakukan, gunakan nama subclass-nya, bukan NativeActivity.

    Atribut android:value tag meta-data menetapkan nama library bersama yang memuat titik masuk ke aplikasi (seperti C/C++ main), dengan menghilangkan awalan lib dan akhiran .so dari nama library.

                  <meta-data android:name="android.app.lib_name"
                    android:value="native-activity" />
                    <intent-filter>
                      <action android:name="android.intent.action.MAIN" />
                      <category android:name="android.intent.category.LAUNCHER" />
                    </intent-filter>
                  </activity>
                </application>
              </manifest>
        
  4. Buat file untuk aktivitas native Anda, dan terapkan 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 memuat pointer fungsi ke berbagai implementasi callback yang perlu Anda tulis. Tetapkan pointer fungsi callback yang berlaku di ANativeActivity->callbacks ke implementasi callback Anda.
  5. Tetapkan kolom ANativeActivity->instance ke alamat salah satu instance data spesifik yang ingin Anda gunakan.
  6. Implementasikan semua lainnya yang Anda inginkan untuk dilakukan aplikasi Anda saat memulai.
  7. Implementasikan callback selebihnya yang Anda tetapkan di ANativeActivity->callbacks. Untuk informasi selengkapnya tentang kapan callback dipanggil, lihat Mengelola Siklus Proses Aktivitas.
  8. Kembangkan bagian selebihnya dari aplikasi Anda.
  9. Buat Android.mk file dalam direktori jni/ project Anda untuk mendeskripsikan modul native Anda ke sistem build. Untuk informasi selengkapnya, lihat Android.mk.
  10. Setelah Anda memiliki file Android.mk, kompilasi kode native Anda menggunakan perintah ndk-build.
  11.     $ cd <path>/<to>/<project>
        $ <ndk>/ndk-build
        
  12. Buat dan instal project Android Anda seperti biasa. Jika kode native Anda berada di direktori jni/, skrip build akan otomatis mengemas file .so yang dibuat darinya ke dalam APK.

Kode sampel tambahan

Untuk mendownload sampel NDK, lihat Contoh NDK.