Merge branch 'master' of github.com:project-chip/connectedhomeip into…

… granbery/preset_atomic
project-chip · Aug 22, 2024 · 179ceba · 179ceba
2 parents 127a00b + 2695601
commit 179ceba
Show file tree

Hide file tree

Showing 79 changed files with 9,702 additions and 6,775 deletions.
diff --git a/examples/chip-tool/BUILD.gn b/examples/chip-tool/BUILD.gn
@@ -53,6 +53,7 @@ static_library("chip-tool-utils") {
     "${chip_root}/src/controller/ExamplePersistentStorage.h",
     "${chip_root}/zzz_generated/chip-tool/zap-generated/cluster/ComplexArgumentParser.cpp",
     "${chip_root}/zzz_generated/chip-tool/zap-generated/cluster/logging/DataModelLogger.cpp",
+    "${chip_root}/zzz_generated/chip-tool/zap-generated/cluster/logging/EntryToText.cpp",
     "commands/clusters/ModelCommand.cpp",
     "commands/clusters/ModelCommand.h",
     "commands/common/BDXDiagnosticLogsServerDelegate.cpp",

diff --git a/examples/chip-tool/commands/clusters/DataModelLogger.h b/examples/chip-tool/commands/clusters/DataModelLogger.h
@@ -28,6 +28,7 @@
 #include <app/data-model/DecodableList.h>
 #include <commands/common/RemoteDataModelLogger.h>
 #include <lib/support/BytesToHex.h>
+#include <zap-generated/cluster/logging/EntryToText.h>
 
 class DataModelLogger
 {
@@ -157,6 +158,100 @@ class DataModelLogger
         return CHIP_NO_ERROR;
     }
 
+    static CHIP_ERROR LogClusterId(const char * label, size_t indent,
+                                   const chip::app::DataModel::DecodableList<chip::ClusterId> & value)
+    {
+        size_t count = 0;
+        ReturnErrorOnFailure(value.ComputeSize(&count));
+        DataModelLogger::LogString(label, indent, std::to_string(count) + " entries");
+
+        auto iter = value.begin();
+        size_t i  = 0;
+        while (iter.Next())
+        {
+            ++i;
+            std::string index = std::string("[") + std::to_string(i) + "]";
+            std::string item  = std::to_string(iter.GetValue()) + " (" + ClusterIdToText(iter.GetValue()) + ")";
+            DataModelLogger::LogString(index, indent + 1, item);
+        }
+        if (iter.GetStatus() != CHIP_NO_ERROR)
+        {
+            DataModelLogger::LogString(indent + 1, "List truncated due to invalid value");
+        }
+        return iter.GetStatus();
+    }
+
+    static CHIP_ERROR LogAttributeId(const char * label, size_t indent,
+                                     const chip::app::DataModel::DecodableList<chip::AttributeId> & value, chip::ClusterId cluster)
+    {
+        size_t count = 0;
+        ReturnErrorOnFailure(value.ComputeSize(&count));
+        DataModelLogger::LogString(label, indent, std::to_string(count) + " entries");
+
+        auto iter = value.begin();
+        size_t i  = 0;
+        while (iter.Next())
+        {
+            ++i;
+            std::string index = std::string("[") + std::to_string(i) + "]";
+            std::string item  = std::to_string(iter.GetValue()) + " (" + AttributeIdToText(cluster, iter.GetValue()) + ")";
+            DataModelLogger::LogString(index, indent + 1, item);
+        }
+        if (iter.GetStatus() != CHIP_NO_ERROR)
+        {
+            DataModelLogger::LogString(indent + 1, "List truncated due to invalid value");
+        }
+        return iter.GetStatus();
+    }
+
+    static CHIP_ERROR LogAcceptedCommandId(const char * label, size_t indent,
+                                           const chip::app::DataModel::DecodableList<chip::CommandId> & value,
+                                           chip::ClusterId cluster)
+    {
+        size_t count = 0;
+        ReturnErrorOnFailure(value.ComputeSize(&count));
+        DataModelLogger::LogString(label, indent, std::to_string(count) + " entries");
+
+        auto iter = value.begin();
+        size_t i  = 0;
+        while (iter.Next())
+        {
+            ++i;
+            std::string index = std::string("[") + std::to_string(i) + "]";
+            std::string item  = std::to_string(iter.GetValue()) + " (" + AcceptedCommandIdToText(cluster, iter.GetValue()) + ")";
+            DataModelLogger::LogString(index, indent + 1, item);
+        }
+        if (iter.GetStatus() != CHIP_NO_ERROR)
+        {
+            DataModelLogger::LogString(indent + 1, "List truncated due to invalid value");
+        }
+        return iter.GetStatus();
+    }
+
+    static CHIP_ERROR LogGeneratedCommandId(const char * label, size_t indent,
+                                            const chip::app::DataModel::DecodableList<chip::CommandId> & value,
+                                            chip::ClusterId cluster)
+    {
+        size_t count = 0;
+        ReturnErrorOnFailure(value.ComputeSize(&count));
+        DataModelLogger::LogString(label, indent, std::to_string(count) + " entries");
+
+        auto iter = value.begin();
+        size_t i  = 0;
+        while (iter.Next())
+        {
+            ++i;
+            std::string index = std::string("[") + std::to_string(i) + "]";
+            std::string item  = std::to_string(iter.GetValue()) + " (" + GeneratedCommandIdToText(cluster, iter.GetValue()) + ")";
+            DataModelLogger::LogString(index, indent + 1, item);
+        }
+        if (iter.GetStatus() != CHIP_NO_ERROR)
+        {
+            DataModelLogger::LogString(indent + 1, "List truncated due to invalid value");
+        }
+        return iter.GetStatus();
+    }
+
 #include <zap-generated/cluster/logging/DataModelLogger.h>
 
     static void LogString(size_t indent, const std::string string) { LogString("", indent, string); }

diff --git a/examples/chip-tool/templates/logging/DataModelLogger-src.zapt b/examples/chip-tool/templates/logging/DataModelLogger-src.zapt
@@ -75,7 +75,19 @@ CHIP_ERROR DataModelLogger::LogAttribute(const chip::app::ConcreteDataAttributeP
             {
                 {{zapTypeToDecodableClusterObjectType type ns=parent.name forceNotOptional=true}} value;
                 ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
+{{#if (isEqual name "ServerList")}}
+                return DataModelLogger::LogClusterId("{{name}}", 1, value);
+{{else if (isEqual name "ClientList")}}
+                return DataModelLogger::LogClusterId("{{name}}", 1, value);
+{{else if (isEqual name "AttributeList")}}
+                return DataModelLogger::LogAttributeId("{{name}}", 1, value, {{asUpperCamelCase parent.name}}::Id);
+{{else if (isEqual name "AcceptedCommandList")}}
+                return DataModelLogger::LogAcceptedCommandId("{{name}}", 1, value, {{asUpperCamelCase parent.name}}::Id);
+{{else if (isEqual name "GeneratedCommandList")}}
+                return DataModelLogger::LogGeneratedCommandId("{{name}}", 1, value, {{asUpperCamelCase parent.name}}::Id);
+{{else}}
                 return DataModelLogger::LogValue("{{name}}", 1, value);
+{{/if}}
             }
 {{#last}}
           }

diff --git a/examples/chip-tool/templates/logging/EntryToText-src.zapt b/examples/chip-tool/templates/logging/EntryToText-src.zapt
@@ -0,0 +1,84 @@
+{{> header}}
+
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app-common/zap-generated/ids/Commands.h>
+
+char const * ClusterIdToText(chip::ClusterId id) {
+	switch(id)
+	{
+{{#zcl_clusters}}
+		case chip::app::Clusters::{{asUpperCamelCase name}}::Id: return "{{asUpperCamelCase name}}";
+{{/zcl_clusters}}
+		default: return "Unknown";
+	}
+}
+
+char const * AttributeIdToText(chip::ClusterId cluster, chip::AttributeId id) {
+	switch(cluster)
+	{
+{{#zcl_clusters}}
+{{#zcl_attributes_server}}
+{{#first}}
+		case chip::app::Clusters::{{asUpperCamelCase parent.name}}::Id:
+		{
+			switch(id)
+			{
+{{/first}}
+				case chip::app::Clusters::{{asUpperCamelCase parent.name}}::Attributes::{{asUpperCamelCase name}}::Id: return "{{asUpperCamelCase name}}";
+{{#last}}
+				default: return "Unknown";
+			}
+		}
+{{/last}}
+{{/zcl_attributes_server}}
+{{/zcl_clusters}}
+		default: return "Unknown";
+	}
+}
+
+char const * AcceptedCommandIdToText(chip::ClusterId cluster, chip::CommandId id) {
+	switch(cluster)
+	{
+{{#zcl_clusters}}
+{{#zcl_commands_source_client}}
+{{#first}}
+		case chip::app::Clusters::{{asUpperCamelCase parent.name}}::Id:
+		{
+			switch(id)
+			{
+{{/first}}
+				case chip::app::Clusters::{{asUpperCamelCase parent.name}}::Commands::{{asUpperCamelCase name}}::Id: return "{{asUpperCamelCase name}}";
+{{#last}}
+				default: return "Unknown";
+			}
+		}
+{{/last}}
+{{/zcl_commands_source_client}}
+{{/zcl_clusters}}
+		default: return "Unknown";
+	}
+}
+
+char const * GeneratedCommandIdToText(chip::ClusterId cluster, chip::CommandId id) {
+	switch(cluster)
+	{
+{{#zcl_clusters}}
+{{#zcl_commands_source_server}}
+{{#first}}
+		case chip::app::Clusters::{{asUpperCamelCase parent.name}}::Id:
+		{
+			switch(id)
+			{
+{{/first}}
+				case chip::app::Clusters::{{asUpperCamelCase parent.name}}::Commands::{{asUpperCamelCase name}}::Id: return "{{asUpperCamelCase name}}";
+{{#last}}
+				default: return "Unknown";
+			}
+		}
+{{/last}}
+{{/zcl_commands_source_server}}
+{{/zcl_clusters}}
+		default: return "Unknown";
+	}
+}
diff --git a/examples/chip-tool/templates/logging/EntryToText.zapt b/examples/chip-tool/templates/logging/EntryToText.zapt
@@ -0,0 +1,13 @@
+{{> header}}
+
+#include <app-common/zap-generated/ids/Attributes.h>
+#include <app-common/zap-generated/ids/Clusters.h>
+#include <app-common/zap-generated/ids/Commands.h>
+
+char const * ClusterIdToText(chip::ClusterId id);
+
+char const * AttributeIdToText(chip::ClusterId cluster, chip::AttributeId id);
+
+char const * AcceptedCommandIdToText(chip::ClusterId cluster, chip::CommandId id);
+
+char const * GeneratedCommandIdToText(chip::ClusterId cluster, chip::CommandId id);
diff --git a/examples/chip-tool/templates/templates.json b/examples/chip-tool/templates/templates.json
@@ -64,6 +64,16 @@
             "path": "ComplexArgumentParser-src.zapt",
             "name": "Complex Argument Parser",
             "output": "cluster/ComplexArgumentParser.cpp"
+        },
+        {
+            "path": "logging/EntryToText.zapt",
+            "name": "Entry To Text header",
+            "output": "cluster/logging/EntryToText.h"
+        },
+        {
+            "path": "logging/EntryToText-src.zapt",
+            "name": "Entry To Text",
+            "output": "cluster/logging/EntryToText.cpp"
         }
     ]
 }
diff --git a/examples/fabric-admin/commands/clusters/DataModelLogger.h b/examples/fabric-admin/commands/clusters/DataModelLogger.h
@@ -28,6 +28,7 @@
 #include <app/data-model/DecodableList.h>
 #include <commands/common/RemoteDataModelLogger.h>
 #include <lib/support/BytesToHex.h>
+#include <zap-generated/cluster/logging/EntryToText.h>
 
 class DataModelLogger
 {
@@ -157,6 +158,100 @@ class DataModelLogger
         return CHIP_NO_ERROR;
     }
 
+    static CHIP_ERROR LogClusterId(const char * label, size_t indent,
+                                   const chip::app::DataModel::DecodableList<chip::ClusterId> & value)
+    {
+        size_t count = 0;
+        ReturnErrorOnFailure(value.ComputeSize(&count));
+        DataModelLogger::LogString(label, indent, std::to_string(count) + " entries");
+
+        auto iter = value.begin();
+        size_t i  = 0;
+        while (iter.Next())
+        {
+            ++i;
+            std::string index = std::string("[") + std::to_string(i) + "]";
+            std::string item  = std::to_string(iter.GetValue()) + " (" + ClusterIdToText(iter.GetValue()) + ")";
+            DataModelLogger::LogString(index, indent + 1, item);
+        }
+        if (iter.GetStatus() != CHIP_NO_ERROR)
+        {
+            DataModelLogger::LogString(indent + 1, "List truncated due to invalid value");
+        }
+        return iter.GetStatus();
+    }
+
+    static CHIP_ERROR LogAttributeId(const char * label, size_t indent,
+                                     const chip::app::DataModel::DecodableList<chip::AttributeId> & value, chip::ClusterId cluster)
+    {
+        size_t count = 0;
+        ReturnErrorOnFailure(value.ComputeSize(&count));
+        DataModelLogger::LogString(label, indent, std::to_string(count) + " entries");
+
+        auto iter = value.begin();
+        size_t i  = 0;
+        while (iter.Next())
+        {
+            ++i;
+            std::string index = std::string("[") + std::to_string(i) + "]";
+            std::string item  = std::to_string(iter.GetValue()) + " (" + AttributeIdToText(cluster, iter.GetValue()) + ")";
+            DataModelLogger::LogString(index, indent + 1, item);
+        }
+        if (iter.GetStatus() != CHIP_NO_ERROR)
+        {
+            DataModelLogger::LogString(indent + 1, "List truncated due to invalid value");
+        }
+        return iter.GetStatus();
+    }
+
+    static CHIP_ERROR LogAcceptedCommandId(const char * label, size_t indent,
+                                           const chip::app::DataModel::DecodableList<chip::CommandId> & value,
+                                           chip::ClusterId cluster)
+    {
+        size_t count = 0;
+        ReturnErrorOnFailure(value.ComputeSize(&count));
+        DataModelLogger::LogString(label, indent, std::to_string(count) + " entries");
+
+        auto iter = value.begin();
+        size_t i  = 0;
+        while (iter.Next())
+        {
+            ++i;
+            std::string index = std::string("[") + std::to_string(i) + "]";
+            std::string item  = std::to_string(iter.GetValue()) + " (" + AcceptedCommandIdToText(cluster, iter.GetValue()) + ")";
+            DataModelLogger::LogString(index, indent + 1, item);
+        }
+        if (iter.GetStatus() != CHIP_NO_ERROR)
+        {
+            DataModelLogger::LogString(indent + 1, "List truncated due to invalid value");
+        }
+        return iter.GetStatus();
+    }
+
+    static CHIP_ERROR LogGeneratedCommandId(const char * label, size_t indent,
+                                            const chip::app::DataModel::DecodableList<chip::CommandId> & value,
+                                            chip::ClusterId cluster)
+    {
+        size_t count = 0;
+        ReturnErrorOnFailure(value.ComputeSize(&count));
+        DataModelLogger::LogString(label, indent, std::to_string(count) + " entries");
+
+        auto iter = value.begin();
+        size_t i  = 0;
+        while (iter.Next())
+        {
+            ++i;
+            std::string index = std::string("[") + std::to_string(i) + "]";
+            std::string item  = std::to_string(iter.GetValue()) + " (" + GeneratedCommandIdToText(cluster, iter.GetValue()) + ")";
+            DataModelLogger::LogString(index, indent + 1, item);
+        }
+        if (iter.GetStatus() != CHIP_NO_ERROR)
+        {
+            DataModelLogger::LogString(indent + 1, "List truncated due to invalid value");
+        }
+        return iter.GetStatus();
+    }
+
 #include <zap-generated/cluster/logging/DataModelLogger.h>
 
     static void LogString(size_t indent, const std::string string) { LogString("", indent, string); }

diff --git a/examples/tv-casting-app/android/App/app/build.gradle b/examples/tv-casting-app/android/App/app/build.gradle
@@ -7,7 +7,7 @@ android {
 
     defaultConfig {
         applicationId "com.chip.casting"
-        minSdk 24
+        minSdk 26
         targetSdk 30
         versionCode 1
         versionName "1.0"
@@ -47,6 +47,8 @@ android {
             java.srcDirs = [
                     'src/main/java',
                     'src/main/jni',
+                    'src/compat/java',
+                    'src/compat/jni',
             ]
 
             // uncomment this code to debug

diff --git a/.../com/chip/casting/app/CastingContext.java → .../com/chip/casting/app/CastingContext.java b/.../com/chip/casting/app/CastingContext.java → .../com/chip/casting/app/CastingContext.java
@@ -5,6 +5,8 @@
 import androidx.fragment.app.FragmentActivity;
 import com.R;
 
+/** @deprecated Use the APIs described in /examples/tv-casting-app/APIs.md instead. */
+@Deprecated
 public class CastingContext {
   private FragmentActivity fragmentActivity;