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
|
// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
/*!
\page android-platform-notes.html
\title Android Platform Notes
\ingroup androidplatform
\previouspage Supporting Google Emoji Font Policy
\nextpage Android GNU C++ Run-time Licensing
\brief Information particular to building and running Qt applications on Android.
This page contains information particular to building and running Qt
applications on Android. See \l{android_support}{Supported Android Versions}
for what Android versions and API levels are supported.
\section1 Android Development in Qt Creator
The easiest way to develop with Qt for Android is to use
\l{Qt Creator: Connecting Android Devices}{Qt Creator}. When you use an
\b{Android Kit} with a Qt Creator project, it builds your code in addition
to some Android specific files that are required for enabling Qt on Android
and generating your application bundle. Qt Creator adds these files in a
subdirectory of your project called \b android. For more information, see
\l{Android Package Templates}.
\section1 Application Package
On Android, apps are distributed to devices as \b{APK} packages. For
distributing apps in Google Play, a different format called \b{AAB} is used
instead. For more information, see \l{Publishing to Google Play}.
Use Qt Creator to build both \b{APK} and \b{AAB} package formats, or build
them manually. For more information, see \l{Deploying an Application on Android}.
\section1 Plugins and Imports Special Considerations
If an application uses plugins that depend on other modules, these modules
must be listed in the application's dependencies. For more information, see
\l{Dependencies Detection}.
\section1 Qt Gui Dependency
Given that Android apps typically include GUI elements, the Qt for Android
plugin is built mainly to provide a GUI, so it implements the various QPA
abstractions. As a result, deploying a Qt for Android app is expected to
involve a dependency on \l [QtGui]{Qt GUI}. Moreover, it's worth noting that Qt
Creator only supports Gradle builds and deployments, meaning that command
line or shell executions are not supported out of the box.
\section1 Text Special Considerations
Because of a bug in some OpenGL drivers, the mechanism used by Qt to cache
text glyphs does not work as expected on all Android devices, causing text
to appear scrambled. To remedy this, a workaround is in place, but it can
increase memory consumption and can also affect text rendering performance.
The workaround is now used by default on all devices.
You can disable the workaround by setting the
\c QT_ANDROID_DISABLE_GLYPH_CACHE_WORKAROUND environment variable to \e 1 or
\e true. However, you should do so only after verifying that text appears
correctly on all targeted devices.
\section1 OpenGL Special Considerations
Modern devices often support OpenGL ES 3.0 or 3.1 in addition to 2.0. To get
a suitable OpenGL context, set the requested version via
\l{QSurfaceFormat::setVersion()}.
\note Using OpenGL ES 3.x features will result in the application breaking on older
devices that only support 2.0.
\section1 Assets File System
Qt for Android provides a special, virtual file system which is based on
the \l{Android: Accessing original files}{Android Assets mechanism}.
Files that are put under the directory (\l{ANDROID_PACKAGE_SOURCE_DIR}/assets/)
are packaged as part of your application package. These can be accessed in
Qt by prefixing the paths with \c{assets:/}. For more information, see
\l{Porting to Android}{Porting Qt applications to Android}.
\section1 Android Supported Architectures
Qt for Android currently has binaries for \e{armv7a}, \e{arm64-v8a}, \e{x86}
and \e{x86-64}.
If you want to support several different ABIs in your application in Google
Play, the recommendation is to build an Application App Bundle (AAB)
containing binaries for each of the ABIs. Based on your AAB, Google Play
generates optimized Application Packages (APK) for each device requesting a
download.
For more information, see \l{Building the Android Application}.
\section1 Known Issues
Due to a bug on some devices, when you turn off predictive text with
\c{ImhNoPredictiveText}, this property is ignored and predictive text is
still enabled. To work around this, set the
\c{QT_ANDROID_ENABLE_WORKAROUND_TO_DISABLE_PREDICTIVE_TEXT} environment
variable to \c 1. However, one side effect is that this environment variable
can cause a problem with other keyboards such as Gboard. If you use a
language like Japanese, with Gboard, only a QWERTY keyboard is displayed.
This environment variable is queried each time the keyboard is displayed,
so it's possible to toggle the workaround on and off, as necessary.
\section1 Limitations
Some of the Qt modules might have features that are not supported on Android
or have limitations. For more information, see \l{QTBUG-72086}.
\section1 Frequently Asked Questions
\list
\li Should I use \c QtActivity or \l{Android: Activity}{Android Activity}
to create a custom Activity?
\c QtActivity extends \c Activity and implements the logic needed to load
the Qt libraries or handle events and native calls between Android and Qt.
In general, extending \c QtActivity is needed if you are using any native
calls. Otherwise, extending \c Activity should work.
\li Should I use \c QtService or \l{Android: Service}{Android Service}?
The same reasoning as \c QtActivity applies here. Unless you are using
features that require the Qt libraries to be loaded, like native calls.
\li Can \l{Android: Fragments}{Android Fragments} be used with Qt? What is
the equivalent for Fragment in Qt?
Android Fragments cannot be used with Qt. However, Qt offers it's own modular
components and views with QML. You can combine multiple components in one
QML view. For more information, see \l{Qt QML}.
\endlist
*/
|
