* Artikel ini dipersembahkan oleh Intel Developer Zone. Untuk Mengetahui lebih lanjut tentang membuat aplikasi Android di Arstitektur Intel, kunjungi Intel Developer Zone for Android. Artikel asli dari artikel ini dapat dilihat di link ini.
Artikel ini adalah pengantar pemula dalam membuat aplikasi Android native (NDK) untuk perangkat yang berbasis arsitektur Intel (IA). Akan dijelaskan juga tentang porting aplikasi NDK Android ke perangkat berbasis IA yang sebelumnya dibuat untuk perangkat berbasis arsitektur lainnya.
Hal-hal tersebut akan dijelaskan melalui 2 skenario, satu dengan mendemokan proses dalam pembuatan aplikasi NDK Android yang sederhana mulai dari awal hingga selesai, dan satu lagi menampilkan proses sederhana dalam mem-porting aplikasi Android NDK yang sudah ada untuk digunakan di perangkat berbasis IA.
[toc]
Pengenalan
Aplikasi Android dapat menggunakan kode native menggunakan peralatan Native Development Kit (NDK). Hal ini memungkinkan pengembang aplikasi untuk menggunakan kembali kode legacy, kode perangkat keras tingkat rendah, atau membedakan aplikasi mereka dengan memanfaatkan fitur yang sebelumnya tidak optimal atau tidak mungkin.
Artikel ini adalah pengenalan dasar tentang bagaimana caranya membuat aplikasi berbasis NDK untuk IA mulai dari awal hingga selesai. Dan juga, terdapat studi kasus sederhana untuk mem-porting aplikasi NDK Android yang sudah ada ke perangkat berbasis IA. Kesemuanya akan dijabarkan melalui skenario pengembangan aplikasi sederhana secara langkah demi langkah untuk mendemokan prosesnya.
Di artikel ini diasumsikan kamu sudah menginstal lingkungan pengembangan Android termasuk Android SDK, Android NDK, dan sudah mengkonfigurasikan emulator x86 untuk pengetesan aplikasi. Untuk informasi lebih lanjut tentang ini, bisa mengunjungi bagian Android Community di situs web Intel. Untuk menjaga lingkungan pengembangan agar tetap sederhana, perintah Linux digunakan untuk mayoritas bagian di artikel ini.
Membuat aplikasi Android berbasis NDK untuk perangkat berbasis IA – Panduan aplikasi sederhana
Asumsikan kita memiliki kode legacy yang menggunakan bahasa C dan assembly untuk mengurai CPUID (kunjungi http://en.wikipedia.org/wiki/CPUID untuk info lebih lanjut tentang CPUID). Di bawah ini adalah kode sumber untuk contoh kode C “legacy” cpuid.c (hanya untuk tujuan demo).
Kita akan memanggil cpuid_parse dari aplikasi Android kita (hanya untuk tujuan demo saja – fungsi cpuid_parse menerima buffer yang sudah dialokasikan) dan menampilkan hasilnya di aplikasi.
Di bawah ini adalah panduan langkah demi langkah untuk membuat aplikasi Android dari awal hingga selesai dan menggunakan kode legacy di atas.
1. Membuat Proyek Android Bawaan
Android SDK mempunyai perintah command line untuk membuat struktur proyek bawaan untuk membuat aplikasi “hello world”. Kita pertama-tama akan membuat proyek bawaan dan kemudian mengubah sumber kode Java-nya untuk ditambahkan pemanggilan JNI dan kode native.
Pada gambar di atas, kita pertama-tama membuat sebuah direktori bernama labs/lab2 dan menggunakan perintah “android” untuk membuat proyek bawaan. Kita kemudian menspesifikasikan android-15 sebagai level API dan menamakan aplikasi kita “CPUIdApp” dengan package com.example.cpuid.
Kita kemudian menggunakan perintah “ant” untuk membuat proyek di mode debug dan menginstal menggunakan perintah “adb” (atau reinstal jika sudah ada sebelumnya di emulator atau target perangkat). Diasumsikan kamu sudah memiliki sebuah emulator atau perangkat yang terpasang dan itu juga satu-satunya yang ditampilkan di daftar perangkat di keluaran perintah “adb devices”.
Di bawah ini adalah gambar dari emulator x86 dengan ICS setelah menyelesaikan proses di atas:
Mengklik di aplikasinya akan memperlihatkan keluaran “hello world” bawaan dari aplikasinya. Kita sekarang akan memodifikasi aplikasinya menggunakan kode native.
2. Menjalankan kode native dari sumber kode Java
Proyek Android bawaan membuat sumber kode Java untuk proyek “hello world” dan sudah dilengkapi dengan penamaan package (contoh: com.example.cpuid). Gambar di bawah ini menampilkan kode sumber yang dihasilkan untuk file kode Java utama.
Untuk menggunakan kode C/C++ di file sumber kode Java kita, kita pertama-tama harus mendeklarasikan pemanggilan JNI dan memuat native library seperti yang dapat dilihat di gambar di bawah ini yang disorot dengan warna kuning.
Seperti yang bisa dilihat di deklarasinya, pemanggilan native menghasilkan teks dalam format Java yang dapat kita gunakan di mana saja di kodingan Java kita. Seperti yang dilihat di atas juga, kita sudah mengubah TextView untuk menampilkan teks yang kita dapat dari pemanggilan native. Ini bisa dilihat di bagian yang disorot warna merah.
Ini merupakan kasus yang paling sederhana untuk mendeklarasikan dan menggunakan pemanggilan native JNI di sumber kode Java aplikasi Android. Berikutnya, kita akan menggunakan perintah “javah” untuk menghasilkan JNI header stub untuk kode native dan menambah atau mengubah kode native agar mengikuti JNI native header.
3. Menggunakan “javah” untuk menghasilkan JNI header stub untuk kode native
Sekarang kita harus mengubah kode native kita untuk mengikuti spesifikasi pemanggilan JNI. “javah” membantu kita untuk menghasilkan JNI header stub yang benar secara otomatis berdasarkan file sumber kode Java. Perintah “javah” memerlukan Java class file yang sudah di-compile untuk menghasilkan header tersebut. Jadi, kita akan menggunakan perintah “ant” untuk secara cepat menghasilkan Java class file seperti yang diperlihatkan pada gambar di bawah ini (“ant debug”).
Gunakan “javah” untuk menghasilkan JNI header seperti yang ditampilkan pada gambar di atas (baris teks kedua yang disorot warna kuning). Itu akan membuat sebuah direktori “jni” dan header stub sesuai dengan class Java-nya. Tampilan di bawah ini menampilkan JNI native stub yang dihasilkan.
Buat file sumber kode C (“com_example_cpuid_CPUIdApp.c”) yang sesuai dengan header yang dihasilkan di atas. Di bawah ini adalah sumber kodenya:
Kita memanggil kode native cpuid_parse dan mengembalikan buffer yang sudah diurai dalam bentuk teks JNI. Kita sekarang sudah siap untuk meng-compile kode native menggunakan peralatan x86 NDK.
4. Membuat kode native menggunakan NDK untuk x86
Lihat bagian Android Community di situs web Intel (http://software.intel.com/en-us/articles/ndk-for-ia) untuk informasi lebih lanjut tentang instalasi dan penggunaan NDK untuk IA.
Peralatan NDK Android menggunakan sistem build yang mana memerlukan file make yang spesifik didesain untuk Android (Android.mk) berada di folder “jni” proyek kita untuk meng-compile kode native. Android.mk menentukan semua file sumber kode C/C++ native yang akan di-compile termasuk juga header dan tipe build (contoh: shared_library).
Di bawah ini adalah kode native Android untuk perintah make untuk proyek kita (“jni/Android.mk”).
Ini adalah skenario sederhana yang melibatkan 2 file sumber kode C dan digunakan untuk membuat shared library.
Sekarang kita dapat menggunakan perintah “ndk-build APP_ABI=x86” untuk mem-build kode native kita dan menghasilkan shared library. Sistem build Android juga menyediakan file make tambahan lainnya “Application.mk” yang bisa kita gunakan untuk menspesifikasikan opsi konfigurasi tambahan. Sebagai contoh, kita dapat menspesifikasikan semua ABI yang didukung di file Application.mk dan ndk-build akan menghasilkan native shared library yang ditargetkan untuk semua arsitektur.
Gambar di atas menampilkan proses compile kode native x86 yang sukses dan juga menampilkan shared library yang sedang dihasilkan dan diinstal. Kita sekarang sudah siap untuk membuat ulang kembali aplikasi Android kita dan menginstal/menjalankan di emulator x86 atau perangkat pengetesan.
5. Membuat ulang, Menginstal, dan Menjalankan Aplikasi NDK Android untuk IA
Kita dapat menggunakan perintah “ant debug clean” untuk menghapus build file lama kita dan mengeksekusi lagi perintah “ant debug” untuk memulai pembuatan ulang proyek Android secara menyeluruh. Gunakan perintah “adb” untuk menginstal ulang aplikasinya di perangkat pengetesan atau emulator x86 seperti yang ditampilkan pada gambar di bawah ini:
Gambar di bawah ini menampilkan ikon aplikasi kita dan hasil dari menjalankan aplikasinya di dalam emulator x86.
Kita sudah sukses membuat aplikasi NDK Android hingga selesai.
Menggunakan peralatan x86 NDK untuk mem-porting aplikasi NDK Android yang sudah ada ke perangkat berbasis IA
Aplikasi Android dengan kode native biasanya memiliki struktur proyek yang standar di mana terdapat folder “jni” yang berisi kode sumber native dan build file Android.mk/Application.mk yang sesuai. Di bagian sebelumnya, kita sudah melihat contoh sederhana tentang kode sumber native dan file Android.mk yang sesuai.
Peralatan NDK Android memungkinkan kita untuk menspesifikasikan semua target ABI sekaligus di Application.mk dan secara otomatis membuat native shared library untuk semua target. Sistem build Android akan secara otomatis mempaketkan semua target native library di dalam APK dan pada saat menginstal manajer paket Android akan menginstal native library yang sesuai dengan target arsitektur.
Kita dapat menggunakan perintah “ndk-build” atau menspesifikasikannya di Application.mk
APP_ABI := all
atau
APP_ABI := armeabi armeabi-v7a x86
Lihat http://developer.android.com/sdk/ndk/index.html untuk informasi lebih lanjut tentang ini.
Untuk mem-porting aplikasi Android dengan kode native (yang belum ditargetkan untuk x86), proses pengubahan aplikasinya agar mendukung IA itu sangat mudah untuk kebanyakan kasus (seperti yang dijelaskan di atas) kecuali jika aplikasinya menggunakan bahasa assembly atau construct yang spesifik dengan suatu arsitektur. Selain itu ada kemungkinan masalah lain seperti memory alignment atau penggunaan instruksi yang spesifik ke satu platform. Lihat http://software.intel.com/en-us/articles/ndk-android-application-porting-methodologies untuk informasi lebih lanjut.
* Kunjungi Intel Developer Zone for Android untuk mengetahui lebih lanjut. Artikel asli dari artikel ini dapat dilihat di link ini.