#[[ Important! You should include this file in your top-level CMakeLists.txt get_system(OS ARCH) Set current operating system name to OS and target architecture to ARCH On Linux try to retrieve OS from "os-release" or "lsb-release" set_version( [MAJOR ] [MINOR ] [REVISION ] [SUFFIX ] [BUILD ] [OUTPUT ]) Set target version, optionally creates file Create variable _VERSION with full version name If OUTPUT then generate header with version macros - _VERSION_ Also create macro _VERSION_NAME with full string version and macro _MAKE_VERSION(major, minor, revision) that returns byte-packed integer version. Attention: macro _VERSION is byte-packed integer version! set_lang( [ [...] ]) Set target translations, e.g. "ru" "fr" import_version( ) Copy all version components and languages from import_deploy_properties( ) Copy all deploy properties from set_deploy_property( [SHARED | STATIC] NAME [NAME [...] ]) Set target deploy property, where NAME one of: * LABEL - application icon name * FULLNAME - package name in format "*.*.*" * COMPANY - company name * ICON - icon file path * INFO - additional info Specify SHARED or STATIC if your target is library You can setup several properties in one command make_rc( ) Generate Windows *.rc file from deploy properties and return file path to On other platforms this variable set to empty You should set version and deploy properties before call this macro, see "set_version()" and "set_deploy_property()" deploy_target( [DEPLOY_DIR ] [DESTINATION ] [RESOURCES [ ...] ] [PLUGINS [ ...] ] [FILES [ ...] ] [LIBS [ ...] ] [OPTIONS ...] [VERBOSE] [DMG_NO_ZIP] [DEB_USR_DIR] [DEB_ADD_SERVICE] [ADD_MANIFEST]) Create make target "deploy_", depends on target "deploy". On this target create release package, containing all dependencies: * .zip on Windows * .deb on Linux * .dmg[.zip] on MacOS * .apk/.aab on Android If not defined DMG_NO_ZIP then *.dmg.zip will be created on MacOS. You should set version and deploy properties before call this macro, see "set_version()" and "set_deploy_property()". Example: deploy_target(my_app DESTINATION packages) DEPLOY_DIR - dir where you install * executable on Windows, Linux * .app directory with executable on MacOS DESTINATION - dir where macro place package RESOURCES, PLUGINS and FILES - list of directories and files, copied to: | | Windows | Linux | Linux (DEB_USR_DIR) | MacOS | |-----------|---------|-----------------------------|---------------------------|-----------------------------| | RESOURCES | root | /opt/FULLNAME | /usr/share/FULLNAME | <*.app>/Contents/Resources | | PLUGINS | root | /opt/FULLNAME/plugins | /usr/lib/FULLNAME | <*.app>/Contents/PlugIns | | FILES | root | /opt/FULLNAME | /usr/bin | <*.app>/Contents/MacOS | | LIBS | root | /opt/FULLNAME/lib | /usr/lib | <*.app>/Contents/Frameworks | Relative paths are taken from DEPLOY_DIR Also check library dependencies from PLUGINS and FILES Important! RESOURCES, PLUGINS, FILES and LIBS lists check at cmake-time, so if entry ends with "/" it treat as directory, else - file FILES can be presents as cmake-generator-expressions. In this case entry treated as absolute path only if it prepened with "/". Examples: * "/$" - right, TARGET_FILE is absolute path * "$" - right, relative item and TARGET_FILE_NAME is only filename * "/$" - wrong, absolute item with only filename This macro using "deploy_tool" from PIP, so make sure it can be executed from shell OPTIONS allow you to pass custom flags to "deploy_tool" You can see flags by launch "deploy_tool" without arguments Using CMAKE_LDD, CMAKE_OTOOL or CMAKE_OBJDUMP variable, depends on target platform DEPLOY_ADD_LIBPATH variable used as additional library search path If DEB_ADD_SERVICE then -service.deb package will be created. This package use contents of CMAKE_CURRENT_SOURCE_DIR/debian-service directory: * CMAKE_CURRENT_SOURCE_DIR/debian-service/DEBIAN/ * CMAKE_CURRENT_SOURCE_DIR/debian-service/*.service .service file placed in /opt/FULLNAME, you should copy it to system with script You can use "postinst,postrm,preinst,prerm,config" files to configure service If ADD_MANIFEST then *.manifest file near package will be created. This file contains all metainformation about package. ]] cmake_policy(SET CMP0011 NEW) # don`t affect includer policies if (POLICY CMP0057) cmake_policy(SET CMP0057 NEW) # Support if() IN_LIST endif() if (POLICY CMP0053) cmake_policy(SET CMP0053 NEW) endif() if (NOT _dep_exists AND NOT PIP_FREERTOS) set(_dep_exists 1) add_custom_target(deploy COMMENT "Deploy") endif() set(_modules_dir "${CMAKE_ROOT}/Modules") if (DEFINED SHSTKPROJECT) set(_modules_dir "${ROOT_DIR}/cmake") endif() if (NOT "x${GIT_CMAKE_DIR}" STREQUAL "x") set(_modules_dir "${GIT_CMAKE_DIR}") endif() set(_dt_delim "::") include(DeployVersionMacros) if (NOT MY_ARCH) target_architecture(MY_ARCH) endif() # Help macros begin macro(__add_file_or_dir _DIR_VAR _FILE_VAR _PATH _RELPATH) set(_p) set(_remabs 0) set(_abs 0) if (IS_ABSOLUTE "${_PATH}") set(_abs 1) endif() if ("${_PATH}" MATCHES "^\\/\\$") set(_abs 1) set(_remabs 1) endif() if (_abs) set(_p "${_PATH}") else() set(_p "${_RELPATH}/${_PATH}") endif() if (_remabs) #message("b \"${_p}\"") string(LENGTH "${_p}" __sl) math(EXPR __sl ${__sl}-1) string(SUBSTRING "${_p}" 1 ${__sl} _p) #message("a \"${_p}\"") endif() if ("${_p}" MATCHES ".*\\/\$") #message("b \"${_p}\"") string(LENGTH "${_p}" __sl) math(EXPR __sl ${__sl}-1) string(SUBSTRING "${_p}" 0 ${__sl} _p) #message("a \"${_p}\"") list(APPEND ${_DIR_VAR} "${_p}") else() list(APPEND ${_FILE_VAR} "${_p}") endif() endmacro() set(__win_host 0) set(__mac_host 0) if ("x${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "xWindows") set(__win_host 1) endif() if ("x${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "xDarwin") set(__mac_host 1) endif() macro(__make_dir _cmd _dest) set(${_cmd} ${${_cmd}} COMMAND "${CMAKE_COMMAND}" -E make_directory "${_dest}") endmacro() macro(__make_copy _cmd _dirs _files _dest) if (${_dirs} OR ${_files}) __make_dir(${_cmd} "${_dest}") endif() if(__win_host) foreach(_d ${${_dirs}}) get_filename_component(_dname "${_d}" NAME) set(${_cmd} ${${_cmd}} COMMAND "${CMAKE_COMMAND}" -E copy_directory "${_d}" "${_dest}/${_dname}/") endforeach() foreach(_f ${${_files}}) set(${_cmd} ${${_cmd}} COMMAND "${CMAKE_COMMAND}" -E copy "${_f}" "${_dest}/") endforeach() else() foreach(_d ${${_dirs}}) set(${_cmd} ${${_cmd}} COMMAND cp ${_VERB} -rf "${_d}" "${_dest}/") endforeach() foreach(_f ${${_files}}) set(${_cmd} ${${_cmd}} COMMAND cp ${_VERB} -f "${_f}" "${_dest}/") endforeach() endif() endmacro() macro(__gather_deps _T _search_path_var _dep_libs_var _dep_libs_cs_var _added_) get_target_property(_LL${_T} ${_T} LINK_LIBRARIES) foreach (_L${_T} ${_LL${_T}}) set(_lib ${_L${_T}}) if (TARGET ${_lib}) get_target_property(_AT ${_lib} ALIASED_TARGET) #message("${_lib} aliased = ${_AT}") if (_AT) set(_lib ${_AT}) endif() get_target_property(_II ${_lib} IMPORTED) #message("${_lib} imported = ${_II}") if ((NOT _II) AND (TARGET ${_lib})) #message("depend on ${_lib}") get_target_property(_LT ${_lib} TYPE) #message("${_lib} type = ${_LT}") if (("x${_LT}" STREQUAL "xSHARED_LIBRARY") OR ("x${_LT}" STREQUAL "xSTATIC_LIBRARY")) if (NOT _lib IN_LIST ${_added_}) list(APPEND ${_added_} ${_lib}) if ("x${_LT}" STREQUAL "xSHARED_LIBRARY") if (NOT DEFINED ANDROID_PLATFORM) set(${_search_path_var} "${${_search_path_var}}${_dt_delim}$") endif() #message("add dep $/$") set(${_dep_libs_cs_var} "${${_dep_libs_cs_var}}${_dt_delim}$/$") set(${_dep_libs_var} "${${_dep_libs_var}}" "$/$") endif() __gather_deps(${_lib} ${_search_path_var} ${_dep_libs_var} ${_dep_libs_cs_var} ${_added_}) endif() endif() endif() endif() endforeach() endmacro() set(__macos_privacy_text "Application request permission") set(__macos_privacies "NFCReaderUsageDescription ${__macos_privacy_text} NSAppleMusicUsageDescription ${__macos_privacy_text} NSBluetoothPeripheralUsageDescription ${__macos_privacy_text} NSCalendarsUsageDescription ${__macos_privacy_text} NSCameraUsageDescription ${__macos_privacy_text} NSContactsUsageDescription ${__macos_privacy_text} NSFaceIDUsageDescription ${__macos_privacy_text} NSHealthShareUsageDescription ${__macos_privacy_text} NSHealthUpdateUsageDescription ${__macos_privacy_text} NSHomeKitUsageDescription ${__macos_privacy_text} NSLocationAlwaysUsageDescription ${__macos_privacy_text} NSLocationWhenInUseUsageDescription ${__macos_privacy_text} NSMicrophoneUsageDescription ${__macos_privacy_text} NSMotionUsageDescription ${__macos_privacy_text} NSPhotoLibraryAddUsageDescription ${__macos_privacy_text} NSPhotoLibraryUsageDescription ${__macos_privacy_text} NSRemindersUsageDescription ${__macos_privacy_text} NSVideoSubscriberAccountUsageDescription ${__macos_privacy_text}" ) set(__gradle_lang_start " defaultConfig { resConfigs ") set(__gradle_sign " signingConfigs { debug { storeFile file(DEBUG_STORE_FILE) } release { storeFile file(RELEASE_STORE_FILE) storePassword RELEASE_STORE_PASSWORD keyPassword RELEASE_KEY_PASSWORD keyAlias RELEASE_KEY_ALIAS } } buildTypes { debug { signingConfig signingConfigs.debug } release { signingConfig signingConfigs.release } }") # Help macros end macro(get_system _OS _ARCH) if (NOT MY_ARCH) target_architecture(MY_ARCH) endif() if ("x${CMAKE_SYSTEM_NAME}" STREQUAL "xLinux") set(_os_id "") set(_os_ver "") set(_paths "/usr/lib" "/etc") if (CMAKE_CROSSCOMPILING) set(_paths "") foreach (_c ${CMAKE_PREFIX_PATH}) list(APPEND _paths "${_c}/lib" "${_c}/../etc") endforeach() endif() find_file(_release_file NAMES os-release lsb-release PATHS ${_paths} NO_DEFAULT_PATH) if (NOT "x${_release_file}" STREQUAL "x") file(STRINGS "${_release_file}" _lines) foreach(_l ${_lines}) if ("${_l}" MATCHES "VERSION_ID=.*") string(SUBSTRING "${_l}" 11 -1 _os_ver) string(REPLACE "\"" "" _os_ver "${_os_ver}") #message("VERSION_ID ${_os_ver}") elseif ("${_l}" MATCHES "ID=.*") string(SUBSTRING "${_l}" 3 -1 _os_id) string(REPLACE "\"" "" _os_id "${_os_id}") #message("ID ${_os_id}") endif() endforeach() endif() string(TOLOWER "${_os_id}${_os_ver}" ${_OS}) if ("x${${_OS}}" STREQUAL "x") set(${_OS} "linux") endif() set(${_ARCH} "${MY_ARCH}") elseif(WIN32) set(${_OS} "windows") set(${_ARCH} "${MY_ARCH}") elseif (APPLE) set(${_OS} "macosx") set(${_ARCH} "x64") elseif (DEFINED ANDROID_PLATFORM) set(${_OS} "android") set(${_ARCH} "all") endif() endmacro() macro(deploy_target _T) set(_DESTINATION "${CMAKE_INSTALL_PREFIX}") set(_DEPLOY_DIR "${CMAKE_INSTALL_PREFIX}") set(_Qt_) if (${LOCAL_FOUND6}) set(_Qt_ 6) elseif (${LOCAL_FOUND5}) set(_Qt_ 5) endif() set(_RES_DIRS) set(_RES_FILES) set(_PLUG_DIRS) set(_PLUG_FILES) set(_FILE_DIRS) set(_FILE_FILES) set(_LIBS_DIRS) set(_LIBS_FILES) set(_VERB) set(_WVERB 1> NUL) set(_OPTIONS "--strip;${CMAKE_STRIP}") set(_ZIP_DMG 1) set(_DEB_OPT 1) set(_DEB_SERVICE 0) set(_MANIFEST 0) set(_cur_arg) set(__args "DESTINATION;DEPLOY_DIR;RESOURCES;PLUGINS;FILES;LIBS;OPTIONS;VERBOSE;DMG_NO_ZIP;DEB_USR_DIR;DEB_ADD_SERVICE;ADD_MANIFEST") foreach(_i ${ARGN}) if (_i IN_LIST __args) set(_cur_arg "${_i}") if ("x${_cur_arg}" STREQUAL "VERBOSE") set(_VERB -v) set(_WVERB) elseif("x${_cur_arg}" STREQUAL "xDMG_NO_ZIP") set(_ZIP_DMG 0) elseif("x${_cur_arg}" STREQUAL "xDEB_USR_DIR") set(_DEB_OPT 0) elseif("x${_cur_arg}" STREQUAL "xDEB_ADD_SERVICE") set(_DEB_SERVICE 1) elseif("x${_cur_arg}" STREQUAL "xADD_MANIFEST") set(_MANIFEST 1) endif() elseif ("x${_cur_arg}" STREQUAL "xDESTINATION") set(_cur_arg) set(_DESTINATION "${_i}/") elseif ("x${_cur_arg}" STREQUAL "xDEPLOY_DIR") set(_cur_arg) set(_DEPLOY_DIR "${_i}/") elseif ("x${_cur_arg}" STREQUAL "xRESOURCES") __add_file_or_dir(_RES_DIRS _RES_FILES "${_i}" "${_DEPLOY_DIR}") elseif ("x${_cur_arg}" STREQUAL "xPLUGINS") __add_file_or_dir(_PLUG_DIRS _PLUG_FILES "${_i}" "${_DEPLOY_DIR}") elseif ("x${_cur_arg}" STREQUAL "xFILES") __add_file_or_dir(_FILE_DIRS _FILE_FILES "${_i}" "${_DEPLOY_DIR}") elseif ("x${_cur_arg}" STREQUAL "xLIBS") __add_file_or_dir(_LIBS_DIRS _LIBS_FILES "${_i}" "${_DEPLOY_DIR}") elseif ("x${_cur_arg}" STREQUAL "xOPTIONS") list(APPEND _OPTIONS "${_i}") endif() #message("-i = ${_i}") endforeach() get_filename_component(_ICON_NAME "${${_T}_ICON}" NAME) get_filename_component(_ICON_FN "${${_T}_ICON}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}") set(_TV "${_T}_${${_T}_VERSION}") set(_DEP_LIBPATH) set(_DEP_LIBS_CS) set(_DEP_LIBS) set(_add_search_path) set(_added_) set(_ADD_DEPS ${_PLUG_DIRS} ${_PLUG_FILES} ${_FILE_DIRS} ${_FILE_FILES} ${_LIBS_DIRS} ${_LIBS_FILES}) __gather_deps(${_T} _add_search_path _DEP_LIBS _DEP_LIBS_CS _added_) foreach (_L ${DEPLOY_ADD_LIBPATH}) set(_add_search_path "${_add_search_path}${_dt_delim}${_L}") endforeach() #message("app depend ${_T} libpath ${_add_search_path}") set(_CMD_) set(_deployed) set(_TARGET_LABEL "${${_T}_LABEL}") set(_TARGET_FULLNAME "${${_T}_FULLNAME}") set(_TARGET_VERSION "${${_T}_VERSION}") set(_TARGET_BUILD "${${_T}_VERSION_BUILD}") set(_TARGET_COMPANY "${${_T}_COMPANY}") set(_TARGET_INFO "${${_T}_INFO}") set(_TARGET_OS "???") set(_TARGET_ARCH "???") set(_TARGET_PACKAGE "???") string(TIMESTAMP _TARGET_TIMESTAMP "%Y-%m-%d %H:%M:%S") get_system(_TARGET_OS _TARGET_ARCH) if ("x${CMAKE_SYSTEM_NAME}" STREQUAL "xLinux") set(_build "${${_T}_VERSION_BUILD}") if (NOT "x${_build}" STREQUAL "x") set(_build "-${_build}") endif() string(REPLACE "_" "-" _DEBNAME "${_T}") set(_DEBVERSION "${${_T}_VERSION_MAJOR}.${${_T}_VERSION_MINOR}.${${_T}_VERSION_REVISION}${_build}${${_T}_VERSION_FULLSUFFIX}+${_TARGET_OS}") string(REPLACE "_" "-" _DEBVERSION "${_DEBVERSION}") string(TOLOWER "${_DEBNAME}" _DEBNAME) set(_DEB_ARCH) if("_${_TARGET_ARCH}" STREQUAL "_arm64") set(_DEB_ARCH "arm64") elseif("_${_TARGET_ARCH}" STREQUAL "_armv7") set(_DEB_ARCH "armhf") elseif("_${_TARGET_ARCH}" STREQUAL "_i386") set(_DEB_ARCH "i386") elseif("_${_TARGET_ARCH}" STREQUAL "_x86_64") set(_DEB_ARCH "amd64") elseif("_${_TARGET_ARCH}" STREQUAL "_ppc") set(_DEB_ARCH "PowerPC") elseif("_${_TARGET_ARCH}" STREQUAL "_ppc64") set(_DEB_ARCH "PPC64") elseif("_${_TARGET_ARCH}" STREQUAL "_ia64") set(_DEB_ARCH "ia64") endif() if (NOT "x${${_T}_FULLNAME}" STREQUAL "x") set(_app_dir "${${_T}_FULLNAME}") else() set(_app_dir "${_T}") endif() set(_DEB "${_TV}_deb_${_DEB_ARCH}") set(_AGD "${_DEPLOY_DIR}/${_DEB}") set(_C_echof ">" "${_AGD}/DEBIAN/control") set(_C_echo ">>" "${_AGD}/DEBIAN/control") set(_D_echof ">" "${_AGD}/usr/share/applications/${_DEBNAME}.desktop") set(_D_echo ">>" "${_AGD}/usr/share/applications/${_DEBNAME}.desktop") set(_bin_path "${_AGD}/usr/bin") set(_lib_path "${_AGD}/usr/lib") set(_pli_path "${_AGD}/usr/lib/${_app_dir}") set(_res_path "${_AGD}/usr/share/${_app_dir}") set(_ico_path "${_AGD}/usr/share/pixmaps") set(_app_bin_path "/usr/bin") set(_app_ico_path "/usr/share/pixmaps") if(_DEB_OPT) set(_bin_path "${_AGD}/opt/${_app_dir}") set(_lib_path "${_AGD}/opt/${_app_dir}/lib") set(_pli_path "${_AGD}/opt/${_app_dir}/plugins") set(_res_path "${_AGD}/opt/${_app_dir}") set(_ico_path "${_AGD}/opt/${_app_dir}/pixmaps") set(_app_bin_path "/opt/${_app_dir}") set(_app_ico_path "/opt/${_app_dir}/pixmaps") endif() set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_bin_path}") set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_lib_path}") set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_pli_path}") set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_res_path}") set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_ico_path}") set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_AGD}/usr/share/applications") __make_copy(_CMD_ _FILE_DIRS _FILE_FILES ${_bin_path}) __make_copy(_CMD_ _PLUG_DIRS _PLUG_FILES ${_pli_path}) __make_copy(_CMD_ _RES_DIRS _RES_FILES ${_res_path}) __make_copy(_CMD_ _LIBS_DIRS _LIBS_FILES ${_lib_path}) set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_DEPLOY_DIR}/$" "${_bin_path}/") if (_DEP_LIBS) set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_DEP_LIBS}" "${_lib_path}/") endif() if (_ICON_NAME) set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_ICON_FN}" "${_ico_path}/") endif() if(_DEB_OPT) set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_AGD}/usr/bin") set(_CMD_ ${_CMD_} COMMAND ln -srf ${_VERB} "${_bin_path}/$" "${_AGD}/usr/bin/$") endif() file(GLOB _files "${CMAKE_CURRENT_SOURCE_DIR}/debian/DEBIAN/*") foreach (_f ${_files}) set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_f}" "${_AGD}/DEBIAN/") endforeach() file(GLOB _files "${_AGD}/DEBIAN/p*inst" "${_AGD}/DEBIAN/p*rm" "${_AGD}/DEBIAN/config") foreach (_f ${_files}) set(_CMD_ ${_CMD_} COMMAND chmod 0755 ${_VERB} "${_f}") endforeach() if (NOT CMAKE_LDD) find_program(CMAKE_LDD ldd) endif() set(_dt_opts -l "${CMAKE_LDD}") if (CMAKE_CROSSCOMPILING) set(_dt_searchdirs "") foreach (_c ${CMAKE_PREFIX_PATH}) set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${_c}/lib") endforeach() if (NOT "x${CMAKE_LIBRARY_ARCHITECTURE}" STREQUAL "x") foreach (_c ${CMAKE_PREFIX_PATH}) set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${_c}/lib/${CMAKE_LIBRARY_ARCHITECTURE}") set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${_c}/../lib/${CMAKE_LIBRARY_ARCHITECTURE}") endforeach() endif() if (NOT "x${PIP_DEPLOY_LIBDIR}" STREQUAL "x") set(_dt_searchdirs "${_dt_searchdirs}${_dt_delim}${PIP_DEPLOY_LIBDIR}") endif() set(_dt_opts -L "${CMAKE_READELF}" --dpkg-workdir "${CMAKE_DPKG_WORKDIR}" -s "${_dt_searchdirs}") endif() list(APPEND _dt_opts -q "${Qt${_Qt_}_ROOT}" --qt-conf-dir "${_bin_path}" --qt-plugins-dir "${_pli_path}" --rpath) set(_deb_name "${_TV}_${_TARGET_OS}_${_DEB_ARCH}.deb") set(_TARGET_PACKAGE "${_deb_name}") #message("VER = \"${_DEBVERSION}\"") #message("DEB = \"${_deb_name}\"") list(APPEND _CMD_ COMMAND echo "Package: ${_DEBNAME}" ${_C_echof}) list(APPEND _CMD_ COMMAND echo "Version: ${_DEBVERSION}" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Architecture: ${_DEB_ARCH}" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Maintainer: ${${_T}_COMPANY} <>" ${_C_echo}) list(APPEND _CMD_ COMMAND ${PIP_DEPLOY_TOOL} ${_OPTIONS} --prefix "Depends: " --dependencies ${_dt_opts} -a "${_DEP_LIBS_CS}" -o "${_lib_path}" "${_bin_path}/$" ${_ADD_DEPS} ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Conflicts:" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Replaces:" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Section: misc" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Priority: optional" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Description: ${${_T}_INFO}" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "[Desktop Entry]" ${_D_echof}) list(APPEND _CMD_ COMMAND echo "Encoding=UTF-8" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "Type=Application" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "Name=${${_T}_LABEL}" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "GenericName=${${_T}_LABEL}" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "Comment=${${_T}_INFO}" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "Exec=${_app_bin_path}/${_T}" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "Icon=${_app_ico_path}/${_ICON_NAME}" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "Terminal=false" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "StartupNotify=true" ${_D_echo}) list(APPEND _CMD_ COMMAND echo "Categories=Utility;" ${_D_echo}) add_custom_target(deploy_${_T} # gather deb dir COMMAND rm -rf ${_VERB} "${_AGD}" COMMAND mkdir ${_VERB} -p "${_AGD}/DEBIAN" ${_CMD_} # generate deb COMMAND cd "${_AGD}" "&&" md5deep -rl opt usr ">" DEBIAN/md5sums COMMAND mkdir ${_VERB} -p "${_DESTINATION}" COMMAND dpkg-deb -Z gzip -b "${_AGD}" "${_DESTINATION}/${_deb_name}" VERBATIM COMMENT "Generating ${_deb_name}" ) set(_deployed "deploy_${_T}") if (_DEB_SERVICE) set(_CMD_) set(_DEB "${_TV}-service_deb_${_DEB_ARCH}") set(_AGD "${_DEPLOY_DIR}/${_DEB}") set(_C_echof ">" "${_AGD}/DEBIAN/control") set(_C_echo ">>" "${_AGD}/DEBIAN/control") set(_opt_path "${_AGD}/opt/${_app_dir}") set(_CMD_ ${_CMD_} COMMAND mkdir ${_VERB} -p "${_opt_path}") file(GLOB _files "${CMAKE_CURRENT_SOURCE_DIR}/debian-service/*.service") foreach (_f ${_files}) set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_f}" "${_opt_path}/") endforeach() set(__deb_dir "${CMAKE_CURRENT_SOURCE_DIR}/debian-service/DEBIAN") file(GLOB _files "${__deb_dir}/*") foreach (_f ${_files}) set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_f}" "${_AGD}/DEBIAN/") endforeach() file(GLOB _files RELATIVE "${__deb_dir}" "${__deb_dir}/p*inst" "${__deb_dir}/p*rm" "${__deb_dir}/config") foreach (_f ${_files}) set(_CMD_ ${_CMD_} COMMAND chmod 0755 ${_VERB} "${_AGD}/DEBIAN/${_f}") endforeach() set(_deb_name "${_TV}-service_${_TARGET_OS}_${_DEB_ARCH}.deb") #message("VER = \"${_DEBVERSION}\"") #message("DEB = \"${_deb_name}\"") list(APPEND _CMD_ COMMAND echo "Package: ${_DEBNAME}-service" ${_C_echof}) list(APPEND _CMD_ COMMAND echo "Version: ${_DEBVERSION}" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Architecture: ${_DEB_ARCH}" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Maintainer: ${${_T}_COMPANY} <>" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Depends: ${_DEBNAME} (>= ${_DEBVERSION})" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Conflicts:" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Replaces:" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Section: misc" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Priority: optional" ${_C_echo}) list(APPEND _CMD_ COMMAND echo "Description: ${${_T}_LABEL} service" ${_C_echo}) add_custom_target(deploy_${_T}-service # gather deb dir COMMAND rm -rf ${_VERB} "${_AGD}" COMMAND mkdir ${_VERB} -p "${_AGD}/DEBIAN" ${_CMD_} # generate deb COMMAND mkdir ${_VERB} -p "${_DESTINATION}" COMMAND dpkg-deb -Z gzip -b "${_AGD}" "${_DESTINATION}/${_deb_name}" VERBATIM COMMENT "Generating ${_deb_name}" ) list(APPEND _deployed "deploy_${_T}-service") endif() elseif(WIN32) if (NOT CMAKE_OBJDUMP) find_program(CMAKE_OBJDUMP objdump) endif() set(_AGD "${_DEPLOY_DIR}/${_TV}_win_${MY_ARCH}/") if (__win_host) string(REPLACE "/" "\\" CMAKE_OBJDUMP "${CMAKE_OBJDUMP}") endif() set(_var_exe "${_DEPLOY_DIR}/$") set(_var_empty) __make_dir(_CMD_ "${_AGD}") __make_dir(_CMD_ "${_DESTINATION}") __make_copy(_CMD_ _var_empty _var_exe "${_AGD}") __make_copy(_CMD_ _RES_DIRS _RES_FILES "${_AGD}") __make_copy(_CMD_ _PLUG_DIRS _PLUG_FILES "${_AGD}") __make_copy(_CMD_ _FILE_DIRS _FILE_FILES "${_AGD}") __make_copy(_CMD_ _LIBS_DIRS _LIBS_FILES "${_AGD}") set(_zip_name "${_TV}_${_TARGET_OS}_${_TARGET_ARCH}.zip") set(_TARGET_PACKAGE "${_zip_name}") set(_search_path "") foreach (_c ${CMAKE_PREFIX_PATH}) set(_search_path "${_search_path}${_dt_delim}${_c}/bin") endforeach() set(_search_path "${_search_path}${_dt_delim}${MINGW_BIN}${_add_search_path}${_dt_delim}${MINGW_LIB}") add_custom_target(deploy_${_T} # gather dir ${_CMD_} COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -W "\"${CMAKE_OBJDUMP}\"" -P windows,minimal -S windows -q "\"${Qt${_Qt_}_ROOT}\"" -s "\"${_search_path}\"" -o "${_AGD}" -p "${_AGD}" "\"${_AGD}$\"" ${_ADD_DEPS} # zip COMMAND cd "\"${_DEPLOY_DIR}\"" "&&" zip -q -r "\"${_DESTINATION}/${_zip_name}\"" "\"${_TV}_win_${MY_ARCH}\"" COMMENT "Generating ${_zip_name}" ) set(_deployed "deploy_${_T}") elseif (APPLE) set(MACOSX_BUNDLE_GUI_IDENTIFIER "${${_T}_FULLNAME}") set(MACOSX_BUNDLE_SHORT_VERSION_STRING "${${_T}_VERSION}") set(MACOSX_BUNDLE_LONG_VERSION_STRING "${${_T}_VERSION}") set(MACOSX_BUNDLE_ICON_FILE "${_ICON_NAME}") set(MACOSX_BUNDLE_BUNDLE_NAME "${${_T}_LABEL}") set(MACOSX_BUNDLE_COPYRIGHT "${${_T}_COMPANY}") set(MACOSX_BUNDLE_INFO_STRING "${${_T}_INFO}") set(MACOSX_BUNDLE_BUNDLE_VERSION "6.0") set(MACOSX_BUNDLE_SIGNATURE "????") set(MACOSX_BUNDLE_PRIVACIES "${__macos_privacies}") set_target_properties(${_T} PROPERTIES MACOSX_BUNDLE TRUE) set_target_properties(${_T} PROPERTIES MACOSX_BUNDLE_INFO_PLIST "${_modules_dir}/SHSMacOSBundle.plist.in") set(_AGD "${_DEPLOY_DIR}/${_T}.app") set(_DMG "${CMAKE_CURRENT_BINARY_DIR}/dmg") set(_bin_path "${_AGD}/Contents/MacOS") set(_lib_path "${_AGD}/Contents/Frameworks") set(_pli_path "${_AGD}/Contents/PlugIns") set(_res_path "${_AGD}/Contents/Resources") __make_copy(_CMD_ _RES_DIRS _RES_FILES "${_res_path}") __make_copy(_CMD_ _PLUG_DIRS _PLUG_FILES "${_pli_path}") __make_copy(_CMD_ _FILE_DIRS _FILE_FILES "${_bin_path}") __make_copy(_CMD_ _LIBS_DIRS _LIBS_FILES "${_lib_path}") if (_ICON_NAME) set(_CMD_ ${_CMD_} COMMAND cp ${_VERB} -f "${_ICON_FN}" "${_res_path}") endif() if (NOT CMAKE_OTOOL) set(CMAKE_OTOOL "otool") endif() if (NOT CMAKE_PREFIX_PATH) set(CMAKE_PREFIX_PATH "/usr/local") endif() set(_dmg_name "${_TV}_${_TARGET_OS}_${_TARGET_ARCH}.dmg") set(_TARGET_PACKAGE "${_dmg_name}") set(_cmd_gen_dmg COMMAND genisoimage -quiet -V "${MACOSX_BUNDLE_BUNDLE_NAME}" -D -R -apple -no-pad -o "${_DESTINATION}/${_dmg_name}" "${_DMG}") if (__mac_host) set(_cmd_gen_dmg COMMAND hdiutil create "${_DESTINATION}/${_dmg_name}" -ov -volname "${MACOSX_BUNDLE_BUNDLE_NAME}" -fs HFS+ -srcfolder "${_DMG}") endif() if (_ZIP_DMG) set(_cmd_gen_dmg ${_cmd_gen_dmg} COMMAND cd "${_DESTINATION}" "&&" zip -q -r "${_dmg_name}.zip" "${_dmg_name}") set(_cmd_gen_dmg ${_cmd_gen_dmg} COMMAND rm "\"${_DESTINATION}/${_dmg_name}\"") set(_TARGET_PACKAGE "${_dmg_name}.zip") endif() set(_comment "Generating ${_TARGET_PACKAGE}") set(_search_path "") foreach (_c ${CMAKE_PREFIX_PATH}) set(_search_path "${_search_path}${_dt_delim}${_c}/lib") endforeach() set(_search_path "${_search_path}${_add_search_path}") add_custom_target(deploy_${_T} # gather .app dir COMMAND mkdir ${_VERB} -p "${_res_path}" COMMAND mkdir ${_VERB} -p "${_lib_path}" COMMAND mkdir ${_VERB} -p "${_pli_path}" COMMAND mkdir ${_VERB} -p "${_DESTINATION}" ${_CMD_} COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -M "${CMAKE_OTOOL}" -P cocoa,minimal -S mac -q "${Qt5_ROOT}" --qt-conf-dir "${_res_path}" --qt-plugins-dir "${_pli_path}" -s "${_search_path}" -o "${_lib_path}" "${_bin_path}/${_T}" ${_ADD_DEPS} # prepare dmg dir COMMAND rm -rf "${_DMG}" COMMAND mkdir ${_VERB} -p "${_DMG}" COMMAND cp -r "${_AGD}" "${_DMG}" COMMAND ln ${_VERB} -s /Applications "${_DMG}" # generate dmg ${_cmd_gen_dmg} COMMENT "${_comment}" ) set(_deployed "deploy_${_T}") elseif (DEFINED ANDROID_PLATFORM) set(_res_files) set(_res_files "${_res_files}\n ") foreach (_f ${_RES_FILES}) set(_res_files "${_res_files}\n ${_f}") endforeach() set(_res_files "${_res_files}\n ") foreach (_d ${_RES_DIRS}) file(GLOB_RECURSE _df "${_d}/*") #message("FILES ${_d} = ${_df}") get_filename_component(_dn "${_d}" NAME) set(_res_files "${_res_files}\n ") foreach (_f ${_df}) get_filename_component(_fn "${_f}" NAME) set(_res_files "${_res_files}\n ${_f}") endforeach() set(_res_files "${_res_files}\n ") endforeach() set(_res_qrc "${CMAKE_CURRENT_BINARY_DIR}/android_res.qrc") file(WRITE "${_res_qrc}" "${_res_files}\n") set(_AT ${_T}_lib) set(_ATA ${_AT}_${ANDROID_ABI}) get_target_property(_sources ${_T} SOURCES) get_target_property(_libs ${_T} LINK_LIBRARIES) get_target_property(_incs ${_T} INCLUDE_DIRECTORIES) get_target_property(_defs ${_T} COMPILE_DEFINITIONS) qt5_add_resources(_res_out "${_res_qrc}") add_library(${_ATA} SHARED ${_sources} ${_res_out}) target_link_libraries(${_ATA} ${_libs}) target_include_directories(${_ATA} PRIVATE ${_incs}) target_compile_definitions(${_ATA} PRIVATE ${_defs}) set_target_properties(${_T} PROPERTIES EXCLUDE_FROM_ALL 1) #message("create new target ${_ATA} ${_sources} ${_libs}") set(_AGD "${_DEPLOY_DIR}/${_T}.android") __make_dir(_CMD_ "${_AGD}") set(_file) set(_dir "${CMAKE_BINARY_DIR}/android-build/libs" "${CMAKE_CURRENT_SOURCE_DIR}/android/res" "${CMAKE_CURRENT_SOURCE_DIR}/android/src") __make_copy(_CMD_ _dir _file "${_AGD}") set(_dir) set(_file "${Qt${_Qt_}_ROOT}/src/android/templates/res/values/libs.xml") __make_copy(_CMD_ _dir _file "${_AGD}/res/values") set(_dir "${Qt${_Qt_}_ROOT}/src/3rdparty/gradle/gradle") set(_file "${Qt${_Qt_}_ROOT}/src/3rdparty/gradle/gradlew" "${Qt${_Qt_}_ROOT}/src/3rdparty/gradle/gradlew.bat") __make_copy(_CMD_ _dir _file "${_AGD}") #message("bindir = ${CMAKE_CURRENT_SOURCE_DIR}") set(SDK_ROOT "$ENV{ANDROID_SDK_ROOT}") if("x${SDK_ROOT}" STREQUAL "x") set(SDK_ROOT "$ENV{ANDROID_HOME}") endif() set(__archs "armeabi-v7a" "arm64-v8a" "x86" "x86_64") set(QT_ANDROID_ARCHITECTURES) find_library(_lib_ c++_shared) foreach (_a ${__archs}) set(_aname "${_a}") if ("${_a}" STREQUAL "armeabi-v7a") set(_aname "arm") elseif ("${_a}" STREQUAL "arm64-v8a") set(_aname "arm64") endif() set(_exist 0) if ("${_a}" STREQUAL "${ANDROID_ABI}") set(_exist 1) elseif (EXISTS "${CMAKE_BINARY_DIR}/android-build/libs/${_a}") set(_exist 1) endif() if (_exist) string(REPLACE "${ANDROID_ABI}" "${_a}" _a_prefix "${CMAKE_PREFIX_PATH}") string(REPLACE "arch-${ANDROID_ARCH_NAME}" "arch-${_aname}" _a_prefix "${_a_prefix}") list(APPEND QT_ANDROID_ARCHITECTURES " \"${_a}\" : \"${ANDROID_SYSROOT_${_a}}\"") string(REPLACE "${ANDROID_SYSROOT_${ANDROID_ABI}}" "${ANDROID_SYSROOT_${_a}}" _lib_${_a} "${_lib_}") #message("search = ${_a_prefix}/lib") __make_copy(_CMD_ _empty _lib_${_a} "${_AGD}/libs/${_a}") set(_CMD_ ${_CMD_} COMMAND ${PIP_DEPLOY_TOOL} ${_VERB} ${_OPTIONS} -W "\"${CMAKE_OBJDUMP}\"" -s "${_a_prefix}/lib${_dt_delim}${Qt${_Qt_}_ROOT}/lib${_add_search_path}" -o "\"${_AGD}/libs/${_a}\"" --ignore "\"c${_dt_delim}m${_dt_delim}z${_dt_delim}dl${_dt_delim}log\"" "\"${_AGD}/libs/${_a}/lib${_AT}_${_a}.so\"" ${_ADD_DEPS}) #message("c++_${_a} -> ${_lib_${_a}}") endif() endforeach() string(REPLACE ";" ",\n" QT_ANDROID_ARCHITECTURES "${QT_ANDROID_ARCHITECTURES}") set(QT_ANDROID_APPLICATION_BINARY ${_AT}) set(ANDROID_LABEL "${${_T}_LABEL}") set(ANDROID_ICON "${${_T}_ICON}") set(ANDROID_VERSION "${${_T}_VERSION}") set(ANDROID_BUILD "${${_T}_VERSION_BUILD}") set(ANDROID_PACKAGE "${${_T}_FULLNAME}") set(ANDROID_TARGET_SDK "${${_T}_ANDROID_TARGET_SDK}") set(ANDROID_STORE_FILE "${${_T}_ANDROID_STORE_FILE}") set(ANDROID_STORE_PASSWORD "${${_T}_ANDROID_STORE_PASSWORD}") set(ANDROID_KEY_PASSWORD "${${_T}_ANDROID_KEY_PASSWORD}") set(ANDROID_KEY_ALIAS "${${_T}_ANDROID_KEY_ALIAS}") if (NOT IS_ABSOLUTE "${ANDROID_STORE_FILE}") set(ANDROID_STORE_FILE "${CMAKE_CURRENT_SOURCE_DIR}/android/${ANDROID_STORE_FILE}") endif() if (${_T}_ANDROID_NEW_LOADER) set(ANDROID_NEW_LOADER "true") else() set(ANDROID_NEW_LOADER "false") endif() set(__ANDROID_DEBUG_KEYSTORE__ "${_modules_dir}/android_debug.keystore") set(QT_DIR ${Qt${_Qt_}_ROOT}) set(_out_json "${CMAKE_CURRENT_BINARY_DIR}/${_T}_android_deployment_settings.json") configure_file("${CMAKE_BINARY_DIR}/android_deployment_settings.json.in" "${_out_json}") configure_file("${CMAKE_CURRENT_SOURCE_DIR}/android/AndroidManifest.xml.in" "${_AGD}/AndroidManifest.xml") configure_file("${_modules_dir}/gradle.properties.in" "${_AGD}/gradle.properties") set(_depstr) foreach (_d ${ANDROID_GRADLE_DEPENDENCIES}) set(_depstr "${_depstr}\n ${_d}") endforeach() set(__gradle_lang) foreach (_l ${${_T}_LANG}) if (NOT "x${__gradle_lang}" STREQUAL "x") set(__gradle_lang "${__gradle_lang}, ") endif() set(__gradle_lang "${__gradle_lang}\"${_l}\"") endforeach() if ("x${__gradle_lang}" STREQUAL "x") set(__gradle_lang "\"en\"") endif() file(READ "${Qt${_Qt_}_ROOT}/src/android/templates/build.gradle" _file) string(REPLACE "\ndependencies {" "\ndependencies {${_depstr}" _file "${_file}") string(REPLACE "\nandroid {" "\nandroid {\n${__gradle_sign}\n${__gradle_lang_start}${__gradle_lang}\n\t}\n" _file "${_file}") string(REPLACE "['resources']" "['res']" _file "${_file}") file(WRITE "${_AGD}/build.gradle" "${_file}") set(_gradle_home) if (NOT __win_host) set(_gradle_home "-g" "${CMAKE_BINARY_DIR}") endif() set(_CMD_ ${_CMD_} COMMAND "${Qt${_Qt_}_BIN}/androiddeployqt" --aux-mode --android-platform ${ANDROID_PLATFORM} --output "\"${_AGD}\"" --input "\"${_out_json}\"") set(_CMD_ ${_CMD_} COMMAND "${_AGD}/gradlew" ${_gradle_home} --no-daemon -p "\"${_AGD}\"" assembleDebug) set(_CMD_ ${_CMD_} COMMAND "${_AGD}/gradlew" ${_gradle_home} --no-daemon -p "\"${_AGD}\"" bundleRelease) set(_base_name "${_TV}_${_TARGET_OS}_${_TARGET_ARCH}") set(_TARGET_PACKAGE "${_base_name}.apk") set(_CMD_ ${_CMD_} COMMAND "${CMAKE_COMMAND}" -E copy "${_AGD}/build/outputs/apk/debug/${_T}.android-debug.apk" "${_DESTINATION}/${_base_name}.apk") if (ANDROID_STORE_FILE) set(_CMD_ ${_CMD_} COMMAND "${CMAKE_COMMAND}" -E copy "${_AGD}/build/outputs/bundle/release/${_T}.android-release.aab" "${_DESTINATION}/${_base_name}.aab") endif() add_custom_target(deploy_${_T} # gather .app dir ${_CMD_} COMMENT "Generating ${_base_name}.apk/aab" ) set(_deployed "deploy_${_T}") endif() if (_MANIFEST) configure_file("${_modules_dir}/DeployTarget.manifest.in" "${_DESTINATION}/${_TARGET_PACKAGE}.manifest") endif() foreach (_d ${_deployed}) add_dependencies(deploy ${_d}) endforeach() endmacro()