How Qt for Android Works

This thread is implemented and started by the Qt app first before, for example, loading the libraries. This thread is called qtMainLoopThread. All the following operations are executed under this thread:

• Qt library loading.

• Operations done inside https://.

• Starting the native application.

• The execution of main().

Similar to Android apps, operations that affect the UI are expected to run in the UI thread. Qt does that under the hood for any internal calls that are expected to run in the UI. Also, Qt offers an API QAndroidApplication::runOnAndroidMainThread to run operations under this thread from C++ code. Using this API, Qt manages when the calls are directly posted to the thread if the app is active, or queued if the app is paused or in the background.

When extending https://, you can set a specific Android theme using https://. However, that call must precede the call to the parent class's https:// for it to take effect since Qt sets the theme by default. For example, you can use:

@Override
protected void onCreate(Bundle bundle)
{
    setTheme(android.R.style.Theme_DeviceDefault_DayNight);
    super.onCreate(bundle);
}

By default, for Android 10 and later, Qt sets the theme https://, and https:// for earlier versions.

To append an extra application parameter, that is an argument that's passed to the application's (main()) function from Java/Kotlin, you can do the following after extending https://:

@Override
protected void onCreate(Bundle bundle)
{
    appendApplicationParameters("--flag value");
    super.onCreate(bundle);
}

This is similar to using the CMake variable https:// directly. Parameters passed using either method accept spaces or tabs as separators, and the final list of parameters passed to the application are parsed using https://.

The class loader object is set early on by the QtLoader before loading Qt libraries or initializing the delegates. This is because the class loader is used by https:// to find Java classes and is required to do any JNI call with https://.

Before loading the libraries, Qt has to ensure environment variables are passed as metadata in the Android manifest to set. This step enables the initialization of some modules based on the configuration flags set as manifest meta-data. Some of this meta-data is also propagated to the application parameters list that is passed to the application when it's started.

Various Qt modules might need to do some initialization work from the Java side that requires having the context of the https:// or https://. Those modules then implement a static method that takes an https://, Service or Context as a parameter:

void setActivity(Activity activity)
{
    m_activity = activity;
    // Other logic
}

Then, the QtLoader invokes these methods with the parent context of the loader just before loading the native shared libraries.

When the Activity is created, QtActivityBase initializes the Qt environment. This includes loading the Qt libraries, setting up the class loader that https:// uses, parsing the app’s metadata, and preparing the Qt application for execution. It ensures that all necessary initialization specific to the Activity is handled.

Calls Android's Activity.OnStart().

When the Activity moves to the foreground, QtActivityBase resumes the Qt application. It ensures that paused processes or operations continue and the application is again ready for user interaction. It will re-register the display manager listener stopped by onPause().

If another activity partially obscures the Activity, QtActivityBase pauses the Qt application. It will save the application state or release resources that are not needed while the application is not in the foreground.

When the Activity is no longer visible, QtActivityBase stops the Qt application, which involves more extensive state saving and resource release, preparing the application for potential destruction.

If the Activity is finished or being destroyed by the system, QtActivityBase cleans up all resources associated with the Qt application. It ensures a proper shutdown and that all necessary cleanup operations are performed.

This integration allows developers to focus on building their Qt application without worrying about the intricacies of the Android life-cycle, as QtActivityBase manages these complexities under the hood.