プロジェクトへの C / C++ コードの追加

Android Studio 2.2 以上と Gradle バージョン 2.2.0 以上用の Android プラグインを使用すると、C / C++ コードをコンパイルしてネイティブライブラリを作成し、それを Gradle で APK にパッケージ化することで、C / C++ コードをアプリに追加できます。Java コードは JNI（Java Native Interface）を介してネイティブライブラリの関数を呼び出すことができます。JNI フレームワークの使用の詳細については、Android での JNI の使い方をご覧ください。

Android Studio はネイティブライブラリのビルドツールとしてデフォルトで CMake を使用します。Android Studio は、ndk-build もサポートしています。ほとんどの既存プロジェクトで、ネイティブコードのコンパイルにはこのビルドツールキットが使用されているためです。既存の ndk-build ライブラリを Android Studio プロジェクトにインポートする必要がある場合は、Gradle でのネイティブライブラリへのリンクの設定方法に関するセクションをご覧ください。ただし、新しいネイティブライブラリを作成している場合は CMake を使用する必要があります。

このページでは、必要なビルドツールと Android Studio をセットアップして、Android でネイティブコードをサポートするプロジェクトを作成または設定し、アプリをビルドおよび実行するために必要な情報を提供します。

注: 既存のプロジェクトでサポートを終了した ndkCompile ツールを使用している場合、build.properties ファイルを開いてコードの次の行を削除してから、Gradle をネイティブライブラリにリンクさせます。

// Remove this line
android.useDeprecatedNdk = true

試験運用版の Gradle ユーザーの皆様へ: 次のいずれかの条件にあてはまる場合は、プラグインバージョン 2.2.0 以上への移行と、CMake または ndk-build を使用してネイティブライブラリをビルドすることをご検討ください。ネイティブプロジェクトですでに CMake または ndk-build を使用している。Gradle ビルドシステムの安定版のほうを使用したい。CCache など、アドオンツールのサポートを必要としている。それ以外の場合は、引き続き試験運用版の Gradle と Android プラグインを使用できます。

NDK とビルドツールのダウンロード

アプリのネイティブコードをコンパイルおよびデバッグするには、次のコンポーネントが必要です。

Android NDK（Native Development Kit）: Android で C / C++ コードを使用できるツールセットで、ネイティブアクティビティを管理して、センサーやタップ入力など実機のコンポーネントにアクセスできるプラットフォームライブラリを提供します。
CMake: Gradle と一緒に使用してネイティブライブラリをビルドする外部ビルドツール。ndk-build を使用する予定の場合は、このコンポーネントは不要です。
LLDB: Android Studio がネイティブコードのデバッグに使用するデバッガー。

これらのコンポーネントは、SDK Manager を使用してインストールできます。

開いているプロジェクトで、メニューバーの [Tools] > [Android] > [SDK Manager] を選択します。
[SDK Tools] タブをクリックします。
図 1 のように [LLDB]、[CMake]、[NDK] の横のボックスをオンにします。
図 1. SDK Manager での LLDB、CMake、NDK のインストール
[Apply] をクリックして、ポップアップダイアログの [OK] をクリックします。
インストールが完了したら、[Finish]、[OK] の順にクリックします。

C / C++ のサポートを使用した新しいプロジェクトの作成

ネイティブコードのサポートを利用した新規プロジェクトの作成は、他の Android Studio プロジェクトの作成と同様ですが、いくつか追加の手順があります。

ウィザードの [Configure your new project] セクションで、[Include C++ Support] チェックボックスをオンにします。
[Next] をクリックします。
他のすべてのフィールドと、ウィザードの次のいくつかのセクションを通常どおり入力します。
ウィザードの [Customize C++ Support] セクションで、次のオプションを使用してプロジェクトをカスタマイズできます。
- [C++ Standard]: プルダウンリストを使用して、使用する C++ の標準化を選択します。[Toolchain Default] を選択すると、デフォルトの CMake 設定が使用されます。
- [Exceptions Support]: C++ の例外処理のサポートを有効にする場合は、このボックスをオンにします。有効にすると、Android Studio はモジュールレベルの build.gradle ファイルで -fexceptions フラグを cppFlags に追加し、Gradle がこれを CMake に渡します。
- [Runtime Type Information Support]: RTTI のサポートが必要な場合は、このボックスをオンにします。有効にすると、Android Studio はモジュールレベルの build.gradle ファイルで -frtti フラグを cppFlags に追加し、Gradle がこれを CMake に渡します。
[Finish] をクリックします。

Android Studio で新しいプロジェクトの作成が完了したら、IDE の左側の [Project] を開き、[Android] ビューを選択します。図 2 のように、Android Studio によって cpp グループと External Build Files グループが追加されます。

図 2. Android ビューのネイティブソースのグループと外部ビルドスクリプトのグループ

注: このビューではディスク上の実際のファイル階層は反映されておらず、プロジェクト内を移動しやすいように類似のファイルがグループ化されています。

cpp グループには、プロジェクトに含まれているすべてのネイティブソースファイル、ヘッダー、ビルド済みのライブラリがあります。新しいプロジェクトで、Android Studio はサンプルの C++ ソースファイルである native-lib.cpp を作成し、それをアプリモジュールの src/main/cpp/ ディレクトリに配置します。このサンプルコードには、“Hello from C++” という文字列を返す簡単な C++ 関数、stringFromJNI() が記述されています。プロジェクトに追加のソースファイルを含める方法については、新しいネイティブソースファイルの作成方法に関するセクションをご覧ください。
External Build Files グループには、CMake または ndk-build のビルドスクリプトがあります。build.gradle ファイルで Gradle にアプリのビルド方法を指示するのと同様に、CMake と ndk-build はビルドスクリプトでネイティブライブラリのビルド方法を確認する必要があります。新しいプロジェクトでは、Android Studio は CMake ビルドスクリプトである CMakeLists.txt を作成し、それをモジュールのルートディレクトリに配置します。このビルドスクリプトの内容の詳細については、Cmake ビルドスクリプトの作成方法に関するセクションをご覧ください。

サンプルアプリのビルドと実行

[Run] をクリックすると、Android Studio はアプリをビルドして、Android 端末またはエミュレータでテキスト “Hello from C++” と表示するアプリを起動します。以下では、サンプルアプリをビルドおよび実行する際に発生するイベントの概要を説明します。

Gradle が外部ビルドスクリプトの CMakeLists.txt を呼び出します。
CMake はビルドスクリプトのコマンドに従って C++ ソースファイルの native-lib.cpp をコンパイルして共有オブジェクトライブラリを生成し、libnative-lib.so という名前を付けます。次に、Gradle がこれを APK にパッケージ化します。
実行時にアプリの MainActivity が System.loadLibrary() を使用してネイティブライブラリを読み込みます。これで、ライブラリのネイティブ関数である stringFromJNI() をアプリで使用できるようになりました。
MainActivity.onCreate() が stringFromJNI() を呼び出し、返された “Hello from C++” で TextView を更新します。

注: Instant Run は、ネイティブコードを使用するプロジェクトと互換性がありません。Android Studio は自動的にこの機能を無効にします。

Gradle がライブラリを APK にパッケージ化したことを確認するには、APK Analyzer を使用します。

[Build] > [Analyze APK] を選択します。
app/build/outputs/apk/ ディレクトリの APK を選択し、[OK] をクリックします。
図 3 のように、[APK Analyzer] ウィンドウの lib/<ABI>/ の下に libnative-lib.so が表示されます。
図 3. APK Analyzer を使用してネイティブライブラリを特定する

ヒント: ネイティブコードを使用する他の Android アプリで試す場合は、[File] > [New] > [Import Sample] をクリックし、[Ndk] リストからサンプルプロジェクトを選択します。

既存のプロジェクトへの C / C++ コードの追加

既存のプロジェクトにネイティブコードを追加するには、次の手順を実行します。

新しいネイティブソースファイルを作成し、そのファイルを Android Studio プロジェクトに追加します。
- すでにネイティブコードがある場合、またはビルド済みのネイティブライブラリをインポートする場合は、この手順をスキップしてください。
CMake ビルドスクリプトを作成し、ネイティブソースコードをライブラリにビルドします。このビルドスクリプトは、ビルド済みライブラリやプラットフォームライブラリにインポートまたはリンクする際にも必要です。
- CMakeLists.txt ビルドスクリプトが存在する既存のネイティブライブラリを使用する場合、または ndk-build を使用して Android.mk ビルドスクリプトを含める場合は、この手順をスキップしてください。
CMake または ndk-build スクリプトファイルでパスを指定して、Gradle をネイティブライブラリにリンクします。Gradle はこのビルドスクリプトを使用してソースコードを Android Studio プロジェクトにインポートし、ネイティブライブラリ（SO ファイル）を APK にパッケージ化します。

プロジェクトを設定すると、JNI フレームワークを使用して Java コードからネイティブ関数にアクセスできます。アプリをビルドおよび実行するには、[Run] をクリックするだけです。Gradle は外部ネイティブビルドプロセスを依存関係として追加し、ネイティブライブラリをコンパイル、ビルドして APK にパッケージ化します。

新しいネイティブソースファイルの作成

cpp/ ディレクトリを作成し、新しいネイティブソースファイルをアプリモジュールの main ソースセットに設定するには、次の手順を実行します。

IDE の左側にある [Project] ペインを開き、プルダウンメニューの [Project] ビューを選択します。
[your-module] > [src] に移動し、main ディレクトリを右クリックして [New] > [Directory] を選択します。
ディレクトリの名前（cpp など）を入力し、[OK] をクリックします。
作成したディレクトリを右クリックして、[New] > [C/C++ Source File] を選択します。
ソースファイルの名前（native-lib など）を入力します。
[Type] プルダウンメニューで、ソースファイルのファイル拡張子（.cpp など）を選択します。
- その他のファイル形式（.cxx や .hxx など）を追加することもできます。そのためには、[Edit File Types] をクリックします。ポップアップ表示された [C/C++] ダイアログボックスの [Source Extension] プルダウンメニューと [Header Extension] プルダウンメニューで別のファイル拡張子を選択し、[OK] をクリックします。
ヘッダーファイルを作成する場合は、[Create an associated header] チェックボックスをオンにします。
[OK] をクリックします。

CMake ビルドスクリプトの作成

ネイティブソースの CMake ビルドスクリプトがない場合は、作成して適切な CMake コマンドを含める必要があります。CMake ビルドスクリプトは書式なしテキストで、名前は CMakeLists.txt にする必要があります。このセクションでは、ネイティブライブラリの作成時に使用するソースを CMake に指示するために、ビルドスクリプトに含める必要がある基本的なコマンドについて説明します。

注: プロジェクトで ndk-build を使用する場合、CMake ビルドスクリプトの作成は不要です。Android.mk ファイルへのパスを指定して、Gradle をネイティブライブラリにリンクさせることができます。

CMake ビルドスクリプトとして使用できる書式なしテキストを作成するには、次の手順を実行します。

IDE の左側にある [Project] ペインを開き、プルダウンメニューの [Project] ビューを選択します。
your-module のルートディレクトリを右クリックして、[New] > [File] を選択します。
注: ビルドスクリプトは任意の場所に作成できます。ただし、ビルドスクリプトを設定するときは、ネイティブソースファイルとライブラリのパスにはビルドスクリプトの場所に対する相対パスを指定してください。
ファイル名に "CMakeLists.txt" と入力し、[OK] をクリックします。

これで、CMake コマンドを追加すればビルドスクリプトを設定できるようになりました。ネイティブソースコードからネイティブライブラリを作成するように CMake に指示するには、cmake_minimum_required() コマンドと add_library() コマンドをビルドスクリプトに追加します。

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

add_library() を使用してソースファイルまたはライブラリを CMake ビルドスクリプトに追加すると、プロジェクトを同期した後に Android Studio の [Project] ビューに関連するヘッダーファイルも表示されます。ただし、コンパイル時に CMake がヘッダーファイルを特定できるようにするには、include_directories() コマンドを CMake ビルドスクリプトに追加して、ヘッダーへのパスを指定する必要があります。

add_library(...)

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

CMake で使用するライブラリファイルの命名規則は次のとおりです。

liblibrary-name.so

たとえば、ビルドスクリプトで共有ライブラリの名前を "native-lib" と指定すると、CMake によって libnative-lib.so というファイルが作成されます。ただし、このライブラリを Java コードで読み込む場合は、CMake ビルドスクリプトで指定した名前を使用します。

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

注: CMake ビルドスクリプトでライブラリの名前を変更したりライブラリを削除した場合、Gradle でその変更を適用したり APK から以前のバージョンのライブラリを削除するには、プロジェクトのクリーンを実行する必要があります。プロジェクトのクリーンを実行するには、メニューバーの [Build] > [Clean Project] を選択します。

Android Studio は、[Project] ペインの cpp グループにソースファイルとヘッダーを自動的に追加します。複数の add_library() コマンドを使用して、CMake の追加のライブラリを定義すると、他のソースファイルからビルドできるようになります。

NDK API の追加

Android NDK では、有用なネイティブ API とライブラリのセットを提供しています。プロジェクトの CMakeLists.txt スクリプトファイルに NDK ライブラリを含めることで、これらの API を使用できます。

ビルド済みの NDK ライブラリは Android プラットフォームにすでに存在するため、ビルドしたり APK にパッケージ化したりする必要はありません。NDK ライブラリはすでに CMake の検索パスに含まれているため、ローカルの NDK のインストール場所を指定する必要もありません。必要なのは、使用するライブラリの名前を CMake に指定して、ネイティブライブラリとリンクさせることだけです。

NDK ライブラリを特定して変数にそのパスを保存できるように、CMake ビルドスクリプトに find_library() コマンドを追加します。この変数を使用して、ビルドスクリプトの他の部分で NDK ライブラリを参照します。次のサンプルでは、Android 固有のログサポートライブラリを特定し、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 )

ネイティブライブラリで log ライブラリの関数を呼び出すには、CMake ビルドスクリプトで target_link_libraries() コマンドを使用してライブラリをリンクする必要があります。

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 の一部のライブラリは、ビルドしてネイティブライブラリにリンクする必要があるソースコードとして提供されています。CMake ビルドスクリプトで add_library() コマンドを使用して、そのソースコードをネイティブライブラリにコンパイルできます。ローカルの NDK ライブラリへのパスを指定するには、ANDROID_NDK パス変数を使用します。これは、Android Studio が自動的に定義します。

次のコマンドは、NativeActivity のライフサイクルイベントとタップ入力を管理する android_native_app_glue.c を静的ライブラリにビルドして、native-lib にリンクするよう CMake に指示します。

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

その他のビルド済みライブラリの追加

ビルド済みライブラリを追加する方法は、別のネイティブライブラリを CMake でビルドするよう指定する場合と同様です。ただしライブラリはビルド済みであるため、IMPORTED フラグを使用してプロジェクトへのインポートのみを実行するよう CMake に指示する必要があります。

add_library( imported-lib
             SHARED
             IMPORTED )

次に、以下のように set_target_properties() コマンドを使用して、ライブラリへのパスを指定する必要があります。

一部のライブラリでは、特定の CPU アーキテクチャに対応した個別のパッケージや ABI（Application Binary Interfaces）を提供しており、それらを別のディレクトリにまとめています。このアプローチによって、ライブラリは特定の CPU アーキテクチャを活用でき、さらには必要なバージョンのライブラリのみを使用できます。複数の ABI バージョンのライブラリを CMake ビルドスクリプトに追加する場合、ライブラリのバージョンごとに複数のコマンドを記述する必要はありません。ANDROID_ABI パス変数を使用できます。この変数は、NDK がサポートするデフォルトの ABI のリストを使用するか、手動で Gradle を設定してフィルタリングした ABI のリストを使用します。次に例を示します。

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 )

コンパイル時に CMake でヘッダーファイルを特定するには、include_directories() コマンドを使用して、ヘッダーファイルへのパスを指定する必要があります。

include_directories( imported-lib/include/ )

注: たとえば、imported-lib の依存関係であるビルド済みライブラリを追加するときなど、ビルド時の依存関係ではないビルド済みライブラリをパッケージ化する場合は、次の手順でライブラリをリンクする必要はありません。

独自のネイティブライブラリにビルド済みライブラリをリンクするには、CMake ビルドスクリプトの target_link_libraries() コマンドにそのライブラリを追加します。

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

アプリをビルドすると、Gradle はインポートしたライブラリを自動的に APK にパッケージ化します。APK Analyzer で、Gradle が APK にパッケージ化するライブラリを確認することができます。CMake の詳細については、CMake のドキュメントをご覧ください。

ネイティブライブラリへの Gradle のリンク

Gradle をネイティブライブラリにリンクするには、CMake または ndk-build スクリプトファイルでパスを指定する必要があります。アプリをビルドすると、Gradle は依存関係として CMake または ndk-build を実行し、共有ライブラリを APK にパッケージ化します。また、Gradle はビルドスクリプトを使用して Android Studio プロジェクトに含めるファイルを判別するため、[Project] ウィンドウからそれらのファイルにアクセスできます。ネイティブソースのビルドスクリプトがない場合は、次の手順に進む前に CMake ビルドスクリプトを作成してください。

Gradle をネイティブプロジェクトにリンクすると、Android Studio は [Project] ペインを更新して [cpp] グループにソースファイルとネイティブライブラリを表示し、[External Build Files] グループに外部ビルドスクリプトを表示します。

注: Gradle の設定を変更したときは、必ずツールバーの [Sync Project] をクリックして変更を適用してください。また、Gradle にリンクした後に CMake または ndk-build スクリプトファイルを変更したときは、メニューバーの [Build] > [Refresh Linked C++ Projects] を選択し、Android Studio で変更内容を同期する必要があります。

Android Studio UI の使用

Android Studio UI を使用して Gradle を外部の CMake または ndk-build プロジェクトにリンクさせることができます。

IDE の左側の [Project] を開き、[Android] ビューを選択します。
app モジュールなど、ネイティブライブラリにリンクさせるモジュールを右クリックし、メニューの [Link C++ Project with Gradle] を選択します。図 4 のようなダイアログが表示されます。
プルダウンメニューで、[CMake] または [ndk-build] を選択します。
1. [CMake] を選択した場合、[Project Path] の横のフィールドで、外部 CMake プロジェクトの CMakeLists.txt スクリプトファイルを指定します。
2. [ndk-build] を選択した場合、[Project Path] の横のフィールドで、外部 ndk-build プロジェクトの Android.mk スクリプトファイルを指定します。Android Studio は、Application.mk ファイルが Android.mk ファイルと同じディレクトリに配置されている場合はそのファイルも対象に含めます。
図 4. Android Studio のダイアログを使用して外部 C++ プロジェクトをリンクする
[OK] をクリックします。

Gradle の手動設定

Gradle を手動で設定してネイティブライブラリにリンクさせるには、externalNativeBuild {} ブロックをモジュールレベルの build.gradle ファイルに追加し、cmake {} または 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"
    }
  }
}

注: Gradle を既存の ndk-build プロジェクトにリンクする場合は、cmake {} ではなく ndkBuild {} ブロックを使用して、Android.mk ファイルへの相対パスを指定します。Gradle は、Application.mk ファイルが Android.mk ファイルと同じディレクトリに配置されている場合はそのファイルも対象に含めます。

オプション設定の指定

モジュールレベルの build.gradle ファイルで、defaultConfig {} ブロック内に別の externalNativeBuild {} ブロックを設定することで、CMake または ndk-build のオプションの引数とフラグを指定できます。defaultConfig {} ブロック内のその他のプロパティと同様に、ビルド設定のプロダクトフレーバーごとに、これらのプロパティをオーバーライドできます。

たとえば、CMake または ndk-build プロジェクトで複数のネイティブライブラリを定義する場合、targets プロパティを使用して、指定したプロダクトフレーバーのライブラリのサブセットのみをビルドしてパッケージ化することができます。次のコードのサンプルは、設定できるプロパティをいくつか示しています。

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 {...}
  }
}

プロダクトフレーバーとビルドバリアントの設定の詳細については、ビルドバリアントの設定をご覧ください。arguments プロパティを使用して CMake で設定できる変数のリストについては、CMake 変数の使用の説明をご覧ください。

ABI の指定

デフォルトで、Gradle は ABI および NDK のサポートのためネイティブライブラリを個別の .so ファイルにビルドして、すべて APK にパッケージ化します。Gradle で、ネイティブライブラリの特定の ABI 設定のみをビルドおよびパッケージ化する場合は、以下のようにモジュールレベルの build.gradle ファイルでndk.abiFilters フラグを使用して指定します。

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 {...}
}

ほとんどの場合、上記のように ndk {} ブロックで abiFilters を指定するだけで済みます。この設定によって Gradle はネイティブライブラリの目的のバージョンを対象に、ビルドとパッケージ化の両方を実行します。ただし、APK にパッケージ化するネイティブライブラリとは別に、Gradle のビルドの対象を制御したい場合は、defaultConfig.externalNativeBuild.cmake {} ブロック（または defaultConfig.externalNativeBuild.ndkBuild {} ブロック）内で別の abiFilters フラグを設定します。Gradle はこの ABI 設定をビルドしますが、defaultConfig.ndk{} ブロックで指定されたものだけをパッケージ化します。

APK のサイズをさらに削減するには、すべてのバージョンのネイティブライブラリを使用して 1 つの大きなAPK を作成するのではなく、ABI の APK の分割を設定することを検討してください。この場合、Gradle はサポートする必要がある ABI ごとに個別の APK を作成し、各 ABI に必要なファイルのみをパッケージ化します。上記のコードサンプルのように abiFilters フラグを指定せずに ABI の分割を設定すると、Gradle はサポート対象となるすべての ABI のバージョンのネイティブライブラリをビルドしますが、ABI の分割設定で指定したネイティブライブラリのみをパッケージ化します。不要なバージョンのネイティブライブラリをビルド対象から除外するには、abiFilters フラグと ABI 分割設定の両方で同じ ABI のリストを指定します。