Qt on Android Episode 6 - How to use Android Studio to extend and debug the Java part of your Qt application

16.04.2015 BogDan Vatra 12 comments

Update: Here you have also the Chinese version, thanks goes to Foruok.

In the last Qt on Android episode we learned the basics of JNI on Android in a Qt way. In this episode I’d like to focus on tools that will help us to be more productive when we extend our Qt on Android applications.

Using an external IDE to manage Java files.

Sadly, the Java support in Qt Creator is very limited, and in order to be productive we need to use an external IDE to easily extend and debug the Java part of our application. Android provides two powerful IDEs:

• Android Studio
• Eclipse (recently deprecated).

This article will focus only on Android Studio.

But before we talk more about tools, let’s check the Android specific files which are part of your project.

As I told you in the first article, any Qt on Android application has two big parts:

• The native part, which is your C/C++ [Qt] code built into one or more .so files.
• The Android specific part:
  • Android manifest file.
  • Android build system file(s).
  • Two Java classes which are needed to load your application dependencies, the application .so files and start the application.
  • Ministro service .aidl files and other resources, e.g. assets, strings, images, etc.

All the Android specific files are needed to build your android package (as we learned in episode 3). But where are all these files? Why are only a few files copied to your sources when you press “Create templates” button (as shown in the next image)?

Well, Java, Ministro service .aidl files and some resources are kept “hidden” in your Qt SDK. We don’t want to copy them to your source tree for two reasons:

• We might change them from version to version and we might break the compatibility. If they are part of your project it will be impossible to upgrade them and your application will misbehave (e.g. Java files from Qt 5.4 might not be compatible with Qt 5.5).
• We don’t want you to change them, because the code in these files is quite sensible, hard to explain and understand and changing them might break your application behavior. If you should not change them, then all your applications will share the same files, so again there is no point in copying them :).

Before Qt 5.4 it was quite complicated to extend the Java part of your application, mostly because you could not use an external IDE (Eclipse) in a decent way (e.g. with syntax highlighting, code-completion, code-refactoring, etc.). In order to get these goodies you had to manually copy all the Java files from Qt SDK installation folder to your application source folder, but as I said, we don’t want you to do that and the only way to do it was to copy them locally and not add them to your SCM…

But starting with Qt 5.4. the situation changed when I added Gradle support to Qt 5.4 and to Qt Creator 3.3. Gradle is the new recommended android build system which is used by Android Studio. Using Gradle we can keep all these files hidden and still give you all the goodies that you expect from a 21st century IDE. So, if you are planning to extend your Java part of your application, it is highly recommended to Copy the Gradle files to Android directory as shown in the next image:

Besides the AndroidManifest.xml and res/values/libs.xml files, the wizard will copy a few more:

• build.gradle – this is the project file needed by Android Studio.
• gradlew[.bat] – build script wrapper used to build Java part and to create final APK.
• gradle/wrapper/* – build script wrapper files

build.gradle is very important, it allows you to easily add dependencies to your project.

E.g. to add PlayServices to your application you just need to add:

dependencies {
    ...
    compile 'com.google.android.gms:play-services:7.0.0'
}

to build.gradle, check this page for more info on this matter.

Now let’s see how to use Android Studio with Qt:

Android Studio will be used only to:

• open the Gradle project.
• create, edit the java files.
• debug the Java part.

Android Studio will NOT be used to run your Qt application, you still need to use Qt Creator for that job!

Let’s take a look on how to import the Java part of your Qt application and how to debug it.

The import step is very easy: you just need to Open the existing build.gradle project file. Check the following image:

Warning: Qt 5.4.0 users should upgrade their gradle files using Qt 5.4.1 or later (press again Create templates button and overwrite only gradle files). This step is needed because Qt 5.4.0 uses an old Gradle plugin and, after we released it, Google, as usual, broke the compatibility with older Gradle plugins and Android Studio doesn’t import Qt 5.4.0 projects.

The last thing we are going to learn today is how to debug the Java part using Android Studio. You need to take the following steps:

• set the breakpoints
• attach debugger (Run->Attach debugger to Android process)
• start the application using QtCreator
• wait for application to start (you should see it in Attach debugger dialog).
• select the application
• click the OK button

After the last step, your application will be stopped by Android Studio when it hits first breakpoint.The problem comes when we need to start the debugging very early. To do that we are going to use the old fashioned sleep trick Debug.waitForDebugger() function.

This is how our custom onCreate function looks:

@Override
public void onCreate(Bundle savedInstanceState)
{
    Debug.waitForDebugger();
    // ....
    super.onCreate(savedInstanceState);
}

Now the application waits until a debugger attaches, then in resumes the execution.

Now that we have learned the basics of the JNI and how to use external tools to make la vie en rose (or la dolce vita), in the next article we will talk about Qt on Android apps architecture: how to extend the Java part of your application using a real life example to show how to correctly do safe calls from Qt thread to Android UI thread and vice-versa.