Modules/Internal/CPack/CPackAPKMaven.cmake

# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file LICENSE.rst or https://cmake.org/licensing for details.

# Resolve the Maven dependencies listed in CPACK_APK_MAVEN_DEPENDENCIES the
# way Gradle resolves the runtime classpath of an Android application, and
# download them.  Included by CPackAPK.cmake.
#
# Gradle module metadata (`.module`) is used when published: the runtime
# variant for Android is selected and `available-at` redirections, which
# Kotlin Multiplatform libraries use, are followed.  Otherwise the POM is
# used.  The highest version requested wins, in the order of Gradle, only
# the modules at their selected versions requesting versions, and
# dependency constraints, including those of platforms, can raise versions
# or give them to dependencies that have none.  Exclusions apply below a
# module when they apply on every path to it.

if(NOT DEFINED CPACK_APK_MAVEN_REPOSITORIES)
  set(CPACK_APK_MAVEN_REPOSITORIES
    https://maven.google.com
    https://repo.maven.apache.org/maven2
    )
endif()
set(_maven_repositories)
# Relative paths are relative to the directory cpack runs in, like those of
# the other variables.
file(REAL_PATH "." _cpack_directory)
foreach(_repository IN LISTS CPACK_APK_MAVEN_REPOSITORIES)
  # A local directory is a repository as well.  It need not exist.
  if(NOT _repository MATCHES "^[A-Za-z][A-Za-z0-9+.-]*://")
    cmake_path(ABSOLUTE_PATH _repository
      BASE_DIRECTORY "${_cpack_directory}" NORMALIZE)
    if(NOT _repository MATCHES "^/")
      string(PREPEND _repository "/")
    endif()
    string(PREPEND _repository "file://")
  endif()
  string(REGEX REPLACE "/+$" "" _repository "${_repository}")
  list(APPEND _maven_repositories "${_repository}")
endforeach()

if(NOT CPACK_APK_MAVEN_CACHE_DIRECTORY)
  # Next to the top level directory, which is removed after packaging.
  set(CPACK_APK_MAVEN_CACHE_DIRECTORY
    "${CPACK_PACKAGE_DIRECTORY}/_CPack_Packages/maven")
endif()

# Download `url` to `file` unless it exists.  Sets `result` to TRUE on
# success.  An optional `<algorithm>=<hash>` argument is verified.
function(_cpack_apk_maven_download url file result)
  if(EXISTS "${file}")
    set(${result} TRUE PARENT_SCOPE)
    return()
  endif()
  file(DOWNLOAD "${url}" "${file}.part" STATUS _status)
  list(GET _status 0 _code)
  if(NOT _code EQUAL 0)
    file(REMOVE "${file}.part")
    set(${result} FALSE PARENT_SCOPE)
    return()
  endif()
  if(ARGV3 MATCHES "^([A-Z0-9]+)=(.+)$")
    set(_expected "${CMAKE_MATCH_2}")
    file(${CMAKE_MATCH_1} "${file}.part" _actual)
    if(NOT _actual STREQUAL _expected)
      file(REMOVE "${file}.part")
      message(FATAL_ERROR
        "CPack APK: The file downloaded from\n"
        "  ${url}\n"
        "does not have the ${CMAKE_MATCH_1} hash the repository publishes.\n"
        "  Expected: ${_expected}\n"
        "  Actual:   ${_actual}")
    endif()
  endif()
  file(RENAME "${file}.part" "${file}")
  # Repositories are tried in turn, so only the successful download is
  # reported.
  message(STATUS "CPack APK: Downloaded ${url}")
  set(${result} TRUE PARENT_SCOPE)
endfunction()

# Download `name` of `group:artifact:version` from the first repository
# that has it, into the cache.  Sets `result` to the local path, or to an
# empty string when no repository has it.
function(_cpack_apk_maven_fetch group artifact version name result)
  string(REPLACE "." "/" _group_path "${group}")
  set(_relative "${_group_path}/${artifact}/${version}/${name}")
  set(_file "${CPACK_APK_MAVEN_CACHE_DIRECTORY}/${_relative}")
  foreach(_repository IN LISTS _maven_repositories)
    _cpack_apk_maven_download("${_repository}/${_relative}" "${_file}" _ok
      ${ARGN})
    if(_ok)
      set(${result} "${_file}" PARENT_SCOPE)
      return()
    endif()
  endforeach()
  set(${result} "" PARENT_SCOPE)
endfunction()

# Split `group:artifact:version` into the variables named by the other
# arguments.
function(_cpack_apk_maven_split coordinates group_var artifact_var version_var)
  string(REPLACE ":" ";" _parts "${coordinates}")
  list(LENGTH _parts _length)
  if(NOT _length EQUAL 3)
    message(FATAL_ERROR
      "CPack APK: '${coordinates}' is not of the form "
      "<group>:<artifact>:<version>.")
  endif()
  list(GET _parts 0 _group)
  list(GET _parts 1 _artifact)
  list(GET _parts 2 _version)
  set(${group_var} "${_group}" PARENT_SCOPE)
  set(${artifact_var} "${_artifact}" PARENT_SCOPE)
  set(${version_var} "${_version}" PARENT_SCOPE)
endfunction()

# Strip the brackets of a hard version requirement, `[1.2.3]` -> `1.2.3`.
function(_cpack_apk_maven_plain_version version context result)
  string(REGEX REPLACE "^\\[([^,]*)\\]$" "\\1" _version "${version}")
  if(_version MATCHES "[][(),]")
    message(FATAL_ERROR
      "CPack APK: ${context} requires the version range '${version}'.  "
      "Version ranges are not supported.")
  endif()
  set(${result} "${_version}" PARENT_SCOPE)
endfunction()

# Split `version` into the parts Gradle compares: separated by `.`, `-`,
# `_` and `+`, and where digits and other characters meet.
function(_cpack_apk_maven_version_parts version result)
  string(REGEX REPLACE "[-_+]" "." _version "${version}")
  string(REGEX REPLACE "([0-9])([^0-9.])" "\\1.\\2" _version "${_version}")
  string(REGEX REPLACE "([^0-9.])([0-9])" "\\1.\\2" _version "${_version}")
  string(REGEX REPLACE "\\.\\.+" "." _version "${_version}")
  string(REGEX REPLACE "^\\.|\\.$" "" _version "${_version}")
  string(REPLACE "." ";" _version "${_version}")
  set(${result} "${_version}" PARENT_SCOPE)
endfunction()

# Rank of the version part `part`: `dev` is below the other qualifiers,
# `rc`, `snapshot`, `final`, `ga`, `release` and `sp` are above them, in
# this order, and numbers are above all qualifiers.
function(_cpack_apk_maven_version_rank part result)
  if(part MATCHES "^[0-9]+$")
    set(${result} 8 PARENT_SCOPE)
    return()
  endif()
  string(TOLOWER "${part}" _part)
  list(FIND _cpack_apk_maven_qualifiers "${_part}" _rank)
  if(_rank EQUAL -1)
    set(_rank 1)
  endif()
  set(${result} ${_rank} PARENT_SCOPE)
endfunction()
set(_cpack_apk_maven_qualifiers dev _other_ rc snapshot final ga release sp)

# Set `result` to 1, 0 or -1 as the version `a` is higher than, equal to or
# lower than `b`, the way Gradle orders versions.  `1.0-alpha` is lower
# than `1.0`, which is lower than `1.0.1`.
function(_cpack_apk_maven_version_compare a b result)
  _cpack_apk_maven_version_parts("${a}" _a)
  _cpack_apk_maven_version_parts("${b}" _b)
  list(LENGTH _a _a_length)
  list(LENGTH _b _b_length)
  set(_length ${_a_length})
  if(_b_length LESS _length)
    set(_length ${_b_length})
  endif()
  set(_i 0)
  while(_i LESS _length)
    list(GET _a ${_i} _a_part)
    list(GET _b ${_i} _b_part)
    _cpack_apk_maven_version_rank("${_a_part}" _a_rank)
    _cpack_apk_maven_version_rank("${_b_part}" _b_rank)
    if(_a_rank GREATER _b_rank)
      set(${result} 1 PARENT_SCOPE)
      return()
    elseif(_a_rank LESS _b_rank)
      set(${result} -1 PARENT_SCOPE)
      return()
    elseif(_a_rank EQUAL 8)
      if(_a_part GREATER _b_part)
        set(${result} 1 PARENT_SCOPE)
        return()
      elseif(_a_part LESS _b_part)
        set(${result} -1 PARENT_SCOPE)
        return()
      endif()
    elseif(_a_rank EQUAL 1)
      if(_a_part STRGREATER _b_part)
        set(${result} 1 PARENT_SCOPE)
        return()
      elseif(_a_part STRLESS _b_part)
        set(${result} -1 PARENT_SCOPE)
        return()
      endif()
    endif()
    math(EXPR _i "${_i} + 1")
  endwhile()
  # The longer version is higher if its next part is a number, and lower
  # otherwise.
  if(_a_length EQUAL _b_length)
    set(${result} 0 PARENT_SCOPE)
    return()
  elseif(_a_length GREATER _b_length)
    list(GET _a ${_length} _part)
    set(_sign 1)
  else()
    list(GET _b ${_length} _part)
    set(_sign -1)
  endif()
  if(NOT _part MATCHES "^[0-9]+$")
    math(EXPR _sign "-${_sign}")
  endif()
  set(${result} ${_sign} PARENT_SCOPE)
endfunction()

# Remove from `xml` the text from each `open` to the following `close`.
function(_cpack_apk_maven_xml_remove xml open close result)
  string(LENGTH "${close}" _close_length)
  while(TRUE)
    string(FIND "${xml}" "${open}" _begin)
    if(_begin EQUAL -1)
      break()
    endif()
    string(SUBSTRING "${xml}" ${_begin} -1 _tail)
    string(FIND "${_tail}" "${close}" _end)
    if(_end EQUAL -1)
      break()
    endif()
    math(EXPR _end "${_end} + ${_close_length}")
    string(SUBSTRING "${xml}" 0 ${_begin} _head)
    string(SUBSTRING "${_tail}" ${_end} -1 _tail)
    set(xml "${_head}${_tail}")
  endwhile()
  set(${result} "${xml}" PARENT_SCOPE)
endfunction()

# Set `result` to the content of the first element `tag` of `xml`, or to
# an empty string.
function(_cpack_apk_maven_xml_element xml tag result)
  set(_content "")
  string(FIND "${xml}" "<${tag}>" _begin)
  if(_begin GREATER -1)
    string(LENGTH "<${tag}>" _length)
    math(EXPR _begin "${_begin} + ${_length}")
    string(SUBSTRING "${xml}" ${_begin} -1 _content)
    string(FIND "${_content}" "</${tag}>" _end)
    if(_end GREATER -1)
      string(SUBSTRING "${_content}" 0 ${_end} _content)
    endif()
  endif()
  set(${result} "${_content}" PARENT_SCOPE)
endfunction()

# Set `result` to TRUE if `group:artifact` matches one of the `excludes`,
# `group:artifact` patterns in which either part may be `*`.
function(_cpack_apk_maven_excluded group artifact excludes result)
  foreach(_exclude IN LISTS excludes)
    if(NOT _exclude MATCHES "^([^:]*):(.*)$")
      continue()
    endif()
    set(_group "${CMAKE_MATCH_1}")
    set(_artifact "${CMAKE_MATCH_2}")
    if((_group STREQUAL "*" OR _group STREQUAL group)
        AND (_artifact STREQUAL "*" OR _artifact STREQUAL artifact))
      set(${result} TRUE PARENT_SCOPE)
      return()
    endif()
  endforeach()
  set(${result} FALSE PARENT_SCOPE)
endfunction()

# Index of the variant of the module metadata `json` that Gradle picks for
# the runtime classpath of an Android application, or an empty string.
# `kind` is `library`, or `platform` for a platform, which only has
# dependency constraints.
function(_cpack_apk_maven_variant json kind result)
  set(_best "")
  set(_best_score 0)
  string(JSON _count LENGTH "${json}" variants)
  if(_count EQUAL 0)
    set(${result} "" PARENT_SCOPE)
    return()
  endif()
  math(EXPR _last "${_count} - 1")
  foreach(_i RANGE ${_last})
    foreach(_attribute IN ITEMS usage category platform environment build_type)
      set(_${_attribute} "")
    endforeach()
    foreach(_pair IN ITEMS
        usage=org.gradle.usage
        category=org.gradle.category
        platform=org.jetbrains.kotlin.platform.type
        environment=org.gradle.jvm.environment
        build_type=com.android.build.api.attributes.BuildTypeAttr)
      string(REPLACE "=" ";" _pair "${_pair}")
      list(GET _pair 0 _attribute)
      list(GET _pair 1 _name)
      string(JSON _value ERROR_VARIABLE _error
        GET "${json}" variants ${_i} attributes ${_name})
      if(NOT _error)
        set(_${_attribute} "${_value}")
      endif()
    endforeach()
    if(NOT _usage STREQUAL "java-runtime")
      continue()
    endif()
    if(kind STREQUAL "platform")
      if(NOT _category MATCHES "^(enforced-)?platform$")
        continue()
      endif()
    elseif(_category AND NOT _category STREQUAL "library")
      continue()
    endif()
    set(_score 2)
    if(_platform STREQUAL "androidJvm")
      math(EXPR _score "${_score} + 8")
    elseif(_platform STREQUAL "jvm")
      math(EXPR _score "${_score} + 4")
    elseif(_platform)
      # Kotlin/Native, JavaScript, WebAssembly or common metadata.
      continue()
    endif()
    if(_environment STREQUAL "android")
      math(EXPR _score "${_score} + 2")
    endif()
    # Libraries publishing all their Android build types have a debug and a
    # release variant; the application is packaged for release.
    if(_build_type STREQUAL "" OR _build_type STREQUAL "release")
      math(EXPR _score "${_score} + 1")
    endif()
    if(_score GREATER _best_score)
      set(_best ${_i})
      set(_best_score ${_score})
    endif()
  endforeach()
  set(${result} "${_best}" PARENT_SCOPE)
endfunction()

# Read the Gradle module metadata `json` of `coordinates`, as a `kind`.
function(_cpack_apk_maven_module json kind coordinates)
  _cpack_apk_maven_variant("${json}" ${kind} _variant)
  if(_variant STREQUAL "")
    if(kind STREQUAL "platform")
      set(_what "platform variant")
    else()
      set(_what "variant")
    endif()
    message(FATAL_ERROR
      "CPack APK: The Maven module '${coordinates}' has no ${_what} for the "
      "Java runtime.")
  endif()
  set(_deps)
  set(_constraints)
  set(_redirect)
  set(_files)
  string(JSON _available ERROR_VARIABLE _error
    GET "${json}" variants ${_variant} available-at)
  if(NOT _error)
    string(JSON _g GET "${_available}" group)
    string(JSON _m GET "${_available}" module)
    string(JSON _v GET "${_available}" version)
    set(_redirect "${_g}:${_m}:${_v}")
  else()
    foreach(_kind IN ITEMS dependencies dependencyConstraints)
      string(JSON _count ERROR_VARIABLE _error
        LENGTH "${json}" variants ${_variant} ${_kind})
      if(_error OR _count EQUAL 0)
        continue()
      endif()
      math(EXPR _last "${_count} - 1")
      foreach(_i RANGE ${_last})
        string(JSON _dep GET "${json}" variants ${_variant} ${_kind} ${_i})
        string(JSON _g GET "${_dep}" group)
        string(JSON _m GET "${_dep}" module)
        set(_v)
        foreach(_key IN ITEMS strictly requires prefers)
          string(JSON _v ERROR_VARIABLE _error GET "${_dep}" version ${_key})
          if(NOT _error)
            break()
          endif()
          set(_v)
        endforeach()
        if(_v)
          _cpack_apk_maven_plain_version("${_v}"
            "The Maven module '${coordinates}'" _v)
        endif()
        if(_kind STREQUAL "dependencyConstraints")
          # A constraint without a version, which only rejects versions,
          # does not raise one.
          if(_v)
            list(APPEND _constraints "${_g}:${_m}:${_v}")
          endif()
          continue()
        endif()
        # A platform has no artifacts, but its constraints give versions,
        # including to dependencies that have none.
        set(_dep_kind library)
        string(JSON _category ERROR_VARIABLE _error
          GET "${_dep}" attributes org.gradle.category)
        if(NOT _error AND _category MATCHES "platform")
          set(_dep_kind platform)
        endif()
        set(_excludes)
        string(JSON _excludes_count ERROR_VARIABLE _error
          LENGTH "${_dep}" excludes)
        if(NOT _error AND _excludes_count GREATER 0)
          math(EXPR _excludes_last "${_excludes_count} - 1")
          foreach(_j RANGE ${_excludes_last})
            foreach(_field IN ITEMS group module)
              string(JSON _${_field} ERROR_VARIABLE _error
                GET "${_dep}" excludes ${_j} ${_field})
              if(_error)
                set(_${_field} "*")
              endif()
            endforeach()
            list(APPEND _excludes "${_group}:${_module}")
          endforeach()
        endif()
        list(JOIN _excludes "," _excludes)
        list(APPEND _deps "${_dep_kind}|${_g}:${_m}:${_v}|${_excludes}")
      endforeach()
    endforeach()
    string(JSON _count ERROR_VARIABLE _error
      LENGTH "${json}" variants ${_variant} files)
    if(NOT _error AND _count GREATER 0)
      math(EXPR _last "${_count} - 1")
      foreach(_i RANGE ${_last})
        string(JSON _url GET "${json}" variants ${_variant} files ${_i} url)
        string(JSON _sha256 GET "${json}" variants ${_variant} files ${_i} sha256)
        string(TOLOWER "${_sha256}" _sha256)
        list(APPEND _files "${_url}|SHA256=${_sha256}")
      endforeach()
    endif()
  endif()
  set(_maven_deps "${_deps}" PARENT_SCOPE)
  set(_maven_constraints "${_constraints}" PARENT_SCOPE)
  set(_maven_redirect "${_redirect}" PARENT_SCOPE)
  set(_maven_files "${_files}" PARENT_SCOPE)
endfunction()

# The `<dependency>` elements of `xml`, as
# `group|artifact|version|scope|optional|excludes`, where `excludes` are
# the `group:artifact` of its exclusions, joined by `,`.  The `[` and `]`
# of version ranges would keep lists from being split, so they are given
# as `<lb>` and `<rb>`, which the elements cannot hold.
function(_cpack_apk_maven_pom_dependencies xml result)
  set(_space "[ \t\r\n]*")
  set(_deps)
  string(LENGTH "<dependency>" _open_length)
  string(LENGTH "<exclusion>" _exclusion_open_length)
  while(TRUE)
    string(FIND "${xml}" "<dependency>" _begin)
    if(_begin EQUAL -1)
      break()
    endif()
    math(EXPR _begin "${_begin} + ${_open_length}")
    string(SUBSTRING "${xml}" ${_begin} -1 xml)
    string(FIND "${xml}" "</dependency>" _end)
    string(SUBSTRING "${xml}" 0 ${_end} _chunk)
    # The transitive dependencies to leave out.
    _cpack_apk_maven_xml_element("${_chunk}" exclusions _exclusions)
    _cpack_apk_maven_xml_remove("${_chunk}" "<exclusions>" "</exclusions>"
      _chunk)
    set(_excludes)
    while(TRUE)
      string(FIND "${_exclusions}" "<exclusion>" _begin)
      if(_begin EQUAL -1)
        break()
      endif()
      math(EXPR _begin "${_begin} + ${_exclusion_open_length}")
      string(SUBSTRING "${_exclusions}" ${_begin} -1 _exclusions)
      string(FIND "${_exclusions}" "</exclusion>" _end)
      string(SUBSTRING "${_exclusions}" 0 ${_end} _exclusion)
      foreach(_tag IN ITEMS groupId artifactId)
        set(_${_tag} "*")
        if(_exclusion MATCHES "<${_tag}>${_space}([^< \t\r\n]+)${_space}</${_tag}>")
          set(_${_tag} "${CMAKE_MATCH_1}")
        endif()
      endforeach()
      string(APPEND _excludes ",${_groupId}:${_artifactId}")
    endwhile()
    string(REGEX REPLACE "^," "" _excludes "${_excludes}")
    foreach(_tag IN ITEMS groupId artifactId version scope optional)
      set(_${_tag})
      if(_chunk MATCHES "<${_tag}>${_space}([^< \t\r\n]*)${_space}</${_tag}>")
        set(_${_tag} "${CMAKE_MATCH_1}")
      endif()
    endforeach()
    set(_entry
      "${_groupId}|${_artifactId}|${_version}|${_scope}|${_optional}|${_excludes}")
    string(REPLACE "[" "<lb>" _entry "${_entry}")
    string(REPLACE "]" "<rb>" _entry "${_entry}")
    list(APPEND _deps "${_entry}")
  endwhile()
  set(${result} "${_deps}" PARENT_SCOPE)
endfunction()

# Set `result` to the version `value` given by
# `_cpack_apk_maven_pom_dependencies`, with its `[` and `]` restored.
function(_cpack_apk_maven_pom_dependency_version value result)
  string(REPLACE "<lb>" "[" value "${value}")
  string(REPLACE "<rb>" "]" value "${value}")
  set(${result} "${value}" PARENT_SCOPE)
endfunction()

# Set `result` to `value`, the `what` of `dependency` in the POM of
# `group:artifact:version`, whose `<properties>` element holds `properties`,
# with the properties it refers to replaced.
function(_cpack_apk_maven_pom_property value properties group artifact version
    dependency what result)
  set(_space "[ \t\r\n]*")
  # Properties of this POM; those of parent POMs are not known.
  while(value MATCHES "\\$\\{([^}]*)\\}")
    set(_property "${CMAKE_MATCH_1}")
    if(_property MATCHES "^((project|pom)\\.)?groupId$")
      set(_value "${group}")
    elseif(_property MATCHES "^((project|pom)\\.)?artifactId$")
      set(_value "${artifact}")
    elseif(_property MATCHES "^((project|pom)\\.)?version$")
      set(_value "${version}")
    elseif(properties MATCHES "<${_property}>${_space}([^<]*[^< \t\r\n])${_space}</${_property}>")
      set(_value "${CMAKE_MATCH_1}")
    else()
      message(FATAL_ERROR
        "CPack APK: The ${what} of '${dependency}' in the POM of "
        "'${group}:${artifact}:${version}' refers to the unknown property "
        "'${_property}'.  Parent POMs are not supported.")
    endif()
    string(REPLACE "\${${_property}}" "${_value}" value "${value}")
  endwhile()
  set(${result} "${value}" PARENT_SCOPE)
endfunction()

# Set `result` to the version `value` of `dependency` in the POM of
# `group:artifact:version`, whose `<properties>` element holds
# `properties`.
function(_cpack_apk_maven_pom_version value properties group artifact version
    dependency result)
  _cpack_apk_maven_pom_property("${value}" "${properties}"
    ${group} ${artifact} ${version} "${dependency}" version value)
  if(NOT value STREQUAL "")
    _cpack_apk_maven_plain_version("${value}"
      "The POM of '${group}:${artifact}:${version}'" value)
  endif()
  set(${result} "${value}" PARENT_SCOPE)
endfunction()

# Replace the properties that the group and artifact held by the variables
# named `group_var` and `artifact_var` refer to, in the POM of
# `group:artifact:version`, whose `<properties>` element holds `properties`.
# Modules often name the group of their siblings `${project.groupId}`.
function(_cpack_apk_maven_pom_coordinates group_var artifact_var properties
    group artifact version)
  set(_dependency "${${group_var}}:${${artifact_var}}")
  _cpack_apk_maven_pom_property("${${group_var}}" "${properties}"
    ${group} ${artifact} ${version} "${_dependency}" group _group)
  _cpack_apk_maven_pom_property("${${artifact_var}}" "${properties}"
    ${group} ${artifact} ${version} "${_dependency}" artifact _artifact)
  set(${group_var} "${_group}" PARENT_SCOPE)
  set(${artifact_var} "${_artifact}" PARENT_SCOPE)
endfunction()

# Read the POM `pom` of `group:artifact:version`, as a `kind`.  A platform
# has the versions the POM manages as dependency constraints, and the
# platforms it imports as dependencies.
function(_cpack_apk_maven_pom pom kind group artifact version)
  file(READ "${pom}" _content)
  string(REPLACE ";" "," _content "${_content}")
  # Only the elements of the project itself count, not those in comments,
  # profiles or the build, such as the dependencies of plugins.
  _cpack_apk_maven_xml_remove("${_content}" "<!--" "-->" _content)
  foreach(_tag IN ITEMS profiles build reporting)
    _cpack_apk_maven_xml_remove("${_content}" "<${_tag}>" "</${_tag}>"
      _content)
  endforeach()
  _cpack_apk_maven_xml_element("${_content}" properties _properties)
  _cpack_apk_maven_xml_element("${_content}" dependencyManagement _managed)
  _cpack_apk_maven_xml_remove("${_content}"
    "<dependencyManagement>" "</dependencyManagement>" _content)

  set(_deps)
  set(_constraints)
  _cpack_apk_maven_pom_dependencies("${_managed}" _managed)
  foreach(_entry IN LISTS _managed)
    string(REPLACE "|" ";" _fields "${_entry}")
    list(GET _fields 0 _g)
    list(GET _fields 1 _a)
    list(GET _fields 2 _v)
    list(GET _fields 3 _scope)
    _cpack_apk_maven_pom_dependency_version("${_v}" _v)
    _cpack_apk_maven_pom_coordinates(_g _a "${_properties}"
      ${group} ${artifact} ${version})
    if(kind STREQUAL "platform")
      _cpack_apk_maven_pom_version("${_v}" "${_properties}"
        ${group} ${artifact} ${version} "${_g}:${_a}" _v)
      if(_v STREQUAL "")
        continue()
      endif()
      if(_scope STREQUAL "import")
        list(APPEND _deps "platform|${_g}:${_a}:${_v}|")
      else()
        list(APPEND _constraints "${_g}:${_a}:${_v}")
      endif()
    elseif(NOT _scope STREQUAL "import")
      # The versions of the dependencies that do not give one.
      string(MAKE_C_IDENTIFIER "${_g}:${_a}" _id)
      set(_managed_${_id} "${_v}")
    endif()
  endforeach()

  set(_files)
  if(kind STREQUAL "library")
    _cpack_apk_maven_pom_dependencies("${_content}" _dependencies)
    foreach(_entry IN LISTS _dependencies)
      string(REPLACE "|" ";" _fields "${_entry}")
      list(GET _fields 0 _g)
      list(GET _fields 1 _a)
      list(GET _fields 2 _v)
      list(GET _fields 3 _scope)
      list(GET _fields 4 _optional)
      list(GET _fields 5 _excludes)
      _cpack_apk_maven_pom_dependency_version("${_v}" _v)
      _cpack_apk_maven_pom_coordinates(_g _a "${_properties}"
        ${group} ${artifact} ${version})
      string(REPLACE "," ";" _excludes "${_excludes}")
      set(_resolved_excludes)
      foreach(_exclude IN LISTS _excludes)
        string(REPLACE ":" ";" _exclude "${_exclude}")
        list(GET _exclude 0 _eg)
        list(GET _exclude 1 _ea)
        _cpack_apk_maven_pom_coordinates(_eg _ea "${_properties}"
          ${group} ${artifact} ${version})
        list(APPEND _resolved_excludes "${_eg}:${_ea}")
      endforeach()
      list(JOIN _resolved_excludes "," _excludes)
      if(_scope AND NOT _scope MATCHES "^(compile|runtime)$")
        continue()
      endif()
      if(_optional STREQUAL "true")
        continue()
      endif()
      if(_v STREQUAL "")
        string(MAKE_C_IDENTIFIER "${_g}:${_a}" _id)
        set(_v "${_managed_${_id}}")
      endif()
      _cpack_apk_maven_pom_version("${_v}" "${_properties}"
        ${group} ${artifact} ${version} "${_g}:${_a}" _v)
      if(_v STREQUAL "")
        message(FATAL_ERROR
          "CPack APK: The POM of '${group}:${artifact}:${version}' does not "
          "give the version of '${_g}:${_a}'.  Parent POMs and imported "
          "BOMs are not supported.")
      endif()
      list(APPEND _deps "library|${_g}:${_a}:${_v}|${_excludes}")
    endforeach()

    set(_space "[ \t\r\n]*")
    set(_packaging jar)
    if(_content MATCHES "<packaging>${_space}([^< \t\r\n]*)")
      set(_packaging "${CMAKE_MATCH_1}")
    endif()
    if(_packaging STREQUAL "bundle")
      set(_packaging jar)
    endif()
    if(NOT _packaging STREQUAL "pom")
      set(_name "${artifact}-${version}.${_packaging}")
      _cpack_apk_maven_fetch(${group} ${artifact} ${version} "${_name}.sha1"
        _sha1_file)
      if(_sha1_file)
        file(STRINGS "${_sha1_file}" _sha1 LIMIT_COUNT 1 REGEX "^[0-9a-fA-F]+")
        string(REGEX MATCH "^[0-9a-fA-F]+" _sha1 "${_sha1}")
        string(TOLOWER "${_sha1}" _sha1)
        list(APPEND _files "${_name}|SHA1=${_sha1}")
      else()
        list(APPEND _files "${_name}|")
      endif()
    endif()
  endif()
  set(_maven_deps "${_deps}" PARENT_SCOPE)
  set(_maven_constraints "${_constraints}" PARENT_SCOPE)
  set(_maven_redirect "" PARENT_SCOPE)
  set(_maven_files "${_files}" PARENT_SCOPE)
endfunction()

# Read the metadata of `group:artifact:version` as a `kind`, `library` or
# `platform`, and set in the caller:
#   _maven_deps         its dependencies, `kind|group:artifact:version|excludes`,
#                       where the version may be empty and `excludes` are
#                       `group:artifact` patterns joined by `,`
#   _maven_constraints  its dependency constraints, `group:artifact:version`
#   _maven_redirect     the `group:artifact:version` it moved to, if any
#   _maven_files        its files, `name|algorithm=hash`
function(_cpack_apk_maven_metadata kind group artifact version)
  set(_coordinates "${group}:${artifact}:${version}")
  _cpack_apk_maven_fetch(${group} ${artifact} ${version}
    "${artifact}-${version}.module" _module)
  if(_module)
    file(READ "${_module}" _json)
    _cpack_apk_maven_module("${_json}" ${kind} "${_coordinates}")
  else()
    _cpack_apk_maven_fetch(${group} ${artifact} ${version}
      "${artifact}-${version}.pom" _pom)
    if(NOT _pom)
      list(JOIN _maven_repositories ", " _repositories)
      message(FATAL_ERROR
        "CPack APK: The Maven artifact '${_coordinates}' was not found in "
        "any of: ${_repositories}")
    endif()
    _cpack_apk_maven_pom("${_pom}" ${kind} ${group} ${artifact} ${version})
  endif()
  foreach(_field IN ITEMS deps constraints redirect files)
    set(_maven_${_field} "${_maven_${_field}}" PARENT_SCOPE)
  endforeach()
endfunction()

# Set `result` to TRUE if the version `a` is higher than `b`, or `b` is
# empty.
function(_cpack_apk_maven_version_higher a b result)
  set(_higher TRUE)
  if(NOT b STREQUAL "")
    _cpack_apk_maven_version_compare("${a}" "${b}" _order)
    if(NOT _order EQUAL 1)
      set(_higher FALSE)
    endif()
  endif()
  set(${result} ${_higher} PARENT_SCOPE)
endfunction()

# Resolve CPACK_APK_MAVEN_DEPENDENCIES and set `result` to the downloaded
# archives.
function(_cpack_apk_maven_resolve result)
  list(JOIN CPACK_APK_MAVEN_DEPENDENCIES ", " _dependencies)
  message(STATUS "CPack APK: Resolving Maven dependencies: ${_dependencies}")
  # The graph is walked again whenever the version of a module, or the
  # exclusions that apply below it, change after it was visited, until
  # they are stable.  Exclusions only shrink.  Each walk starts from the
  # versions the modules were requested at, and constrained to, in the
  # previous one, so that, as with Gradle, the versions a module no longer
  # selected requests do not count.  Should those versions cycle, they are
  # only raised from then on.
  set(_ids)
  set(_states)
  set(_monotonic FALSE)
  set(_walk TRUE)
  while(_walk)
    set(_walk FALSE)
    set(_visited)
    set(_visited_modules)
    set(_selected_files)
    set(_pending)
    foreach(_id IN LISTS _ids)
      set(_selected_${_id} "${_floor_${_id}}")
      set(_constraint_${_id} "${_floor_constraint_${_id}}")
      set(_requested_${_id})
      set(_constrained_${_id})
    endforeach()
    # Entries are `kind|group:artifact:version|excludes`.
    set(_queue)
    foreach(_dependency IN LISTS CPACK_APK_MAVEN_DEPENDENCIES)
      list(APPEND _queue "library|${_dependency}|")
    endforeach()
    while(_queue)
      while(_queue)
        list(POP_FRONT _queue _entry)
        string(REPLACE "|" ";" _fields "${_entry}")
        list(GET _fields 0 _kind)
        list(GET _fields 1 _coordinates)
        list(GET _fields 2 _incoming)
        string(REPLACE "," ";" _incoming "${_incoming}")
        _cpack_apk_maven_split("${_coordinates}" _g _a _v)
        string(MAKE_C_IDENTIFIER "${_g}:${_a}" _id)
        list(APPEND _ids "${_id}")
        if(NOT _v STREQUAL "")
          _cpack_apk_maven_version_higher("${_v}" "${_requested_${_id}}"
            _higher)
          if(_higher)
            set(_requested_${_id} "${_v}")
          endif()
        endif()
        foreach(_candidate IN ITEMS "${_v}" "${_constraint_${_id}}")
          if(_candidate STREQUAL "")
            continue()
          endif()
          _cpack_apk_maven_version_higher("${_candidate}"
            "${_selected_${_id}}" _higher)
          if(_higher)
            set(_selected_${_id} "${_candidate}")
            if("${_g}:${_a}" IN_LIST _visited_modules)
              set(_walk TRUE)
            endif()
          endif()
        endforeach()

        # Exclusions apply below a module if they apply on every path to it.
        string(MAKE_C_IDENTIFIER "${_kind}:${_g}:${_a}" _node)
        if(NOT DEFINED _excludes_${_node})
          set(_excludes_${_node} "${_incoming}")
        else()
          set(_common)
          foreach(_exclude IN LISTS _excludes_${_node})
            if(_exclude IN_LIST _incoming)
              list(APPEND _common "${_exclude}")
            endif()
          endforeach()
          if(NOT "${_common}" STREQUAL "${_excludes_${_node}}")
            set(_excludes_${_node} "${_common}")
            if("${_kind}|${_g}:${_a}" IN_LIST _visited)
              set(_walk TRUE)
            endif()
          endif()
        endif()

        if("${_kind}|${_g}:${_a}" IN_LIST _visited)
          continue()
        endif()
        if("${_selected_${_id}}" STREQUAL "")
          # Required without a version, which a platform or a dependency
          # constraint may give later.
          list(APPEND _pending "${_entry}")
          continue()
        endif()
        list(APPEND _visited "${_kind}|${_g}:${_a}")
        list(APPEND _visited_modules "${_g}:${_a}")
        set(_v "${_selected_${_id}}")

        string(MAKE_C_IDENTIFIER "${_kind}:${_g}:${_a}:${_v}" _key)
        if(NOT DEFINED _metadata_${_key}_files)
          _cpack_apk_maven_metadata(${_kind} ${_g} ${_a} ${_v})
          foreach(_field IN ITEMS deps constraints redirect files)
            set(_metadata_${_key}_${_field} "${_maven_${_field}}")
          endforeach()
        endif()

        foreach(_constraint IN LISTS _metadata_${_key}_constraints)
          _cpack_apk_maven_split("${_constraint}" _cg _ca _cv)
          string(MAKE_C_IDENTIFIER "${_cg}:${_ca}" _cid)
          list(APPEND _ids "${_cid}")
          _cpack_apk_maven_version_higher("${_cv}" "${_constrained_${_cid}}"
            _higher)
          if(_higher)
            set(_constrained_${_cid} "${_cv}")
          endif()
          _cpack_apk_maven_version_higher("${_cv}" "${_constraint_${_cid}}"
            _higher)
          if(_higher)
            set(_constraint_${_cid} "${_cv}")
            if("${_cg}:${_ca}" IN_LIST _visited_modules)
              _cpack_apk_maven_version_higher("${_cv}" "${_selected_${_cid}}"
                _higher)
              if(_higher)
                set(_walk TRUE)
              endif()
            endif()
          endif()
        endforeach()

        set(_excludes "${_excludes_${_node}}")
        foreach(_dep IN LISTS _metadata_${_key}_deps)
          string(REPLACE "|" ";" _fields "${_dep}")
          list(GET _fields 0 _dep_kind)
          list(GET _fields 1 _dep_coordinates)
          list(GET _fields 2 _dep_excludes)
          _cpack_apk_maven_split("${_dep_coordinates}" _dg _da _dv)
          _cpack_apk_maven_excluded(${_dg} ${_da} "${_excludes}" _excluded)
          if(_excluded)
            continue()
          endif()
          string(REPLACE "," ";" _dep_excludes "${_dep_excludes}")
          set(_below ${_excludes} ${_dep_excludes})
          list(REMOVE_DUPLICATES _below)
          list(JOIN _below "," _below)
          list(APPEND _queue "${_dep_kind}|${_dep_coordinates}|${_below}")
        endforeach()
        if(_metadata_${_key}_redirect)
          list(JOIN _excludes "," _below)
          list(APPEND _queue
            "${_kind}|${_metadata_${_key}_redirect}|${_below}")
        endif()
        foreach(_file IN LISTS _metadata_${_key}_files)
          list(APPEND _selected_files "${_g}:${_a}:${_v}|${_file}")
        endforeach()
      endwhile()

      # Modules required without a version may have been given one since.
      set(_waiting)
      foreach(_entry IN LISTS _pending)
        string(REPLACE "|" ";" _fields "${_entry}")
        list(GET _fields 1 _coordinates)
        _cpack_apk_maven_split("${_coordinates}" _g _a _v)
        string(MAKE_C_IDENTIFIER "${_g}:${_a}" _id)
        if(NOT "${_selected_${_id}}${_constraint_${_id}}" STREQUAL "")
          list(APPEND _queue "${_entry}")
        else()
          list(APPEND _waiting "${_entry}")
        endif()
      endforeach()
      set(_pending "${_waiting}")
    endwhile()

    # The versions the next walk starts from.
    list(REMOVE_DUPLICATES _ids)
    set(_changed FALSE)
    set(_state)
    foreach(_id IN LISTS _ids)
      foreach(_floor_kind IN ITEMS requested constrained)
        if(_floor_kind STREQUAL "requested")
          set(_floor_var _floor_${_id})
        else()
          set(_floor_var _floor_constraint_${_id})
        endif()
        set(_floor "${_${_floor_kind}_${_id}}")
        if(_monotonic)
          _cpack_apk_maven_version_higher("${${_floor_var}}" "${_floor}"
            _higher)
          if(_higher)
            set(_floor "${${_floor_var}}")
          endif()
        endif()
        if(NOT "${_floor}" STREQUAL "${${_floor_var}}")
          set(${_floor_var} "${_floor}")
          set(_changed TRUE)
        endif()
        list(APPEND _state "${_floor}")
      endforeach()
    endforeach()
    if(_changed)
      set(_walk TRUE)
      if(NOT _monotonic)
        string(MD5 _state "${_ids};${_state}")
        if(_state IN_LIST _states)
          set(_monotonic TRUE)
        else()
          list(APPEND _states "${_state}")
        endif()
      endif()
    endif()

    if(_pending AND NOT _walk)
      set(_modules)
      foreach(_entry IN LISTS _pending)
        string(REPLACE "|" ";" _fields "${_entry}")
        list(GET _fields 1 _coordinates)
        _cpack_apk_maven_split("${_coordinates}" _g _a _v)
        list(APPEND _modules "${_g}:${_a}")
      endforeach()
      list(REMOVE_DUPLICATES _modules)
      list(JOIN _modules "\n  " _modules)
      message(FATAL_ERROR
        "CPack APK: The Maven artifacts\n  ${_modules}\nare required "
        "without a version, and no platform or dependency constraint gives "
        "one.")
    endif()
  endwhile()

  set(_archives)
  foreach(_entry IN LISTS _selected_files)
    string(REPLACE "|" ";" _fields "${_entry}")
    list(GET _fields 0 _coordinates)
    list(GET _fields 1 _name)
    list(GET _fields 2 _hash)
    _cpack_apk_maven_split("${_coordinates}" _g _a _v)
    _cpack_apk_maven_fetch(${_g} ${_a} ${_v} "${_name}" _path ${_hash})
    if(NOT _path)
      message(FATAL_ERROR
        "CPack APK: '${_name}' of the Maven artifact '${_coordinates}' could "
        "not be downloaded.")
    endif()
    # Only code archives are consumed; a module may publish other files.
    if(_path MATCHES "\\.(aar|jar)$")
      list(APPEND _archives "${_path}")
      _cpack_apk_debug("Maven dependency: ${_path}")
    endif()
  endforeach()
  set(${result} "${_archives}" PARENT_SCOPE)
endfunction()