- Qt 6.11
- Product information
- Supported Platforms
- Qt for Android
- Building Qt for Android Projects from Command Line
- Qt 6.11.1 Reference Documentation

Building from source ◦ Environment variables

# Building Qt for Android Projects from Command Line

## Building with CMake

To build CMake projects with an installed Qt, for example, for Linux use the following with qt-cmake wrapper:

     ~/Qt/<qt_version>/android_<abi>/bin/qt-cmake \
         -DANDROID_SDK_ROOT=~/Android/Sdk \
         -DANDROID_NDK_ROOT=~/Android/Sdk/ndk/27.2.12479018 \
         -S <source_dir> -B <build_dir> \
         -GNinja

Throughout this page, we use the Android SDK path for Linux for simplicity, however, when issuing these commands, make sure to use your system's relevant path.

The Android SDK is commonly installed by Qt Creator or Android Studio in the following locations:

- Linux: ~/Android/Sdk/
- macOS: ~/Library/Android/sdk/
- Windows: C:\Users\<USER>\AppData\Local\Android\Sdk\

Note: If you're using a self-built Qt, you don't need to provide the SDK and NDK arguments, as the same values used for building Qt are used with qt-cmake.

### Building multi-ABI packages using CMake

In Qt 6.11, several ways exist to build a multi-ABI package. By default, only the single ABI belonging to the qt-cmake script is selected. Setting the QT_ANDROID_BUILD_ALL_ABIS variable to `TRUE` enables the automatic detection of available Qt for Android SDKs. The detection mechanism assumes the use of the default directory structure supplied by Qt Online Installer:

     ~/Qt/<qt_version>:
         android_arm64_v8a
         android_armv7
         android_x86
         android_x86_64

The command below shows the easiest way to build an Android multi-ABI package using the Qt for Android SDKs supplied by Qt Online Installer:

     ~/Qt/<qt_version>/android_<abi>/bin/qt-cmake \
         -DQT_ANDROID_BUILD_ALL_ABIS=TRUE \
         -DANDROID_SDK_ROOT=~/Android/Sdk \
         -DANDROID_NDK_ROOT=~/Android/Sdk/ndk/27.2.12479018 \
         -S <source_directory> -B <build_directory>
         -GNinja

Using the QT_ANDROID_ABIS variable, it's possible to customize the list of ABIs the project is built for. The corresponding Qt for Android development kits needs to follow the directory structure described previously. The following command line configures a project for `arm64-v8a` and `x86` ABIs only:

     ~/Qt/<qt_version>/android_<abi>/bin/qt-cmake \
         -DQT_ANDROID_ABIS="arm64-v8a;x86" \
         -DANDROID_SDK_ROOT=~/Android/Sdk \
         -DANDROID_NDK_ROOT=~/Android/Sdk/ndk/27.2.12479018 \
         -S <source_directory> -B <build_directory>
         -GNinja

Note: The ABI of the primary SDK that qt-cmake script belongs to is added to the list of used ABIs unconditionally. It's not possible to exclude it from the build.

Note: QT_ANDROID_BUILD_ALL_ABIS has higher priority than QT_ANDROID_ABIS.

Paths to the Qt for Android SDKs that do not match the default directory structure can be changed using the corresponding QT_PATH_ANDROID_ABI_<ABI> variables.

The following example enables the automatic detection of available Qt for Android SDKs and specifies custom paths to `armeabi-v7a` and `arm64-v8a` SDKs:

     <qt_for_android_install_path>/bin/qt-cmake \
         -DQT_ANDROID_BUILD_ALL_ABIS=TRUE
         -DQT_PATH_ANDROID_ABI_armeabi-v7a="<Qt/for/armeabi-v7a>" \
         -DQT_PATH_ANDROID_ABI_arm64-v8a="<Qt/for/arm64-v8a>" \
         -DANDROID_SDK_ROOT=~/Android/Sdk \
         -DANDROID_NDK_ROOT=~/Android/Sdk/ndk/27.2.12479018 \
         -S <source_directory> -B <build_directory>
         -GNinja

It's also possible to set the QT_ANDROID_ABIS target property that specifies a list of ABIs that the single executable target is built for. For example:

     qt_add_executable(MyApp main.cpp)
     set_target_properties(MyApp PROPERTIES QT_ANDROID_ABIS "arm64-v8a;x86")

The `MyApp` target will be built for `armeabi-v7a` and `arm64-v8a` only, even if the `QT_ANDROID_BUILD_ALL_ABIS` or `QT_ANDROID_ABIS` variable is set.

### Creating the Android Bundle

Once the project is configured, you may use the following CMake targets to create the application bundle:

     cmake --build . --target apk

Or to generate the AAB:

     cmake --build . --target aab

Under the hood, your Qt code is built and copied to the `android-build` directory, then Gradle is used to build the Java code and package the application.

### Signing the Android Package

If an APK intended for release is built, then it should be signed. For more information on signing the package with Qt Creator, see Signing Android Packages. Otherwise, check the CMake variables QT_ANDROID_SIGN_APK and QT_ANDROID_SIGN_AAB.

### Building an AAR (Android Archive) File

Note: AAR build support was introduced in Qt 6.8.

An Android Archive (AAR) is an Android library format. Unlike an APK or AAB, it cannot be run standalone; instead it is intended to be embedded as a dependency in a native Android application. This is the typical setup when hosting Qt/QML content inside a native Android activity.

To produce an AAR, define your Qt application with qt_add_executable as usual. AAR build targets are created automatically alongside the APK and AAB targets. Build all AAR packages in a project with:

     cmake --build . --target aar

To build only the AAR for a specific target named `myapp`:

     cmake --build . --target myapp_make_aar

## Building with qmake

You can continue to use `qmake` to build user projects as in Qt 5.

Note: Building multi-ABI packages with `qmake` is not supported in Qt 6.

See also QT_ANDROID_ABIS, QT_ANDROID_BUILD_ALL_ABIS, QT_PATH_ANDROID_ABI_<ABI>, and QT_ANDROID_ABIS.

Building from source ◦ Environment variables