Introduce new dependency: aws-crt-cpp

Using git submodule as a new approach to consume AWS common runtime libraries.
aws-crt-cpp (https://github.com/awslabs/aws-crt-cpp) is C++ wrapper around the aws-c-* libraries, which includes aws-c-event-stream, aws-c-auth, aws-c-http and so on.

Author: wps132230

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "aws-common-runtime/aws-crt-cpp"]
+	path = crt/aws-crt-cpp
+	url = https://github.com/awslabs/aws-crt-cpp.git

CI/install-test/CMakeLists.txt

@@ -3,5 +3,13 @@ set(CMAKE_CXX_STANDARD 11)
 project(app LANGUAGES CXX)
 find_package(AWSSDK REQUIRED COMPONENTS s3)
 add_executable(${PROJECT_NAME} "main.cpp")
+if(MSVC AND BUILD_SHARED_LIBS)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC "USE_IMPORT_EXPORT")
+    add_definitions(-DUSE_IMPORT_EXPORT)
+    # Copy relevant AWS SDK for C++ libraries into the current binary directory for running and debugging.
+    list(APPEND SERVICE_LIST s3)
+    AWSSDK_CPY_DYN_LIBS(SERVICE_LIST "" ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE})
+endif()
+set_compiler_flags(${PROJECT_NAME})
+set_compiler_warnings(${PROJECT_NAME})
 target_link_libraries(${PROJECT_NAME} ${AWSSDK_LINK_LIBRARIES})
-target_compile_options(${PROJECT_NAME} PRIVATE "-Wall" "-Werror")

CI/install-test/main.cpp

@@ -5,7 +5,7 @@
 
 using namespace Aws;
 
-int main(int argc, char *argv[])
+int main()
 {
     SDKOptions options;
     options.loggingOptions.logLevel = Utils::Logging::LogLevel::Warn;

CI/trebuchet-release-pipeline/buildspec_regenerate_code.yml

@@ -4,7 +4,7 @@ phases:
   build:
     commands:
       - echo $CODEBUILD_SOURCE_VERSION
-      - git clone https://${GIT_USERNAME}:${GIT_PASSWORD}@github.com/${GITHUB_PRIVATE_REPOSITORY}.git aws-sdk-cpp
+      - git clone --recurse-submodules https://${GIT_USERNAME}:${GIT_PASSWORD}@github.com/${GITHUB_PRIVATE_REPOSITORY}.git aws-sdk-cpp
       - export RELEASE_ID=$(cat $RELEASE_ID_FILENAME)
       - python3 aws-sdk-cpp/CI/trebuchet-release-pipeline/UpdateStatus.py -s RegenerateCode -i "$RELEASE_ID" -m "Step 1 of 4. Regenerating Code with New Models." -b $CODEBUILD_BUILD_SUCCEEDING
       - cp models/*.normal.json aws-sdk-cpp/code-generation/api-descriptions/

CMakeLists.txt

@@ -18,19 +18,18 @@ endif()
 if(POLICY CMP0057)
     cmake_policy(SET CMP0057 NEW) # support IN_LIST
 endif()
+if (POLICY CMP0077)
+    cmake_policy(SET CMP0077 OLD) # Enable options to get their values from normal variables
+endif()
 
-
-# 3.0 or higher is strongly suggested; build settings (target_compile_options/etc...) sometimes do not get propagated properly under certain conditions prior to this version
+# 3.12 or higher is strongly suggested; build settings (target_compile_options/etc...) sometimes do not get propagated properly under certain conditions prior to this version
 # Making this a hard requirement is potentially disruptive to existing customers who aren't affected by the bad behavior though, so just warn for now
-if(CMAKE_MAJOR_VERSION LESS 3)
-    message(WARNING "Building with CMake 3.0 or higher is strongly suggested; current version is ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION}")
+if(CMAKE_VERSION VERSION_LESS 3.12)
+    message(WARNING "Building with CMake 3.12 or higher is strongly suggested; current version is ${CMAKE_VERSION}")
 endif()
 
 get_filename_component(AWS_NATIVE_SDK_ROOT "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE)
 
-# git is required for Android builds and building third-party dependencies
-find_package(Git)
-
 # Cmake invocation variables:
 #   CUSTOM_MEMORY_MANAGEMENT - if set to ON, generates the sdk project files with custom memory management enabled, otherwise disables it
 #   BUILD_ONLY - only build project identified by this variable, a semi-colon delimited list, if this is set we will build only the projects listed. Core will always be built as will its unit tests.
@@ -71,10 +70,7 @@ option(ENABLE_VIRTUAL_OPERATIONS "This option usually works with REGENERATE_CLIE
 
 set(BUILD_ONLY "" CACHE STRING "A semi-colon delimited list of the projects to build")
 set(CPP_STANDARD "11" CACHE STRING "Flag to upgrade the C++ standard used. The default is 11. The minimum is 11.")
-
-if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release)
-endif()
+set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Release build by default.")
 
 #From https://stackoverflow.com/questions/18968979/how-to-get-colorized-output-with-cmake
 if(NOT WIN32)
@@ -109,10 +105,27 @@ endif()
 
 set(PYTHON_CMD "python")
 
+if (UNIX AND NOT APPLE)
+    include(GNUInstallDirs)
+elseif(NOT DEFINED CMAKE_INSTALL_LIBDIR)
+    set(CMAKE_INSTALL_LIBDIR "lib")
+endif()
+
+if (DEFINED CMAKE_PREFIX_PATH)
+    file(TO_CMAKE_PATH "${CMAKE_PREFIX_PATH}" CMAKE_PREFIX_PATH)
+endif()
+
+if (DEFINED CMAKE_INSTALL_PREFIX)
+    file(TO_CMAKE_PATH "${CMAKE_INSTALL_PREFIX}" CMAKE_INSTALL_PREFIX)
+endif()
+
 # CMAKE_MODULE_PATH is a CMAKE variable. It contains a list of paths
 # which could be used to search CMAKE modules by "include()" or "find_package()", but the default value is empty.
-# Add cmake dir to search list
+# Add ${CMAKE_INSTALL_LIBDIR}/cmake and ${CMAKE_PREFIX_PATH}/lib/cmake to search list
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
+set(AWS_MODULE_DIR "/${CMAKE_INSTALL_LIBDIR}/cmake")
+string(REPLACE ";" "${AWS_MODULE_DIR};" AWS_MODULE_PATH "${CMAKE_PREFIX_PATH}${AWS_MODULE_DIR}")
+list(APPEND CMAKE_MODULE_PATH ${AWS_MODULE_PATH})
 
 # include() will "load and run" cmake script
 include(resolve_platform)
@@ -144,90 +157,6 @@ endif()
 # Add Linker search paths to RPATH so as to fix the problem where some linkers can't find cross-compiled dependent libraries in customer paths when linking executables.
 set(CMAKE_INSTALL_RPATH_USE_LINK_PATH true)
 
-# build third-party targets
-if (BUILD_DEPS)
-    # If building third party dependencies, we will move them to the same directory where SDK has been installed during installation.
-    # Therefore, we should set rpath to $ORIGIN to let SDK find these third party dependencies.
-    # Otherwise, customers are responsible for handling the linkage to these libraries.
-    set(CMAKE_INSTALL_RPATH "$ORIGIN")
-    set(AWS_DEPS_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/.deps)
-    if (NOT DEFINED AWS_DEPS_INSTALL_DIR)
-        if (DEFINED CMAKE_INSTALL_PREFIX)
-            set(AWS_DEPS_INSTALL_DIR ${CMAKE_INSTALL_PREFIX} CACHE STRING "A string describes the path where 3rd-party dependencies will be or have been installed")
-        else()
-            set(AWS_DEPS_INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/.deps/install CACHE STRING "A string describes the path where 3rd-party dependencies will be or have been installed")
-        endif()
-    endif()
-    if (NOT CMAKE_GENERATOR_PLATFORM STREQUAL "")
-        set(GEN_PLATFORM_ARG "-A${CMAKE_GENERATOR_PLATFORM}")
-    endif()
-    file(MAKE_DIRECTORY ${AWS_DEPS_BUILD_DIR})
-    if(TARGET_ARCH STREQUAL "ANDROID")
-        execute_process(
-            COMMAND ${CMAKE_COMMAND} -G ${CMAKE_GENERATOR}
-            -DTARGET_ARCH=${TARGET_ARCH}
-            -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-            -DCMAKE_ANDROID_NDK_TOOLCHAIN_VERSION=${CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION}
-            -DANDROID_NATIVE_API_LEVEL=${ANDROID_NATIVE_API_LEVEL}
-            -DANDROID_ABI=${ANDROID_ABI}
-            -DANDROID_TOOLCHAIN=${ANDROID_TOOLCHAIN}
-            -DANDROID_STL=${ANDROID_STL}
-            -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-            -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}
-            -DCMAKE_INSTALL_PREFIX=${AWS_DEPS_INSTALL_DIR}
-            -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
-            ${GEN_PLATFORM_ARG}
-            ${CMAKE_CURRENT_SOURCE_DIR}/third-party
-            WORKING_DIRECTORY ${AWS_DEPS_BUILD_DIR}
-            RESULT_VARIABLE BUILD_3P_EXIT_CODE)
-    elseif(TARGET_ARCH STREQUAL "APPLE" AND DEFINED CMAKE_OSX_ARCHITECTURES AND NOT CMAKE_OSX_ARCHITECTURES STREQUAL "")
-        message("Cross compiling third-party dependencies for architecture ${CMAKE_OSX_ARCHITECTURES}")
-        execute_process(
-            COMMAND ${CMAKE_COMMAND} -G ${CMAKE_GENERATOR}
-            -DTARGET_ARCH=${TARGET_ARCH}
-            -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-            -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-            -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}
-            -DCMAKE_INSTALL_PREFIX=${AWS_DEPS_INSTALL_DIR}
-            -DCMAKE_OSX_SYSROOT=${CMAKE_OSX_SYSROOT}
-            -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES}
-            -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-            -DCMAKE_C_FLAGS=${CMAKE_C_FLAGS}
-            -DCMAKE_RUNTIME_OUTPUT_DIRECTORY=${CMAKE_CURRENT_BINARY_DIR}/bin
-            ${GEN_PLATFORM_ARG}
-            ${CMAKE_CURRENT_SOURCE_DIR}/third-party
-            WORKING_DIRECTORY ${AWS_DEPS_BUILD_DIR}
-            RESULT_VARIABLE BUILD_3P_EXIT_CODE)
-    else()
-        execute_process(
-            COMMAND ${CMAKE_COMMAND} -G ${CMAKE_GENERATOR}
-            -DTARGET_ARCH=${TARGET_ARCH}
-            -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-            -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-            -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS}
-            -DSTATIC_CRT=${STATIC_CRT}
-            -DCMAKE_INSTALL_PREFIX=${AWS_DEPS_INSTALL_DIR}
-            -DCMAKE_RUNTIME_OUTPUT_DIRECTORY=${CMAKE_CURRENT_BINARY_DIR}/bin
-            ${GEN_PLATFORM_ARG}
-            ${CMAKE_CURRENT_SOURCE_DIR}/third-party
-            WORKING_DIRECTORY ${AWS_DEPS_BUILD_DIR}
-            RESULT_VARIABLE BUILD_3P_EXIT_CODE)
-    endif()
-
-    if (NOT ${BUILD_3P_EXIT_CODE} EQUAL 0)
-        message(FATAL_ERROR "Failed to configure third-party libraries.")
-    endif()
-    execute_process(COMMAND ${CMAKE_COMMAND} --build ${AWS_DEPS_BUILD_DIR} --config ${CMAKE_BUILD_TYPE}
-        RESULT_VARIABLE BUILD_3P_EXIT_CODE)
-
-    if (NOT ${BUILD_3P_EXIT_CODE} EQUAL 0)
-        message(FATAL_ERROR "Failed to build third-party libraries.")
-    endif()
-    message(STATUS "Third-party dependencies are installed at: ${AWS_DEPS_INSTALL_DIR}")
-    list(APPEND CMAKE_PREFIX_PATH "${AWS_DEPS_INSTALL_DIR}")
-endif()
-set(THIRD_PARTY_LIBS "aws-c-event-stream;aws-checksums;aws-c-common")
-
 # build the sdk targets
 project("aws-cpp-sdk-all" VERSION "${PROJECT_VERSION}" LANGUAGES CXX)
 
@@ -246,6 +175,24 @@ set(CMAKE_CONFIGURATION_TYPES
         MinSizeRel              # Like Release, but optimized for memory rather than speed.
         )
 
+# build third-party targets
+if (BUILD_DEPS)
+    set(CMAKE_INSTALL_RPATH "$ORIGIN")
+    list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/crt/aws-crt-cpp/crt/aws-c-common/cmake")
+
+    include(AwsFindPackage)
+
+    set(IN_SOURCE_BUILD ON)
+    set(BUILD_TESTING_PREV ${BUILD_TESTING})
+    set(BUILD_TESTING OFF)
+    add_subdirectory(crt/aws-crt-cpp)
+    set(BUILD_TESTING ${BUILD_TESTING_PREV})
+else()
+    include(AwsFindPackage)
+    set(IN_SOURCE_BUILD OFF)
+endif()
+set(AWS_COMMON_RUNTIME_LIBS "aws-crt-cpp;aws-c-auth;aws-c-cal;aws-c-common;aws-c-compression;aws-c-event-stream;aws-c-http;aws-c-io;aws-c-mqtt;aws-c-s3;aws-checksums")
+
 include(compiler_settings)
 # Instead of calling functions/macros inside included cmake scripts, we should call them in our main CMakeList.txt
 set_msvc_flags()

aws-cpp-sdk-core/CMakeLists.txt

@@ -493,10 +493,9 @@ endif()
 
 target_link_libraries(${PROJECT_NAME} PRIVATE ${PLATFORM_DEP_LIBS} ${CLIENT_LIBS} ${CRYPTO_LIBS} ${AWS_SDK_ADDITIONAL_LIBRARIES})
 
-find_package(aws-c-event-stream REQUIRED)
-
-target_link_libraries(${PROJECT_NAME} PUBLIC AWS::aws-c-event-stream)
+aws_use_package(aws-crt-cpp)
 
+target_link_libraries(${PROJECT_NAME} PUBLIC ${DEP_AWS_LIBS})
 
 if(USE_WINDOWS_DLL_SEMANTICS)
     target_compile_definitions(${PROJECT_NAME} PUBLIC "USE_WINDOWS_DLL_SEMANTICS")
@@ -530,7 +529,7 @@ endif()
 
 if(SIMPLE_INSTALL)
     # These libs are needed by aws-cpp-sdk-core only.
-    set(ALL_DEP_LIBS ${THIRD_PARTY_LIBS} ${PLATFORM_DEP_LIBS_ABSTRACT_NAME} ${CLIENT_LIBS_ABSTRACT_NAME} ${CRYPTO_LIBS_ABSTRACT_NAME})
+    set(ALL_DEP_LIBS ${AWS_COMMON_RUNTIME_LIBS} ${PLATFORM_DEP_LIBS_ABSTRACT_NAME} ${CLIENT_LIBS_ABSTRACT_NAME} ${CRYPTO_LIBS_ABSTRACT_NAME})
     generate_pkgconfig_link_flags(ALL_DEP_LIBS ALL_DEP_LIBS_LINK_FLAGS)
     set(ALL_DEP_LIBS_LINK_FLAGS "${ALL_DEP_LIBS_LINK_FLAGS}")
     configure_file("${AWS_NATIVE_SDK_ROOT}/toolchains/pkg-config.pc.in" "${PROJECT_NAME}.pc" @ONLY)

aws-cpp-sdk-core/source/Globals.cpp

@@ -2,13 +2,40 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0.
  */
+
+#include <aws/crt/Api.h>
 #include <aws/core/Globals.h>
 #include <aws/core/utils/EnumParseOverflowContainer.h>
 #include <aws/core/utils/memory/AWSMemory.h>
+#include <aws/auth/auth.h>
 
 namespace Aws
 {
     static const char TAG[] = "GlobalEnumOverflowContainer";
+
+    static Aws::Crt::ApiHandle* g_apiHandle;
+
+    Aws::Crt::ApiHandle* GetApiHandle()
+    {
+        return g_apiHandle;
+    }
+
+    void InitializeCrt()
+    {
+        g_apiHandle = Aws::New<Aws::Crt::ApiHandle>(TAG, Aws::get_aws_allocator());
+    }
+
+    void CleanupCrt()
+    {
+        aws_global_thread_creator_shutdown_wait_for(5);
+        Aws::Crt::g_allocator = nullptr;
+        aws_auth_library_clean_up();
+        aws_mqtt_library_clean_up();
+        aws_http_library_clean_up();
+
+        Aws::Delete(g_apiHandle);
+    }
+
     static Utils::EnumParseOverflowContainer* g_enumOverflow;
 
     Utils::EnumParseOverflowContainer* GetEnumOverflowContainer()

cmake/AWSSDKConfig.cmake

@@ -41,6 +41,19 @@ if (NOT AWSSDK_INSTALL_INCLUDEDIR)
     set(AWSSDK_INSTALL_INCLUDEDIR "include")
 endif()
 
+if (DEFINED CMAKE_PREFIX_PATH)
+    file(TO_CMAKE_PATH "${CMAKE_PREFIX_PATH}" CMAKE_PREFIX_PATH)
+endif()
+
+if (DEFINED CMAKE_INSTALL_PREFIX)
+    file(TO_CMAKE_PATH "${CMAKE_INSTALL_PREFIX}" CMAKE_INSTALL_PREFIX)
+endif()
+
+set(AWS_MODULE_DIR "/${AWSSDK_INSTALL_LIBDIR}/cmake")
+string(REPLACE ";" "${AWS_MODULE_DIR};" AWS_MODULE_PATH "${CMAKE_PREFIX_PATH}${AWS_MODULE_DIR}")
+string(REPLACE ";" "${AWS_MODULE_DIR};" SYSTEM_MODULE_PATH "${CMAKE_SYSTEM_PREFIX_PATH}${AWS_MODULE_DIR}")
+list(APPEND CMAKE_MODULE_PATH ${AWS_MODULE_PATH} ${SYSTEM_MODULE_PATH})
+
 # On Windows, dlls are treated as runtime target and installed in bindir
 if (WIN32 AND AWSSDK_INSTALL_AS_SHARED_LIBS)
     set(AWSSDK_INSTALL_LIBDIR "${AWSSDK_INSTALL_BINDIR}")
@@ -153,7 +166,7 @@ message(STATUS "Found AWS SDK for C++, Version: ${PACKAGE_VERSION}, Install Root
 # copy libs of services in SERVICE_LIST and all there dependent libs to DEST_DIR
 # CONFIG denote copy release or debug version
 macro(AWSSDK_CPY_DYN_LIBS SERVICE_LIST CONFIG DEST_DIR)
-    set(ALL_SERVICES "core" ${AWSSDK_THIRD_PARTY_LIBS})
+    set(ALL_SERVICES "core" ${AWSSDK_COMMON_RUNTIME_LIBS})
 
     foreach(SVC IN LISTS ${SERVICE_LIST})
         list(APPEND ALL_SERVICES ${SVC})
@@ -251,7 +264,7 @@ macro(AWSSDK_DETERMINE_LIBS_TO_LINK SERVICE_LIST OUTPUT_VAR)
         list(APPEND ${OUTPUT_VAR} "aws-cpp-sdk-${DEP}")
     endforeach()
     if (NOT AWSSDK_INSTALL_AS_SHARED_LIBS)
-        list(APPEND ${OUTPUT_VAR} ${AWSSDK_THIRD_PARTY_LIBS} ${AWSSDK_PLATFORM_DEPS})
+        list(APPEND ${OUTPUT_VAR} ${AWSSDK_COMMON_RUNTIME_LIBS} ${AWSSDK_PLATFORM_DEPS})
     endif()
 endmacro(AWSSDK_DETERMINE_LIBS_TO_LINK)
 
@@ -282,8 +295,8 @@ if (AWSSDK_FIND_COMPONENTS)
 
     # platform dependencies will be resolved automatically when doing find_package(aws-cpp-sdk-core).
     list(REMOVE_ITEM AWSSDK_LINK_LIBRARIES ${AWSSDK_PLATFORM_DEPS})
-    # third_party dependencies will be resolved automatically when doing find_package(aws-cpp-sdk-core) as well.
-    list(REMOVE_ITEM AWSSDK_LINK_LIBRARIES ${AWSSDK_THIRD_PARTY_LIBS})
+    # AWS common runtime dependencies will be resolved automatically when doing find_package(aws-cpp-sdk-core) as well.
+    list(REMOVE_ITEM AWSSDK_LINK_LIBRARIES ${AWSSDK_COMMON_RUNTIME_LIBS})
 
     set(AWSSDK_TARGETS ${AWSSDK_LINK_LIBRARIES})
     list(REVERSE AWSSDK_TARGETS)

cmake/compiler_settings.cmake

@@ -71,9 +71,6 @@ endmacro()
 
 macro(set_msvc_flags)
     if(MSVC)
-        # Put all runtime outputs, including DLLs, executables into one directory, so as to avoid copying DLLs.
-        set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
-
         # Based on the FORCE_SHARED_CRT and BUILD_SHARED_LIBS options, make sure our compile/link flags bring in the right CRT library
         # modified from gtest's version; while only the else clause is actually necessary, do both for completeness/future-proofing
         foreach (var

cmake/platform/android.cmake

@@ -1,13 +1,14 @@
 
 macro(verify_tools)
     # TODO: don't do this if the user is supplying their own curl/openssl/zlib
-    # minimum version of cmake that 
+    # minimum version of cmake that
     #   (1) supports ExternalProject_Add URL_HASH
     #   (2) correctly extracts OPENSSL's version number from openssl/opensslv.h in version 1.0.2d
     cmake_minimum_required (VERSION 3.1.2)
 
     # TODO: don't do this if the user is supplying their own curl/openssl/zlib
     if(NOT GIT_FOUND)
+        find_package(Git)
         message(FATAL_ERROR "Unable to find git; git is required in order to build for Android")
     endif()
 endmacro()
@@ -40,7 +41,7 @@ macro(determine_stdlib_and_api)
 
         # With gnustl, API level can go as low as 3, but let's make a reasonably modern default
         if(NOT ANDROID_NATIVE_API_LEVEL)
-            set(ANDROID_NATIVE_API_LEVEL "android-19") 
+            set(ANDROID_NATIVE_API_LEVEL "android-19")
         endif()
 
     else()
@@ -102,10 +103,6 @@ macro(apply_pre_project_platform_settings)
 endmacro()
 
 macro(apply_post_project_platform_settings)
-    # CMAKE_FIND_ROOT_PATH_MODE_PACKAGE is set to ONLY by default, which means find_package will only search packages under ${ANDROID_NDK} (which is defined by built-in cmake toolchain file.)
-    # In Android NDK before and including 15c, we are not able to change CMAKE_FIND_ROOT_PATH_MODE_PACKAGE, we'd add AWS_DEPS_INSTALL_DIR to the search paths.
-    list(APPEND CMAKE_FIND_ROOT_PATH "${AWS_DEPS_INSTALL_DIR}")
-
     set(SDK_INSTALL_BINARY_PREFIX "${SDK_INSTALL_BINARY_PREFIX}/${ANDROID_ABI}-api-${ANDROID_NATIVE_API_LEVEL}")
 
     set(PLATFORM_DEP_LIBS log atomic)

cmake/platform/windows.cmake

@@ -10,13 +10,17 @@ else()
 endif()
 
 macro(apply_post_project_platform_settings)
+    if(MSVC)
+        # Put all runtime outputs, including DLLs, executables into one directory, so as to avoid copying DLLs.
+        set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
+    endif()
     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
         set(SDK_INSTALL_BINARY_PREFIX "${SDK_INSTALL_BINARY_PREFIX}/intel64")
     else()
         set(SDK_INSTALL_BINARY_PREFIX "${SDK_INSTALL_BINARY_PREFIX}/ia32")
-    endif()    
-   
-    set(PLATFORM_DEP_LIBS Userenv version ws2_32)    
+    endif()
+
+    set(PLATFORM_DEP_LIBS Userenv version ws2_32)
     set(PLATFORM_DEP_LIBS_ABSTRACT_NAME Userenv version ws2_32)
 
 endmacro()