960 lines
35 KiB
CMake
960 lines
35 KiB
CMake
#[[
|
|
|
|
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(<target> [MAJOR <value>] [MINOR <value>] [REVISION <value>] [SUFFIX <value>] [BUILD <value>] [OUTPUT <file>])
|
|
|
|
Set target version, optionally creates file
|
|
|
|
Create variable <target>_VERSION with full version name
|
|
|
|
If OUTPUT then generate header <file> with
|
|
version macros - <target>_VERSION_<NAME>
|
|
Also create macro <target>_VERSION_NAME with full string version and
|
|
macro <target>_MAKE_VERSION(major, minor, revision) that returns
|
|
byte-packed integer version.
|
|
Attention: macro <target>_VERSION is byte-packed integer version!
|
|
|
|
|
|
|
|
|
|
set_lang(<target> <lang> [<lang> [...] ])
|
|
|
|
Set target translations, e.g. "ru" "fr"
|
|
|
|
|
|
|
|
|
|
import_version(<target> <source_target>)
|
|
|
|
Copy all version components and languages from <source_target>
|
|
|
|
|
|
|
|
|
|
import_deploy_properties(<target> <source_target>)
|
|
|
|
Copy all deploy properties from <source_target>
|
|
|
|
|
|
|
|
|
|
set_deploy_property(<target> [SHARED | STATIC] NAME <value> [NAME <value> [...] ])
|
|
|
|
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(<target> <rc_out_file>)
|
|
|
|
Generate Windows *.rc file from deploy properties
|
|
and return file path to <rc_out_file>
|
|
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(<target> [DEPLOY_DIR <dir>]
|
|
[DESTINATION <dir>]
|
|
[RESOURCES <dir|file> [<dir|file> ...] ]
|
|
[PLUGINS <dir|file> [<dir|file> ...] ]
|
|
[FILES <dir|file> [<dir|file> ...] ]
|
|
[LIBS <dir|file> [<dir|file> ...] ]
|
|
[OPTIONS <flag> ...]
|
|
[VERBOSE]
|
|
[DMG_NO_ZIP]
|
|
[DEB_USR_DIR]
|
|
[DEB_ADD_SERVICE]
|
|
[ADD_MANIFEST])
|
|
|
|
Create make target "deploy_<target>", 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
|
|
* <T>.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:
|
|
* "/$<TARGET_FILE:myexe>" - right, TARGET_FILE is absolute path
|
|
* "$<TARGET_FILE_NAME:myexe>" - right, relative item and TARGET_FILE_NAME is only filename
|
|
* "/$<TARGET_FILE_NAME:myexe>" - 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 <T>-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}$<TARGET_FILE_DIR:${_lib}>")
|
|
endif()
|
|
#message("add dep $<TARGET_FILE_DIR:${_lib}>/$<TARGET_FILE_NAME:${_lib}>")
|
|
set(${_dep_libs_cs_var} "${${_dep_libs_cs_var}}${_dt_delim}$<TARGET_FILE_DIR:${_lib}>/$<TARGET_FILE_NAME:${_lib}>")
|
|
set(${_dep_libs_var} "${${_dep_libs_var}}" "$<TARGET_FILE_DIR:${_lib}>/$<TARGET_FILE_NAME:${_lib}>")
|
|
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
|
|
"<key>NFCReaderUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSAppleMusicUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSBluetoothPeripheralUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSCalendarsUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSCameraUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSContactsUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSFaceIDUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSHealthShareUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSHealthUpdateUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSHomeKitUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSLocationAlwaysUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSLocationWhenInUseUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSMicrophoneUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSMotionUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSPhotoLibraryAddUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSPhotoLibraryUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSRemindersUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>
|
|
<key>NSVideoSubscriberAccountUsageDescription</key>
|
|
<string>${__macos_privacy_text}</string>"
|
|
)
|
|
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(_DEBUG_SUFFIX)
|
|
set(_OPTIONS "--strip;${CMAKE_STRIP}")
|
|
if (CMAKE_BUILD_TYPE MATCHES Debug)
|
|
list(APPEND _OPTIONS "--no-strip")
|
|
set(_DEBUG_SUFFIX "_debug")
|
|
endif()
|
|
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_BUILDTYPE "${${_T}_BUILDTYPE}")
|
|
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}/$<TARGET_FILE_NAME:${_T}>" "${_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}/$<TARGET_FILE_NAME:${_T}>" "${_AGD}/usr/bin/$<TARGET_FILE_NAME:${_T}>")
|
|
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}${_DEBUG_SUFFIX}.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}/$<TARGET_FILE_NAME:${_T}>" ${_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}${_DEBUG_SUFFIX}.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}/$<TARGET_FILE_NAME:${_T}>")
|
|
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}${_DEBUG_SUFFIX}.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}$<TARGET_FILE_NAME:${_T}>\"" ${_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}${_DEBUG_SUFFIX}.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 <qresource prefix=\"/\">")
|
|
foreach (_f ${_RES_FILES})
|
|
set(_res_files "${_res_files}\n <file>${_f}</file>")
|
|
endforeach()
|
|
set(_res_files "${_res_files}\n </qresource>")
|
|
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 <qresource prefix=\"${_dn}\">")
|
|
foreach (_f ${_df})
|
|
get_filename_component(_fn "${_f}" NAME)
|
|
set(_res_files "${_res_files}\n <file alias=\"${_fn}\">${_f}</file>")
|
|
endforeach()
|
|
set(_res_files "${_res_files}\n </qresource>")
|
|
endforeach()
|
|
set(_res_qrc "${CMAKE_CURRENT_BINARY_DIR}/android_res.qrc")
|
|
file(WRITE "${_res_qrc}" "<RCC>${_res_files}\n</RCC>")
|
|
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}${_DEBUG_SUFFIX}")
|
|
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()
|