bionic (7) ecm-toolchains.7.gz

NAME

       ecm-toolchains - ECM Toolchains Reference

INTRODUCTION

       Extra  CMake Modules (ECM) provides some toolchain modules. Unlike normal modules, these are not included
       directly in projects, but specified with the CMAKE_TOOLCHAIN_FILE cache variable on the commandline.

ALL MODULES

   AndroidToolchain
       Enable easy compilation of cmake projects on Android.

       By using this android toolchain, the projects will be set up to compile the specified  project  targeting
       an  Android  platform, depending on its input.  Furthermore, if desired, an APK can be directly generated
       by using the androiddeployqt tool.

       NOTE:
          This module requires CMake 3.1.

       Since 1.7.0.

   Usage
       To use this file, you need to set the CMAKE_TOOLCHAIN_FILE to  point  to  AndroidToolchain.cmake  on  the
       command line:

          cmake -DCMAKE_TOOLCHAIN_FILE=/usr/share/ECM/toolchain/AndroidToolchain.cmake

       You  will  also  need  to  provide  the  locations  of  the  Android NDK and SDK. This can be done on the
       commandline or with environment variables; in either case the variable names are:

       ANDROID_NDK
              The NDK root path.

       ANDROID_SDK_ROOT
              The SDK root path.

       Additional options are specified as cache variables (eg: on the command line):

       ANDROID_ARCHITECTURE
              The architecture to compile for. Default: arm.

       ANDROID_TOOLCHAIN
              The toolchain to use. See the toolchains directory of the NDK.  Default: arm-linux-androideabi.

       ANDROID_COMPILER_PREFIX
              The      prefix      for      the      gcc      and      g++      executables.       See       the
              toolchains/$ANDROID_TOOLCHAIN/prebuilt/*/bin/*-gcc in the NDK.  Default: arm-linux-androideabi.

       ANDROID_ABI
              The  ABI  to  use.  See  the sources/cxx-stl/gnu-libstdc++/*/libs directories in the NDK. Default:
              armeabi-v7a.

       ANDROID_GCC_VERSION
              The GCC version to use. Default: 4.9.

       ANDROID_API_LEVEL
              The API level to require. Default: 14.

       ANDROID_SDK_BUILD_TOOLS_REVISION
              The build tools version to use. Default: 21.1.1.

       For integrating other libraries which are not part of the Android toolchain, like Qt5, and installed to a
       separate  prefix  on  the  host  system,  the  install  prefixes  of  those  libraries would be passed as
       alternative roots as list via ECM_ADDITIONAL_FIND_ROOT_PATH. Since 5.30.0.

       For   example,   for   integrating   a   Qt5   for    Android    with    armv7    target    present    at
       /opt/android/Qt5/5.7/android_armv7 and some other libraries installed to the prefix /opt/android/foo, you
       would use:

          cmake \
            -DCMAKE_TOOLCHAIN_FILE=/usr/share/ECM/toolchain/AndroidToolchain.cmake \
            -DECM_ADDITIONAL_FIND_ROOT_PATH="/opt/android/Qt5/5.7/android_armv7;/opt/android/foo"

       If your project uses find_package() to locate  build  tools  on  the  host  system,  make  sure  to  pass
       CMAKE_FIND_ROOT_PATH_BOTH  or  NO_CMAKE_FIND_ROOT_PATH  as  argument  in the call. See the find_package()
       documentation for more details.

   Deploying Qt Applications
       After building the application, you will need to generate an APK that  can  be  deployed  to  an  Android
       device. This module integrates androiddeployqt support to help with this for Qt-based projects. To enable
       this, set the QTANDROID_EXPORTED_TARGET variable to the target you wish to export as an APK, as  well  as
       ANDROID_APK_DIR  to a directory containing some basic information. This will create a create-apk-<target>
       target that will generate the APK file.   See  the  Qt  on  Android  deployment  documentation  for  more
       information.

       For example, you could do:

          cmake \
            -DCMAKE_TOOLCHAIN_FILE=/usr/share/ECM/toolchain/AndroidToolchain.cmake \
            -DQTANDROID_EXPORTED_TARGET=myapp \
            -DANDROID_APK_DIR=myapp-apk
          make
          make create-apk-myapp

       The APK would then be found in myapp_build_apk/bin in the build directory.

       The  create-apk-myapp  target  will  be  able  to  take  an  ARGS  parameter  with  further arguments for
       androiddeployqt. For example, one can use:

          make create-apk-myapp ARGS="--install"

       To install the apk to test. To generate a signed apk, one can do it with the following syntax:

          make create-apk-myapp ARGS="--sign ~/my.keystore alias_name"

       See Android documentation on how to create a keystore to use

SEE ALSO

       ecm(7)

COPYRIGHT

       KDE Developers