Diese Seite wurde von der Cloud Translation API übersetzt.

CMake konfigurieren

Ein CMake-Build-Skript ist eine Nur-Text-Datei, die Sie benennen müssen CMakeLists.txt und enthält Befehle, mit denen CMake Ihre C/C++ Bibliotheken. Wenn Ihre nativen Quellen noch keinen CMake-Build haben Skript erstellen, müssen Sie selbst eins erstellen und die entsprechende CMake-up-Datei . Eine Anleitung zum Installieren von CMake finden Sie unter NDK installieren und konfigurieren und CMake.

In diesem Abschnitt werden einige grundlegende Befehle behandelt, die Sie in Ihren Build aufnehmen sollten um CMake mitzuteilen, welche Quellen beim Erstellen der nativen Bibliothek. Weitere Informationen finden Sie in der offiziellen Dokumentation zu CMake-Befehlen.

Nachdem Sie ein neues CMake-Build-Skript konfiguriert haben, müssen Sie Gradle konfigurieren Ihr CMake-Projekt als Build-Abhängigkeit hinzuzufügen, sodass Gradle ein Ihre native Bibliothek mit dem APK Ihrer App verpackt.

Hinweis: Wenn Ihr Projekt ndk-build verwendet, müssen Sie nicht Erstellen Sie ein CMake-Build-Skript. Sie können einfach <ph type="x-smartling-placeholder"></ph> Gradle konfigurieren um Ihr vorhandenes natives Bibliotheksprojekt einzubeziehen, indem Sie einen Pfad zu Ihrem Android.mk-Datei.

CMake-Build-Script erstellen

Um eine Nur-Text-Datei zu erstellen, die Sie als Ihr CMake-Build-Skript verwenden können, gehen Sie wie folgt vor:

Öffnen Sie links in der IDE den Bereich Project (Projekt) und wählen Sie Projektansicht aus.
Klicken Sie mit der rechten Maustaste auf das Stammverzeichnis von your-module und wählen Sie Neu > Datei:
Hinweis: Sie können das Build-Skript an einem beliebigen Speicherort erstellen. Beim Konfigurieren des Build-Skripts müssen jedoch die Pfade zur nativen Quelle angegeben werden. -Dateien und -Bibliotheken beziehen sich auf den Speicherort des Build-Skripts.
Geben Sie „CMakeLists.txt“ ein. als Dateinamen ein und klicken Sie auf OK.

Sie können Ihr Build-Skript jetzt konfigurieren, indem Sie CMake-Befehle hinzufügen. Anweisungen Fügen Sie Ihrem Build-Skript die Befehle cmake_minimum_required() und add_library() hinzu, um eine native Bibliothek aus dem nativen Quellcode zu erstellen:

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

Tipp:So können Sie CMake anweisen, eine native Bibliothek aus Quelldateien haben, können Sie den <ph type="x-smartling-placeholder"></ph> add_executable(), damit CMake stattdessen eine aus diesen Quelldateien ausführbar ist. Das Erstellen ausführbarer Dateien native Quellen optional ist. Wenn Sie native Bibliotheken für die Paketerstellung in Ihren Das APK erfüllt die meisten Projektanforderungen.

Wenn Sie Ihrem CMake-Build-Skript mithilfe add_library(), Android Studio zeigt auch zugehörige Headerdateien an in der Ansicht Projekt angezeigt, nachdem Sie Ihr Projekt synchronisiert haben. In damit CMake Ihre Header-Dateien während der Kompilierung findet, müssen Sie Fügen Sie den Befehl include_directories() in CMake ein. und geben Sie den Pfad zu Ihren Headern an:

add_library(...)

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

CMake verwendet folgende Konvention, um die Datei Ihrer Bibliothek zu benennen:

liblibrary-name.so

Wenn Sie beispielsweise "native-lib" angeben, als Name Ihrer gemeinsam genutzten Bibliothek verwenden. im Build-Skript erstellt CMake eine Datei mit dem Namen libnative-lib.so Beim Laden dieser Bibliothek in Ihr Verwenden Sie für Java- oder Kotlin-Code den Namen, den Sie im CMake-Build-Skript angegeben haben:

Kotlin

companion object {
    init {
        System.loadLibrary("native-lib");
    }
}

Java

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

Hinweis:Wenn Sie eine Bibliothek in Ihrem CMake-Build umbenennen oder entfernen müssen Sie Ihr Projekt bereinigen, bevor Gradle die Änderungen anwendet. wird die ältere Version der Bibliothek aus deinem APK entfernt. So reinigen Sie Ihr wählen Sie Build > Projekt bereinigen aus.

Android Studio fügt die Quelldateien und Header automatisch zum cpp-Gruppe im Bereich Project (Projekt). Durch die Verwendung von add_library()-Befehle verwenden, können Sie zusätzliche Bibliotheken, die CMake aus anderen Quelldateien erstellen kann.

NDK APIs hinzufügen

Das Android NDK bietet eine Reihe nativer APIs und Bibliotheken, die Sie möglicherweise nützlich sind. Sie können jede dieser APIs verwenden, indem Sie die NDK-Bibliotheken in das CMakeLists.txt-Skriptdatei.

Auf der Android-Plattform gibt es bereits vordefinierte NDK-Bibliotheken. erstellen oder in Ihr APK packen. Da die NDK-Bibliotheken bereits Teil des Suchpfads von CMake sind, müssen Sie nicht einmal Speicherort der Bibliothek in Ihrer lokalen NDK-Installation. Sie müssen nur Geben Sie in CMake den Namen der Bibliothek an, die Sie verwenden möchten, und verknüpfen Sie diese mit Ihrer eigenen nativen Bibliothek vergleichen.

Fügen Sie dem CMake-Build den Befehl find_library() hinzu. um eine NDK-Bibliothek zu finden und ihren Pfad als Variable zu speichern. Sie verwenden um in anderen Teilen des Build-Skripts auf die NDK-Bibliothek zu verweisen. Im folgenden Beispiel wird die Android-spezifische Protokoll-Supportbibliothek ermittelt. und speichert den Pfad in 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 )

Damit über deine native Bibliothek Funktionen im log aufgerufen werden können, müssen Sie die Bibliotheken mit dem Befehl target_link_libraries() in Ihr CMake-Build-Skript:

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

Das NDK enthält auch einige Bibliotheken als Quellcode, die Sie zum Erstellen und einen Link zu Ihrer nativen Bibliothek. Sie können den Quellcode in einer native Bibliothek mithilfe des Befehls add_library() in der CMake-Datei Build-Script. Um einen Pfad zu Ihrer lokalen NDK-Bibliothek anzugeben, können Sie den ANDROID_NDK-Pfadvariable, die Android Studio automatisch für Sie definiert.

Der folgende Befehl weist CMake an, android_native_app_glue.c verwaltet NativeActivity Lebenszyklus-Ereignisse und Berührungseingabe in eine statische Bibliothek verschieben 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} )

Weitere vordefinierte Bibliotheken hinzufügen

Das Hinzufügen einer vordefinierten Bibliothek ähnelt der Angabe einer anderen nativen Bibliothek für mit CMake erstellen. Da die Bibliothek bereits erstellt wurde, müssen Sie IMPORTED, um CMake mitzuteilen, dass Sie die Bibliothek nur in Ihr Projekt importieren möchten:

add_library( imported-lib
             SHARED
             IMPORTED )

Anschließend müssen Sie den Pfad zur Bibliothek mithilfe der set_target_properties()-Befehl als wie unten dargestellt.

Einige Bibliotheken bieten separate Pakete für bestimmte CPU-Architekturen oder Application Binary Interfaces (ABI) und in separaten Verzeichnissen organisieren. Dieser Ansatz hilft Bibliotheken dabei, bestimmte CPU-Architekturen nutzen und gleichzeitig nur die der gewünschten Bibliothek. Mehrere ABI-Versionen einer Bibliothek hinzufügen in Ihr CMake-Build-Skript kopieren, ohne mehrere Befehle für Version der Bibliothek erhalten möchten, können Sie den Pfad ANDROID_ABI verwenden. . Für diese Variable wird eine Liste der vom NDK unterstützten standardmäßigen ABIs oder eine gefilterte Liste verwendet. der ABIs, die du <ph type="x-smartling-placeholder"></ph> Gradle manuell konfigurieren. Beispiel:

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 )

Damit CMake Ihre Header-Dateien während der Kompilierung findet, müssen Sie den Befehl include_directories() und fügen Sie den Pfad zu Ihrem Headerdateien:

include_directories( imported-lib/include/ )

Hinweis:Wenn Sie eine vordefinierte Bibliothek verpacken möchten, Abhängigkeit von der Build-Zeit, z. B. beim Hinzufügen einer vordefinierten Bibliothek, die ein imported-lib ist, müssen Sie den folgen Sie der Anleitung, um die Bibliothek zu verknüpfen.

Um die vordefinierte Bibliothek mit Ihrer eigenen nativen Bibliothek zu verknüpfen, fügen Sie sie zum target_link_libraries()-Befehl im CMake-Build-Skript:

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

Um die vordefinierte Bibliothek in Ihr APK zu verpacken, müssen Sie <ph type="x-smartling-placeholder"></ph> Gradle manuell mit dem sourceSets-Block konfigurieren, Geben Sie den Pfad zu Ihrer .so-Datei an. Nachdem Sie Ihr APK erstellt haben, können Sie prüfen, welche Bibliotheken Gradle-Pakete in Ihrem APK enthalten. Verwenden Sie dazu die APK Analyzer:

Andere CMake-Projekte einbeziehen

Wenn Sie mehrere CMake-Projekte erstellen und deren Ausgaben in Ihr Android-Projekt verwenden, können Sie eine CMakeLists.txt-Datei als übergeordnetes CMake-Build-Skript (das ist das, das Sie Link in Gradle) und fügen Sie weitere CMake-Projekte als Abhängigkeiten dieses Builds hinzu. . Das folgende übergeordnete CMake-Build-Skript verwendet das Anzugebender add_subdirectory()-Befehl CMakeLists.txt-Datei als Build-Abhängigkeit zu platzieren und wie bei jeder anderen vordefinierten Bibliothek.

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

CMake über die Befehlszeile aufrufen

Verwenden Sie den folgenden Befehl, um CMake aufzurufen und ein Ninja-Projekt außerhalb von von Android Studio:

cmake
-Hpath/to/cmakelists/folder
-Bpath/to/generated/ninja/project/debug/ABI
-DANDROID_ABI=ABI                               // For example, arm64-v8a
-DANDROID_PLATFORM=platform-version-string      // For example, android-16
-DANDROID_NDK=android-sdk/ndk/ndk-version
-DCMAKE_TOOLCHAIN_FILE=android-sdk/ndk/ndk-version/build/cmake/android.toolchain.cmake
-G Ninja

Dieser Befehl generiert das Ninja-Projekt, das ausgeführt werden kann, um Ausführbare Android-Bibliotheken (.so-Dateien) CMAKE_TOOLCHAIN_FILE ist erforderlich, um den CMake-Support von NDK zu nutzen. Ab CMake 3.21 ist die integrierte Stattdessen kann NDK-Unterstützung verwendet werden, es muss jedoch eine andere Gruppe von Variablen verwendet werden enthalten, wie in der CMake-Dokumentation Cross Compiling for Android beschrieben.