Skip to content

Most visited

Recently visited

navigation

Menambahkan Kode C dan C++ ke Proyek Anda

Dengan menggunakan Android Studio 2.2 atau yang lebih tinggi bersama Android Plugin untuk Gradle versi 2.2.0 atau yang lebih tinggi, Anda bisa menambahkan kode C dan C++ ke aplikasi dengan mengompilasinya ke dalam pustaka asli yang bisa dikemas Gradle bersama APK Anda. Kode Java Anda nanti bisa memanggil fungsi di pustaka asli melalui Java Native Interface (JNI). Jika Anda ingin mengetahui selengkapnya tentang menggunakan kerangka kerja JNI, baca Tip JNI untuk Android.

Alat pembangunan default Android Studio untuk pustaka asli adalah CMake. Android Studio juga mendukung ndk-build karena sejumlah besar proyek yang ada menggunakan toolkit pembangunan untuk mengompilasi kode asli mereka. Jika Anda ingin mengimpor pustaka ndk-build yang ada ke dalam proyek Android Studio, lihat bagian tentang cara mengonfigurasi Gradle untuk menautkan ke pustaka asli. Akan tetapi, jika Anda membuat pustaka asli yang baru, Anda harus menggunakan CMake.

Laman ini memberi Anda informasi yang dibutuhkan untuk mempersiapkan Android Studio dengan alat pembangunan yang diperlukan, buat atau konfigurasikan proyek untuk mendukung kode asli di Android, dan bangun serta jalankan aplikasi Anda.

Catatan: Jika proyek yang ada menggunakan alat ndkCompile yang tidak digunakan lagi, Anda harus membuka file build.properties dan membuang baris kode berikut sebelum menautkan Gradle ke pustaka asli:

// Remove this line
android.useDeprecatedNdk = true

Perhatian untuk pengguna Gradle eksperimental: Pertimbangkan migrasi ke plugin versi 2.2.0 atau yang lebih tinggi, dan menggunakan CMake atau ndk-build untuk membangun pustaka asli jika ada dari berikut ini yang berlaku untuk Anda: Proyek asli Anda sudah menggunakan CMake atau ndk-build; Anda lebih baik menggunakan versi stabil sistem pembangunan Gradle; atau perlu mendukung alat pengaya, misalnya CCache. Jika tidak, Anda bisa tetap menggunakan versi eksperimental Gradle dan plugin Android.

Mengunduh NDK dan Build Tools

Untuk mengompilasi dan men-debug kode asli aplikasi, Anda membutuhkan komponen berikut:

Anda bisa memasang komponen ini menggunakan SDK Manager:

  1. Dari proyek yang dibuka, pilih Tools > Android > SDK Manager dari bilah menu.
  2. Klik tab SDK Tools.
  3. Centang kotak-kotak di sebelah LLDB, CMake, dan NDK, seperti yang ditampilkan dalam gambar 1.

    Gambar 1. Memasang LLDB, CMake, dan NDK dari SDK Manager.

  4. Klik Apply, kemudian klik OK dalam dialog munculan.
  5. Bila pemasangan selesai, klik Finish, kemudian klik OK.

Membuat Proyek Baru dengan Dukungan C/C++

Membuat proyek baru dengan dukungan untuk kode asli mirip dengan membuat proyek Android Studio lainnya:, namun ada beberapa langkah tambahan:

  1. Di bagian Configure your new project pada wizard, tandai kotak centang Include C++ Support.
  2. Klik Next.
  3. Lengkapi semua bidang lainnya dan beberapa bagian berikutnya pada wizard seperti biasa.
  4. Di bagian Customize C++ Support pada wizard, Anda bisa menyesuaikan proyek dengan opsi berikut:
    • C++ Standard: gunakan daftar tarik-turun untuk memilih standardisasi C++ yang ingin Anda gunakan. Memilih Toolchain Default berarti menggunakan setelan CMake default.
    • Exceptions Support: centang kotak ini jika Anda ingin mengaktifkan dukungan untuk penanganan pengecualian C++. Jika diaktifkan, Android Studio akan menambahkan flag -fexceptions ke cppFlags dalam file build.gradle tingkat modul, yang akan diteruskan Gradle ke CMake.
    • Runtime Type Information Support: centang kotak ini jika Anda ingin menginginkan dukungan untuk RTTI. Jika diaktifkan, Android Studio akan menambahkan flag -frtti ke cppFlags dalam file build.gradle tingkat modul, yang akan diteruskan Gradle ke CMake.
  5. Klik Finish.

Setelah Android Studio menyelesaikan pembuatan proyek baru Anda, buka panel Project dari sisi kiri IDE dan pilih tampilan Android. Seperti yang ditampilkan dalam gambar 2, Android Studio menambahkan grup cpp dan External Build Files:

    Gambar 2. Grup tampilan Android untuk sumber asli dan skrip pembangunan eksternal Anda.

    Catatan: Tampilan ini tidak mencerminkan hierarki file sesungguhnya di disk, melainkan mengelompokkan file yang serupa untuk menyederhanakan navigasi proyek Anda.

  1. Grup cpp adalah tempat menemukan semua file sumber asli, header, dan pustaka bawaan yang menjadi bagian dari proyek Anda. Untuk proyek baru, Android Studio akan membuat contoh file sumber C++, native-lib.cpp, dan menempatkannya dalam direktori src/main/cpp/ modul aplikasi Anda. Kode contoh ini menyediakan fungsi C++ sederhana, stringFromJNI(), yang mengembalikan string “Hello from C++”. Anda bisa mempelajari cara menambahkan file sumber tambahan ke proyek di bagian tentang cara Membuat file sumber asli yang baru.
  2. Grup External Build Files adalah tempat Anda bisa menemukan skrip pembangunan untuk CMake atau ndk-build. Mirip dengan cara file build.gradle memberi tahu Gradle cara membangun aplikasi Anda, CMake dan ndk-build memerlukan skrip pembangunan untuk mengetahui cara membangun pustaka asli. Untuk proyek baru, Android Studio membuat skrip pembangunan CMake, CMakeLists.txt, dan menempatkannya dalam direktori akar modul Anda. Anda bisa mengetahui selengkapnya tentang materi skrip pembangunan ini di bagian tentang cara Membuat Skrip Pembangunan Cmake.

Membangun dan menjalankan aplikasi contoh

Bila Anda mengeklik Run jalankan kemudian jalankan aplikasi dari bilah menu, Android Studio akan membangun dan meluncurkan aplikasi yang menampilkan teks “Hello from C++” pada perangkat Android atau emulator Anda. Ringkasan berikut menjelaskan kejadian-kejadian yang berlangsung dalam rangka membangun dan menjalankan aplikasi contoh:

  1. Gradle memanggil skrip pembangunan eksternal Anda, CMakeLists.txt.
  2. CMake mengikuti perintah dalam skrip pembangunan untuk mengompilasi file sumber C++, native-lib.cpp, ke dalam pustaka objek bersama dan menamakannya libnative-lib.so, yang kemudian dipaketkan Gradle ke dalam APK.
  3. Selama waktu proses, MainActivity aplikasi akan memuat pustaka asli dengan menggunakan System.loadLibrary(). Fungsi asli pustaka, stringFromJNI(), kini tersedia untuk aplikasi.
  4. MainActivity.onCreate() memanggil stringFromJNI(), yang akan mengembalikan “Hello from C++”, dan menggunakannya untuk memperbarui TextView.

Catatan: Instant Run tidak kompatibel dengan proyek yang menggunakan kode asli. Android Studio secara otomatis menonaktifkan fitur tersebut.

Jika Anda ingin memverifikasi apakah Gradle memaketkan pustaka asli dalam APK, Anda bisa menggunakan Penganalisis APK:

  1. Pilih Build > Analyze APK.
  2. Pilih APK dari direktori app/build/outputs/apk/ dan klik OK.
  3. Seperti yang ditampilkan dalam gambar 3, Anda bisa melihat libnative-lib.so dalam jendela Penganalisis APK pada lib/<ABI>/.

    Gambar 3. Menemukan lokasi pustaka asli menggunakan Penganalisis APK.

Tip: Jika Anda ingin bereksperimen dengan aplikasi Android lainnya yang menggunakan kode asli, klik File > New > Import Sample dan pilih proyek contoh dari daftar Ndk.

Menambahkan Kode C/C++ ke Proyek yang Ada

Jika Anda ingin menambahkan kode asli ke proyek yang ada, lakukan langkah-langkah ini:

  1. Membuat file sumber asli yang baru dan menambahkannya ke proyek Android Studio.
    • Anda bisa lewati langkah ini jika sudah memiliki kode asli atau ingin mengimpor pustaka asli bawaan.
  2. Membuat skrip pembangunan CMake untuk membangun kode sumber asli ke dalam pustaka. Anda juga memerlukan skrip pembangunan ini jika mengimpor dan menautkan ke pustaka platform atau pustaka bawaan.
    • Jika pustaka asli yang Anda miliki sudah berisi skrip pembangunan CMakeLists.txt, atau menggunakan ndk-build dan menyertakan skrip pembangunan Android.mk, Anda bisa lewati langkah ini.
  3. Tautkan Gradle ke pustaka asli Anda dengan menyediakan jalur ke file skrip CMake atau ndk-build. Gradle menggunakan skrip pembangunan untuk mengimpor kode sumber ke dalam proyek Android Studio dan memaketkan pustaka asli (file SO) ke dalam APK.

Setelah mengonfigurasi proyek, Anda bisa mengakses fungsi asli dari kode Java dengan menggunakan kerangka kerja JNI. Untuk membangun dan menjalankan aplikasi Anda, tinggal klik Run jalankan kemudian jalankan aplikasi dari bilah menu. Gradle akan menambahkan proses pembangunan asli eksternal Anda sebagai dependensi untuk mengompilasi, membangun, dan memaketkan pustaka asli bersama APK Anda.

Membuat file sumber asli yang baru

Untuk membuat direktori cpp/ bersama file sumber asli yang baru di sourceset utama modul aplikasi Anda, lakukan seperti berikut:

  1. Buka panel Project dari sisi kiri IDE dan pilih tampilan Project dari menu tarik-turun.
  2. Arahkan ke your-module > src, klik kanan pada direktori main, dan pilih New > Directory.
  3. Masukkan nama direktori (misalnya cpp) dan klik OK.
  4. Klik kanan pada direktori yang baru saja Anda buat dan pilih New > C/C++ Source File.
  5. Masukkan nama untuk file sumber Anda, misalnya native-lib.
  6. Dari menu tarik-turun Type, pilih ekstensi file untuk file sumber Anda, misalnya .cpp.
    • Anda bisa menambahkan jenis file lainnya ke menu tarik-turun, misalnya .cxx atau .hxx, dengan mengeklik Edit File Types . Dalam kotak dialog C/C++ yang muncul, pilih ekstensi file lain dari menu tarik-turun Source Extension dan Header Extension dan klik OK.
  7. Jika Anda juga ingin membuat file header, tandai kotak centang Create an associated header.
  8. Klik OK.

Membuat skrip pembangunan CMake

Jika sumber asli Anda belum memiliki skrip pembangunan CMake, Anda perlu membuatnya sendiri dan menyertakan perintah CMake yang sesuai. Skrip pembangunan CMake adalah file teks biasa yang harus Anda namai CMakeLists.txt. Bagian ini membahas beberapa perintah dasar yang harus Anda sertakan dalam skrip pembangunan agar dapat memberi tahu CMake sumber mana yang akan digunakan saat membuat pustaka asli Anda.

Catatan: Jika proyek Anda menggunakan ndk-build, Anda tidak perlu membuat skrip pembangunan CMake. Anda bisa menautkan Gradle ke pustaka asli dengan menyediakan jalur ke file Android.mk.

Untuk membuat file teks biasa yang bisa Anda gunakan sebagai skrip pembangunan CMake, lakukan seperti berikut:

  1. Buka panel Project dari sisi kiri IDE dan pilih tampilan Project dari menu tarik-turun.
  2. Klik kanan pada direktori akar your-module dan pilih New > File.

    Catatan: Anda bisa membuat skrip pembangunan di lokasi mana saja yang Anda inginkan. Akan tetapi, saat mengonfigurasi skrip pembangunan, jalur ke file sumber asli dan pustaka bersifat relatif terhadap lokasi skrip pembangunan.

  3. Masukkan "CMakeLists.txt" sebagai nama file dan klik OK.

Kini Anda bisa mengonfigurasi skrip pembangunan dengan menambahkan perintah CMake. Untuk memerintahkan CMake membuat pustaka asli dari kode sumber asli, tambahkan perintah cmake_minimum_required() dan add_library() ke skrip pembangunan:

# Sets the minimum version of CMake required to build your native library.
# This ensures that a certain set of CMake features is available to
# your build.

cmake_minimum_required(VERSION 3.4.1)

# Specifies a library name, specifies whether the library is STATIC or
# SHARED, and provides relative paths to the source code. You can
# define multiple libraries by adding multiple add.library() commands,
# and CMake builds them for you. When you build your app, Gradle
# automatically packages shared libraries with your APK.

add_library( # Specifies the name of the library.
             native-lib

             # Sets the library as a shared library.
             SHARED

             # Provides a relative path to your source file(s).
             src/main/cpp/native-lib.cpp )

Bila Anda menambahkan file sumber atau pustaka ke skrip pembangunan CMake dengan menggunakan add_library(), Android Studio juga akan menampilkan file header terkait dalam tampilan Project setelah Anda menyinkronkan proyek. Akan tetapi, agar CMake dapat menemukan file header Anda selama waktu kompilasi, Anda perlu menambahkan perintah include_directories() ke skrip pembangunan CMake dan menetapkan jalur ke header:

add_library(...)

# Specifies a path to native header files.
include_directories(src/main/cpp/include/)

Konvensi yang digunakan CMake untuk menamai file pustaka adalah seperti berikut:

liblibrary-name.so

Misalnya, jika Anda menetapkan "native-lib" sebagai nama pustaka bersama dalam skrip pembangunan, CMake akan membuat file bernama libnative-lib.so. Akan tetapi, saat memuat pustaka ini dalam kode Java, gunakan nama yang Anda tetapkan dalam skrip pembangunan CMake:

static {
    System.loadLibrary(“native-lib”);
}

Catatan: Jika Anda mengganti nama atau membuang pustaka dalam skrip pembangunan CMake, maka Anda perlu membersihkan proyek sebelum Gradle menerapkan perubahan tersebut atau membuang pustaka versi lama dari APK Anda. Untuk membersihkan proyek Anda, pilih Build > Clean Project dari bilah menu.

Android Studio secara otomatis menambahkan file sumber dan header ke grup cpp dalam panel Project. Dengan menggunakan beberapa perintah add_library(), Anda bisa mendefinisikan pustaka tambahan untuk dibangun CMake dari file sumber lainnya.

Menambahkan NDK API

Android NDK menyediakan seperangkat pustaka dan API asli yang mungkin berguna untuk Anda. Anda bisa menggunakan semua API ini dengan menyertakan pustaka NDK dalam file skrip CMakeLists.txt.

Pustaka NDK bawaan sudah ada di platform Android, jadi Anda tidak perlu membangunnya atau memaketkannya ke dalam APK. Karena pustaka NDK sudah menjadi bagian dari jalur penelusuran CMake, maka Anda bahkan tidak perlu menetapkan lokasi pustaka dalam pemasangan NDK lokal—Anda hanya perlu menyediakan nama pustaka yang ingin digunakan pada CMake dan menautkannya ke pustaka asli Anda.

Tambahkan perintah find_library() ke skrip pembangunan CMake untuk menemukan pustaka NDK dan menyimpan jalurnya sebagai variabel. Anda menggunakan variabel ini untuk merujuk ke pustaka NDK di bagian lain skrip pembangunan. Contoh berikut mencari lokasi pustaka dukungan log spesifik Android dan menyimpan jalurnya di log-lib:

find_library( # Defines the name of the path variable that stores the
              # location of the NDK library.
              log-lib

              # Specifies the name of the NDK library that
              # CMake needs to locate.
              log )

Agar pustaka asli Anda dapat memanggil fungsi dalam pustaka log, Anda perlu menautkan pustaka dengan menggunakan perintah target_link_libraries() dalam skrip pembangunan CMake:

find_library(...)

# Links your native library against one or more other native libraries.
target_link_libraries( # Specifies the target library.
                       native-lib

                       # Links the log library to the target library.
                       ${log-lib} )

NDK juga menyertakan beberapa pustaka sebagai kode sumber yang perlu Anda bangun dan tautkan ke pustaka asli. Anda bisa mengompilasi kode sumber ke dalam pustaka asli dengan menggunakan perintah add_library() dalam skrip pembangunan CMake. Untuk menyediakan jalur ke pustaka NDK lokal, Anda bisa menggunakan variabel jalur ANDROID_NDK, yang didefinisikan Android Studio secara otomatis untuk Anda.

Perintah berikut memberi tahu CMake untuk membangun android_native_app_glue.c, yang mengelola kejadian daur hidup NativeActivity dan masukan sentuh, ke dalam pustaka statis dan menautkannya ke native-lib:

add_library( app-glue
             STATIC
             ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c )

# You need to link static libraries against your shared native library.
target_link_libraries( native-lib app-glue ${log-lib} )

Menambahkan pustaka bawaan lainnya

Menambahkan pustaka bawaan mirip dengan menetapkan pustaka asli lainnya yang akan dibangun CMake. Akan tetapi, karena pustaka sudah menjadi bawaan, Anda perlu menggunakan flag IMPORTED untuk memberi tahu CMake bahwa Anda hanya ingin mengimpor pustaka ke dalam proyek:

add_library( imported-lib
             SHARED
             IMPORTED )

Kemudian Anda perlu menetapkan jalur ke pustaka dengan menggunakan perintah set_target_properties() seperti yang ditampilkan di bawah ini.

Beberapa pustaka menyediakan paket terpisah untuk arsitektur CPU tertentu, atau Application Binary Interfaces (ABI), dan mengorganisirnya ke dalam beberapa direktori terpisah. Pendekatan ini membantu pustaka memanfaatkan arsitektur CPU tertentu sekaligus memungkinkan Anda menggunakan versi pustaka yang Anda inginkan saja. Untuk menambahkan beberapa versi ABI pustaka ke skrip pembangunan CMake, tanpa harus menulis banyak perintah untuk setiap versi pustaka, Anda bisa menggunakan variabel jalur ANDROID_ABI. Variabel ini menggunakan daftar ABI default yang didukung NDK, atau daftar ABI yang telah difilter yang Anda konfigurasi secara manual untuk digunakan Gradle. Misalnya:

add_library(...)
set_target_properties( # Specifies the target library.
                       imported-lib

                       # Specifies the parameter you want to define.
                       PROPERTIES IMPORTED_LOCATION

                       # Provides the path to the library you want to import.
                       imported-lib/src/${ANDROID_ABI}/libimported-lib.so )

Agar CMake mencari file header Anda selama waktu kompilasi, Anda perlu menggunakan perintah include_directories() dan menyertakan jalur ke file header:

include_directories( imported-lib/include/ )

Catatan: Jika Anda ingin memaketkan pustaka bawaan yang bukan dependensi waktu-pembangunan—misalnya, saat menambahkan pustaka bawaan yang merupakan dependensi imported-lib, Anda tidak perlu melakukan instruksi berikut untuk menautkan pustaka.

Untuk menautkan pustaka bawaan ke pustaka asli Anda sendiri, tambahkan ke perintah target_link_libraries() dalam skrip pembangunan CMake:

target_link_libraries( native-lib imported-lib app-glue ${log-lib} )

Bila Anda membangun aplikasi, Gradle secara otomatis akan memaketkan pustaka yang diimpor ke dalam APK. Anda bisa memverifikasi pustaka mana yang dipaketkan Gradle ke dalam APK dengan menggunakan Penganalisis APK. Untuk informasi selengkapnya tentang perintah CMake, lihat dokumentasi CMake.

Untuk menautkan Gradle ke pustaka asli, Anda perlu menyediakan jalur ke file skrip CMake atau ndk-build. Bila Anda membangun aplikasi, Gradle akan menjalankan CMake atau ndk-build sebagai dependensi, dan memaketkan pustaka bersama dengan APK Anda. Gradle juga menggunakan skrip pembangunan untuk mengetahui file mana yang akan ditarik ke dalam proyek Android Studio, jadi Anda bisa mengaksesnya dari jendela Project. Jika Anda tidak memiliki skrip pembangunan untuk sumber asli, Anda perlu membuat skrip pembangunan CMake sebelum melanjutkan.

Setelah Anda menautkan Gradle ke proyek asli, Android Studio akan memperbarui panel Project untuk menampilkan file sumber dan pustaka asli dalam grup cpp, dan skrip pembangunan eksternal Anda dalam grup External Build Files.

Catatan: Saat membuat perubahan pada konfigurasi Gradle, pastikan menerapkan perubahan Anda dengan mengeklik Sync Project di bilah alat. Selain itu, saat membuat perubahan pada file skrip CMake atau ndk-build setelah Anda menautkannya ke Gradle, Anda harus menyinkronkan Android Studio dengan perubahan tersebut dengan memilih Build > Refresh Linked C++ Projects dari bilah menu.

Anda bisa menautkan Gradle ke proyek eksternal CMake atau ndk-build dengan menggunakan UI Android Studio:

  1. Buka panel Project dari sisi kiri IDE dan pilih tampilan Android.
  2. Klik kanan pada modul yang ingin Anda tautkan ke pustaka asli, misalnya modul app, dan pilih Link C++ Project with Gradle dari menu. Anda akan melihat dialog yang mirip dengan yang ditampilkan dalam gambar 4.
  3. Dari menu tarik-turun, pilih CMake atau ndk-build.
    1. Jika Anda memilih CMake, gunakan bidang di sebelah Project Path untuk menetapkan file skrip CMakeLists.txt bagi proyek CMake eksternal.
    2. Jika Anda memilih ndk-build, gunakan bidang di sebelah Project Path untuk menetapkan file skrip Android.mk bagi proyek ndk-build eksternal. Android Studio juga menyertakan file Application.mk jika lokasinya sama dengan direktori file Android.mk Anda.

    Gambar 4. Menautkan proyek C++ eksternal dengan menggunakan dialog Android Studio.

  4. Klik OK.

Mengonfigurasi Gradle secara manual

Untuk mengonfigurasi Gradle secara manual guna menautkan ke pustaka asli, Anda perlu menambahkan blok externalNativeBuild {} ke file build.gradle tingkat modul dan konfigurasilah dengan cmake {} atau ndkBuild {}:

android {
  ...
  defaultConfig {...}
  buildTypes {...}

  // Encapsulates your external native build configurations.
  externalNativeBuild {

    // Encapsulates your CMake build configurations.
    cmake {

      // Provides a relative path to your CMake build script.
      path "CMakeLists.txt"
    }
  }
}

Catatan: Jika Anda ingin menautkan Gradle ke proyek ndk-build yang ada, gunakan blok ndkBuild {} sebagai ganti cmake {}, dan sediakan jalur relatif ke file Android.mk. Gradle juga menyertakan file Application.mk jika lokasinya sama dengan direktori file Android.mk Anda.

Menetapkan konfigurasi opsional

Anda bisa menetapkan argumen opsional dan flag untuk CMake atau ndk-build dengan mengonfigurasi blok externalNativeBuild {} lain dalam blok defaultConfig {} file build.gradle tingkat modul. Demikian pula dengan properti lain dalam blok defaultConfig {}, Anda bisa mengganti properti ini untuk setiap macam produk dalam konfigurasi pembangunan Anda.

Misalnya, jika proyek CMake atau ndk-build Anda mendefinisikan banyak pustaka asli, Anda bisa menggunakan properti targets untuk membangun dan memaketkan subset pustaka itu saja bagi ragam produk yang ditentukan. Kode contoh berikut menjelaskan beberapa properti yang bisa Anda konfigurasi:

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {

      // For ndk-build, instead use ndkBuild {}
      cmake {

        // Passes optional arguments to CMake.
        arguments "-DANDROID_ARM_NEON=TRUE", "-DANDROID_TOOLCHAIN=clang"

        // Sets optional flags for the C compiler.
        cFlags "-D_EXAMPLE_C_FLAG1", "-D_EXAMPLE_C_FLAG2"

        // Sets a flag to enable format macro constants for the C++ compiler.
        cppFlags "-D__STDC_FORMAT_MACROS"
      }
    }
  }

  buildTypes {...}

  productFlavors {
    ...
    demo {
      ...
      externalNativeBuild {
        cmake {
          ...
          // Specifies which native libraries to build and package for this
          // product flavor. If you don't configure this property, Gradle
          // builds and packages all shared object libraries that you define
          // in your CMake or ndk-build project.
          targets "native-lib-demo"
        }
      }
    }

    paid {
      ...
      externalNativeBuild {
        cmake {
          ...
          targets "native-lib-paid"
        }
      }
    }
  }

  // Use this block to link Gradle to your CMake or ndk-build script.
  externalNativeBuild {
    cmake {...}
    // or ndkBuild {...}
  }
}

Untuk mengetahui selengkapnya tentang mengonfigurasi ragam produk dan varian pembangunan, masuklah ke Mengonfigurasi Varian Pembangunan. Untuk daftar variabel yang bisa Anda konfigurasi bagi CMake dengan properti arguments, lihat Menggunakan Variabel CMake.

Menetapkan ABI

Secara default, Gradle membangun pustaka asli Anda ke dalam file .so terpisah untuk ABI yang didukung NDK dan memaketkannya semua ke dalam APK. Jika Anda ingin Gradle membangun dan memaketkan konfigurasi ABI tertentu saja pada pustaka asli, Anda bisa menetapkannya dengan flag ndk.abiFilters dalam file build.gradle tingkat modul, seperti yang ditampilkan di bawah ini:

android {
  ...
  defaultConfig {
    ...
    externalNativeBuild {
      cmake {...}
      // or ndkBuild {...}
    }

    ndk {
      // Specifies the ABI configurations of your native
      // libraries Gradle should build and package with your APK.
      abiFilters 'x86', 'x86_64', 'armeabi', 'armeabi-v7a',
                   'arm64-v8a'
    }
  }
  buildTypes {...}
  externalNativeBuild {...}
}

Umumnya, Anda hanya perlu menetapkan abiFilters dalam blok ndk {}, seperti yang ditampilkan di atas, karena ini akan memberi tahu Gradle mengenai kedua pembangunan dan memaketkan semua versi pustaka asli Anda. Akan tetapi, jika Anda ingin mengontrol apa yang harus dibangun Gradle, tanpa memedulikan apa yang ingin Anda paketkan ke dalam APK, konfigurasilah flag abiFilters lain dalam blok defaultConfig.externalNativeBuild.cmake {} (atau blok defaultConfig.externalNativeBuild.ndkBuild {}). Gradle akan membangun semua konfigurasi ABI itu namun hanya memaketkan konfigurasi yang Anda tetapkan dalam blok defaultConfig.ndk{}.

Untuk mengurangi lebih jauh ukuran APK, pertimbangkan mengonfigurasi potongan APK ABI—sebagai ganti membuat satu APK besar berisi semua versi pustaka asli Anda, Gradle akan membuat APK terpisah untuk setiap ABI yang ingin Anda dukung dan hanya memaketkan file yang dibutuhkan setiap ABI. Jika Anda mengonfigurasi potongan ABI tanpa menetapkan flag abiFilters seperti yang ditampilkan dalam contoh kode di atas, Gradle akan membangun semua versi ABI yang didukung oleh pustaka asli Anda, namun hanya memaketkan yang Anda tetapkan dalam konfigurasi potongan ABI. Untuk menghindari pembangunan versi pustaka asli yang tidak Anda inginkan, sediakan daftar ABI yang sama untuk flag abiFilters maupun konfigurasi potongan ABI Anda.

This site uses cookies to store your preferences for site-specific language and display options.

Get the latest Android developer news and tips that will help you find success on Google Play.

* Required Fields

Hooray!

Follow Google Developers on WeChat

Browse this site in ?

You requested a page in , but your language preference for this site is .

Would you like to change your language preference and browse this site in ? If you want to change your language preference later, use the language menu at the bottom of each page.

This class requires API level or higher

This doc is hidden because your selected API level for the documentation is . You can change the documentation API level with the selector above the left navigation.

For more information about specifying the API level your app requires, read Supporting Different Platform Versions.

Take a short survey?
Help us improve the Android developer experience.
(Sep 2017 survey)