Merge pull request #34 from leapmotion/fix-android

Fix android toolchain & arm platform matching.

Author: James Donald

standard/StandardProject.cmake

@@ -16,27 +16,37 @@ does the following:
 
 include(CMakeParseArguments) # Backwards compatibility
 
-# This must be a macro since project defines scope-local variables
-# that we generally rely on being in the root context.
 # IMPORTANT: Note that if there is no *direct* call to 'project' in the root CMakeLists.txt
 # file, CMake will automatically inject one with the default languages of C and CXX.
 # This will cause the toolchain file to be parsed multiple times, and will
 # make much of the work done in standard_project_preinit useless.
 macro(standard_project project_name)
-  cmake_parse_arguments(standard "" "VERSION" "LANGUAGES" ${ARGN})
+  message(AUTHOR_WARNING "Standard_project has been replaced by an override of project.")
+  project(${ARGV})
+endmacro()
 
-  if(NOT standard_VERSION)
-    message(FATAL_ERROR "Standard compliant projects must specify a version")
-  endif()
+if(NOT DEFINED standard_project_OVERRIDE)
+  set(standard_project_OVERRIDE ON)
+endif()
 
-  set(_language_arg "")
-  if(standard_LANGUAGES)
-    set(_language_arg LANGUAGES ${standard_LANGUAGES})
-  endif()
+# This must be a macro since project defines scope-local variables
+# that we generally rely on being in the root context.
+macro(project project_name)
+  if(standard_project_OVERRIDE)
+    cmake_parse_arguments(standard "" "VERSION" "" ${ARGN})
+
+    if(NOT standard_VERSION)
+      message(FATAL_ERROR "Standard compliant projects must specify a version")
+    endif()
+
+    standard_project_preinit()
+    _project(${project_name} VERSION ${standard_VERSION} ${standard_UNPARSED_ARGUMENTS})
+    standard_project_postinit()
 
-  standard_project_preinit()
-  project(${project_name} VERSION ${standard_VERSION} ${_language_arg})
-  standard_project_postinit()
+    set(standard_project_OVERRIDE OFF) #we generally only want to modify the root project.
+  else()
+    _project(${ARGV})
+  endif()
 endmacro()
 
 function(standard_project_preinit)
@@ -48,30 +58,28 @@ function(standard_project_preinit)
     else()
       # Build Fat binaries on OSX by default
       set(CMAKE_OSX_ARCHITECTURES "x86_64;i386" CACHE STRING "Mac OS X build architectures" FORCE)
+      if(NOT CMAKE_OSX_SYSROOT)
+        # CLANG_VERSION requires a sysroot to obtain, so resort to execute_process() here
+        execute_process(COMMAND clang -v ERROR_VARIABLE _clang_version)
+        if(_clang_version MATCHES "clang-7")
+          set(_developer_sdk_version 10.11)
+        elseif(_clang_version MATCHES "clang-8")
+          set(_developer_sdk_version 10.12)
+        endif()
+        if(_developer_sdk_version)
+          set(CMAKE_OSX_SYSROOT "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX${_developer_sdk_version}.sdk" CACHE STRING "Mac OS X build environment" FORCE)
+          if(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
+            set(CMAKE_OSX_DEPLOYMENT_TARGET "10.10" CACHE STRING "Mac OS X deployment target" FORCE)
+          endif()
+        endif()
+      endif()
     endif()
   endif()
 
   if(NOT MSVC AND NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release." FORCE)
   endif()
 
-  if(APPLE AND NOT (CMAKE_SYSTEM_PROCESSOR STREQUAL "arm"))
-    if(NOT CMAKE_OSX_SYSROOT)
-      # CLANG_VERSION requires a sysroot to obtain, so resort to execute_process() here
-      execute_process(COMMAND clang -v ERROR_VARIABLE _clang_version)
-      if(_clang_version MATCHES "clang-7")
-        set(_developer_sdk_version 10.11)
-      elseif(_clang_version MATCHES "clang-8")
-        set(_developer_sdk_version 10.12)
-      endif()
-      if(_developer_sdk_version)
-        set(CMAKE_OSX_SYSROOT "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX${_developer_sdk_version}.sdk" CACHE STRING "Mac OS X build environment" FORCE)
-        if(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
-          set(CMAKE_OSX_DEPLOYMENT_TARGET "10.10" CACHE STRING "Mac OS X deployment target" FORCE)
-        endif()
-      endif()
-    endif()
-  endif()
 endfunction()
 
 function(standard_project_postinit)
@@ -122,19 +130,16 @@ function(standard_project_postinit)
   # CMAKE_SYSTEM_PROCESSOR is set by the toolchain, so must happen strictly after project()
   if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" OR CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
     set(standard_BUILD_ARCHITECTURES "aarch64" PARENT_SCOPE)
-    set(standard_BUILD_64 ON PARENT_SCOPE)
-  elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm")
+  elseif(CMAKE_SYSTEM_NAME MATCHES "Android")
+    set(standard_BUILD_ARCHITECTURES "${CMAKE_ANDROID_ARCH_ABI}" PARENT_SCOPE) #prevent mixing armeabi & armeabi-v7a
+  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm")
     set(standard_BUILD_ARCHITECTURES "arm" PARENT_SCOPE)
-    set(standard_BUILD_64 OFF PARENT_SCOPE)
   elseif(CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64;i386")
     set(standard_BUILD_ARCHITECTURES x64 x86 PARENT_SCOPE)
-    set(standard_BUILD_64 ON PARENT_SCOPE)
   elseif(CMAKE_SIZEOF_VOID_P STREQUAL 4)
     set(standard_BUILD_ARCHITECTURES "x86" PARENT_SCOPE)
-    set(standard_BUILD_64 OFF PARENT_SCOPE)
   else()
     set(standard_BUILD_ARCHITECTURES "x64" PARENT_SCOPE)
-    set(standard_BUILD_64 ON PARENT_SCOPE)
   endif()
   message(STATUS "Using architecture: ${standard_BUILD_ARCHITECTURES}")
 

standard/standard-configVersion.cmake.in

@@ -5,28 +5,22 @@ if(@ARG_NAME@_DEBUG)
   message(STATUS "Installed @ARG_NAME@_VERSION: ${PACKAGE_VERSION}")
 
   message(STATUS "Installed @ARG_NAME@_BUILD_ARCHITECTURES: @standard_BUILD_ARCHITECTURES@")
-    message(STATUS "Configured @ARG_NAME@_BUILD_ARCHITECTURES: ${@ARG_NAME@_BUILD_ARCHITECTURES}")
+  message(STATUS "Configured @ARG_NAME@_BUILD_ARCHITECTURES: ${@ARG_NAME@_BUILD_ARCHITECTURES}")
 
   message(STATUS "Installed CMAKE_SIZEOF_VOID_P: @CMAKE_SIZEOF_VOID_P@")
   message(STATUS "Configured CMAKE_SIZEOF_VOID_P: ${CMAKE_SIZEOF_VOID_P}")
 endif()
 
 # If the customer has an override architecture requirement, use that
 if(DEFINED @ARG_NAME@_ARCHITECTURE)
-  foreach(i IN LISTS @ARG_NAME@_ARCHITECTURE)
-    string(REGEX MATCH "amd64|x86_64|x64" @ARG_NAME@_is_x64 ${i})
-    string(REGEX MATCH "i386|x86" @ARG_NAME@_is_x86 ${i})
-    string(REGEX MATCH "arm$" @ARG_NAME@_is_arm ${i})
-    string(REGEX MATCH "arm64|aarch64" @ARG_NAME@_is_aarch64 ${i})
-
-    # Classify
-    if(@ARG_NAME@_is_x86)
-      list(APPEND @ARG_NAME@_ARCHITECTURES x86)
-    elseif(@ARG_NAME@_is_x64)
+  foreach(_arch IN LISTS @ARG_NAME@_ARCHITECTURE)
+    if(_arch MATCHES "amd64|x86_64|x64")
       list(APPEND @ARG_NAME@_ARCHITECTURES x64)
-    elseif(@ARG_NAME@_is_arm)
+    elseif(_arch MATCHES "i386|x86")
+      list(APPEND @ARG_NAME@_ARCHITECTURES x86)
+    elseif(_arch MATCHES "arm$")
       list(APPEND @ARG_NAME@_ARCHITECTURES arm)
-    elseif(@ARG_NAME@_is_aarch64)
+    elseif(_arch MATCHES "arm64|aarch64")
       list(APPEND @ARG_NAME@_ARCHITECTURES aarch64)
     else()
       message(WARNING "Unrecognized architecture ${i}")
@@ -36,7 +30,9 @@ else()
   # Try to infer what the user wants
   if(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64" OR CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
     set(@ARG_NAME@_ARCHITECTURES aarch64)
-  elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm")
+  elseif(CMAKE_SYSTEM_NAME MATCHES "Android")
+    set(@ARG_NAME@_ARCHITECTURES "${CMAKE_ANDROID_ARCH_ABI}") #prevent mixing armeabi & armeabi-v7a
+  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm")
     set(@ARG_NAME@_ARCHITECTURES arm)
   elseif(CMAKE_SIZEOF_VOID_P EQUAL "8")
     set(@ARG_NAME@_ARCHITECTURES x64)

standard/toolchain-android.cmake

@@ -1,31 +1,12 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_VERSION 1)
-
-# Deal with weirdnesses caused by our standard_project setup. See
-# notes in StandardProject.cmake
-if(NOT LLVM_ANDROID_TOOLCHAIN_DIR)
-  set(LLVM_ANDROID_TOOLCHAIN_DIR $ENV{LLVM_ANDROID_TOOLCHAIN_DIR})
-else()
-  set(ENV{LLVM_ANDROID_TOOLCHAIN_DIR} ${LLVM_ANDROID_TOOLCHAIN_DIR} CACHE PATH)
-endif()
-
-find_path(ANDROID_NDK_ROOT bin/${ANDROID_NDK_TOOL_PREFIX}-gcc${_exe_suffix} PATHS
-  ${LLVM_ANDROID_TOOLCHAIN_DIR}${_ndk_suffix} # legacy variable
-  /opt/android-standalone-toolchain${_ndk_suffix}
-  ${LLVM_ANDROID_TOOLCHAIN_DIR}
+set(CMAKE_SYSTEM_NAME Android)
+set(CMAKE_SYSTEM_VERSION 21)
+find_path(CMAKE_ANDROID_STANDALONE_TOOLCHAIN sysroot/usr/lib/libandroid.so PATHS
   /opt/android-standalone-toolchain
 )
-if(NOT ANDROID_NDK_ROOT)
-  message(FATAL_ERROR "ANDROID_NDK_ROOT could not be located. Have you installed the NDK?")
+if(NOT CMAKE_ANDROID_STANDALONE_TOOLCHAIN)
+  message(FATAL_ERROR "CMAKE_ANDROID_STANDALONE_TOOLCHAIN could not be located. Have you installed the NDK?")
 endif()
 
-set(ANDROID_COMMON_FLAGS " --sysroot=${ANDROID_NDK_ROOT}/sysroot -B${ANDROID_NDK_ROOT} -pie ")
-set(CMAKE_C_COMPILER ${ANDROID_NDK_ROOT}/bin/${ANDROID_NDK_TOOL_PREFIX}-gcc${_exe_suffix} CACHE FILEPATH "C Compiler" FORCE)
-set(CMAKE_CXX_COMPILER ${ANDROID_NDK_ROOT}/bin/${ANDROID_NDK_TOOL_PREFIX}-g++${_exe_suffix} CACHE FILEPATH "C++ Compiler" FORCE)
-set(ANDROID_STRIP_COMMAND ${ANDROID_NDK_ROOT}/bin/${ANDROID_NDK_TOOL_PREFIX}-strip)
-set(CMAKE_C_FLAGS "${ANDROID_COMMON_FLAGS}" CACHE STRING "toolchain_cflags" FORCE)
-set(CMAKE_CXX_FLAGS "${ANDROID_COMMON_FLAGS}" CACHE STRING "toolchain_cxxflags" FORCE)
-set(CMAKE_LINK_FLAGS "${ANDROID_COMMON_FLAGS}" CACHE STRING "toolchain_linkflags" FORCE)
 set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

standard/toolchain-android32.cmake

@@ -1,4 +1,4 @@
-set(ARM_TARGET "armeabi-v7a")
-set(ANDROID_NDK_TOOL_PREFIX arm-linux-androideabi)
-set(CMAKE_SYSTEM_PROCESSOR arm)
+if(NOT DEFINED CMAKE_ANDROID_ARCH_ABI)
+  set(CMAKE_ANDROID_ARCH_ABI armeabi)
+endif()
 include(${CMAKE_CURRENT_LIST_DIR}/toolchain-android.cmake)

standard/toolchain-android64.cmake

@@ -1,4 +1,3 @@
-set(ANDROID_NDK_TOOL_PREFIX aarch64-linux-android)
-set(_ndk_suffix -4.9-aarch64)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
+set(CMAKE_ANDROID_ARCH_ABI arm64-v8a)
 include(${CMAKE_CURRENT_LIST_DIR}/toolchain-android.cmake)
+