Android support experiments

[LeonMatthesKDAB]

So I've recently been able to get the Markdown-combine app ( #371 ) compiling and running for Android!

There were a few issues along the way, but none caused by CXX-Qt itself actually.
I think for now we shouldn't state this constitutes "official Android support", but if you're determined, you should be able to get this to work in a day or two worths of work.

TLDR: I've attached an example config here: CMakeLists.txt

Setting up Qt Creator for Android cross-compilation

Bascially, I followed this guide.

I did have to use Qt Installer to install Qt again with full Android support, as the one from my package manager (Fedora w/ dnf) didn't include everything necessary.
Also, I used the Android SDK & NDK provided by Qt Creator, as it wouldn't accept the one I already had installed.

Do not require QQmlImportScanner

For some reason requiring CMake to find QQmlImportScanner didn't work, so I just removed it.
Honestly don't know why it was needed in the first place.
Maybe someone can shine a light on that.

Figure out the right CMake flags for corrosion to fix Rust compilation errors

For some reason the way we usually set up QMake wasn't working for my case.
I believe this has something to do with the two versions of Qt that are now installed on my system.

I.e. this code:

get_target_property(QMAKE Qt::qmake IMPORTED_LOCATION)

corrosion_set_env_vars(${CRATE}
    "CXXQT_EXPORT_DIR=${CXXQT_EXPORT_DIR}"
    "QMAKE=${QMAKE}"
)

Instead, I had to use the environment variables provided by Qt Creator (see the Projects tab after opening the project in Qt Creator):

corrosion_set_env_vars(${CRATE}
    "CXXQT_EXPORT_DIR=${CXXQT_EXPORT_DIR}"
    "QMAKE=${QT_QMAKE_EXECUTABLE}"
    "AR_aarch64_linux_android=${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ar"
    "CXXFLAGS_aarch64-linux-android=--std=c++17"
)

I also had to point the cxx_build crate to the right AR executable, see: https://stackoverflow.com/questions/69945638/do-rust-and-cargo-1-56-simply-not-work-with-android-ndk-r23-without-binutils
And something required C++17, so I enabled that as well.

Use Corrosion 0.4-beta2 to fix linker errors

Corrosion hard-codes a few linker flags for rustc to link to Rusts stdlib.
However, these flags are simply not correct for Android compilation.
In Corrosion 0.4, this has actually already been fixed.
So just update corrosion to the right version (still in beta at the time of writing).

if(NOT Corrosion_FOUND)
    include(FetchContent)
    FetchContent_Declare(
        Corrosion
        GIT_REPOSITORY https://github.com/corrosion-rs/corrosion.git
        GIT_TAG v0.4-beta2
    )

Use qt_add_executable, instead of add_executable

Otherwise, Qt doesn't know what to package as the "application".

qt_add_executable(${APP_NAME} WIN32 MACOSX_BUNDLE
    src/main.cpp
    src/qml/qml.qrc
)

We should consider making this the default for all Cxx-Qt examples!

Profit

The app now builds and runs on my Galaxy S9+ under Android 10 🥳

Rust's std::fs module has a few issues accessing files that are outside of my app directory, but that's really got to do with Androids restrictive permissions, and is not an issue with the build itself.
Simply using println! also doesn't show up in the debug output of the Android app.
I suspect I should be using something like android_logger should fix this though.

Overall, this journey wasn't easy, but was also less impossible than I thought.

[ahayzen-kdab]

Was the import scanner required for qt_import_qml_plugins which is for statically linked Qt builds (eg macOS) ? Or maybe it was something else...

[LeonMatthesKDAB]

Hm, maybe.

I'm still using this command, and it's still working 🤔

Also, the Qt docs mention, that this isn't necessary if using qt_add_executable, so maybe we should just change our projects over to qt_add_executable? Then we could remove that call.

If target was created using qt_add_executable(), projects would not normally need to call qt_import_qml_plugins() directly. When Qt is built statically, the command is called automatically as part of target finalization if target links to the Qml library. By default, this finalization occurs at the end of the same directory scope in which the target was created. If the target was created using the standard CMake add_executable() command instead, the project needs to call qt_import_qml_plugins() itself.

[ahayzen-kdab]

qt_add_executable is Qt 6 only IIRC :-)

[LeonMatthesKDAB]

Fair point...

[NoelJacob]

How did you get around the android permissions?

[LeonMatthesKDAB]

Do you mean the file-system permissions with Rusts std::fs?

I didn't really try any further TBH. I don't know much about the Rust best practices for Android.
But I assume there have to be libraries that can take care of stuff like this.

This issue has nothing to do with CXX-Qt though, and is just a problem of the MarkdownCombiner app, as that apps backend uses std::fs to access the files.
So my exploration here was successful in the sense that using CXX-Qt is still possible on Android, but you still have to live with Android as the operating system and use the appropriate libraries for OS interfacing.