Marble/AndroidCompiling: Difference between revisions

    From KDE TechBase
    mNo edit summary
    (Page moved to community wiki)
     
    (3 intermediate revisions by 3 users not shown)
    Line 1: Line 1:
    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  [https://community.kde.org/Android Community Wiki] also.
    {{ Moved To Community }}
     
    === 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 the 32 bit versions of libgcc, zlib and libc to be able to run them.}}
    # 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:
    #<syntaxhighlight lang="bash">/path_where_you_installed_the_sdk/tools/android sdk</syntaxhighlight>
     
    Make sure to install the platform version 22.
     
    === Getting the Marble Source Code  ===
    # Start a terminal
    #We download the source code by cloning the developer repository with the following command:
    <syntaxhighlight lang="bash">git clone git://anongit.kde.org/marble ~/marble/sources</syntaxhighlight>
     
    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:
    <syntaxhighlight lang="bash">cd ~/marble/sources</syntaxhighlight>
    Then the toolchain have to be cloned from its git repository:
    <syntaxhighlight lang="bash">git clone git://anongit.kde.org/extra-cmake-modules</syntaxhighlight>
    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:
    <syntaxhighlight lang="bash">export ANDROID_NDK=/path_to_your_NDK_install</syntaxhighlight>
    Android SDK:
    <syntaxhighlight lang="bash">export ANDROID_SDK=/path_to_your_SDK_install</syntaxhighlight>
    Ant:
     
    You can get the path to the binary with:
    <syntaxhighlight lang="bash">whereis ant</syntaxhighlight>
    After you know the path:
    <syntaxhighlight lang="bash">export ANT=/path_to_ant</syntaxhighlight>
    Java:
     
    Path to your Java installation, for example:
    <syntaxhighlight lang="bash">export JAVA_HOME=/usr/lib/jvm/java-7-openjdk</syntaxhighlight>
    Qt:
     
    For example, if you installed Qt in /opt/Qt you have to set the following on a 64 bit system:
    <syntaxhighlight lang="bash">export Qt5_android=/opt/Qt/5.4/android_armv7</syntaxhighlight>
    Also specify the location of extra-cmake-modules:
    <syntaxhighlight lang="bash">export ECM=/path/to/extra-cmake-modules</syntaxhighlight>
     
    And you also need to specify your target platform (at least 22, but after the build the package will be backward compatible):
    <syntaxhighlight lang="bash">export ANDROID_PLATFORM=android-22</syntaxhighlight>
     
    === Compiling Marble ===
    First of all, create a build directory in marble's source dir:
    <syntaxhighlight lang="bash">mkdir ~/marble/build</syntaxhighlight>
    Than change your working directory to it:
    <syntaxhighlight lang="bash">cd ~/marble/build</syntaxhighlight>
    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:
    <syntaxhighlight lang="bash">cmake -DCMAKE_PREFIX_PATH=${Qt5_android} -DCMAKE_TOOLCHAIN_FILE="${ECM}/toolchain/Android.cmake" -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../export ../sources/
    </syntaxhighlight>
    This will generate the needed Makefile for compiling. Start the build process with the following command:
    <syntaxhighlight lang="bash">make install/strip</syntaxhighlight>
     
    === Generating the Android Application Package (APK) ===
    After the build successfully finished, the files have been installed to {{Path|1=../export}} or whichever other path you passed in the <code>-DCMAKE_INSTALL_PREFIX</code> option to cmake. Now run the Python script {{Path|1=src/apps/marble-maps/create-apk.py}} to generate the Android package:
    <syntaxhighlight lang="bash">~/marble/sources/src/apps/marble-maps/create-apk.py --target MarbleMaps.apk ../export
    </syntaxhighlight>
     
    The script provides a number of parameters. Typical usage is as follows:
    * Testing directly on a connected device: <code>create-apk.py --reinstall /path/to/marble/export</code>
    * Creating an .apk locally: <code>create-apk.py --target MarbleMaps.apk /path/to/marble/export</code>
    * Creating a signed package for release: <code>create-apk.py --target MarbleMaps.apk --keystore /path/to/Marble.keystore /path/to/marble/export</code>. You'll be prompted for the required passwords (unless you pass them using the <code>--storepass</code> option).
     
    All parameters of {{Path|1=create-apk.py}} can be shown with its <code>--help</code> switch:
    {{Output|1=<nowiki>
    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)
    </nowiki>}}

    Latest revision as of 04:51, 26 October 2016

    This page is now on the community wiki.