myvtm/CMakeLists.txt

#
# This is a CMake makefile.  CMake is a tool that helps you build C++ programs.
# You can download CMake from http://www.cmake.org.  This CMakeLists.txt file
# you are reading builds dlib's example programs. 
#
# To compile this program all you need to do is ask cmake.  You would type
# these commands from within the directory containing this CMakeLists.txt
# file:
#   mkdir build
#   cd build
#   cmake ..
#   cmake --build . --config {Release|Debug}
#
# The cmake .. command looks in the parent folder for a file named
# CMakeLists.txt, reads it, and sets up everything needed to build program.
#
# CMake can generate a lot of different types of IDE projects.  Run the cmake -h 
# command to see a list of arguments to -G to see what kinds of projects cmake can generate for you. 
# It probably includes your favorite IDE in the list.

cmake_minimum_required (VERSION 3.8)

# program url: http://mayun.itc.cmbchina.cn/QD_RemoteBankArea/LR04.02_RVCTerminalPlus.git
project(RvcTerminalApp)

set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

#  Include extend cmake scripts
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/addin/cmake/ )

include(CheckStructHasMember)
include(CheckIncludeFiles)
include(CheckSymbolExists)
include(CheckCCompilerFlag)
include(ConfigOptions)
include(GetGitRevisionDescription)
include(ComplexLibrary)
include(TodayTimeStamp)
include(PrecompiledHeader)

include(WindowsDLLVersion)

# include path enviroment for RVC
include(BuildMakeSettings)
include(ModMakeSettings)
include(ThirdPartySettings)

# Turn on solution folders (2.8.4+) for Visual Studio.
set_property(GLOBAL PROPERTY USE_FOLDERS ON)

# THIS_MONTH(BUILD_NUMBER)
get_today(BUILD_YEAR BUILD_MONTH BUILD_DAY)
set(BUILD_DATE_STRING "${BUILD_YEAR}.${BUILD_MONTH}.${BUILD_DAY}")

set(BUILD_NUMBER 0)
if ($ENV{BUILD_NUMBER})
	set(BUILD_NUMBER $ENV{BUILD_NUMBER})
else()
	rvc_record_build_number()
endif()
set(DEVOPS_ON FALSE)
set(FORMAT_WITH_SUFFIX TRUE)
set(DEVOPS_ON_CMAKE_ST FALSE)
set(DEVOPS_ON_CMAKE_UAT FALSE)
set(DEVOPS_ON_CMAKE_DEV FALSE)
set(DEVOPS_ON_CMAKE_PRD FALSE)
set(COMPILED_ENV_TYPE 0)
if(MSVC)
	set(TARGET_PLATFORM Windows)
else()
	set(TARGET_PLATFORM UOS)
endif(MSVC)

if($ENV{PIPELINE_BUILD_ID})
	message(STATUS "DevOps pipeline environment: $ENV{DEVOPS_ENV}")
	message(STATUS "PIPELINE_BUILD_ID: $ENV{PIPELINE_BUILD_ID}")
	message(STATUS "PIPELINE_NAME: $ENV{PIPELINE_NAME}")
	message(STATUS "DEVOPS_GROUPID: $ENV{DEVOPS_GROUPID}")
	message(STATUS "DEVOPS_ARTIFACTID: $ENV{DEVOPS_ARTIFACTID}")
	message(STATUS "PIPELINE_NUMBER: $ENV{PIPELINE_NUMBER}")
	message(STATUS "PIPELINE_BRANCH: $ENV{PIPELINE_BRANCH}")
	message(STATUS "RVC_TAG_ID: $ENV{RVC_TAG_ID}")
	set(DEVOPS_ON TRUE)
else()
	set(GIT_HASH "unknown")
	get_git_hash(GIT_HASH)
	message(STATUS "Git hash is ${GIT_HASH}")

	set(GIT_BRANCH "unknown")
	get_git_branch(GIT_BRANCH)
	message(STATUS "Git branch is ${GIT_BRANCH}")
endif($ENV{PIPELINE_BUILD_ID})

# alpha: 内测版本，BUG多，不稳定
# beta1,beta2: 公测版本，不稳定（比alpha稍微稳定），BUG相对较多
# rc1,rc2: 候选版本
# stable 稳定版本

#Set the project(terminal) version
set(RAW_VERSION_STRING "7.5.1-rc1")


if(NOT DEVOPS_ON)
	if(WITH_GITFUR_LOCALCP)
		set(RAW_VERSION_STRING "8.5.1-rc1")
	endif(WITH_GITFUR_LOCALCP)
endif(NOT DEVOPS_ON)


string(STRIP ${RAW_VERSION_STRING} RAW_VERSION_STRING)

set(VERSION_REGEX "^.?([0-9]+)\\.([0-9]+)\\.([0-9]+)-?(.*)")
string(REGEX REPLACE "${VERSION_REGEX}" "\\1" RVC_VERSION_MAJOR "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\2" RVC_VERSION_MINOR "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\3" RVC_VERSION_REVISION "${RAW_VERSION_STRING}")
string(REGEX REPLACE "${VERSION_REGEX}" "\\4" RVC_VERSION_SUFFIX "${RAW_VERSION_STRING}")
set(VERSION_DEV_REGEX "^.?([0-9]+)\\.([0-9]+)\\.([0-9]+)-?([A-Za-z]*)(.*)")
string(REGEX REPLACE "${VERSION_DEV_REGEX}" "\\5" RVC_DEV_NUM "${RAW_VERSION_STRING}")

if(DEVOPS_ON)
	set(DEVOPS_ENV_STR $ENV{DEVOPS_ENV})
	string(TOLOWER $ENV{DEVOPS_ENV} DEVOPS_ENV_STR)
	
	string(COMPARE EQUAL ${DEVOPS_ENV_STR} "st" DEVOPS_ON_CMAKE_ST)
	string(COMPARE EQUAL ${DEVOPS_ENV_STR} "dev" DEVOPS_ON_CMAKE_DEV)
	string(COMPARE EQUAL ${DEVOPS_ENV_STR} "uat" DEVOPS_ON_CMAKE_UAT)
	if(DEVOPS_ON_CMAKE_UAT)
		message(STATUS "UAT devops environment, judge PRD or not.")
		if(DEFINED ENV{FOR_PRD})
			message(STATUS "FOR_PRD: $ENV{FOR_PRD}")
			if($ENV{FOR_PRD})
				set(DEVOPS_ON_CMAKE_PRD TRUE)
				set(DEVOPS_ON_CMAKE_UAT FALSE)
			endif($ENV{FOR_PRD})
		endif(DEFINED ENV{FOR_PRD})
	endif(DEVOPS_ON_CMAKE_UAT)

	#set vesion number: ENV_VER_Major.ENV_VER_Minor.ENV_VER_Revision.ENV_VER_Build
	if(DEFINED ENV{ENV_VER_Major})
		set(ENV_VER_Major_STR $ENV{ENV_VER_Major})
		string(LENGTH ${ENV_VER_Major_STR} ENV_VER_Major_STR_var)
		if(${ENV_VER_Major_STR_var})
			set(RVC_VERSION_MAJOR "${ENV_VER_Major_STR}")
			message(STATUS "reset RVC_VERSION_MAJOR: ${RVC_VERSION_MAJOR}")
		endif(${ENV_VER_Major_STR_var})
	endif(DEFINED ENV{ENV_VER_Major})
	if(DEFINED ENV{ENV_VER_Minor})
		set(ENV_VER_Minor_STR $ENV{ENV_VER_Minor})
		string(LENGTH ${ENV_VER_Minor_STR} ENV_VER_Minor_STR_var)
		if(${ENV_VER_Minor_STR_var})
			set(RVC_VERSION_MINOR "${ENV_VER_Minor_STR}")
			message(STATUS "reset RVC_VERSION_MINOR: ${RVC_VERSION_MINOR}")
		endif(${ENV_VER_Minor_STR_var})
	endif(DEFINED ENV{ENV_VER_Minor})
	if(DEFINED ENV{ENV_VER_Revision})
		set(ENV_VER_Revision_STR $ENV{ENV_VER_Revision})
		string(LENGTH ${ENV_VER_Revision_STR} ENV_VER_Revision_STR_var)
		if(${ENV_VER_Revision_STR_var})
			set(RVC_VERSION_REVISION "${ENV_VER_Revision_STR}")
			message(STATUS "reset RVC_VERSION_REVISION: ${RVC_VERSION_REVISION}")
		endif(${ENV_VER_Revision_STR_var})
	endif(DEFINED ENV{ENV_VER_Revision})
	if(DEFINED ENV{ENV_VER_Build})
		set(ENV_VER_Build_STR $ENV{ENV_VER_Build})
		string(LENGTH ${ENV_VER_Build_STR} ENV_VER_Build_STR_var)
		if(${ENV_VER_Build_STR_var})
			set(RVC_DEV_NUM "${ENV_VER_Build_STR}")
			set(BUILD_NUMBER "${ENV_VER_Build_STR}")
			message(STATUS "reset BUILD_NUMBER: ${BUILD_NUMBER}")
		endif(${ENV_VER_Build_STR_var})
	elseif((NOT DEVOPS_ON_CMAKE_PRD) AND DEFINED ENV{PIPELINE_NUMBER})
		set(BUILD_NUMBER $ENV{PIPELINE_NUMBER})
	else()
		message(WARN "not set pipe number env virable.")
		set(BUILD_NUMBER ${RVC_DEV_NUM})
	endif(DEFINED ENV{ENV_VER_Build})

	if(DEVOPS_ON_CMAKE_PRD)
		set(RVC_VERSION_SUFFIX "PRD")
		if(PACK_AS_DEB_PKG)
			#product version as debian installer, reset the last version element to zero.
			set(BUILD_NUMBER 0)
		endif(PACK_AS_DEB_PKG)
	else()
		set(RVC_VERSION_SUFFIX "$ENV{DEVOPS_ENV}_$ENV{PIPELINE_NAME}")
	endif(DEVOPS_ON_CMAKE_PRD)

	if(DEFINED ENV{RVC_TAG_ID})
		set(ENV_RVC_TAG_ID_STR $ENV{RVC_TAG_ID})
		string(LENGTH ${ENV_RVC_TAG_ID_STR} ENV_RVC_TAG_ID_STR_var)
		if(${ENV_RVC_TAG_ID_STR_var})
			set(RVC_VERSION_SUFFIX "${RVC_VERSION_SUFFIX}_${ENV_RVC_TAG_ID_STR}")
		endif(${ENV_RVC_TAG_ID_STR_var})
	endif(DEFINED ENV{RVC_TAG_ID})

	if(NOT FORMAT_WITH_SUFFIX)
		unset(RVC_VERSION_SUFFIX)
	endif(NOT FORMAT_WITH_SUFFIX)

elseif(BUILD_NUMBER EQUAL 0)
	set(BUILD_NUMBER ${RVC_DEV_NUM})

endif(DEVOPS_ON)

message(STATUS "BUILD_NUMBER ${BUILD_NUMBER}")
set(RVC_VERSION_BUILD "${BUILD_NUMBER}")

set(RVC_API_VERSION "${RVC_VERSION_MAJOR}")
set(RVC_VERSION "${RVC_VERSION_MAJOR}.${RVC_VERSION_MINOR}.${RVC_VERSION_REVISION}.${RVC_VERSION_BUILD}")
set(RVC_FRAMEWORK_VERSION "${RVC_VERSION_MAJOR}.${RVC_VERSION_MINOR}.${RVC_VERSION_REVISION}")
if (RVC_VERSION_SUFFIX)
	set(RVC_VERSION_FULL "${RVC_VERSION}-${RVC_VERSION_SUFFIX}")
else()
	set(RVC_VERSION_FULL "${RVC_VERSION}")
endif(RVC_VERSION_SUFFIX)
set(PACK_VERSION_NAME "${RVC_VERSION_FULL}")

if(NOT DEFINED BUILD_SHARED_LIBS)
	set(BUILD_SHARED_LIBS ON)
endif()

if(BUILD_SHARED_LIBS)
	message(STATUS "Build shared libraries")
endif(BUILD_SHARED_LIBS)

set(RVC_COMPANY "China Merchants Bank" CACHE STRING "China Merchants Bank Corporation")
set(RVC_PRODUCT "VTM")
set(RVC_AUTHOR "CCDG")
set(RVC_COPYRIGHT "Copyright (C) ${BUILD_YEAR}")
set(RVC_DESCRIPTION "${BUILD_YEAR}.${BUILD_MONTH}")


# Some buildsystems generated by CMake have a predetermined build-configuration set in the 
# CMAKE_BUILD_TYPE variable. The buildsystem for the IDEs such as Visual Studio and Xcode are 
# generated independent of the build-configuration, and the actual build configuration is not known 
# until build-time. 
# string(TOLOWER ${CMAKE_BUILD_TYPE} _type)
#if (_type STREQUAL debug)
#  target_compile_definitions(exe1 PRIVATE DEBUG_BUILD)
# endif()
#may appear to work for Makefile Generators and Ninja generators, but is not portable to IDE generators. 
#Additionally, the IMPORTED configuration-mappings are not accounted for with code like this, so it should be avoided.

if(NOT DEFINED CMAKE_CONFIGURATION_TYPES AND NOT DEFINED CMAKE_BUILD_TYPE)
	message(FATAL_ERROR "User should define CMAKE_CONFIGURATION_TYPES or CMAKE_BUILD_TYPE")
elseif(DEFINED CMAKE_CONFIGURATION_TYPES AND NOT DEFINED CMAKE_BUILD_TYPE)
	set(CMAKE_BUILD_TYPE ${CMAKE_CONFIGURATION_TYPES})
elseif(DEFINED CMAKE_BUILD_TYPE AND NOT DEFINED CMAKE_CONFIGURATION_TYPES)
	set(CMAKE_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE})
endif()

if(${CMAKE_GENERATOR} MATCHES "Visual Studio*")
	if(NOT DEFINED CMAKE_CONFIGURATION_TYPES)
		set(CMAKE_CONFIGURATION_TYPES "Debug")
	endif()
	if(CMAKE_CONFIGURATION_TYPES STREQUAL Release)
		set(BUILD_TYPE_NAME "Release")
	elseif(CMAKE_CONFIGURATION_TYPES STREQUAL Debug)
		message(STATUS "debug type")
		set(BUILD_TYPE_NAME "Debug")
	else()
		message(STATUS "Unknown config type: ${CMAKE_CONFIGURATION_TYPES}")
		set(BUILD_TYPE_NAME "Default")
	endif()
	if(NOT CMAKE_GENERATOR_PLATFORM)
		message(STATUS "set win32 platform default ${CMAKE_SYSTEM_PROCESSOR}")
		set(CMAKE_GENERATOR_PLATFORM "${CMAKE_SYSTEM_PROCESSOR}")
	endif()

elseif(${CMAKE_GENERATOR} MATCHES "Unix*")
	if(NOT DEFINED CMAKE_BUILD_TYPE)
		set(CMAKE_BUILD_TYPE "Debug")
	endif()
	set(BUILD_TYPE_NAME ${CMAKE_BUILD_TYPE})
	if(NOT CMAKE_GENERATOR_PLATFORM)
	    # uncomment would make "CHECK_SYMBOL_EXISTS" failed !!! 20201014@Gifur Issue#IP1F
		# message(STATUS "set unix platform default: ${CMAKE_SYSTEM_PROCESSOR}")
		# set(CMAKE_GENERATOR_PLATFORM "${CMAKE_SYSTEM_PROCESSOR}")
	endif()
endif()

#Would not happen ever. todo
set(OLD_CONAN_EXPORTED ${CONAN_EXPORTED})
message(STATUS "CONAN_EXPORTED type: ${CONAN_EXPORTED}")
if(CONAN_EXPORTED)
	message(STATUS "Set CONAN_EXPORTED FALSE")
	set(CONAN_EXPORTED FALSE)
endif(CONAN_EXPORTED)


include(conan)
if(CONAN_CACHE_CLEAR)
	conan_local_remove()
endif(CONAN_CACHE_CLEAR)

include(DependencyConanFiles)

set(RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS})
if(NOT MSVC)
	set(RVC_CONAN_DEP_LIBS ${RVC_CONAN_DEP_LIBS} ${CONAN_LIB_DIRS})
endif(NOT MSVC)

set(CONAN_EXPORTED ${OLD_CONAN_EXPORTED})

message("=-=-=-=-=-=-=-====-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=\n\n")
message(STATUS "RVC_VERSION=${RVC_VERSION_FULL}, Build time: ${BUILD_YEAR}.${BUILD_MONTH}.${BUILD_DAY}")
message("\n\n=-=-=-=-=-=-=-====-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=")

message("CMAKE_SYSTEM_NAME: ${CMAKE_SYSTEM_NAME}, CMAKE_GENERATOR: ${CMAKE_GENERATOR}, CMAKE_SYSTEM_PROCESSOR: ${CMAKE_SYSTEM_PROCESSOR}")

if(MSVC)
	set(LIB_PREFIX "")
	set(LIB_SUFFIX ".dll")
	set(ROOT_INI_NAME "root.ini.win32")
else()
	set(LIB_PREFIX "lib")
	set(LIB_SUFFIX ".so")
	set(ROOT_INI_NAME "root.ini.unix")
endif(MSVC)


if(BUILD_TESTING)
	include(CTest)
	message(STATUS "******** build the tests ********")
	enable_testing()
	set(TESTING_OUTPUT_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
endif()

message(STATUS "CMAKE_GENERATOR_PLATFORM:  ${CMAKE_GENERATOR_PLATFORM}")

set(RVC_DEBUG_MODE TRUE)

string(TOLOWER ${BUILD_TYPE_NAME} _type)
string(TOUPPER ${BUILD_TYPE_NAME} _type_upper)
set(RVC_OUTPUT_SUFFIX "")
if (_type STREQUAL debug)
	add_compile_definitions(_DEBUG)
	set(RVC_OUTPUT_SUFFIX "_${_type_upper}")
elseif(_type STREQUAL release)
	add_compile_definitions(NDEBUG)
	set(RVC_DEBUG_MODE FALSE)

	set(RVC_OUTPUT_SUFFIX "_${_type_upper}")
endif()
if(DEVOPS_ON_CMAKE_ST)
	add_compile_definitions(DEVOPS_ON_ST)
	message(STATUS "add st compile definition")
	set(COMPILED_ENV_TYPE 2)
	set(INI_CONTENT "[MicroServiceURL]\nenv=ST_BIZ")
elseif(DEVOPS_ON_CMAKE_UAT)
	add_compile_definitions(DEVOPS_ON_UAT)
	message(STATUS "add uat compile definition")
	set(COMPILED_ENV_TYPE 3)
	set(INI_CONTENT "[MicroServiceURL]\nenv=UAT_BIZ")
elseif(DEVOPS_ON_CMAKE_DEV)
	add_compile_definitions(DEVOPS_ON_DEV)
	message(STATUS "add dev compile definition")
	set(INI_CONTENT "[MicroServiceURL]\nenv=ST_BIZ")
	set(COMPILED_ENV_TYPE 1)
elseif(DEVOPS_ON_CMAKE_PRD)
	add_compile_definitions(DEVOPS_ON_PRD)
	message(STATUS "add product compile definition")
	set(COMPILED_ENV_TYPE 4)
	set(INI_CONTENT "[MicroServiceURL]\nenv=PRD")
else()
	set(INI_CONTENT "[MicroServiceURL]\nenv=ST_BIZ")
endif(DEVOPS_ON_CMAKE_ST)

# Configure MSVC Runtime
if(MSVC)
	include(MSVCRuntime)
	if(NOT DEFINED MSVC_RUNTIME)
		set(MSVC_RUNTIME "dynamic")
		message(STATUS "dynamic format")
	endif()
	set(MSVC_DYNAMIC_RUNTIME ${MSVC_RUNTIME})
	configure_msvc_runtime()
	set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)

	add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/source-charset:utf-8>")
	add_compile_options("$<$<C_COMPILER_ID:MSVC>:/source-charset:utf-8>")

	add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/execution-charset:gbk>")
	add_compile_options("$<$<C_COMPILER_ID:MSVC>:/execution-charset:gbk>")

else()
	add_compile_options("-Wno-unused-function")
	#add_compile_options("-Werror=implicit-function-declaration")
endif(MSVC)

# Enable 64bit file support on linux and FreeBSD.
if("${CMAKE_SYSTEM_NAME}" MATCHES "Linux" OR FREEBSD)
	add_definitions("-D_FILE_OFFSET_BITS=64")
endif()

if(CMAKE_COMPILER_IS_GNUCC)
	if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "i686")
		CHECK_SYMBOL_EXISTS(__x86_64__ "" IS_X86_64)
		if(IS_X86_64)
			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
			message(STATUS "set -fPIC")
		else()
			set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=i686")
			message(STATUS "set -march=i686")
		endif()
	else()
		if(CMAKE_POSITION_INDEPENDENT_CODE)
			if(${CMAKE_VERSION} VERSION_LESS 2.8.9)
				message(STATUS "set -fPIC 2")
				set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
			endif()
		endif()
	endif()
	# active warning or gun c compiler would not burn warning if not necessary.
	# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -g3 -rdynamic")
	# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g3 -rdynamic")
	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic")

	check_c_compiler_flag(-Wno-unused-result Wno-unused-result)
	if(Wno-unused-result)
		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-result")
	endif()
	check_c_compiler_flag(-Wno-unused-but-set-variable Wno-unused-but-set-variable)
	if(Wno-unused-but-set-variable)
		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-but-set-variable")
	endif()
	check_c_compiler_flag(-Wno-deprecated-declarations Wno-deprecated-declarations)
	if(Wno-deprecated-declarations)
		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
	endif()
	check_c_compiler_flag(-Wno-deprecated-declarations Wno-deprecated-declarationsCXX)
	if(Wno-deprecated-declarationsCXX)
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
	endif()

	if(CMAKE_BUILD_TYPE STREQUAL "Release")
		add_definitions(-DNDEBUG)
		message(STATUS "add ndebug")
	else()
		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g")
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
	endif()

endif()

if(MSVC)
	# Window occurs '/' error
	if(DEVOPS_INSTALL_SWITCH)
		set(CURRENT_DISK "${CMAKE_BINARY_DIR}\\out")
		message(STATUS "CURRENT_DISK: ${CURRENT_DISK}")
	else(DEVOPS_INSTALL_SWITCH)
		STRING(REGEX REPLACE "^([A-Z]*.)([/\\].*)" "\\1" CURRENT_DISK "${CMAKE_CURRENT_SOURCE_DIR}")
	endif(DEVOPS_INSTALL_SWITCH)
	set(OUTPUT_CUR_DISK_PATH "${CURRENT_DISK}\\")
else(MSVC)
		if(DEVOPS_INSTALL_SWITCH)
			set(CURRENT_DISK "${CMAKE_BINARY_DIR}/out/" )
			message(STATUS "CURRENT_DISK: ${CURRENT_DISK}")
		else(DEVOPS_INSTALL_SWITCH)
			STRING(REGEX MATCH "^/home/([A-Za-z0-9_]*)/" CURRENT_DISK "${CMAKE_CURRENT_SOURCE_DIR}")
			STRING(LENGTH "${CURRENT_DISK}" disk_length)
			if(NOT ${disk_length})
				set(CURRENT_DISK "/opt/")
			endif()
		endif(DEVOPS_INSTALL_SWITCH)
		set(OUTPUT_CUR_DISK_PATH "${CURRENT_DISK}")
endif(MSVC)
message(STATUS "OUTPUT_CUR_DISK_PATH: ${OUTPUT_CUR_DISK_PATH}")


set(OUTPUT_VERSION_DIR_PATH "${OUTPUT_CUR_DISK_PATH}Run\\version")
set(OUTPUT_CUR_VERSION_PATH "${OUTPUT_VERSION_DIR_PATH}\\${RVC_VERSION}")
if(NOT MSVC)
	string(REPLACE "\\" "/" OUTPUT_VERSION_DIR_PATH ${OUTPUT_VERSION_DIR_PATH})
	string(REPLACE "\\" "/" OUTPUT_CUR_VERSION_PATH ${OUTPUT_CUR_VERSION_PATH})
endif(NOT MSVC)

#Config install information
set(PACK_INSTALL_RUN_DIR "Run")
set(PACK_INSTALL_RVC_DIR "rvc")
set(PACK_INSTALL_RUNTIME_DIR "Runtime")
set(PACK_INSTALL_PREFIX_VERSION "${PACK_INSTALL_RUN_DIR}/version")
set(PACK_INSTALL_PREFIX_CUR_VER "${PACK_INSTALL_PREFIX_VERSION}/${RVC_VERSION}")
set(PACK_INSTALL_DATA_DIR "${PACK_INSTALL_RVC_DIR}/adData")
set(PACK_INSTALL_MISCS_DIR "${PACK_INSTALL_RVC_DIR}/Other")
set(RVC_BASE_PATH "${PACK_INSTALL_PREFIX_VERSION}")
set(RVC_INCLUDE_PATH  "${PACK_INSTALL_PREFIX_CUR_VER}/include")
set(RVC_LIBRARY_PATH   "${PACK_INSTALL_PREFIX_CUR_VER}/lib")
set(RVC_RUNTIME_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/bin")
set(RVC_PDBSAVE_PATH "${PACK_INSTALL_PREFIX_CUR_VER}/pdb")
set(RVC_PLUGINS_PATH "${RVC_RUNTIME_PATH}/plugins")
set(RVC_MODULE_PATH  "${PACK_INSTALL_PREFIX_CUR_VER}/mod")
set(RVC_CONFIG_PATH    "${PACK_INSTALL_PREFIX_CUR_VER}/cfg")
set(RVC_VENDOR_PATH  "${PACK_INSTALL_PREFIX_CUR_VER}/dep")
set(RVC_SHARED_PATH   "${PACK_INSTALL_PREFIX_CUR_VER}/share")
set(RVC_RESOURCE_PATH   "${PACK_INSTALL_PREFIX_CUR_VER}/res")
set(RVC_EXTEND_PATH   "${PACK_INSTALL_PREFIX_CUR_VER}/ext")
set(RVC_INSTALL_NEWDEP "${PACK_INSTALL_RUN_DIR}/dep")
set(RVC_INSTALL_NEWDEP_VERSION_FILE "${RVC_INSTALL_NEWDEP}/depver.txt")
#win
set(RVC_CHROMIUM_PATH "${RVC_RUNTIME_PATH}/Chromium")
set(CMAKE_INSTALL_INCLUDEDIR ${RVC_INCLUDE_PATH})
set(CMAKE_INSTALL_BINDIR ${RVC_RUNTIME_PATH})
if(MSVC)
	set(CMAKE_INSTALL_LIBDIR ${RVC_LIBRARY_PATH})
else()
	set(CMAKE_INSTALL_LIBDIR ${RVC_RUNTIME_PATH})
endif(MSVC)

# set(CPACK_SYSTEM_NAME "${TARGET_PLATFORM}-${BUILD_YEAR}${BUILD_MONTH}${BUILD_DAY}")
set(CPACK_SYSTEM_NAME "${TARGET_PLATFORM}-${BUILD_TYPE_NAME}")
set(CPACK_TOPLEVEL_TAG "${TARGET_PLATFORM}-${BUILD_TYPE_NAME}")

if(MSVC)
	string(REPLACE "\\" "/" OUTPUT_VERSION_DIR_PATH ${OUTPUT_VERSION_DIR_PATH})
	string(REPLACE "\\" "/" OUTPUT_CUR_DISK_PATH ${OUTPUT_CUR_DISK_PATH})
endif(MSVC)
set(CMAKE_INSTALL_PREFIX "${OUTPUT_CUR_DISK_PATH}")
set(RVC_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")

if(WIN32)
   # dll rc version
	string(TIMESTAMP RC_VERSION_YEAR "%Y")
	set(RC_VERSION_AUTHOR    ${RVC_AUTHOR})
	set(RC_VERSION_COMPANY ${RVC_COMPANY})
	set(RC_VERSION_PRODUCT  ${RVC_PRODUCT})
	set(RC_VERSION_PATCH       ${BUILD_NUMBER})
	set(RC_VERSION_DESCRIPTION "${RVC_VERSION_FULL} ${CPACK_SYSTEM_NAME}")

	#set previous definitions
	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
	add_definitions(-DWIN32_LEAN_AND_MEAN)
	add_definitions(-D_WINSOCK_DEPRECATED_NO_WARNINGS)

	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi")
	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG /OPT:REF /OPT:ICF")
	set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG /OPT:REF /OPT:ICF")
endif(WIN32)

if(MSVC)
	# Force to always compile with W4
	if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
		string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
	else()
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
	endif()
	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4505")
	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
	set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
	set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
endif()
message(STATUS "definition content: CMAKE_C_FLAGS:${CMAKE_C_FLAGS}; CMAKE_CXX_FLAGS:${CMAKE_CXX_FLAGS}")
# Include files
check_include_files(fcntl.h HAVE_FCNTL_H)
check_include_files(unistd.h HAVE_UNISTD_H)
check_include_files(execinfo.h HAVE_EXECINFO_H)
check_include_files(inttypes.h HAVE_INTTYPES_H)
check_include_files(sys/modem.h HAVE_SYS_MODEM_H)
check_include_files(sys/filio.h HAVE_SYS_FILIO_H)
check_include_files(sys/sockio.h HAVE_SYS_SOCKIO_H)
check_include_files(sys/strtio.h HAVE_SYS_STRTIO_H)
check_include_files(sys/select.h HAVE_SYS_SELECT_H)
check_include_files(syslog.h HAVE_SYSLOG_H)

check_struct_has_member("struct tm" tm_gmtoff time.h HAVE_TM_GMTOFF)
set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
find_package(Threads REQUIRED)

if(NOT WIN32)
	CHECK_SYMBOL_EXISTS(pthread_mutex_timedlock pthread.h HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
	if (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
		CHECK_LIBRARY_EXISTS(pthread pthread_mutex_timedlock "" HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)
	endif (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL)
	if (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)
		CHECK_LIBRARY_EXISTS(pthreads pthread_mutex_timedlock "" HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
	endif (NOT HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB)

	if (HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
		set(HAVE_PTHREAD_MUTEX_TIMEDLOCK ON)
	endif (HAVE_PTHREAD_MUTEX_TIMEDLOCK_SYMBOL OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIB OR HAVE_PTHREAD_MUTEX_TIMEDLOCK_LIBS)
endif()

if(UNIX)
	check_include_files(aio.h HAVE_AIO_H)
	check_include_files(sys/eventfd.h HAVE_SYS_EVENTFD_H)
	if (HAVE_SYS_EVENTFD_H)
		check_symbol_exists(eventfd_read sys/eventfd.h WITH_EVENTFD_READ_WRITE)
	endif()
	check_include_files(sys/timerfd.h HAVE_SYS_TIMERFD_H)
	check_include_files(poll.h HAVE_POLL_H)
endif(UNIX)

# Include directories
include_directories(${CMAKE_CURRENT_BINARY_DIR})

# 生成env.ini文件
file(WRITE ${CMAKE_BINARY_DIR}/env.ini "${INI_CONTENT}")
message("Generated env.ini file in ${CMAKE_BINARY_DIR}")

set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
#Output directory for MS debug symbol .pdb files generated by the linker for executable and shared library targets.
#This variable is used to initialize the PDB_OUTPUT_DIRECTORY property on all the targets. See that target property for additional information.
set(CMAKE_PDB_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/pdb)
if(WIN32)
	set(RVC_PDB_BINARY_DIR "${CMAKE_PDB_OUTPUT_DIRECTORY}/${CMAKE_CONFIGURATION_TYPES}")
else()
	set(RVC_PDB_BINARY_DIR ${CMAKE_PDB_OUTPUT_DIRECTORY})
endif(WIN32)
message(STATUS "RVC_PDB_BINARY_DIR: ${RVC_PDB_BINARY_DIR}")

set(PRIVATE_KEYWORD PRIVATE)
set(PUBLIC_KEYWORD PUBLIC)

if(BUILD_COREFRAMEWORK)
	add_subdirectory(Framework)
endif(BUILD_COREFRAMEWORK)

if(BUILD_MODULE)
	add_subdirectory(Other)
	add_subdirectory(Module)
else()
	message(WARNING "skipping Other and Module directories.")
endif(BUILD_MODULE)

if(BUILD_TOOLS)
	add_subdirectory(Tool)
else()
	message(WARNING "skipping Tool directory.")
endif(BUILD_TOOLS)

if(BUILD_DEVADAPTER)
	add_subdirectory(DevAdapter)
endif(BUILD_DEVADAPTER)

set(CMAKE_INSTALL_LOCAL_ONLY ON)

# Config package information.
set(CPACK_SOURCE_IGNORE_FILES "/\\\\.git/;/\\\\.gitignore;/CMakeCache.txt;/\\\\build;/\\\\out")
string(TOLOWER ${CMAKE_PROJECT_NAME} CMAKE_PROJECT_NAME_lower)
set(CPACK_PACKAGE_NAME_PREFIX "${CMAKE_PROJECT_NAME}")
set(CPACK_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME_PREFIX}-${PACK_VERSION_NAME}-${CPACK_SYSTEM_NAME}")
set(CPACK_SOURCE_PACKAGE_FILE_NAME "${CPACK_PACKAGE_NAME_PREFIX}-${PACK_VERSION_NAME}-${CPACK_SYSTEM_NAME}")
# 
set(CPACK_PACKAGE_NAME "RvcTerminalApplication")
set(CPACK_PACKAGE_VENDOR "RVC-CCDG")
# 
set(CPACK_PACKAGE_VERSION              ${RVC_VERSION})
set(CPACK_PACKAGE_VERSION_MAJOR ${RVC_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${RVC_VERSION_MINOR})
set(CPACK_PACKAGE_VERSION_PATCH ${RVC_VERSION_REVISION})
# set(CMAKE_PROJECT_HOMEPAGE_URL "TODO")

# Configure package type
if(MSVC)
	if( NOT CPACK_GENERATOR)
		#set(CPACK_GENERATOR "NSIS")
		set(CPACK_GENERATOR "ZIP")
		message(STATUS "set zip package file type")
	endif()
	if(CPACK_GENERATOR MATCHES "NSIS")
		set(CPACK_PACKAGE_INSTALL_DIRECTORY "C:\\\\Run")
	endif()
else(MSVC)
	if(NOT CPACK_GENERATOR)
		set(CPACK_GENERATOR "ZIP")
		message(STATUS "set zip package file type for matching head bank publish")
	endif()

	if(NOT DEVOPS_ON)
		if(NOT WITH_GITFUR_LOCALCP)
			install(CODE "execute_process(COMMAND chmod 0777 ${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh)")
			install(CODE "execute_process(COMMAND bash ${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh)")
		endif(NOT WITH_GITFUR_LOCALCP)
	endif(NOT DEVOPS_ON)

	install(CODE "execute_process(COMMAND 'chmod 0777 ${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/*')")

endif(MSVC)

install(FILES "${CMAKE_SOURCE_DIR}/addin/assets/VTM.ico"
	"${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/WallPaper1920.png"
	DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT resources)

install(FILES "${CMAKE_SOURCE_DIR}/addin/assets/VTM.ico"
	"${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/WallPaper1920.png"
	DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/Media" COMPONENT resources)

if(MSVC)
		
else()
	install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/spexplorerauto.desktop"
		DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT resources)
endif(MSVC)

file(GLOB ENTITY_INTERFACE_XML_FILES "${MODULE_BASE_DIR}/mod_*/*.xml")
install(FILES ${ENTITY_INTERFACE_XML_FILES} DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/StructConfig" COMPONENT resources)

file(GLOB RVC_RESOURCE_FILES LIST_DIRECTORIES FALSE "${CMAKE_SOURCE_DIR}/addin/assets/*")
install(FILES ${RVC_RESOURCE_FILES} DESTINATION ${RVC_RUNTIME_PATH} COMPONENT resources)

if(MSVC)
	if(MSVC_RUNTIME STREQUAL "dynamic")
		# the INSTALL command is not called. The user can use the variable 
		# CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS to use a custom install command and install them however they want.
		set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
		include(InstallRequiredSystemLibraries)
		message(STATUS "CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS: ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS}")
		install(PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS}
			DESTINATION ${RVC_RUNTIME_PATH}
			COMPONENT libraries)
	else()
		include(InstallRequiredSystemLibraries)
	endif()
endif()

set(active_txt_file "${CMAKE_BINARY_DIR}/active.txt")
message(STATUS "RVC_VERSION = ${RVC_VERSION}, RVC_VERSION_MAJOR=${RVC_VERSION_MAJOR}, RVC_VERSION_MINOR=${RVC_VERSION_MINOR}, RVC_VERSION_REVISION=${RVC_VERSION_REVISION}, RVC_VERSION_SUFFIX=${RVC_VERSION_SUFFIX}")
file(WRITE ${active_txt_file} "${RVC_VERSION}")
install(FILES ${active_txt_file} DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)

set(INSTALLSCRIPT_TYPE 0)
if(DEVOPS_ON)
	if(DEVOPS_ON_CMAKE_PRD)
		set(INSTALLSCRIPT_TYPE 1)
	else()
		#set(INSTALLSCRIPT_TYPE 2)
	endif(DEVOPS_ON_CMAKE_PRD)
endif(DEVOPS_ON)

if(MSVC)
	configure_file("${CMAKE_SOURCE_DIR}/addin/packaging/WIN/installbat.in" "${CMAKE_BINARY_DIR}/install.bat" @ONLY NEWLINE_STYLE CRLF)
	install(PROGRAMS "${CMAKE_BINARY_DIR}/install.bat" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
	install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/Readme.txt" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
	if(NOT DEVOPS_ON_CMAKE_PRD)
		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/kill.bat" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/test.vbs" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
	endif(NOT DEVOPS_ON_CMAKE_PRD)
else(MSVC)
	install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/spexplorer.sh" DESTINATION "${RVC_BASE_PATH}" COMPONENT scripts)
	if(NOT DEVOPS_ON_CMAKE_PRD)
		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/test.sh" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
	endif(NOT DEVOPS_ON_CMAKE_PRD)
	configure_file("${CMAKE_SOURCE_DIR}/addin/packaging/UOS/installsub.in" "${CMAKE_BINARY_DIR}/installsub.sh" @ONLY NEWLINE_STYLE UNIX)
	install(PROGRAMS "${CMAKE_BINARY_DIR}/installsub.sh" DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT scripts)

	install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/install.sh" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
	install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/Readme.txt" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
	install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/spshellstart.sh" DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT scripts)
endif(MSVC)

if(NOT DEVOPS_ON)
	install(FILES "${CMAKE_SOURCE_DIR}/addin/hardwarecfg/${ROOT_INI_NAME}" 
		DESTINATION "${PACK_INSTALL_RUN_DIR}/hardwarecfg" 
		RENAME "root.ini"
		COMPONENT scripts)
endif(NOT DEVOPS_ON)

install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
	COMPONENT scripts FILES_MATCHING PATTERN "*.ini")
install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
	COMPONENT scripts FILES_MATCHING PATTERN "*.xml")
install(FILES ${CMAKE_BINARY_DIR}/env.ini DESTINATION ${RVC_CONFIG_PATH} COMPONENT scripts)

install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/res" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" COMPONENT scripts)
file(GLOB RUN_SCRIPTS_FILES LIST_DIRECTORIES true "${CMAKE_SOURCE_DIR}/addin/res/RunScript/*")
foreach(item ${RUN_SCRIPTS_FILES})
		install(FILES ${item} DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/RunScript" 
		PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
		COMPONENT scripts)
endforeach()

list(REMOVE_DUPLICATES RVC_CONAN_DEP_LIBS)

if(MSVC)
	if(CONAN_BIN_DIRS_CEFCLIENT_MUTABLE)
		message(STATUS "remove cefclient dirs")
		list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_CEFCLIENT_MUTABLE})
		file(GLOB RVC_CHROMIUM_BIN_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_CEFCLIENT_MUTABLE}/Chromium/*")
		foreach(item ${RVC_CHROMIUM_BIN_FILES})
			if(IS_DIRECTORY ${item})
				install(DIRECTORY "${item}" DESTINATION "${RVC_CHROMIUM_PATH}" COMPONENT libraries )
			else()
				install(FILES ${item} DESTINATION "${RVC_CHROMIUM_PATH}" 
				PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
				COMPONENT libraries)
			endif()
		endforeach()
	endif(CONAN_BIN_DIRS_CEFCLIENT_MUTABLE)
	if(CONAN_BIN_DIRS_CEFCLIENT_CONST)
		message(STATUS "remove cefclient dirs")
		list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_CEFCLIENT_CONST})
		file(GLOB RVC_CHROMIUM_BIN_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_CEFCLIENT_CONST}/Chromium/*")
		foreach(item ${RVC_CHROMIUM_BIN_FILES})
			if(IS_DIRECTORY ${item})
				install(DIRECTORY "${item}" DESTINATION "${RVC_CHROMIUM_PATH}" COMPONENT libraries )
			else()
				install(FILES ${item} DESTINATION "${RVC_CHROMIUM_PATH}" 
				PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
				COMPONENT libraries)
			endif()
		endforeach()
	endif(CONAN_BIN_DIRS_CEFCLIENT_CONST)
	if(CONAN_BIN_DIRS_RUNTIMEBASE)
		message(STATUS "install runtime base files")
		file(GLOB RVC_RUNTIME_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_RUNTIMEBASE}/*")
		install(PROGRAMS ${RVC_RUNTIME_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
		#${PACK_INSTALL_RUNTIME_DIR}
		#RVC_RUNTIME_PATH
	endif(CONAN_BIN_DIRS_RUNTIMEBASE)
endif(MSVC)

foreach(bin_dir ${RVC_CONAN_DEP_LIBS})
	message(STATUS "bin dir: ${bin_dir}")
	# file(GLOB RVC_CONAN_BIN_FILES  LIST_DIRECTORIES false "${bin_dir}/*.so" "${bin_dir}/*.dll")
	file(GLOB RVC_CONAN_BIN_FILES LIST_DIRECTORIES false "${bin_dir}/*")
	foreach(filter_elem ${AARCH64_USELESS_LIBRARY_FILE_NAMES})
		set(filter_args ".*\\${filter_elem}$")
		list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ${filter_args})
	endforeach()
	list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*\\.a$")
	list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*\\.lib$")
	install(PROGRAMS ${RVC_CONAN_BIN_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
endforeach()

#pdb save
if(WITH_PDB_SAVEV2)
	message(STATUS "config pdb save scripts.")
	string(TIMESTAMP PDBSAVE_TIME %Y%m%d_%H%M%S)
	if(DEVOPS_ON)
		set(DEVOPS_ENV_UPPER_STR $ENV{DEVOPS_ENV})
		string(TOUPPER $ENV{DEVOPS_ENV} DEVOPS_ENV_UPPER_STR)
		set(SUBDIR_STR "${DEVOPS_ENV_UPPER_STR}")
		set(PDB_ZIP_FILE_PURE_NAME "savepdbVS2019_${RVC_VERSION}_$ENV{PIPELINE_NAME}_${PDBSAVE_TIME}")
	else()
		set(SUBDIR_STR "LocalBuild")
		set(PDB_ZIP_FILE_PURE_NAME "savepdbVS2019_${RVC_VERSION}_${PDBSAVE_TIME}")
	endif(DEVOPS_ON)
	set(PDB_ZIP_FILE_INFO_NAME "${PDB_ZIP_FILE_PURE_NAME}.txt")
	file(WRITE ${CMAKE_BINARY_DIR}/${PDB_ZIP_FILE_INFO_NAME} "PIPELINE_PRE_TAG=$ENV{PIPELINE_PRE_TAG}\r\nPIPELINE_BRANCH=$ENV{PIPELINE_BRANCH}\r\nGIT_BRANCH=$ENV{GIT_BRANCH}\r\nGIT_COMMIT=$ENV{GIT_COMMIT}\r\nGIT_COMMIT_ID=$ENV{GIT_COMMIT_ID}")
	set(PDB_ZIP_FILE_NAME "${PDB_ZIP_FILE_PURE_NAME}.7z")
	#curl -T <local_file_path> ftp://<username>:<password>@<ftp_server_address>/<remote_directory>/<remote_file_name>
	#curl -T example.txt ftp://user:pass123@ftp.example.com/uploads/example.txt
	set (FTP_URL_NAME "ftp://99.12.43.134:3721/${SUBDIR_STR}/")
	message(STATUS "FTP_URL_NAME: ${FTP_URL_NAME}")
	install(CODE "MESSAGE(\"----Pack PDB file ${PDB_ZIP_FILE_NAME}----\")" COMPONENT symbols)
	install(CODE "execute_process(COMMAND 7z a ${PDB_ZIP_FILE_NAME} ${RVC_PDB_BINARY_DIR}/* ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/* -xr!*cmbsz* -xr!*simulator* -xr!*self* WORKING_DIRECTORY ${CMAKE_BINARY_DIR})" COMPONENT symbols)
	install(CODE "execute_process(COMMAND curl -T ${PDB_ZIP_FILE_NAME} ${FTP_URL_NAME} -u savefile:12345678 WORKING_DIRECTORY ${CMAKE_BINARY_DIR})" COMPONENT symbols)
	install(CODE "execute_process(COMMAND curl -T ${PDB_ZIP_FILE_INFO_NAME} ${FTP_URL_NAME} -u savefile:12345678 WORKING_DIRECTORY ${CMAKE_BINARY_DIR})" COMPONENT symbols)
	install(CODE "file(REMOVE ${CMAKE_BINARY_DIR}/${PDB_ZIP_FILE_NAME})" COMPONENT symbols)
	install(CODE "MESSAGE(\"----Pack PDB File Done----\")" COMPONENT symbols)
endif(WITH_PDB_SAVEV2)

if(WITH_LABEL_RECORD AND DEVOPS_ON AND NOT DEVOPS_ON_CMAKE_PRD)
	message(STATUS "PIPELINE_BRANCH: $ENV{PIPELINE_BRANCH}")
	message(STATUS "PIPELINE_PRE_TAG: $ENV{PIPELINE_PRE_TAG}")
	
	set(LABEL_UPLOAD_ENV_STR $ENV{DEVOPS_ENV})
	string(TOLOWER $ENV{DEVOPS_ENV} LABEL_UPLOAD_ENV_STR) #st|uat
	
	if(DEVOPS_ON_CMAKE_ST)
		set(LABEL_UPLOAD_URL_PREFIX "http://55.150.137.198/upgrade/LR04.02_RVCTerminalPlus_ST")
	else()
		set(LABEL_UPLOAD_URL_PREFIX "http://55.150.137.198/upgrade/LR04.02_RVCTerminalPlus_UAT")
	endif(DEVOPS_ON_CMAKE_ST)
	set(LABEL_UPLOAD_URL "${LABEL_UPLOAD_URL_PREFIX}/RVCTerminalPlus-$ENV{PIPELINE_BRANCH}.zip")
	set(LABEL_UPLOAD_URL_NAME "http://avsuser.paasuat.cmbchina.cn/avsui/other-bean/insert-tmp-version-info")
	if(MSVC)
		set(LABEL_UPLOAD_PLATFORM "win")
	else()
		set(LABEL_UPLOAD_PLATFORM "uos")
	endif(MSVC)
	set(LABEL_UPLOAD_VERSION "${RVC_VERSION}")
	set(LABEL_UPLOAD_UPDATER "DEVOPS_USER")
	set(LABEL_UPLOADE_JSON_CONTENT "{\"version\":\"${LABEL_UPLOAD_VERSION}\",\"url\":\"${LABEL_UPLOAD_URL}\",\"env\":\"${LABEL_UPLOAD_ENV_STR}\",\"platform\":\"${LABEL_UPLOAD_PLATFORM}\",\"updater\":\"${LABEL_UPLOAD_UPDATER}\"}")
	install(CODE "MESSAGE(\"----upload label info ${LABEL_UPLOAD_URL}----\")" COMPONENT symbols)
	install(CODE "execute_process(COMMAND curl -X POST -H \"Content-Type: application/json\" -d ${LABEL_UPLOADE_JSON_CONTENT} ${LABEL_UPLOAD_URL_NAME})" COMPONENT symbols)
	install(CODE "MESSAGE(\"----finished uploading label info ${LABEL_UPLOAD_URL}----\")" COMPONENT symbols)
endif(WITH_LABEL_RECORD AND DEVOPS_ON AND NOT DEVOPS_ON_CMAKE_PRD)

#appoint the component to install , except header file here.
 #set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
set(CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE TRUE)

GET_CMAKE_PROPERTY(CPACK_COMPONENTS_ALL COMPONENTS)
FOREACH(item ${CPACK_COMPONENTS_ALL})
	message(STATUS "component: ${item}")
ENDFOREACH()

list(REMOVE_ITEM CPACK_COMPONENTS_ALL "headers" "tools" "symbols")
set_property(GLOBAL PROPERTY COMPONENTS ${CPACK_COMPONENTS_ALL})
GET_CMAKE_PROPERTY(CPACK_COMPONENTS_ALL  COMPONENTS)
FOREACH(item ${CPACK_COMPONENTS_ALL})
	message(STATUS "after component: ${item}")
ENDFOREACH()

set(CPACK_COMPONENT_headers_DISABLED TRUE)

include(CPack)