Marble/AndroidCompiling
This page presents how to compile Marble for Android, using the Android SDK, Android NDK and Qt for Android, and how to deploy it to your device. Additional, more detailled instructions can be found in the Community Wiki also.
Prerequisites
You will need the following tools:
- Android SDK - It can be downloaded from here: http://developer.android.com/sdk/index.html
Note
- Android NDK - You can download it from here: https://developer.android.com/ndk/downloads/
- 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 platform version 22.
Note
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 has 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 ENV variables
You have to add the following environment variables:
Android NDK:
export ANDROID_NDK_ROOT=/path_to_your_NDK_install
# sadly extra-cmake-modules uses another variable name than Marble, which also needs to be set:
export ANDROID_NDK=$ANDROID_NDK_ROOT
Android SDK:
export ANDROID_SDK_ROOT=/path_to_your_SDK_install
Ant:
You can get the path to the binary with:
whereis ant
After you know the path (note that this must be an executable file, not a directory):
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_android=/opt/Qt/5.4/android_armv7
Also specify the location of extra-cmake-modules (replace /path/to/extra-cmake-modules below with the folder where you cloned extra-cmake-modules to in the step above):
export ECM=/path/to/extra-cmake-modules
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
Setting up Kirigami
You will also need to get Kirigami, which you can get here: https://github.com/KDE/kirigami After cloning the source code change your working directory to the Kirigami's source directory:
cd path/to/kirigami
Then create a build folder and navigate to it:
mkdir build
cd build
After that we need to configure the project using Cmake:
cmake .. -DCMAKE_TOOLCHAIN_FILE=${ECM}/toolchain/Android.cmake -DCMAKE_PREFIX_PATH=${Qt5_android} -DCMAKE_INSTALL_PREFIX=~/marble/export -DECM_DIR=/usr/local/share/ECM/cmake
Then you install the files using:
make
make install
This should install all the files required by Kirigami in ~/marble/export or whichever other path you passed in the -DCMAKE_INSTALL_PREFIX option to Cmake.
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 has 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 -DECM_ADDITIONAL_FIND_ROOT_PATH=${Qt5_android} -DCMAKE_TOOLCHAIN_FILE="${ECM}/toolchain/Android.cmake" -DCMAKE_BUILD_TYPE=Release -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--storepassoption).
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)