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