This flag tells the app to use as much of the screen as possible
while still keeping system UI visible, and can be supported on Android
by using translucent system UI, similar to iOS.
What this does:
1. It changes the current fullscreen/not-fullscreen logic to
allow three states: fullscreen, fullscreen with translucent
decorations and not-fullscreen.
2. In order for it to work, we have to send the actual
screen geometry and available geometry, at least in the case
where the user needs to know the available geometry to
know the safe area of the window. So we get the real screen
metrics and pass these to the QPA plugin (API level 17, so
we can do that now that the minimum version is 21.)
3. Note that getting the insets and calculating the useable
area does not work for non-fullscreen windows, since Android
is quite inconsistent in this respect. So in this case we
just use the window size and origin of 0,0 for the available
geometry.
4. Since we are touching this code anyway, this patch also tries to use
more consistent wording (calling it "available geometry" everywhere
instead of desktop geometry in some places and just geometry in
others, etc.)
[ChangeLog][Android] Qt::MaximizeUsingFullscreenGeometryHint window
flag is now supported, and will make the window fullscreen, but keep
the system UI on-screen, with a translucent background color.
Fixes: QTBUG-74202
Change-Id: I7a59a6c6fb51ebbdb86e7149e794726e67001279
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
Instead to extract the assets QML file, we create a .rcc bundle file
which is register by android qpa plugin before the it invokes the main
function. Thsi way we avoid extracting the QML files from assets as they
can be accessed directly from resources.
[ChangeLog][Android] Instead of bundling QML resources in assets
and extracting them on first start, Qt now creates an .rcc file
and register it before invoking the main function.
Change-Id: Icb2fda79d82c5af102cc9a0276ff26bb0d1599e8
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
The new version fix QDirIterators and it lists all the files and dirs.
Change-Id: I5a30eedb61ab2397a84365d00f308cda0c194de2
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
In 5bb178c479, the Android platform plugin was moved from
platforms/android to platforms/. The unforeseen consequence of this was that the plugin
loader for plugins/platforms would now find it, whereas before it would be ignored. It
would therefore be detected as the appropriate plugin, but since it was intended to be
loaded as a static plugin, loading it dynamically would fail.
Instead of fixing the static plugin loading, we remove this hack.
Fixes: QTBUG-78440
Change-Id: Idcb6c075fdebaf67644f32a59d7aaf0d1c0bbe20
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
env var values might contain '=' char, so we can't use split.
Change-Id: Iedf3ea46a847acaaf02f51bc80586a519fe7a310
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
As the non prefixed variants are deprecated
Change-Id: I2ba09d71b9cea5203b54297a3f2332e6d44fedcf
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>
When the application is closed via the task manager on Android
then we need to ensure that that the application can close down
any running event loops. So we wake up all the event loops and
then call quit() directly on the application object to start a
graceful termination of the application.
In order to aid the graceful termination of Qt then a check is
added to ensure that it does not try to create a new surface when
the application is suspended. This prevents it from locking
while trying to create a new surface when this is not possible.
Fixes: QTBUG-70772
Change-Id: I6795b3d280e178d7f1207004a1b965a31a0cc9e9
Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>
Reviewed-by: Andy Shaw <andy.shaw@qt.io>
The "file dialog" on Android returns such URLs, which so far required
special-casing this in application code. With this change QFile can
consume those URLs directly.
Change-Id: I489c0db112cf1dc7497e7a90f0e9a79ea8fa5237
Reviewed-by: Nicolas Fella <nicolas.fella@kdab.com>
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
Reviewed-by: Aleix Pol Gonzalez <aleixpol@kde.org>
[ChangeLog][Android] The application and dependent Qt libraries are
now loaded on the same thread as main() is run on, ensuring that global
static initializers, constructor functions, and main() are all run on the
same thread. The same applies during application shutdown, for destructors
of global objects, and destructor functions.
Change-Id: Id4bfece1ed2a0532ed2e8fb7d8ffd6e55d5a10dc
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
We need it
1. to be sure, that thread is already attached to jvm
when we attach debugger to the process
2. to have a human-friendly name for main native thread
Change-Id: I1e572a0f09ec8af24a910835aaa6d302f6f2cb43
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
It is needed to implement Android Binder in Qt.
Change-Id: I8f6f8ef778f97a444a1b16d6f62e211e188b65cc
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
Fixes dubious lock protecting the platform interface handle, and makes
sure that we lock and hold a valid reference to the platform
interface before accessing it. Since the platform interface is exposed
we also need to expose the mutex protecting it.
Change-Id: I1ec1219a75c589bc793676369b11fb403de20102
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
The call does nothing as it's always called from the Android thread,
meaning there are no events, or even eventloop.
Change-Id: I6c03b6ebe74bc52af45bc295b42aa01ad6d51157
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
This is amends commit 9091a058bc to make sure we don't drop
geometry updates that are set before the platform plugins is ready.
Task-number: QTBUG-60963
Change-Id: I4489eb9329bb8983458ad328a43b85382bba3cf6
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
- Make sure we don't process state changes before the platform plugin
is completely created and registered.
- Protect shared data with mutexes.
- Don't update the application state from different threads.
This was causing issues when testing run-time permission checks, when
the application quickly switches state due to permission dialog being
shown. In this case the states would be incorrectly delivered when the
application was made active again.
Change-Id: I3446eab9414ee5437cd788c27d65f808d1314aa5
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
We need to remove and release the surface imediately, otherwise
setSurface might be called after the object is deleted.
Task-number: QTBUG-59818
Change-Id: I3a09e3de1ceecc22d8d7a48e2fc1cfe40cf09f0a
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
Reviewed-by: Mathias Hasselmann <mathias.hasselmann@kdab.com>
Reviewed-by: Christian Stromme <christian.stromme@qt.io>
This patch fixes the followings:
- call "it.value()" only on valid iterators
- destroySurface() doesn't remove the surfaceId from m_surfaces
- the surfaceId is removed from m_surfaces when the QtSurface is really
destroyed
Task-number: QTBUG-59185
Change-Id: Iee37dde16fee16f19906812c55c1f0b0279b033c
Reviewed-by: Mathias Hasselmann <mathias.hasselmann@kdab.com>
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
Also bump minimum required Qt version for Android: Ministro updates.
Conflicts:
src/android/java/src/org/qtproject/qt5/android/bindings/QtActivityLoader.java
src/android/java/src/org/qtproject/qt5/android/bindings/QtLoader.java
src/plugins/platforms/android/androidjnimain.cpp
Change-Id: I966f249bebf92da37bfdeb995ad21b027eb03301
Offscreen windows should not be handle by the platform plugin.
Task-number: QTBUG-50973
Change-Id: I719a24b9bbcaad460d78fdc4095e86d615357cd2
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>
If the main thread is blocked updateApplicationState will hang. It
happens when we're using functions like runOnAndroidThreadSync or
requestPermissionsSync.
Change-Id: Ic1135c5630b48cf1076ef5cbc133933fce439bfb
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>
QAndroidEventDispatcherStopper is stopped when the application is in background
and the user uses the task manager to kill the task. If the application has
services the task manager doesn't kills it, but instead it tries to gently
terminate the activity. The problem is that the activity is still backgrounded
(meaning that the Qt event loop is freezed), therefore terminateQt will hang.
Task-number: QTBUG-54012
Change-Id: I6e333cbcaf41e9e298eeb8b2b0bc3adcf446783f
Reviewed-by: Christian Stromme <christian.stromme@qt.io>
Conflicts:
src/corelib/io/qtemporarydir.cpp
One side encapsulated a repeated piece of #if-ery in a local define;
the other added to the #if-ery. Made its addition to the other's.
src/corelib/kernel/qeventdispatcher_unix_p.h
One side moved some members into a struct; this collided with a #undef
check that neither side now has. Discarded the #undef part.
src/gui/opengl/qopengltexturehelper_p.h
5.7 deleted a bunch of methods; not clear why merge got confused.
src/tools/moc/moc.cpp
One added a name to the copyright header; another changed its URL.
Change-Id: I9e9032b819f030d67f1915445acf2793e98713fa
Since Android 5.0 Google introduce a nasty bug[1] which calls
JNI_OnLoad more than once.
Basically every time when a library is loaded JNI_OnLoad is
called if found, but it calls *again* JNI_OnLoad of its .so
dependencies! So, JNI_OnLoad of libQt5Core.so gets called may times,
this is not a problem as long as it's called from Qt's java delegate
class loader. The problem is that the application .so file *must* be
called from default class loader to allow the user to find his custom
Activity/Service stuff.
[1] Workaround https://code.google.com/p/android/issues/detail?id=215069
Change-Id: Ia71209658ef56056b560018597608acf7cb0f9ea
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@qt.io>
... by replacing them with C++11 range-for loops.
This is the simplest of the patch series: Q_FOREACH took a
copy, so we do, too. Except we don't, since we're just
catching the return value that comes out of the function
(RVO). We can't feed the rvalues into range-for, because
they are non-const and would thus detach.
Change-Id: Ia086b1f3d072dd56c3545780490be03346df2880
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
... (or trivially marked const) local variables,
parameters, or data members with trivial loop bodies,
by replacing them with C++11 range-for loops.
Change-Id: I25e9e2148abd7676305ebd18754dc647f217e48b
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
It's urgent to fix the issue that on Android, it became impossible
to interact with any widget or MouseArea which handles only mouse
events but not tablet events, using the stylus, because stylus events
are sent only as QTabletEvents. Before 5.6 (change
01d78ba86a) they were sent as
touch events, and mouse events were synthesized from those. Whereas
on other platforms, every QTabletEvent is followed by a synthesized
QMouseEvent.
This fix proceeds in the direction that event synthesis should be done
in cross-platform code so that platform plugins don't have to repeat it,
following the same pattern as for touch->mouse synthesis. Just as
in that case, the application can disable it, and the platform plugin
can also report that it's unnecessary for Qt to do the synthesis
because the platform already does.
So QTBUG-51618 is fixed, but QTBUG-47007 requires us to remove the
tablet->mouse synthesis from all platform plugins, because the plugin
does not know whether the tablet event was accepted or not, so it does
not have enough information to decide whether to synthesize a mouse
event. Synthesis has been unconditional until now, which contradicts
what the documentation says: the mouse event should be sent only if
the tablet event is NOT accepted. We can now gradually make this
promise come true.
[ChangeLog][QtCore][Tablet support] A synthetic mouse event will
no longer be sent after every QTabletEvent, only after those which are
not accepted (as documented).
Task-number: QTBUG-47007
Task-number: QTBUG-51618
Change-Id: I99404e0c2b39bbca4377be6fd48e0c6b20338466
Reviewed-by: Laszlo Agocs <laszlo.agocs@theqtcompany.com>
The printf-style version of QDebug expands to a lot less code than the
std::ostream-style version. Of course, you pay in type safety (but
compilers warn about it these days), you cannot stream complex Qt
types and streaming QStrings is awkward, but in many cases you
actually improve on readability.
But the main reason is that something that's not supposed to be
executed under normal operation has no business bloating executable
code size.
This is not an attempt at converting all qWarnings() to printf-style,
only the low-hanging fruit.
In this first part, replace
qWarning() << ""
with
qWarning("...").
Had to fix broken qImDebug() definition. Instead of defining it as
a nullary macro in the QT_NO_DEBUG case and as a variadic macro in
the other, define it in both cases, as is customary, as a non-function
macro so that overload selection works without requiring variadic
macro support of the compiler.
Saves e.g. ~250b in text size in QtPrintSupport on optimized GCC 5.3
AMD64 builds.
Change-Id: Ie30fe2f7942115d5dbf99fff1750ae0d477c379f
Reviewed-by: Kai Koehne <kai.koehne@theqtcompany.com>
This changeset enables running a QCoreApplication from within an Android
Service. The Android Application running can now have a QtActivity or a
QtService, but having both in the same process is not supported.
This patch was based on Cory Slep's patch
[ChangeLog][Android] Qt can now be used to easily create Android Services.
Task-number: QTBUG-37221
Change-Id: I0fd693daaa85b991940ffe9cc41c483022677199
Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@theqtcompany.com>
Hide the native view in constructor and in destructor.
Task-number: QTBUG-40159
Change-Id: I200b28af9ac2928c38299b71395a97e39f1bbe6d
Reviewed-by: Christian Stromme <christian.stromme@theqtcompany.com>
From Qt 5.7 -> LGPL v2.1 isn't an option anymore, see
http://blog.qt.io/blog/2016/01/13/new-agreement-with-the-kde-free-qt-foundation/
Updated license headers to use new LGPL header instead of LGPL21 one
(in those files which will be under LGPL v3)
Change-Id: I046ec3e47b1876cd7b4b0353a576b352e3a946d9
Reviewed-by: Lars Knoll <lars.knoll@theqtcompany.com>
Delay the exit call until Java part finishes the execution.
We must be sure all the threads are stopped (hanged), when we
call exit, otherwise java thread will try to use static vars
that are freed by the qt thread.
We also need to call exit from Qt thread, otherwise Qt will complain
about it.
Change-Id: Ia1e7a4d7d56c39d38313f040aab618ec5a68dfb6
Reviewed-by: Christian Stromme <christian.stromme@theqtcompany.com>
If, after checking a condition, we issue a qFatal()
or a qCritical(), by definition that check is
unlikely to be true.
Tell the compiler so it can move the error handling
code out of the normal code path to increase the
effective icache size.
Moved conditional code around where possible so that
we could always use Q_UNLIKELY, instead of having to
revert to Q_LIKELY here and there.
In some cases, simplified the expressions newly wrapped
in Q_UNLIKELY as a drive-by.
Change-Id: I67537d62b04bc6977d69254690c5ebbdf98bfd6d
Reviewed-by: Konstantin Ritt <ritt.ks@gmail.com>
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
For qDebug() and qWarning(), this is just an optimization.
For qCritical(), which can be fatal, the old code was just wrong.
Change-Id: I6d8ab1d7531d766cd41b49569dc0fd4420ecab8b
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com>
Reviewed-by: Olivier Goffart (Woboq GmbH) <ogoffart@woboq.com>
Opt-in by setting android.app.auto_screen_scale_factor
to true in AndroidManifest.xml. This will enable
devicePixelRatio scaling in QtGui using a scale
factor provided by Android DisplayMetrics.
Note that the Android style is not currently supported:
it already accounts for different display densities
which results in incorrect visual sizes when enabling
devicePixelRatio scaling.
Implementation: Bring DisplayMetrics::density through
to setDisplayMetrics in androidjnimain.cpp, similar
to what is done for "scaledDensity". Override
QPlatformScreen::pixelDensity(), which forwards the
scale factor to QtGui.
[The difference between "density" and "scaledDensity"
is that the former is a physical display density factor
which corresponds closely to devicePixelRatio in Qt,
while the latter also includes the Android global font
scale factor.]
Scale the global font pixel size in qandroidplatformtheme.cpp
to keep the visual font size constant.
Based on an initial patch from Daiwei Li <daiweili@suitabletech.com>
Task-number: QTBUG-46615
Change-Id: Ia51f99bf6dda485a57413949246c7b32cb47e8dd
Reviewed-by: BogDan Vatra <bogdan@kdab.com>
Android doesn't automatically trigger global objects destruction, so we need to do it ourselves.
Test case:
struct TestGlobal {
~TestGlobal() { qDebug() << " ~TestGlobal";}
} global;
int main() {
return 0;
}
Change-Id: I32507c1cffebafc9841e9707a8f6711dcbd36281
Reviewed-by: Christian Stromme <christian.stromme@theqtcompany.com>
Eskil Abrahamsen Blomfeldt
BogDan Vatra
BogDan Vatra
Lars Knoll
Qt Forward Merge Bot
Volker Krause
Liang Qi
Vyacheslav Koscheev
Christian Strømme
Anton Kudryavtsev
Edward Welbourne
Marc Mutz
Shawn Rutledge
Liang Qi
Jani Heikkinen
Morten Johan Sørvig
Friedemann Kleint
Frederik Gladhorn