// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only

/*!
    \page android-building-projects-from-commandline.html
    \title Building Qt for Android Projects from Command Line
    \brief How to build user projects using Qt for Android from the command line.
    \previouspage android-building.html
    \nextpage porting-to-android.html

    \section1 Building with CMake

    To build CMake projects with an installed Qt, for example, for Linux use the
    following with \l{Building projects on the command line}{qt-cmake} wrapper:

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

    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.

    \include  src/platforms/android/android-prerequisites.qdoc Android SDK Paths

    \note If you're using \l{Qt for Android - Building from Source}{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 \e {qt-cmake}.

    \section2 Building multi-ABI packages using CMake

    In Qt \QtVer, several ways exist to build a multi-ABI package. By default,
    only the single ABI belonging to the \l{Building projects on the command line}{qt-cmake}
    script is selected. Setting the
    \l{cmake-variable-QT_ANDROID_BUILD_ALL_ABIS}{QT_ANDROID_BUILD_ALL_ABIS}
    variable to \c{TRUE} enables the automatic detection of available Qt for
    Android SDKs. The detection mechanism assumes the use of the default
    directory structure supplied by \QOI:
    \badcode
        ~/Qt/<qt_version>:
            android_arm64_v8a
            android_armv7
            android_x86
            android_x86_64
    \endcode

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

    \badcode \NdkFullVer
    ~/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/\1 \
        -S <source_directory> -B <build_directory>
        -GNinja
    \endcode

    Using the \l{cmake-variable-QT_ANDROID_ABIS}{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 \c{arm64-v8a} and \c{x86} ABIs only:

    \badcode \NdkFullVer
    ~/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/\1 \
        -S <source_directory> -B <build_directory>
        -GNinja
    \endcode

    \note The ABI of the primary SDK that \l{Building projects on the command line}{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 \l{cmake-variable-QT_ANDROID_BUILD_ALL_ABIS}{QT_ANDROID_BUILD_ALL_ABIS}
    has higher priority than \l{cmake-variable-QT_ANDROID_ABIS}{QT_ANDROID_ABIS}.

    Paths to the Qt for Android SDKs that do not match the default directory
    structure can be changed using the corresponding
    \l{cmake-variable-QT_PATH_ANDROID_ABI_<ABI>}{QT_PATH_ANDROID_ABI_<ABI>}
    variables.

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

    \badcode \NdkFullVer
    <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/\1 \
        -S <source_directory> -B <build_directory>
        -GNinja
    \endcode

    \sa {cmake-variable-QT_ANDROID_ABIS}{QT_ANDROID_ABIS},
        {cmake-variable-QT_ANDROID_BUILD_ALL_ABIS}{QT_ANDROID_BUILD_ALL_ABIS},
        {cmake-variable-QT_PATH_ANDROID_ABI_<ABI>}{QT_PATH_ANDROID_ABI_<ABI>}

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

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

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

    \sa {cmake-target-property-QT_ANDROID_ABIS}{QT_ANDROID_ABIS}

    \section2 Creating the Android Bundle

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

    \badcode
    cmake --build . --target apk
    \endcode

    Or to generate the AAB:

    \badcode
    cmake --build . --target aab
    \endcode

    Under the hood, your Qt code is built and copied to the \c {android-build}
    directory, then \l Gradle is used to build the Java code and package the
    application.

    \section2 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 \QC, see
    \l{\QC: Android Deploy Configuration}{Signing Android Packages}. Otherwise,
    check the CMake variables \l QT_ANDROID_SIGN_APK and \l QT_ANDROID_SIGN_AAB.

    \section2 Building an AAR (Android Archive) File

    \note AAR build support was introduced in Qt 6.8.

    An \l{Android: Android Archive (AAR)}{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 \l 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:

    \badcode
    cmake --build . --target aar
    \endcode

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

    \badcode
    cmake --build . --target myapp_make_aar
    \endcode

    \section1 Building with qmake

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

    \note Building multi-ABI packages with \c qmake is not supported in Qt 6.
*/
