Marble/AndroidCompiling

Under Construction
This is a new page, currently under construction!

This page present how to compile Marble for Android, using the Android SDK, Android NDK and Qt for Android, and how to deploy it to your device.

Prerequisites

You will need the following tools:

Android SDK - It can be downloaded from here: http://developer.android.com/sdk/index.html

Note

The SDK contains binary 32 bit tools that are required to create the Marble package. If you're running a 64 bit system, install support for running 32 bit applications.

Android NDK - You can download it from here: https://developer.android.com/ndk/index.html
Qt with support for Android devices. Download the best one for you: https://www.qt.io/download-open-source/#section-2 and install it, but be sure that the Android support is installed too (for example you have to check in to install it in the online installer).
CMake - Usually you should be able to install it from your repository.
Java Development Kit - For example you can install openjdk, usually it should be in your repository.
Ant - This should be available from the repositories too.

Some Android platforms will be needed, you should install them with the Android SDK's package manager. It can be started with:

/path_where_you_installed_the_sdk/tools/android sdk

Make sure to install the following platforms:

10
11
16
18
19
22

Getting the Marble Source Code

Start a terminal
We download the source code by cloning the developer repository with the following command:

git clone git://anongit.kde.org/marble ~/marble/sources

After you run the git clone command (shown above), all the Marble source files and considerable resource files will be found in a folder called marble in your home directory.

Getting the CMake toolchain for Android

First, you should change your working directory to Marble's source directory:

cd ~/marble/sources

Then the toolchain have to be cloned from its git repository:

git clone git://anongit.kde.org/extra-cmake-modules

We will use this to compile Marble and pack it as an apk.

Setting your PATH

You have to add the following paths to your PATH:

Android NDK:

export ANDROID_NDK=/path_to_your_NDK_install

Android SDK:

export ANDROID_SDK=/path_to_your_SDK_install

Ant:

You can get the path to the binary with:

whereis ant

After you know the path:

export ANT=/path_to_ant

Java:

Path to your Java installation, for example:

export JAVA_HOME=/usr/lib/jvm/java-7-openjdk

Qt:

For example, if you installed Qt in /opt/Qt you have to set the following on a 64 bit system:

export Qt5_host=/opt/Qt/5.4/gcc_64

And for the Android version:

export Qt5_android=/opt/Qt/5.4/android_armv7

Also specify the location of qt-android-cmake:

export Qt5_android_cmake=/path/to/qt-android-cmake

And you also need to specify your target platform (at least 22, but after the build the package will be backward compatible):

export ANDROID_PLATFORM=android-22

Compiling Marble

First of all, create a build directory in marble's source dir:

mkdir ~/marble/build

Than change your working directory to it:

cd ~/marble/build

Then the project have to be configured with Cmake. First we will build the libraries and the plugins, after that we will build the app.

First, run the following command:

cmake -DCMAKE_TOOLCHAIN_FILE="${Qt5_android_cmake}/toolchain/android.toolchain.cmake" -DCMAKE_BUILD_TYPE=Release -DQT_NO_WEBKIT=TRUE -DQT_NO_PRINTER=TRUE  -DQT_NO_DBUS=TRUE -DCMAKE_INSTALL_PREFIX=../export ../sources/

This will generate the needed Makefile for compiling. Start the build process with the following command:

make install/strip

Generating the Android Application Package (APK)

After the build successfully finished, the files have been installed to ../export or whichever other path you passed in the -DCMAKE_INSTALL_PREFIX option to cmake. Now run the Python script src/apps/marble-maps/create-apk.py to generate the Android package:

~/marble/sources/src/apps/marble-maps/create-apk.py --target MarbleMaps.apk ../export

The script provides a number of parameters. Typical usage is as follows:

Testing directly on a connected device: create-apk.py --reinstall /path/to/marble/export
Creating an .apk locally: create-apk.py --target MarbleMaps.apk /path/to/marble/export
Creating a signed package for release: create-apk.py --target MarbleMaps.apk --keystore /path/to/Marble.keystore /path/to/marble/export. You'll be prompted for the required passwords (unless you pass them using the --storepass option).

All parameters of create-apk.py can be shown with its --help switch:

usage: create-apk.py [-h] [--target TARGET] [--keystore KEYSTORE]
                     [--storepass STOREPASS] [--release] [--install]
                     [--reinstall]
                     directory

Create an Android application package (APK) for Marble Maps

positional arguments:
  directory             The directory where the Android build is installed to

optional arguments:
  -h, --help            show this help message and exit
  --target TARGET       Target filename (or directory) for the .apk package
  --keystore KEYSTORE   Keystore file for signing the package
  --storepass STOREPASS
                        Keystore password for signing the package
  --release             Build a release package
  --install             Install the package to a connected device
                        (uninstalling it before, if needed)
  --reinstall           Install the package to a connected device (keeping
                        previous data intact, if any)