Bagaimana Cara Mengonfigurasikan CMake pada Android Studio?

Desember 10, 2019

Bagaimana Cara Mengonfigurasikan CMake pada Android Studio?

Skrip build CMake adalah file teks biasa yang harus diberi nama CMakeLists.txt dan menyertakan perintah yang digunakan CMake untuk mem-build library C/C++ Anda. Jika sumber native Anda belum memiliki skrip build CMake, Anda perlu membuatnya sendiri dan menyertakan perintah CMake yang sesuai.

Bagian ini membahas tentang beberapa perintah dasar yang harus Anda sertakan dalam skrip build agar dapat memberi tahu CMake sumber mana yang digunakan saat membuat library native Anda. Untuk mempelajari lebih lanjut, baca dokumentasi resmi tentang perintah CMake.

Setelah mengonfigurasi skrip build CMake baru, Anda perlu mengonfigurasi Gradle untuk menyertakan project CMake sebagai dependensi build, sehingga Gradle dapat mem-build dan memaketkan library native Anda dengan APK aplikasi.

Catatan: Jika project menggunakan ndk-build, Anda tidak perlu membuat skrip build CMake. Anda cukup mengonfigurasi Gradle untuk menyertakan project library native yang ada dengan menyediakan lokasi file Android.mk Anda.

Membuat skrip build CMake

Untuk membuat file teks biasa yang dapat Anda gunakan sebagai skrip build CMake, lakukan langkah berikut:

Buka panel Project dari sisi kiri IDE, lalu pilih tampilan Project dari menu drop-down.
Klik kanan pada direktori utama modul Anda, lalu pilih New > File.
Catatan: Anda dapat membuat skrip build di lokasi mana pun yang Anda inginkan. Namun, saat mengonfigurasi skrip build, lokasi file dan library sumber native bersifat relatif terhadap lokasi skrip build.
Masukkan "CMakeLists.txt" sebagai nama file, lalu klik OK.

Kini Anda dapat mengonfigurasi skrip build dengan menambahkan perintah CMake. Untuk menginstruksikan CMake agar membuat library native dari kode sumber native, tambahkan perintah cmake_minimum_required() dan add_library() ke skrip build:

    # 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 )

Tips: Mirip dengan cara Anda memberi tahu CMake untuk membuat library native dari file sumber, Anda juga dapat menggunakan perintah add_executable() guna memberi tahu CMake untuk membuat file sumber yang dapat dijalankan. Namun, mem-build file yang dapat dijalankan dari sumber native adalah opsional, dan mem-build library native untuk dipaketkan ke APK Anda akan memenuhi sebagian besar persyaratan project.

Jika Anda menambahkan file sumber atau library ke skrip build CMake menggunakan add_library(), Android Studio juga akan menampilkan file header terkait dalam tampilan Project setelah Anda menyinkronkan project. Namun, agar CMake dapat menemukan file header Anda selama waktu kompilasi, Anda perlu menambahkan perintah include_directories() ke skrip build CMake dan menetapkan lokasi header:

    add_library(...)

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

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

liblibrary-name.so

Misalnya, jika Anda menetapkan "native-lib" sebagai nama library bersama dalam skrip build, CMake akan membuat file bernama libnative-lib.so. Namun, saat memuat library ini dalam kode Java atau Kotlin, gunakan nama yang Anda tetapkan dalam skrip build CMake:

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

Catatan: Jika Anda mengganti nama atau menghapus library dalam skrip build CMake, Anda harus membersihkan project sebelum Gradle menerapkan perubahan atau menghapus versi library lama dari APK Anda. Untuk membersihkan project, pilih Build > Clean Project dari panel menu.

Android Studio secara otomatis menambahkan file sumber dan header ke grup cpp dalam panel Project. Dengan beberapa perintah add_library(), Anda dapat menentukan library tambahan agar CMake dapat melakukan build dari file sumber lainnya.

Menambahkan NDK API

Android NDK menyediakan kumpulan library dan API native yang mungkin berguna. Anda dapat menggunakan semua API ini dengan library NDK dalam file skrip CMakeLists.txt project.

Library NDK bawaan sudah ada di platform Android, jadi Anda tidak perlu mem-build atau memaketkannya ke APK. Karena library NDK sudah menjadi bagian dari lokasi penelusuran CMake, Anda bahkan tidak perlu menentukan lokasi library di penginstalan NDK lokal. Anda hanya perlu menyediakan CMake dengan nama library yang ingin digunakan dan menautkannya terhadap library native Anda sendiri.

Tambahkan perintah find_library() ke skrip build CMake untuk menemukan library NDK dan menyimpan lokasinya sebagai variabel. Anda menggunakan variabel ini untuk merujuk ke library NDK di bagian lain skrip build. Contoh berikut menemukan support library log spesifik Android dan menyimpan lokasinya 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 library native Anda dapat memanggil fungsi dalam library log, Anda perlu menautkan library menggunakan perintah target_link_libraries() dalam skrip build 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 library sebagai kode sumber yang perlu di-build dan ditautkan ke library native. Anda dapat mengompilasi kode sumber ke library native menggunakan perintah add_library() dalam skrip build CMake. Untuk menyediakan lokasi library NDK lokal, Anda dapat menggunakan variabel lokasi ANDROID_NDK, yang ditentukan Android Studio secara otomatis untuk Anda.

Perintah berikut memberi tahu CMake untuk mem-build android_native_app_glue.c, yang mengelola peristiwa siklus proses NativeActivity dan input sentuh, ke library 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 library bawaan lainnya

Langkah menambahkan library bawaan serupa dengan menetapkan library native lainnya untuk CMake yang di-build. Namun, karena library sudah di-build, Anda perlu menggunakan tanda IMPORTED untuk memberi tahu CMake bahwa Anda hanya ingin mengimpor library ke project:

    add_library( imported-lib
                 SHARED
                 IMPORTED )

Selanjutnya Anda perlu menetapkan lokasi library menggunakan perintah set_target_properties()seperti yang ditunjukkan di bawah ini.

Beberapa library menyediakan paket terpisah untuk arsitektur CPU spesifik, atau Application Binary Interfaces (ABI), dan mengaturnya ke beberapa direktori terpisah. Pendekatan ini membantu library memanfaatkan arsitektur CPU spesifik serta memungkinkan Anda hanya menggunakan versi library yang Anda inginkan. Untuk menambahkan beberapa versi ABI library ke skrip build CMake, tanpa perlu menulis banyak perintah untuk setiap versi library, Anda dapat menggunakan variabel lokasi ANDROID_ABI. Variabel ini menggunakan daftar ABI default yang didukung NDK atau daftar ABI terfilter yang secara manual mengonfigurasi Gradle untuk digunakan. Contoh:

    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 dapat menemukan file header selama waktu kompilasi, Anda perlu menggunakan perintah include_directories() dan menyertakan lokasi file header:

    include_directories( imported-lib/include/ )

Catatan: Jika Anda ingin memaketkan library bawaan yang bukan dependensi waktu-build, misalnya, saat menambahkan library bawaan yang merupakan dependensi imported-lib, Anda tidak perlu melakukan petunjuk berikut ini untuk menautkan library.

Untuk menautkan library bawaan ke library native Anda sendiri, tambahkan ke perintah target_link_libraries() dalam skrip build CMake:

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

Untuk memaketkan library bawaan ke APK, Anda perlu mengonfigurasi Gradle secara manual dengan blok sourceSets untuk menyertakan lokasi file .so Anda. Setelah mem-build APK, Anda dapat memverifikasi library yang dipaketkan oleh Gradle ke APK menggunakan Penganalisis APK.

Menyertakan project CMake lainnya

Jika Anda ingin mem-build beberapa project CMake dan memasukkan output ke project Android, Anda dapat menggunakan satu file CMakeLists.txt sebagai skrip build CMake level atas (yang Anda tautkan ke Gradle) dan menambahkan poject CMake tambahan sebagai dependensi skrip build tersebut. Skrip build CMake level atas berikut menggunakan perintah add_subdirectory() untuk menentukan file CMakeLists.txt lain sebagai dependensi build, lalu menautkan ke outputnya seperti dengan library bawaan lainnya.

    # Sets lib_src_DIR to the path of the target CMake project.
    set( lib_src_DIR ../gmath )

    # Sets lib_build_DIR to the path of the desired output directory.
    set( lib_build_DIR ../gmath/outputs )
    file(MAKE_DIRECTORY ${lib_build_DIR})

    # Adds the CMakeLists.txt file located in the specified directory
    # as a build dependency.
    add_subdirectory( # Specifies the directory of the CMakeLists.txt file.
                      ${lib_src_DIR}

                      # Specifies the directory for the build outputs.
                      ${lib_build_DIR} )

    # Adds the output of the additional CMake build as a prebuilt static
    # library and names it lib_gmath.
    add_library( lib_gmath STATIC IMPORTED )
    set_target_properties( lib_gmath PROPERTIES IMPORTED_LOCATION
                           ${lib_build_DIR}/${ANDROID_ABI}/lib_gmath.a )
    include_directories( ${lib_src_DIR}/include )

    # Links the top-level CMake build output against lib_gmath.
    target_link_libraries( native-lib ... lib_gmath )

Was this page helpful?

sumber: https://developer.android.com/studio/projects/configure-cmake

Cari Blog Ini

YUK BELAJAR ANDROID STUDIO