Skip to content

Most visited

Recently visited

navigation

プロジェクトへの 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 とビルドツールのダウンロード

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

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

  1. 開いているプロジェクトで、メニューバーの [Tools] > [Android] > [SDK Manager] を選択します。
  2. [SDK Tools] タブをクリックします。
  3. 図 1 のように [LLDB]、[CMake]、[NDK] の横のボックスをオンにします。

    図 1. SDK Manager での LLDB、CMake、NDK のインストール

  4. [Apply] をクリックして、ポップアップ ダイアログの [OK] をクリックします。
  5. インストールが完了したら、[Finish]、[OK] の順にクリックします。

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

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

  1. ウィザードの [Configure your new project] セクションで、[Include C++ Support] チェックボックスをオンにします。
  2. [Next] をクリックします。
  3. 他のすべてのフィールドと、ウィザードの次のいくつかのセクションを通常どおり入力します。
  4. ウィザードの [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 に渡します。
  5. [Finish] をクリックします。

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

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

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

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

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

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

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

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

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

  1. [Build] > [Analyze APK] を選択します。
  2. app/build/outputs/apk/ ディレクトリの APK を選択し、[OK] をクリックします。
  3. 図 3 のように、[APK Analyzer] ウィンドウの lib/<ABI>/ の下に libnative-lib.so が表示されます。

    図 3. APK Analyzer を使用してネイティブ ライブラリを特定する

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

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

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

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

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

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

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

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

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

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

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

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

  1. IDE の左側にある [Project] ペインを開き、プルダウン メニューの [Project] ビューを選択します。
  2. your-module のルート ディレクトリを右クリックして、[New] > [File] を選択します。

    注: ビルド スクリプトは任意の場所に作成できます。ただし、ビルド スクリプトを設定するときは、ネイティブ ソース ファイルとライブラリのパスにはビルド スクリプトの場所に対する相対パスを指定してください。

  3. ファイル名に "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 をネイティブ ライブラリにリンクするには、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 を使用して Gradle を外部の CMake または ndk-build プロジェクトにリンクさせることができます。

  1. IDE の左側の [Project] を開き、[Android] ビューを選択します。
  2. app モジュールなど、ネイティブ ライブラリにリンクさせるモジュールを右クリックし、メニューの [Link C++ Project with Gradle] を選択します。図 4 のようなダイアログが表示されます。
  3. プルダウン メニューで、[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++ プロジェクトをリンクする

  4. [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 のリストを指定します。

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!

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 one-minute survey?
Help us improve Android tools and documentation.