# Copyright (c) 2010-2011, Ethan Rublee

# Copyright (c) 2011-2014, Andrey Kamaev

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are met:

#

# 1. Redistributions of source code must retain the above copyright notice,

# this list of conditions and the following disclaimer.

#

# 2. Redistributions in binary form must reproduce the above copyright notice,

# this list of conditions and the following disclaimer in the documentation

# and/or other materials provided with the distribution.

#

# 3. Neither the name of the copyright holder nor the names of its

# contributors may be used to endorse or promote products derived from this

# software without specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

# ------------------------------------------------------------------------------

# Android CMake toolchain file, for use with the Android NDK r5-r9

# Requires cmake 2.6.3 or newer (2.8.5 or newer is recommended).

# See home page: https://github.com/taka-no-me/android-cmake

#

# The file is mantained by the OpenCV project. The latest version can be get at

# http://code.opencv.org/projects/opencv/repository/revisions/master/changes/android/android.toolchain.cmake

#

# Usage Linux:

# $ export ANDROID_NDK=/absolute/path/to/the/android-ndk

# $ mkdir build && cd build

# $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake ..

# $ make -j8

#

# Usage Linux (using standalone toolchain):

# $ export ANDROID_STANDALONE_TOOLCHAIN=/absolute/path/to/android-toolchain

# $ mkdir build && cd build

# $ cmake -DCMAKE_TOOLCHAIN_FILE=path/to/the/android.toolchain.cmake ..

# $ make -j8

#

# Usage Windows:

# You need native port of make to build your project.

# Android NDK r7 (or newer) already has make.exe on board.

# For older NDK you have to install it separately.

# For example, this one: http://gnuwin32.sourceforge.net/packages/make.htm

#

# $ SET ANDROID_NDK=C:\absolute\path\to\the\android-ndk

# $ mkdir build && cd build

# $ cmake.exe -G"MinGW Makefiles"

# -DCMAKE_TOOLCHAIN_FILE=path\to\the\android.toolchain.cmake

# -DCMAKE_MAKE_PROGRAM="%ANDROID_NDK%\prebuilt\windows\bin\make.exe" ..

# $ cmake.exe --build .

#

#

# Options (can be set as cmake parameters: -D<option_name>=<value>):

# ANDROID_NDK=/opt/android-ndk - path to the NDK root.

# Can be set as environment variable. Can be set only at first cmake run.

#

# ANDROID_STANDALONE_TOOLCHAIN=/opt/android-toolchain - path to the

# standalone toolchain. This option is not used if full NDK is found

# (ignored if ANDROID_NDK is set).

# Can be set as environment variable. Can be set only at first cmake run.

#

# ANDROID_ABI=armeabi-v7a - specifies the target Application Binary

# Interface (ABI). This option nearly matches to the APP_ABI variable

# used by ndk-build tool from Android NDK.

#

# Possible targets are:

# "armeabi" - matches to the NDK ABI with the same name.

# See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation.

# "armeabi-v7a" - matches to the NDK ABI with the same name.

# See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation.

# "armeabi-v6" - tuned for ARMv6 processors having VFP.

# "x86" - matches to the NDK ABI with the same name.

# See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation.

# "mips" - matches to the NDK ABI with the same name.

# See ${ANDROID_NDK}/docs/CPU-ARCH-ABIS.html for the documentation.

#

# ANDROID_NATIVE_API_LEVEL=android-8 - level of Android API compile for.

# Option is read-only when standalone toolchain is used.

#

# ANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.6 - the name of compiler

# toolchain to be used. The list of possible values depends on the NDK

# version. For NDK r8c the possible values are:

#

# * arm-linux-androideabi-4.4.3

# * arm-linux-androideabi-4.6

# * arm-linux-androideabi-clang3.1

# * mipsel-linux-android-4.4.3

# * mipsel-linux-android-4.6

# * mipsel-linux-android-clang3.1

# * x86-4.4.3

# * x86-4.6

# * x86-clang3.1

#

# ANDROID_FORCE_ARM_BUILD=OFF - set ON to generate 32-bit ARM instructions

# instead of Thumb. Is not available for "x86" (inapplicable) and

# "armeabi-v6 with VFP" (is forced to be ON) ABIs.

#

# ANDROID_NO_UNDEFINED=ON - set ON to show all undefined symbols as linker

# errors even if they are not used.

#

# ANDROID_SO_UNDEFINED=OFF - set ON to allow undefined symbols in shared

# libraries. Automatically turned for NDK r5x and r6x due to GLESv2

# problems.

#

# LIBRARY_OUTPUT_PATH_ROOT=${CMAKE_SOURCE_DIR} - where to output binary

# files. See additional details below.

#

# ANDROID_SET_OBSOLETE_VARIABLES=ON - if set, then toolchain defines some

# obsolete variables which were used by previous versions of this file for

# backward compatibility.

#

# ANDROID_STL=gnustl_static - specify the runtime to use.

#

# Possible values are:

# none -> Do not configure the runtime.

# system -> Use the default minimal system C++ runtime library.

# Implies -fno-rtti -fno-exceptions.

# Is not available for standalone toolchain.

# system_re -> Use the default minimal system C++ runtime library.

# Implies -frtti -fexceptions.

# Is not available for standalone toolchain.

# gabi++_static -> Use the GAbi++ runtime as a static library.

# Implies -frtti -fno-exceptions.

# Available for NDK r7 and newer.

# Is not available for standalone toolchain.

# gabi++_shared -> Use the GAbi++ runtime as a shared library.

# Implies -frtti -fno-exceptions.

# Available for NDK r7 and newer.

# Is not available for standalone toolchain.

# stlport_static -> Use the STLport runtime as a static library.

# Implies -fno-rtti -fno-exceptions for NDK before r7.

# Implies -frtti -fno-exceptions for NDK r7 and newer.

# Is not available for standalone toolchain.

# stlport_shared -> Use the STLport runtime as a shared library.

# Implies -fno-rtti -fno-exceptions for NDK before r7.

# Implies -frtti -fno-exceptions for NDK r7 and newer.

# Is not available for standalone toolchain.

# gnustl_static -> Use the GNU STL as a static library.

# Implies -frtti -fexceptions.

# gnustl_shared -> Use the GNU STL as a shared library.

# Implies -frtti -fno-exceptions.

# Available for NDK r7b and newer.

# Silently degrades to gnustl_static if not available.

#

# ANDROID_STL_FORCE_FEATURES=ON - turn rtti and exceptions support based on

# chosen runtime. If disabled, then the user is responsible for settings

# these options.

#

# What?:

# android-cmake toolchain searches for NDK/toolchain in the following order:

# ANDROID_NDK - cmake parameter

# ANDROID_NDK - environment variable

# ANDROID_STANDALONE_TOOLCHAIN - cmake parameter

# ANDROID_STANDALONE_TOOLCHAIN - environment variable

# ANDROID_NDK - default locations

# ANDROID_STANDALONE_TOOLCHAIN - default locations

#

# Make sure to do the following in your scripts:

# SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${my_cxx_flags}" )

# SET( CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${my_cxx_flags}" )

# The flags will be prepopulated with critical flags, so don't loose them.

# Also be aware that toolchain also sets configuration-specific compiler

# flags and linker flags.

#

# ANDROID and BUILD_ANDROID will be set to true, you may test any of these

# variables to make necessary Android-specific configuration changes.

#

# Also ARMEABI or ARMEABI_V7A or X86 or MIPS will be set true, mutually

# exclusive.

#

# LIBRARY_OUTPUT_PATH_ROOT should be set in cache to determine where Android

# libraries will be installed.

# Default is ${CMAKE_SOURCE_DIR}, and the android libs will always be

# under the ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME}

# (depending on the target ABI). This is convenient for Android packaging.

#

# Change Log:

# - initial version December 2010

# - April 2011

# [+] added possibility to build with NDK (without standalone toolchain)

# [+] support cross-compilation on Windows (native, no cygwin support)

# [+] added compiler option to force "char" type to be signed

# [+] added toolchain option to compile to 32-bit ARM instructions

# [+] added toolchain option to disable SWIG search

# [+] added platform "armeabi-v7a with VFPV3"

# [~] ARM_TARGETS renamed to ARM_TARGET

# [+] EXECUTABLE_OUTPUT_PATH is set by toolchain (required on Windows)

# [~] Fixed bug with ANDROID_API_LEVEL variable

# [~] turn off SWIG search if it is not found first time

# - May 2011

# [~] ANDROID_LEVEL is renamed to ANDROID_API_LEVEL

# [+] ANDROID_API_LEVEL is detected by toolchain if not specified

# [~] added guard to prevent changing of output directories on the first

# cmake pass

# [~] toolchain exits with error if ARM_TARGET is not recognized

# - June 2011

# [~] default NDK path is updated for version r5c

# [+] variable CMAKE_SYSTEM_PROCESSOR is set based on ARM_TARGET

# [~] toolchain install directory is added to linker paths

# [-] removed SWIG-related stuff from toolchain

# [+] added macro find_host_package, find_host_program to search

# packages/programs on the host system

# [~] fixed path to STL library

# - July 2011

# [~] fixed options caching

# [~] search for all supported NDK versions

# [~] allowed spaces in NDK path

# - September 2011

# [~] updated for NDK r6b

# - November 2011

# [*] rewritten for NDK r7

# [+] x86 toolchain support (experimental)

# [+] added "armeabi-v6 with VFP" ABI for ARMv6 processors.

# [~] improved compiler and linker flags management

# [+] support different build flags for Release and Debug configurations

# [~] by default compiler flags the same as used by ndk-build (but only

# where reasonable)

# [~] ANDROID_NDK_TOOLCHAIN_ROOT is splitted to ANDROID_STANDALONE_TOOLCHAIN

# and ANDROID_TOOLCHAIN_ROOT

# [~] ARM_TARGET is renamed to ANDROID_ABI

# [~] ARMEABI_NDK_NAME is renamed to ANDROID_NDK_ABI_NAME

# [~] ANDROID_API_LEVEL is renamed to ANDROID_NATIVE_API_LEVEL

# - January 2012

# [+] added stlport_static support (experimental)

# [+] added special check for cygwin

# [+] filtered out hidden files (starting with .) while globbing inside NDK

# [+] automatically applied GLESv2 linkage fix for NDK revisions 5-6

# [+] added ANDROID_GET_ABI_RAWNAME to get NDK ABI names by CMake flags

# - February 2012

# [+] updated for NDK r7b

# [~] fixed cmake try_compile() command

# [~] Fix for missing install_name_tool on OS X

# - March 2012

# [~] fixed incorrect C compiler flags

# [~] fixed CMAKE_SYSTEM_PROCESSOR change on ANDROID_ABI change

# [+] improved toolchain loading speed

# [+] added assembler language support (.S)

# [+] allowed preset search paths and extra search suffixes

# - April 2012

# [+] updated for NDK r7c

# [~] fixed most of problems with compiler/linker flags and caching

# [+] added option ANDROID_FUNCTION_LEVEL_LINKING

# - May 2012

# [+] updated for NDK r8

# [+] added mips architecture support

# - August 2012

# [+] updated for NDK r8b

# [~] all intermediate files generated by toolchain are moved to CMakeFiles

# [~] libstdc++ and libsupc are removed from explicit link libraries

# [+] added CCache support (via NDK_CCACHE environment or cmake variable)

# [+] added gold linker support for NDK r8b

# [~] fixed mips linker flags for NDK r8b

# - September 2012

# [+] added NDK release name detection (see ANDROID_NDK_RELEASE)

# [+] added support for all C++ runtimes from NDK

# (system, gabi++, stlport, gnustl)

# [+] improved warnings on known issues of NDKs

# [~] use gold linker as default if available (NDK r8b)

# [~] globally turned off rpath

# [~] compiler options are aligned with NDK r8b

# - October 2012

# [~] fixed C++ linking: explicitly link with math library (OpenCV #2426)

# - November 2012

# [+] updated for NDK r8c

# [+] added support for clang compiler

# - December 2012

# [+] suppress warning about unused CMAKE_TOOLCHAIN_FILE variable

# [+] adjust API level to closest compatible as NDK does

# [~] fixed ccache full path search

# [+] updated for NDK r8d

# [~] compiler options are aligned with NDK r8d

# - March 2013

# [+] updated for NDK r8e (x86 version)

# [+] support x86_64 version of NDK

# - April 2013

# [+] support non-release NDK layouts (from Linaro git and Android git)

# [~] automatically detect if explicit link to crtbegin_*.o is needed

# - June 2013

# [~] fixed stl include path for standalone toolchain made by NDK >= r8c

# - July 2013

# [+] updated for NDK r9

# - November 2013

# [+] updated for NDK r9b

# - December 2013

# [+] updated for NDK r9c

# - January 2014

# [~] fix copying of shared STL

# - April 2014

# [+] updated for NDK r9d

# - June 2014

# [+] Customised for PPSSPP by forcing NEON only build for armv7 -xsacha

# ------------------------------------------------------------------------------

cmake_minimum_required( VERSION 2.6.3 )

if( DEFINED CMAKE_CROSSCOMPILING )

# subsequent toolchain loading is not really needed

return()

endif()

if( CMAKE_TOOLCHAIN_FILE )

# touch toolchain variable only to suppress "unused variable" warning

endif()

get_property( _CMAKE_IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE )

if( _CMAKE_IN_TRY_COMPILE )

include( "${CMAKE_CURRENT_SOURCE_DIR}/../android.toolchain.config.cmake" OPTIONAL )

endif()

# this one is important

set( CMAKE_SYSTEM_NAME Linux )

# this one not so much

set( CMAKE_SYSTEM_VERSION 1 )

# rpath makes low sence for Android

set( CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries." )

set( ANDROID_SUPPORTED_NDK_VERSIONS ${ANDROID_EXTRA_NDK_VERSIONS} -r9d -r9c -r9b -r9 -r8e -r8d -r8c -r8b -r8 -r7c -r7b -r7 -r6b -r6 -r5c -r5b -r5 "" )

if(NOT DEFINED ANDROID_NDK_SEARCH_PATHS)

if( CMAKE_HOST_WIN32 )

file( TO_CMAKE_PATH "$ENV{PROGRAMFILES}" ANDROID_NDK_SEARCH_PATHS )

set( ANDROID_NDK_SEARCH_PATHS "${ANDROID_NDK_SEARCH_PATHS}/android-ndk" "$ENV{SystemDrive}/NVPACK/android-ndk" )

else()

file( TO_CMAKE_PATH "$ENV{HOME}" ANDROID_NDK_SEARCH_PATHS )

set( ANDROID_NDK_SEARCH_PATHS /opt/android-ndk "${ANDROID_NDK_SEARCH_PATHS}/NVPACK/android-ndk" )

endif()

endif()

if(NOT DEFINED ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH)

set( ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH /opt/android-toolchain )

endif()

set( ANDROID_SUPPORTED_ABIS_arm "armeabi-v7a;armeabi-v6" )

set( ANDROID_SUPPORTED_ABIS_x86 "x86" )

set( ANDROID_SUPPORTED_ABIS_mipsel "mips" )

set( ANDROID_DEFAULT_NDK_API_LEVEL 8 )

set( ANDROID_DEFAULT_NDK_API_LEVEL_x86 9 )

set( ANDROID_DEFAULT_NDK_API_LEVEL_mips 9 )

macro( __LIST_FILTER listvar regex )

if( ${listvar} )

foreach( __val ${${listvar}} )

if( __val MATCHES "${regex}" )

list( REMOVE_ITEM ${listvar} "${__val}" )

endif()

endforeach()

endif()

endmacro()

macro( __INIT_VARIABLE var_name )

set( __test_path 0 )

foreach( __var ${ARGN} )

if( __var STREQUAL "PATH" )

set( __test_path 1 )

break()

endif()

endforeach()

if( __test_path AND NOT EXISTS "${${var_name}}" )

unset( ${var_name} CACHE )

endif()

if( "${${var_name}}" STREQUAL "" )

set( __values 0 )

foreach( __var ${ARGN} )

if( __var STREQUAL "VALUES" )

set( __values 1 )

elseif( NOT __var STREQUAL "PATH" )

set( __obsolete 0 )

if( __var MATCHES "^OBSOLETE_.*$" )

string( REPLACE "OBSOLETE_" "" __var "${__var}" )

set( __obsolete 1 )

endif()

if( __var MATCHES "^ENV_.*$" )

string( REPLACE "ENV_" "" __var "${__var}" )

set( __value "$ENV{${__var}}" )

elseif( DEFINED ${__var} )

set( __value "${${__var}}" )

else()

if( __values )

set( __value "${__var}" )

else()

set( __value "" )

endif()

endif()

if( NOT "${__value}" STREQUAL "" )

if( __test_path )

if( EXISTS "${__value}" )

file( TO_CMAKE_PATH "${__value}" ${var_name} )

if( __obsolete AND NOT _CMAKE_IN_TRY_COMPILE )

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." )

endif()

break()

endif()

else()

set( ${var_name} "${__value}" )

if( __obsolete AND NOT _CMAKE_IN_TRY_COMPILE )

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." )

endif()

break()

endif()

endif()

endif()

endforeach()

unset( __value )

unset( __values )

unset( __obsolete )

elseif( __test_path )

file( TO_CMAKE_PATH "${${var_name}}" ${var_name} )

endif()

unset( __test_path )

endmacro()

macro( __DETECT_NATIVE_API_LEVEL _var _path )

SET( __ndkApiLevelRegex "^[\t ]*#define[\t ]+__ANDROID_API__[\t ]+([0-9]+)[\t ]*$" )

FILE( STRINGS ${_path} __apiFileContent REGEX "${__ndkApiLevelRegex}" )

if( NOT __apiFileContent )

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." )

endif()

string( REGEX REPLACE "${__ndkApiLevelRegex}" "\\1" ${_var} "${__apiFileContent}" )

unset( __apiFileContent )

unset( __ndkApiLevelRegex )

endmacro()

macro( __DETECT_TOOLCHAIN_MACHINE_NAME _var _root )

if( EXISTS "${_root}" )

file( GLOB __gccExePath RELATIVE "${_root}/bin/" "${_root}/bin/*-gcc${TOOL_OS_SUFFIX}" )

__LIST_FILTER( __gccExePath "^[.].*" )

list( LENGTH __gccExePath __gccExePathsCount )

if( NOT __gccExePathsCount EQUAL 1 AND NOT _CMAKE_IN_TRY_COMPILE )

message( WARNING "Could not determine machine name for compiler from ${_root}" )

set( ${_var} "" )

else()

get_filename_component( __gccExeName "${__gccExePath}" NAME_WE )

string( REPLACE "-gcc" "" ${_var} "${__gccExeName}" )

endif()

unset( __gccExePath )

unset( __gccExePathsCount )

unset( __gccExeName )

else()

set( ${_var} "" )

endif()

endmacro()

# fight against cygwin

set( ANDROID_FORBID_SYGWIN TRUE CACHE BOOL "Prevent cmake from working under cygwin and using cygwin tools")

mark_as_advanced( ANDROID_FORBID_SYGWIN )

if( ANDROID_FORBID_SYGWIN )

if( CYGWIN )

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." )

endif()

if( CMAKE_HOST_WIN32 )

# remove cygwin from PATH

set( __new_path "$ENV{PATH}")

__LIST_FILTER( __new_path "cygwin" )

set(ENV{PATH} "${__new_path}")

unset(__new_path)

endif()

endif()

# detect current host platform

if( NOT DEFINED ANDROID_NDK_HOST_X64 AND (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64|x86_64|AMD64" OR CMAKE_HOST_APPLE) )

set( ANDROID_NDK_HOST_X64 1 CACHE BOOL "Try to use 64-bit compiler toolchain" )

mark_as_advanced( ANDROID_NDK_HOST_X64 )

endif()

set( TOOL_OS_SUFFIX "" )

if( CMAKE_HOST_APPLE )

set( ANDROID_NDK_HOST_SYSTEM_NAME "darwin-x86_64" )

set( ANDROID_NDK_HOST_SYSTEM_NAME2 "darwin-x86" )

elseif( CMAKE_HOST_WIN32 )

set( ANDROID_NDK_HOST_SYSTEM_NAME "windows-x86_64" )

set( ANDROID_NDK_HOST_SYSTEM_NAME2 "windows" )

set( TOOL_OS_SUFFIX ".exe" )

elseif( CMAKE_HOST_UNIX )

set( ANDROID_NDK_HOST_SYSTEM_NAME "linux-x86_64" )

set( ANDROID_NDK_HOST_SYSTEM_NAME2 "linux-x86" )

else()

message( FATAL_ERROR "Cross-compilation on your platform is not supported by this cmake toolchain" )

endif()

if( NOT ANDROID_NDK_HOST_X64 )

set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} )

endif()

# see if we have path to Android NDK

__INIT_VARIABLE( ANDROID_NDK PATH ENV_ANDROID_NDK )

if( NOT ANDROID_NDK )

# see if we have path to Android standalone toolchain

__INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ENV_ANDROID_STANDALONE_TOOLCHAIN OBSOLETE_ANDROID_NDK_TOOLCHAIN_ROOT OBSOLETE_ENV_ANDROID_NDK_TOOLCHAIN_ROOT )

if( NOT ANDROID_STANDALONE_TOOLCHAIN )

#try to find Android NDK in one of the the default locations

set( __ndkSearchPaths )

foreach( __ndkSearchPath ${ANDROID_NDK_SEARCH_PATHS} )

foreach( suffix ${ANDROID_SUPPORTED_NDK_VERSIONS} )

list( APPEND __ndkSearchPaths "${__ndkSearchPath}${suffix}" )

endforeach()

endforeach()

__INIT_VARIABLE( ANDROID_NDK PATH VALUES ${__ndkSearchPaths} )

unset( __ndkSearchPaths )

if( ANDROID_NDK )

message( STATUS "Using default path for Android NDK: ${ANDROID_NDK}" )

message( STATUS " If you prefer to use a different location, please define a cmake or environment variable: ANDROID_NDK" )

else()

#try to find Android standalone toolchain in one of the the default locations

__INIT_VARIABLE( ANDROID_STANDALONE_TOOLCHAIN PATH ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH )

if( ANDROID_STANDALONE_TOOLCHAIN )

message( STATUS "Using default path for standalone toolchain ${ANDROID_STANDALONE_TOOLCHAIN}" )

message( STATUS " If you prefer to use a different location, please define the variable: ANDROID_STANDALONE_TOOLCHAIN" )

endif( ANDROID_STANDALONE_TOOLCHAIN )

endif( ANDROID_NDK )

endif( NOT ANDROID_STANDALONE_TOOLCHAIN )

endif( NOT ANDROID_NDK )

# remember found paths

if( ANDROID_NDK )

get_filename_component( ANDROID_NDK "${ANDROID_NDK}" ABSOLUTE )

set( ANDROID_NDK "${ANDROID_NDK}" CACHE INTERNAL "Path of the Android NDK" FORCE )

set( BUILD_WITH_ANDROID_NDK True )

if( EXISTS "${ANDROID_NDK}/RELEASE.TXT" )

file( STRINGS "${ANDROID_NDK}/RELEASE.TXT" ANDROID_NDK_RELEASE_FULL LIMIT_COUNT 1 REGEX r[0-9]+[a-z]? )

string( REGEX MATCH r[0-9]+[a-z]? ANDROID_NDK_RELEASE "${ANDROID_NDK_RELEASE_FULL}" )

else()

set( ANDROID_NDK_RELEASE "r1x" )

set( ANDROID_NDK_RELEASE_FULL "unreleased" )

endif()

elseif( ANDROID_STANDALONE_TOOLCHAIN )

get_filename_component( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" ABSOLUTE )

# try to detect change

if( CMAKE_AR )

string( LENGTH "${ANDROID_STANDALONE_TOOLCHAIN}" __length )

string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidStandaloneToolchainPreviousPath )

if( NOT __androidStandaloneToolchainPreviousPath STREQUAL ANDROID_STANDALONE_TOOLCHAIN )

message( FATAL_ERROR "It is not possible to change path to the Android standalone toolchain on subsequent run." )

endif()

unset( __androidStandaloneToolchainPreviousPath )

unset( __length )

endif()

set( ANDROID_STANDALONE_TOOLCHAIN "${ANDROID_STANDALONE_TOOLCHAIN}" CACHE INTERNAL "Path of the Android standalone toolchain" FORCE )

set( BUILD_WITH_STANDALONE_TOOLCHAIN True )

else()

list(GET ANDROID_NDK_SEARCH_PATHS 0 ANDROID_NDK_SEARCH_PATH)

message( FATAL_ERROR "Could not find neither Android NDK nor Android standalone toolchain.

You should either set an environment variable:

export ANDROID_NDK=~/my-android-ndk

or

export ANDROID_STANDALONE_TOOLCHAIN=~/my-android-toolchain

or put the toolchain or NDK in the default path:

sudo ln -s ~/my-android-ndk ${ANDROID_NDK_SEARCH_PATH}

sudo ln -s ~/my-android-toolchain ${ANDROID_STANDALONE_TOOLCHAIN_SEARCH_PATH}" )

endif()

# android NDK layout

if( BUILD_WITH_ANDROID_NDK )

if( NOT DEFINED ANDROID_NDK_LAYOUT )

# try to automatically detect the layout

if( EXISTS "${ANDROID_NDK}/RELEASE.TXT")

set( ANDROID_NDK_LAYOUT "RELEASE" )

elseif( EXISTS "${ANDROID_NDK}/../../linux-x86/toolchain/" )

set( ANDROID_NDK_LAYOUT "LINARO" )

elseif( EXISTS "${ANDROID_NDK}/../../gcc/" )

set( ANDROID_NDK_LAYOUT "ANDROID" )

endif()

endif()

set( ANDROID_NDK_LAYOUT "${ANDROID_NDK_LAYOUT}" CACHE STRING "The inner layout of NDK" )

mark_as_advanced( ANDROID_NDK_LAYOUT )

if( ANDROID_NDK_LAYOUT STREQUAL "LINARO" )

set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) # only 32-bit at the moment

set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/../../${ANDROID_NDK_HOST_SYSTEM_NAME}/toolchain" )

set( ANDROID_NDK_TOOLCHAINS_SUBPATH "" )

set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "" )

elseif( ANDROID_NDK_LAYOUT STREQUAL "ANDROID" )

set( ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_NDK_HOST_SYSTEM_NAME2} ) # only 32-bit at the moment

set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/../../gcc/${ANDROID_NDK_HOST_SYSTEM_NAME}/arm" )

set( ANDROID_NDK_TOOLCHAINS_SUBPATH "" )

set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "" )

else() # ANDROID_NDK_LAYOUT STREQUAL "RELEASE"

set( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK}/toolchains" )

set( ANDROID_NDK_TOOLCHAINS_SUBPATH "/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME}" )

set( ANDROID_NDK_TOOLCHAINS_SUBPATH2 "/prebuilt/${ANDROID_NDK_HOST_SYSTEM_NAME2}" )

endif()

get_filename_component( ANDROID_NDK_TOOLCHAINS_PATH "${ANDROID_NDK_TOOLCHAINS_PATH}" ABSOLUTE )

# try to detect change of NDK

if( CMAKE_AR )

string( LENGTH "${ANDROID_NDK_TOOLCHAINS_PATH}" __length )

string( SUBSTRING "${CMAKE_AR}" 0 ${__length} __androidNdkPreviousPath )

if( NOT __androidNdkPreviousPath STREQUAL ANDROID_NDK_TOOLCHAINS_PATH )

message( FATAL_ERROR "It is not possible to change the path to the NDK on subsequent CMake run. You must remove all generated files from your build folder first.

" )

endif()

unset( __androidNdkPreviousPath )

unset( __length )

endif()

endif()

# get all the details about standalone toolchain

if( BUILD_WITH_STANDALONE_TOOLCHAIN )

__DETECT_NATIVE_API_LEVEL( ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot/usr/include/android/api-level.h" )

set( ANDROID_STANDALONE_TOOLCHAIN_API_LEVEL ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )

set( __availableToolchains "standalone" )

__DETECT_TOOLCHAIN_MACHINE_NAME( __availableToolchainMachines "${ANDROID_STANDALONE_TOOLCHAIN}" )

if( NOT __availableToolchainMachines )

message( FATAL_ERROR "Could not determine machine name of your toolchain. Probably your Android standalone toolchain is broken." )

endif()

if( __availableToolchainMachines MATCHES i686 )

set( __availableToolchainArchs "x86" )

elseif( __availableToolchainMachines MATCHES arm )

set( __availableToolchainArchs "arm" )

elseif( __availableToolchainMachines MATCHES mipsel )

set( __availableToolchainArchs "mipsel" )

endif()

execute_process( COMMAND "${ANDROID_STANDALONE_TOOLCHAIN}/bin/${__availableToolchainMachines}-gcc${TOOL_OS_SUFFIX}" -dumpversion

OUTPUT_VARIABLE __availableToolchainCompilerVersions OUTPUT_STRIP_TRAILING_WHITESPACE )

string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9]+)?" __availableToolchainCompilerVersions "${__availableToolchainCompilerVersions}" )

if( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/bin/clang${TOOL_OS_SUFFIX}" )

list( APPEND __availableToolchains "standalone-clang" )

list( APPEND __availableToolchainMachines ${__availableToolchainMachines} )

list( APPEND __availableToolchainArchs ${__availableToolchainArchs} )

list( APPEND __availableToolchainCompilerVersions ${__availableToolchainCompilerVersions} )

endif()

endif()

macro( __GLOB_NDK_TOOLCHAINS __availableToolchainsVar __availableToolchainsLst __toolchain_subpath )

foreach( __toolchain ${${__availableToolchainsLst}} )

if( "${__toolchain}" MATCHES "-clang3[.][0-9]$" AND NOT EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/${__toolchain}${__toolchain_subpath}" )

string( REGEX REPLACE "-clang3[.][0-9]$" "-4.6" __gcc_toolchain "${__toolchain}" )

else()

set( __gcc_toolchain "${__toolchain}" )

endif()

__DETECT_TOOLCHAIN_MACHINE_NAME( __machine "${ANDROID_NDK_TOOLCHAINS_PATH}/${__gcc_toolchain}${__toolchain_subpath}" )

if( __machine )

string( REGEX MATCH "[0-9]+[.][0-9]+([.][0-9x]+)?$" __version "${__gcc_toolchain}" )

if( __machine MATCHES i686 )

set( __arch "x86" )

elseif( __machine MATCHES arm )

set( __arch "arm" )

elseif( __machine MATCHES mipsel )

set( __arch "mipsel" )

endif()

list( APPEND __availableToolchainMachines "${__machine}" )

list( APPEND __availableToolchainArchs "${__arch}" )

list( APPEND __availableToolchainCompilerVersions "${__version}" )

list( APPEND ${__availableToolchainsVar} "${__toolchain}" )

endif()

unset( __gcc_toolchain )

endforeach()

endmacro()

# get all the details about NDK

if( BUILD_WITH_ANDROID_NDK )

file( GLOB ANDROID_SUPPORTED_NATIVE_API_LEVELS RELATIVE "${ANDROID_NDK}/platforms" "${ANDROID_NDK}/platforms/android-*" )

string( REPLACE "android-" "" ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_SUPPORTED_NATIVE_API_LEVELS}" )

set( __availableToolchains "" )

set( __availableToolchainMachines "" )

set( __availableToolchainArchs "" )

set( __availableToolchainCompilerVersions "" )

if( ANDROID_TOOLCHAIN_NAME AND EXISTS "${ANDROID_NDK_TOOLCHAINS_PATH}/${ANDROID_TOOLCHAIN_NAME}/" )

# do not go through all toolchains if we know the name

set( __availableToolchainsLst "${ANDROID_TOOLCHAIN_NAME}" )

__GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH}" )

if( NOT __availableToolchains AND NOT ANDROID_NDK_TOOLCHAINS_SUBPATH STREQUAL ANDROID_NDK_TOOLCHAINS_SUBPATH2 )

__GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH2}" )

if( __availableToolchains )

set( ANDROID_NDK_TOOLCHAINS_SUBPATH ${ANDROID_NDK_TOOLCHAINS_SUBPATH2} )

endif()

endif()

endif()

if( NOT __availableToolchains )

file( GLOB __availableToolchainsLst RELATIVE "${ANDROID_NDK_TOOLCHAINS_PATH}" "${ANDROID_NDK_TOOLCHAINS_PATH}/*" )

if( __availableToolchains )

list(SORT __availableToolchainsLst) # we need clang to go after gcc

endif()

__LIST_FILTER( __availableToolchainsLst "^[.]" )

__LIST_FILTER( __availableToolchainsLst "llvm" )

__LIST_FILTER( __availableToolchainsLst "renderscript" )

__GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH}" )

if( NOT __availableToolchains AND NOT ANDROID_NDK_TOOLCHAINS_SUBPATH STREQUAL ANDROID_NDK_TOOLCHAINS_SUBPATH2 )

__GLOB_NDK_TOOLCHAINS( __availableToolchains __availableToolchainsLst "${ANDROID_NDK_TOOLCHAINS_SUBPATH2}" )

if( __availableToolchains )

set( ANDROID_NDK_TOOLCHAINS_SUBPATH ${ANDROID_NDK_TOOLCHAINS_SUBPATH2} )

endif()

endif()

endif()

if( NOT __availableToolchains )

message( FATAL_ERROR "Could not find any working toolchain in the NDK. Probably your Android NDK is broken." )

endif()

endif()

# build list of available ABIs

set( ANDROID_SUPPORTED_ABIS "" )

set( __uniqToolchainArchNames ${__availableToolchainArchs} )

list( REMOVE_DUPLICATES __uniqToolchainArchNames )

list( SORT __uniqToolchainArchNames )

foreach( __arch ${__uniqToolchainArchNames} )

list( APPEND ANDROID_SUPPORTED_ABIS ${ANDROID_SUPPORTED_ABIS_${__arch}} )

endforeach()

unset( __uniqToolchainArchNames )

if( NOT ANDROID_SUPPORTED_ABIS )

message( FATAL_ERROR "No one of known Android ABIs is supported by this cmake toolchain." )

endif()

# choose target ABI

__INIT_VARIABLE( ANDROID_ABI OBSOLETE_ARM_TARGET OBSOLETE_ARM_TARGETS VALUES ${ANDROID_SUPPORTED_ABIS} )

# verify that target ABI is supported

list( FIND ANDROID_SUPPORTED_ABIS "${ANDROID_ABI}" __androidAbiIdx )

if( __androidAbiIdx EQUAL -1 )

string( REPLACE ";" "\", \"" PRINTABLE_ANDROID_SUPPORTED_ABIS "${ANDROID_SUPPORTED_ABIS}" )

message( FATAL_ERROR "Specified ANDROID_ABI = \"${ANDROID_ABI}\" is not supported by this cmake toolchain or your NDK/toolchain.

Supported values are: \"${PRINTABLE_ANDROID_SUPPORTED_ABIS}\"

" )

endif()

unset( __androidAbiIdx )

# set target ABI options

if( ANDROID_ABI STREQUAL "x86" )

set( X86 true )

set( ANDROID_NDK_ABI_NAME "x86" )

set( ANDROID_ARCH_NAME "x86" )

set( ANDROID_ARCH_FULLNAME "x86" )

set( ANDROID_LLVM_TRIPLE "i686-none-linux-android" )

set( CMAKE_SYSTEM_PROCESSOR "i686" )

elseif( ANDROID_ABI STREQUAL "mips" )

set( MIPS true )

set( ANDROID_NDK_ABI_NAME "mips" )

set( ANDROID_ARCH_NAME "mips" )

set( ANDROID_ARCH_FULLNAME "mipsel" )

set( ANDROID_LLVM_TRIPLE "mipsel-none-linux-android" )

set( CMAKE_SYSTEM_PROCESSOR "mips" )

elseif( ANDROID_ABI STREQUAL "armeabi" )

set( ARMEABI true )

set( ANDROID_NDK_ABI_NAME "armeabi" )

set( ANDROID_ARCH_NAME "arm" )

set( ANDROID_ARCH_FULLNAME "arm" )

set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )

set( CMAKE_SYSTEM_PROCESSOR "armv5te" )

elseif( ANDROID_ABI STREQUAL "armeabi-v6" )

set( ARMEABI_V6 true )

set( ANDROID_NDK_ABI_NAME "armeabi" )

set( ANDROID_ARCH_NAME "arm" )

set( ANDROID_ARCH_FULLNAME "arm" )

set( ANDROID_LLVM_TRIPLE "armv5te-none-linux-androideabi" )

set( CMAKE_SYSTEM_PROCESSOR "armv6" )

# need always fallback to older platform

set( ARMEABI true )

elseif( ANDROID_ABI STREQUAL "armeabi-v7a" )

set( ARMEABI_V7A true )

set( ANDROID_NDK_ABI_NAME "armeabi-v7a" )

set( ANDROID_ARCH_NAME "arm" )

set( ANDROID_ARCH_FULLNAME "arm" )

set( ANDROID_LLVM_TRIPLE "armv7-none-linux-androideabi" )

set( CMAKE_SYSTEM_PROCESSOR "armv7-a" )

else()

message( SEND_ERROR "Unknown ANDROID_ABI=\"${ANDROID_ABI}\" is specified." )

endif()

if( CMAKE_BINARY_DIR AND EXISTS "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" )

# really dirty hack

# it is not possible to change CMAKE_SYSTEM_PROCESSOR after the first run...

file( APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake" "SET(CMAKE_SYSTEM_PROCESSOR \"${CMAKE_SYSTEM_PROCESSOR}\")\n" )

endif()

if( ANDROID_ARCH_NAME STREQUAL "arm" AND NOT ARMEABI_V6 )

__INIT_VARIABLE( ANDROID_FORCE_ARM_BUILD OBSOLETE_FORCE_ARM VALUES OFF )

set( ANDROID_FORCE_ARM_BUILD ${ANDROID_FORCE_ARM_BUILD} CACHE BOOL "Use 32-bit ARM instructions instead of Thumb-1" FORCE )

mark_as_advanced( ANDROID_FORCE_ARM_BUILD )

else()

unset( ANDROID_FORCE_ARM_BUILD CACHE )

endif()

# choose toolchain

if( ANDROID_TOOLCHAIN_NAME )

list( FIND __availableToolchains "${ANDROID_TOOLCHAIN_NAME}" __toolchainIdx )

if( __toolchainIdx EQUAL -1 )

list( SORT __availableToolchains )

string( REPLACE ";" "\n * " toolchains_list "${__availableToolchains}" )

set( toolchains_list " * ${toolchains_list}")

message( FATAL_ERROR "Specified toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is missing in your NDK or broken. Please verify that your NDK is working or select another compiler toolchain.

To configure the toolchain set CMake variable ANDROID_TOOLCHAIN_NAME to one of the following values:\n${toolchains_list}\n" )

endif()

list( GET __availableToolchainArchs ${__toolchainIdx} __toolchainArch )

if( NOT __toolchainArch STREQUAL ANDROID_ARCH_FULLNAME )

message( SEND_ERROR "Selected toolchain \"${ANDROID_TOOLCHAIN_NAME}\" is not able to compile binaries for the \"${ANDROID_ARCH_NAME}\" platform." )

endif()

else()

set( __toolchainIdx -1 )

set( __applicableToolchains "" )

set( __toolchainMaxVersion "0.0.0" )

list( LENGTH __availableToolchains __availableToolchainsCount )

math( EXPR __availableToolchainsCount "${__availableToolchainsCount}-1" )

foreach( __idx RANGE ${__availableToolchainsCount} )

list( GET __availableToolchainArchs ${__idx} __toolchainArch )

if( __toolchainArch STREQUAL ANDROID_ARCH_FULLNAME )

list( GET __availableToolchainCompilerVersions ${__idx} __toolchainVersion )

string( REPLACE "x" "99" __toolchainVersion "${__toolchainVersion}")

if( __toolchainVersion VERSION_GREATER __toolchainMaxVersion )

set( __toolchainMaxVersion "${__toolchainVersion}" )

set( __toolchainIdx ${__idx} )

endif()

endif()

endforeach()

unset( __availableToolchainsCount )

unset( __toolchainMaxVersion )

unset( __toolchainVersion )

endif()

unset( __toolchainArch )

if( __toolchainIdx EQUAL -1 )

message( FATAL_ERROR "No one of available compiler toolchains is able to compile for ${ANDROID_ARCH_NAME} platform." )

endif()

list( GET __availableToolchains ${__toolchainIdx} ANDROID_TOOLCHAIN_NAME )

list( GET __availableToolchainMachines ${__toolchainIdx} ANDROID_TOOLCHAIN_MACHINE_NAME )

list( GET __availableToolchainCompilerVersions ${__toolchainIdx} ANDROID_COMPILER_VERSION )

unset( __toolchainIdx )

unset( __availableToolchains )

unset( __availableToolchainMachines )

unset( __availableToolchainArchs )

unset( __availableToolchainCompilerVersions )

# choose native API level

__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 )

string( REGEX MATCH "[0-9]+" ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" )

# adjust API level

set( __real_api_level ${ANDROID_DEFAULT_NDK_API_LEVEL_${ANDROID_ARCH_NAME}} )

foreach( __level ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )

if( NOT __level GREATER ANDROID_NATIVE_API_LEVEL AND NOT __level LESS __real_api_level )

set( __real_api_level ${__level} )

endif()

endforeach()

if( __real_api_level AND NOT ANDROID_NATIVE_API_LEVEL EQUAL __real_api_level )

message( STATUS "Adjusting Android API level 'android-${ANDROID_NATIVE_API_LEVEL}' to 'android-${__real_api_level}'")

set( ANDROID_NATIVE_API_LEVEL ${__real_api_level} )

endif()

unset(__real_api_level)

# validate

list( FIND ANDROID_SUPPORTED_NATIVE_API_LEVELS "${ANDROID_NATIVE_API_LEVEL}" __levelIdx )

if( __levelIdx EQUAL -1 )

message( SEND_ERROR "Specified Android native API level 'android-${ANDROID_NATIVE_API_LEVEL}' is not supported by your NDK/toolchain." )

else()

if( BUILD_WITH_ANDROID_NDK )

__DETECT_NATIVE_API_LEVEL( __realApiLevel "${ANDROID_NDK}/platforms/android-${ANDROID_NATIVE_API_LEVEL}/arch-${ANDROID_ARCH_NAME}/usr/include/android/api-level.h" )

if( NOT __realApiLevel EQUAL ANDROID_NATIVE_API_LEVEL )

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." )

endif()

unset( __realApiLevel )

endif()

set( ANDROID_NATIVE_API_LEVEL "${ANDROID_NATIVE_API_LEVEL}" CACHE STRING "Android API level for native code" FORCE )

if( CMAKE_VERSION VERSION_GREATER "2.8" )

list( SORT ANDROID_SUPPORTED_NATIVE_API_LEVELS )

set_property( CACHE ANDROID_NATIVE_API_LEVEL PROPERTY STRINGS ${ANDROID_SUPPORTED_NATIVE_API_LEVELS} )

endif()

endif()

unset( __levelIdx )

# remember target ABI

set( ANDROID_ABI "${ANDROID_ABI}" CACHE STRING "The target ABI for Android. If arm, then armeabi-v7a is recommended for hardware floating point." FORCE )

if( CMAKE_VERSION VERSION_GREATER "2.8" )

list( SORT ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME} )

set_property( CACHE ANDROID_ABI PROPERTY STRINGS ${ANDROID_SUPPORTED_ABIS_${ANDROID_ARCH_FULLNAME}} )

endif()

# runtime choice (STL, rtti, exceptions)

if( NOT ANDROID_STL )

# honor legacy ANDROID_USE_STLPORT

if( DEFINED ANDROID_USE_STLPORT )

if( ANDROID_USE_STLPORT )

set( ANDROID_STL stlport_static )

endif()

message( WARNING "You are using an obsolete variable ANDROID_USE_STLPORT to select the STL variant. Use -DANDROID_STL=stlport_static instead." )

endif()

if( NOT ANDROID_STL )

set( ANDROID_STL gnustl_static )

endif()

endif()

set( ANDROID_STL "${ANDROID_STL}" CACHE STRING "C++ runtime" )

set( ANDROID_STL_FORCE_FEATURES ON CACHE BOOL "automatically configure rtti and exceptions support based on C++ runtime" )

mark_as_advanced( ANDROID_STL ANDROID_STL_FORCE_FEATURES )

if( BUILD_WITH_ANDROID_NDK )

if( NOT "${ANDROID_STL}" MATCHES "^(none|system|system_re|gabi\\+\\+_static|gabi\\+\\+_shared|stlport_static|stlport_shared|gnustl_static|gnustl_shared)$")

message( FATAL_ERROR "ANDROID_STL is set to invalid value \"${ANDROID_STL}\".

The possible values are:

none -> Do not configure the runtime.

system -> Use the default minimal system C++ runtime library.

system_re -> Same as system but with rtti and exceptions.

gabi++_static -> Use the GAbi++ runtime as a static library.

gabi++_shared -> Use the GAbi++ runtime as a shared library.

stlport_static -> Use the STLport runtime as a static library.

stlport_shared -> Use the STLport runtime as a shared library.

gnustl_static -> (default) Use the GNU STL as a static library.

gnustl_shared -> Use the GNU STL as a shared library.

" )

endif()

elseif( BUILD_WITH_STANDALONE_TOOLCHAIN )

if( NOT "${ANDROID_STL}" MATCHES "^(none|gnustl_static|gnustl_shared)$")

message( FATAL_ERROR "ANDROID_STL is set to invalid value \"${ANDROID_STL}\".

The possible values are:

none -> Do not configure the runtime.

gnustl_static -> (default) Use the GNU STL as a static library.

gnustl_shared -> Use the GNU STL as a shared library.

" )

endif()

endif()

unset( ANDROID_RTTI )

unset( ANDROID_EXCEPTIONS )

unset( ANDROID_STL_INCLUDE_DIRS )

unset( __libstl )

unset( __libsupcxx )

if( NOT _CMAKE_IN_TRY_COMPILE AND X86 AND ANDROID_STL MATCHES "gnustl" AND ANDROID_NDK_RELEASE STREQUAL "r6" )

message( WARNING "The x86 system header file from NDK r6 has incorrect definition for ptrdiff_t. You are recommended to upgrade to a newer NDK release or manually patch the header:

See https://android.googlesource.com/platform/development.git f907f4f9d4e56ccc8093df6fee54454b8bcab6c2

diff --git a/ndk/platforms/android-9/arch-x86/include/machine/_types.h b/ndk/platforms/android-9/arch-x86/include/machine/_types.h

index 5e28c64..65892a1 100644

--- a/ndk/platforms/android-9/arch-x86/include/machine/_types.h

+++ b/ndk/platforms/android-9/arch-x86/include/machine/_types.h

@@ -51,7 +51,11 @@ typedef long int ssize_t;

#endif

#ifndef _PTRDIFF_T

#define _PTRDIFF_T

-typedef long ptrdiff_t;

+# ifdef __ANDROID__

+ typedef int ptrdiff_t;

+# else

+ typedef long ptrdiff_t;

+# endif

#endif

" )

endif()

# setup paths and STL for standalone toolchain

if( BUILD_WITH_STANDALONE_TOOLCHAIN )

set( ANDROID_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )

set( ANDROID_CLANG_TOOLCHAIN_ROOT "${ANDROID_STANDALONE_TOOLCHAIN}" )

set( ANDROID_SYSROOT "${ANDROID_STANDALONE_TOOLCHAIN}/sysroot" )

if( NOT ANDROID_STL STREQUAL "none" )

set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_STANDALONE_TOOLCHAIN}/include/c++/${ANDROID_COMPILER_VERSION}" )

if( NOT EXISTS "${ANDROID_STL_INCLUDE_DIRS}" )

# old location ( pre r8c )

set( ANDROID_STL_INCLUDE_DIRS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/include/c++/${ANDROID_COMPILER_VERSION}" )

endif()

if( ARMEABI_V7A AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}/bits" )

list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/${CMAKE_SYSTEM_PROCESSOR}" )

elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb/bits" )

list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/thumb" )

else()

list( APPEND ANDROID_STL_INCLUDE_DIRS "${ANDROID_STL_INCLUDE_DIRS}/${ANDROID_TOOLCHAIN_MACHINE_NAME}" )

endif()

# always search static GNU STL to get the location of libsupc++.a

if( ARMEABI_V7A AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb/libstdc++.a" )

set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/thumb" )

elseif( ARMEABI_V7A AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libstdc++.a" )

set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}" )

elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libstdc++.a" )

set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb" )

elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libstdc++.a" )

set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib" )

endif()

if( __libstl )

set( __libsupcxx "${__libstl}/libsupc++.a" )

set( __libstl "${__libstl}/libstdc++.a" )

endif()

if( NOT EXISTS "${__libsupcxx}" )

message( FATAL_ERROR "The required libstdsupc++.a is missing in your standalone toolchain.

Usually it happens because of bug in make-standalone-toolchain.sh script from NDK r7, r7b and r7c.

You need to either upgrade to newer NDK or manually copy

$ANDROID_NDK/sources/cxx-stl/gnu-libstdc++/libs/${ANDROID_NDK_ABI_NAME}/libsupc++.a

to

${__libsupcxx}

" )

endif()

if( ANDROID_STL STREQUAL "gnustl_shared" )

if( ARMEABI_V7A AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" )

set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/${CMAKE_SYSTEM_PROCESSOR}/libgnustl_shared.so" )

elseif( ARMEABI AND NOT ANDROID_FORCE_ARM_BUILD AND EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" )

set( __libstl "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/thumb/libgnustl_shared.so" )

elseif( EXISTS "${ANDROID_STANDALONE_TOOLCHAIN}/${ANDROID_TOOLCHAIN_MACHINE_NAME}/lib/libgnustl_shared.so" )