Update TV SDK, mac address bug addressed and synced content launch xm…

…l files per spec. (#14961) * Update XML files to match the spec & Tests * Run zap regen script * Update code * Restyle fix
project-chip · Aug 21, 2023 · 1116880 · 1116880
1 parent 13247bd
commit 1116880
Show file tree

Hide file tree

Showing 25 changed files with 214 additions and 203 deletions.
diff --git a/examples/tv-app/android/java/ContentLauncherManager.cpp b/examples/tv-app/android/java/ContentLauncherManager.cpp
@@ -27,6 +27,7 @@
 
 using namespace std;
 using namespace chip;
+using namespace chip::app::DataModel;
 using namespace chip::app::Clusters::ContentLauncher;
 
 void emberAfContentLauncherClusterInitCallback(EndpointId endpoint)
@@ -44,7 +45,7 @@ void ContentLauncherManager::NewManager(jint endpoint, jobject manager)
 }
 
 void ContentLauncherManager::HandleLaunchContent(CommandResponseHelper<LaunchResponseType> & helper,
-                                                 const std::list<Parameter> & parameterList, bool autoplay,
+                                                 const DecodableList<ParameterType> & parameterList, bool autoplay,
                                                  const chip::CharSpan & data)
 {
     Commands::LaunchResponse::Type response;
@@ -99,7 +100,7 @@ void ContentLauncherManager::HandleLaunchContent(CommandResponseHelper<LaunchRes
 
 void ContentLauncherManager::HandleLaunchUrl(CommandResponseHelper<LaunchResponseType> & helper, const chip::CharSpan & contentUrl,
                                              const chip::CharSpan & displayString,
-                                             const std::list<BrandingInformation> & brandingInformation)
+                                             const BrandingInformationType & brandingInformation)
 {
     Commands::LaunchResponse::Type response;
     CHIP_ERROR err = CHIP_NO_ERROR;

diff --git a/examples/tv-app/android/java/ContentLauncherManager.h b/examples/tv-app/android/java/ContentLauncherManager.h
@@ -24,24 +24,26 @@
 #include <app/clusters/content-launch-server/content-launch-server.h>
 #include <jni.h>
 #include <lib/core/CHIPError.h>
-#include <list>
 
 using chip::CharSpan;
 using chip::app::AttributeValueEncoder;
 using chip::app::CommandResponseHelper;
 using ContentLauncherDelegate = chip::app::Clusters::ContentLauncher::Delegate;
 using LaunchResponseType      = chip::app::Clusters::ContentLauncher::Commands::LaunchResponse::Type;
+using ParameterType           = chip::app::Clusters::ContentLauncher::Structs::Parameter::DecodableType;
+using BrandingInformationType = chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::Type;
 
 class ContentLauncherManager : public ContentLauncherDelegate
 {
 public:
     static void NewManager(jint endpoint, jobject manager);
     void InitializeWithObjects(jobject managerObject);
 
-    void HandleLaunchContent(CommandResponseHelper<LaunchResponseType> & helper, const std::list<Parameter> & parameterList,
-                             bool autoplay, const CharSpan & data) override;
+    void HandleLaunchContent(CommandResponseHelper<LaunchResponseType> & helper,
+                             const chip::app::DataModel::DecodableList<ParameterType> & parameterList, bool autoplay,
+                             const CharSpan & data) override;
     void HandleLaunchUrl(CommandResponseHelper<LaunchResponseType> & helper, const CharSpan & contentUrl,
-                         const CharSpan & displayString, const std::list<BrandingInformation> & brandingInformation) override;
+                         const CharSpan & displayString, const BrandingInformationType & brandingInformation) override;
     CHIP_ERROR HandleGetAcceptHeaderList(AttributeValueEncoder & aEncoder) override;
     uint32_t HandleGetSupportedStreamingProtocols() override;
 

diff --git a/examples/tv-app/linux/BUILD.gn b/examples/tv-app/linux/BUILD.gn
@@ -20,6 +20,23 @@ import("${chip_root}/build/chip/tools.gni")
 
 assert(chip_build_tools)
 
+declare_args() {
+  # Enable Wake on LAN cluster
+  chip_enable_wake_on_lan = false
+}
+
+config("config") {
+  include_dirs = [
+    ".",
+    "${chip_root}/zzz_generated/chip-tv-app",
+    "${chip_root}/src/lib",
+  ]
+
+  defines = [ "CHIP_ENABLE_WAKE_ON_LAN=${chip_enable_wake_on_lan}" ]
+
+  cflags = [ "-Wconversion" ]
+}
+
 executable("chip-tv-app") {
   sources = [
     "${chip_root}/examples/tv-app/tv-common/include/CHIPProjectAppConfig.h",
@@ -66,6 +83,8 @@ executable("chip-tv-app") {
 
   cflags = [ "-Wconversion" ]
 
+  public_configs = [ ":config" ]
+
   if (chip_build_libshell) {
     cflags += [ "-DENABLE_CHIP_SHELL" ]
   }

diff --git a/examples/tv-app/linux/include/channel/ChannelManager.cpp b/examples/tv-app/linux/include/channel/ChannelManager.cpp
@@ -30,9 +30,9 @@ CHIP_ERROR ChannelManager::HandleGetChannelList(AttributeValueEncoder & aEncoder
         for (int i = 0; i < maximumVectorSize; ++i)
         {
             chip::app::Clusters::Channel::Structs::ChannelInfo::Type channelInfo;
-            channelInfo.affiliateCallSign = Optional<CharSpan>(chip::CharSpan::fromCharString("exampleASign"));
-            channelInfo.callSign          = Optional<CharSpan>(chip::CharSpan::fromCharString("exampleCSign"));
-            channelInfo.name              = Optional<CharSpan>(chip::CharSpan::fromCharString("exampleName"));
+            channelInfo.affiliateCallSign = MakeOptional(chip::CharSpan::fromCharString("exampleASign"));
+            channelInfo.callSign          = MakeOptional(chip::CharSpan::fromCharString("exampleCSign"));
+            channelInfo.name              = MakeOptional(chip::CharSpan::fromCharString("exampleName"));
             channelInfo.majorNumber       = static_cast<uint8_t>(1 + i);
             channelInfo.minorNumber       = static_cast<uint16_t>(2 + i);
 
@@ -47,8 +47,8 @@ CHIP_ERROR ChannelManager::HandleGetLineup(AttributeValueEncoder & aEncoder)
 {
     chip::app::Clusters::Channel::Structs::LineupInfo::Type lineup;
     lineup.operatorName   = chip::CharSpan::fromCharString("operatorName");
-    lineup.lineupName     = Optional<CharSpan>(chip::CharSpan::fromCharString("lineupName"));
-    lineup.postalCode     = Optional<CharSpan>(chip::CharSpan::fromCharString("postalCode"));
+    lineup.lineupName     = MakeOptional(chip::CharSpan::fromCharString("lineupName"));
+    lineup.postalCode     = MakeOptional(chip::CharSpan::fromCharString("postalCode"));
     lineup.lineupInfoType = chip::app::Clusters::Channel::LineupInfoTypeEnum::kMso;
 
     return aEncoder.Encode(lineup);
@@ -57,9 +57,9 @@ CHIP_ERROR ChannelManager::HandleGetLineup(AttributeValueEncoder & aEncoder)
 CHIP_ERROR ChannelManager::HandleGetCurrentChannel(AttributeValueEncoder & aEncoder)
 {
     chip::app::Clusters::Channel::Structs::ChannelInfo::Type currentChannel;
-    currentChannel.affiliateCallSign = Optional<CharSpan>(chip::CharSpan::fromCharString("exampleASign"));
-    currentChannel.callSign          = Optional<CharSpan>(chip::CharSpan::fromCharString("exampleCSign"));
-    currentChannel.name              = Optional<CharSpan>(chip::CharSpan::fromCharString("exampleName"));
+    currentChannel.affiliateCallSign = MakeOptional(chip::CharSpan::fromCharString("exampleASign"));
+    currentChannel.callSign          = MakeOptional(chip::CharSpan::fromCharString("exampleCSign"));
+    currentChannel.name              = MakeOptional(chip::CharSpan::fromCharString("exampleName"));
     currentChannel.majorNumber       = 1;
     currentChannel.minorNumber       = 0;
 
@@ -71,9 +71,9 @@ void ChannelManager::HandleChangeChannel(CommandResponseHelper<ChangeChannelResp
     ChangeChannelResponseType response;
     response.channelMatch.majorNumber       = 1;
     response.channelMatch.minorNumber       = 0;
-    response.channelMatch.name              = Optional<CharSpan>(chip::CharSpan::fromCharString("name"));
-    response.channelMatch.callSign          = Optional<CharSpan>(chip::CharSpan::fromCharString("callSign"));
-    response.channelMatch.affiliateCallSign = Optional<CharSpan>(chip::CharSpan::fromCharString("affiliateCallSign"));
+    response.channelMatch.name              = MakeOptional(chip::CharSpan::fromCharString("name"));
+    response.channelMatch.callSign          = MakeOptional(chip::CharSpan::fromCharString("callSign"));
+    response.channelMatch.affiliateCallSign = MakeOptional(chip::CharSpan::fromCharString("affiliateCallSign"));
     response.errorType                      = chip::app::Clusters::Channel::ErrorTypeEnum::kMultipleMatches;
 
     helper.Success(response);

diff --git a/examples/tv-app/linux/include/content-launcher/ContentLauncherManager.cpp b/examples/tv-app/linux/include/content-launcher/ContentLauncherManager.cpp
@@ -21,6 +21,7 @@
 using namespace std;
 using namespace chip::app;
 using namespace chip::app::Clusters;
+using namespace chip::app::DataModel;
 using namespace chip::app::Clusters::ContentLauncher;
 
 ContentLauncherManager::ContentLauncherManager(list<std::string> acceptHeaderList, uint32_t supportedStreamingProtocols)
@@ -30,20 +31,21 @@ ContentLauncherManager::ContentLauncherManager(list<std::string> acceptHeaderLis
 }
 
 void ContentLauncherManager::HandleLaunchContent(CommandResponseHelper<LaunchResponseType> & helper,
-                                                 const list<Parameter> & parameterList, bool autoplay, const CharSpan & data)
+                                                 const DecodableList<ParameterType> & parameterList, bool autoplay,
+                                                 const CharSpan & data)
 {
     ChipLogProgress(Zcl, "ContentLauncherManager::HandleLaunchContent for endpoint %d", mEndpointId);
     string dataString(data.data(), data.size());
 
     LaunchResponseType response;
     // TODO: Insert code here
-    response.data   = chip::Optional<CharSpan>(CharSpan::fromCharString("exampleData"));
+    response.data   = chip::MakeOptional(CharSpan::fromCharString("exampleData"));
     response.status = ContentLauncher::StatusEnum::kSuccess;
     helper.Success(response);
 }
 
 void ContentLauncherManager::HandleLaunchUrl(CommandResponseHelper<LaunchResponseType> & helper, const CharSpan & contentUrl,
-                                             const CharSpan & displayString, const list<BrandingInformation> & brandingInformation)
+                                             const CharSpan & displayString, const BrandingInformationType & brandingInformation)
 {
     ChipLogProgress(Zcl, "ContentLauncherManager::HandleLaunchUrl");
 
@@ -52,7 +54,7 @@ void ContentLauncherManager::HandleLaunchUrl(CommandResponseHelper<LaunchRespons
 
     // TODO: Insert code here
     LaunchResponseType response;
-    response.data   = chip::Optional<CharSpan>(CharSpan::fromCharString("exampleData"));
+    response.data   = chip::MakeOptional(CharSpan::fromCharString("exampleData"));
     response.status = ContentLauncher::StatusEnum::kSuccess;
     helper.Success(response);
 }

diff --git a/examples/tv-app/linux/include/content-launcher/ContentLauncherManager.h b/examples/tv-app/linux/include/content-launcher/ContentLauncherManager.h
@@ -26,17 +26,20 @@ using chip::app::AttributeValueEncoder;
 using chip::app::CommandResponseHelper;
 using ContentLauncherDelegate = chip::app::Clusters::ContentLauncher::Delegate;
 using LaunchResponseType      = chip::app::Clusters::ContentLauncher::Commands::LaunchResponse::Type;
+using ParameterType           = chip::app::Clusters::ContentLauncher::Structs::Parameter::DecodableType;
+using BrandingInformationType = chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::Type;
 
 class ContentLauncherManager : public ContentLauncherDelegate
 {
 public:
     ContentLauncherManager() : ContentLauncherManager({ "example", "example" }, 0){};
     ContentLauncherManager(std::list<std::string> acceptHeaderList, uint32_t supportedStreamingProtocols);
 
-    void HandleLaunchContent(CommandResponseHelper<LaunchResponseType> & helper, const std::list<Parameter> & parameterList,
-                             bool autoplay, const CharSpan & data) override;
+    void HandleLaunchContent(CommandResponseHelper<LaunchResponseType> & helper,
+                             const chip::app::DataModel::DecodableList<ParameterType> & parameterList, bool autoplay,
+                             const CharSpan & data) override;
     void HandleLaunchUrl(CommandResponseHelper<LaunchResponseType> & helper, const CharSpan & contentUrl,
-                         const CharSpan & displayString, const std::list<BrandingInformation> & brandingInformation) override;
+                         const CharSpan & displayString, const BrandingInformationType & brandingInformation) override;
     CHIP_ERROR HandleGetAcceptHeaderList(AttributeValueEncoder & aEncoder) override;
     uint32_t HandleGetSupportedStreamingProtocols() override;
 

diff --git a/examples/tv-app/linux/include/target-navigator/TargetNavigatorManager.cpp b/examples/tv-app/linux/include/target-navigator/TargetNavigatorManager.cpp
@@ -55,14 +55,14 @@ void TargetNavigatorManager::HandleNavigateTarget(CommandResponseHelper<Navigate
     NavigateTargetResponseType response;
     if (target == kNoCurrentTarget || target > mTargets.size())
     {
-        response.data   = chip::Optional<CharSpan>(CharSpan::fromCharString("error"));
+        response.data   = chip::MakeOptional(CharSpan::fromCharString("error"));
         response.status = StatusEnum::kTargetNotFound;
         helper.Success(response);
         return;
     }
     mCurrentTarget = static_cast<uint8_t>(target);
 
-    response.data   = chip::Optional<CharSpan>(CharSpan::fromCharString("data response"));
+    response.data   = chip::MakeOptional(CharSpan::fromCharString("data response"));
     response.status = StatusEnum::kSuccess;
     helper.Success(response);
 }
diff --git a/examples/tv-app/linux/include/wake-on-lan/WakeOnLanManager.cpp b/examples/tv-app/linux/include/wake-on-lan/WakeOnLanManager.cpp
@@ -17,11 +17,26 @@
  */
 
 #include "WakeOnLanManager.h"
+#include <fstream>
+#include <iostream>
+#include <string>
 
 using namespace chip;
 using namespace chip::app::Clusters::WakeOnLan;
 
+std::string getMacAddress()
+{
+    std::ifstream input("/sys/class/net/eth0/address");
+    std::string line;
+    std::getline(input, line);
+    return line;
+}
+
 CHIP_ERROR WakeOnLanManager::HandleGetMacAddress(chip::app::AttributeValueEncoder & aEncoder)
 {
+#if CHIP_ENABLE_WAKE_ON_LAN
+    return aEncoder.Encode(CharSpan::fromCharString(getMacAddress().c_str()));
+#else
     return aEncoder.Encode(CharSpan::fromCharString("00:00:00:00:00"));
+#endif // CHIP_ENABLE_WAKE_ON_LAN
 }
diff --git a/examples/tv-app/tv-common/tv-app.matter b/examples/tv-app/tv-common/tv-app.matter
@@ -450,7 +450,7 @@ server cluster ContentLauncher = 1290 {
   readonly global attribute int16u clusterRevision = 65533;
 
   request struct LaunchContentRequestRequest {
-    ContentSearch search[] = 0;
+    ContentSearch search = 0;
     BOOLEAN autoPlay = 1;
     optional CHAR_STRING data = 2;
   }

diff --git a/examples/tv-casting-app/tv-casting-common/tv-casting-app.matter b/examples/tv-casting-app/tv-casting-common/tv-casting-app.matter
@@ -692,7 +692,7 @@ client cluster ContentLauncher = 1290 {
   readonly global attribute int16u clusterRevision = 65533;
 
   request struct LaunchContentRequestRequest {
-    ContentSearch search[] = 0;
+    ContentSearch search = 0;
     BOOLEAN autoPlay = 1;
     optional CHAR_STRING data = 2;
   }

diff --git a/src/app/clusters/content-launch-server/content-launch-delegate.h b/src/app/clusters/content-launch-server/content-launch-delegate.h
@@ -31,17 +31,21 @@ namespace app {
 namespace Clusters {
 namespace ContentLauncher {
 
+using BrandingInformation = chip::app::Clusters::ContentLauncher::Structs::BrandingInformation::Type;
+using Parameter           = chip::app::Clusters::ContentLauncher::Structs::Parameter::DecodableType;
+
 /** @brief
  *    Defines methods for implementing application-specific logic for the Content Launcher Cluster.
  */
 class Delegate
 {
 public:
     virtual void HandleLaunchContent(CommandResponseHelper<Commands::LaunchResponse::Type> & helper,
-                                     const std::list<Parameter> & parameterList, bool autoplay, const CharSpan & data) = 0;
+                                     const DataModel::DecodableList<Parameter> & parameterList, bool autoplay,
+                                     const CharSpan & data) = 0;
 
     virtual void HandleLaunchUrl(CommandResponseHelper<Commands::LaunchResponse::Type> & helper, const CharSpan & contentUrl,
-                                 const CharSpan & displayString, const std::list<BrandingInformation> & brandingInformation) = 0;
+                                 const CharSpan & displayString, const BrandingInformation & brandingInformation) = 0;
 
     virtual CHIP_ERROR HandleGetAcceptHeaderList(app::AttributeValueEncoder & aEncoder) = 0;
 

diff --git a/src/app/clusters/content-launch-server/content-launch-server.cpp b/src/app/clusters/content-launch-server/content-launch-server.cpp
@@ -193,18 +193,16 @@ bool emberAfContentLauncherClusterLaunchContentRequestCallback(
     CHIP_ERROR err      = CHIP_NO_ERROR;
     EndpointId endpoint = commandPath.mEndpointId;
 
-    auto & autoplay = commandData.autoPlay;
-    auto & data     = commandData.data;
-    // TODO: Decode the parameter and pass it to delegate
-    // auto searchIterator = commandData.search.begin();
-    std::list<Parameter> parameterList;
+    auto & autoplay               = commandData.autoPlay;
+    auto & data                   = commandData.data;
+    auto & decodableParameterList = commandData.search.parameterList;
 
     app::CommandResponseHelper<Commands::LaunchResponse::Type> responder(commandObj, commandPath);
 
     Delegate * delegate = GetDelegate(endpoint);
     VerifyOrExit(isDelegateNull(delegate, endpoint) != true, err = CHIP_ERROR_INCORRECT_STATE);
     {
-        delegate->HandleLaunchContent(responder, parameterList, autoplay, data.HasValue() ? data.Value() : CharSpan());
+        delegate->HandleLaunchContent(responder, decodableParameterList, autoplay, data.HasValue() ? data.Value() : CharSpan());
     }
 
 exit:
@@ -229,19 +227,18 @@ bool emberAfContentLauncherClusterLaunchURLRequestCallback(
     CHIP_ERROR err      = CHIP_NO_ERROR;
     EndpointId endpoint = commandPath.mEndpointId;
 
-    auto & contentUrl    = commandData.contentURL;
-    auto & displayString = commandData.displayString;
-    // TODO: Decode the parameter and pass it to delegate
-    // auto brandingInformationIterator = commandData.brandingInformation.begin();
-    std::list<BrandingInformation> brandingInformationList;
+    auto & contentUrl          = commandData.contentURL;
+    auto & displayString       = commandData.displayString;
+    auto & brandingInformation = commandData.brandingInformation;
 
     app::CommandResponseHelper<Commands::LaunchResponse::Type> responder(commandObj, commandPath);
 
     Delegate * delegate = GetDelegate(endpoint);
     VerifyOrExit(isDelegateNull(delegate, endpoint) != true, err = CHIP_ERROR_INCORRECT_STATE);
     {
         delegate->HandleLaunchUrl(responder, contentUrl, displayString.HasValue() ? displayString.Value() : CharSpan(),
-                                  brandingInformationList);
+                                  brandingInformation.HasValue() ? brandingInformation.Value()
+                                                                 : chip::app::Clusters::ContentLauncher::BrandingInformation());
     }
 
 exit:

diff --git a/src/app/tests/suites/TV_ContentLauncherCluster.yaml b/src/app/tests/suites/TV_ContentLauncherCluster.yaml
@@ -46,9 +46,15 @@ tests:
               - name: "search"
                 value:
                     {
-                        type: 1,
-                        value: "exampleValue",
-                        externalIDList: [{ name: "name", value: "value" }],
+                        parameterList:
+                            [
+                                {
+                                    type: 1,
+                                    value: "exampleValue",
+                                    externalIDList:
+                                        [{ name: "name", value: "value" }],
+                                },
+                            ],
                     }
       response:
           values:

diff --git a/src/app/zap-templates/zcl/data-model/chip/content-launch-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/content-launch-cluster.xml
@@ -31,7 +31,7 @@ limitations under the License.
 
     <command source="client" code="0x00" name="LaunchContentRequest" response="LaunchResponse" optional="false">
       <description>Upon receipt, this SHALL launch the specified content with optional search criteria.</description>
-      <arg name="search" type="ContentSearch" array="true"/>
+      <arg name="search" type="ContentSearch"/>
       <arg name="autoPlay" type="BOOLEAN"/>
       <arg name="data" type="CHAR_STRING" optional="true"/>
     </command>

diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter
@@ -981,7 +981,7 @@ client cluster ContentLauncher = 1290 {
   readonly global attribute int16u clusterRevision = 65533;
 
   request struct LaunchContentRequestRequest {
-    ContentSearch search[] = 0;
+    ContentSearch search = 0;
     BOOLEAN autoPlay = 1;
     optional CHAR_STRING data = 2;
   }