Get cluster info mapping (#10919)
* basic code generation template, but not able to import to tool app
* create new public class under chip/clusterinfo
* change package
* no error code generation
* new design solution
* need to wait for cast-helper
* callback generation done
* on/off commands working
* revert .idea changes
* one more .idea change revert
* remove outline.java
* Restyled by whitespace
* Restyled by google-java-format
* Restyled by gn
* Restyled by google-java-format
* fix merge
* merge conflict
* fix comments
* Restyled by gn
* resolve type, nullable and format comments
* resolve build issues
* Restyled by gn
* update zap generated file
* add descriptive documentation on each new class
* Restyled by google-java-format
* modify description of each new added class
* Restyled by google-java-format
* add . at the end of class description
* Restyled by google-java-format
* rebase and regenerate script file
* merge with mbedos problem fixed
* rebase and try checks
* rebase master to see if pass checks
* retry checks
Co-authored-by: Restyled.io <commits@restyled.io>
diff --git a/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/ClusterInteractionFragment.kt b/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/ClusterInteractionFragment.kt
index 66c20fb..96d171b 100644
--- a/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/ClusterInteractionFragment.kt
+++ b/src/android/CHIPTool/app/src/main/java/com/google/chip/chiptool/clusterclient/ClusterInteractionFragment.kt
@@ -7,6 +7,9 @@
import android.view.ViewGroup
import android.widget.Toast
import androidx.fragment.app.Fragment
+import chip.clusterinfo.ClusterCommandCallback
+import chip.clusterinfo.ClusterInfo
+import chip.clusterinfo.CommandInfo
import chip.devicecontroller.ChipDeviceController
import com.google.chip.chiptool.ChipClient
import com.google.chip.chiptool.GenericChipDeviceListener
@@ -15,12 +18,18 @@
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.cancel
+import chip.devicecontroller.ClusterInfoMapping
+import java.lang.Exception
+import kotlinx.android.synthetic.main.cluster_interaction_fragment.view.getClusterMappingBtn
+import kotlinx.coroutines.launch
class ClusterInteractionFragment : Fragment() {
private val deviceController: ChipDeviceController
get() = ChipClient.getDeviceController(requireContext())
private val scope = CoroutineScope(Dispatchers.Main + Job())
+ private lateinit var addressUpdateFragment: AddressUpdateFragment
+ private lateinit var clusterMap: Map<String, ClusterInfo>
override fun onCreateView(
inflater: LayoutInflater,
@@ -29,9 +38,43 @@
): View {
return inflater.inflate(R.layout.cluster_interaction_fragment, container, false).apply {
deviceController.setCompletionListener(ChipControllerCallback())
+ addressUpdateFragment =
+ childFragmentManager.findFragmentById(R.id.addressUpdateFragment) as AddressUpdateFragment
+ clusterMap = ClusterInfoMapping().clusterMap;
+ getClusterMappingBtn.setOnClickListener { scope.launch { getClusterMapping() } }
}
}
+ private suspend fun getClusterMapping() {
+ // In real code: "OnOff" would be selected by the user.
+ val methodSelected = "onOff"
+ showMessage(methodSelected + " is initialized")
+ val selectedClusterInfo = clusterMap[methodSelected]!!
+ val devicePtr =
+ ChipClient.getConnectedDevicePointer(requireContext(), addressUpdateFragment.deviceId)
+ val endpointId = 1
+ val selectedCluster = selectedClusterInfo.createClusterFunction.create(devicePtr, endpointId)
+ // Imagine user wants to execute the command "OffWithEffect", pass the string here
+ val selectedCommandInfo: CommandInfo = selectedClusterInfo.commands["on"]!!
+
+ var selectedCommandCallback = selectedCommandInfo.commandCallbackSupplier.get()
+ selectedCommandCallback?.setCallbackDelegate(object : ClusterCommandCallback {
+ override fun onSuccess(responseValues: List<Any>) {
+ showMessage("Command success")
+ // Populate UI based on response values. We know the types from CommandInfo.getCommandResponses().
+ responseValues.forEach { Log.d(TAG, it.toString()) }
+ }
+
+ override fun onFailure(exception: Exception) {
+ showMessage("Command failed")
+ Log.e(TAG, exception.toString())
+ }
+ })
+
+ var commandArguments: HashMap<String, Any> = HashMap<String, Any>()
+ selectedCommandInfo.getCommandFunction().invokeCommand(selectedCluster, selectedCommandCallback, commandArguments)
+ }
+
private fun showMessage(msg: String) {
requireActivity().runOnUiThread {
Toast.makeText(requireContext(), msg, Toast.LENGTH_SHORT).show()
diff --git a/src/android/CHIPTool/app/src/main/res/layout/cluster_interaction_fragment.xml b/src/android/CHIPTool/app/src/main/res/layout/cluster_interaction_fragment.xml
index 29cf6e5..f101f9d 100644
--- a/src/android/CHIPTool/app/src/main/res/layout/cluster_interaction_fragment.xml
+++ b/src/android/CHIPTool/app/src/main/res/layout/cluster_interaction_fragment.xml
@@ -1,24 +1,34 @@
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
+ xmlns:tools="http://schemas.android.com/tools"
+ android:id="@+id/clusterInteraction"
android:layout_width="match_parent"
android:layout_height="match_parent">
+ <Button
+ android:id="@+id/getClusterMappingBtn"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:layout_marginTop="132dp"
+ android:layout_marginStart="16dp"
+ android:text="Button"
+ app:layout_constraintStart_toStartOf="parent"
+ app:layout_constraintTop_toTopOf="parent" />
<androidx.fragment.app.FragmentContainerView
android:id="@+id/addressUpdateFragment"
android:name="com.google.chip.chiptool.clusterclient.AddressUpdateFragment"
android:layout_width="match_parent"
android:layout_height="wrap_content"
- app:layout_constraintTop_toTopOf="parent"
+ app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
- app:layout_constraintEnd_toEndOf="parent"/>
-
+ app:layout_constraintTop_toTopOf="parent" />
<androidx.recyclerview.widget.RecyclerView
android:id="@+id/endpointList"
android:layout_width="match_parent"
android:layout_height="match_parent"
+ android:layout_marginTop="180dp"
android:clipToPadding="false"
- android:layout_marginTop="48dp"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/addressUpdateFragment" />
diff --git a/src/controller/java/BUILD.gn b/src/controller/java/BUILD.gn
index 4eaa2d0..6bd7248 100644
--- a/src/controller/java/BUILD.gn
+++ b/src/controller/java/BUILD.gn
@@ -58,6 +58,11 @@
]
sources = [
+ "src/chip/clusterinfo/ClusterCommandCallback.java",
+ "src/chip/clusterinfo/ClusterInfo.java",
+ "src/chip/clusterinfo/CommandInfo.java",
+ "src/chip/clusterinfo/CommandParameterInfo.java",
+ "src/chip/clusterinfo/DelegatedClusterCallback.java",
"src/chip/devicecontroller/ChipClusterException.java",
"src/chip/devicecontroller/ChipCommandType.java",
"src/chip/devicecontroller/ChipDeviceController.java",
@@ -65,6 +70,7 @@
"src/chip/devicecontroller/GetConnectedDeviceCallbackJni.java",
"src/chip/devicecontroller/PaseVerifierParams.java",
"zap-generated/chip/devicecontroller/ChipClusters.java",
+ "zap-generated/chip/devicecontroller/ClusterInfoMapping.java",
]
javac_flags = [ "-Xlint:deprecation" ]
diff --git a/src/controller/java/src/chip/clusterinfo/ClusterCommandCallback.java b/src/controller/java/src/chip/clusterinfo/ClusterCommandCallback.java
new file mode 100644
index 0000000..f7cfef3
--- /dev/null
+++ b/src/controller/java/src/chip/clusterinfo/ClusterCommandCallback.java
@@ -0,0 +1,12 @@
+package chip.clusterinfo;
+
+import java.util.List;
+
+/**
+ * Interface for making customized callback that implements both onSuccess and onFailure functions.
+ */
+public interface ClusterCommandCallback {
+ void onSuccess(List<Object> responseValues);
+
+ void onFailure(Exception exception);
+}
diff --git a/src/controller/java/src/chip/clusterinfo/ClusterInfo.java b/src/controller/java/src/chip/clusterinfo/ClusterInfo.java
new file mode 100644
index 0000000..f90a9b8
--- /dev/null
+++ b/src/controller/java/src/chip/clusterinfo/ClusterInfo.java
@@ -0,0 +1,33 @@
+package chip.clusterinfo;
+
+import chip.devicecontroller.ChipClusters.BaseChipCluster;
+import java.util.Map;
+
+/** ClusterInfo maps commands and provides a constructor function for a cluster. */
+public class ClusterInfo {
+ private final ClusterConstructor createClusterFunction;
+ private final Map<String, CommandInfo> commands;
+
+ public ClusterInfo(ClusterConstructor createClusterFunction, Map<String, CommandInfo> commands) {
+ this.createClusterFunction = createClusterFunction;
+ this.commands = commands;
+ }
+
+ public ClusterConstructor getCreateClusterFunction() {
+ return createClusterFunction;
+ }
+
+ public Map<String, CommandInfo> getCommands() {
+ return commands;
+ }
+
+ /**
+ * The functional interface provides a uniform way to create cluster through create function. In
+ * ClusterInfoMapping, each ClusterConstructor was generated using the intended function. Using
+ * lambda function, it only needs to have ptr and endpointId to create the intended cluster.
+ */
+ @FunctionalInterface
+ public interface ClusterConstructor {
+ BaseChipCluster create(Long devicePtr, int endpointId);
+ }
+}
diff --git a/src/controller/java/src/chip/clusterinfo/CommandInfo.java b/src/controller/java/src/chip/clusterinfo/CommandInfo.java
new file mode 100644
index 0000000..7bc59c1
--- /dev/null
+++ b/src/controller/java/src/chip/clusterinfo/CommandInfo.java
@@ -0,0 +1,49 @@
+package chip.clusterinfo;
+
+import chip.devicecontroller.ChipClusters.BaseChipCluster;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/**
+ * CommandInfo has a functional interface to invoke arbitrary commands based on cluster, callback
+ * and a map of arguments, a Supplier that provides {@link DelegatedClusterCallback}, and maps the
+ * parameter and commandParametersInfo.
+ */
+public class CommandInfo {
+ public ClusterCommandFunction commandFunction;
+ private Supplier<DelegatedClusterCallback> commandCallbackSupplier;
+ private Map<String, CommandParameterInfo> commandParameters;
+
+ public CommandInfo(
+ ClusterCommandFunction commandFunction,
+ Supplier<DelegatedClusterCallback> commandCallbackSupplier,
+ Map<String, CommandParameterInfo> commandParameters) {
+ this.commandFunction = commandFunction;
+ this.commandCallbackSupplier = commandCallbackSupplier;
+ this.commandParameters = commandParameters;
+ }
+
+ public ClusterCommandFunction getCommandFunction() {
+ return commandFunction;
+ }
+
+ public Supplier<DelegatedClusterCallback> getCommandCallbackSupplier() {
+ return commandCallbackSupplier;
+ }
+
+ public Map<String, CommandParameterInfo> getCommandParameters() {
+ return commandParameters;
+ }
+
+ /**
+ * The functional interface provides a uniform way to invoke commands through invokeCommand
+ * function. In ClusterInfoMapping, each ClusterCommandFunction was generated using the intended
+ * function. By using lambda function, the app component only needs to have cluster, callback,
+ * commandArguments to execute the correct function.
+ */
+ @FunctionalInterface
+ public interface ClusterCommandFunction {
+ void invokeCommand(
+ BaseChipCluster cluster, Object callback, Map<String, Object> commandArguments);
+ }
+}
diff --git a/src/controller/java/src/chip/clusterinfo/CommandParameterInfo.java b/src/controller/java/src/chip/clusterinfo/CommandParameterInfo.java
new file mode 100644
index 0000000..f549874
--- /dev/null
+++ b/src/controller/java/src/chip/clusterinfo/CommandParameterInfo.java
@@ -0,0 +1,14 @@
+package chip.clusterinfo;
+
+/** CommandParameterInfo captures the name and type of a parameter */
+public class CommandParameterInfo {
+ public CommandParameterInfo() {}
+
+ public CommandParameterInfo(String name, Class<?> type) {
+ this.name = name;
+ this.type = type;
+ }
+
+ public String name;
+ public Class<?> type;
+}
diff --git a/src/controller/java/src/chip/clusterinfo/DelegatedClusterCallback.java b/src/controller/java/src/chip/clusterinfo/DelegatedClusterCallback.java
new file mode 100644
index 0000000..e2f21cb
--- /dev/null
+++ b/src/controller/java/src/chip/clusterinfo/DelegatedClusterCallback.java
@@ -0,0 +1,6 @@
+package chip.clusterinfo;
+
+/** Interface for a callback that delegates to {@link ClusterCommandCallback}. */
+public interface DelegatedClusterCallback {
+ void setCallbackDelegate(ClusterCommandCallback callback);
+}
diff --git a/src/controller/java/templates/ClusterInfo-java.zapt b/src/controller/java/templates/ClusterInfo-java.zapt
new file mode 100644
index 0000000..992c6cb
--- /dev/null
+++ b/src/controller/java/templates/ClusterInfo-java.zapt
@@ -0,0 +1,153 @@
+{{> header}}
+{{#if (chip_has_client_clusters)}}
+
+package chip.devicecontroller;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.List;
+import java.util.HashMap;
+import chip.clusterinfo.ClusterInfo;
+import chip.clusterinfo.CommandInfo;
+import chip.clusterinfo.CommandParameterInfo;
+import chip.clusterinfo.DelegatedClusterCallback;
+import chip.clusterinfo.ClusterCommandCallback;
+import chip.devicecontroller.ChipClusters.DefaultClusterCallback;
+
+
+public class ClusterInfoMapping {
+
+ class DelegatedDefaultClusterCallback implements DefaultClusterCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ // Parameters and list-adds here should be generated - refer to the template code that creates each callback interface.
+ @Override
+ public void onSuccess() {
+ List<Object> responseValues = new ArrayList<>();
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception e) {
+ callback.onFailure(e);
+ }
+ }
+ {{#chip_client_clusters}}
+ {{#chip_cluster_responses}}
+ public class Delegated{{asUpperCamelCase name}}Callback implements ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase name}}Callback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(
+ {{#chip_cluster_response_arguments}}
+ {{#if isArray}}
+ // {{asSymbol label}}: {{asUnderlyingZclType type}}
+ // Conversion from this type to Java is not properly implemented yet
+ {{else if (isOctetString type)}}
+ {{omitCommaForFirstNonStatusCommand parent.id index}}byte[] {{asSymbol label}}
+ {{else if (isShortString type)}}
+ {{omitCommaForFirstNonStatusCommand parent.id index}}String {{asSymbol label}}
+ {{else}}
+ {{omitCommaForFirstNonStatusCommand parent.id index}}{{asJavaBasicTypeForZclType type false}} {{asSymbol label}}
+ {{/if}}
+ {{/chip_cluster_response_arguments}}
+ ) {
+ List<Object> responseValues = new ArrayList<>();
+ {{#chip_cluster_response_arguments}}
+ {{#if isArray}}
+ // {{asSymbol label}}: {{asUnderlyingZclType type}}
+ // Conversion from this type to Java is not properly implemented yet
+ {{else}}
+ responseValues.add({{asSymbol label}});
+ {{/if}}
+ {{/chip_cluster_response_arguments}}
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ {{/chip_cluster_responses}}
+ {{/chip_client_clusters}}
+
+ public Map<String, ClusterInfo> getClusterMap() {
+ Map<String, ClusterInfo> clusterMap = new HashMap<>();
+ {{#chip_client_clusters}}
+ Map<String, CommandInfo> {{asLowerCamelCase name}}ClusterCommandInfoMap = new LinkedHashMap<>();
+ {{#chip_cluster_commands}}
+ Map<String, CommandParameterInfo> {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParams = new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ {{#if (zcl_command_arguments_count this.id)}}
+ {{#if hasSpecificResponse}}
+ CommandParameterInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParameterInfo = new CommandParameterInfo("{{asUpperCamelCase ../name}}", ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase responseName}}Callback.class);
+ {{else}}
+ CommandParameterInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParameterInfo = new CommandParameterInfo("{{asUpperCamelCase ../name}}", ChipClusters.DefaultClusterCallback.class);
+ {{/if}}
+ {{#chip_cluster_command_arguments_with_structs_expanded}}
+ CommandParameterInfo {{asLowerCamelCase ../../name}}{{asLowerCamelCase ../name}}{{asLowerCamelCase label}}CommandParameterInfo = new CommandParameterInfo("{{asLowerCamelCase label}}", {{asJavaBasicType type}}.class);
+ {{asLowerCamelCase ../../name}}{{asLowerCamelCase ../name}}CommandParams.put("{{asLowerCamelCase label}}",{{asLowerCamelCase ../../name}}{{asLowerCamelCase ../name}}{{asLowerCamelCase label}}CommandParameterInfo);
+ {{#not_last}} {{/not_last}}
+ {{/chip_cluster_command_arguments_with_structs_expanded}}
+ {{else}}
+ {{#if hasSpecificResponse}}
+ CommandParameterInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParameterInfo = new CommandParameterInfo("{{asUpperCamelCase ../name}}", ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase responseName}}Callback.class);
+ {{else}}
+ CommandParameterInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParameterInfo = new CommandParameterInfo("{{asUpperCamelCase ../name}}", ChipClusters.DefaultClusterCallback.class);
+ {{/if}}
+ {{/if}}
+ // Populate commands
+ {{#if hasSpecificResponse}}
+ CommandInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandInfo = new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.{{asUpperCamelCase ../name}}Cluster) cluster)
+ .{{asLowerCamelCase name}}((ChipClusters.{{asUpperCamelCase ../name}}Cluster.{{asUpperCamelCase responseName}}Callback) callback
+ {{#chip_cluster_command_arguments_with_structs_expanded}},
+ ({{asJavaBoxedType type}})
+ commandArguments.get("{{asLowerCamelCase label}}")
+ {{/chip_cluster_command_arguments_with_structs_expanded}}
+ );
+ },
+ () -> new Delegated{{asUpperCamelCase responseName}}Callback(),
+ {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParams
+ );
+ {{else}}
+ CommandInfo {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandInfo = new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.{{asUpperCamelCase ../name}}Cluster) cluster)
+ .{{asLowerCamelCase name}}((DefaultClusterCallback) callback
+ {{#chip_cluster_command_arguments_with_structs_expanded}},
+ ({{asJavaBoxedType type}})
+ commandArguments.get("{{asLowerCamelCase label}}")
+ {{/chip_cluster_command_arguments_with_structs_expanded}}
+ );
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandParams
+ );
+ {{/if}}
+ {{asLowerCamelCase ../name}}ClusterCommandInfoMap.put("{{asLowerCamelCase name}}", {{asLowerCamelCase ../name}}{{asLowerCamelCase name}}CommandInfo);
+ {{/chip_cluster_commands}}
+ // Populate cluster
+ ClusterInfo {{asLowerCamelCase name}}ClusterInfo = new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.{{asUpperCamelCase name}}Cluster(ptr, endpointId), {{asLowerCamelCase name}}ClusterCommandInfoMap);
+ clusterMap.put("{{asLowerCamelCase name}}", {{asLowerCamelCase name}}ClusterInfo);
+ {{/chip_client_clusters}}
+ return clusterMap;
+ }
+}
+
+{{/if}}
diff --git a/src/controller/java/templates/helper.js b/src/controller/java/templates/helper.js
index 3b2f59e..f42ad49 100644
--- a/src/controller/java/templates/helper.js
+++ b/src/controller/java/templates/helper.js
@@ -88,6 +88,17 @@
}
}
+function asJavaBoxedType(type)
+{
+ if (StringHelper.isOctetString(type)) {
+ return 'byte[]';
+ } else if (StringHelper.isCharString(type)) {
+ return 'String';
+ } else {
+ return convertBasicCTypeToJavaBoxedType(ChipTypesHelper.asBasicType(this.chipType));
+ }
+}
+
function asJniBasicType(type)
{
if (StringHelper.isOctetString(type)) {
@@ -207,6 +218,7 @@
// Module exports
//
exports.asJavaBasicType = asJavaBasicType;
+exports.asJavaBoxedType = asJavaBoxedType;
exports.asJniBasicType = asJniBasicType;
exports.asJniBasicTypeForZclType = asJniBasicTypeForZclType;
exports.asJniSignature = asJniSignature;
diff --git a/src/controller/java/templates/templates.json b/src/controller/java/templates/templates.json
index 04f4fb6..16bbc72 100644
--- a/src/controller/java/templates/templates.json
+++ b/src/controller/java/templates/templates.json
@@ -35,6 +35,11 @@
"path": "ChipClusters-java.zapt",
"name": "CHIP ZCL API for Java",
"output": "src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java"
+ },
+ {
+ "path": "ClusterInfo-java.zapt",
+ "name": "Cluster information mapping for Java",
+ "output": "src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java"
}
]
}
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java
new file mode 100644
index 0000000..4e37105
--- /dev/null
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java
@@ -0,0 +1,7110 @@
+/*
+ *
+ * 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.
+ */
+
+// THIS FILE IS GENERATED BY ZAP
+
+package chip.devicecontroller;
+
+import chip.clusterinfo.ClusterCommandCallback;
+import chip.clusterinfo.ClusterInfo;
+import chip.clusterinfo.CommandInfo;
+import chip.clusterinfo.CommandParameterInfo;
+import chip.clusterinfo.DelegatedClusterCallback;
+import chip.devicecontroller.ChipClusters.DefaultClusterCallback;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ClusterInfoMapping {
+
+ class DelegatedDefaultClusterCallback
+ implements DefaultClusterCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ // Parameters and list-adds here should be generated - refer to the template code that creates
+ // each callback interface.
+ @Override
+ public void onSuccess() {
+ List<Object> responseValues = new ArrayList<>();
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception e) {
+ callback.onFailure(e);
+ }
+ }
+
+ public class DelegatedGetSetupPINResponseCallback
+ implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(String setupPIN) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(setupPIN);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedLaunchAppResponseCallback
+ implements ChipClusters.ApplicationLauncherCluster.LaunchAppResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, String data) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(data);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedLaunchContentResponseCallback
+ implements ChipClusters.ContentLauncherCluster.LaunchContentResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(String data, int contentLaunchStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(data);
+ responseValues.add(contentLaunchStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedLaunchURLResponseCallback
+ implements ChipClusters.ContentLauncherCluster.LaunchURLResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(String data, int contentLaunchStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(data);
+ responseValues.add(contentLaunchStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedRetrieveLogsResponseCallback
+ implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, byte[] content, long timeStamp, long timeSinceBoot) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(content);
+ responseValues.add(timeStamp);
+ responseValues.add(timeSinceBoot);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedClearAllPinsResponseCallback
+ implements ChipClusters.DoorLockCluster.ClearAllPinsResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedClearAllRfidsResponseCallback
+ implements ChipClusters.DoorLockCluster.ClearAllRfidsResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedClearHolidayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.ClearHolidayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedClearPinResponseCallback
+ implements ChipClusters.DoorLockCluster.ClearPinResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedClearRfidResponseCallback
+ implements ChipClusters.DoorLockCluster.ClearRfidResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedClearWeekdayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.ClearWeekdayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedClearYeardayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.ClearYeardayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetHolidayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.GetHolidayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(
+ int scheduleId,
+ int status,
+ long localStartTime,
+ long localEndTime,
+ int operatingModeDuringHoliday) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(scheduleId);
+ responseValues.add(status);
+ responseValues.add(localStartTime);
+ responseValues.add(localEndTime);
+ responseValues.add(operatingModeDuringHoliday);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetLogRecordResponseCallback
+ implements ChipClusters.DoorLockCluster.GetLogRecordResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(
+ int logEntryId,
+ long timestamp,
+ int eventType,
+ int source,
+ int eventIdOrAlarmCode,
+ int userId,
+ byte[] pin) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(logEntryId);
+ responseValues.add(timestamp);
+ responseValues.add(eventType);
+ responseValues.add(source);
+ responseValues.add(eventIdOrAlarmCode);
+ responseValues.add(userId);
+ responseValues.add(pin);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetPinResponseCallback
+ implements ChipClusters.DoorLockCluster.GetPinResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int userId, int userStatus, int userType, byte[] pin) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(userId);
+ responseValues.add(userStatus);
+ responseValues.add(userType);
+ responseValues.add(pin);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetRfidResponseCallback
+ implements ChipClusters.DoorLockCluster.GetRfidResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int userId, int userStatus, int userType, byte[] rfid) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(userId);
+ responseValues.add(userStatus);
+ responseValues.add(userType);
+ responseValues.add(rfid);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetUserTypeResponseCallback
+ implements ChipClusters.DoorLockCluster.GetUserTypeResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int userId, int userType) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(userId);
+ responseValues.add(userType);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetWeekdayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.GetWeekdayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(
+ int scheduleId,
+ int userId,
+ int status,
+ int daysMask,
+ int startHour,
+ int startMinute,
+ int endHour,
+ int endMinute) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(scheduleId);
+ responseValues.add(userId);
+ responseValues.add(status);
+ responseValues.add(daysMask);
+ responseValues.add(startHour);
+ responseValues.add(startMinute);
+ responseValues.add(endHour);
+ responseValues.add(endMinute);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetYeardayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.GetYeardayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(
+ int scheduleId, int userId, int status, long localStartTime, long localEndTime) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(scheduleId);
+ responseValues.add(userId);
+ responseValues.add(status);
+ responseValues.add(localStartTime);
+ responseValues.add(localEndTime);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedLockDoorResponseCallback
+ implements ChipClusters.DoorLockCluster.LockDoorResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedSetHolidayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.SetHolidayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedSetPinResponseCallback
+ implements ChipClusters.DoorLockCluster.SetPinResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedSetRfidResponseCallback
+ implements ChipClusters.DoorLockCluster.SetRfidResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedSetUserTypeResponseCallback
+ implements ChipClusters.DoorLockCluster.SetUserTypeResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedSetWeekdayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.SetWeekdayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedSetYeardayScheduleResponseCallback
+ implements ChipClusters.DoorLockCluster.SetYeardayScheduleResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedUnlockDoorResponseCallback
+ implements ChipClusters.DoorLockCluster.UnlockDoorResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedUnlockWithTimeoutResponseCallback
+ implements ChipClusters.DoorLockCluster.UnlockWithTimeoutResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedArmFailSafeResponseCallback
+ implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedCommissioningCompleteResponseCallback
+ implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedSetRegulatoryConfigResponseCallback
+ implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedAddGroupResponseCallback
+ implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int groupId) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(groupId);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetGroupMembershipResponseCallback
+ implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int capacity, int groupCount
+ // groupList: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ ) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(capacity);
+ responseValues.add(groupCount);
+ // groupList: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedRemoveGroupResponseCallback
+ implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int groupId) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(groupId);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedViewGroupResponseCallback
+ implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int groupId, String groupName) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(groupId);
+ responseValues.add(groupName);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedIdentifyQueryResponseCallback
+ implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int timeout) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(timeout);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedSendKeyResponseCallback
+ implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaFastForwardResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaFastForwardResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaNextResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaNextResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaPauseResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaPauseResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaPlayResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaPlayResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaPreviousResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaPreviousResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaRewindResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaRewindResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaSeekResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaSeekResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaSkipBackwardResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaSkipBackwardResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaSkipForwardResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaSkipForwardResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaStartOverResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaStartOverResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedMediaStopResponseCallback
+ implements ChipClusters.MediaPlaybackCluster.MediaStopResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int mediaPlaybackStatus) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(mediaPlaybackStatus);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedAddThreadNetworkResponseCallback
+ implements ChipClusters.NetworkCommissioningCluster.AddThreadNetworkResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedAddWiFiNetworkResponseCallback
+ implements ChipClusters.NetworkCommissioningCluster.AddWiFiNetworkResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedDisableNetworkResponseCallback
+ implements ChipClusters.NetworkCommissioningCluster.DisableNetworkResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedEnableNetworkResponseCallback
+ implements ChipClusters.NetworkCommissioningCluster.EnableNetworkResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedRemoveNetworkResponseCallback
+ implements ChipClusters.NetworkCommissioningCluster.RemoveNetworkResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedScanNetworksResponseCallback
+ implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText
+ // wifiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ // threadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ ) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ // wifiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ // threadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedUpdateThreadNetworkResponseCallback
+ implements ChipClusters.NetworkCommissioningCluster.UpdateThreadNetworkResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedUpdateWiFiNetworkResponseCallback
+ implements ChipClusters.NetworkCommissioningCluster.UpdateWiFiNetworkResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int errorCode, String debugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(errorCode);
+ responseValues.add(debugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedApplyUpdateRequestResponseCallback
+ implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateRequestResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int action, long delayedActionTime) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(action);
+ responseValues.add(delayedActionTime);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedQueryImageResponseCallback
+ implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(
+ int status,
+ long delayedActionTime,
+ String imageURI,
+ long softwareVersion,
+ String softwareVersionString,
+ byte[] updateToken,
+ boolean userConsentNeeded,
+ byte[] metadataForRequestor) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(delayedActionTime);
+ responseValues.add(imageURI);
+ responseValues.add(softwareVersion);
+ responseValues.add(softwareVersionString);
+ responseValues.add(updateToken);
+ responseValues.add(userConsentNeeded);
+ responseValues.add(metadataForRequestor);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedAttestationResponseCallback
+ implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(byte[] AttestationElements, byte[] Signature) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(AttestationElements);
+ responseValues.add(Signature);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedCertificateChainResponseCallback
+ implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(byte[] Certificate) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(Certificate);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedNOCResponseCallback
+ implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int StatusCode, int FabricIndex, String DebugText) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(StatusCode);
+ responseValues.add(FabricIndex);
+ responseValues.add(DebugText);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedOpCSRResponseCallback
+ implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(NOCSRElements);
+ responseValues.add(AttestationSignature);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedAddSceneResponseCallback
+ implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int groupId, int sceneId) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(groupId);
+ responseValues.add(sceneId);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedGetSceneMembershipResponseCallback
+ implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int capacity, int groupId, int sceneCount
+ // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ ) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(capacity);
+ responseValues.add(groupId);
+ responseValues.add(sceneCount);
+ // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedRemoveAllScenesResponseCallback
+ implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int groupId) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(groupId);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedRemoveSceneResponseCallback
+ implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int groupId, int sceneId) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(groupId);
+ responseValues.add(sceneId);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedStoreSceneResponseCallback
+ implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int groupId, int sceneId) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(groupId);
+ responseValues.add(sceneId);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedViewSceneResponseCallback
+ implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, int groupId, int sceneId, int transitionTime, String sceneName
+ // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ ) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(groupId);
+ responseValues.add(sceneId);
+ responseValues.add(transitionTime);
+ responseValues.add(sceneName);
+ // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedChangeChannelResponseCallback
+ implements ChipClusters.TvChannelCluster.ChangeChannelResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(
+ // ChannelMatch: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ int ErrorType) {
+ List<Object> responseValues = new ArrayList<>();
+ // ChannelMatch: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ responseValues.add(ErrorType);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedNavigateTargetResponseCallback
+ implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int status, String data) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(status);
+ responseValues.add(data);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedTestAddArgumentsResponseCallback
+ implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int returnValue) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(returnValue);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedTestEnumsResponseCallback
+ implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int arg1, int arg2) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(arg1);
+ responseValues.add(arg2);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedTestListInt8UReverseResponseCallback
+ implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(
+ // arg1: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ ) {
+ List<Object> responseValues = new ArrayList<>();
+ // arg1: /* TYPE WARNING: array array defaults to */ uint8_t *
+ // Conversion from this type to Java is not properly implemented yet
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedTestNullableOptionalResponseCallback
+ implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(boolean wasPresent, boolean wasNull, int value) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(wasPresent);
+ responseValues.add(wasNull);
+ responseValues.add(value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public class DelegatedTestSpecificResponseCallback
+ implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback,
+ DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(int returnValue) {
+ List<Object> responseValues = new ArrayList<>();
+ responseValues.add(returnValue);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+
+ public Map<String, ClusterInfo> getClusterMap() {
+ Map<String, ClusterInfo> clusterMap = new HashMap<>();
+ Map<String, CommandInfo> accountLoginClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> accountLogingetSetupPINCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo accountLogingetSetupPINCommandParameterInfo =
+ new CommandParameterInfo(
+ "AccountLogin", ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback.class);
+ CommandParameterInfo accountLogingetSetupPINtempAccountIdentifierCommandParameterInfo =
+ new CommandParameterInfo("tempAccountIdentifier", String.class);
+ accountLogingetSetupPINCommandParams.put(
+ "tempAccountIdentifier", accountLogingetSetupPINtempAccountIdentifierCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo accountLogingetSetupPINCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.AccountLoginCluster) cluster)
+ .getSetupPIN(
+ (ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback,
+ (String) commandArguments.get("tempAccountIdentifier"));
+ },
+ () -> new DelegatedGetSetupPINResponseCallback(),
+ accountLogingetSetupPINCommandParams);
+ accountLoginClusterCommandInfoMap.put("getSetupPIN", accountLogingetSetupPINCommandInfo);
+ Map<String, CommandParameterInfo> accountLoginloginCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo accountLoginloginCommandParameterInfo =
+ new CommandParameterInfo("AccountLogin", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo accountLoginlogintempAccountIdentifierCommandParameterInfo =
+ new CommandParameterInfo("tempAccountIdentifier", String.class);
+ accountLoginloginCommandParams.put(
+ "tempAccountIdentifier", accountLoginlogintempAccountIdentifierCommandParameterInfo);
+
+ CommandParameterInfo accountLoginloginsetupPINCommandParameterInfo =
+ new CommandParameterInfo("setupPIN", String.class);
+ accountLoginloginCommandParams.put("setupPIN", accountLoginloginsetupPINCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo accountLoginloginCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.AccountLoginCluster) cluster)
+ .login(
+ (DefaultClusterCallback) callback,
+ (String) commandArguments.get("tempAccountIdentifier"),
+ (String) commandArguments.get("setupPIN"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ accountLoginloginCommandParams);
+ accountLoginClusterCommandInfoMap.put("login", accountLoginloginCommandInfo);
+ // Populate cluster
+ ClusterInfo accountLoginClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId),
+ accountLoginClusterCommandInfoMap);
+ clusterMap.put("accountLogin", accountLoginClusterInfo);
+ Map<String, CommandInfo> administratorCommissioningClusterCommandInfoMap =
+ new LinkedHashMap<>();
+ Map<String, CommandParameterInfo>
+ administratorCommissioningopenBasicCommissioningWindowCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo
+ administratorCommissioningopenBasicCommissioningWindowCommandParameterInfo =
+ new CommandParameterInfo(
+ "AdministratorCommissioning", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo
+ administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo =
+ new CommandParameterInfo("commissioningTimeout", int.class);
+ administratorCommissioningopenBasicCommissioningWindowCommandParams.put(
+ "commissioningTimeout",
+ administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo administratorCommissioningopenBasicCommissioningWindowCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.AdministratorCommissioningCluster) cluster)
+ .openBasicCommissioningWindow(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("commissioningTimeout"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ administratorCommissioningopenBasicCommissioningWindowCommandParams);
+ administratorCommissioningClusterCommandInfoMap.put(
+ "openBasicCommissioningWindow",
+ administratorCommissioningopenBasicCommissioningWindowCommandInfo);
+ Map<String, CommandParameterInfo>
+ administratorCommissioningopenCommissioningWindowCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo administratorCommissioningopenCommissioningWindowCommandParameterInfo =
+ new CommandParameterInfo(
+ "AdministratorCommissioning", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo
+ administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo =
+ new CommandParameterInfo("commissioningTimeout", int.class);
+ administratorCommissioningopenCommissioningWindowCommandParams.put(
+ "commissioningTimeout",
+ administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo);
+
+ CommandParameterInfo
+ administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo =
+ new CommandParameterInfo("PAKEVerifier", byte[].class);
+ administratorCommissioningopenCommissioningWindowCommandParams.put(
+ "PAKEVerifier",
+ administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo);
+
+ CommandParameterInfo
+ administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo =
+ new CommandParameterInfo("discriminator", int.class);
+ administratorCommissioningopenCommissioningWindowCommandParams.put(
+ "discriminator",
+ administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo);
+
+ CommandParameterInfo
+ administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo =
+ new CommandParameterInfo("iterations", long.class);
+ administratorCommissioningopenCommissioningWindowCommandParams.put(
+ "iterations",
+ administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo);
+
+ CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo =
+ new CommandParameterInfo("salt", byte[].class);
+ administratorCommissioningopenCommissioningWindowCommandParams.put(
+ "salt", administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo);
+
+ CommandParameterInfo
+ administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo =
+ new CommandParameterInfo("passcodeID", int.class);
+ administratorCommissioningopenCommissioningWindowCommandParams.put(
+ "passcodeID",
+ administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo administratorCommissioningopenCommissioningWindowCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.AdministratorCommissioningCluster) cluster)
+ .openCommissioningWindow(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("commissioningTimeout"),
+ (byte[]) commandArguments.get("PAKEVerifier"),
+ (Integer) commandArguments.get("discriminator"),
+ (Long) commandArguments.get("iterations"),
+ (byte[]) commandArguments.get("salt"),
+ (Integer) commandArguments.get("passcodeID"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ administratorCommissioningopenCommissioningWindowCommandParams);
+ administratorCommissioningClusterCommandInfoMap.put(
+ "openCommissioningWindow", administratorCommissioningopenCommissioningWindowCommandInfo);
+ Map<String, CommandParameterInfo> administratorCommissioningrevokeCommissioningCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo administratorCommissioningrevokeCommissioningCommandParameterInfo =
+ new CommandParameterInfo(
+ "AdministratorCommissioning", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo administratorCommissioningrevokeCommissioningCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.AdministratorCommissioningCluster) cluster)
+ .revokeCommissioning((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ administratorCommissioningrevokeCommissioningCommandParams);
+ administratorCommissioningClusterCommandInfoMap.put(
+ "revokeCommissioning", administratorCommissioningrevokeCommissioningCommandInfo);
+ // Populate cluster
+ ClusterInfo administratorCommissioningClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) ->
+ new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId),
+ administratorCommissioningClusterCommandInfoMap);
+ clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo);
+ Map<String, CommandInfo> applicationBasicClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> applicationBasicchangeStatusCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo applicationBasicchangeStatusCommandParameterInfo =
+ new CommandParameterInfo("ApplicationBasic", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo applicationBasicchangeStatusstatusCommandParameterInfo =
+ new CommandParameterInfo("status", int.class);
+ applicationBasicchangeStatusCommandParams.put(
+ "status", applicationBasicchangeStatusstatusCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo applicationBasicchangeStatusCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ApplicationBasicCluster) cluster)
+ .changeStatus(
+ (DefaultClusterCallback) callback, (Integer) commandArguments.get("status"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ applicationBasicchangeStatusCommandParams);
+ applicationBasicClusterCommandInfoMap.put(
+ "changeStatus", applicationBasicchangeStatusCommandInfo);
+ // Populate cluster
+ ClusterInfo applicationBasicClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId),
+ applicationBasicClusterCommandInfoMap);
+ clusterMap.put("applicationBasic", applicationBasicClusterInfo);
+ Map<String, CommandInfo> applicationLauncherClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> applicationLauncherlaunchAppCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo applicationLauncherlaunchAppCommandParameterInfo =
+ new CommandParameterInfo(
+ "ApplicationLauncher",
+ ChipClusters.ApplicationLauncherCluster.LaunchAppResponseCallback.class);
+ CommandParameterInfo applicationLauncherlaunchAppdataCommandParameterInfo =
+ new CommandParameterInfo("data", String.class);
+ applicationLauncherlaunchAppCommandParams.put(
+ "data", applicationLauncherlaunchAppdataCommandParameterInfo);
+
+ CommandParameterInfo applicationLauncherlaunchAppcatalogVendorIdCommandParameterInfo =
+ new CommandParameterInfo("catalogVendorId", int.class);
+ applicationLauncherlaunchAppCommandParams.put(
+ "catalogVendorId", applicationLauncherlaunchAppcatalogVendorIdCommandParameterInfo);
+
+ CommandParameterInfo applicationLauncherlaunchAppapplicationIdCommandParameterInfo =
+ new CommandParameterInfo("applicationId", String.class);
+ applicationLauncherlaunchAppCommandParams.put(
+ "applicationId", applicationLauncherlaunchAppapplicationIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo applicationLauncherlaunchAppCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ApplicationLauncherCluster) cluster)
+ .launchApp(
+ (ChipClusters.ApplicationLauncherCluster.LaunchAppResponseCallback) callback,
+ (String) commandArguments.get("data"),
+ (Integer) commandArguments.get("catalogVendorId"),
+ (String) commandArguments.get("applicationId"));
+ },
+ () -> new DelegatedLaunchAppResponseCallback(),
+ applicationLauncherlaunchAppCommandParams);
+ applicationLauncherClusterCommandInfoMap.put(
+ "launchApp", applicationLauncherlaunchAppCommandInfo);
+ // Populate cluster
+ ClusterInfo applicationLauncherClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId),
+ applicationLauncherClusterCommandInfoMap);
+ clusterMap.put("applicationLauncher", applicationLauncherClusterInfo);
+ Map<String, CommandInfo> audioOutputClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> audioOutputrenameOutputCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo audioOutputrenameOutputCommandParameterInfo =
+ new CommandParameterInfo("AudioOutput", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo audioOutputrenameOutputindexCommandParameterInfo =
+ new CommandParameterInfo("index", int.class);
+ audioOutputrenameOutputCommandParams.put(
+ "index", audioOutputrenameOutputindexCommandParameterInfo);
+
+ CommandParameterInfo audioOutputrenameOutputnameCommandParameterInfo =
+ new CommandParameterInfo("name", String.class);
+ audioOutputrenameOutputCommandParams.put(
+ "name", audioOutputrenameOutputnameCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo audioOutputrenameOutputCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.AudioOutputCluster) cluster)
+ .renameOutput(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("index"),
+ (String) commandArguments.get("name"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ audioOutputrenameOutputCommandParams);
+ audioOutputClusterCommandInfoMap.put("renameOutput", audioOutputrenameOutputCommandInfo);
+ Map<String, CommandParameterInfo> audioOutputselectOutputCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo audioOutputselectOutputCommandParameterInfo =
+ new CommandParameterInfo("AudioOutput", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo audioOutputselectOutputindexCommandParameterInfo =
+ new CommandParameterInfo("index", int.class);
+ audioOutputselectOutputCommandParams.put(
+ "index", audioOutputselectOutputindexCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo audioOutputselectOutputCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.AudioOutputCluster) cluster)
+ .selectOutput(
+ (DefaultClusterCallback) callback, (Integer) commandArguments.get("index"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ audioOutputselectOutputCommandParams);
+ audioOutputClusterCommandInfoMap.put("selectOutput", audioOutputselectOutputCommandInfo);
+ // Populate cluster
+ ClusterInfo audioOutputClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId),
+ audioOutputClusterCommandInfoMap);
+ clusterMap.put("audioOutput", audioOutputClusterInfo);
+ Map<String, CommandInfo> barrierControlClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> barrierControlbarrierControlGoToPercentCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo barrierControlbarrierControlGoToPercentCommandParameterInfo =
+ new CommandParameterInfo("BarrierControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo =
+ new CommandParameterInfo("percentOpen", int.class);
+ barrierControlbarrierControlGoToPercentCommandParams.put(
+ "percentOpen", barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo barrierControlbarrierControlGoToPercentCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.BarrierControlCluster) cluster)
+ .barrierControlGoToPercent(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("percentOpen"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ barrierControlbarrierControlGoToPercentCommandParams);
+ barrierControlClusterCommandInfoMap.put(
+ "barrierControlGoToPercent", barrierControlbarrierControlGoToPercentCommandInfo);
+ Map<String, CommandParameterInfo> barrierControlbarrierControlStopCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo barrierControlbarrierControlStopCommandParameterInfo =
+ new CommandParameterInfo("BarrierControl", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo barrierControlbarrierControlStopCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.BarrierControlCluster) cluster)
+ .barrierControlStop((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ barrierControlbarrierControlStopCommandParams);
+ barrierControlClusterCommandInfoMap.put(
+ "barrierControlStop", barrierControlbarrierControlStopCommandInfo);
+ // Populate cluster
+ ClusterInfo barrierControlClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId),
+ barrierControlClusterCommandInfoMap);
+ clusterMap.put("barrierControl", barrierControlClusterInfo);
+ Map<String, CommandInfo> basicClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> basicmfgSpecificPingCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo basicmfgSpecificPingCommandParameterInfo =
+ new CommandParameterInfo("Basic", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo basicmfgSpecificPingCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.BasicCluster) cluster)
+ .mfgSpecificPing((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ basicmfgSpecificPingCommandParams);
+ basicClusterCommandInfoMap.put("mfgSpecificPing", basicmfgSpecificPingCommandInfo);
+ // Populate cluster
+ ClusterInfo basicClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId),
+ basicClusterCommandInfoMap);
+ clusterMap.put("basic", basicClusterInfo);
+ Map<String, CommandInfo> binaryInputBasicClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo binaryInputBasicClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId),
+ binaryInputBasicClusterCommandInfoMap);
+ clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo);
+ Map<String, CommandInfo> bindingClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> bindingbindCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo bindingbindCommandParameterInfo =
+ new CommandParameterInfo("Binding", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo bindingbindnodeIdCommandParameterInfo =
+ new CommandParameterInfo("nodeId", long.class);
+ bindingbindCommandParams.put("nodeId", bindingbindnodeIdCommandParameterInfo);
+
+ CommandParameterInfo bindingbindgroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ bindingbindCommandParams.put("groupId", bindingbindgroupIdCommandParameterInfo);
+
+ CommandParameterInfo bindingbindendpointIdCommandParameterInfo =
+ new CommandParameterInfo("endpointId", int.class);
+ bindingbindCommandParams.put("endpointId", bindingbindendpointIdCommandParameterInfo);
+
+ CommandParameterInfo bindingbindclusterIdCommandParameterInfo =
+ new CommandParameterInfo("clusterId", long.class);
+ bindingbindCommandParams.put("clusterId", bindingbindclusterIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo bindingbindCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.BindingCluster) cluster)
+ .bind(
+ (DefaultClusterCallback) callback,
+ (Long) commandArguments.get("nodeId"),
+ (Integer) commandArguments.get("groupId"),
+ (Integer) commandArguments.get("endpointId"),
+ (Long) commandArguments.get("clusterId"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ bindingbindCommandParams);
+ bindingClusterCommandInfoMap.put("bind", bindingbindCommandInfo);
+ Map<String, CommandParameterInfo> bindingunbindCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo bindingunbindCommandParameterInfo =
+ new CommandParameterInfo("Binding", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo bindingunbindnodeIdCommandParameterInfo =
+ new CommandParameterInfo("nodeId", long.class);
+ bindingunbindCommandParams.put("nodeId", bindingunbindnodeIdCommandParameterInfo);
+
+ CommandParameterInfo bindingunbindgroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ bindingunbindCommandParams.put("groupId", bindingunbindgroupIdCommandParameterInfo);
+
+ CommandParameterInfo bindingunbindendpointIdCommandParameterInfo =
+ new CommandParameterInfo("endpointId", int.class);
+ bindingunbindCommandParams.put("endpointId", bindingunbindendpointIdCommandParameterInfo);
+
+ CommandParameterInfo bindingunbindclusterIdCommandParameterInfo =
+ new CommandParameterInfo("clusterId", long.class);
+ bindingunbindCommandParams.put("clusterId", bindingunbindclusterIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo bindingunbindCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.BindingCluster) cluster)
+ .unbind(
+ (DefaultClusterCallback) callback,
+ (Long) commandArguments.get("nodeId"),
+ (Integer) commandArguments.get("groupId"),
+ (Integer) commandArguments.get("endpointId"),
+ (Long) commandArguments.get("clusterId"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ bindingunbindCommandParams);
+ bindingClusterCommandInfoMap.put("unbind", bindingunbindCommandInfo);
+ // Populate cluster
+ ClusterInfo bindingClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId),
+ bindingClusterCommandInfoMap);
+ clusterMap.put("binding", bindingClusterInfo);
+ Map<String, CommandInfo> booleanStateClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo booleanStateClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId),
+ booleanStateClusterCommandInfoMap);
+ clusterMap.put("booleanState", booleanStateClusterInfo);
+ Map<String, CommandInfo> bridgedDeviceBasicClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo bridgedDeviceBasicClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId),
+ bridgedDeviceBasicClusterCommandInfoMap);
+ clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo);
+ Map<String, CommandInfo> colorControlClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> colorControlcolorLoopSetCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlcolorLoopSetCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo =
+ new CommandParameterInfo("updateFlags", int.class);
+ colorControlcolorLoopSetCommandParams.put(
+ "updateFlags", colorControlcolorLoopSetupdateFlagsCommandParameterInfo);
+
+ CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo =
+ new CommandParameterInfo("action", int.class);
+ colorControlcolorLoopSetCommandParams.put(
+ "action", colorControlcolorLoopSetactionCommandParameterInfo);
+
+ CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo =
+ new CommandParameterInfo("direction", int.class);
+ colorControlcolorLoopSetCommandParams.put(
+ "direction", colorControlcolorLoopSetdirectionCommandParameterInfo);
+
+ CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo =
+ new CommandParameterInfo("time", int.class);
+ colorControlcolorLoopSetCommandParams.put(
+ "time", colorControlcolorLoopSettimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo =
+ new CommandParameterInfo("startHue", int.class);
+ colorControlcolorLoopSetCommandParams.put(
+ "startHue", colorControlcolorLoopSetstartHueCommandParameterInfo);
+
+ CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlcolorLoopSetCommandParams.put(
+ "optionsMask", colorControlcolorLoopSetoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlcolorLoopSetCommandParams.put(
+ "optionsOverride", colorControlcolorLoopSetoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlcolorLoopSetCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .colorLoopSet(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("updateFlags"),
+ (Integer) commandArguments.get("action"),
+ (Integer) commandArguments.get("direction"),
+ (Integer) commandArguments.get("time"),
+ (Integer) commandArguments.get("startHue"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlcolorLoopSetCommandParams);
+ colorControlClusterCommandInfoMap.put("colorLoopSet", colorControlcolorLoopSetCommandInfo);
+ Map<String, CommandParameterInfo> colorControlenhancedMoveHueCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlenhancedMoveHueCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo =
+ new CommandParameterInfo("moveMode", int.class);
+ colorControlenhancedMoveHueCommandParams.put(
+ "moveMode", colorControlenhancedMoveHuemoveModeCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo =
+ new CommandParameterInfo("rate", int.class);
+ colorControlenhancedMoveHueCommandParams.put(
+ "rate", colorControlenhancedMoveHuerateCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlenhancedMoveHueCommandParams.put(
+ "optionsMask", colorControlenhancedMoveHueoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlenhancedMoveHueCommandParams.put(
+ "optionsOverride", colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlenhancedMoveHueCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .enhancedMoveHue(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("moveMode"),
+ (Integer) commandArguments.get("rate"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlenhancedMoveHueCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "enhancedMoveHue", colorControlenhancedMoveHueCommandInfo);
+ Map<String, CommandParameterInfo> colorControlenhancedMoveToHueCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlenhancedMoveToHueCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo =
+ new CommandParameterInfo("enhancedHue", int.class);
+ colorControlenhancedMoveToHueCommandParams.put(
+ "enhancedHue", colorControlenhancedMoveToHueenhancedHueCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo =
+ new CommandParameterInfo("direction", int.class);
+ colorControlenhancedMoveToHueCommandParams.put(
+ "direction", colorControlenhancedMoveToHuedirectionCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlenhancedMoveToHueCommandParams.put(
+ "transitionTime", colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlenhancedMoveToHueCommandParams.put(
+ "optionsMask", colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlenhancedMoveToHueCommandParams.put(
+ "optionsOverride", colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlenhancedMoveToHueCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .enhancedMoveToHue(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("enhancedHue"),
+ (Integer) commandArguments.get("direction"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlenhancedMoveToHueCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "enhancedMoveToHue", colorControlenhancedMoveToHueCommandInfo);
+ Map<String, CommandParameterInfo> colorControlenhancedMoveToHueAndSaturationCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlenhancedMoveToHueAndSaturationCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo =
+ new CommandParameterInfo("enhancedHue", int.class);
+ colorControlenhancedMoveToHueAndSaturationCommandParams.put(
+ "enhancedHue", colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo =
+ new CommandParameterInfo("saturation", int.class);
+ colorControlenhancedMoveToHueAndSaturationCommandParams.put(
+ "saturation", colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo);
+
+ CommandParameterInfo
+ colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlenhancedMoveToHueAndSaturationCommandParams.put(
+ "transitionTime",
+ colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlenhancedMoveToHueAndSaturationCommandParams.put(
+ "optionsMask", colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo
+ colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlenhancedMoveToHueAndSaturationCommandParams.put(
+ "optionsOverride",
+ colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlenhancedMoveToHueAndSaturationCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .enhancedMoveToHueAndSaturation(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("enhancedHue"),
+ (Integer) commandArguments.get("saturation"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlenhancedMoveToHueAndSaturationCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "enhancedMoveToHueAndSaturation", colorControlenhancedMoveToHueAndSaturationCommandInfo);
+ Map<String, CommandParameterInfo> colorControlenhancedStepHueCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlenhancedStepHueCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo =
+ new CommandParameterInfo("stepMode", int.class);
+ colorControlenhancedStepHueCommandParams.put(
+ "stepMode", colorControlenhancedStepHuestepModeCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo =
+ new CommandParameterInfo("stepSize", int.class);
+ colorControlenhancedStepHueCommandParams.put(
+ "stepSize", colorControlenhancedStepHuestepSizeCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlenhancedStepHueCommandParams.put(
+ "transitionTime", colorControlenhancedStepHuetransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlenhancedStepHueCommandParams.put(
+ "optionsMask", colorControlenhancedStepHueoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlenhancedStepHueCommandParams.put(
+ "optionsOverride", colorControlenhancedStepHueoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlenhancedStepHueCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .enhancedStepHue(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("stepMode"),
+ (Integer) commandArguments.get("stepSize"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlenhancedStepHueCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "enhancedStepHue", colorControlenhancedStepHueCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveColorCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveColorCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo =
+ new CommandParameterInfo("rateX", int.class);
+ colorControlmoveColorCommandParams.put("rateX", colorControlmoveColorrateXCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo =
+ new CommandParameterInfo("rateY", int.class);
+ colorControlmoveColorCommandParams.put("rateY", colorControlmoveColorrateYCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveColorCommandParams.put(
+ "optionsMask", colorControlmoveColoroptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveColorCommandParams.put(
+ "optionsOverride", colorControlmoveColoroptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveColorCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveColor(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("rateX"),
+ (Integer) commandArguments.get("rateY"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveColorCommandParams);
+ colorControlClusterCommandInfoMap.put("moveColor", colorControlmoveColorCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveColorTemperatureCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveColorTemperatureCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo =
+ new CommandParameterInfo("moveMode", int.class);
+ colorControlmoveColorTemperatureCommandParams.put(
+ "moveMode", colorControlmoveColorTemperaturemoveModeCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo =
+ new CommandParameterInfo("rate", int.class);
+ colorControlmoveColorTemperatureCommandParams.put(
+ "rate", colorControlmoveColorTemperaturerateCommandParameterInfo);
+
+ CommandParameterInfo
+ colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo =
+ new CommandParameterInfo("colorTemperatureMinimum", int.class);
+ colorControlmoveColorTemperatureCommandParams.put(
+ "colorTemperatureMinimum",
+ colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo);
+
+ CommandParameterInfo
+ colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo =
+ new CommandParameterInfo("colorTemperatureMaximum", int.class);
+ colorControlmoveColorTemperatureCommandParams.put(
+ "colorTemperatureMaximum",
+ colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveColorTemperatureCommandParams.put(
+ "optionsMask", colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveColorTemperatureCommandParams.put(
+ "optionsOverride", colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveColorTemperatureCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveColorTemperature(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("moveMode"),
+ (Integer) commandArguments.get("rate"),
+ (Integer) commandArguments.get("colorTemperatureMinimum"),
+ (Integer) commandArguments.get("colorTemperatureMaximum"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveColorTemperatureCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "moveColorTemperature", colorControlmoveColorTemperatureCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveHueCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveHueCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo =
+ new CommandParameterInfo("moveMode", int.class);
+ colorControlmoveHueCommandParams.put(
+ "moveMode", colorControlmoveHuemoveModeCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveHuerateCommandParameterInfo =
+ new CommandParameterInfo("rate", int.class);
+ colorControlmoveHueCommandParams.put("rate", colorControlmoveHuerateCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveHueCommandParams.put(
+ "optionsMask", colorControlmoveHueoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveHueCommandParams.put(
+ "optionsOverride", colorControlmoveHueoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveHueCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveHue(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("moveMode"),
+ (Integer) commandArguments.get("rate"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveHueCommandParams);
+ colorControlClusterCommandInfoMap.put("moveHue", colorControlmoveHueCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveSaturationCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveSaturationCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo =
+ new CommandParameterInfo("moveMode", int.class);
+ colorControlmoveSaturationCommandParams.put(
+ "moveMode", colorControlmoveSaturationmoveModeCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo =
+ new CommandParameterInfo("rate", int.class);
+ colorControlmoveSaturationCommandParams.put(
+ "rate", colorControlmoveSaturationrateCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveSaturationCommandParams.put(
+ "optionsMask", colorControlmoveSaturationoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveSaturationCommandParams.put(
+ "optionsOverride", colorControlmoveSaturationoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveSaturationCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveSaturation(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("moveMode"),
+ (Integer) commandArguments.get("rate"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveSaturationCommandParams);
+ colorControlClusterCommandInfoMap.put("moveSaturation", colorControlmoveSaturationCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveToColorCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveToColorCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo =
+ new CommandParameterInfo("colorX", int.class);
+ colorControlmoveToColorCommandParams.put(
+ "colorX", colorControlmoveToColorcolorXCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo =
+ new CommandParameterInfo("colorY", int.class);
+ colorControlmoveToColorCommandParams.put(
+ "colorY", colorControlmoveToColorcolorYCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlmoveToColorCommandParams.put(
+ "transitionTime", colorControlmoveToColortransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveToColorCommandParams.put(
+ "optionsMask", colorControlmoveToColoroptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveToColorCommandParams.put(
+ "optionsOverride", colorControlmoveToColoroptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveToColorCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveToColor(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("colorX"),
+ (Integer) commandArguments.get("colorY"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveToColorCommandParams);
+ colorControlClusterCommandInfoMap.put("moveToColor", colorControlmoveToColorCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveToColorTemperatureCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveToColorTemperatureCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo =
+ new CommandParameterInfo("colorTemperature", int.class);
+ colorControlmoveToColorTemperatureCommandParams.put(
+ "colorTemperature", colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlmoveToColorTemperatureCommandParams.put(
+ "transitionTime", colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveToColorTemperatureCommandParams.put(
+ "optionsMask", colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveToColorTemperatureCommandParams.put(
+ "optionsOverride", colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveToColorTemperatureCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveToColorTemperature(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("colorTemperature"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveToColorTemperatureCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "moveToColorTemperature", colorControlmoveToColorTemperatureCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveToHueCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveToHueCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo =
+ new CommandParameterInfo("hue", int.class);
+ colorControlmoveToHueCommandParams.put("hue", colorControlmoveToHuehueCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo =
+ new CommandParameterInfo("direction", int.class);
+ colorControlmoveToHueCommandParams.put(
+ "direction", colorControlmoveToHuedirectionCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlmoveToHueCommandParams.put(
+ "transitionTime", colorControlmoveToHuetransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveToHueCommandParams.put(
+ "optionsMask", colorControlmoveToHueoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveToHueCommandParams.put(
+ "optionsOverride", colorControlmoveToHueoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveToHueCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveToHue(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("hue"),
+ (Integer) commandArguments.get("direction"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveToHueCommandParams);
+ colorControlClusterCommandInfoMap.put("moveToHue", colorControlmoveToHueCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveToHueAndSaturationCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveToHueAndSaturationCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo =
+ new CommandParameterInfo("hue", int.class);
+ colorControlmoveToHueAndSaturationCommandParams.put(
+ "hue", colorControlmoveToHueAndSaturationhueCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo =
+ new CommandParameterInfo("saturation", int.class);
+ colorControlmoveToHueAndSaturationCommandParams.put(
+ "saturation", colorControlmoveToHueAndSaturationsaturationCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlmoveToHueAndSaturationCommandParams.put(
+ "transitionTime", colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveToHueAndSaturationCommandParams.put(
+ "optionsMask", colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveToHueAndSaturationCommandParams.put(
+ "optionsOverride", colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveToHueAndSaturationCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveToHueAndSaturation(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("hue"),
+ (Integer) commandArguments.get("saturation"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveToHueAndSaturationCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "moveToHueAndSaturation", colorControlmoveToHueAndSaturationCommandInfo);
+ Map<String, CommandParameterInfo> colorControlmoveToSaturationCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlmoveToSaturationCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo =
+ new CommandParameterInfo("saturation", int.class);
+ colorControlmoveToSaturationCommandParams.put(
+ "saturation", colorControlmoveToSaturationsaturationCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlmoveToSaturationCommandParams.put(
+ "transitionTime", colorControlmoveToSaturationtransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlmoveToSaturationCommandParams.put(
+ "optionsMask", colorControlmoveToSaturationoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlmoveToSaturationCommandParams.put(
+ "optionsOverride", colorControlmoveToSaturationoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlmoveToSaturationCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .moveToSaturation(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("saturation"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlmoveToSaturationCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "moveToSaturation", colorControlmoveToSaturationCommandInfo);
+ Map<String, CommandParameterInfo> colorControlstepColorCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlstepColorCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlstepColorstepXCommandParameterInfo =
+ new CommandParameterInfo("stepX", int.class);
+ colorControlstepColorCommandParams.put("stepX", colorControlstepColorstepXCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepColorstepYCommandParameterInfo =
+ new CommandParameterInfo("stepY", int.class);
+ colorControlstepColorCommandParams.put("stepY", colorControlstepColorstepYCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlstepColorCommandParams.put(
+ "transitionTime", colorControlstepColortransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlstepColorCommandParams.put(
+ "optionsMask", colorControlstepColoroptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlstepColorCommandParams.put(
+ "optionsOverride", colorControlstepColoroptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlstepColorCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .stepColor(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("stepX"),
+ (Integer) commandArguments.get("stepY"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlstepColorCommandParams);
+ colorControlClusterCommandInfoMap.put("stepColor", colorControlstepColorCommandInfo);
+ Map<String, CommandParameterInfo> colorControlstepColorTemperatureCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlstepColorTemperatureCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo =
+ new CommandParameterInfo("stepMode", int.class);
+ colorControlstepColorTemperatureCommandParams.put(
+ "stepMode", colorControlstepColorTemperaturestepModeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo =
+ new CommandParameterInfo("stepSize", int.class);
+ colorControlstepColorTemperatureCommandParams.put(
+ "stepSize", colorControlstepColorTemperaturestepSizeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlstepColorTemperatureCommandParams.put(
+ "transitionTime", colorControlstepColorTemperaturetransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo
+ colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo =
+ new CommandParameterInfo("colorTemperatureMinimum", int.class);
+ colorControlstepColorTemperatureCommandParams.put(
+ "colorTemperatureMinimum",
+ colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo);
+
+ CommandParameterInfo
+ colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo =
+ new CommandParameterInfo("colorTemperatureMaximum", int.class);
+ colorControlstepColorTemperatureCommandParams.put(
+ "colorTemperatureMaximum",
+ colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlstepColorTemperatureCommandParams.put(
+ "optionsMask", colorControlstepColorTemperatureoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlstepColorTemperatureCommandParams.put(
+ "optionsOverride", colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlstepColorTemperatureCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .stepColorTemperature(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("stepMode"),
+ (Integer) commandArguments.get("stepSize"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("colorTemperatureMinimum"),
+ (Integer) commandArguments.get("colorTemperatureMaximum"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlstepColorTemperatureCommandParams);
+ colorControlClusterCommandInfoMap.put(
+ "stepColorTemperature", colorControlstepColorTemperatureCommandInfo);
+ Map<String, CommandParameterInfo> colorControlstepHueCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlstepHueCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo =
+ new CommandParameterInfo("stepMode", int.class);
+ colorControlstepHueCommandParams.put(
+ "stepMode", colorControlstepHuestepModeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo =
+ new CommandParameterInfo("stepSize", int.class);
+ colorControlstepHueCommandParams.put(
+ "stepSize", colorControlstepHuestepSizeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlstepHueCommandParams.put(
+ "transitionTime", colorControlstepHuetransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlstepHueCommandParams.put(
+ "optionsMask", colorControlstepHueoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlstepHueCommandParams.put(
+ "optionsOverride", colorControlstepHueoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlstepHueCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .stepHue(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("stepMode"),
+ (Integer) commandArguments.get("stepSize"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlstepHueCommandParams);
+ colorControlClusterCommandInfoMap.put("stepHue", colorControlstepHueCommandInfo);
+ Map<String, CommandParameterInfo> colorControlstepSaturationCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlstepSaturationCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo =
+ new CommandParameterInfo("stepMode", int.class);
+ colorControlstepSaturationCommandParams.put(
+ "stepMode", colorControlstepSaturationstepModeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo =
+ new CommandParameterInfo("stepSize", int.class);
+ colorControlstepSaturationCommandParams.put(
+ "stepSize", colorControlstepSaturationstepSizeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ colorControlstepSaturationCommandParams.put(
+ "transitionTime", colorControlstepSaturationtransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlstepSaturationCommandParams.put(
+ "optionsMask", colorControlstepSaturationoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlstepSaturationCommandParams.put(
+ "optionsOverride", colorControlstepSaturationoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlstepSaturationCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .stepSaturation(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("stepMode"),
+ (Integer) commandArguments.get("stepSize"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlstepSaturationCommandParams);
+ colorControlClusterCommandInfoMap.put("stepSaturation", colorControlstepSaturationCommandInfo);
+ Map<String, CommandParameterInfo> colorControlstopMoveStepCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo colorControlstopMoveStepCommandParameterInfo =
+ new CommandParameterInfo("ColorControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo =
+ new CommandParameterInfo("optionsMask", int.class);
+ colorControlstopMoveStepCommandParams.put(
+ "optionsMask", colorControlstopMoveStepoptionsMaskCommandParameterInfo);
+
+ CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionsOverride", int.class);
+ colorControlstopMoveStepCommandParams.put(
+ "optionsOverride", colorControlstopMoveStepoptionsOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo colorControlstopMoveStepCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ColorControlCluster) cluster)
+ .stopMoveStep(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("optionsMask"),
+ (Integer) commandArguments.get("optionsOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ colorControlstopMoveStepCommandParams);
+ colorControlClusterCommandInfoMap.put("stopMoveStep", colorControlstopMoveStepCommandInfo);
+ // Populate cluster
+ ClusterInfo colorControlClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId),
+ colorControlClusterCommandInfoMap);
+ clusterMap.put("colorControl", colorControlClusterInfo);
+ Map<String, CommandInfo> contentLauncherClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> contentLauncherlaunchContentCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo contentLauncherlaunchContentCommandParameterInfo =
+ new CommandParameterInfo(
+ "ContentLauncher",
+ ChipClusters.ContentLauncherCluster.LaunchContentResponseCallback.class);
+ CommandParameterInfo contentLauncherlaunchContentautoPlayCommandParameterInfo =
+ new CommandParameterInfo("autoPlay", boolean.class);
+ contentLauncherlaunchContentCommandParams.put(
+ "autoPlay", contentLauncherlaunchContentautoPlayCommandParameterInfo);
+
+ CommandParameterInfo contentLauncherlaunchContentdataCommandParameterInfo =
+ new CommandParameterInfo("data", String.class);
+ contentLauncherlaunchContentCommandParams.put(
+ "data", contentLauncherlaunchContentdataCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo contentLauncherlaunchContentCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ContentLauncherCluster) cluster)
+ .launchContent(
+ (ChipClusters.ContentLauncherCluster.LaunchContentResponseCallback) callback,
+ (Boolean) commandArguments.get("autoPlay"),
+ (String) commandArguments.get("data"));
+ },
+ () -> new DelegatedLaunchContentResponseCallback(),
+ contentLauncherlaunchContentCommandParams);
+ contentLauncherClusterCommandInfoMap.put(
+ "launchContent", contentLauncherlaunchContentCommandInfo);
+ Map<String, CommandParameterInfo> contentLauncherlaunchURLCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo contentLauncherlaunchURLCommandParameterInfo =
+ new CommandParameterInfo(
+ "ContentLauncher", ChipClusters.ContentLauncherCluster.LaunchURLResponseCallback.class);
+ CommandParameterInfo contentLauncherlaunchURLcontentURLCommandParameterInfo =
+ new CommandParameterInfo("contentURL", String.class);
+ contentLauncherlaunchURLCommandParams.put(
+ "contentURL", contentLauncherlaunchURLcontentURLCommandParameterInfo);
+
+ CommandParameterInfo contentLauncherlaunchURLdisplayStringCommandParameterInfo =
+ new CommandParameterInfo("displayString", String.class);
+ contentLauncherlaunchURLCommandParams.put(
+ "displayString", contentLauncherlaunchURLdisplayStringCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo contentLauncherlaunchURLCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ContentLauncherCluster) cluster)
+ .launchURL(
+ (ChipClusters.ContentLauncherCluster.LaunchURLResponseCallback) callback,
+ (String) commandArguments.get("contentURL"),
+ (String) commandArguments.get("displayString"));
+ },
+ () -> new DelegatedLaunchURLResponseCallback(),
+ contentLauncherlaunchURLCommandParams);
+ contentLauncherClusterCommandInfoMap.put("launchURL", contentLauncherlaunchURLCommandInfo);
+ // Populate cluster
+ ClusterInfo contentLauncherClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId),
+ contentLauncherClusterCommandInfoMap);
+ clusterMap.put("contentLauncher", contentLauncherClusterInfo);
+ Map<String, CommandInfo> descriptorClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo descriptorClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId),
+ descriptorClusterCommandInfoMap);
+ clusterMap.put("descriptor", descriptorClusterInfo);
+ Map<String, CommandInfo> diagnosticLogsClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> diagnosticLogsretrieveLogsRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo diagnosticLogsretrieveLogsRequestCommandParameterInfo =
+ new CommandParameterInfo(
+ "DiagnosticLogs",
+ ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback.class);
+ CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo =
+ new CommandParameterInfo("intent", int.class);
+ diagnosticLogsretrieveLogsRequestCommandParams.put(
+ "intent", diagnosticLogsretrieveLogsRequestintentCommandParameterInfo);
+
+ CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo =
+ new CommandParameterInfo("requestedProtocol", int.class);
+ diagnosticLogsretrieveLogsRequestCommandParams.put(
+ "requestedProtocol",
+ diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo);
+
+ CommandParameterInfo
+ diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo =
+ new CommandParameterInfo("transferFileDesignator", byte[].class);
+ diagnosticLogsretrieveLogsRequestCommandParams.put(
+ "transferFileDesignator",
+ diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo diagnosticLogsretrieveLogsRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DiagnosticLogsCluster) cluster)
+ .retrieveLogsRequest(
+ (ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback,
+ (Integer) commandArguments.get("intent"),
+ (Integer) commandArguments.get("requestedProtocol"),
+ (byte[]) commandArguments.get("transferFileDesignator"));
+ },
+ () -> new DelegatedRetrieveLogsResponseCallback(),
+ diagnosticLogsretrieveLogsRequestCommandParams);
+ diagnosticLogsClusterCommandInfoMap.put(
+ "retrieveLogsRequest", diagnosticLogsretrieveLogsRequestCommandInfo);
+ // Populate cluster
+ ClusterInfo diagnosticLogsClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId),
+ diagnosticLogsClusterCommandInfoMap);
+ clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo);
+ Map<String, CommandInfo> doorLockClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> doorLockclearAllPinsCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockclearAllPinsCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.ClearAllPinsResponseCallback.class);
+ // Populate commands
+ CommandInfo doorLockclearAllPinsCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .clearAllPins(
+ (ChipClusters.DoorLockCluster.ClearAllPinsResponseCallback) callback);
+ },
+ () -> new DelegatedClearAllPinsResponseCallback(),
+ doorLockclearAllPinsCommandParams);
+ doorLockClusterCommandInfoMap.put("clearAllPins", doorLockclearAllPinsCommandInfo);
+ Map<String, CommandParameterInfo> doorLockclearAllRfidsCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockclearAllRfidsCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.ClearAllRfidsResponseCallback.class);
+ // Populate commands
+ CommandInfo doorLockclearAllRfidsCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .clearAllRfids(
+ (ChipClusters.DoorLockCluster.ClearAllRfidsResponseCallback) callback);
+ },
+ () -> new DelegatedClearAllRfidsResponseCallback(),
+ doorLockclearAllRfidsCommandParams);
+ doorLockClusterCommandInfoMap.put("clearAllRfids", doorLockclearAllRfidsCommandInfo);
+ Map<String, CommandParameterInfo> doorLockclearHolidayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockclearHolidayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.ClearHolidayScheduleResponseCallback.class);
+ CommandParameterInfo doorLockclearHolidaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLockclearHolidayScheduleCommandParams.put(
+ "scheduleId", doorLockclearHolidaySchedulescheduleIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockclearHolidayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .clearHolidaySchedule(
+ (ChipClusters.DoorLockCluster.ClearHolidayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"));
+ },
+ () -> new DelegatedClearHolidayScheduleResponseCallback(),
+ doorLockclearHolidayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put(
+ "clearHolidaySchedule", doorLockclearHolidayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLockclearPinCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockclearPinCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.ClearPinResponseCallback.class);
+ CommandParameterInfo doorLockclearPinuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockclearPinCommandParams.put("userId", doorLockclearPinuserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockclearPinCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .clearPin(
+ (ChipClusters.DoorLockCluster.ClearPinResponseCallback) callback,
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedClearPinResponseCallback(),
+ doorLockclearPinCommandParams);
+ doorLockClusterCommandInfoMap.put("clearPin", doorLockclearPinCommandInfo);
+ Map<String, CommandParameterInfo> doorLockclearRfidCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockclearRfidCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.ClearRfidResponseCallback.class);
+ CommandParameterInfo doorLockclearRfiduserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockclearRfidCommandParams.put("userId", doorLockclearRfiduserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockclearRfidCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .clearRfid(
+ (ChipClusters.DoorLockCluster.ClearRfidResponseCallback) callback,
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedClearRfidResponseCallback(),
+ doorLockclearRfidCommandParams);
+ doorLockClusterCommandInfoMap.put("clearRfid", doorLockclearRfidCommandInfo);
+ Map<String, CommandParameterInfo> doorLockclearWeekdayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockclearWeekdayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.ClearWeekdayScheduleResponseCallback.class);
+ CommandParameterInfo doorLockclearWeekdaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLockclearWeekdayScheduleCommandParams.put(
+ "scheduleId", doorLockclearWeekdaySchedulescheduleIdCommandParameterInfo);
+
+ CommandParameterInfo doorLockclearWeekdayScheduleuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockclearWeekdayScheduleCommandParams.put(
+ "userId", doorLockclearWeekdayScheduleuserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockclearWeekdayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .clearWeekdaySchedule(
+ (ChipClusters.DoorLockCluster.ClearWeekdayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"),
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedClearWeekdayScheduleResponseCallback(),
+ doorLockclearWeekdayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put(
+ "clearWeekdaySchedule", doorLockclearWeekdayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLockclearYeardayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockclearYeardayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.ClearYeardayScheduleResponseCallback.class);
+ CommandParameterInfo doorLockclearYeardaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLockclearYeardayScheduleCommandParams.put(
+ "scheduleId", doorLockclearYeardaySchedulescheduleIdCommandParameterInfo);
+
+ CommandParameterInfo doorLockclearYeardayScheduleuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockclearYeardayScheduleCommandParams.put(
+ "userId", doorLockclearYeardayScheduleuserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockclearYeardayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .clearYeardaySchedule(
+ (ChipClusters.DoorLockCluster.ClearYeardayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"),
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedClearYeardayScheduleResponseCallback(),
+ doorLockclearYeardayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put(
+ "clearYeardaySchedule", doorLockclearYeardayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLockgetHolidayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockgetHolidayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.GetHolidayScheduleResponseCallback.class);
+ CommandParameterInfo doorLockgetHolidaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLockgetHolidayScheduleCommandParams.put(
+ "scheduleId", doorLockgetHolidaySchedulescheduleIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockgetHolidayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .getHolidaySchedule(
+ (ChipClusters.DoorLockCluster.GetHolidayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"));
+ },
+ () -> new DelegatedGetHolidayScheduleResponseCallback(),
+ doorLockgetHolidayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put("getHolidaySchedule", doorLockgetHolidayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLockgetLogRecordCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockgetLogRecordCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.GetLogRecordResponseCallback.class);
+ CommandParameterInfo doorLockgetLogRecordlogIndexCommandParameterInfo =
+ new CommandParameterInfo("logIndex", int.class);
+ doorLockgetLogRecordCommandParams.put(
+ "logIndex", doorLockgetLogRecordlogIndexCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockgetLogRecordCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .getLogRecord(
+ (ChipClusters.DoorLockCluster.GetLogRecordResponseCallback) callback,
+ (Integer) commandArguments.get("logIndex"));
+ },
+ () -> new DelegatedGetLogRecordResponseCallback(),
+ doorLockgetLogRecordCommandParams);
+ doorLockClusterCommandInfoMap.put("getLogRecord", doorLockgetLogRecordCommandInfo);
+ Map<String, CommandParameterInfo> doorLockgetPinCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockgetPinCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.GetPinResponseCallback.class);
+ CommandParameterInfo doorLockgetPinuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockgetPinCommandParams.put("userId", doorLockgetPinuserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockgetPinCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .getPin(
+ (ChipClusters.DoorLockCluster.GetPinResponseCallback) callback,
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedGetPinResponseCallback(),
+ doorLockgetPinCommandParams);
+ doorLockClusterCommandInfoMap.put("getPin", doorLockgetPinCommandInfo);
+ Map<String, CommandParameterInfo> doorLockgetRfidCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockgetRfidCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.GetRfidResponseCallback.class);
+ CommandParameterInfo doorLockgetRfiduserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockgetRfidCommandParams.put("userId", doorLockgetRfiduserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockgetRfidCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .getRfid(
+ (ChipClusters.DoorLockCluster.GetRfidResponseCallback) callback,
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedGetRfidResponseCallback(),
+ doorLockgetRfidCommandParams);
+ doorLockClusterCommandInfoMap.put("getRfid", doorLockgetRfidCommandInfo);
+ Map<String, CommandParameterInfo> doorLockgetUserTypeCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockgetUserTypeCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.GetUserTypeResponseCallback.class);
+ CommandParameterInfo doorLockgetUserTypeuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockgetUserTypeCommandParams.put("userId", doorLockgetUserTypeuserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockgetUserTypeCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .getUserType(
+ (ChipClusters.DoorLockCluster.GetUserTypeResponseCallback) callback,
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedGetUserTypeResponseCallback(),
+ doorLockgetUserTypeCommandParams);
+ doorLockClusterCommandInfoMap.put("getUserType", doorLockgetUserTypeCommandInfo);
+ Map<String, CommandParameterInfo> doorLockgetWeekdayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockgetWeekdayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.GetWeekdayScheduleResponseCallback.class);
+ CommandParameterInfo doorLockgetWeekdaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLockgetWeekdayScheduleCommandParams.put(
+ "scheduleId", doorLockgetWeekdaySchedulescheduleIdCommandParameterInfo);
+
+ CommandParameterInfo doorLockgetWeekdayScheduleuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockgetWeekdayScheduleCommandParams.put(
+ "userId", doorLockgetWeekdayScheduleuserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockgetWeekdayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .getWeekdaySchedule(
+ (ChipClusters.DoorLockCluster.GetWeekdayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"),
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedGetWeekdayScheduleResponseCallback(),
+ doorLockgetWeekdayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put("getWeekdaySchedule", doorLockgetWeekdayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLockgetYeardayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockgetYeardayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.GetYeardayScheduleResponseCallback.class);
+ CommandParameterInfo doorLockgetYeardaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLockgetYeardayScheduleCommandParams.put(
+ "scheduleId", doorLockgetYeardaySchedulescheduleIdCommandParameterInfo);
+
+ CommandParameterInfo doorLockgetYeardayScheduleuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLockgetYeardayScheduleCommandParams.put(
+ "userId", doorLockgetYeardayScheduleuserIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockgetYeardayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .getYeardaySchedule(
+ (ChipClusters.DoorLockCluster.GetYeardayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"),
+ (Integer) commandArguments.get("userId"));
+ },
+ () -> new DelegatedGetYeardayScheduleResponseCallback(),
+ doorLockgetYeardayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put("getYeardaySchedule", doorLockgetYeardayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLocklockDoorCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLocklockDoorCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.LockDoorResponseCallback.class);
+ CommandParameterInfo doorLocklockDoorpinCommandParameterInfo =
+ new CommandParameterInfo("pin", byte[].class);
+ doorLocklockDoorCommandParams.put("pin", doorLocklockDoorpinCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLocklockDoorCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .lockDoor(
+ (ChipClusters.DoorLockCluster.LockDoorResponseCallback) callback,
+ (byte[]) commandArguments.get("pin"));
+ },
+ () -> new DelegatedLockDoorResponseCallback(),
+ doorLocklockDoorCommandParams);
+ doorLockClusterCommandInfoMap.put("lockDoor", doorLocklockDoorCommandInfo);
+ Map<String, CommandParameterInfo> doorLocksetHolidayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLocksetHolidayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.SetHolidayScheduleResponseCallback.class);
+ CommandParameterInfo doorLocksetHolidaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLocksetHolidayScheduleCommandParams.put(
+ "scheduleId", doorLocksetHolidaySchedulescheduleIdCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetHolidaySchedulelocalStartTimeCommandParameterInfo =
+ new CommandParameterInfo("localStartTime", long.class);
+ doorLocksetHolidayScheduleCommandParams.put(
+ "localStartTime", doorLocksetHolidaySchedulelocalStartTimeCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetHolidaySchedulelocalEndTimeCommandParameterInfo =
+ new CommandParameterInfo("localEndTime", long.class);
+ doorLocksetHolidayScheduleCommandParams.put(
+ "localEndTime", doorLocksetHolidaySchedulelocalEndTimeCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetHolidayScheduleoperatingModeDuringHolidayCommandParameterInfo =
+ new CommandParameterInfo("operatingModeDuringHoliday", int.class);
+ doorLocksetHolidayScheduleCommandParams.put(
+ "operatingModeDuringHoliday",
+ doorLocksetHolidayScheduleoperatingModeDuringHolidayCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLocksetHolidayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .setHolidaySchedule(
+ (ChipClusters.DoorLockCluster.SetHolidayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"),
+ (Long) commandArguments.get("localStartTime"),
+ (Long) commandArguments.get("localEndTime"),
+ (Integer) commandArguments.get("operatingModeDuringHoliday"));
+ },
+ () -> new DelegatedSetHolidayScheduleResponseCallback(),
+ doorLocksetHolidayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put("setHolidaySchedule", doorLocksetHolidayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLocksetPinCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLocksetPinCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.SetPinResponseCallback.class);
+ CommandParameterInfo doorLocksetPinuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLocksetPinCommandParams.put("userId", doorLocksetPinuserIdCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetPinuserStatusCommandParameterInfo =
+ new CommandParameterInfo("userStatus", int.class);
+ doorLocksetPinCommandParams.put("userStatus", doorLocksetPinuserStatusCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetPinuserTypeCommandParameterInfo =
+ new CommandParameterInfo("userType", int.class);
+ doorLocksetPinCommandParams.put("userType", doorLocksetPinuserTypeCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetPinpinCommandParameterInfo =
+ new CommandParameterInfo("pin", byte[].class);
+ doorLocksetPinCommandParams.put("pin", doorLocksetPinpinCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLocksetPinCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .setPin(
+ (ChipClusters.DoorLockCluster.SetPinResponseCallback) callback,
+ (Integer) commandArguments.get("userId"),
+ (Integer) commandArguments.get("userStatus"),
+ (Integer) commandArguments.get("userType"),
+ (byte[]) commandArguments.get("pin"));
+ },
+ () -> new DelegatedSetPinResponseCallback(),
+ doorLocksetPinCommandParams);
+ doorLockClusterCommandInfoMap.put("setPin", doorLocksetPinCommandInfo);
+ Map<String, CommandParameterInfo> doorLocksetRfidCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLocksetRfidCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.SetRfidResponseCallback.class);
+ CommandParameterInfo doorLocksetRfiduserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLocksetRfidCommandParams.put("userId", doorLocksetRfiduserIdCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetRfiduserStatusCommandParameterInfo =
+ new CommandParameterInfo("userStatus", int.class);
+ doorLocksetRfidCommandParams.put("userStatus", doorLocksetRfiduserStatusCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetRfiduserTypeCommandParameterInfo =
+ new CommandParameterInfo("userType", int.class);
+ doorLocksetRfidCommandParams.put("userType", doorLocksetRfiduserTypeCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetRfididCommandParameterInfo =
+ new CommandParameterInfo("id", byte[].class);
+ doorLocksetRfidCommandParams.put("id", doorLocksetRfididCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLocksetRfidCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .setRfid(
+ (ChipClusters.DoorLockCluster.SetRfidResponseCallback) callback,
+ (Integer) commandArguments.get("userId"),
+ (Integer) commandArguments.get("userStatus"),
+ (Integer) commandArguments.get("userType"),
+ (byte[]) commandArguments.get("id"));
+ },
+ () -> new DelegatedSetRfidResponseCallback(),
+ doorLocksetRfidCommandParams);
+ doorLockClusterCommandInfoMap.put("setRfid", doorLocksetRfidCommandInfo);
+ Map<String, CommandParameterInfo> doorLocksetUserTypeCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLocksetUserTypeCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.SetUserTypeResponseCallback.class);
+ CommandParameterInfo doorLocksetUserTypeuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLocksetUserTypeCommandParams.put("userId", doorLocksetUserTypeuserIdCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetUserTypeuserTypeCommandParameterInfo =
+ new CommandParameterInfo("userType", int.class);
+ doorLocksetUserTypeCommandParams.put(
+ "userType", doorLocksetUserTypeuserTypeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLocksetUserTypeCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .setUserType(
+ (ChipClusters.DoorLockCluster.SetUserTypeResponseCallback) callback,
+ (Integer) commandArguments.get("userId"),
+ (Integer) commandArguments.get("userType"));
+ },
+ () -> new DelegatedSetUserTypeResponseCallback(),
+ doorLocksetUserTypeCommandParams);
+ doorLockClusterCommandInfoMap.put("setUserType", doorLocksetUserTypeCommandInfo);
+ Map<String, CommandParameterInfo> doorLocksetWeekdayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLocksetWeekdayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.SetWeekdayScheduleResponseCallback.class);
+ CommandParameterInfo doorLocksetWeekdaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLocksetWeekdayScheduleCommandParams.put(
+ "scheduleId", doorLocksetWeekdaySchedulescheduleIdCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetWeekdayScheduleuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLocksetWeekdayScheduleCommandParams.put(
+ "userId", doorLocksetWeekdayScheduleuserIdCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetWeekdayScheduledaysMaskCommandParameterInfo =
+ new CommandParameterInfo("daysMask", int.class);
+ doorLocksetWeekdayScheduleCommandParams.put(
+ "daysMask", doorLocksetWeekdayScheduledaysMaskCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetWeekdaySchedulestartHourCommandParameterInfo =
+ new CommandParameterInfo("startHour", int.class);
+ doorLocksetWeekdayScheduleCommandParams.put(
+ "startHour", doorLocksetWeekdaySchedulestartHourCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetWeekdaySchedulestartMinuteCommandParameterInfo =
+ new CommandParameterInfo("startMinute", int.class);
+ doorLocksetWeekdayScheduleCommandParams.put(
+ "startMinute", doorLocksetWeekdaySchedulestartMinuteCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetWeekdayScheduleendHourCommandParameterInfo =
+ new CommandParameterInfo("endHour", int.class);
+ doorLocksetWeekdayScheduleCommandParams.put(
+ "endHour", doorLocksetWeekdayScheduleendHourCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetWeekdayScheduleendMinuteCommandParameterInfo =
+ new CommandParameterInfo("endMinute", int.class);
+ doorLocksetWeekdayScheduleCommandParams.put(
+ "endMinute", doorLocksetWeekdayScheduleendMinuteCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLocksetWeekdayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .setWeekdaySchedule(
+ (ChipClusters.DoorLockCluster.SetWeekdayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"),
+ (Integer) commandArguments.get("userId"),
+ (Integer) commandArguments.get("daysMask"),
+ (Integer) commandArguments.get("startHour"),
+ (Integer) commandArguments.get("startMinute"),
+ (Integer) commandArguments.get("endHour"),
+ (Integer) commandArguments.get("endMinute"));
+ },
+ () -> new DelegatedSetWeekdayScheduleResponseCallback(),
+ doorLocksetWeekdayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put("setWeekdaySchedule", doorLocksetWeekdayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLocksetYeardayScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLocksetYeardayScheduleCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.SetYeardayScheduleResponseCallback.class);
+ CommandParameterInfo doorLocksetYeardaySchedulescheduleIdCommandParameterInfo =
+ new CommandParameterInfo("scheduleId", int.class);
+ doorLocksetYeardayScheduleCommandParams.put(
+ "scheduleId", doorLocksetYeardaySchedulescheduleIdCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetYeardayScheduleuserIdCommandParameterInfo =
+ new CommandParameterInfo("userId", int.class);
+ doorLocksetYeardayScheduleCommandParams.put(
+ "userId", doorLocksetYeardayScheduleuserIdCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetYeardaySchedulelocalStartTimeCommandParameterInfo =
+ new CommandParameterInfo("localStartTime", long.class);
+ doorLocksetYeardayScheduleCommandParams.put(
+ "localStartTime", doorLocksetYeardaySchedulelocalStartTimeCommandParameterInfo);
+
+ CommandParameterInfo doorLocksetYeardaySchedulelocalEndTimeCommandParameterInfo =
+ new CommandParameterInfo("localEndTime", long.class);
+ doorLocksetYeardayScheduleCommandParams.put(
+ "localEndTime", doorLocksetYeardaySchedulelocalEndTimeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLocksetYeardayScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .setYeardaySchedule(
+ (ChipClusters.DoorLockCluster.SetYeardayScheduleResponseCallback) callback,
+ (Integer) commandArguments.get("scheduleId"),
+ (Integer) commandArguments.get("userId"),
+ (Long) commandArguments.get("localStartTime"),
+ (Long) commandArguments.get("localEndTime"));
+ },
+ () -> new DelegatedSetYeardayScheduleResponseCallback(),
+ doorLocksetYeardayScheduleCommandParams);
+ doorLockClusterCommandInfoMap.put("setYeardaySchedule", doorLocksetYeardayScheduleCommandInfo);
+ Map<String, CommandParameterInfo> doorLockunlockDoorCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockunlockDoorCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.UnlockDoorResponseCallback.class);
+ CommandParameterInfo doorLockunlockDoorpinCommandParameterInfo =
+ new CommandParameterInfo("pin", byte[].class);
+ doorLockunlockDoorCommandParams.put("pin", doorLockunlockDoorpinCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockunlockDoorCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .unlockDoor(
+ (ChipClusters.DoorLockCluster.UnlockDoorResponseCallback) callback,
+ (byte[]) commandArguments.get("pin"));
+ },
+ () -> new DelegatedUnlockDoorResponseCallback(),
+ doorLockunlockDoorCommandParams);
+ doorLockClusterCommandInfoMap.put("unlockDoor", doorLockunlockDoorCommandInfo);
+ Map<String, CommandParameterInfo> doorLockunlockWithTimeoutCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo doorLockunlockWithTimeoutCommandParameterInfo =
+ new CommandParameterInfo(
+ "DoorLock", ChipClusters.DoorLockCluster.UnlockWithTimeoutResponseCallback.class);
+ CommandParameterInfo doorLockunlockWithTimeouttimeoutInSecondsCommandParameterInfo =
+ new CommandParameterInfo("timeoutInSeconds", int.class);
+ doorLockunlockWithTimeoutCommandParams.put(
+ "timeoutInSeconds", doorLockunlockWithTimeouttimeoutInSecondsCommandParameterInfo);
+
+ CommandParameterInfo doorLockunlockWithTimeoutpinCommandParameterInfo =
+ new CommandParameterInfo("pin", byte[].class);
+ doorLockunlockWithTimeoutCommandParams.put(
+ "pin", doorLockunlockWithTimeoutpinCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo doorLockunlockWithTimeoutCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.DoorLockCluster) cluster)
+ .unlockWithTimeout(
+ (ChipClusters.DoorLockCluster.UnlockWithTimeoutResponseCallback) callback,
+ (Integer) commandArguments.get("timeoutInSeconds"),
+ (byte[]) commandArguments.get("pin"));
+ },
+ () -> new DelegatedUnlockWithTimeoutResponseCallback(),
+ doorLockunlockWithTimeoutCommandParams);
+ doorLockClusterCommandInfoMap.put("unlockWithTimeout", doorLockunlockWithTimeoutCommandInfo);
+ // Populate cluster
+ ClusterInfo doorLockClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId),
+ doorLockClusterCommandInfoMap);
+ clusterMap.put("doorLock", doorLockClusterInfo);
+ Map<String, CommandInfo> electricalMeasurementClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo electricalMeasurementClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId),
+ electricalMeasurementClusterCommandInfoMap);
+ clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo);
+ Map<String, CommandInfo> ethernetNetworkDiagnosticsClusterCommandInfoMap =
+ new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> ethernetNetworkDiagnosticsresetCountsCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo ethernetNetworkDiagnosticsresetCountsCommandParameterInfo =
+ new CommandParameterInfo(
+ "EthernetNetworkDiagnostics", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo ethernetNetworkDiagnosticsresetCountsCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster)
+ .resetCounts((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ ethernetNetworkDiagnosticsresetCountsCommandParams);
+ ethernetNetworkDiagnosticsClusterCommandInfoMap.put(
+ "resetCounts", ethernetNetworkDiagnosticsresetCountsCommandInfo);
+ // Populate cluster
+ ClusterInfo ethernetNetworkDiagnosticsClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) ->
+ new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId),
+ ethernetNetworkDiagnosticsClusterCommandInfoMap);
+ clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo);
+ Map<String, CommandInfo> fixedLabelClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo fixedLabelClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId),
+ fixedLabelClusterCommandInfoMap);
+ clusterMap.put("fixedLabel", fixedLabelClusterInfo);
+ Map<String, CommandInfo> flowMeasurementClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo flowMeasurementClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId),
+ flowMeasurementClusterCommandInfoMap);
+ clusterMap.put("flowMeasurement", flowMeasurementClusterInfo);
+ Map<String, CommandInfo> generalCommissioningClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> generalCommissioningarmFailSafeCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo generalCommissioningarmFailSafeCommandParameterInfo =
+ new CommandParameterInfo(
+ "GeneralCommissioning",
+ ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback.class);
+ CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo =
+ new CommandParameterInfo("expiryLengthSeconds", int.class);
+ generalCommissioningarmFailSafeCommandParams.put(
+ "expiryLengthSeconds",
+ generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo);
+
+ CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ generalCommissioningarmFailSafeCommandParams.put(
+ "breadcrumb", generalCommissioningarmFailSafebreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ generalCommissioningarmFailSafeCommandParams.put(
+ "timeoutMs", generalCommissioningarmFailSafetimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo generalCommissioningarmFailSafeCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GeneralCommissioningCluster) cluster)
+ .armFailSafe(
+ (ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback)
+ callback,
+ (Integer) commandArguments.get("expiryLengthSeconds"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedArmFailSafeResponseCallback(),
+ generalCommissioningarmFailSafeCommandParams);
+ generalCommissioningClusterCommandInfoMap.put(
+ "armFailSafe", generalCommissioningarmFailSafeCommandInfo);
+ Map<String, CommandParameterInfo> generalCommissioningcommissioningCompleteCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo generalCommissioningcommissioningCompleteCommandParameterInfo =
+ new CommandParameterInfo(
+ "GeneralCommissioning",
+ ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback.class);
+ // Populate commands
+ CommandInfo generalCommissioningcommissioningCompleteCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GeneralCommissioningCluster) cluster)
+ .commissioningComplete(
+ (ChipClusters.GeneralCommissioningCluster
+ .CommissioningCompleteResponseCallback)
+ callback);
+ },
+ () -> new DelegatedCommissioningCompleteResponseCallback(),
+ generalCommissioningcommissioningCompleteCommandParams);
+ generalCommissioningClusterCommandInfoMap.put(
+ "commissioningComplete", generalCommissioningcommissioningCompleteCommandInfo);
+ Map<String, CommandParameterInfo> generalCommissioningsetRegulatoryConfigCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo generalCommissioningsetRegulatoryConfigCommandParameterInfo =
+ new CommandParameterInfo(
+ "GeneralCommissioning",
+ ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback.class);
+ CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo =
+ new CommandParameterInfo("location", int.class);
+ generalCommissioningsetRegulatoryConfigCommandParams.put(
+ "location", generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo);
+
+ CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo =
+ new CommandParameterInfo("countryCode", String.class);
+ generalCommissioningsetRegulatoryConfigCommandParams.put(
+ "countryCode", generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo);
+
+ CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ generalCommissioningsetRegulatoryConfigCommandParams.put(
+ "breadcrumb", generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ generalCommissioningsetRegulatoryConfigCommandParams.put(
+ "timeoutMs", generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo generalCommissioningsetRegulatoryConfigCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GeneralCommissioningCluster) cluster)
+ .setRegulatoryConfig(
+ (ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback)
+ callback,
+ (Integer) commandArguments.get("location"),
+ (String) commandArguments.get("countryCode"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedSetRegulatoryConfigResponseCallback(),
+ generalCommissioningsetRegulatoryConfigCommandParams);
+ generalCommissioningClusterCommandInfoMap.put(
+ "setRegulatoryConfig", generalCommissioningsetRegulatoryConfigCommandInfo);
+ // Populate cluster
+ ClusterInfo generalCommissioningClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId),
+ generalCommissioningClusterCommandInfoMap);
+ clusterMap.put("generalCommissioning", generalCommissioningClusterInfo);
+ Map<String, CommandInfo> generalDiagnosticsClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo generalDiagnosticsClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId),
+ generalDiagnosticsClusterCommandInfoMap);
+ clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo);
+ Map<String, CommandInfo> groupKeyManagementClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo groupKeyManagementClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId),
+ groupKeyManagementClusterCommandInfoMap);
+ clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo);
+ Map<String, CommandInfo> groupsClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> groupsaddGroupCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo groupsaddGroupCommandParameterInfo =
+ new CommandParameterInfo(
+ "Groups", ChipClusters.GroupsCluster.AddGroupResponseCallback.class);
+ CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ groupsaddGroupCommandParams.put("groupId", groupsaddGroupgroupIdCommandParameterInfo);
+
+ CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo =
+ new CommandParameterInfo("groupName", String.class);
+ groupsaddGroupCommandParams.put("groupName", groupsaddGroupgroupNameCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo groupsaddGroupCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GroupsCluster) cluster)
+ .addGroup(
+ (ChipClusters.GroupsCluster.AddGroupResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"),
+ (String) commandArguments.get("groupName"));
+ },
+ () -> new DelegatedAddGroupResponseCallback(),
+ groupsaddGroupCommandParams);
+ groupsClusterCommandInfoMap.put("addGroup", groupsaddGroupCommandInfo);
+ Map<String, CommandParameterInfo> groupsaddGroupIfIdentifyingCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo groupsaddGroupIfIdentifyingCommandParameterInfo =
+ new CommandParameterInfo("Groups", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ groupsaddGroupIfIdentifyingCommandParams.put(
+ "groupId", groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo);
+
+ CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo =
+ new CommandParameterInfo("groupName", String.class);
+ groupsaddGroupIfIdentifyingCommandParams.put(
+ "groupName", groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo groupsaddGroupIfIdentifyingCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GroupsCluster) cluster)
+ .addGroupIfIdentifying(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("groupId"),
+ (String) commandArguments.get("groupName"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ groupsaddGroupIfIdentifyingCommandParams);
+ groupsClusterCommandInfoMap.put(
+ "addGroupIfIdentifying", groupsaddGroupIfIdentifyingCommandInfo);
+ Map<String, CommandParameterInfo> groupsgetGroupMembershipCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo groupsgetGroupMembershipCommandParameterInfo =
+ new CommandParameterInfo(
+ "Groups", ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback.class);
+ CommandParameterInfo groupsgetGroupMembershipgroupCountCommandParameterInfo =
+ new CommandParameterInfo("groupCount", int.class);
+ groupsgetGroupMembershipCommandParams.put(
+ "groupCount", groupsgetGroupMembershipgroupCountCommandParameterInfo);
+
+ CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo =
+ new CommandParameterInfo("groupList", int.class);
+ groupsgetGroupMembershipCommandParams.put(
+ "groupList", groupsgetGroupMembershipgroupListCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo groupsgetGroupMembershipCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GroupsCluster) cluster)
+ .getGroupMembership(
+ (ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback,
+ (Integer) commandArguments.get("groupCount"),
+ (Integer) commandArguments.get("groupList"));
+ },
+ () -> new DelegatedGetGroupMembershipResponseCallback(),
+ groupsgetGroupMembershipCommandParams);
+ groupsClusterCommandInfoMap.put("getGroupMembership", groupsgetGroupMembershipCommandInfo);
+ Map<String, CommandParameterInfo> groupsremoveAllGroupsCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo groupsremoveAllGroupsCommandParameterInfo =
+ new CommandParameterInfo("Groups", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo groupsremoveAllGroupsCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GroupsCluster) cluster)
+ .removeAllGroups((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ groupsremoveAllGroupsCommandParams);
+ groupsClusterCommandInfoMap.put("removeAllGroups", groupsremoveAllGroupsCommandInfo);
+ Map<String, CommandParameterInfo> groupsremoveGroupCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo groupsremoveGroupCommandParameterInfo =
+ new CommandParameterInfo(
+ "Groups", ChipClusters.GroupsCluster.RemoveGroupResponseCallback.class);
+ CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ groupsremoveGroupCommandParams.put("groupId", groupsremoveGroupgroupIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo groupsremoveGroupCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GroupsCluster) cluster)
+ .removeGroup(
+ (ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"));
+ },
+ () -> new DelegatedRemoveGroupResponseCallback(),
+ groupsremoveGroupCommandParams);
+ groupsClusterCommandInfoMap.put("removeGroup", groupsremoveGroupCommandInfo);
+ Map<String, CommandParameterInfo> groupsviewGroupCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo groupsviewGroupCommandParameterInfo =
+ new CommandParameterInfo(
+ "Groups", ChipClusters.GroupsCluster.ViewGroupResponseCallback.class);
+ CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ groupsviewGroupCommandParams.put("groupId", groupsviewGroupgroupIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo groupsviewGroupCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.GroupsCluster) cluster)
+ .viewGroup(
+ (ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"));
+ },
+ () -> new DelegatedViewGroupResponseCallback(),
+ groupsviewGroupCommandParams);
+ groupsClusterCommandInfoMap.put("viewGroup", groupsviewGroupCommandInfo);
+ // Populate cluster
+ ClusterInfo groupsClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId),
+ groupsClusterCommandInfoMap);
+ clusterMap.put("groups", groupsClusterInfo);
+ Map<String, CommandInfo> identifyClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> identifyidentifyCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo identifyidentifyCommandParameterInfo =
+ new CommandParameterInfo("Identify", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo =
+ new CommandParameterInfo("identifyTime", int.class);
+ identifyidentifyCommandParams.put(
+ "identifyTime", identifyidentifyidentifyTimeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo identifyidentifyCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.IdentifyCluster) cluster)
+ .identify(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("identifyTime"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ identifyidentifyCommandParams);
+ identifyClusterCommandInfoMap.put("identify", identifyidentifyCommandInfo);
+ Map<String, CommandParameterInfo> identifyidentifyQueryCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo identifyidentifyQueryCommandParameterInfo =
+ new CommandParameterInfo(
+ "Identify", ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback.class);
+ // Populate commands
+ CommandInfo identifyidentifyQueryCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.IdentifyCluster) cluster)
+ .identifyQuery(
+ (ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback);
+ },
+ () -> new DelegatedIdentifyQueryResponseCallback(),
+ identifyidentifyQueryCommandParams);
+ identifyClusterCommandInfoMap.put("identifyQuery", identifyidentifyQueryCommandInfo);
+ Map<String, CommandParameterInfo> identifytriggerEffectCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo identifytriggerEffectCommandParameterInfo =
+ new CommandParameterInfo("Identify", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo =
+ new CommandParameterInfo("effectIdentifier", int.class);
+ identifytriggerEffectCommandParams.put(
+ "effectIdentifier", identifytriggerEffecteffectIdentifierCommandParameterInfo);
+
+ CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo =
+ new CommandParameterInfo("effectVariant", int.class);
+ identifytriggerEffectCommandParams.put(
+ "effectVariant", identifytriggerEffecteffectVariantCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo identifytriggerEffectCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.IdentifyCluster) cluster)
+ .triggerEffect(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("effectIdentifier"),
+ (Integer) commandArguments.get("effectVariant"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ identifytriggerEffectCommandParams);
+ identifyClusterCommandInfoMap.put("triggerEffect", identifytriggerEffectCommandInfo);
+ // Populate cluster
+ ClusterInfo identifyClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId),
+ identifyClusterCommandInfoMap);
+ clusterMap.put("identify", identifyClusterInfo);
+ Map<String, CommandInfo> illuminanceMeasurementClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo illuminanceMeasurementClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId),
+ illuminanceMeasurementClusterCommandInfoMap);
+ clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo);
+ Map<String, CommandInfo> keypadInputClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> keypadInputsendKeyCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo keypadInputsendKeyCommandParameterInfo =
+ new CommandParameterInfo(
+ "KeypadInput", ChipClusters.KeypadInputCluster.SendKeyResponseCallback.class);
+ CommandParameterInfo keypadInputsendKeykeyCodeCommandParameterInfo =
+ new CommandParameterInfo("keyCode", int.class);
+ keypadInputsendKeyCommandParams.put("keyCode", keypadInputsendKeykeyCodeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo keypadInputsendKeyCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.KeypadInputCluster) cluster)
+ .sendKey(
+ (ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback,
+ (Integer) commandArguments.get("keyCode"));
+ },
+ () -> new DelegatedSendKeyResponseCallback(),
+ keypadInputsendKeyCommandParams);
+ keypadInputClusterCommandInfoMap.put("sendKey", keypadInputsendKeyCommandInfo);
+ // Populate cluster
+ ClusterInfo keypadInputClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId),
+ keypadInputClusterCommandInfoMap);
+ clusterMap.put("keypadInput", keypadInputClusterInfo);
+ Map<String, CommandInfo> levelControlClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> levelControlmoveCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo levelControlmoveCommandParameterInfo =
+ new CommandParameterInfo("LevelControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo levelControlmovemoveModeCommandParameterInfo =
+ new CommandParameterInfo("moveMode", int.class);
+ levelControlmoveCommandParams.put("moveMode", levelControlmovemoveModeCommandParameterInfo);
+
+ CommandParameterInfo levelControlmoverateCommandParameterInfo =
+ new CommandParameterInfo("rate", int.class);
+ levelControlmoveCommandParams.put("rate", levelControlmoverateCommandParameterInfo);
+
+ CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo =
+ new CommandParameterInfo("optionMask", int.class);
+ levelControlmoveCommandParams.put("optionMask", levelControlmoveoptionMaskCommandParameterInfo);
+
+ CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionOverride", int.class);
+ levelControlmoveCommandParams.put(
+ "optionOverride", levelControlmoveoptionOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo levelControlmoveCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LevelControlCluster) cluster)
+ .move(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("moveMode"),
+ (Integer) commandArguments.get("rate"),
+ (Integer) commandArguments.get("optionMask"),
+ (Integer) commandArguments.get("optionOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ levelControlmoveCommandParams);
+ levelControlClusterCommandInfoMap.put("move", levelControlmoveCommandInfo);
+ Map<String, CommandParameterInfo> levelControlmoveToLevelCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo levelControlmoveToLevelCommandParameterInfo =
+ new CommandParameterInfo("LevelControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo =
+ new CommandParameterInfo("level", int.class);
+ levelControlmoveToLevelCommandParams.put(
+ "level", levelControlmoveToLevellevelCommandParameterInfo);
+
+ CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ levelControlmoveToLevelCommandParams.put(
+ "transitionTime", levelControlmoveToLeveltransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo =
+ new CommandParameterInfo("optionMask", int.class);
+ levelControlmoveToLevelCommandParams.put(
+ "optionMask", levelControlmoveToLeveloptionMaskCommandParameterInfo);
+
+ CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionOverride", int.class);
+ levelControlmoveToLevelCommandParams.put(
+ "optionOverride", levelControlmoveToLeveloptionOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo levelControlmoveToLevelCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LevelControlCluster) cluster)
+ .moveToLevel(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("level"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionMask"),
+ (Integer) commandArguments.get("optionOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ levelControlmoveToLevelCommandParams);
+ levelControlClusterCommandInfoMap.put("moveToLevel", levelControlmoveToLevelCommandInfo);
+ Map<String, CommandParameterInfo> levelControlmoveToLevelWithOnOffCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo levelControlmoveToLevelWithOnOffCommandParameterInfo =
+ new CommandParameterInfo("LevelControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo =
+ new CommandParameterInfo("level", int.class);
+ levelControlmoveToLevelWithOnOffCommandParams.put(
+ "level", levelControlmoveToLevelWithOnOfflevelCommandParameterInfo);
+
+ CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ levelControlmoveToLevelWithOnOffCommandParams.put(
+ "transitionTime", levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo levelControlmoveToLevelWithOnOffCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LevelControlCluster) cluster)
+ .moveToLevelWithOnOff(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("level"),
+ (Integer) commandArguments.get("transitionTime"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ levelControlmoveToLevelWithOnOffCommandParams);
+ levelControlClusterCommandInfoMap.put(
+ "moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffCommandInfo);
+ Map<String, CommandParameterInfo> levelControlmoveWithOnOffCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo levelControlmoveWithOnOffCommandParameterInfo =
+ new CommandParameterInfo("LevelControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo =
+ new CommandParameterInfo("moveMode", int.class);
+ levelControlmoveWithOnOffCommandParams.put(
+ "moveMode", levelControlmoveWithOnOffmoveModeCommandParameterInfo);
+
+ CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo =
+ new CommandParameterInfo("rate", int.class);
+ levelControlmoveWithOnOffCommandParams.put(
+ "rate", levelControlmoveWithOnOffrateCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo levelControlmoveWithOnOffCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LevelControlCluster) cluster)
+ .moveWithOnOff(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("moveMode"),
+ (Integer) commandArguments.get("rate"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ levelControlmoveWithOnOffCommandParams);
+ levelControlClusterCommandInfoMap.put("moveWithOnOff", levelControlmoveWithOnOffCommandInfo);
+ Map<String, CommandParameterInfo> levelControlstepCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo levelControlstepCommandParameterInfo =
+ new CommandParameterInfo("LevelControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo levelControlstepstepModeCommandParameterInfo =
+ new CommandParameterInfo("stepMode", int.class);
+ levelControlstepCommandParams.put("stepMode", levelControlstepstepModeCommandParameterInfo);
+
+ CommandParameterInfo levelControlstepstepSizeCommandParameterInfo =
+ new CommandParameterInfo("stepSize", int.class);
+ levelControlstepCommandParams.put("stepSize", levelControlstepstepSizeCommandParameterInfo);
+
+ CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ levelControlstepCommandParams.put(
+ "transitionTime", levelControlsteptransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo =
+ new CommandParameterInfo("optionMask", int.class);
+ levelControlstepCommandParams.put("optionMask", levelControlstepoptionMaskCommandParameterInfo);
+
+ CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionOverride", int.class);
+ levelControlstepCommandParams.put(
+ "optionOverride", levelControlstepoptionOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo levelControlstepCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LevelControlCluster) cluster)
+ .step(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("stepMode"),
+ (Integer) commandArguments.get("stepSize"),
+ (Integer) commandArguments.get("transitionTime"),
+ (Integer) commandArguments.get("optionMask"),
+ (Integer) commandArguments.get("optionOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ levelControlstepCommandParams);
+ levelControlClusterCommandInfoMap.put("step", levelControlstepCommandInfo);
+ Map<String, CommandParameterInfo> levelControlstepWithOnOffCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo levelControlstepWithOnOffCommandParameterInfo =
+ new CommandParameterInfo("LevelControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo =
+ new CommandParameterInfo("stepMode", int.class);
+ levelControlstepWithOnOffCommandParams.put(
+ "stepMode", levelControlstepWithOnOffstepModeCommandParameterInfo);
+
+ CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo =
+ new CommandParameterInfo("stepSize", int.class);
+ levelControlstepWithOnOffCommandParams.put(
+ "stepSize", levelControlstepWithOnOffstepSizeCommandParameterInfo);
+
+ CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ levelControlstepWithOnOffCommandParams.put(
+ "transitionTime", levelControlstepWithOnOfftransitionTimeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo levelControlstepWithOnOffCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LevelControlCluster) cluster)
+ .stepWithOnOff(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("stepMode"),
+ (Integer) commandArguments.get("stepSize"),
+ (Integer) commandArguments.get("transitionTime"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ levelControlstepWithOnOffCommandParams);
+ levelControlClusterCommandInfoMap.put("stepWithOnOff", levelControlstepWithOnOffCommandInfo);
+ Map<String, CommandParameterInfo> levelControlstopCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo levelControlstopCommandParameterInfo =
+ new CommandParameterInfo("LevelControl", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo =
+ new CommandParameterInfo("optionMask", int.class);
+ levelControlstopCommandParams.put("optionMask", levelControlstopoptionMaskCommandParameterInfo);
+
+ CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo =
+ new CommandParameterInfo("optionOverride", int.class);
+ levelControlstopCommandParams.put(
+ "optionOverride", levelControlstopoptionOverrideCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo levelControlstopCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LevelControlCluster) cluster)
+ .stop(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("optionMask"),
+ (Integer) commandArguments.get("optionOverride"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ levelControlstopCommandParams);
+ levelControlClusterCommandInfoMap.put("stop", levelControlstopCommandInfo);
+ Map<String, CommandParameterInfo> levelControlstopWithOnOffCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo levelControlstopWithOnOffCommandParameterInfo =
+ new CommandParameterInfo("LevelControl", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo levelControlstopWithOnOffCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LevelControlCluster) cluster)
+ .stopWithOnOff((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ levelControlstopWithOnOffCommandParams);
+ levelControlClusterCommandInfoMap.put("stopWithOnOff", levelControlstopWithOnOffCommandInfo);
+ // Populate cluster
+ ClusterInfo levelControlClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId),
+ levelControlClusterCommandInfoMap);
+ clusterMap.put("levelControl", levelControlClusterInfo);
+ Map<String, CommandInfo> lowPowerClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> lowPowersleepCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo lowPowersleepCommandParameterInfo =
+ new CommandParameterInfo("LowPower", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo lowPowersleepCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.LowPowerCluster) cluster).sleep((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ lowPowersleepCommandParams);
+ lowPowerClusterCommandInfoMap.put("sleep", lowPowersleepCommandInfo);
+ // Populate cluster
+ ClusterInfo lowPowerClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId),
+ lowPowerClusterCommandInfoMap);
+ clusterMap.put("lowPower", lowPowerClusterInfo);
+ Map<String, CommandInfo> mediaInputClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> mediaInputhideInputStatusCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaInputhideInputStatusCommandParameterInfo =
+ new CommandParameterInfo("MediaInput", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo mediaInputhideInputStatusCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaInputCluster) cluster)
+ .hideInputStatus((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ mediaInputhideInputStatusCommandParams);
+ mediaInputClusterCommandInfoMap.put("hideInputStatus", mediaInputhideInputStatusCommandInfo);
+ Map<String, CommandParameterInfo> mediaInputrenameInputCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaInputrenameInputCommandParameterInfo =
+ new CommandParameterInfo("MediaInput", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo mediaInputrenameInputindexCommandParameterInfo =
+ new CommandParameterInfo("index", int.class);
+ mediaInputrenameInputCommandParams.put("index", mediaInputrenameInputindexCommandParameterInfo);
+
+ CommandParameterInfo mediaInputrenameInputnameCommandParameterInfo =
+ new CommandParameterInfo("name", String.class);
+ mediaInputrenameInputCommandParams.put("name", mediaInputrenameInputnameCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo mediaInputrenameInputCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaInputCluster) cluster)
+ .renameInput(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("index"),
+ (String) commandArguments.get("name"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ mediaInputrenameInputCommandParams);
+ mediaInputClusterCommandInfoMap.put("renameInput", mediaInputrenameInputCommandInfo);
+ Map<String, CommandParameterInfo> mediaInputselectInputCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaInputselectInputCommandParameterInfo =
+ new CommandParameterInfo("MediaInput", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo mediaInputselectInputindexCommandParameterInfo =
+ new CommandParameterInfo("index", int.class);
+ mediaInputselectInputCommandParams.put("index", mediaInputselectInputindexCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo mediaInputselectInputCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaInputCluster) cluster)
+ .selectInput(
+ (DefaultClusterCallback) callback, (Integer) commandArguments.get("index"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ mediaInputselectInputCommandParams);
+ mediaInputClusterCommandInfoMap.put("selectInput", mediaInputselectInputCommandInfo);
+ Map<String, CommandParameterInfo> mediaInputshowInputStatusCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaInputshowInputStatusCommandParameterInfo =
+ new CommandParameterInfo("MediaInput", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo mediaInputshowInputStatusCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaInputCluster) cluster)
+ .showInputStatus((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ mediaInputshowInputStatusCommandParams);
+ mediaInputClusterCommandInfoMap.put("showInputStatus", mediaInputshowInputStatusCommandInfo);
+ // Populate cluster
+ ClusterInfo mediaInputClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId),
+ mediaInputClusterCommandInfoMap);
+ clusterMap.put("mediaInput", mediaInputClusterInfo);
+ Map<String, CommandInfo> mediaPlaybackClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> mediaPlaybackmediaFastForwardCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaFastForwardCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback",
+ ChipClusters.MediaPlaybackCluster.MediaFastForwardResponseCallback.class);
+ // Populate commands
+ CommandInfo mediaPlaybackmediaFastForwardCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaFastForward(
+ (ChipClusters.MediaPlaybackCluster.MediaFastForwardResponseCallback)
+ callback);
+ },
+ () -> new DelegatedMediaFastForwardResponseCallback(),
+ mediaPlaybackmediaFastForwardCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put(
+ "mediaFastForward", mediaPlaybackmediaFastForwardCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaNextCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaNextCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback", ChipClusters.MediaPlaybackCluster.MediaNextResponseCallback.class);
+ // Populate commands
+ CommandInfo mediaPlaybackmediaNextCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaNext(
+ (ChipClusters.MediaPlaybackCluster.MediaNextResponseCallback) callback);
+ },
+ () -> new DelegatedMediaNextResponseCallback(),
+ mediaPlaybackmediaNextCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put("mediaNext", mediaPlaybackmediaNextCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaPauseCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaPauseCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback", ChipClusters.MediaPlaybackCluster.MediaPauseResponseCallback.class);
+ // Populate commands
+ CommandInfo mediaPlaybackmediaPauseCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaPause(
+ (ChipClusters.MediaPlaybackCluster.MediaPauseResponseCallback) callback);
+ },
+ () -> new DelegatedMediaPauseResponseCallback(),
+ mediaPlaybackmediaPauseCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put("mediaPause", mediaPlaybackmediaPauseCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaPlayCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaPlayCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback", ChipClusters.MediaPlaybackCluster.MediaPlayResponseCallback.class);
+ // Populate commands
+ CommandInfo mediaPlaybackmediaPlayCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaPlay(
+ (ChipClusters.MediaPlaybackCluster.MediaPlayResponseCallback) callback);
+ },
+ () -> new DelegatedMediaPlayResponseCallback(),
+ mediaPlaybackmediaPlayCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put("mediaPlay", mediaPlaybackmediaPlayCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaPreviousCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaPreviousCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback", ChipClusters.MediaPlaybackCluster.MediaPreviousResponseCallback.class);
+ // Populate commands
+ CommandInfo mediaPlaybackmediaPreviousCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaPrevious(
+ (ChipClusters.MediaPlaybackCluster.MediaPreviousResponseCallback) callback);
+ },
+ () -> new DelegatedMediaPreviousResponseCallback(),
+ mediaPlaybackmediaPreviousCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put("mediaPrevious", mediaPlaybackmediaPreviousCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaRewindCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaRewindCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback", ChipClusters.MediaPlaybackCluster.MediaRewindResponseCallback.class);
+ // Populate commands
+ CommandInfo mediaPlaybackmediaRewindCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaRewind(
+ (ChipClusters.MediaPlaybackCluster.MediaRewindResponseCallback) callback);
+ },
+ () -> new DelegatedMediaRewindResponseCallback(),
+ mediaPlaybackmediaRewindCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put("mediaRewind", mediaPlaybackmediaRewindCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaSeekCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaSeekCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback", ChipClusters.MediaPlaybackCluster.MediaSeekResponseCallback.class);
+ CommandParameterInfo mediaPlaybackmediaSeekpositionCommandParameterInfo =
+ new CommandParameterInfo("position", long.class);
+ mediaPlaybackmediaSeekCommandParams.put(
+ "position", mediaPlaybackmediaSeekpositionCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo mediaPlaybackmediaSeekCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaSeek(
+ (ChipClusters.MediaPlaybackCluster.MediaSeekResponseCallback) callback,
+ (Long) commandArguments.get("position"));
+ },
+ () -> new DelegatedMediaSeekResponseCallback(),
+ mediaPlaybackmediaSeekCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put("mediaSeek", mediaPlaybackmediaSeekCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaSkipBackwardCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaSkipBackwardCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback",
+ ChipClusters.MediaPlaybackCluster.MediaSkipBackwardResponseCallback.class);
+ CommandParameterInfo
+ mediaPlaybackmediaSkipBackwarddeltaPositionMillisecondsCommandParameterInfo =
+ new CommandParameterInfo("deltaPositionMilliseconds", long.class);
+ mediaPlaybackmediaSkipBackwardCommandParams.put(
+ "deltaPositionMilliseconds",
+ mediaPlaybackmediaSkipBackwarddeltaPositionMillisecondsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo mediaPlaybackmediaSkipBackwardCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaSkipBackward(
+ (ChipClusters.MediaPlaybackCluster.MediaSkipBackwardResponseCallback)
+ callback,
+ (Long) commandArguments.get("deltaPositionMilliseconds"));
+ },
+ () -> new DelegatedMediaSkipBackwardResponseCallback(),
+ mediaPlaybackmediaSkipBackwardCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put(
+ "mediaSkipBackward", mediaPlaybackmediaSkipBackwardCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaSkipForwardCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaSkipForwardCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback",
+ ChipClusters.MediaPlaybackCluster.MediaSkipForwardResponseCallback.class);
+ CommandParameterInfo
+ mediaPlaybackmediaSkipForwarddeltaPositionMillisecondsCommandParameterInfo =
+ new CommandParameterInfo("deltaPositionMilliseconds", long.class);
+ mediaPlaybackmediaSkipForwardCommandParams.put(
+ "deltaPositionMilliseconds",
+ mediaPlaybackmediaSkipForwarddeltaPositionMillisecondsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo mediaPlaybackmediaSkipForwardCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaSkipForward(
+ (ChipClusters.MediaPlaybackCluster.MediaSkipForwardResponseCallback) callback,
+ (Long) commandArguments.get("deltaPositionMilliseconds"));
+ },
+ () -> new DelegatedMediaSkipForwardResponseCallback(),
+ mediaPlaybackmediaSkipForwardCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put(
+ "mediaSkipForward", mediaPlaybackmediaSkipForwardCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaStartOverCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaStartOverCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback",
+ ChipClusters.MediaPlaybackCluster.MediaStartOverResponseCallback.class);
+ // Populate commands
+ CommandInfo mediaPlaybackmediaStartOverCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaStartOver(
+ (ChipClusters.MediaPlaybackCluster.MediaStartOverResponseCallback) callback);
+ },
+ () -> new DelegatedMediaStartOverResponseCallback(),
+ mediaPlaybackmediaStartOverCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put(
+ "mediaStartOver", mediaPlaybackmediaStartOverCommandInfo);
+ Map<String, CommandParameterInfo> mediaPlaybackmediaStopCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo mediaPlaybackmediaStopCommandParameterInfo =
+ new CommandParameterInfo(
+ "MediaPlayback", ChipClusters.MediaPlaybackCluster.MediaStopResponseCallback.class);
+ // Populate commands
+ CommandInfo mediaPlaybackmediaStopCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.MediaPlaybackCluster) cluster)
+ .mediaStop(
+ (ChipClusters.MediaPlaybackCluster.MediaStopResponseCallback) callback);
+ },
+ () -> new DelegatedMediaStopResponseCallback(),
+ mediaPlaybackmediaStopCommandParams);
+ mediaPlaybackClusterCommandInfoMap.put("mediaStop", mediaPlaybackmediaStopCommandInfo);
+ // Populate cluster
+ ClusterInfo mediaPlaybackClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId),
+ mediaPlaybackClusterCommandInfoMap);
+ clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo);
+ Map<String, CommandInfo> networkCommissioningClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> networkCommissioningaddThreadNetworkCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioningaddThreadNetworkCommandParameterInfo =
+ new CommandParameterInfo(
+ "NetworkCommissioning",
+ ChipClusters.NetworkCommissioningCluster.AddThreadNetworkResponseCallback.class);
+ CommandParameterInfo
+ networkCommissioningaddThreadNetworkoperationalDatasetCommandParameterInfo =
+ new CommandParameterInfo("operationalDataset", byte[].class);
+ networkCommissioningaddThreadNetworkCommandParams.put(
+ "operationalDataset",
+ networkCommissioningaddThreadNetworkoperationalDatasetCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningaddThreadNetworkbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ networkCommissioningaddThreadNetworkCommandParams.put(
+ "breadcrumb", networkCommissioningaddThreadNetworkbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningaddThreadNetworktimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioningaddThreadNetworkCommandParams.put(
+ "timeoutMs", networkCommissioningaddThreadNetworktimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioningaddThreadNetworkCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .addThreadNetwork(
+ (ChipClusters.NetworkCommissioningCluster.AddThreadNetworkResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("operationalDataset"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedAddThreadNetworkResponseCallback(),
+ networkCommissioningaddThreadNetworkCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "addThreadNetwork", networkCommissioningaddThreadNetworkCommandInfo);
+ Map<String, CommandParameterInfo> networkCommissioningaddWiFiNetworkCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioningaddWiFiNetworkCommandParameterInfo =
+ new CommandParameterInfo(
+ "NetworkCommissioning",
+ ChipClusters.NetworkCommissioningCluster.AddWiFiNetworkResponseCallback.class);
+ CommandParameterInfo networkCommissioningaddWiFiNetworkssidCommandParameterInfo =
+ new CommandParameterInfo("ssid", byte[].class);
+ networkCommissioningaddWiFiNetworkCommandParams.put(
+ "ssid", networkCommissioningaddWiFiNetworkssidCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningaddWiFiNetworkcredentialsCommandParameterInfo =
+ new CommandParameterInfo("credentials", byte[].class);
+ networkCommissioningaddWiFiNetworkCommandParams.put(
+ "credentials", networkCommissioningaddWiFiNetworkcredentialsCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningaddWiFiNetworkbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ networkCommissioningaddWiFiNetworkCommandParams.put(
+ "breadcrumb", networkCommissioningaddWiFiNetworkbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningaddWiFiNetworktimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioningaddWiFiNetworkCommandParams.put(
+ "timeoutMs", networkCommissioningaddWiFiNetworktimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioningaddWiFiNetworkCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .addWiFiNetwork(
+ (ChipClusters.NetworkCommissioningCluster.AddWiFiNetworkResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("ssid"),
+ (byte[]) commandArguments.get("credentials"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedAddWiFiNetworkResponseCallback(),
+ networkCommissioningaddWiFiNetworkCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "addWiFiNetwork", networkCommissioningaddWiFiNetworkCommandInfo);
+ Map<String, CommandParameterInfo> networkCommissioningdisableNetworkCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioningdisableNetworkCommandParameterInfo =
+ new CommandParameterInfo(
+ "NetworkCommissioning",
+ ChipClusters.NetworkCommissioningCluster.DisableNetworkResponseCallback.class);
+ CommandParameterInfo networkCommissioningdisableNetworknetworkIDCommandParameterInfo =
+ new CommandParameterInfo("networkID", byte[].class);
+ networkCommissioningdisableNetworkCommandParams.put(
+ "networkID", networkCommissioningdisableNetworknetworkIDCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningdisableNetworkbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ networkCommissioningdisableNetworkCommandParams.put(
+ "breadcrumb", networkCommissioningdisableNetworkbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningdisableNetworktimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioningdisableNetworkCommandParams.put(
+ "timeoutMs", networkCommissioningdisableNetworktimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioningdisableNetworkCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .disableNetwork(
+ (ChipClusters.NetworkCommissioningCluster.DisableNetworkResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("networkID"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedDisableNetworkResponseCallback(),
+ networkCommissioningdisableNetworkCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "disableNetwork", networkCommissioningdisableNetworkCommandInfo);
+ Map<String, CommandParameterInfo> networkCommissioningenableNetworkCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioningenableNetworkCommandParameterInfo =
+ new CommandParameterInfo(
+ "NetworkCommissioning",
+ ChipClusters.NetworkCommissioningCluster.EnableNetworkResponseCallback.class);
+ CommandParameterInfo networkCommissioningenableNetworknetworkIDCommandParameterInfo =
+ new CommandParameterInfo("networkID", byte[].class);
+ networkCommissioningenableNetworkCommandParams.put(
+ "networkID", networkCommissioningenableNetworknetworkIDCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningenableNetworkbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ networkCommissioningenableNetworkCommandParams.put(
+ "breadcrumb", networkCommissioningenableNetworkbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningenableNetworktimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioningenableNetworkCommandParams.put(
+ "timeoutMs", networkCommissioningenableNetworktimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioningenableNetworkCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .enableNetwork(
+ (ChipClusters.NetworkCommissioningCluster.EnableNetworkResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("networkID"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedEnableNetworkResponseCallback(),
+ networkCommissioningenableNetworkCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "enableNetwork", networkCommissioningenableNetworkCommandInfo);
+ Map<String, CommandParameterInfo>
+ networkCommissioninggetLastNetworkCommissioningResultCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioninggetLastNetworkCommissioningResultCommandParameterInfo =
+ new CommandParameterInfo("NetworkCommissioning", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo
+ networkCommissioninggetLastNetworkCommissioningResulttimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioninggetLastNetworkCommissioningResultCommandParams.put(
+ "timeoutMs",
+ networkCommissioninggetLastNetworkCommissioningResulttimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioninggetLastNetworkCommissioningResultCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .getLastNetworkCommissioningResult(
+ (DefaultClusterCallback) callback, (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ networkCommissioninggetLastNetworkCommissioningResultCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "getLastNetworkCommissioningResult",
+ networkCommissioninggetLastNetworkCommissioningResultCommandInfo);
+ Map<String, CommandParameterInfo> networkCommissioningremoveNetworkCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioningremoveNetworkCommandParameterInfo =
+ new CommandParameterInfo(
+ "NetworkCommissioning",
+ ChipClusters.NetworkCommissioningCluster.RemoveNetworkResponseCallback.class);
+ CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo =
+ new CommandParameterInfo("networkID", byte[].class);
+ networkCommissioningremoveNetworkCommandParams.put(
+ "networkID", networkCommissioningremoveNetworknetworkIDCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ networkCommissioningremoveNetworkCommandParams.put(
+ "breadcrumb", networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningremoveNetworktimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioningremoveNetworkCommandParams.put(
+ "timeoutMs", networkCommissioningremoveNetworktimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioningremoveNetworkCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .removeNetwork(
+ (ChipClusters.NetworkCommissioningCluster.RemoveNetworkResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("networkID"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedRemoveNetworkResponseCallback(),
+ networkCommissioningremoveNetworkCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "removeNetwork", networkCommissioningremoveNetworkCommandInfo);
+ Map<String, CommandParameterInfo> networkCommissioningscanNetworksCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioningscanNetworksCommandParameterInfo =
+ new CommandParameterInfo(
+ "NetworkCommissioning",
+ ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback.class);
+ CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo =
+ new CommandParameterInfo("ssid", byte[].class);
+ networkCommissioningscanNetworksCommandParams.put(
+ "ssid", networkCommissioningscanNetworksssidCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ networkCommissioningscanNetworksCommandParams.put(
+ "breadcrumb", networkCommissioningscanNetworksbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningscanNetworkstimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioningscanNetworksCommandParams.put(
+ "timeoutMs", networkCommissioningscanNetworkstimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioningscanNetworksCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .scanNetworks(
+ (ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("ssid"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedScanNetworksResponseCallback(),
+ networkCommissioningscanNetworksCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "scanNetworks", networkCommissioningscanNetworksCommandInfo);
+ Map<String, CommandParameterInfo> networkCommissioningupdateThreadNetworkCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioningupdateThreadNetworkCommandParameterInfo =
+ new CommandParameterInfo(
+ "NetworkCommissioning",
+ ChipClusters.NetworkCommissioningCluster.UpdateThreadNetworkResponseCallback.class);
+ CommandParameterInfo
+ networkCommissioningupdateThreadNetworkoperationalDatasetCommandParameterInfo =
+ new CommandParameterInfo("operationalDataset", byte[].class);
+ networkCommissioningupdateThreadNetworkCommandParams.put(
+ "operationalDataset",
+ networkCommissioningupdateThreadNetworkoperationalDatasetCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningupdateThreadNetworkbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ networkCommissioningupdateThreadNetworkCommandParams.put(
+ "breadcrumb", networkCommissioningupdateThreadNetworkbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningupdateThreadNetworktimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioningupdateThreadNetworkCommandParams.put(
+ "timeoutMs", networkCommissioningupdateThreadNetworktimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioningupdateThreadNetworkCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .updateThreadNetwork(
+ (ChipClusters.NetworkCommissioningCluster.UpdateThreadNetworkResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("operationalDataset"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedUpdateThreadNetworkResponseCallback(),
+ networkCommissioningupdateThreadNetworkCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "updateThreadNetwork", networkCommissioningupdateThreadNetworkCommandInfo);
+ Map<String, CommandParameterInfo> networkCommissioningupdateWiFiNetworkCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo networkCommissioningupdateWiFiNetworkCommandParameterInfo =
+ new CommandParameterInfo(
+ "NetworkCommissioning",
+ ChipClusters.NetworkCommissioningCluster.UpdateWiFiNetworkResponseCallback.class);
+ CommandParameterInfo networkCommissioningupdateWiFiNetworkssidCommandParameterInfo =
+ new CommandParameterInfo("ssid", byte[].class);
+ networkCommissioningupdateWiFiNetworkCommandParams.put(
+ "ssid", networkCommissioningupdateWiFiNetworkssidCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningupdateWiFiNetworkcredentialsCommandParameterInfo =
+ new CommandParameterInfo("credentials", byte[].class);
+ networkCommissioningupdateWiFiNetworkCommandParams.put(
+ "credentials", networkCommissioningupdateWiFiNetworkcredentialsCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningupdateWiFiNetworkbreadcrumbCommandParameterInfo =
+ new CommandParameterInfo("breadcrumb", long.class);
+ networkCommissioningupdateWiFiNetworkCommandParams.put(
+ "breadcrumb", networkCommissioningupdateWiFiNetworkbreadcrumbCommandParameterInfo);
+
+ CommandParameterInfo networkCommissioningupdateWiFiNetworktimeoutMsCommandParameterInfo =
+ new CommandParameterInfo("timeoutMs", long.class);
+ networkCommissioningupdateWiFiNetworkCommandParams.put(
+ "timeoutMs", networkCommissioningupdateWiFiNetworktimeoutMsCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo networkCommissioningupdateWiFiNetworkCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.NetworkCommissioningCluster) cluster)
+ .updateWiFiNetwork(
+ (ChipClusters.NetworkCommissioningCluster.UpdateWiFiNetworkResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("ssid"),
+ (byte[]) commandArguments.get("credentials"),
+ (Long) commandArguments.get("breadcrumb"),
+ (Long) commandArguments.get("timeoutMs"));
+ },
+ () -> new DelegatedUpdateWiFiNetworkResponseCallback(),
+ networkCommissioningupdateWiFiNetworkCommandParams);
+ networkCommissioningClusterCommandInfoMap.put(
+ "updateWiFiNetwork", networkCommissioningupdateWiFiNetworkCommandInfo);
+ // Populate cluster
+ ClusterInfo networkCommissioningClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId),
+ networkCommissioningClusterCommandInfoMap);
+ clusterMap.put("networkCommissioning", networkCommissioningClusterInfo);
+ Map<String, CommandInfo> otaSoftwareUpdateProviderClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> otaSoftwareUpdateProviderapplyUpdateRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestCommandParameterInfo =
+ new CommandParameterInfo(
+ "OtaSoftwareUpdateProvider",
+ ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateRequestResponseCallback.class);
+ CommandParameterInfo
+ otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo =
+ new CommandParameterInfo("updateToken", byte[].class);
+ otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put(
+ "updateToken", otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo);
+
+ CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo =
+ new CommandParameterInfo("newVersion", long.class);
+ otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put(
+ "newVersion", otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo otaSoftwareUpdateProviderapplyUpdateRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster)
+ .applyUpdateRequest(
+ (ChipClusters.OtaSoftwareUpdateProviderCluster
+ .ApplyUpdateRequestResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("updateToken"),
+ (Long) commandArguments.get("newVersion"));
+ },
+ () -> new DelegatedApplyUpdateRequestResponseCallback(),
+ otaSoftwareUpdateProviderapplyUpdateRequestCommandParams);
+ otaSoftwareUpdateProviderClusterCommandInfoMap.put(
+ "applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestCommandInfo);
+ Map<String, CommandParameterInfo> otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParameterInfo =
+ new CommandParameterInfo(
+ "OtaSoftwareUpdateProvider", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo
+ otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo =
+ new CommandParameterInfo("updateToken", byte[].class);
+ otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put(
+ "updateToken", otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo);
+
+ CommandParameterInfo
+ otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo =
+ new CommandParameterInfo("softwareVersion", long.class);
+ otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put(
+ "softwareVersion",
+ otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo otaSoftwareUpdateProvidernotifyUpdateAppliedCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster)
+ .notifyUpdateApplied(
+ (DefaultClusterCallback) callback,
+ (byte[]) commandArguments.get("updateToken"),
+ (Long) commandArguments.get("softwareVersion"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams);
+ otaSoftwareUpdateProviderClusterCommandInfoMap.put(
+ "notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedCommandInfo);
+ Map<String, CommandParameterInfo> otaSoftwareUpdateProviderqueryImageCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo otaSoftwareUpdateProviderqueryImageCommandParameterInfo =
+ new CommandParameterInfo(
+ "OtaSoftwareUpdateProvider",
+ ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback.class);
+ CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo =
+ new CommandParameterInfo("vendorId", int.class);
+ otaSoftwareUpdateProviderqueryImageCommandParams.put(
+ "vendorId", otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo);
+
+ CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo =
+ new CommandParameterInfo("productId", int.class);
+ otaSoftwareUpdateProviderqueryImageCommandParams.put(
+ "productId", otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo);
+
+ CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo =
+ new CommandParameterInfo("hardwareVersion", int.class);
+ otaSoftwareUpdateProviderqueryImageCommandParams.put(
+ "hardwareVersion", otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo);
+
+ CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo =
+ new CommandParameterInfo("softwareVersion", long.class);
+ otaSoftwareUpdateProviderqueryImageCommandParams.put(
+ "softwareVersion", otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo);
+
+ CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo =
+ new CommandParameterInfo("protocolsSupported", int.class);
+ otaSoftwareUpdateProviderqueryImageCommandParams.put(
+ "protocolsSupported",
+ otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo);
+
+ CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo =
+ new CommandParameterInfo("location", String.class);
+ otaSoftwareUpdateProviderqueryImageCommandParams.put(
+ "location", otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo);
+
+ CommandParameterInfo
+ otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo =
+ new CommandParameterInfo("requestorCanConsent", boolean.class);
+ otaSoftwareUpdateProviderqueryImageCommandParams.put(
+ "requestorCanConsent",
+ otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo);
+
+ CommandParameterInfo
+ otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo =
+ new CommandParameterInfo("metadataForProvider", byte[].class);
+ otaSoftwareUpdateProviderqueryImageCommandParams.put(
+ "metadataForProvider",
+ otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo otaSoftwareUpdateProviderqueryImageCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster)
+ .queryImage(
+ (ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback)
+ callback,
+ (Integer) commandArguments.get("vendorId"),
+ (Integer) commandArguments.get("productId"),
+ (Integer) commandArguments.get("hardwareVersion"),
+ (Long) commandArguments.get("softwareVersion"),
+ (Integer) commandArguments.get("protocolsSupported"),
+ (String) commandArguments.get("location"),
+ (Boolean) commandArguments.get("requestorCanConsent"),
+ (byte[]) commandArguments.get("metadataForProvider"));
+ },
+ () -> new DelegatedQueryImageResponseCallback(),
+ otaSoftwareUpdateProviderqueryImageCommandParams);
+ otaSoftwareUpdateProviderClusterCommandInfoMap.put(
+ "queryImage", otaSoftwareUpdateProviderqueryImageCommandInfo);
+ // Populate cluster
+ ClusterInfo otaSoftwareUpdateProviderClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId),
+ otaSoftwareUpdateProviderClusterCommandInfoMap);
+ clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo);
+ Map<String, CommandInfo> otaSoftwareUpdateRequestorClusterCommandInfoMap =
+ new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> otaSoftwareUpdateRequestorannounceOtaProviderCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderCommandParameterInfo =
+ new CommandParameterInfo(
+ "OtaSoftwareUpdateRequestor", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo
+ otaSoftwareUpdateRequestorannounceOtaProviderproviderLocationCommandParameterInfo =
+ new CommandParameterInfo("providerLocation", long.class);
+ otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put(
+ "providerLocation",
+ otaSoftwareUpdateRequestorannounceOtaProviderproviderLocationCommandParameterInfo);
+
+ CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo =
+ new CommandParameterInfo("vendorId", int.class);
+ otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put(
+ "vendorId", otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo);
+
+ CommandParameterInfo
+ otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo =
+ new CommandParameterInfo("announcementReason", int.class);
+ otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put(
+ "announcementReason",
+ otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo);
+
+ CommandParameterInfo
+ otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo =
+ new CommandParameterInfo("metadataForNode", byte[].class);
+ otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put(
+ "metadataForNode",
+ otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo otaSoftwareUpdateRequestorannounceOtaProviderCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster)
+ .announceOtaProvider(
+ (DefaultClusterCallback) callback,
+ (Long) commandArguments.get("providerLocation"),
+ (Integer) commandArguments.get("vendorId"),
+ (Integer) commandArguments.get("announcementReason"),
+ (byte[]) commandArguments.get("metadataForNode"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ otaSoftwareUpdateRequestorannounceOtaProviderCommandParams);
+ otaSoftwareUpdateRequestorClusterCommandInfoMap.put(
+ "announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderCommandInfo);
+ // Populate cluster
+ ClusterInfo otaSoftwareUpdateRequestorClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) ->
+ new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId),
+ otaSoftwareUpdateRequestorClusterCommandInfoMap);
+ clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo);
+ Map<String, CommandInfo> occupancySensingClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo occupancySensingClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId),
+ occupancySensingClusterCommandInfoMap);
+ clusterMap.put("occupancySensing", occupancySensingClusterInfo);
+ Map<String, CommandInfo> onOffClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> onOffoffCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo onOffoffCommandParameterInfo =
+ new CommandParameterInfo("OnOff", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo onOffoffCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OnOffCluster) cluster).off((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ onOffoffCommandParams);
+ onOffClusterCommandInfoMap.put("off", onOffoffCommandInfo);
+ Map<String, CommandParameterInfo> onOffoffWithEffectCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo onOffoffWithEffectCommandParameterInfo =
+ new CommandParameterInfo("OnOff", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo =
+ new CommandParameterInfo("effectId", int.class);
+ onOffoffWithEffectCommandParams.put("effectId", onOffoffWithEffecteffectIdCommandParameterInfo);
+
+ CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo =
+ new CommandParameterInfo("effectVariant", int.class);
+ onOffoffWithEffectCommandParams.put(
+ "effectVariant", onOffoffWithEffecteffectVariantCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo onOffoffWithEffectCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OnOffCluster) cluster)
+ .offWithEffect(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("effectId"),
+ (Integer) commandArguments.get("effectVariant"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ onOffoffWithEffectCommandParams);
+ onOffClusterCommandInfoMap.put("offWithEffect", onOffoffWithEffectCommandInfo);
+ Map<String, CommandParameterInfo> onOffonCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo onOffonCommandParameterInfo =
+ new CommandParameterInfo("OnOff", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo onOffonCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OnOffCluster) cluster).on((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ onOffonCommandParams);
+ onOffClusterCommandInfoMap.put("on", onOffonCommandInfo);
+ Map<String, CommandParameterInfo> onOffonWithRecallGlobalSceneCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo onOffonWithRecallGlobalSceneCommandParameterInfo =
+ new CommandParameterInfo("OnOff", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo onOffonWithRecallGlobalSceneCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OnOffCluster) cluster)
+ .onWithRecallGlobalScene((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ onOffonWithRecallGlobalSceneCommandParams);
+ onOffClusterCommandInfoMap.put(
+ "onWithRecallGlobalScene", onOffonWithRecallGlobalSceneCommandInfo);
+ Map<String, CommandParameterInfo> onOffonWithTimedOffCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo onOffonWithTimedOffCommandParameterInfo =
+ new CommandParameterInfo("OnOff", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo =
+ new CommandParameterInfo("onOffControl", int.class);
+ onOffonWithTimedOffCommandParams.put(
+ "onOffControl", onOffonWithTimedOffonOffControlCommandParameterInfo);
+
+ CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo =
+ new CommandParameterInfo("onTime", int.class);
+ onOffonWithTimedOffCommandParams.put("onTime", onOffonWithTimedOffonTimeCommandParameterInfo);
+
+ CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo =
+ new CommandParameterInfo("offWaitTime", int.class);
+ onOffonWithTimedOffCommandParams.put(
+ "offWaitTime", onOffonWithTimedOffoffWaitTimeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo onOffonWithTimedOffCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OnOffCluster) cluster)
+ .onWithTimedOff(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("onOffControl"),
+ (Integer) commandArguments.get("onTime"),
+ (Integer) commandArguments.get("offWaitTime"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ onOffonWithTimedOffCommandParams);
+ onOffClusterCommandInfoMap.put("onWithTimedOff", onOffonWithTimedOffCommandInfo);
+ Map<String, CommandParameterInfo> onOfftoggleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo onOfftoggleCommandParameterInfo =
+ new CommandParameterInfo("OnOff", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo onOfftoggleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OnOffCluster) cluster).toggle((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ onOfftoggleCommandParams);
+ onOffClusterCommandInfoMap.put("toggle", onOfftoggleCommandInfo);
+ // Populate cluster
+ ClusterInfo onOffClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId),
+ onOffClusterCommandInfoMap);
+ clusterMap.put("onOff", onOffClusterInfo);
+ Map<String, CommandInfo> onOffSwitchConfigurationClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo onOffSwitchConfigurationClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId),
+ onOffSwitchConfigurationClusterCommandInfoMap);
+ clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo);
+ Map<String, CommandInfo> operationalCredentialsClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> operationalCredentialsaddNOCCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialsaddNOCCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials",
+ ChipClusters.OperationalCredentialsCluster.NOCResponseCallback.class);
+ CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo =
+ new CommandParameterInfo("NOCValue", byte[].class);
+ operationalCredentialsaddNOCCommandParams.put(
+ "NOCValue", operationalCredentialsaddNOCNOCValueCommandParameterInfo);
+
+ CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo =
+ new CommandParameterInfo("ICACValue", byte[].class);
+ operationalCredentialsaddNOCCommandParams.put(
+ "ICACValue", operationalCredentialsaddNOCICACValueCommandParameterInfo);
+
+ CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo =
+ new CommandParameterInfo("IPKValue", byte[].class);
+ operationalCredentialsaddNOCCommandParams.put(
+ "IPKValue", operationalCredentialsaddNOCIPKValueCommandParameterInfo);
+
+ CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo =
+ new CommandParameterInfo("caseAdminNode", long.class);
+ operationalCredentialsaddNOCCommandParams.put(
+ "caseAdminNode", operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo);
+
+ CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo =
+ new CommandParameterInfo("adminVendorId", int.class);
+ operationalCredentialsaddNOCCommandParams.put(
+ "adminVendorId", operationalCredentialsaddNOCadminVendorIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialsaddNOCCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .addNOC(
+ (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback,
+ (byte[]) commandArguments.get("NOCValue"),
+ (byte[]) commandArguments.get("ICACValue"),
+ (byte[]) commandArguments.get("IPKValue"),
+ (Long) commandArguments.get("caseAdminNode"),
+ (Integer) commandArguments.get("adminVendorId"));
+ },
+ () -> new DelegatedNOCResponseCallback(),
+ operationalCredentialsaddNOCCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "addNOC", operationalCredentialsaddNOCCommandInfo);
+ Map<String, CommandParameterInfo> operationalCredentialsaddTrustedRootCertificateCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialsaddTrustedRootCertificateCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo
+ operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo =
+ new CommandParameterInfo("rootCertificate", byte[].class);
+ operationalCredentialsaddTrustedRootCertificateCommandParams.put(
+ "rootCertificate",
+ operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialsaddTrustedRootCertificateCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .addTrustedRootCertificate(
+ (DefaultClusterCallback) callback,
+ (byte[]) commandArguments.get("rootCertificate"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ operationalCredentialsaddTrustedRootCertificateCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "addTrustedRootCertificate", operationalCredentialsaddTrustedRootCertificateCommandInfo);
+ Map<String, CommandParameterInfo> operationalCredentialsattestationRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialsattestationRequestCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials",
+ ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback.class);
+ CommandParameterInfo
+ operationalCredentialsattestationRequestattestationNonceCommandParameterInfo =
+ new CommandParameterInfo("attestationNonce", byte[].class);
+ operationalCredentialsattestationRequestCommandParams.put(
+ "attestationNonce",
+ operationalCredentialsattestationRequestattestationNonceCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialsattestationRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .attestationRequest(
+ (ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback)
+ callback,
+ (byte[]) commandArguments.get("attestationNonce"));
+ },
+ () -> new DelegatedAttestationResponseCallback(),
+ operationalCredentialsattestationRequestCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "attestationRequest", operationalCredentialsattestationRequestCommandInfo);
+ Map<String, CommandParameterInfo> operationalCredentialscertificateChainRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialscertificateChainRequestCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials",
+ ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback.class);
+ CommandParameterInfo
+ operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo =
+ new CommandParameterInfo("certificateType", int.class);
+ operationalCredentialscertificateChainRequestCommandParams.put(
+ "certificateType",
+ operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialscertificateChainRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .certificateChainRequest(
+ (ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback)
+ callback,
+ (Integer) commandArguments.get("certificateType"));
+ },
+ () -> new DelegatedCertificateChainResponseCallback(),
+ operationalCredentialscertificateChainRequestCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "certificateChainRequest", operationalCredentialscertificateChainRequestCommandInfo);
+ Map<String, CommandParameterInfo> operationalCredentialsopCSRRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialsopCSRRequestCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials",
+ ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback.class);
+ CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo =
+ new CommandParameterInfo("CSRNonce", byte[].class);
+ operationalCredentialsopCSRRequestCommandParams.put(
+ "CSRNonce", operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialsopCSRRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .opCSRRequest(
+ (ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback,
+ (byte[]) commandArguments.get("CSRNonce"));
+ },
+ () -> new DelegatedOpCSRResponseCallback(),
+ operationalCredentialsopCSRRequestCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "opCSRRequest", operationalCredentialsopCSRRequestCommandInfo);
+ Map<String, CommandParameterInfo> operationalCredentialsremoveFabricCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialsremoveFabricCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials",
+ ChipClusters.OperationalCredentialsCluster.NOCResponseCallback.class);
+ CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo =
+ new CommandParameterInfo("fabricIndex", int.class);
+ operationalCredentialsremoveFabricCommandParams.put(
+ "fabricIndex", operationalCredentialsremoveFabricfabricIndexCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialsremoveFabricCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .removeFabric(
+ (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback,
+ (Integer) commandArguments.get("fabricIndex"));
+ },
+ () -> new DelegatedNOCResponseCallback(),
+ operationalCredentialsremoveFabricCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "removeFabric", operationalCredentialsremoveFabricCommandInfo);
+ Map<String, CommandParameterInfo>
+ operationalCredentialsremoveTrustedRootCertificateCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialsremoveTrustedRootCertificateCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo
+ operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo =
+ new CommandParameterInfo("trustedRootIdentifier", byte[].class);
+ operationalCredentialsremoveTrustedRootCertificateCommandParams.put(
+ "trustedRootIdentifier",
+ operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialsremoveTrustedRootCertificateCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .removeTrustedRootCertificate(
+ (DefaultClusterCallback) callback,
+ (byte[]) commandArguments.get("trustedRootIdentifier"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ operationalCredentialsremoveTrustedRootCertificateCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "removeTrustedRootCertificate",
+ operationalCredentialsremoveTrustedRootCertificateCommandInfo);
+ Map<String, CommandParameterInfo> operationalCredentialsupdateFabricLabelCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialsupdateFabricLabelCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials",
+ ChipClusters.OperationalCredentialsCluster.NOCResponseCallback.class);
+ CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo =
+ new CommandParameterInfo("label", String.class);
+ operationalCredentialsupdateFabricLabelCommandParams.put(
+ "label", operationalCredentialsupdateFabricLabellabelCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialsupdateFabricLabelCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .updateFabricLabel(
+ (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback,
+ (String) commandArguments.get("label"));
+ },
+ () -> new DelegatedNOCResponseCallback(),
+ operationalCredentialsupdateFabricLabelCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "updateFabricLabel", operationalCredentialsupdateFabricLabelCommandInfo);
+ Map<String, CommandParameterInfo> operationalCredentialsupdateNOCCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo operationalCredentialsupdateNOCCommandParameterInfo =
+ new CommandParameterInfo(
+ "OperationalCredentials",
+ ChipClusters.OperationalCredentialsCluster.NOCResponseCallback.class);
+ CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo =
+ new CommandParameterInfo("NOCValue", byte[].class);
+ operationalCredentialsupdateNOCCommandParams.put(
+ "NOCValue", operationalCredentialsupdateNOCNOCValueCommandParameterInfo);
+
+ CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo =
+ new CommandParameterInfo("ICACValue", byte[].class);
+ operationalCredentialsupdateNOCCommandParams.put(
+ "ICACValue", operationalCredentialsupdateNOCICACValueCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo operationalCredentialsupdateNOCCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.OperationalCredentialsCluster) cluster)
+ .updateNOC(
+ (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback,
+ (byte[]) commandArguments.get("NOCValue"),
+ (byte[]) commandArguments.get("ICACValue"));
+ },
+ () -> new DelegatedNOCResponseCallback(),
+ operationalCredentialsupdateNOCCommandParams);
+ operationalCredentialsClusterCommandInfoMap.put(
+ "updateNOC", operationalCredentialsupdateNOCCommandInfo);
+ // Populate cluster
+ ClusterInfo operationalCredentialsClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId),
+ operationalCredentialsClusterCommandInfoMap);
+ clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo);
+ Map<String, CommandInfo> powerSourceClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo powerSourceClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId),
+ powerSourceClusterCommandInfoMap);
+ clusterMap.put("powerSource", powerSourceClusterInfo);
+ Map<String, CommandInfo> pressureMeasurementClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo pressureMeasurementClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId),
+ pressureMeasurementClusterCommandInfoMap);
+ clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo);
+ Map<String, CommandInfo> pumpConfigurationAndControlClusterCommandInfoMap =
+ new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo pumpConfigurationAndControlClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) ->
+ new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId),
+ pumpConfigurationAndControlClusterCommandInfoMap);
+ clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo);
+ Map<String, CommandInfo> relativeHumidityMeasurementClusterCommandInfoMap =
+ new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo relativeHumidityMeasurementClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) ->
+ new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId),
+ relativeHumidityMeasurementClusterCommandInfoMap);
+ clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo);
+ Map<String, CommandInfo> scenesClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> scenesaddSceneCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo scenesaddSceneCommandParameterInfo =
+ new CommandParameterInfo(
+ "Scenes", ChipClusters.ScenesCluster.AddSceneResponseCallback.class);
+ CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ scenesaddSceneCommandParams.put("groupId", scenesaddScenegroupIdCommandParameterInfo);
+
+ CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo =
+ new CommandParameterInfo("sceneId", int.class);
+ scenesaddSceneCommandParams.put("sceneId", scenesaddScenesceneIdCommandParameterInfo);
+
+ CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ scenesaddSceneCommandParams.put(
+ "transitionTime", scenesaddScenetransitionTimeCommandParameterInfo);
+
+ CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo =
+ new CommandParameterInfo("sceneName", String.class);
+ scenesaddSceneCommandParams.put("sceneName", scenesaddScenesceneNameCommandParameterInfo);
+
+ CommandParameterInfo scenesaddSceneclusterIdCommandParameterInfo =
+ new CommandParameterInfo("clusterId", long.class);
+ scenesaddSceneCommandParams.put("clusterId", scenesaddSceneclusterIdCommandParameterInfo);
+
+ CommandParameterInfo scenesaddScenelengthCommandParameterInfo =
+ new CommandParameterInfo("length", int.class);
+ scenesaddSceneCommandParams.put("length", scenesaddScenelengthCommandParameterInfo);
+
+ CommandParameterInfo scenesaddScenevalueCommandParameterInfo =
+ new CommandParameterInfo("value", int.class);
+ scenesaddSceneCommandParams.put("value", scenesaddScenevalueCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo scenesaddSceneCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ScenesCluster) cluster)
+ .addScene(
+ (ChipClusters.ScenesCluster.AddSceneResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"),
+ (Integer) commandArguments.get("sceneId"),
+ (Integer) commandArguments.get("transitionTime"),
+ (String) commandArguments.get("sceneName"),
+ (Long) commandArguments.get("clusterId"),
+ (Integer) commandArguments.get("length"),
+ (Integer) commandArguments.get("value"));
+ },
+ () -> new DelegatedAddSceneResponseCallback(),
+ scenesaddSceneCommandParams);
+ scenesClusterCommandInfoMap.put("addScene", scenesaddSceneCommandInfo);
+ Map<String, CommandParameterInfo> scenesgetSceneMembershipCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo scenesgetSceneMembershipCommandParameterInfo =
+ new CommandParameterInfo(
+ "Scenes", ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback.class);
+ CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ scenesgetSceneMembershipCommandParams.put(
+ "groupId", scenesgetSceneMembershipgroupIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo scenesgetSceneMembershipCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ScenesCluster) cluster)
+ .getSceneMembership(
+ (ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"));
+ },
+ () -> new DelegatedGetSceneMembershipResponseCallback(),
+ scenesgetSceneMembershipCommandParams);
+ scenesClusterCommandInfoMap.put("getSceneMembership", scenesgetSceneMembershipCommandInfo);
+ Map<String, CommandParameterInfo> scenesrecallSceneCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo scenesrecallSceneCommandParameterInfo =
+ new CommandParameterInfo("Scenes", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ scenesrecallSceneCommandParams.put("groupId", scenesrecallScenegroupIdCommandParameterInfo);
+
+ CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo =
+ new CommandParameterInfo("sceneId", int.class);
+ scenesrecallSceneCommandParams.put("sceneId", scenesrecallScenesceneIdCommandParameterInfo);
+
+ CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo =
+ new CommandParameterInfo("transitionTime", int.class);
+ scenesrecallSceneCommandParams.put(
+ "transitionTime", scenesrecallScenetransitionTimeCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo scenesrecallSceneCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ScenesCluster) cluster)
+ .recallScene(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("groupId"),
+ (Integer) commandArguments.get("sceneId"),
+ (Integer) commandArguments.get("transitionTime"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ scenesrecallSceneCommandParams);
+ scenesClusterCommandInfoMap.put("recallScene", scenesrecallSceneCommandInfo);
+ Map<String, CommandParameterInfo> scenesremoveAllScenesCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo scenesremoveAllScenesCommandParameterInfo =
+ new CommandParameterInfo(
+ "Scenes", ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback.class);
+ CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ scenesremoveAllScenesCommandParams.put(
+ "groupId", scenesremoveAllScenesgroupIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo scenesremoveAllScenesCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ScenesCluster) cluster)
+ .removeAllScenes(
+ (ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"));
+ },
+ () -> new DelegatedRemoveAllScenesResponseCallback(),
+ scenesremoveAllScenesCommandParams);
+ scenesClusterCommandInfoMap.put("removeAllScenes", scenesremoveAllScenesCommandInfo);
+ Map<String, CommandParameterInfo> scenesremoveSceneCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo scenesremoveSceneCommandParameterInfo =
+ new CommandParameterInfo(
+ "Scenes", ChipClusters.ScenesCluster.RemoveSceneResponseCallback.class);
+ CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ scenesremoveSceneCommandParams.put("groupId", scenesremoveScenegroupIdCommandParameterInfo);
+
+ CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo =
+ new CommandParameterInfo("sceneId", int.class);
+ scenesremoveSceneCommandParams.put("sceneId", scenesremoveScenesceneIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo scenesremoveSceneCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ScenesCluster) cluster)
+ .removeScene(
+ (ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"),
+ (Integer) commandArguments.get("sceneId"));
+ },
+ () -> new DelegatedRemoveSceneResponseCallback(),
+ scenesremoveSceneCommandParams);
+ scenesClusterCommandInfoMap.put("removeScene", scenesremoveSceneCommandInfo);
+ Map<String, CommandParameterInfo> scenesstoreSceneCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo scenesstoreSceneCommandParameterInfo =
+ new CommandParameterInfo(
+ "Scenes", ChipClusters.ScenesCluster.StoreSceneResponseCallback.class);
+ CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ scenesstoreSceneCommandParams.put("groupId", scenesstoreScenegroupIdCommandParameterInfo);
+
+ CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo =
+ new CommandParameterInfo("sceneId", int.class);
+ scenesstoreSceneCommandParams.put("sceneId", scenesstoreScenesceneIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo scenesstoreSceneCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ScenesCluster) cluster)
+ .storeScene(
+ (ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"),
+ (Integer) commandArguments.get("sceneId"));
+ },
+ () -> new DelegatedStoreSceneResponseCallback(),
+ scenesstoreSceneCommandParams);
+ scenesClusterCommandInfoMap.put("storeScene", scenesstoreSceneCommandInfo);
+ Map<String, CommandParameterInfo> scenesviewSceneCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo scenesviewSceneCommandParameterInfo =
+ new CommandParameterInfo(
+ "Scenes", ChipClusters.ScenesCluster.ViewSceneResponseCallback.class);
+ CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo =
+ new CommandParameterInfo("groupId", int.class);
+ scenesviewSceneCommandParams.put("groupId", scenesviewScenegroupIdCommandParameterInfo);
+
+ CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo =
+ new CommandParameterInfo("sceneId", int.class);
+ scenesviewSceneCommandParams.put("sceneId", scenesviewScenesceneIdCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo scenesviewSceneCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ScenesCluster) cluster)
+ .viewScene(
+ (ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback,
+ (Integer) commandArguments.get("groupId"),
+ (Integer) commandArguments.get("sceneId"));
+ },
+ () -> new DelegatedViewSceneResponseCallback(),
+ scenesviewSceneCommandParams);
+ scenesClusterCommandInfoMap.put("viewScene", scenesviewSceneCommandInfo);
+ // Populate cluster
+ ClusterInfo scenesClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId),
+ scenesClusterCommandInfoMap);
+ clusterMap.put("scenes", scenesClusterInfo);
+ Map<String, CommandInfo> softwareDiagnosticsClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> softwareDiagnosticsresetWatermarksCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo softwareDiagnosticsresetWatermarksCommandParameterInfo =
+ new CommandParameterInfo("SoftwareDiagnostics", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo softwareDiagnosticsresetWatermarksCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.SoftwareDiagnosticsCluster) cluster)
+ .resetWatermarks((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ softwareDiagnosticsresetWatermarksCommandParams);
+ softwareDiagnosticsClusterCommandInfoMap.put(
+ "resetWatermarks", softwareDiagnosticsresetWatermarksCommandInfo);
+ // Populate cluster
+ ClusterInfo softwareDiagnosticsClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId),
+ softwareDiagnosticsClusterCommandInfoMap);
+ clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo);
+ Map<String, CommandInfo> switchClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo switchClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId),
+ switchClusterCommandInfoMap);
+ clusterMap.put("switch", switchClusterInfo);
+ Map<String, CommandInfo> tvChannelClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> tvChannelchangeChannelCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo tvChannelchangeChannelCommandParameterInfo =
+ new CommandParameterInfo(
+ "TvChannel", ChipClusters.TvChannelCluster.ChangeChannelResponseCallback.class);
+ CommandParameterInfo tvChannelchangeChannelmatchCommandParameterInfo =
+ new CommandParameterInfo("match", String.class);
+ tvChannelchangeChannelCommandParams.put(
+ "match", tvChannelchangeChannelmatchCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo tvChannelchangeChannelCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TvChannelCluster) cluster)
+ .changeChannel(
+ (ChipClusters.TvChannelCluster.ChangeChannelResponseCallback) callback,
+ (String) commandArguments.get("match"));
+ },
+ () -> new DelegatedChangeChannelResponseCallback(),
+ tvChannelchangeChannelCommandParams);
+ tvChannelClusterCommandInfoMap.put("changeChannel", tvChannelchangeChannelCommandInfo);
+ Map<String, CommandParameterInfo> tvChannelchangeChannelByNumberCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo tvChannelchangeChannelByNumberCommandParameterInfo =
+ new CommandParameterInfo("TvChannel", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo tvChannelchangeChannelByNumbermajorNumberCommandParameterInfo =
+ new CommandParameterInfo("majorNumber", int.class);
+ tvChannelchangeChannelByNumberCommandParams.put(
+ "majorNumber", tvChannelchangeChannelByNumbermajorNumberCommandParameterInfo);
+
+ CommandParameterInfo tvChannelchangeChannelByNumberminorNumberCommandParameterInfo =
+ new CommandParameterInfo("minorNumber", int.class);
+ tvChannelchangeChannelByNumberCommandParams.put(
+ "minorNumber", tvChannelchangeChannelByNumberminorNumberCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo tvChannelchangeChannelByNumberCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TvChannelCluster) cluster)
+ .changeChannelByNumber(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("majorNumber"),
+ (Integer) commandArguments.get("minorNumber"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ tvChannelchangeChannelByNumberCommandParams);
+ tvChannelClusterCommandInfoMap.put(
+ "changeChannelByNumber", tvChannelchangeChannelByNumberCommandInfo);
+ Map<String, CommandParameterInfo> tvChannelskipChannelCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo tvChannelskipChannelCommandParameterInfo =
+ new CommandParameterInfo("TvChannel", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo tvChannelskipChannelcountCommandParameterInfo =
+ new CommandParameterInfo("count", int.class);
+ tvChannelskipChannelCommandParams.put("count", tvChannelskipChannelcountCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo tvChannelskipChannelCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TvChannelCluster) cluster)
+ .skipChannel(
+ (DefaultClusterCallback) callback, (Integer) commandArguments.get("count"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ tvChannelskipChannelCommandParams);
+ tvChannelClusterCommandInfoMap.put("skipChannel", tvChannelskipChannelCommandInfo);
+ // Populate cluster
+ ClusterInfo tvChannelClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.TvChannelCluster(ptr, endpointId),
+ tvChannelClusterCommandInfoMap);
+ clusterMap.put("tvChannel", tvChannelClusterInfo);
+ Map<String, CommandInfo> targetNavigatorClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> targetNavigatornavigateTargetCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo targetNavigatornavigateTargetCommandParameterInfo =
+ new CommandParameterInfo(
+ "TargetNavigator",
+ ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback.class);
+ CommandParameterInfo targetNavigatornavigateTargettargetCommandParameterInfo =
+ new CommandParameterInfo("target", int.class);
+ targetNavigatornavigateTargetCommandParams.put(
+ "target", targetNavigatornavigateTargettargetCommandParameterInfo);
+
+ CommandParameterInfo targetNavigatornavigateTargetdataCommandParameterInfo =
+ new CommandParameterInfo("data", String.class);
+ targetNavigatornavigateTargetCommandParams.put(
+ "data", targetNavigatornavigateTargetdataCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo targetNavigatornavigateTargetCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TargetNavigatorCluster) cluster)
+ .navigateTarget(
+ (ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback,
+ (Integer) commandArguments.get("target"),
+ (String) commandArguments.get("data"));
+ },
+ () -> new DelegatedNavigateTargetResponseCallback(),
+ targetNavigatornavigateTargetCommandParams);
+ targetNavigatorClusterCommandInfoMap.put(
+ "navigateTarget", targetNavigatornavigateTargetCommandInfo);
+ // Populate cluster
+ ClusterInfo targetNavigatorClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId),
+ targetNavigatorClusterCommandInfoMap);
+ clusterMap.put("targetNavigator", targetNavigatorClusterInfo);
+ Map<String, CommandInfo> temperatureMeasurementClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo temperatureMeasurementClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId),
+ temperatureMeasurementClusterCommandInfoMap);
+ clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo);
+ Map<String, CommandInfo> testClusterClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> testClustertestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestCommandParameterInfo =
+ new CommandParameterInfo("TestCluster", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo testClustertestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster).test((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ testClustertestCommandParams);
+ testClusterClusterCommandInfoMap.put("test", testClustertestCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestAddArgumentsCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestAddArgumentsCommandParameterInfo =
+ new CommandParameterInfo(
+ "TestCluster", ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback.class);
+ CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo =
+ new CommandParameterInfo("arg1", int.class);
+ testClustertestAddArgumentsCommandParams.put(
+ "arg1", testClustertestAddArgumentsarg1CommandParameterInfo);
+
+ CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo =
+ new CommandParameterInfo("arg2", int.class);
+ testClustertestAddArgumentsCommandParams.put(
+ "arg2", testClustertestAddArgumentsarg2CommandParameterInfo);
+
+ // Populate commands
+ CommandInfo testClustertestAddArgumentsCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testAddArguments(
+ (ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback,
+ (Integer) commandArguments.get("arg1"),
+ (Integer) commandArguments.get("arg2"));
+ },
+ () -> new DelegatedTestAddArgumentsResponseCallback(),
+ testClustertestAddArgumentsCommandParams);
+ testClusterClusterCommandInfoMap.put(
+ "testAddArguments", testClustertestAddArgumentsCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestEnumsRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestEnumsRequestCommandParameterInfo =
+ new CommandParameterInfo(
+ "TestCluster", ChipClusters.TestClusterCluster.TestEnumsResponseCallback.class);
+ CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo =
+ new CommandParameterInfo("arg1", int.class);
+ testClustertestEnumsRequestCommandParams.put(
+ "arg1", testClustertestEnumsRequestarg1CommandParameterInfo);
+
+ CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo =
+ new CommandParameterInfo("arg2", int.class);
+ testClustertestEnumsRequestCommandParams.put(
+ "arg2", testClustertestEnumsRequestarg2CommandParameterInfo);
+
+ // Populate commands
+ CommandInfo testClustertestEnumsRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testEnumsRequest(
+ (ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback,
+ (Integer) commandArguments.get("arg1"),
+ (Integer) commandArguments.get("arg2"));
+ },
+ () -> new DelegatedTestEnumsResponseCallback(),
+ testClustertestEnumsRequestCommandParams);
+ testClusterClusterCommandInfoMap.put(
+ "testEnumsRequest", testClustertestEnumsRequestCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestListInt8UArgumentRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestListInt8UArgumentRequestCommandParameterInfo =
+ new CommandParameterInfo("TestCluster", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo =
+ new CommandParameterInfo("arg1", int.class);
+ testClustertestListInt8UArgumentRequestCommandParams.put(
+ "arg1", testClustertestListInt8UArgumentRequestarg1CommandParameterInfo);
+
+ // Populate commands
+ CommandInfo testClustertestListInt8UArgumentRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testListInt8UArgumentRequest(
+ (DefaultClusterCallback) callback, (Integer) commandArguments.get("arg1"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ testClustertestListInt8UArgumentRequestCommandParams);
+ testClusterClusterCommandInfoMap.put(
+ "testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestListInt8UReverseRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestListInt8UReverseRequestCommandParameterInfo =
+ new CommandParameterInfo(
+ "TestCluster",
+ ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback.class);
+ CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo =
+ new CommandParameterInfo("arg1", int.class);
+ testClustertestListInt8UReverseRequestCommandParams.put(
+ "arg1", testClustertestListInt8UReverseRequestarg1CommandParameterInfo);
+
+ // Populate commands
+ CommandInfo testClustertestListInt8UReverseRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testListInt8UReverseRequest(
+ (ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback)
+ callback,
+ (Integer) commandArguments.get("arg1"));
+ },
+ () -> new DelegatedTestListInt8UReverseResponseCallback(),
+ testClustertestListInt8UReverseRequestCommandParams);
+ testClusterClusterCommandInfoMap.put(
+ "testListInt8UReverseRequest", testClustertestListInt8UReverseRequestCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestListStructArgumentRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestListStructArgumentRequestCommandParameterInfo =
+ new CommandParameterInfo("TestCluster", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo testClustertestListStructArgumentRequestaCommandParameterInfo =
+ new CommandParameterInfo("a", int.class);
+ testClustertestListStructArgumentRequestCommandParams.put(
+ "a", testClustertestListStructArgumentRequestaCommandParameterInfo);
+
+ CommandParameterInfo testClustertestListStructArgumentRequestbCommandParameterInfo =
+ new CommandParameterInfo("b", boolean.class);
+ testClustertestListStructArgumentRequestCommandParams.put(
+ "b", testClustertestListStructArgumentRequestbCommandParameterInfo);
+
+ CommandParameterInfo testClustertestListStructArgumentRequestcCommandParameterInfo =
+ new CommandParameterInfo("c", int.class);
+ testClustertestListStructArgumentRequestCommandParams.put(
+ "c", testClustertestListStructArgumentRequestcCommandParameterInfo);
+
+ CommandParameterInfo testClustertestListStructArgumentRequestdCommandParameterInfo =
+ new CommandParameterInfo("d", byte[].class);
+ testClustertestListStructArgumentRequestCommandParams.put(
+ "d", testClustertestListStructArgumentRequestdCommandParameterInfo);
+
+ CommandParameterInfo testClustertestListStructArgumentRequesteCommandParameterInfo =
+ new CommandParameterInfo("e", String.class);
+ testClustertestListStructArgumentRequestCommandParams.put(
+ "e", testClustertestListStructArgumentRequesteCommandParameterInfo);
+
+ CommandParameterInfo testClustertestListStructArgumentRequestfCommandParameterInfo =
+ new CommandParameterInfo("f", int.class);
+ testClustertestListStructArgumentRequestCommandParams.put(
+ "f", testClustertestListStructArgumentRequestfCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo testClustertestListStructArgumentRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testListStructArgumentRequest(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("a"),
+ (Boolean) commandArguments.get("b"),
+ (Integer) commandArguments.get("c"),
+ (byte[]) commandArguments.get("d"),
+ (String) commandArguments.get("e"),
+ (Integer) commandArguments.get("f"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ testClustertestListStructArgumentRequestCommandParams);
+ testClusterClusterCommandInfoMap.put(
+ "testListStructArgumentRequest", testClustertestListStructArgumentRequestCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestNotHandledCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestNotHandledCommandParameterInfo =
+ new CommandParameterInfo("TestCluster", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo testClustertestNotHandledCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testNotHandled((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ testClustertestNotHandledCommandParams);
+ testClusterClusterCommandInfoMap.put("testNotHandled", testClustertestNotHandledCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestNullableOptionalRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestNullableOptionalRequestCommandParameterInfo =
+ new CommandParameterInfo(
+ "TestCluster",
+ ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback.class);
+ CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo =
+ new CommandParameterInfo("arg1", int.class);
+ testClustertestNullableOptionalRequestCommandParams.put(
+ "arg1", testClustertestNullableOptionalRequestarg1CommandParameterInfo);
+
+ // Populate commands
+ CommandInfo testClustertestNullableOptionalRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testNullableOptionalRequest(
+ (ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback)
+ callback,
+ (Integer) commandArguments.get("arg1"));
+ },
+ () -> new DelegatedTestNullableOptionalResponseCallback(),
+ testClustertestNullableOptionalRequestCommandParams);
+ testClusterClusterCommandInfoMap.put(
+ "testNullableOptionalRequest", testClustertestNullableOptionalRequestCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestSpecificCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestSpecificCommandParameterInfo =
+ new CommandParameterInfo(
+ "TestCluster", ChipClusters.TestClusterCluster.TestSpecificResponseCallback.class);
+ // Populate commands
+ CommandInfo testClustertestSpecificCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testSpecific(
+ (ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback);
+ },
+ () -> new DelegatedTestSpecificResponseCallback(),
+ testClustertestSpecificCommandParams);
+ testClusterClusterCommandInfoMap.put("testSpecific", testClustertestSpecificCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestStructArgumentRequestCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestStructArgumentRequestCommandParameterInfo =
+ new CommandParameterInfo("TestCluster", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo testClustertestStructArgumentRequestaCommandParameterInfo =
+ new CommandParameterInfo("a", int.class);
+ testClustertestStructArgumentRequestCommandParams.put(
+ "a", testClustertestStructArgumentRequestaCommandParameterInfo);
+
+ CommandParameterInfo testClustertestStructArgumentRequestbCommandParameterInfo =
+ new CommandParameterInfo("b", boolean.class);
+ testClustertestStructArgumentRequestCommandParams.put(
+ "b", testClustertestStructArgumentRequestbCommandParameterInfo);
+
+ CommandParameterInfo testClustertestStructArgumentRequestcCommandParameterInfo =
+ new CommandParameterInfo("c", int.class);
+ testClustertestStructArgumentRequestCommandParams.put(
+ "c", testClustertestStructArgumentRequestcCommandParameterInfo);
+
+ CommandParameterInfo testClustertestStructArgumentRequestdCommandParameterInfo =
+ new CommandParameterInfo("d", byte[].class);
+ testClustertestStructArgumentRequestCommandParams.put(
+ "d", testClustertestStructArgumentRequestdCommandParameterInfo);
+
+ CommandParameterInfo testClustertestStructArgumentRequesteCommandParameterInfo =
+ new CommandParameterInfo("e", String.class);
+ testClustertestStructArgumentRequestCommandParams.put(
+ "e", testClustertestStructArgumentRequesteCommandParameterInfo);
+
+ CommandParameterInfo testClustertestStructArgumentRequestfCommandParameterInfo =
+ new CommandParameterInfo("f", int.class);
+ testClustertestStructArgumentRequestCommandParams.put(
+ "f", testClustertestStructArgumentRequestfCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo testClustertestStructArgumentRequestCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testStructArgumentRequest(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("a"),
+ (Boolean) commandArguments.get("b"),
+ (Integer) commandArguments.get("c"),
+ (byte[]) commandArguments.get("d"),
+ (String) commandArguments.get("e"),
+ (Integer) commandArguments.get("f"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ testClustertestStructArgumentRequestCommandParams);
+ testClusterClusterCommandInfoMap.put(
+ "testStructArgumentRequest", testClustertestStructArgumentRequestCommandInfo);
+ Map<String, CommandParameterInfo> testClustertestUnknownCommandCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo testClustertestUnknownCommandCommandParameterInfo =
+ new CommandParameterInfo("TestCluster", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo testClustertestUnknownCommandCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.TestClusterCluster) cluster)
+ .testUnknownCommand((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ testClustertestUnknownCommandCommandParams);
+ testClusterClusterCommandInfoMap.put(
+ "testUnknownCommand", testClustertestUnknownCommandCommandInfo);
+ // Populate cluster
+ ClusterInfo testClusterClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId),
+ testClusterClusterCommandInfoMap);
+ clusterMap.put("testCluster", testClusterClusterInfo);
+ Map<String, CommandInfo> thermostatClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> thermostatclearWeeklyScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo thermostatclearWeeklyScheduleCommandParameterInfo =
+ new CommandParameterInfo("Thermostat", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo thermostatclearWeeklyScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ThermostatCluster) cluster)
+ .clearWeeklySchedule((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ thermostatclearWeeklyScheduleCommandParams);
+ thermostatClusterCommandInfoMap.put(
+ "clearWeeklySchedule", thermostatclearWeeklyScheduleCommandInfo);
+ Map<String, CommandParameterInfo> thermostatgetRelayStatusLogCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo thermostatgetRelayStatusLogCommandParameterInfo =
+ new CommandParameterInfo("Thermostat", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo thermostatgetRelayStatusLogCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ThermostatCluster) cluster)
+ .getRelayStatusLog((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ thermostatgetRelayStatusLogCommandParams);
+ thermostatClusterCommandInfoMap.put(
+ "getRelayStatusLog", thermostatgetRelayStatusLogCommandInfo);
+ Map<String, CommandParameterInfo> thermostatgetWeeklyScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo thermostatgetWeeklyScheduleCommandParameterInfo =
+ new CommandParameterInfo("Thermostat", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo =
+ new CommandParameterInfo("daysToReturn", int.class);
+ thermostatgetWeeklyScheduleCommandParams.put(
+ "daysToReturn", thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo);
+
+ CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo =
+ new CommandParameterInfo("modeToReturn", int.class);
+ thermostatgetWeeklyScheduleCommandParams.put(
+ "modeToReturn", thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo thermostatgetWeeklyScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ThermostatCluster) cluster)
+ .getWeeklySchedule(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("daysToReturn"),
+ (Integer) commandArguments.get("modeToReturn"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ thermostatgetWeeklyScheduleCommandParams);
+ thermostatClusterCommandInfoMap.put(
+ "getWeeklySchedule", thermostatgetWeeklyScheduleCommandInfo);
+ Map<String, CommandParameterInfo> thermostatsetWeeklyScheduleCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo thermostatsetWeeklyScheduleCommandParameterInfo =
+ new CommandParameterInfo("Thermostat", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo
+ thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo =
+ new CommandParameterInfo("numberOfTransitionsForSequence", int.class);
+ thermostatsetWeeklyScheduleCommandParams.put(
+ "numberOfTransitionsForSequence",
+ thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo);
+
+ CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo =
+ new CommandParameterInfo("dayOfWeekForSequence", int.class);
+ thermostatsetWeeklyScheduleCommandParams.put(
+ "dayOfWeekForSequence",
+ thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo);
+
+ CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo =
+ new CommandParameterInfo("modeForSequence", int.class);
+ thermostatsetWeeklyScheduleCommandParams.put(
+ "modeForSequence", thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo);
+
+ CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo =
+ new CommandParameterInfo("payload", int.class);
+ thermostatsetWeeklyScheduleCommandParams.put(
+ "payload", thermostatsetWeeklySchedulepayloadCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo thermostatsetWeeklyScheduleCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ThermostatCluster) cluster)
+ .setWeeklySchedule(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("numberOfTransitionsForSequence"),
+ (Integer) commandArguments.get("dayOfWeekForSequence"),
+ (Integer) commandArguments.get("modeForSequence"),
+ (Integer) commandArguments.get("payload"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ thermostatsetWeeklyScheduleCommandParams);
+ thermostatClusterCommandInfoMap.put(
+ "setWeeklySchedule", thermostatsetWeeklyScheduleCommandInfo);
+ Map<String, CommandParameterInfo> thermostatsetpointRaiseLowerCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo thermostatsetpointRaiseLowerCommandParameterInfo =
+ new CommandParameterInfo("Thermostat", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo =
+ new CommandParameterInfo("mode", int.class);
+ thermostatsetpointRaiseLowerCommandParams.put(
+ "mode", thermostatsetpointRaiseLowermodeCommandParameterInfo);
+
+ CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo =
+ new CommandParameterInfo("amount", int.class);
+ thermostatsetpointRaiseLowerCommandParams.put(
+ "amount", thermostatsetpointRaiseLoweramountCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo thermostatsetpointRaiseLowerCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ThermostatCluster) cluster)
+ .setpointRaiseLower(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("mode"),
+ (Integer) commandArguments.get("amount"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ thermostatsetpointRaiseLowerCommandParams);
+ thermostatClusterCommandInfoMap.put(
+ "setpointRaiseLower", thermostatsetpointRaiseLowerCommandInfo);
+ // Populate cluster
+ ClusterInfo thermostatClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId),
+ thermostatClusterCommandInfoMap);
+ clusterMap.put("thermostat", thermostatClusterInfo);
+ Map<String, CommandInfo> thermostatUserInterfaceConfigurationClusterCommandInfoMap =
+ new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo thermostatUserInterfaceConfigurationClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) ->
+ new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId),
+ thermostatUserInterfaceConfigurationClusterCommandInfoMap);
+ clusterMap.put(
+ "thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo);
+ Map<String, CommandInfo> threadNetworkDiagnosticsClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> threadNetworkDiagnosticsresetCountsCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo threadNetworkDiagnosticsresetCountsCommandParameterInfo =
+ new CommandParameterInfo(
+ "ThreadNetworkDiagnostics", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo threadNetworkDiagnosticsresetCountsCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster)
+ .resetCounts((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ threadNetworkDiagnosticsresetCountsCommandParams);
+ threadNetworkDiagnosticsClusterCommandInfoMap.put(
+ "resetCounts", threadNetworkDiagnosticsresetCountsCommandInfo);
+ // Populate cluster
+ ClusterInfo threadNetworkDiagnosticsClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId),
+ threadNetworkDiagnosticsClusterCommandInfoMap);
+ clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo);
+ Map<String, CommandInfo> wakeOnLanClusterCommandInfoMap = new LinkedHashMap<>();
+ // Populate cluster
+ ClusterInfo wakeOnLanClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId),
+ wakeOnLanClusterCommandInfoMap);
+ clusterMap.put("wakeOnLan", wakeOnLanClusterInfo);
+ Map<String, CommandInfo> wiFiNetworkDiagnosticsClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> wiFiNetworkDiagnosticsresetCountsCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo wiFiNetworkDiagnosticsresetCountsCommandParameterInfo =
+ new CommandParameterInfo(
+ "WiFiNetworkDiagnostics", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo wiFiNetworkDiagnosticsresetCountsCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster)
+ .resetCounts((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ wiFiNetworkDiagnosticsresetCountsCommandParams);
+ wiFiNetworkDiagnosticsClusterCommandInfoMap.put(
+ "resetCounts", wiFiNetworkDiagnosticsresetCountsCommandInfo);
+ // Populate cluster
+ ClusterInfo wiFiNetworkDiagnosticsClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId),
+ wiFiNetworkDiagnosticsClusterCommandInfoMap);
+ clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo);
+ Map<String, CommandInfo> windowCoveringClusterCommandInfoMap = new LinkedHashMap<>();
+ Map<String, CommandParameterInfo> windowCoveringdownOrCloseCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo windowCoveringdownOrCloseCommandParameterInfo =
+ new CommandParameterInfo("WindowCovering", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo windowCoveringdownOrCloseCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.WindowCoveringCluster) cluster)
+ .downOrClose((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ windowCoveringdownOrCloseCommandParams);
+ windowCoveringClusterCommandInfoMap.put("downOrClose", windowCoveringdownOrCloseCommandInfo);
+ Map<String, CommandParameterInfo> windowCoveringgoToLiftPercentageCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo windowCoveringgoToLiftPercentageCommandParameterInfo =
+ new CommandParameterInfo("WindowCovering", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo =
+ new CommandParameterInfo("liftPercentageValue", int.class);
+ windowCoveringgoToLiftPercentageCommandParams.put(
+ "liftPercentageValue",
+ windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo);
+
+ CommandParameterInfo
+ windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo =
+ new CommandParameterInfo("liftPercent100thsValue", int.class);
+ windowCoveringgoToLiftPercentageCommandParams.put(
+ "liftPercent100thsValue",
+ windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo windowCoveringgoToLiftPercentageCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.WindowCoveringCluster) cluster)
+ .goToLiftPercentage(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("liftPercentageValue"),
+ (Integer) commandArguments.get("liftPercent100thsValue"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ windowCoveringgoToLiftPercentageCommandParams);
+ windowCoveringClusterCommandInfoMap.put(
+ "goToLiftPercentage", windowCoveringgoToLiftPercentageCommandInfo);
+ Map<String, CommandParameterInfo> windowCoveringgoToLiftValueCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo windowCoveringgoToLiftValueCommandParameterInfo =
+ new CommandParameterInfo("WindowCovering", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo =
+ new CommandParameterInfo("liftValue", int.class);
+ windowCoveringgoToLiftValueCommandParams.put(
+ "liftValue", windowCoveringgoToLiftValueliftValueCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo windowCoveringgoToLiftValueCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.WindowCoveringCluster) cluster)
+ .goToLiftValue(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("liftValue"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ windowCoveringgoToLiftValueCommandParams);
+ windowCoveringClusterCommandInfoMap.put(
+ "goToLiftValue", windowCoveringgoToLiftValueCommandInfo);
+ Map<String, CommandParameterInfo> windowCoveringgoToTiltPercentageCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo windowCoveringgoToTiltPercentageCommandParameterInfo =
+ new CommandParameterInfo("WindowCovering", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo =
+ new CommandParameterInfo("tiltPercentageValue", int.class);
+ windowCoveringgoToTiltPercentageCommandParams.put(
+ "tiltPercentageValue",
+ windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo);
+
+ CommandParameterInfo
+ windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo =
+ new CommandParameterInfo("tiltPercent100thsValue", int.class);
+ windowCoveringgoToTiltPercentageCommandParams.put(
+ "tiltPercent100thsValue",
+ windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo windowCoveringgoToTiltPercentageCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.WindowCoveringCluster) cluster)
+ .goToTiltPercentage(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("tiltPercentageValue"),
+ (Integer) commandArguments.get("tiltPercent100thsValue"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ windowCoveringgoToTiltPercentageCommandParams);
+ windowCoveringClusterCommandInfoMap.put(
+ "goToTiltPercentage", windowCoveringgoToTiltPercentageCommandInfo);
+ Map<String, CommandParameterInfo> windowCoveringgoToTiltValueCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo windowCoveringgoToTiltValueCommandParameterInfo =
+ new CommandParameterInfo("WindowCovering", ChipClusters.DefaultClusterCallback.class);
+ CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo =
+ new CommandParameterInfo("tiltValue", int.class);
+ windowCoveringgoToTiltValueCommandParams.put(
+ "tiltValue", windowCoveringgoToTiltValuetiltValueCommandParameterInfo);
+
+ // Populate commands
+ CommandInfo windowCoveringgoToTiltValueCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.WindowCoveringCluster) cluster)
+ .goToTiltValue(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("tiltValue"));
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ windowCoveringgoToTiltValueCommandParams);
+ windowCoveringClusterCommandInfoMap.put(
+ "goToTiltValue", windowCoveringgoToTiltValueCommandInfo);
+ Map<String, CommandParameterInfo> windowCoveringstopMotionCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo windowCoveringstopMotionCommandParameterInfo =
+ new CommandParameterInfo("WindowCovering", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo windowCoveringstopMotionCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.WindowCoveringCluster) cluster)
+ .stopMotion((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ windowCoveringstopMotionCommandParams);
+ windowCoveringClusterCommandInfoMap.put("stopMotion", windowCoveringstopMotionCommandInfo);
+ Map<String, CommandParameterInfo> windowCoveringupOrOpenCommandParams =
+ new LinkedHashMap<String, CommandParameterInfo>();
+ // TODO: fill out parameter types
+ CommandParameterInfo windowCoveringupOrOpenCommandParameterInfo =
+ new CommandParameterInfo("WindowCovering", ChipClusters.DefaultClusterCallback.class);
+ // Populate commands
+ CommandInfo windowCoveringupOrOpenCommandInfo =
+ new CommandInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.WindowCoveringCluster) cluster)
+ .upOrOpen((DefaultClusterCallback) callback);
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ windowCoveringupOrOpenCommandParams);
+ windowCoveringClusterCommandInfoMap.put("upOrOpen", windowCoveringupOrOpenCommandInfo);
+ // Populate cluster
+ ClusterInfo windowCoveringClusterInfo =
+ new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId),
+ windowCoveringClusterCommandInfoMap);
+ clusterMap.put("windowCovering", windowCoveringClusterInfo);
+ return clusterMap;
+ }
+}
