1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// 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.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
\badcode
cmake --build . --target 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.
*/
|
