From 732f8cee0a722a4e5c34cc1ab30cf6fad41ca739 Mon Sep 17 00:00:00 2001 From: Andrew Gunnerson Date: Tue, 30 Oct 2018 22:42:15 -0400 Subject: [PATCH] Update to NDK r18b Signed-off-by: Andrew Gunnerson --- CMakeLists.txt | 2 +- cmake/android.toolchain.cmake | 272 +++++++++++++++-------------- docker/common.sh | 2 +- docker/template/Dockerfile.base.in | 4 +- docs/build/Docker.md | 10 +- 5 files changed, 147 insertions(+), 143 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 606e4639a..f8291debc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -53,7 +53,7 @@ if(${MBP_BUILD_TARGET} STREQUAL android-app # file will work with newer versions of the NDK, we'll depend on an exact # version. set(ndk_version_whitelist - r17.0.4754217 + r18.1.5063045 ) if(NOT ANDROID_NDK_RELEASE IN_LIST ndk_version_whitelist) diff --git a/cmake/android.toolchain.cmake b/cmake/android.toolchain.cmake index 45ccfe015..6ef24535c 100644 --- a/cmake/android.toolchain.cmake +++ b/cmake/android.toolchain.cmake @@ -167,30 +167,78 @@ endif() if(NOT ANDROID_TOOLCHAIN) set(ANDROID_TOOLCHAIN clang) elseif(ANDROID_TOOLCHAIN STREQUAL gcc) - message(WARNING - "GCC is deprecated and will be removed in the next release. See " - "https://android.googlesource.com/platform/ndk/+/master/docs/ClangMigration.md.") + message(FATAL_ERROR "GCC is no longer supported. See " + "https://android.googlesource.com/platform/ndk/+/master/docs/ClangMigration.md.") endif() if(NOT ANDROID_ABI) set(ANDROID_ABI armeabi-v7a) endif() -if(ANDROID_PLATFORM MATCHES "^android-([0-9]|1[0-3])$") - message(WARNING "${ANDROID_PLATFORM} is unsupported. Using minimum supported " - "version android-14") - set(ANDROID_PLATFORM android-14) -elseif(ANDROID_PLATFORM STREQUAL android-20) - set(ANDROID_PLATFORM android-19) -elseif(ANDROID_PLATFORM STREQUAL android-25) - set(ANDROID_PLATFORM android-24) -elseif(NOT ANDROID_PLATFORM) - set(ANDROID_PLATFORM android-14) + +if(ANDROID_ABI STREQUAL armeabi) + message(FATAL_ERROR "armeabi is no longer supported. Use armeabi-v7a.") +elseif(ANDROID_ABI MATCHES "^(mips|mips64)$") + message(FATAL_ERROR "MIPS and MIPS64 are no longer supported.") endif() + +include(${ANDROID_NDK}/build/cmake/platforms.cmake) + +# If no platform version was chosen by the user, default to the minimum version +# supported by this NDK. +if(NOT ANDROID_PLATFORM) + message(STATUS "\ +ANDROID_PLATFORM not set. Defaulting to minimum supported version +${NDK_MIN_PLATFORM_LEVEL}.") + + set(ANDROID_PLATFORM "android-${NDK_MIN_PLATFORM_LEVEL}") +endif() + +if(ANDROID_PLATFORM STREQUAL "latest") + message(STATUS + "Using latest available ANDROID_PLATFORM: ${NDK_MAX_PLATFORM_LEVEL}.") + set(ANDROID_PLATFORM "android-${NDK_MAX_PLATFORM_LEVEL}") + string(REPLACE "android-" "" ANDROID_PLATFORM_LEVEL ${ANDROID_PLATFORM}) +endif() + string(REPLACE "android-" "" ANDROID_PLATFORM_LEVEL ${ANDROID_PLATFORM}) + +# Aliases defined by meta/platforms.json include codename aliases for platform +# API levels as well as cover any gaps in platforms that may not have had NDK +# APIs. +if(NOT "${NDK_PLATFORM_ALIAS_${ANDROID_PLATFORM_LEVEL}}" STREQUAL "") + message(STATUS "\ +${ANDROID_PLATFORM} is an alias for \ +${NDK_PLATFORM_ALIAS_${ANDROID_PLATFORM_LEVEL}}. Adjusting ANDROID_PLATFORM to \ +match.") + set(ANDROID_PLATFORM "${NDK_PLATFORM_ALIAS_${ANDROID_PLATFORM_LEVEL}}") + string(REPLACE "android-" "" ANDROID_PLATFORM_LEVEL ${ANDROID_PLATFORM}) +endif() + +# Pull up to the minimum supported version if an old API level was requested. +if(ANDROID_PLATFORM_LEVEL LESS NDK_MIN_PLATFORM_LEVEL) + message(STATUS "\ +${ANDROID_PLATFORM} is unsupported. Using minimum supported version \ +${NDK_MIN_PLATFORM_LEVEL}.") + set(ANDROID_PLATFORM "android-${NDK_MIN_PLATFORM_LEVEL}") + string(REPLACE "android-" "" ANDROID_PLATFORM_LEVEL ${ANDROID_PLATFORM}) +endif() + +# And for LP64 we need to pull up to 21. No diagnostic is provided here because +# minSdkVersion < 21 is valid for the project even though it may not be for this +# ABI. if(ANDROID_ABI MATCHES "64(-v8a)?$" AND ANDROID_PLATFORM_LEVEL LESS 21) set(ANDROID_PLATFORM android-21) set(ANDROID_PLATFORM_LEVEL 21) endif() +# ANDROID_PLATFORM beyond the maximum is an error. The correct way to specify +# the latest version is ANDROID_PLATFORM=latest. +if(ANDROID_PLATFORM_LEVEL GREATER NDK_MAX_PLATFORM_LEVEL) + message(SEND_ERROR "\ +${ANDROID_PLATFORM} is above the maximum supported version \ +${NDK_MAX_PLATFORM_LEVEL}. Choose a supported API level or set \ +ANDROID_PLATFORM to \"latest\".") +endif() + if(NOT ANDROID_STL) set(ANDROID_STL c++_static) endif() @@ -199,24 +247,23 @@ if("${ANDROID_STL}" STREQUAL "gnustl_shared" OR "${ANDROID_STL}" STREQUAL "gnustl_static" OR "${ANDROID_STL}" STREQUAL "stlport_shared" OR "${ANDROID_STL}" STREQUAL "stlport_static") - message(WARNING - "${ANDROID_STL} is deprecated and will be removed in the next release. " - "Please switch to either c++_shared or c++_static. See " - "https://developer.android.com/ndk/guides/cpp-support.html for more " - "information.") + message(FATAL_ERROR "\ +${ANDROID_STL} is no longer supported. Please switch to either c++_shared or \ +c++_static. See https://developer.android.com/ndk/guides/cpp-support.html \ +for more information.") endif() -if(NOT DEFINED ANDROID_PIE) - if(ANDROID_PLATFORM_LEVEL LESS 16) - set(ANDROID_PIE FALSE) - else() - set(ANDROID_PIE TRUE) - endif() -endif() +set(ANDROID_PIE TRUE) if(NOT ANDROID_ARM_MODE) set(ANDROID_ARM_MODE thumb) endif() +if(ANDROID_ABI STREQUAL "armeabi-v7a" AND NOT DEFINED ANDROID_ARM_NEON) + if(NOT ANDROID_PLATFORM_LEVEL LESS 23) + set(ANDROID_ARM_NEON TRUE) + endif() +endif() + # Export configurable variables for the try_compile() command. set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES ANDROID_TOOLCHAIN @@ -288,15 +335,11 @@ elseif(ANDROID_ABI STREQUAL x86_64) set(ANDROID_LLVM_TRIPLE x86_64-none-linux-android) set(ANDROID_HEADER_TRIPLE x86_64-linux-android) else() - set(ANDROID_ABI_ERROR "") - if(ANDROID_ABI STREQUAL armeabi) - set(ANDROID_ABI_ERROR " (armeabi is no longer supported. Use armeabi-v7a.)") - elseif(ANDROID_ABI MATCHES "^(mips|mips64)$") - set(ANDROID_ABI_ERROR " (MIPS and MIPS64 are no longer supported.)") - endif() - message(FATAL_ERROR "Invalid Android ABI: ${ANDROID_ABI}.${ANDROID_ABI_ERROR}") + message(FATAL_ERROR "Invalid Android ABI: ${ANDROID_ABI}.") endif() +set(ANDROID_LLVM_TRIPLE "${ANDROID_LLVM_TRIPLE}${ANDROID_PLATFORM_LEVEL}") + set(ANDROID_COMPILER_FLAGS) set(ANDROID_COMPILER_FLAGS_CXX) set(ANDROID_COMPILER_FLAGS_DEBUG) @@ -316,19 +359,15 @@ set(ANDROID_STL_LDLIBS) if(ANDROID_STL STREQUAL system) set(USE_NOSTDLIBXX FALSE) if(NOT "x${ANDROID_CPP_FEATURES}" STREQUAL "x") - set(ANDROID_STL_STATIC_LIBRARIES supc++) + set(ANDROID_STL_STATIC_LIBRARIES c++abi) + if(ANDROID_PLATFORM_LEVEL LESS 21) + list(APPEND ANDROID_STL_STATIC_LIBRARIES android_support) + endif() + if(ANDROID_ABI STREQUAL armeabi-v7a) + list(APPEND ANDROID_STL_STATIC_LIBRARIES unwind) + list(APPEND ANDROID_STL_LDLIBS dl) + endif() endif() -elseif(ANDROID_STL STREQUAL stlport_static) - set(USE_NOSTDLIBXX FALSE) - set(ANDROID_STL_STATIC_LIBRARIES stlport_static) -elseif(ANDROID_STL STREQUAL stlport_shared) - set(USE_NOSTDLIBXX FALSE) - set(ANDROID_STL_SHARED_LIBRARIES stlport_shared) -elseif(ANDROID_STL STREQUAL gnustl_static) - set(ANDROID_STL_STATIC_LIBRARIES gnustl_static) -elseif(ANDROID_STL STREQUAL gnustl_shared) - set(ANDROID_STL_STATIC_LIBRARIES supc++) - set(ANDROID_STL_SHARED_LIBRARIES gnustl_shared) elseif(ANDROID_STL STREQUAL c++_static) list(APPEND ANDROID_STL_STATIC_LIBRARIES c++_static c++abi) if(ANDROID_PLATFORM_LEVEL LESS 21) @@ -387,8 +426,6 @@ set(CMAKE_SYSROOT_COMPILE "${CMAKE_SYSROOT}") # machine/ are installed to an arch-$ARCH subdirectory of the sysroot. list(APPEND ANDROID_COMPILER_FLAGS "-isystem ${CMAKE_SYSROOT}/usr/include/${ANDROID_HEADER_TRIPLE}") -list(APPEND ANDROID_COMPILER_FLAGS - "-D__ANDROID_API__=${ANDROID_PLATFORM_LEVEL}") # We need different sysroots for linking and compiling, but cmake doesn't # support that. Pass the sysroot flag manually when linking. @@ -426,44 +463,39 @@ endif() set(ANDROID_HOST_PREBUILTS "${ANDROID_NDK}/prebuilt/${ANDROID_HOST_TAG}") -if(ANDROID_TOOLCHAIN STREQUAL clang) - set(ANDROID_LLVM_TOOLCHAIN_PREFIX "${ANDROID_NDK}/toolchains/llvm/prebuilt/${ANDROID_HOST_TAG}/bin/") - set(ANDROID_C_COMPILER "${ANDROID_LLVM_TOOLCHAIN_PREFIX}clang${ANDROID_TOOLCHAIN_SUFFIX}") - set(ANDROID_CXX_COMPILER "${ANDROID_LLVM_TOOLCHAIN_PREFIX}clang++${ANDROID_TOOLCHAIN_SUFFIX}") - set(ANDROID_ASM_COMPILER "${ANDROID_LLVM_TOOLCHAIN_PREFIX}clang${ANDROID_TOOLCHAIN_SUFFIX}") - # Clang can fail to compile if CMake doesn't correctly supply the target and - # external toolchain, but to do so, CMake needs to already know that the - # compiler is clang. Tell CMake that the compiler is really clang, but don't - # use CMakeForceCompiler, since we still want compile checks. We only want - # to skip the compiler ID detection step. - #set(CMAKE_C_COMPILER_ID_RUN TRUE) - #set(CMAKE_CXX_COMPILER_ID_RUN TRUE) - #set(CMAKE_C_COMPILER_ID Clang) - #set(CMAKE_CXX_COMPILER_ID Clang) - #set(CMAKE_C_COMPILER_VERSION 3.8) - #set(CMAKE_CXX_COMPILER_VERSION 3.8) - #set(CMAKE_C_STANDARD_COMPUTED_DEFAULT 11) - #set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT 98) - #set(CMAKE_C_COMPILER_TARGET ${ANDROID_LLVM_TRIPLE}) - #set(CMAKE_CXX_COMPILER_TARGET ${ANDROID_LLVM_TRIPLE}) - #set(CMAKE_ASM_COMPILER_TARGET ${ANDROID_LLVM_TRIPLE}) - #set(CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN "${ANDROID_TOOLCHAIN_ROOT}") - #set(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN "${ANDROID_TOOLCHAIN_ROOT}") - #set(CMAKE_ASM_COMPILER_EXTERNAL_TOOLCHAIN "${ANDROID_TOOLCHAIN_ROOT}") - list(APPEND ANDROID_COMPILER_FLAGS - -target ${ANDROID_LLVM_TRIPLE} - -gcc-toolchain ${ANDROID_TOOLCHAIN_ROOT}) - set(ANDROID_AR "${ANDROID_TOOLCHAIN_PREFIX}ar${ANDROID_TOOLCHAIN_SUFFIX}") - set(ANDROID_RANLIB "${ANDROID_TOOLCHAIN_PREFIX}ranlib${ANDROID_TOOLCHAIN_SUFFIX}") -elseif(ANDROID_TOOLCHAIN STREQUAL gcc) - set(ANDROID_C_COMPILER "${ANDROID_TOOLCHAIN_PREFIX}gcc${ANDROID_TOOLCHAIN_SUFFIX}") - set(ANDROID_CXX_COMPILER "${ANDROID_TOOLCHAIN_PREFIX}g++${ANDROID_TOOLCHAIN_SUFFIX}") - set(ANDROID_ASM_COMPILER "${ANDROID_TOOLCHAIN_PREFIX}gcc${ANDROID_TOOLCHAIN_SUFFIX}") - set(ANDROID_AR "${ANDROID_TOOLCHAIN_PREFIX}gcc-ar${ANDROID_TOOLCHAIN_SUFFIX}") - set(ANDROID_RANLIB "${ANDROID_TOOLCHAIN_PREFIX}gcc-ranlib${ANDROID_TOOLCHAIN_SUFFIX}") -else() - message(FATAL_ERROR "Invalid Android toolchain: ${ANDROID_TOOLCHAIN}.") -endif() +set(ANDROID_LLVM_TOOLCHAIN_PREFIX + "${ANDROID_NDK}/toolchains/llvm/prebuilt/${ANDROID_HOST_TAG}/bin/") +set(ANDROID_C_COMPILER + "${ANDROID_LLVM_TOOLCHAIN_PREFIX}clang${ANDROID_TOOLCHAIN_SUFFIX}") +set(ANDROID_CXX_COMPILER + "${ANDROID_LLVM_TOOLCHAIN_PREFIX}clang++${ANDROID_TOOLCHAIN_SUFFIX}") +set(ANDROID_ASM_COMPILER + "${ANDROID_LLVM_TOOLCHAIN_PREFIX}clang${ANDROID_TOOLCHAIN_SUFFIX}") +# Clang can fail to compile if CMake doesn't correctly supply the target and +# external toolchain, but to do so, CMake needs to already know that the +# compiler is clang. Tell CMake that the compiler is really clang, but don't +# use CMakeForceCompiler, since we still want compile checks. We only want +# to skip the compiler ID detection step. +#set(CMAKE_C_COMPILER_ID_RUN TRUE) +#set(CMAKE_CXX_COMPILER_ID_RUN TRUE) +#set(CMAKE_C_COMPILER_ID Clang) +#set(CMAKE_CXX_COMPILER_ID Clang) +#set(CMAKE_C_COMPILER_VERSION 7.0) +#set(CMAKE_CXX_COMPILER_VERSION 7.0) +#set(CMAKE_C_STANDARD_COMPUTED_DEFAULT 11) +#set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT 98) +#set(CMAKE_C_COMPILER_TARGET ${ANDROID_LLVM_TRIPLE}) +#set(CMAKE_CXX_COMPILER_TARGET ${ANDROID_LLVM_TRIPLE}) +#set(CMAKE_ASM_COMPILER_TARGET ${ANDROID_LLVM_TRIPLE}) +#set(CMAKE_C_COMPILER_EXTERNAL_TOOLCHAIN "${ANDROID_TOOLCHAIN_ROOT}") +#set(CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN "${ANDROID_TOOLCHAIN_ROOT}") +#set(CMAKE_ASM_COMPILER_EXTERNAL_TOOLCHAIN "${ANDROID_TOOLCHAIN_ROOT}") +list(APPEND ANDROID_COMPILER_FLAGS + -target ${ANDROID_LLVM_TRIPLE} + -gcc-toolchain ${ANDROID_TOOLCHAIN_ROOT}) +set(ANDROID_AR "${ANDROID_TOOLCHAIN_PREFIX}ar${ANDROID_TOOLCHAIN_SUFFIX}") +set(ANDROID_RANLIB + "${ANDROID_TOOLCHAIN_PREFIX}ranlib${ANDROID_TOOLCHAIN_SUFFIX}") if(NOT IS_DIRECTORY "${ANDROID_NDK}/platforms/${ANDROID_PLATFORM}") message(FATAL_ERROR "Invalid Android platform: ${ANDROID_PLATFORM}.") @@ -489,8 +521,8 @@ list(APPEND ANDROID_LINKER_FLAGS_EXE # Debug and release flags. list(APPEND ANDROID_COMPILER_FLAGS_DEBUG -O0) -if(ANDROID_ABI MATCHES "^armeabi") - list(APPEND ANDROID_COMPILER_FLAGS_RELEASE -Os) +if(ANDROID_ABI MATCHES "^armeabi" AND ANDROID_ARM_MODE STREQUAL thumb) + list(APPEND ANDROID_COMPILER_FLAGS_RELEASE -Oz) else() list(APPEND ANDROID_COMPILER_FLAGS_RELEASE -O2) endif() @@ -514,16 +546,7 @@ if(ANDROID_ABI STREQUAL armeabi-v7a) list(APPEND ANDROID_LINKER_FLAGS -Wl,--fix-cortex-a8) endif() -if(ANDROID_ABI STREQUAL mips) - list(APPEND ANDROID_COMPILER_FLAGS - -mips32) -endif() -if(ANDROID_ABI STREQUAL mips AND ANDROID_TOOLCHAIN STREQUAL clang) - # Help clang use mips64el multilib GCC - list(APPEND ANDROID_LINKER_FLAGS - "\"-L${ANDROID_TOOLCHAIN_ROOT}/lib/gcc/${ANDROID_TOOLCHAIN_NAME}/4.9.x/32/mips-r1\"") -endif() -if(ANDROID_ABI STREQUAL x86) +if(ANDROID_ABI STREQUAL x86 AND ANDROID_PLATFORM_LEVEL LESS 24) # http://b.android.com/222239 # http://b.android.com/220159 (internal http://b/31809417) # x86 devices have stack alignment issues. @@ -531,51 +554,43 @@ if(ANDROID_ABI STREQUAL x86) endif() # STL specific flags. +set(ANDROID_STL_PATH "${ANDROID_NDK}/sources/cxx-stl/llvm-libc++") if(ANDROID_STL STREQUAL system) - set(ANDROID_STL_PREFIX gnu-libstdc++/4.9) set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES "${ANDROID_NDK}/sources/cxx-stl/system/include") -elseif(ANDROID_STL MATCHES "^stlport_") - set(ANDROID_STL_PREFIX stlport) - set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES - "${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/stlport" - "${ANDROID_NDK}/sources/cxx-stl/gabi++/include") -elseif(ANDROID_STL MATCHES "^gnustl_") - set(ANDROID_STL_PREFIX gnu-libstdc++/4.9) - set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES - "${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/include" - "${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/libs/${ANDROID_ABI}/include" - "${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/include/backward") elseif(ANDROID_STL MATCHES "^c\\+\\+_") - set(ANDROID_STL_PREFIX llvm-libc++) if(ANDROID_ABI MATCHES "^armeabi") list(APPEND ANDROID_LINKER_FLAGS -Wl,--exclude-libs,libunwind.a) endif() - list(APPEND ANDROID_COMPILER_FLAGS_CXX - -std=c++11) - if(ANDROID_TOOLCHAIN STREQUAL gcc) - list(APPEND ANDROID_COMPILER_FLAGS_CXX - -fno-strict-aliasing) - endif() + + list(APPEND ANDROID_COMPILER_FLAGS_CXX -std=c++11) # Add the libc++ lib directory to the path so the linker scripts can pick up # the extra libraries. list(APPEND ANDROID_LINKER_FLAGS - "-L${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/libs/${ANDROID_ABI}") + "-L${ANDROID_STL_PATH}/libs/${ANDROID_ABI}") + + set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES "${ANDROID_STL_PATH}/include") + + if(ANDROID_PLATFORM_LEVEL LESS 21) + set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES + "${CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES}" + "${ANDROID_NDK}/sources/android/support/include") + endif() set(CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES - "${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/include" - "${ANDROID_NDK}/sources/android/support/include" - "${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}abi/include") + "${CMAKE_CXX_STANDARD_INCLUDE_DIRECTORIES}" + "${ANDROID_STL_PATH}abi/include") endif() + set(ANDROID_CXX_STANDARD_LIBRARIES) foreach(library ${ANDROID_STL_STATIC_LIBRARIES}) list(APPEND ANDROID_CXX_STANDARD_LIBRARIES - "${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/libs/${ANDROID_ABI}/lib${library}.a") + "${ANDROID_STL_PATH}/libs/${ANDROID_ABI}/lib${library}.a") endforeach() foreach(library ${ANDROID_STL_SHARED_LIBRARIES}) list(APPEND ANDROID_CXX_STANDARD_LIBRARIES - "${ANDROID_NDK}/sources/cxx-stl/${ANDROID_STL_PREFIX}/libs/${ANDROID_ABI}/lib${library}.so") + "${ANDROID_STL_PATH}/libs/${ANDROID_ABI}/lib${library}.so") endforeach() foreach(library ${ANDROID_STL_LDLIBS}) list(APPEND ANDROID_CXX_STANDARD_LIBRARIES "-l${library}") @@ -774,9 +789,7 @@ else() endif() set(ANDROID_NDK_HOST_X64 TRUE) set(ANDROID_NDK_LAYOUT RELEASE) -if(ANDROID_ABI STREQUAL armeabi) - set(ARMEABI TRUE) -elseif(ANDROID_ABI STREQUAL armeabi-v7a) +if(ANDROID_ABI STREQUAL armeabi-v7a) set(ARMEABI_V7A TRUE) if(ANDROID_ARM_NEON) set(NEON TRUE) @@ -787,10 +800,6 @@ elseif(ANDROID_ABI STREQUAL x86) set(X86 TRUE) elseif(ANDROID_ABI STREQUAL x86_64) set(X86_64 TRUE) -elseif(ANDROID_ABI STREQUAL mips) - set(MIPS TRUE) -elseif(ANDROID_ABI STREQUAL mips64) - set(MIPS64 TRUE) endif() set(ANDROID_NDK_HOST_SYSTEM_NAME ${ANDROID_HOST_TAG}) set(ANDROID_NDK_ABI_NAME ${ANDROID_ABI}) @@ -805,12 +814,7 @@ endif() # CMake 3.7+ compatibility. if (CMAKE_VERSION VERSION_GREATER 3.7.0) set(CMAKE_ANDROID_NDK ${ANDROID_NDK}) - - if(ANDROID_TOOLCHAIN STREQUAL gcc) - set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION 4.9) - else() - set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION clang) - endif() + set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION clang) set(CMAKE_ANDROID_STL_TYPE ${ANDROID_STL}) diff --git a/docker/common.sh b/docker/common.sh index 7f226deec..94b65bea8 100644 --- a/docker/common.sh +++ b/docker/common.sh @@ -1,3 +1,3 @@ repo=chenxiaolong/dualbootpatcher version=9.3.0 -release=6 +release=7 diff --git a/docker/template/Dockerfile.base.in b/docker/template/Dockerfile.base.in index 5d2b51bed..be55d7789 100644 --- a/docker/template/Dockerfile.base.in +++ b/docker/template/Dockerfile.base.in @@ -45,8 +45,8 @@ RUN dnf -y install gnupg \ && dnf clean all # Install Android NDK -ARG ANDROID_NDK_VERSION=r17 -ARG ANDROID_NDK_CHECKSUM=1d886a64483adf3f3a3e3aaf7ac5084184006ac7 +ARG ANDROID_NDK_VERSION=r18b +ARG ANDROID_NDK_CHECKSUM=500679655da3a86aecf67007e8ab230ea9b4dd7b ENV ANDROID_NDK_HOME /opt/android-ndk ENV ANDROID_NDK ${ANDROID_NDK_HOME} diff --git a/docs/build/Docker.md b/docs/build/Docker.md index 56bc7130e..4dc44426d 100644 --- a/docs/build/Docker.md +++ b/docs/build/Docker.md @@ -26,10 +26,10 @@ Note that building the docker images will take a long time and consume a lot of Once the images have been built, the resulting image tags are written to `docker/generated/images.properties`. It will look something like the following: ```dosini -android=chenxiaolong/dualbootpatcher:9.3.0-6-android -base=chenxiaolong/dualbootpatcher:9.3.0-6-base -linux=chenxiaolong/dualbootpatcher:9.3.0-6-linux -mingw=chenxiaolong/dualbootpatcher:9.3.0-6-mingw +android=chenxiaolong/dualbootpatcher:9.3.0-7-android +base=chenxiaolong/dualbootpatcher:9.3.0-7-base +linux=chenxiaolong/dualbootpatcher:9.3.0-7-linux +mingw=chenxiaolong/dualbootpatcher:9.3.0-7-mingw ``` The following table describes the images that are built: @@ -54,7 +54,7 @@ docker run --rm -it \ -v "${HOME}/.android:/builder/.android:rw,z" \ -v "${HOME}/.ccache:/builder/.ccache:rw,z" \ -v "${HOME}/.gradle:/builder/.gradle:rw,z" \ - chenxiaolong/dualbootpatcher:9.3.0-6-android \ + chenxiaolong/dualbootpatcher:9.3.0-7-android \ bash ```