src/app/chip_data_model.gni

# Copyright (c) 2021 Project CHIP Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import("//build_overrides/build.gni")
import("//build_overrides/chip.gni")
import("${chip_root}/build/chip/chip_codegen.gni")
import("${chip_root}/src/app/common_flags.gni")
import("${chip_root}/src/app/icd/icd.gni")
import("${chip_root}/src/data-model-providers/codegen/model.gni")
import("${chip_root}/src/platform/python.gni")

_app_root = get_path_info(".", "abspath")

# Defines a source_set for CHIP data model.
#
# Arguments:
#  zap_file
#    Path to the ZAP input file.
#
#  idl
#    Path to the .matter IDL corresponding to the zap file. This is for
#    dependencies on build-time code generation.
#
# Forwards all the remaining variables to the source_set.
#
#
#
# Additional underlying source sets that will be provided
#
#   - ${name}-endpoint-metadata
#     contains HEADERS that define endpoint metadata from zap/matter files:
#        - zap-generated/gen_config.h
#        - zap-generated/endpoint_config.h
#        - zap-generated/access.h
#        - PluginApplicationCallbacks.h
#   - ${name}-callbacks
#     contains the callback implementation for cluster init:
#        - cluster-callbacks.cpp
#        - callback-stub.cpp (contains __weak__ implementations. TODO: we should not be using
#          weak linkage over time at all)
#   - ${name}-command-dispatch:
#     contains the implementation of `DispatchServerCommand` which forwards data to
#     `emberAf....Cluster...Callback` callbacks
#        - zap-generated/IMClusterCommandHandler.cpp
#
template("chip_data_model") {
  _data_model_name = target_name

  if (defined(invoker.idl)) {
    _idl = invoker.idl
  } else {
    # Assume that IDL name is the same as the zap file name, but instead of
    # '.zap' use '.matter' as extension. This is currently the case in the
    # sample apps, but may change in the future
    _idl = string_replace(invoker.zap_file, ".zap", ".matter")
  }

  chip_zapgen("${_data_model_name}_zapgen") {
    input = rebase_path(invoker.zap_file)
    generator = "app-templates"

    # NOTE: these files MUST be in sync with outputs in
    #       src/app/zap-templates/app-templates.json
    outputs = [
      "zap-generated/access.h",
      "zap-generated/gen_config.h",
      "zap-generated/endpoint_config.h",
    ]

    if (!chip_build_controller_dynamic_server) {
      outputs += [ "zap-generated/IMClusterCommandHandler.cpp" ]
    }

    if (!defined(deps)) {
      deps = []
    }

    deps += [ "${chip_root}/src/app" ]
  }

  chip_codegen("${_data_model_name}_codegen") {
    input = _idl
    generator = "cpp-app"

    outputs = [
      "app/PluginApplicationCallbacks.h",
      "app/callback-stub.cpp",
      "app/cluster-callbacks.cpp",
      "app/static-cluster-config/{{server_cluster_name}}.h",
    ]

    if (!defined(deps)) {
      deps = []
    }

    deps += [
      ":${_data_model_name}_zapgen",
      "${chip_root}/src/app/common:cluster-objects",
    ]
  }

  # Fixed source sets for allowing reasonable dependencies on things:
  source_set("${_data_model_name}-endpoint-metadata") {
    sources = filter_include(
            get_target_outputs(":${_data_model_name}_codegen_generate"),
            [ "*/PluginApplicationCallbacks.h" ])
    sources += filter_include(
            get_target_outputs(":${_data_model_name}_zapgen_generate"),
            [
              "*/access.h",
              "*/endpoint_config.h",
              "*/gen_config.h",
            ])

    deps = [
      ":${_data_model_name}_codegen_generate",
      ":${_data_model_name}_zapgen_generate",
      "${chip_root}/src/access",
      "${chip_root}/src/lib/core:chip_config_header",
    ]
  }

  source_set("${_data_model_name}-callbacks") {
    sources = filter_include(
            get_target_outputs(":${_data_model_name}_codegen_generate"),
            [
              "*/callback-stup.cpp",
              "*/cluster-callbacks.cpp",
            ])

    deps = [
      ":${_data_model_name}_codegen_generate",
      "${chip_root}/src/app/common:ids",
      "${chip_root}/src/app/common:metadata",
      "${chip_root}/src/lib/support:span",
      "${chip_root}/src/protocols/interaction_model",
    ]
  }

  if (!chip_build_controller_dynamic_server) {
    source_set("${_data_model_name}-command-dispatch") {
      sources = filter_include(
              get_target_outputs(":${_data_model_name}_zapgen_generate"),
              [ "*/IMClusterCommandHandler.cpp" ])

      deps = [
        ":${_data_model_name}_zapgen_generate",
        "${chip_root}/src/app",
        "${chip_root}/src/app:interaction-model",
        "${chip_root}/src/app/common:cluster-objects",
        "${chip_root}/src/app/common:enums",
        "${chip_root}/src/app/common:ids",
        "${chip_root}/src/app/common:metadata",
        "${chip_root}/src/lib/core",
        "${chip_root}/src/lib/support",
      ]
    }
  }

  source_set(_data_model_name) {
    forward_variables_from(invoker,
                           "*",
                           [
                             "zap_file",
                             "is_server",
                             "external_clusters",
                           ])

    if (!defined(sources)) {
      sources = []
    }

    if (!defined(is_server)) {
      is_server = false
    }

    sources += [
      "${_app_root}/clusters/color-control-server/color-control-server.h",
      "${_app_root}/clusters/door-lock-server/door-lock-server.h",
      "${_app_root}/clusters/groups-server/groups-server.h",
      "${_app_root}/clusters/identify-server/identify-server.h",
      "${_app_root}/clusters/level-control/level-control.h",
      "${_app_root}/clusters/on-off-server/on-off-server.h",
      "${_app_root}/clusters/scenes-server/ExtensionFieldSets.h",
      "${_app_root}/clusters/scenes-server/ExtensionFieldSetsImpl.h",
      "${_app_root}/clusters/scenes-server/SceneHandlerImpl.h",
      "${_app_root}/clusters/scenes-server/SceneTable.h",
      "${_app_root}/clusters/scenes-server/SceneTableImpl.h",
      "${_app_root}/clusters/scenes-server/scenes-server.h",
      "${_app_root}/util/binding-table.cpp",
      "${_app_root}/util/binding-table.h",
      "${_app_root}/util/generic-callback-stubs.cpp",
      "${_app_root}/util/privilege-storage.cpp",
      "${chip_root}/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp",
    ]
    sources += codegen_data_model_SOURCES

    if (!chip_build_controller_dynamic_server) {
      sources += [
        "${_app_root}/reporting/reporting.cpp",
        "${_app_root}/util/DataModelHandler.cpp",
        "${_app_root}/util/attribute-storage.cpp",
        "${_app_root}/util/attribute-table.cpp",
        "${_app_root}/util/ember-io-storage.cpp",
        "${_app_root}/util/util.cpp",
      ]
    }

    if (defined(invoker.zap_file)) {
      _zap_file = rebase_path(invoker.zap_file, root_build_dir)
      _script_args = [
        "--zap_file",
        _zap_file,
      ]
      if (defined(invoker.external_clusters)) {
        _script_args += [ "--external-clusters" ]
        _script_args += invoker.external_clusters
      }
      _cluster_sources = exec_script("${_app_root}/zap_cluster_list.py",
                                     _script_args,
                                     "list lines",
                                     [ invoker.zap_file ])
    }

    if (!defined(deps)) {
      deps = []
    }

    if (!defined(public_deps)) {
      public_deps = []
    }

    if (!defined(cflags)) {
      cflags = []
    }

    if (!defined(defines)) {
      defines = []
    }

    # Clusters are expected to have the following format:
    #   - A `BUILD.gn` file that defines targets that do not depend on the specific application configuration. A dependency
    #     will be added on this default target. An empty group will be created
    #     if no special build rules exist
    #   - app_config_dependent_sources.gni - required sources for code generation integration
    #     MUST define a variable named `app_config_dependent_sources`

    _app_config_dependent_sources = []
    foreach(cluster, _cluster_sources) {
      deps += [ "${_app_root}/clusters/${cluster}" ]

      # app_config_dependent_sources paths are relative to the target
      # accumulate them here so that we can "rebase_path" later on
      _app_config_dependent_sources += [
        {
          cluster = cluster
          import(
              "${_app_root}/clusters/${cluster}/app_config_dependent_sources.gni")
        },
      ]
    }

    foreach(cluster_entry, _app_config_dependent_sources) {
      sources += rebase_path(cluster_entry.app_config_dependent_sources,
                             "",
                             "${_app_root}/clusters/${cluster_entry.cluster}")
    }

    deps += [ "${chip_root}/src/app:attribute-persistence" ]

    public_deps += [
      ":${_data_model_name}_codegen",
      ":${_data_model_name}_zapgen",
      "${chip_root}/src/access",
      "${chip_root}/src/app",
      "${chip_root}/src/app:attribute-persistence",
      "${chip_root}/src/app:required-privileges",
      "${chip_root}/src/app/cluster-building-blocks",
      "${chip_root}/src/app/common:attribute-type",
      "${chip_root}/src/app/common:cluster-objects",
      "${chip_root}/src/app/common:enums",
      "${chip_root}/src/app/persistence",
      "${chip_root}/src/app/persistence:default",
      "${chip_root}/src/app/server",
      "${chip_root}/src/app/storage:fabric-table",
      "${chip_root}/src/app/util:types",
      "${chip_root}/src/lib/core",
      "${chip_root}/src/lib/support",
      "${chip_root}/src/protocols/secure_channel",
      "${chip_root}/zzz_generated/app-common/clusters:all-elements",
      "${chip_root}/zzz_generated/app-common/clusters:all-metadata",

      # TODO: Embedded example apps currently build with chip_build_controller = false, and so get a libCHIP without controller support,
      # but nevertheless expect to have access to some of the "controller" code to implement bindings and related functionality.
      "${chip_root}/src/controller:interactions",
    ]
    public_deps += codegen_data_model_PUBLIC_DEPS

    if (is_server) {
      public_deps += [ "${chip_root}/src/app/server" ]
    }

    cflags += [ "-Wconversion" ]
  }
}