git.cworth.org Git - apitrace/blob - cmake/toolchain/android.toolchain.cmake

   1 # ------------------------------------------------------------------------------
   2 #  Android CMake toolchain file, for use with the Android NDK r5-r7
   3 #  Requires cmake 2.6.3 or newer (2.8.3 or newer is recommended).
   4 #  See home page: http://code.google.com/p/android-cmake/
   5 #
   6 #  The file is mantained by the OpenCV project. And also can be found at
   7 #  http://code.opencv.org/svn/opencv/trunk/opencv/android/android.toolchain.cmake
   8 #
   9 #  Usage Linux:
  10 #   $ export ANDROID_NDK=/absolute/path/to/the/android-ndk
  11 #   $ mkdir build && cd build
  12 #   $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake ..
  13 #   $ make -j8
  14 #
  15 #  Usage Linux (using standalone toolchain):
  16 #   $ export ANDROID_STANDALONE_TOOLCHAIN=/absolute/path/to/android-toolchain
  17 #   $ mkdir build && cd build
  18 #   $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake ..
  19 #   $ make -j8
  20 #
  21 #  Usage Windows:
  22 #     You need native port of make to build your project.
  23 #     Android NDK r7 already has make.exe on board.
  24 #     For older NDK you have to install it separately.
  25 #     For example, this one: http://gnuwin32.sourceforge.net/packages/make.htm
  26 #
  27 #   $ SET ANDROID_NDK=C:\absolute\path\to\the\android-ndk
  28 #   $ mkdir build && cd build
  29 #   $ cmake.exe -G"MinGW Makefiles"
  30 #       -DCMAKE_TOOLCHAIN_FILE=path\to\the\android.toolchain.cmake
  31 #       -DCMAKE_MAKE_PROGRAM="%ANDROID_NDK%\prebuilt\windows\bin\make.exe" ..
  32 #   $ "%ANDROID_NDK%\prebuilt\windows\bin\make.exe"
  33 #
  34 #
  35 #  Options (can be set as cmake parameters: -D<option_name>=<value>):
  36 #    ANDROID_NDK=/opt/android-ndk - path to the NDK root.
  37 #      Can be set as environment variable. Can be set only at first cmake run.
  38 #
  39 #    ANDROID_STANDALONE_TOOLCHAIN=/opt/android-toolchain - path to the
  40 #      standalone toolchain. This option is not used if full NDK is found
  41 #      (ignored if ANDROID_NDK is set).
  42 #      Can be set as environment variable. Can be set only at first cmake run.
  43 #
  44 #    ANDROID_ABI=armeabi-v7a -  specifies the target Application Binary
  45 #      Interface (ABI). This option nearly matches to the APP_ABI variable
  46 #      used by ndk-build tool from Android NDK.
  47 #      Possible values are:
  48 #        "armeabi" - matches to the NDK ABI with the same name.
  49 #           See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation.
  50 #        "armeabi-v7a" - matches to the NDK ABI with the same name.
  51 #           See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation.
  52 #        "armeabi-v7a with NEON" - same as armeabi-v7a, but
  53 #            sets NEON as floating-point unit
  54 #        "armeabi-v7a with VFPV3" - same as armeabi-v7a, but
  55 #            sets VFPV3 as floating-point unit (has 32 registers instead of 16).
  56 #        "armeabi-v6 with VFP" - tuned for ARMv6 processors having VFP.
  57 #        "x86" - matches to the NDK ABI with the same name.
  58 #           See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation.
  59 #
  60 #    ANDROID_NATIVE_API_LEVEL=android-8 - level of Android API compile for.
  61 #      Option is read-only when standalone toolchain used.
  62 #
  63 #    ANDROID_FORCE_ARM_BUILD=OFF - set true to generate 32-bit ARM instructions
  64 #      instead of Thumb-1. Is not available for "x86" (inapplicable) and
  65 #      "armeabi-v6 with VFP" (forced) ABIs.
  66 #
  67 #    ANDROID_NO_UNDEFINED=ON - set true to show all undefined symbols as linker
  68 #      errors even if they are not used.
  69 #
  70 #    ANDROID_SO_UNDEFINED=OFF - set true to allow undefined symbols in shared
  71 #      libraries. Automatically turned on for NDK r5x and r6x due to GLESv2
  72 #      problems.
  73 #
  74 #    LIBRARY_OUTPUT_PATH_ROOT=${CMAKE_SOURCE_DIR} - where to output binary
  75 #      files. See additional details below.
  76 #
  77 #    ANDROID_SET_OBSOLETE_VARIABLES=ON - it set, then toolchain defines some
  78 #      obsolete variables which were set by previous versions of this file for
  79 #      backward compatibility.
  80 #
  81 #
  82 #  What?:
  83 #    android-cmake toolchain searches for NDK/toolchain in the following order:
  84 #      ANDROID_NDK - cmake parameter
  85 #      ANDROID_NDK - environment variable
  86 #      ANDROID_STANDALONE_TOOLCHAIN - cmake parameter
  87 #      ANDROID_STANDALONE_TOOLCHAIN - environment variable
  88 #      ANDROID_NDK - default locations
  89 #      ANDROID_STANDALONE_TOOLCHAIN - default locations
  90 #
  91 #    Make sure to do the following in your scripts:
  92 #      SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}" )
  93 #      SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${my_cxx_flags}" )
  94 #      The flags will be prepopulated with critical flags, so don't loose them.
  95 #      Also be aware that toolchain also sets configuration-specific compiler
  96 #      flags and linker flags.
  97 #
  98 #    ANDROID and BUILD_ANDROID will be set to true, you may test any of these
  99 #    variables to make necessary Android-specific configuration changes.
 100 #
 101 #    Also ARMEABI or ARMEABI_V7A or X86 will be set true, mutually exclusive.
 102 #    NEON option will be set true if VFP is set to NEON.
 103 #
 104 #    LIBRARY_OUTPUT_PATH_ROOT should be set in cache to determine where Android
 105 #    libraries will be installed.
 106 #    Default is ${CMAKE_SOURCE_DIR}, and the android libs will always be
 107 #    under the ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}
 108 #    (depending on the target ABI). This is convenient for Android packaging.
 109 #
 110 #
 111 #  Change Log:
 112 #   - initial version December 2010 Ethan Rublee ethan.ruble@gmail.com
 113 #   - modified April 2011 Andrey Kamaev andrey.kamaev@itseez.com
 114 #     [+] added possibility to build with NDK (without standalone toolchain)
 115 #     [+] support cross-compilation on Windows (native, no cygwin support)
 116 #     [+] added compiler option to force "char" type to be signed
 117 #     [+] added toolchain option to compile to 32-bit ARM instructions
 118 #     [+] added toolchain option to disable SWIG search
 119 #     [+] added platform "armeabi-v7a with VFPV3"
 120 #     [~] ARM_TARGETS renamed to ARM_TARGET
 121 #     [+] EXECUTABLE_OUTPUT_PATH is set by toolchain (required on Windows)
 122 #     [~] Fixed bug with ANDROID_API_LEVEL variable
 123 #     [~] turn off SWIG search if it is not found first time
 124 #   - modified May 2011 Andrey Kamaev andrey.kamaev@itseez.com
 125 #     [~] ANDROID_LEVEL is renamed to ANDROID_API_LEVEL
 126 #     [+] ANDROID_API_LEVEL is detected by toolchain if not specified
 127 #     [~] added guard to prevent changing of output directories on the first
 128 #         cmake pass
 129 #     [~] toolchain exits with error if ARM_TARGET is not recognized
 130 #   - modified June 2011 Andrey Kamaev andrey.kamaev@itseez.com
 131 #     [~] default NDK path is updated for version r5c
 132 #     [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET
 133 #     [~] toolchain install directory is added to linker paths
 134 #     [-] removed SWIG-related stuff from toolchain
 135 #     [+] added macro find_host_package, find_host_program to search
 136 #         packages/programs on the host system
 137 #     [~] fixed path to STL library
 138 #   - modified July 2011 Andrey Kamaev andrey.kamaev@itseez.com
 139 #     [~] fixed options caching
 140 #     [~] search for all supported NDK versions
 141 #     [~] allowed spaces in NDK path
 142 #   - modified September 2011 Andrey Kamaev andrey.kamaev@itseez.com
 143 #     [~] updated for NDK r6b
 144 #   - modified November 2011 Andrey Kamaev andrey.kamaev@itseez.com
 145 #     [*] rewritten for NDK r7
 146 #     [+] x86 toolchain support (experimental)
 147 #     [+] added "armeabi-v6 with VFP" ABI for ARMv6 processors.
 148 #     [~] improved compiler and linker flags management
 149 #     [+] support different build flags for Release and Debug configurations
 150 #     [~] by default compiler flags the same as used by ndk-build (but only
 151 #         where reasonable)
 152 #     [~] ANDROID_NDK_TOOLCHAIN_ROOT is splitted to ANDROID_STANDALONE_TOOLCHAIN
 153 #         and ANDROID_TOOLCHAIN_ROOT
 154 #     [~] ARM_TARGET is renamed to ANDROID_ABI
 155 #     [~] ARMEABI_NDK_NAME is renamed to ANDROID_NDK_ABI_NAME
 156 #     [~] ANDROID_API_LEVEL is renamed to ANDROID_NATIVE_API_LEVEL
 157 #   - modified January 2012 Andrey Kamaev andrey.kamaev@itseez.com
 158 #     [+] added stlport_static support (experimental)
 159 #     [+] added special check for cygwin
 160 #     [+] filtered out hidden files (starting with .) while globbing inside NDK
 161 #     [+] automatically applied GLESv2 linkage fix for NDK revisions 5-6
 162 #     [+] added ANDROID_GET_ABI_RAWNAME to get NDK ABI names by CMake flags
 163 #   - modified February 2012 Andrey Kamaev andrey.kamaev@itseez.com
 164 #     [+] updated for NDK r7b
 165 #     [~] fixed cmake try_compile() command
 166 #     [~] Fix for missing install_name_tool on OS X
 167 # ------------------------------------------------------------------------------
 168
 169 cmake_minimum_required( VERSION 2.6.3 )
 170
 171 if( PROJECT_NAME STREQUAL "CMAKE_TRY_COMPILE" )
 172  include( "${CMAKE_CURRENT_SOURCE_DIR}/../android.toolchain.config.cmake" OPTIONAL )
 173 endif()
 174
 175 # this one is important
 176 set( CMAKE_SYSTEM_NAME Linux )
 177 #this one not so much
 178 set( CMAKE_SYSTEM_VERSION 1 )
 179
 180 set( ANDROID_SUPPORTED_NDK_VERSIONS -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )
 181 if( CMAKE_HOST_WIN32 )
 182  file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATHS )
 183  set( ANDROID_NDK_SEARCH_PATHS "${ANDROID_NDK_SEARCH_PATHS}/android-ndk" "$ENV{SystemDrive}/NVPACK/android-ndk" )
 184 else()
 185  set( ANDROID_NDK_SEARCH_PATHS /opt/android-ndk "$ENV{HOME}/NVPACK/android-ndk" )
 186 endif()
 187 set( ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH /opt/android-toolchain )
 188 set( ANDROID_SUPPORTED_ABIS_arm "armeabi-v7a;armeabi;armeabi-v7a with NEON;armeabi-v7a with VFPV3;armeabi-v6 with VFP" )
 189 set( ANDROID_SUPPORTED_ABIS_x86 "x86" )
 190
 191 set( ANDROID_DEFAULT_NDK_API_LEVEL 8 )
 192 set( ANDROID_DEFAULT_NDK_API_LEVEL_x86 9 )
 193
 194
 195 macro( __LIST_FILTER listvar regex )
 196  if( ${listvar} )
 197   foreach( __val ${${listvar}} )
 198    if( __val MATCHES "${regex}" )
 199     list( REMOVE_ITEM ${listvar} "${__val}" )
 200    endif()
 201   endforeach()
 202  endif()
 203 endmacro()
 204
 205 macro( __INIT_VARIABLE var_name )
 206  set( __test_path 0 )
 207  foreach( __var ${ARGN} )
 208   if( __var STREQUAL "PATH" )
 209    set( __test_path 1 )
 210    break()
 211   endif()
 212  endforeach()
 213  if( __test_path AND NOT EXISTS "${${var_name}}" )
 214   unset( ${var_name} CACHE )
 215  endif()
 216  if( "${${var_name}}" STREQUAL "" )
 217   set( __values 0 )
 218   foreach( __var ${ARGN} )
 219    if( __var STREQUAL "VALUES" )
 220     set( __values 1 )
 221    elseif( NOT __var STREQUAL "PATH" )
 222     set( __obsolete 0 )
 223     if( __var MATCHES "^OBSOLETE_.*$" )
 224      string( REPLACE "OBSOLETE_" "" __var "${__var}" )
 225      set( __obsolete 1 )
 226     endif()
 227     if( __var MATCHES "^ENV_.*$" )
 228      string( REPLACE "ENV_" "" __var "${__var}" )
 229      set( __value "$ENV{${__var}}" )
 230     elseif( DEFINED ${__var} )
 231      set( __value "${${__var}}" )
 232     else()
 233      if( __values )
 234       set( __value "${__var}" )
 235      else()
 236       set( __value "" )
 237      endif()
 238     endif()
 239     if( NOT "${__value}" STREQUAL "" )
 240      if( __test_path )
 241       if( EXISTS "${__value}" )
 242        set( ${var_name} "${__value}" )
 243        if( __obsolete )
 244         message( WARNING "Using value of obsolete variable ${__var} as initial value for ${var_name}. Please note, that ${__var} can be completely removed in future versions of the toolchain." )
 245        endif()
 246        break()
 247       endif()
 248      else()
 249       set( ${var_name} "${__value}" )
 250        if( __obsolete )
 251         message( WARNING "Using value of obsolete variable ${__var} as initial value for ${var_name}. Please note, that ${__var} can be completely removed in future versions of the toolchain." )
 252        endif()
 253       break()
 254      endif()
 255     endif()
 256    endif()
 257   endforeach()
 258   unset( __value )
 259   unset( __values )
 260   unset( __obsolete )
 261  endif()
 262  unset( __test_path )
 263 endmacro()
 264
 265 macro( __DETECT_NATIVE_API_LEVEL _var _path )
 266  SET( __ndkApiLevelRegex "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*$" )
 267  FILE( STRINGS ${_path} __apiFileContent REGEX "${__ndkApiLevelRegex}" )
 268  if( NOT __apiFileContent )
 269   message( SEND_ERROR "Could not get Android native API level. Probably you have specified invalid level value, or your copy of NDK/toolchain is broken." )
 270  endif()
 271  string( REGEX REPLACE "${__ndkApiLevelRegex}" "\\1" ${_var} "${__apiFileContent}" )
 272  unset( __apiFileContent )
 273  unset( __ndkApiLevelRegex )
 274 endmacro()
 275
 276 macro( __DETECT_TOOLCHAIN_MACHINE_NAME _var _root )
 277  file( GLOB __gccExePath "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" )
 278  __LIST_FILTER( __gccExePath "bin/[.].*-gcc${TOOL_OS_SUFFIX}$" )
 279  list( LENGTH __gccExePath __gccExePathsCount )
 280  if( NOT __gccExePathsCount EQUAL 1 )
 281   message( WARNING "Could not uniquely determine machine name for compiler from ${_root}." )
 282   set( ${_var} "" )
 283  else()
 284   get_filename_component( __gccExeName "${__gccExePath}" NAME_WE )
 285   string( REPLACE "-gcc" "" ${_var} "${__gccExeName}" )
 286  endif()
 287  unset( __gccExePath )
 288  unset( __gccExePathsCount )
 289  unset( __gccExeName )
 290 endmacro()
 291
 292 macro( __COPY_IF_DIFFERENT _source _destination )
 293  execute_process( COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${_source}" "${_destination}" RESULT_VARIABLE __fileCopyProcess )
 294  if( NOT __fileCopyProcess EQUAL 0 OR NOT EXISTS "${_destination}")
 295   message( SEND_ERROR "Failed copying of ${_source} to the ${_destination}" )
 296  endif()
 297  unset( __fileCopyProcess )
 298 endmacro()
 299
 300
 301 #stl version: by default gnustl_static will be used
 302 set( ANDROID_USE_STLPORT FALSE CACHE BOOL "Experimental: use stlport_static instead of gnustl_static")
 303 mark_as_advanced( ANDROID_USE_STLPORT )
 304
 305 #fight against cygwin
 306 set( ANDROID_FORBID_SYGWIN TRUE CACHE BOOL "Prevent cmake from working under cygwin and using cygwin tools")
 307 mark_as_advanced( ANDROID_FORBID_SYGWIN )
 308 if( ANDROID_FORBID_SYGWIN )
 309  if( CYGWIN )
 310   message( FATAL_ERROR "Android NDK and android-cmake toolchain are not welcome Cygwin. It is unlikely that this cmake toolchain will work under cygwin. But if you want to try then you can set cmake variable ANDROID_FORBID_SYGWIN to FALSE and rerun cmake." )
 311  endif()
 312
 313  if( CMAKE_HOST_WIN32 )
 314   #remove cygwin from PATH
 315   set( __new_path "$ENV{PATH}")
 316   __LIST_FILTER( __new_path "cygwin" )
 317   set(ENV{PATH} "${__new_path}")
 318   unset(__new_path)
 319  endif()
 320 endif()
 321
 322 #detect current host platform
 323 set( TOOL_OS_SUFFIX "" )
 324 if( CMAKE_HOST_APPLE )
 325  set( ANDROID_NDK_HOST_SYSTEM_NAME "darwin-x86" )
 326 elseif( CMAKE_HOST_WIN32 )
 327  set( ANDROID_NDK_HOST_SYSTEM_NAME "windows" )
 328  set( TOOL_OS_SUFFIX ".exe" )
 329 elseif( CMAKE_HOST_UNIX )
 330  set( ANDROID_NDK_HOST_SYSTEM_NAME "linux-x86" )
 331 else()
 332  message( FATAL_ERROR "Cross-compilation on your platform is not supported by this cmake toolchain" )
 333 endif()
 334
 335 #see if we have path to Android NDK
 336 __INIT_VARIABLE( ANDROID_NDK PATH ENV_ANDROID_NDK )
 337 if( NOT ANDROID_NDK )
 338  #see if we have path to Android standalone toolchain
 339  __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ENV_ANDROID_STANDALONE_TOOLCHAIN OBSOLETE_ANDROID_NDK_TOOLCHAIN_ROOT OBSOLETE_ENV_ANDROID_NDK_TOOLCHAIN_ROOT )
 340
 341  if( NOT ANDROID_STANDALONE_TOOLCHAIN )
 342   #try to find Android NDK in one of the the default locations
 343   set( __ndkSearchPaths )
 344   foreach( __ndkSearchPath ${ANDROID_NDK_SEARCH_PATHS} )
 345    foreach( suffix ${ANDROID_SUPPORTED_NDK_VERSIONS} )
 346     list( APPEND __ndkSearchPaths "${__ndkSearchPath}${suffix}" )
 347    endforeach()
 348   endforeach()
 349   __INIT_VARIABLE( ANDROID_NDK PATH VALUES ${__ndkSearchPaths} )
 350   unset( __ndkSearchPaths )
 351
 352   if( ANDROID_NDK )
 353    message( STATUS "Using default path for Android NDK: ${ANDROID_NDK}" )
 354    message( STATUS "  If you prefer to use a different location, please define a cmake or environment variable: ANDROID_NDK" )
 355   else()
 356    #try to find Android standalone toolchain in one of the the default locations
 357    __INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH )
 358
 359    if( ANDROID_STANDALONE_TOOLCHAIN )
 360     message( STATUS "Using default path for standalone toolchain ${ANDROID_STANDALONE_TOOLCHAIN}" )
 361     message( STATUS "  If you prefer to use a different location, please define the variable: ANDROID_STANDALONE_TOOLCHAIN" )
 362    endif( ANDROID_STANDALONE_TOOLCHAIN )
 363   endif( ANDROID_NDK )
 364  endif( NOT ANDROID_STANDALONE_TOOLCHAIN )
 365 endif( NOT ANDROID_NDK )
 366
 367 #remember found paths
 368 if( ANDROID_NDK )
 369  get_filename_component( ANDROID_NDK "${ANDROID_NDK}" ABSOLUTE )
 370  #try to detect change
 371  if( CMAKE_AR )
 372   string( LENGTH "${ANDROID_NDK}" __length )
 373   string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidNdkPreviousPath )
 374   if( NOT __androidNdkPreviousPath STREQUAL ANDROID_NDK )
 375    message( FATAL_ERROR "It is not possible to change path to the NDK on subsequent run." )
 376   endif()
 377   unset( __androidNdkPreviousPath )
 378   unset( __length )
 379  endif()
 380  set( ANDROID_NDK "${ANDROID_NDK}" CACHE INTERNAL "Path of the Android NDK" )
 381  set( BUILD_WITH_ANDROID_NDK True )
 382 elseif( ANDROID_STANDALONE_TOOLCHAIN )
 383  get_filename_component( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" ABSOLUTE )
 384  #try to detect change
 385  if( CMAKE_AR )
 386   string( LENGTH "${ANDROID_STANDALONE_TOOLCHAIN}" __length )
 387   string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidStandaloneToolchainPreviousPath )
 388   if( NOT __androidStandaloneToolchainPreviousPath STREQUAL ANDROID_STANDALONE_TOOLCHAIN )
 389    message( FATAL_ERROR "It is not possible to change path to the Android standalone toolchain on subsequent run." )
 390   endif()
 391   unset( __androidStandaloneToolchainPreviousPath )
 392   unset( __length )
 393  endif()
 394  set( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" CACHE INTERNAL "Path of the Android standalone toolchain" )
 395  set( BUILD_WITH_STANDALONE_TOOLCHAIN True )
 396 else()
 397  list(GET ANDROID_NDK_SEARCH_PATHS 0 ANDROID_NDK_SEARCH_PATH)
 398  message( FATAL_ERROR "Could not find neither Android NDK nor Android standalone toolcahin.
 399     You should either set an environment variable:
 400       export ANDROID_NDK=~/my-android-ndk
 401     or
 402       export ANDROID_STANDALONE_TOOLCHAIN=~/my-android-toolchain
 403     or put the toolchain or NDK in the default path:
 404       sudo ln -s ~/my-android-ndk ${ANDROID_NDK_SEARCH_PATH}
 405       sudo ln -s ~/my-android-toolchain ${ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH}" )
 406 endif()
 407
 408 #get all the details about standalone toolchain
 409 if( BUILD_WITH_STANDALONE_TOOLCHAIN )
 410  __DETECT_NATIVE_API_LEVEL( ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h" )
 411  set( __availableToolchains "standalone" )
 412  __DETECT_TOOLCHAIN_MACHINE_NAME( __availableToolchainMachines "${ANDROID_STANDALONE_TOOLCHAIN}" )
 413  if( NOT __availableToolchainMachines )
 414   message( FATAL_ERROR "Could not determine machine name of your toolchain. Probably your Android standalone toolchain is broken." )
 415  endif()
 416  if( __availableToolchainMachines MATCHES i686 )
 417   set( __availableToolchainArchs "x86" )
 418  elseif( __availableToolchainMachines MATCHES arm )
 419   set( __availableToolchainArchs "arm" )
 420  endif()
 421  if( ANDROID_COMPILER_VERSION )
 422   #do not run gcc every time because it is relatevely expencive
 423   set( __availableToolchainCompilerVersions "${ANDROID_COMPILER_VERSION}" )
 424  else()
 425   execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" --version
 426    OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE )
 427   string( REGEX MATCH "[0-9]+.[0-9]+.[0-9]+" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" )
 428  endif()
 429 endif()
 430
 431 #get all the details about NDK
 432 if( BUILD_WITH_ANDROID_NDK )
 433  file( GLOB ANDROID_SUPPORTED_NATIVE_API_LEVELS RELATIVE "${ANDROID_NDK}/platforms" "${ANDROID_NDK}/platforms/android-*" )
 434  string( REPLACE "android-" "" ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" )
 435  file( GLOB __availableToolchains RELATIVE "${ANDROID_NDK}/toolchains" "${ANDROID_NDK}/toolchains/*" )
 436  __LIST_FILTER( __availableToolchains "^[.]" )
 437  set( __availableToolchainMachines "" )
 438  set( __availableToolchainArchs "" )
 439  set( __availableToolchainCompilerVersions "" )
 440  foreach( __toolchain ${__availableToolchains} )
 441   __DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK}/toolchains/${__toolchain}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
 442   if( __machine )
 443    string( REGEX MATCH "[0-9]+.[0-9]+.[0-9]+$" __version "${__toolchain}" )
 444    string( REGEX MATCH "^[^-]+" __arch "${__toolchain}" )
 445    list( APPEND __availableToolchainMachines ${__machine} )
 446    list( APPEND __availableToolchainArchs ${__arch} )
 447    list( APPEND __availableToolchainCompilerVersions ${__version} )
 448   else()
 449    list( REMOVE_ITEM __availableToolchains "${__toolchain}" )
 450   endif()
 451  endforeach()
 452  if( NOT __availableToolchains )
 453   message( FATAL_ERROR "Could not any working toolchain in the NDK. Probably your Android NDK is broken." )
 454  endif()
 455 endif()
 456
 457 #build list of available ABIs
 458 if( NOT ANDROID_SUPPORTED_ABIS )
 459  set( ANDROID_SUPPORTED_ABIS "" )
 460  set( __uniqToolchainArchNames ${__availableToolchainArchs} )
 461  list( REMOVE_DUPLICATES __uniqToolchainArchNames )
 462  list( SORT __uniqToolchainArchNames )
 463  foreach( __arch ${__uniqToolchainArchNames} )
 464   list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} )
 465  endforeach()
 466  unset( __uniqToolchainArchNames )
 467  if( NOT ANDROID_SUPPORTED_ABIS )
 468   message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." )
 469  endif()
 470 endif()
 471
 472 #choose target ABI
 473 __INIT_VARIABLE( ANDROID_ABI OBSOLETE_ARM_TARGET OBSOLETE_ARM_TARGETS VALUES ${ANDROID_SUPPORTED_ABIS} )
 474 #verify that target ABI is supported
 475 list( FIND ANDROID_SUPPORTED_ABIS "${ANDROID_ABI}" __androidAbiIdx )
 476 if( __androidAbiIdx EQUAL -1 )
 477  string( REPLACE ";" "\", \"", PRINTABLE_ANDROID_SUPPORTED_ABIS  "${ANDROID_SUPPORTED_ABIS}" )
 478  message( FATAL_ERROR "Specified ANDROID_ABI = \"${ANDROID_ABI}\" is not supported by this cmake toolchain or your NDK/toolchain.
 479    Supported values are: \"${PRINTABLE_ANDROID_SUPPORTED_ABIS}\"
 480    " )
 481 endif()
 482 unset( __androidAbiIdx )
 483
 484 #remember target ABI
 485 set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE )
 486
 487 #set target ABI options
 488 if( ANDROID_ABI STREQUAL "x86" )
 489  set( X86 true )
 490  set( ANDROID_NDK_ABI_NAME "x86" )
 491  set( ANDROID_ARCH_NAME "x86" )
 492  set( CMAKE_SYSTEM_PROCESSOR "i686" )
 493 elseif( ANDROID_ABI STREQUAL "armeabi" )
 494  set( ARMEABI true )
 495  set( ANDROID_NDK_ABI_NAME "armeabi" )
 496  set( ANDROID_ARCH_NAME "arm" )
 497  set( CMAKE_SYSTEM_PROCESSOR "armv5te" )
 498 elseif( ANDROID_ABI STREQUAL "armeabi-v6 with VFP" )
 499  set( ARMEABI_V6 true )
 500  set( ANDROID_NDK_ABI_NAME "armeabi" )
 501  set( ANDROID_ARCH_NAME "arm" )
 502  set( CMAKE_SYSTEM_PROCESSOR "armv6" )
 503  #need always fallback to older platform
 504  set( ARMEABI true )
 505 elseif( ANDROID_ABI STREQUAL "armeabi-v7a")
 506  set( ARMEABI_V7A true )
 507  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
 508  set( ANDROID_ARCH_NAME "arm" )
 509  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
 510 elseif( ANDROID_ABI STREQUAL "armeabi-v7a with VFPV3" )
 511  set( ARMEABI_V7A true )
 512  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
 513  set( ANDROID_ARCH_NAME "arm" )
 514  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
 515  set( VFPV3 true )
 516 elseif( ANDROID_ABI STREQUAL "armeabi-v7a with NEON" )
 517  set( ARMEABI_V7A true )
 518  set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )
 519  set( ANDROID_ARCH_NAME "arm" )
 520  set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )
 521  set( VFPV3 true )
 522  set( NEON true )
 523 else()
 524  message( SEND_ERROR "Unknown ANDROID_ABI=\"${ANDROID_ABI}\" is specified." )
 525 endif()
 526
 527 set( ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME}} CACHE INTERNAL "ANDROID_ABI can be changed only to one of these ABIs. Changing to any other ABI requires to reset cmake cache." )
 528 if( CMAKE_VERSION VERSION_GREATER "2.8" )
 529  list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME} )
 530  set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_NAME}} )
 531 endif()
 532
 533 if( ANDROID_ARCH_NAME STREQUAL "arm" AND NOT ARMEABI_V6 )
 534  __INIT_VARIABLE( ANDROID_FORCE_ARM_BUILD OBSOLETE_FORCE_ARM VALUES OFF )
 535  set( ANDROID_FORCE_ARM_BUILD ${ANDROID_FORCE_ARM_BUILD} CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" FORCE )
 536  mark_as_advanced( ANDROID_FORCE_ARM_BUILD )
 537 else()
 538  unset( ANDROID_FORCE_ARM_BUILD CACHE )
 539 endif()
 540
 541 #choose toolchain
 542 if( ANDROID_TOOLCHAIN_NAME )
 543  list( FIND __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" __toolchainIdx )
 544  if( __toolchainIdx EQUAL -1 )
 545   message( FATAL_ERROR "Previously selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing. You need to remove CMakeCache.txt and rerun cmake manually to change the toolchain" )
 546  endif()
 547  list( GET __availableToolchainArchs ${__toolchainIdx} __toolchainArch )
 548  if( NOT __toolchainArch STREQUAL ANDROID_ARCH_NAME )
 549   message( SEND_ERROR "Previously selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." )
 550  endif()
 551 else()
 552  set( __toolchainIdx -1 )
 553  set( __applicableToolchains "" )
 554  set( __toolchainMaxVersion "0.0.0" )
 555  list( LENGTH __availableToolchains __availableToolchainsCount )
 556  math( EXPR __availableToolchainsCount "${__availableToolchainsCount}-1" )
 557  foreach( __idx RANGE ${__availableToolchainsCount} )
 558   list( GET __availableToolchainArchs ${__idx} __toolchainArch )
 559   if( __toolchainArch STREQUAL ANDROID_ARCH_NAME )
 560    list( GET __availableToolchainCompilerVersions ${__idx} __toolchainVersion )
 561    if( __toolchainVersion VERSION_GREATER __toolchainMaxVersion )
 562     set( __toolchainMaxVersion "${__toolchainVersion}" )
 563     set( __toolchainIdx ${__idx} )
 564    endif()
 565   endif()
 566  endforeach()
 567  unset( __availableToolchainsCount )
 568  unset( __toolchainMaxVersion )
 569  unset( __toolchainVersion )
 570 endif()
 571 unset( __toolchainArch )
 572 if( __toolchainIdx EQUAL -1 )
 573  message( FATAL_ERROR "No one of available compiler toolchains is able to compile for ${ANDROID_ARCH_NAME} platform." )
 574 endif()
 575 list( GET __availableToolchains ${__toolchainIdx} ANDROID_TOOLCHAIN_NAME )
 576 list( GET __availableToolchainMachines ${__toolchainIdx} ANDROID_TOOLCHAIN_MACHINE_NAME )
 577 list( GET __availableToolchainCompilerVersions ${__toolchainIdx} ANDROID_COMPILER_VERSION )
 578 set( ANDROID_TOOLCHAIN_NAME "${ANDROID_TOOLCHAIN_NAME}" CACHE INTERNAL "Name of toolchain used" )
 579 set( ANDROID_COMPILER_VERSION "${ANDROID_COMPILER_VERSION}" CACHE INTERNAL "compiler version from selected toolchain" )
 580 unset( __toolchainIdx )
 581 unset( __availableToolchains )
 582 unset( __availableToolchainMachines )
 583 unset( __availableToolchainArchs )
 584 unset( __availableToolchainCompilerVersions )
 585
 586 #choose native API level
 587 __INIT_VARIABLE( ANDROID_NATIVE_API_LEVEL ENV_ANDROID_NATIVE_API_LEVEL ANDROID_API_LEVEL ENV_ANDROID_API_LEVEL ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME} ANDROID_DEFAULT_NDK_API_LEVEL )
 588 string( REGEX MATCH "[0-9]+" ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" )
 589 #validate
 590 list( FIND ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_NATIVE_API_LEVEL}" __levelIdx )
 591 if( __levelIdx EQUAL -1 )
 592  message( SEND_ERROR "Specified Android native API level (${ANDROID_NATIVE_API_LEVEL}) is not supported by your NDK/toolchain." )
 593 endif()
 594 unset( __levelIdx )
 595 if( BUILD_WITH_ANDROID_NDK )
 596  __DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" )
 597  if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL )
 598   message( SEND_ERROR "Specified Android API level (${ANDROID_NATIVE_API_LEVEL}) does not match to the level found (${__realApiLevel}). Probably your copy of NDK is broken." )
 599  endif()
 600  unset( __realApiLevel )
 601 endif()
 602 set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE )
 603 if( CMAKE_VERSION VERSION_GREATER "2.8" )
 604  list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS )
 605  set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )
 606 endif()
 607
 608 #setup paths
 609 if( BUILD_WITH_STANDALONE_TOOLCHAIN )
 610  set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )
 611  set( ANDROID_SYSROOT "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot" )
 612  set( __stlLibPath "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib" )
 613 endif()
 614 if( BUILD_WITH_ANDROID_NDK )
 615  set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_NDK}/toolchains/${ANDROID_TOOLCHAIN_NAME}/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )
 616  set( ANDROID_SYSROOT "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}" )
 617  if( ANDROID_USE_STLPORT )
 618   set( __stlIncludePath "${ANDROID_NDK}/sources/cxx-stl/stlport/stlport" )
 619   set( __stlLibPath "${ANDROID_NDK}/sources/cxx-stl/stlport/libs/${ANDROID_NDK_ABI_NAME}" )
 620  else()
 621   set( __stlIncludePath "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/include" )
 622   set( __stlLibPath "${ANDROID_NDK}/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}" )
 623  endif()
 624 endif()
 625
 626 # specify the cross compiler
 627 set( CMAKE_C_COMPILER   "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-gcc${TOOL_OS_SUFFIX}"     CACHE PATH "gcc" )
 628 set( CMAKE_CXX_COMPILER "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-g++${TOOL_OS_SUFFIX}"     CACHE PATH "g++" )
 629 set( CMAKE_STRIP        "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-strip${TOOL_OS_SUFFIX}"   CACHE PATH "strip" )
 630 #there may be a way to make cmake deduce these TODO deduce the rest of the tools
 631 set( CMAKE_AR           "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ar${TOOL_OS_SUFFIX}"      CACHE PATH "archive" )
 632 set( CMAKE_LINKER       "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ld${TOOL_OS_SUFFIX}"      CACHE PATH "linker" )
 633 set( CMAKE_NM           "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-nm${TOOL_OS_SUFFIX}"      CACHE PATH "nm" )
 634 set( CMAKE_OBJCOPY      "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objcopy${TOOL_OS_SUFFIX}" CACHE PATH "objcopy" )
 635 set( CMAKE_OBJDUMP      "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-objdump${TOOL_OS_SUFFIX}" CACHE PATH "objdump" )
 636 set( CMAKE_RANLIB       "${ANDROID_TOOLCHAIN_ROOT}/bin/${ANDROID_TOOLCHAIN_MACHINE_NAME}-ranlib${TOOL_OS_SUFFIX}"  CACHE PATH "ranlib" )
 637 if( APPLE )
 638  find_program( CMAKE_INSTALL_NAME_TOOL NAMES install_name_tool )
 639  if( NOT CMAKE_INSTALL_NAME_TOOL )
 640   message( FATAL_ERROR "Could not find install_name_tool, please check your installation." )
 641  endif()
 642  mark_as_advanced( CMAKE_INSTALL_NAME_TOOL )
 643 endif()
 644 #export directories
 645 set( ANDROID_SYSTEM_INCLUDE_DIRS "" )
 646 set( ANDROID_SYSTEM_LIB_DIRS "" )
 647
 648 #setup output directories
 649 set( LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_SOURCE_DIR} CACHE PATH "root for library output, set this to change where android libs are installed to" )
 650 set( CMAKE_INSTALL_PREFIX "${ANDROID_TOOLCHAIN_ROOT}/user" CACHE STRING "path for installing" )
 651
 652 set( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS OFF CACHE BOOL "" )
 653 if( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS )
 654  if( EXISTS "${CMAKE_SOURCE_DIR}/jni/CMakeLists.txt" )
 655   set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME}" CACHE PATH "Output directory for applications" )
 656  else()
 657   set( EXECUTABLE_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/bin" CACHE PATH "Output directory for applications" )
 658  endif()
 659  set( LIBRARY_OUTPUT_PATH "${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}" CACHE PATH "path for android libs" )
 660 endif()
 661 set( DO_NOT_CHANGE_OUTPUT_PATHS_ON_FIRST_PASS ON CACHE INTERNAL "" FORCE )
 662
 663 #includes
 664 list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_SYSROOT}/usr/include" )
 665 if( __stlIncludePath AND EXISTS "${__stlIncludePath}" )
 666  list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${__stlIncludePath}" )
 667 endif()
 668
 669 #STL bits includes
 670 if( __stlLibPath AND EXISTS "${__stlLibPath}/include" )
 671  list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${__stlLibPath}/include" )
 672 endif()
 673 if( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/thumb/bits" )
 674  list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/thumb" )
 675 elseif( EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/bits" )
 676  list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}" )
 677 elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb/bits" )
 678  list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb" )
 679 elseif( EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/bits" )
 680  list( APPEND ANDROID_SYSTEM_INCLUDE_DIRS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" )
 681 endif()
 682
 683 #flags and definitions
 684 if(ANDROID_SYSROOT MATCHES "[ ;\"]")
 685  set( ANDROID_CXX_FLAGS "--sysroot=\"${ANDROID_SYSROOT}\"" )
 686  # quotes will break try_compile and compiler identification
 687  message(WARNING "Your Android system root has non-alphanumeric symbols. It can break compiler features detection and the whole build.")
 688 else()
 689  set( ANDROID_CXX_FLAGS "--sysroot=${ANDROID_SYSROOT}" )
 690 endif()
 691
 692 remove_definitions( -DANDROID )
 693 add_definitions( -DANDROID )
 694
 695 # Force set compilers because standard identification works badly for us
 696 include( CMakeForceCompiler )
 697 CMAKE_FORCE_C_COMPILER( "${CMAKE_C_COMPILER}" GNU )
 698 CMAKE_FORCE_CXX_COMPILER( "${CMAKE_CXX_COMPILER}" GNU )
 699 set( CMAKE_SIZEOF_VOID_P 4 )
 700 set( CMAKE_C_SIZEOF_DATA_PTR 4 )
 701 set( CMAKE_CXX_SIZEOF_DATA_PTR 4 )
 702
 703 # NDK flags
 704 if( ARMEABI OR ARMEABI_V7A )
 705  # NDK also defines -ffunction-sections -funwind-tables but they result in worse OpenCV performance
 706  set( CMAKE_CXX_FLAGS "-fPIC -Wno-psabi" )
 707  set( CMAKE_C_FLAGS "-fPIC -Wno-psabi" )
 708  if( ANDROID_USE_STLPORT )
 709   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions" )
 710   set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-rtti -fno-exceptions" )
 711  else()
 712   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -frtti -fexceptions" )
 713   set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fexceptions" )
 714  endif()
 715  remove_definitions( -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ )
 716  add_definitions( -D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ )
 717  # extra arm-specific flags
 718  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -fsigned-char" )
 719 elseif( X86 )
 720  set( CMAKE_CXX_FLAGS "-ffunction-sections -funwind-tables" )
 721  set( CMAKE_C_FLAGS "-ffunction-sections -funwind-tables" )
 722  if( ANDROID_USE_STLPORT )
 723   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions" )
 724   set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-rtti -fno-exceptions" )
 725  else()
 726   set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -frtti -fexceptions" )
 727   set( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fexceptions" )
 728  endif()
 729 else()
 730  set( CMAKE_CXX_FLAGS "" )
 731  set( CMAKE_C_FLAGS "" )
 732 endif()
 733
 734 #release and debug flags
 735 if( ARMEABI OR ARMEABI_V7A )
 736  if( NOT ANDROID_FORCE_ARM_BUILD AND NOT ARMEABI_V6 )
 737   #It is recommended to use the -mthumb compiler flag to force the generation
 738   #of 16-bit Thumb-1 instructions (the default being 32-bit ARM ones).
 739   # O3 instead of O2/Os in release mode - like cmake sets for desktop gcc
 740   set( CMAKE_CXX_FLAGS_RELEASE "-mthumb -O3" )
 741   set( CMAKE_C_FLAGS_RELEASE   "-mthumb -O3" )
 742   set( CMAKE_CXX_FLAGS_DEBUG "-marm -Os -finline-limit=64" )
 743   set( CMAKE_C_FLAGS_DEBUG   "-marm -Os -finline-limit=64" )
 744  else()
 745   # always compile ARMEABI_V6 in arm mode; otherwise there is no difference from ARMEABI
 746   # O3 instead of O2/Os in release mode - like cmake sets for desktop gcc
 747   set( CMAKE_CXX_FLAGS_RELEASE "-marm -O3 -fstrict-aliasing" )
 748   set( CMAKE_C_FLAGS_RELEASE   "-marm -O3 -fstrict-aliasing" )
 749   set( CMAKE_CXX_FLAGS_DEBUG "-marm -O0 -finline-limit=300" )
 750   set( CMAKE_C_FLAGS_DEBUG   "-marm -O0 -finline-limit=300" )
 751  endif()
 752 elseif( X86 )
 753  set( CMAKE_CXX_FLAGS_RELEASE "-O3 -fstrict-aliasing" )
 754  set( CMAKE_C_FLAGS_RELEASE   "-O3 -fstrict-aliasing" )
 755  set( CMAKE_CXX_FLAGS_DEBUG "-O0 -finline-limit=300" )
 756  set( CMAKE_C_FLAGS_DEBUG   "-O0 -finline-limit=300" )
 757 endif()
 758 set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fomit-frame-pointer -DNDEBUG" )
 759 set( CMAKE_C_FLAGS_RELEASE   "${CMAKE_C_FLAGS_RELEASE}   -fomit-frame-pointer -DNDEBUG" )
 760 set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-strict-aliasing -fno-omit-frame-pointer -DDEBUG -D_DEBUG" )
 761 set( CMAKE_C_FLAGS_DEBUG   "${CMAKE_C_FLAGS_DEBUG}   -fno-strict-aliasing -fno-omit-frame-pointer -DDEBUG -D_DEBUG" )
 762
 763 #ABI-specific flags
 764 if( ARMEABI_V7A )
 765  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv7-a -mfloat-abi=softfp" )
 766  if( NEON )
 767   set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=neon" )
 768  elseif( VFPV3 )
 769   set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfpv3" )
 770  else()
 771   set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -mfpu=vfp" )
 772  endif()
 773 elseif( ARMEABI_V6 )
 774  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv6 -mfloat-abi=softfp -mfpu=vfp" )
 775 elseif( ARMEABI )
 776  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS} -march=armv5te -mtune=xscale -msoft-float" )
 777 elseif( X86 )
 778  set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS}" )#sse?
 779 endif()
 780
 781 #linker flags
 782 list( APPEND ANDROID_SYSTEM_LIB_DIRS "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}" "${CMAKE_INSTALL_PREFIX}/libs/${ANDROID_NDK_ABI_NAME}" )
 783 set( LINKER_FLAGS "" )
 784 #STL
 785 if( ANDROID_USE_STLPORT )
 786  if( EXISTS "${__stlLibPath}/libstlport_static.a" )
 787   __COPY_IF_DIFFERENT( "${__stlLibPath}/libstlport_static.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libstlport_static.a" )
 788  endif()
 789  if( EXISTS "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libstlport_static.a" )
 790   set( LINKER_FLAGS "${LINKER_FLAGS} -Wl,--start-group -lstlport_static" )
 791  endif()
 792 else( ANDROID_USE_STLPORT )
 793  if( EXISTS "${__stlLibPath}/libgnustl_static.a" )
 794   __COPY_IF_DIFFERENT( "${__stlLibPath}/libgnustl_static.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
 795  elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${__stlLibPath}/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" )
 796   __COPY_IF_DIFFERENT( "${__stlLibPath}/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
 797  elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${__stlLibPath}/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" )
 798   __COPY_IF_DIFFERENT( "${__stlLibPath}/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
 799  elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${__stlLibPath}/thumb/libstdc++.a" )
 800   __COPY_IF_DIFFERENT( "${__stlLibPath}/thumb/libstdc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
 801  elseif( EXISTS "${__stlLibPath}/libstdc++.a" )
 802   __COPY_IF_DIFFERENT( "${__stlLibPath}/libstdc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
 803  endif()
 804  if( EXISTS "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libstdc++.a" )
 805   set( LINKER_FLAGS "${LINKER_FLAGS} -lstdc++" )
 806  endif()
 807
 808  #gcc exception & rtti support
 809  if( EXISTS "${__stlLibPath}/libsupc++.a" )
 810   __COPY_IF_DIFFERENT( "${__stlLibPath}/libsupc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
 811  elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libsupc++.a" )
 812   __COPY_IF_DIFFERENT( "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libsupc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
 813  elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libsupc++.a" )
 814   __COPY_IF_DIFFERENT( "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libsupc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
 815  elseif( ANDROID_ARCH_NAME STREQUAL "arm" AND EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libsupc++.a" )
 816   __COPY_IF_DIFFERENT( "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libsupc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
 817  elseif( EXISTS "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libsupc++.a" )
 818   __COPY_IF_DIFFERENT( "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libsupc++.a" "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
 819  endif()
 820  if( EXISTS "${CMAKE_BINARY_DIR}/systemlibs/${ANDROID_NDK_ABI_NAME}/libsupc++.a" )
 821   set( LINKER_FLAGS "${LINKER_FLAGS} -lsupc++" )
 822  endif()
 823 endif( ANDROID_USE_STLPORT )
 824
 825 #cleanup for STL search
 826 unset( __stlIncludePath )
 827 unset( __stlLibPath )
 828
 829 #other linker flags
 830 __INIT_VARIABLE( ANDROID_NO_UNDEFINED OBSOLETE_NO_UNDEFINED VALUES ON )
 831 set( ANDROID_NO_UNDEFINED ${ANDROID_NO_UNDEFINED} CACHE BOOL "Show all undefined symbols as linker errors" FORCE )
 832 mark_as_advanced( ANDROID_NO_UNDEFINED )
 833 if( ANDROID_NO_UNDEFINED )
 834  set( LINKER_FLAGS "-Wl,--no-undefined ${LINKER_FLAGS}" )
 835 endif()
 836
 837 if (ANDROID_NDK MATCHES "-r[56].?$")
 838  #libGLESv2.so in NDK's prior to r7 refers to exteranal symbols. So this flag option is required for all projects using OpenGL from native.
 839  __INIT_VARIABLE( ANDROID_SO_UNDEFINED VALUES ON )
 840 else()
 841  __INIT_VARIABLE( ANDROID_SO_UNDEFINED VALUES OFF )
 842 endif()
 843 set( ANDROID_SO_UNDEFINED ${ANDROID_SO_UNDEFINED} CACHE BOOL "Allows or disallows undefined symbols in shared libraries" FORCE )
 844 mark_as_advanced( ANDROID_SO_UNDEFINED )
 845 if( ANDROID_SO_UNDEFINED )
 846  set( LINKER_FLAGS "${LINKER_FLAGS} -Wl,-allow-shlib-undefined" )
 847 endif()
 848
 849 if( ARMEABI_V7A )
 850  # this is *required* to use the following linker flags that routes around
 851  # a CPU bug in some Cortex-A8 implementations:
 852  set( LINKER_FLAGS "-Wl,--fix-cortex-a8 ${LINKER_FLAGS}" )
 853 endif()
 854
 855 #cache flags
 856 set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c++ flags" )
 857 set( CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS}" CACHE STRING "c flags" )
 858 set( CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}" CACHE STRING "c++ Release flags" )
 859 set( CMAKE_C_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}" CACHE STRING "c Release flags" )
 860 set( CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING "c++ Debug flags" )
 861 set( CMAKE_C_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING "c Debug flags" )
 862 set( CMAKE_SHARED_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" )
 863 set( CMAKE_MODULE_LINKER_FLAGS "${LINKER_FLAGS}" CACHE STRING "linker flags" )
 864 set( CMAKE_EXE_LINKER_FLAGS "-Wl,--gc-sections -Wl,-z,nocopyreloc ${LINKER_FLAGS}" CACHE STRING "linker flags" )
 865
 866 include_directories( SYSTEM ${ANDROID_SYSTEM_INCLUDE_DIRS} )
 867 link_directories( ${ANDROID_SYSTEM_LIB_DIRS} )
 868
 869 #finish flags
 870 set( ANDROID_CXX_FLAGS "${ANDROID_CXX_FLAGS}" CACHE INTERNAL "Extra Android falgs")
 871 set( CMAKE_CXX_FLAGS "${ANDROID_CXX_FLAGS} ${CMAKE_CXX_FLAGS}" )
 872 set( CMAKE_C_FLAGS   "${ANDROID_CXX_FLAGS} ${CMAKE_C_FLAGS}" )
 873
 874 #set these global flags for cmake client scripts to change behavior
 875 set( ANDROID True )
 876 set( BUILD_ANDROID True )
 877
 878 # where is the target environment
 879 set( CMAKE_FIND_ROOT_PATH "${ANDROID_TOOLCHAIN_ROOT}/bin" "${ANDROID_TOOLCHAIN_ROOT}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" "${ANDROID_SYSROOT}" "${CMAKE_INSTALL_PREFIX}" "${CMAKE_INSTALL_PREFIX}/share" )
 880
 881 # only search for libraries and includes in the ndk toolchain
 882 set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
 883 set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
 884 set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
 885
 886
 887 #macro to find packages on the host OS
 888 macro( find_host_package )
 889  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
 890  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER )
 891  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER )
 892  if( CMAKE_HOST_WIN32 )
 893   SET( WIN32 1 )
 894   SET( UNIX )
 895  elseif( CMAKE_HOST_APPLE )
 896   SET( APPLE 1 )
 897   SET( UNIX )
 898  endif()
 899  find_package( ${ARGN} )
 900  SET( WIN32 )
 901  SET( APPLE )
 902  SET( UNIX 1 )
 903  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
 904  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
 905  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
 906 endmacro()
 907
 908
 909 #macro to find programs on the host OS
 910 macro( find_host_program )
 911  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER )
 912  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER )
 913  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER )
 914  if( CMAKE_HOST_WIN32 )
 915   SET( WIN32 1 )
 916   SET( UNIX )
 917  elseif( CMAKE_HOST_APPLE )
 918   SET( APPLE 1 )
 919   SET( UNIX )
 920  endif()
 921  find_program( ${ARGN} )
 922  SET( WIN32 )
 923  SET( APPLE )
 924  SET( UNIX 1 )
 925  set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY )
 926  set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
 927  set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
 928 endmacro()
 929
 930
 931 macro( ANDROID_GET_ABI_RAWNAME TOOLCHAIN_FLAG VAR )
 932  if( "${TOOLCHAIN_FLAG}" STREQUAL "ARMEABI" )
 933   set( ${VAR} "armeabi" )
 934  elseif( "${TOOLCHAIN_FLAG}" STREQUAL "ARMEABI_V7A" )
 935     set( ${VAR} "armeabi-v7a" )
 936  elseif( "${TOOLCHAIN_FLAG}" STREQUAL "X86" )
 937     set( ${VAR} "x86" )
 938  else()
 939     set( ${VAR} "unknown" )
 940  endif()
 941 endmacro()
 942
 943
 944 # export toolchain settings for the try_compile() command
 945 if( NOT PROJECT_NAME STREQUAL "CMAKE_TRY_COMPILE" )
 946  set( __toolchain_config "")
 947  foreach( __var ANDROID_ABI ANDROID_FORCE_ARM_BUILD ANDROID_NATIVE_API_LEVEL ANDROID_NO_UNDEFINED ANDROID_SO_UNDEFINED ANDROID_SET_OBSOLETE_VARIABLES LIBRARY_OUTPUT_PATH_ROOT ANDROID_USE_STLPORT ANDROID_FORBID_SYGWIN ANDROID_NDK ANDROID_STANDALONE_TOOLCHAIN )
 948   if( DEFINED ${__var} )
 949    set( __toolchain_config "${__toolchain_config}set( ${__var} \"${${__var}}\" )\n" )
 950   endif()
 951  endforeach()
 952  file( WRITE "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/android.toolchain.config.cmake" "${__toolchain_config}" )
 953  unset( __toolchain_config )
 954 endif()
 955
 956
 957 # set some obsolete variables for backward compatibility
 958 set( ANDROID_SET_OBSOLETE_VARIABLES ON CACHE BOOL "Define obsolete Andrid-specific cmake variables" )
 959 mark_as_advanced( ANDROID_SET_OBSOLETE_VARIABLES )
 960 if( ANDROID_SET_OBSOLETE_VARIABLES )
 961  set( ANDROID_API_LEVEL ${ANDROID_NATIVE_API_LEVEL} )
 962  set( ARM_TARGET "${ANDROID_ABI}" )
 963  set( ARMEABI_NDK_NAME "${ANDROID_NDK_ABI_NAME}" )
 964 endif()
 965
 966 # Variables controlling behavior or set by cmake toolchain:
 967 #   ANDROID_ABI : "armeabi-v7a" (default), "armeabi", "armeabi-v7a with NEON", "armeabi-v7a with VFPV3", "armeabi-v6 with VFP", "x86"
 968 #   ANDROID_FORCE_ARM_BUILD : ON/OFF
 969 #   ANDROID_NATIVE_API_LEVEL : 3,4,5,8,9,14 (depends on NDK version)
 970 #   ANDROID_NO_UNDEFINED : ON/OFF
 971 #   ANDROID_SO_UNDEFINED : OFF/ON  (default depends on NDK version)
 972 #   ANDROID_SET_OBSOLETE_VARIABLES : ON/OFF
 973 #   LIBRARY_OUTPUT_PATH_ROOT : <any valid path>
 974 #   ANDROID_USE_STLPORT : OFF/ON - EXPERIMENTAL!!!
 975 #   ANDROID_FORBID_SYGWIN : ON/OFF
 976 # Can be set only at the first run:
 977 #   ANDROID_NDK
 978 #   ANDROID_STANDALONE_TOOLCHAIN
 979 # Obsolete:
 980 #   ANDROID_API_LEVEL : superseded by ANDROID_NATIVE_API_LEVEL
 981 #   ARM_TARGET : superseded by ANDROID_ABI
 982 #   ARM_TARGETS : superseded by ANDROID_ABI (can be set only)
 983 #   ANDROID_NDK_TOOLCHAIN_ROOT : superseded by ANDROID_STANDALONE_TOOLCHAIN (can be set only)
 984 #   ANDROID_LEVEL : superseded by ANDROID_NATIVE_API_LEVEL (completely removed)
 985 #
 986 # Primary read-only variables:
 987 #   ANDROID : always TRUE
 988 #   ARMEABI : TRUE for arm v6 and older devices
 989 #   ARMEABI_V6 : TRUE for arm v6
 990 #   ARMEABI_V7A : TRUE for arm v7a
 991 #   NEON : TRUE if NEON unit is enabled
 992 #   VFPV3 : TRUE if VFP version 3 is enabled
 993 #   X86 : TRUE if configured for x86
 994 #   BUILD_ANDROID : always TRUE
 995 #   BUILD_WITH_ANDROID_NDK : TRUE if NDK is used
 996 #   BUILD_WITH_STANDALONE_TOOLCHAIN : TRUE if standalone toolchain is used
 997 #   ANDROID_NDK_HOST_SYSTEM_NAME : "windows", "linux-x86" or "darwin-x86" depending on host platform
 998 #   ANDROID_NDK_ABI_NAME : "armeabi", "armeabi-v7a" or "x86" depending on ANDROID_ABI
 999 #   ANDROID_ARCH_NAME : "arm" or "x86" depending on ANDROID_ABI
1000 #   TOOL_OS_SUFFIX : "" or ".exe" depending on host platform
1001 #   ANDROID_SYSTEM_INCLUDE_DIRS
1002 #   ANDROID_SYSTEM_LIB_DIRS
1003 # Obsolete:
1004 #   ARMEABI_NDK_NAME : superseded by ANDROID_NDK_ABI_NAME
1005 #
1006 # Secondary (less stable) read-only variables:
1007 #   ANDROID_COMPILER_VERSION : GCC version used
1008 #   ANDROID_CXX_FLAGS : C/C++ compiler flags required by Android platform
1009 #   ANDROID_SUPPORTED_ABIS : list of currently allowed values for ANDROID_ABI
1010 #   ANDROID_SYSROOT : path to the compiler sysroot
1011 #   ANDROID_TOOLCHAIN_NAME : "standalone", "arm-linux-androideabi-4.4.3" or "x86-4.4.3" or something similar.
1012 #   ANDROID_TOOLCHAIN_MACHINE_NAME : "arm-linux-androideabi", "arm-eabi" or "i686-android-linux"
1013 #   ANDROID_TOOLCHAIN_ROOT : path to the top level of toolchain (standalone or placed inside NDK)
1014 #   ANDROID_SUPPORTED_NATIVE_API_LEVELS : list of native API levels found inside NDK
1015 #
1016 # Defaults:
1017 #   ANDROID_DEFAULT_NDK_API_LEVEL
1018 #   ANDROID_DEFAULT_NDK_API_LEVEL_${ARCH}
1019 #   ANDROID_NDK_SEARCH_PATHS
1020 #   ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH
1021 #   ANDROID_SUPPORTED_ABIS_${ARCH}
1022 #   ANDROID_SUPPORTED_NDK_VERSIONS