diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap
index 4a1597875a8ae3..3765a101fb2152 100644
--- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap
+++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap
@@ -12624,6 +12624,126 @@
}
],
"attributes": [
+ {
+ "name": "playback state",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "start time",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0xFF",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "duration",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "position updated at",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "position",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "playback speed",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "seek range end",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "seek range start",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
{
"name": "ClusterRevision",
"code": 65533,
@@ -17387,5 +17507,6 @@
"endpointVersion": null,
"deviceIdentifier": null
}
- ]
+ ],
+ "log": []
}
\ No newline at end of file
diff --git a/src/app/zap-templates/zcl/data-model/chip/media-playback-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/media-playback-cluster.xml
index 69431a2aad3cad..6aea0f08912c19 100644
--- a/src/app/zap-templates/zcl/data-model/chip/media-playback-cluster.xml
+++ b/src/app/zap-templates/zcl/data-model/chip/media-playback-cluster.xml
@@ -29,8 +29,8 @@ limitations under the License.
playback state
start time
duration
- updated at
- posistion
+ position updated at
+ position
playback speed
seek range end
diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap
index c2aa6222b8bcf1..5a3f06c47b1ca1 100644
--- a/src/controller/data_model/controller-clusters.zap
+++ b/src/controller/data_model/controller-clusters.zap
@@ -8344,6 +8344,126 @@
}
],
"attributes": [
+ {
+ "name": "playback state",
+ "code": 0,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0x00",
+ "reportable": 0,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "start time",
+ "code": 1,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0xFF",
+ "reportable": 0,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "duration",
+ "code": 2,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "position updated at",
+ "code": 3,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "position",
+ "code": 4,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "playback speed",
+ "code": 5,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "seek range end",
+ "code": 6,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
+ {
+ "name": "seek range start",
+ "code": 7,
+ "mfgCode": null,
+ "side": "server",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "",
+ "reportable": 0,
+ "minInterval": 0,
+ "maxInterval": 65344,
+ "reportableChange": 0
+ },
{
"name": "ClusterRevision",
"code": 65533,
diff --git a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
index 0f49163c27a565..04dd42e61341db 100644
--- a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
+++ b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp
@@ -19667,6 +19667,303 @@ JNI_METHOD(void, MediaPlaybackCluster, mediaStop)(JNIEnv * env, jobject self, jl
}
}
+JNI_METHOD(void, MediaPlaybackCluster, readPlaybackStateAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt8uAttributeCallback * onSuccess = new CHIPInt8uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ MediaPlaybackCluster * cppCluster = reinterpret_cast(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributePlaybackState(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, MediaPlaybackCluster, readStartTimeAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ MediaPlaybackCluster * cppCluster = reinterpret_cast(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeStartTime(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, MediaPlaybackCluster, readDurationAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ MediaPlaybackCluster * cppCluster = reinterpret_cast(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeDuration(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, MediaPlaybackCluster, readPositionUpdatedAtAttribute)
+(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ MediaPlaybackCluster * cppCluster = reinterpret_cast(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributePositionUpdatedAt(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, MediaPlaybackCluster, readPositionAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ MediaPlaybackCluster * cppCluster = reinterpret_cast(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributePosition(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, MediaPlaybackCluster, readPlaybackSpeedAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ MediaPlaybackCluster * cppCluster = reinterpret_cast(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributePlaybackSpeed(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, MediaPlaybackCluster, readSeekRangeEndAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ MediaPlaybackCluster * cppCluster = reinterpret_cast(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeSeekRangeEnd(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
+JNI_METHOD(void, MediaPlaybackCluster, readSeekRangeStartAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
+{
+ StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
+ CHIPInt64uAttributeCallback * onSuccess = new CHIPInt64uAttributeCallback(callback);
+ if (!onSuccess)
+ {
+ ReturnIllegalStateException(env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIPDefaultFailureCallback * onFailure = new CHIPDefaultFailureCallback(callback);
+ if (!onFailure)
+ {
+ delete onSuccess;
+ ReturnIllegalStateException(env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY.AsInteger());
+ return;
+ }
+
+ CHIP_ERROR err = CHIP_NO_ERROR;
+ MediaPlaybackCluster * cppCluster = reinterpret_cast(clusterPtr);
+ if (cppCluster == nullptr)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE.AsInteger());
+ return;
+ }
+
+ err = cppCluster->ReadAttributeSeekRangeStart(onSuccess->Cancel(), onFailure->Cancel());
+ if (err != CHIP_NO_ERROR)
+ {
+ delete onSuccess;
+ delete onFailure;
+ ReturnIllegalStateException(env, callback, "Error reading attribute", err.AsInteger());
+ }
+}
+
JNI_METHOD(void, MediaPlaybackCluster, readClusterRevisionAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback)
{
StackLockGuard lock(JniReferences::GetInstance().GetStackLock());
diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
index 035cae7d460e7a..7df03039e0cdfe 100644
--- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
+++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java
@@ -3331,10 +3331,63 @@ public interface MediaStopResponseCallback {
void onError(Exception error);
}
+ public void readPlaybackStateAttribute(IntegerAttributeCallback callback) {
+ readPlaybackStateAttribute(chipClusterPtr, callback);
+ }
+
+ public void readStartTimeAttribute(LongAttributeCallback callback) {
+ readStartTimeAttribute(chipClusterPtr, callback);
+ }
+
+ public void readDurationAttribute(LongAttributeCallback callback) {
+ readDurationAttribute(chipClusterPtr, callback);
+ }
+
+ public void readPositionUpdatedAtAttribute(LongAttributeCallback callback) {
+ readPositionUpdatedAtAttribute(chipClusterPtr, callback);
+ }
+
+ public void readPositionAttribute(LongAttributeCallback callback) {
+ readPositionAttribute(chipClusterPtr, callback);
+ }
+
+ public void readPlaybackSpeedAttribute(LongAttributeCallback callback) {
+ readPlaybackSpeedAttribute(chipClusterPtr, callback);
+ }
+
+ public void readSeekRangeEndAttribute(LongAttributeCallback callback) {
+ readSeekRangeEndAttribute(chipClusterPtr, callback);
+ }
+
+ public void readSeekRangeStartAttribute(LongAttributeCallback callback) {
+ readSeekRangeStartAttribute(chipClusterPtr, callback);
+ }
+
public void readClusterRevisionAttribute(IntegerAttributeCallback callback) {
readClusterRevisionAttribute(chipClusterPtr, callback);
}
+ private native void readPlaybackStateAttribute(
+ long chipClusterPtr, IntegerAttributeCallback callback);
+
+ private native void readStartTimeAttribute(long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readDurationAttribute(long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readPositionUpdatedAtAttribute(
+ long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readPositionAttribute(long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readPlaybackSpeedAttribute(
+ long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readSeekRangeEndAttribute(
+ long chipClusterPtr, LongAttributeCallback callback);
+
+ private native void readSeekRangeStartAttribute(
+ long chipClusterPtr, LongAttributeCallback callback);
+
private native void readClusterRevisionAttribute(
long chipClusterPtr, IntegerAttributeCallback callback);
}
diff --git a/src/controller/python/chip/clusters/CHIPClusters.cpp b/src/controller/python/chip/clusters/CHIPClusters.cpp
index a83a82f388d81b..cc1091480d7a31 100644
--- a/src/controller/python/chip/clusters/CHIPClusters.cpp
+++ b/src/controller/python/chip/clusters/CHIPClusters.cpp
@@ -3436,6 +3436,86 @@ chip::ChipError::StorageType chip_ime_AppendCommand_MediaPlayback_MediaStop(chip
return cluster.MediaStop(nullptr, nullptr).AsInteger();
}
+chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_PlaybackState(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributePlaybackState(gInt8uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_StartTime(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeStartTime(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_Duration(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeDuration(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_PositionUpdatedAt(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributePositionUpdatedAt(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_Position(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributePosition(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_PlaybackSpeed(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributePlaybackSpeed(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_SeekRangeEnd(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeSeekRangeEnd(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
+chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_SeekRangeStart(chip::Controller::Device * device,
+ chip::EndpointId ZCLendpointId,
+ chip::GroupId /* ZCLgroupId */)
+{
+ VerifyOrReturnError(device != nullptr, CHIP_ERROR_INVALID_ARGUMENT.AsInteger());
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, ZCLendpointId);
+ return cluster.ReadAttributeSeekRangeStart(gInt64uAttributeCallback.Cancel(), gDefaultFailureCallback.Cancel()).AsInteger();
+}
+
chip::ChipError::StorageType chip_ime_ReadAttribute_MediaPlayback_ClusterRevision(chip::Controller::Device * device,
chip::EndpointId ZCLendpointId,
chip::GroupId /* ZCLgroupId */)
diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py
index f63e206e3e3b6f..3c7dddeb48c0b8 100644
--- a/src/controller/python/chip/clusters/CHIPClusters.py
+++ b/src/controller/python/chip/clusters/CHIPClusters.py
@@ -1929,6 +1929,46 @@ class ChipClusters:
},
},
"attributes": {
+ 0x00000000: {
+ "attributeName": "PlaybackState",
+ "attributeId": 0x00000000,
+ "type": "int",
+ },
+ 0x00000001: {
+ "attributeName": "StartTime",
+ "attributeId": 0x00000001,
+ "type": "int",
+ },
+ 0x00000002: {
+ "attributeName": "Duration",
+ "attributeId": 0x00000002,
+ "type": "int",
+ },
+ 0x00000003: {
+ "attributeName": "PositionUpdatedAt",
+ "attributeId": 0x00000003,
+ "type": "int",
+ },
+ 0x00000004: {
+ "attributeName": "Position",
+ "attributeId": 0x00000004,
+ "type": "int",
+ },
+ 0x00000005: {
+ "attributeName": "PlaybackSpeed",
+ "attributeId": 0x00000005,
+ "type": "int",
+ },
+ 0x00000006: {
+ "attributeName": "SeekRangeEnd",
+ "attributeId": 0x00000006,
+ "type": "int",
+ },
+ 0x00000007: {
+ "attributeName": "SeekRangeStart",
+ "attributeId": 0x00000007,
+ "type": "int",
+ },
0x0000FFFD: {
"attributeName": "ClusterRevision",
"attributeId": 0x0000FFFD,
@@ -4800,6 +4840,22 @@ def ClusterMediaInput_ReadAttributeCurrentMediaInput(self, device: ctypes.c_void
return self._chipLib.chip_ime_ReadAttribute_MediaInput_CurrentMediaInput(device, ZCLendpoint, ZCLgroupid)
def ClusterMediaInput_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
return self._chipLib.chip_ime_ReadAttribute_MediaInput_ClusterRevision(device, ZCLendpoint, ZCLgroupid)
+ def ClusterMediaPlayback_ReadAttributePlaybackState(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PlaybackState(device, ZCLendpoint, ZCLgroupid)
+ def ClusterMediaPlayback_ReadAttributeStartTime(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_StartTime(device, ZCLendpoint, ZCLgroupid)
+ def ClusterMediaPlayback_ReadAttributeDuration(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_Duration(device, ZCLendpoint, ZCLgroupid)
+ def ClusterMediaPlayback_ReadAttributePositionUpdatedAt(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PositionUpdatedAt(device, ZCLendpoint, ZCLgroupid)
+ def ClusterMediaPlayback_ReadAttributePosition(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_Position(device, ZCLendpoint, ZCLgroupid)
+ def ClusterMediaPlayback_ReadAttributePlaybackSpeed(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PlaybackSpeed(device, ZCLendpoint, ZCLgroupid)
+ def ClusterMediaPlayback_ReadAttributeSeekRangeEnd(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_SeekRangeEnd(device, ZCLendpoint, ZCLgroupid)
+ def ClusterMediaPlayback_ReadAttributeSeekRangeStart(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
+ return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_SeekRangeStart(device, ZCLendpoint, ZCLgroupid)
def ClusterMediaPlayback_ReadAttributeClusterRevision(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
return self._chipLib.chip_ime_ReadAttribute_MediaPlayback_ClusterRevision(device, ZCLendpoint, ZCLgroupid)
def ClusterNetworkCommissioning_ReadAttributeFeatureMap(self, device: ctypes.c_void_p, ZCLendpoint: int, ZCLgroupid: int):
@@ -6229,6 +6285,30 @@ def InitLib(self, chipLib):
# Cluster MediaPlayback Command MediaStop
self._chipLib.chip_ime_AppendCommand_MediaPlayback_MediaStop.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
self._chipLib.chip_ime_AppendCommand_MediaPlayback_MediaStop.restype = ctypes.c_uint32
+ # Cluster MediaPlayback ReadAttribute PlaybackState
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PlaybackState.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PlaybackState.restype = ctypes.c_uint32
+ # Cluster MediaPlayback ReadAttribute StartTime
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_StartTime.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_StartTime.restype = ctypes.c_uint32
+ # Cluster MediaPlayback ReadAttribute Duration
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_Duration.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_Duration.restype = ctypes.c_uint32
+ # Cluster MediaPlayback ReadAttribute PositionUpdatedAt
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PositionUpdatedAt.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PositionUpdatedAt.restype = ctypes.c_uint32
+ # Cluster MediaPlayback ReadAttribute Position
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_Position.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_Position.restype = ctypes.c_uint32
+ # Cluster MediaPlayback ReadAttribute PlaybackSpeed
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PlaybackSpeed.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_PlaybackSpeed.restype = ctypes.c_uint32
+ # Cluster MediaPlayback ReadAttribute SeekRangeEnd
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_SeekRangeEnd.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_SeekRangeEnd.restype = ctypes.c_uint32
+ # Cluster MediaPlayback ReadAttribute SeekRangeStart
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_SeekRangeStart.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
+ self._chipLib.chip_ime_ReadAttribute_MediaPlayback_SeekRangeStart.restype = ctypes.c_uint32
# Cluster MediaPlayback ReadAttribute ClusterRevision
self._chipLib.chip_ime_ReadAttribute_MediaPlayback_ClusterRevision.argtypes = [ctypes.c_void_p, ctypes.c_uint8, ctypes.c_uint16]
self._chipLib.chip_ime_ReadAttribute_MediaPlayback_ClusterRevision.restype = ctypes.c_uint32
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
index a66991557e6313..402c6bd4aaedcd 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h
@@ -935,6 +935,22 @@ NS_ASSUME_NONNULL_BEGIN
- (void)mediaStartOver:(ResponseHandler)responseHandler;
- (void)mediaStop:(ResponseHandler)responseHandler;
+- (void)readAttributePlaybackStateWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributeStartTimeWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributeDurationWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributePositionUpdatedAtWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributePositionWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributePlaybackSpeedWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributeSeekRangeEndWithResponseHandler:(ResponseHandler)responseHandler;
+
+- (void)readAttributeSeekRangeStartWithResponseHandler:(ResponseHandler)responseHandler;
+
- (void)readAttributeClusterRevisionWithResponseHandler:(ResponseHandler)responseHandler;
@end
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
index af7d8bd04a9692..d97ae14b0601ce 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm
@@ -2700,6 +2700,62 @@ new CHIPMediaPlaybackClusterMediaStopResponseCallbackBridge(
});
}
+- (void)readAttributePlaybackStateWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt8uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributePlaybackState(success, failure);
+ });
+}
+
+- (void)readAttributeStartTimeWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeStartTime(success, failure);
+ });
+}
+
+- (void)readAttributeDurationWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeDuration(success, failure);
+ });
+}
+
+- (void)readAttributePositionUpdatedAtWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributePositionUpdatedAt(success, failure);
+ });
+}
+
+- (void)readAttributePositionWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributePosition(success, failure);
+ });
+}
+
+- (void)readAttributePlaybackSpeedWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributePlaybackSpeed(success, failure);
+ });
+}
+
+- (void)readAttributeSeekRangeEndWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeSeekRangeEnd(success, failure);
+ });
+}
+
+- (void)readAttributeSeekRangeStartWithResponseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPInt64uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.ReadAttributeSeekRangeStart(success, failure);
+ });
+}
+
- (void)readAttributeClusterRevisionWithResponseHandler:(ResponseHandler)responseHandler
{
new CHIPInt16uAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h
index 48e5937d448410..0c2c9c443ebc3d 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h
@@ -415,6 +415,14 @@ NS_ASSUME_NONNULL_BEGIN
*/
@interface CHIPTestMediaPlayback : CHIPMediaPlayback
+- (void)writeAttributePlaybackStateWithValue:(uint8_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributeStartTimeWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributeDurationWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributePositionUpdatedAtWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributePositionWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributePlaybackSpeedWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributeSeekRangeEndWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
+- (void)writeAttributeSeekRangeStartWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler;
- (void)writeAttributeClusterRevisionWithValue:(uint16_t)value responseHandler:(ResponseHandler)responseHandler;
@end
diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm
index b317ac78888a30..a08b00ad2de762 100644
--- a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm
+++ b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm
@@ -1348,6 +1348,62 @@ @implementation CHIPTestMediaPlayback
return &_cppCluster;
}
+- (void)writeAttributePlaybackStateWithValue:(uint8_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributePlaybackState(success, failure, value);
+ });
+}
+
+- (void)writeAttributeStartTimeWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeStartTime(success, failure, value);
+ });
+}
+
+- (void)writeAttributeDurationWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeDuration(success, failure, value);
+ });
+}
+
+- (void)writeAttributePositionUpdatedAtWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributePositionUpdatedAt(success, failure, value);
+ });
+}
+
+- (void)writeAttributePositionWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributePosition(success, failure, value);
+ });
+}
+
+- (void)writeAttributePlaybackSpeedWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributePlaybackSpeed(success, failure, value);
+ });
+}
+
+- (void)writeAttributeSeekRangeEndWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeSeekRangeEnd(success, failure, value);
+ });
+}
+
+- (void)writeAttributeSeekRangeStartWithValue:(uint64_t)value responseHandler:(ResponseHandler)responseHandler
+{
+ new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
+ return self.cppCluster.WriteAttributeSeekRangeStart(success, failure, value);
+ });
+}
+
- (void)writeAttributeClusterRevisionWithValue:(uint16_t)value responseHandler:(ResponseHandler)responseHandler
{
new CHIPDefaultSuccessCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) {
diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
index 331261e610f430..1fd741a522f318 100644
--- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
+++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m
@@ -9229,6 +9229,155 @@ - (void)testSendClusterMediaInputReadAttributeClusterRevisionWithResponseHandler
[self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
}
+- (void)testSendClusterMediaPlaybackReadAttributePlaybackStateWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"MediaPlaybackReadAttributePlaybackStateWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPMediaPlayback * cluster = [[CHIPMediaPlayback alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributePlaybackStateWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"MediaPlayback PlaybackState Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterMediaPlaybackReadAttributeStartTimeWithResponseHandler
+{
+ XCTestExpectation * expectation = [self expectationWithDescription:@"MediaPlaybackReadAttributeStartTimeWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPMediaPlayback * cluster = [[CHIPMediaPlayback alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeStartTimeWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"MediaPlayback StartTime Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterMediaPlaybackReadAttributeDurationWithResponseHandler
+{
+ XCTestExpectation * expectation = [self expectationWithDescription:@"MediaPlaybackReadAttributeDurationWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPMediaPlayback * cluster = [[CHIPMediaPlayback alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeDurationWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"MediaPlayback Duration Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterMediaPlaybackReadAttributePositionUpdatedAtWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"MediaPlaybackReadAttributePositionUpdatedAtWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPMediaPlayback * cluster = [[CHIPMediaPlayback alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributePositionUpdatedAtWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"MediaPlayback PositionUpdatedAt Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterMediaPlaybackReadAttributePositionWithResponseHandler
+{
+ XCTestExpectation * expectation = [self expectationWithDescription:@"MediaPlaybackReadAttributePositionWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPMediaPlayback * cluster = [[CHIPMediaPlayback alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributePositionWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"MediaPlayback Position Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterMediaPlaybackReadAttributePlaybackSpeedWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"MediaPlaybackReadAttributePlaybackSpeedWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPMediaPlayback * cluster = [[CHIPMediaPlayback alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributePlaybackSpeedWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"MediaPlayback PlaybackSpeed Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterMediaPlaybackReadAttributeSeekRangeEndWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"MediaPlaybackReadAttributeSeekRangeEndWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPMediaPlayback * cluster = [[CHIPMediaPlayback alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeSeekRangeEndWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"MediaPlayback SeekRangeEnd Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
+- (void)testSendClusterMediaPlaybackReadAttributeSeekRangeStartWithResponseHandler
+{
+ XCTestExpectation * expectation =
+ [self expectationWithDescription:@"MediaPlaybackReadAttributeSeekRangeStartWithResponseHandler"];
+
+ CHIPDevice * device = GetPairedDevice(kDeviceId);
+ dispatch_queue_t queue = dispatch_get_main_queue();
+ CHIPMediaPlayback * cluster = [[CHIPMediaPlayback alloc] initWithDevice:device endpoint:1 queue:queue];
+ XCTAssertNotNil(cluster);
+
+ [cluster readAttributeSeekRangeStartWithResponseHandler:^(NSError * err, NSDictionary * values) {
+ NSLog(@"MediaPlayback SeekRangeStart Error: %@", err);
+ XCTAssertEqual(err.code, 0);
+ [expectation fulfill];
+ }];
+
+ [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil];
+}
+
- (void)testSendClusterMediaPlaybackReadAttributeClusterRevisionWithResponseHandler
{
XCTestExpectation * expectation =
diff --git a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h
index 3135cf3294d15c..31ff74123a0f27 100644
--- a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h
+++ b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h
@@ -732,9 +732,32 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
+ /* Endpoint: 1, Cluster: Media Playback (server), big-endian */ \
+ \
+ /* 7234 - start time, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, \
+ \
+ /* 7242 - duration, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7250 - position updated at, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7258 - position, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7266 - playback speed, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7274 - seek range end, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7282 - seek range start, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
/* Endpoint: 1, Cluster: Media Input (server), big-endian */ \
\
- /* 7234 - media input list, */ \
+ /* 7290 - media input list, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -752,7 +775,7 @@
\
/* Endpoint: 1, Cluster: Content Launcher (server), big-endian */ \
\
- /* 7488 - accepts header list, */ \
+ /* 7544 - accepts header list, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -768,7 +791,7 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 7742 - supported streaming types, */ \
+ /* 7798 - supported streaming types, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -786,7 +809,7 @@
\
/* Endpoint: 1, Cluster: Audio Output (server), big-endian */ \
\
- /* 7996 - audio output list, */ \
+ /* 8052 - audio output list, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -804,7 +827,7 @@
\
/* Endpoint: 1, Cluster: Application Launcher (server), big-endian */ \
\
- /* 8250 - application launcher list, */ \
+ /* 8306 - application launcher list, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -822,45 +845,45 @@
\
/* Endpoint: 1, Cluster: Application Basic (server), big-endian */ \
\
- /* 8504 - vendor name, */ \
+ /* 8560 - vendor name, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8537 - application name, */ \
+ /* 8593 - application name, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8570 - application id, */ \
+ /* 8626 - application id, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
/* Endpoint: 1, Cluster: Test Cluster (server), big-endian */ \
\
- /* 8603 - bitmap32, */ \
+ /* 8659 - bitmap32, */ \
0x00, 0x00, 0x00, 0x00, \
\
- /* 8607 - bitmap64, */ \
+ /* 8663 - bitmap64, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8615 - int32u, */ \
+ /* 8671 - int32u, */ \
0x00, 0x00, 0x00, 0x00, \
\
- /* 8619 - int64u, */ \
+ /* 8675 - int64u, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8627 - int32s, */ \
+ /* 8683 - int32s, */ \
0x00, 0x00, 0x00, 0x00, \
\
- /* 8631 - int64s, */ \
+ /* 8687 - int64s, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8639 - octet_string, */ \
+ /* 8695 - octet_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8650 - list_int8u, */ \
+ /* 8706 - list_int8u, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8660 - list_octet_string, */ \
+ /* 8716 - list_octet_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -876,7 +899,7 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8914 - list_struct_octet_string, */ \
+ /* 8970 - list_struct_octet_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -892,7 +915,7 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 9168 - long_octet_string, */ \
+ /* 9224 - long_octet_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -947,10 +970,10 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 10170 - char_string, */ \
+ /* 10226 - char_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 10181 - long_char_string, */ \
+ /* 10237 - long_char_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1007,15 +1030,15 @@
\
/* Endpoint: 1, Cluster: Electrical Measurement (server), big-endian */ \
\
- /* 11183 - measurement type, */ \
+ /* 11239 - measurement type, */ \
0x00, 0x00, 0x00, 0x00, \
\
- /* 11187 - total active power, */ \
+ /* 11243 - total active power, */ \
0x00, 0x00, 0x00, 0x00, \
\
/* Endpoint: 2, Cluster: On/Off (server), big-endian */ \
\
- /* 11191 - FeatureMap, */ \
+ /* 11247 - FeatureMap, */ \
0x00, 0x00, 0x00, 0x00, \
}
@@ -1728,9 +1751,32 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
+ /* Endpoint: 1, Cluster: Media Playback (server), little-endian */ \
+ \
+ /* 7234 - start time, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, \
+ \
+ /* 7242 - duration, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7250 - position updated at, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7258 - position, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7266 - playback speed, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7274 - seek range end, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
+ /* 7282 - seek range start, */ \
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
+ \
/* Endpoint: 1, Cluster: Media Input (server), little-endian */ \
\
- /* 7234 - media input list, */ \
+ /* 7290 - media input list, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1748,7 +1794,7 @@
\
/* Endpoint: 1, Cluster: Content Launcher (server), little-endian */ \
\
- /* 7488 - accepts header list, */ \
+ /* 7544 - accepts header list, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1764,7 +1810,7 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 7742 - supported streaming types, */ \
+ /* 7798 - supported streaming types, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1782,7 +1828,7 @@
\
/* Endpoint: 1, Cluster: Audio Output (server), little-endian */ \
\
- /* 7996 - audio output list, */ \
+ /* 8052 - audio output list, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1800,7 +1846,7 @@
\
/* Endpoint: 1, Cluster: Application Launcher (server), little-endian */ \
\
- /* 8250 - application launcher list, */ \
+ /* 8306 - application launcher list, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1818,45 +1864,45 @@
\
/* Endpoint: 1, Cluster: Application Basic (server), little-endian */ \
\
- /* 8504 - vendor name, */ \
+ /* 8560 - vendor name, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8537 - application name, */ \
+ /* 8593 - application name, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8570 - application id, */ \
+ /* 8626 - application id, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
/* Endpoint: 1, Cluster: Test Cluster (server), little-endian */ \
\
- /* 8603 - bitmap32, */ \
+ /* 8659 - bitmap32, */ \
0x00, 0x00, 0x00, 0x00, \
\
- /* 8607 - bitmap64, */ \
+ /* 8663 - bitmap64, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8615 - int32u, */ \
+ /* 8671 - int32u, */ \
0x00, 0x00, 0x00, 0x00, \
\
- /* 8619 - int64u, */ \
+ /* 8675 - int64u, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8627 - int32s, */ \
+ /* 8683 - int32s, */ \
0x00, 0x00, 0x00, 0x00, \
\
- /* 8631 - int64s, */ \
+ /* 8687 - int64s, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8639 - octet_string, */ \
+ /* 8695 - octet_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8650 - list_int8u, */ \
+ /* 8706 - list_int8u, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8660 - list_octet_string, */ \
+ /* 8716 - list_octet_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1872,7 +1918,7 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 8914 - list_struct_octet_string, */ \
+ /* 8970 - list_struct_octet_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1888,7 +1934,7 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 9168 - long_octet_string, */ \
+ /* 9224 - long_octet_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -1943,10 +1989,10 @@
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 10170 - char_string, */ \
+ /* 10226 - char_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 10181 - long_char_string, */ \
+ /* 10237 - long_char_string, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
@@ -2003,21 +2049,21 @@
\
/* Endpoint: 1, Cluster: Electrical Measurement (server), little-endian */ \
\
- /* 11183 - measurement type, */ \
+ /* 11239 - measurement type, */ \
0x00, 0x00, 0x00, 0x00, \
\
- /* 11187 - total active power, */ \
+ /* 11243 - total active power, */ \
0x00, 0x00, 0x00, 0x00, \
\
/* Endpoint: 2, Cluster: On/Off (server), little-endian */ \
\
- /* 11191 - FeatureMap, */ \
+ /* 11247 - FeatureMap, */ \
0x00, 0x00, 0x00, 0x00, \
}
#endif // BIGENDIAN_CPU
-#define GENERATED_DEFAULTS_COUNT (131)
+#define GENERATED_DEFAULTS_COUNT (138)
#define ZAP_TYPE(type) ZCL_##type##_ATTRIBUTE_TYPE
#define ZAP_LONG_DEFAULTS_INDEX(index) \
@@ -2045,7 +2091,7 @@
#define ZAP_ATTRIBUTE_MASK(mask) ATTRIBUTE_MASK_##mask
// This is an array of EmberAfAttributeMetadata structures.
-#define GENERATED_ATTRIBUTE_COUNT 403
+#define GENERATED_ATTRIBUTE_COUNT 411
#define GENERATED_ATTRIBUTES \
{ \
\
@@ -2491,10 +2537,18 @@
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
\
/* Endpoint: 1, Cluster: Media Playback (server) */ \
- { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
+ { 0x0000, ZAP_TYPE(ENUM8), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* playback state */ \
+ { 0x0001, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(7234) }, /* start time */ \
+ { 0x0002, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(7242) }, /* duration */ \
+ { 0x0003, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(7250) }, /* position updated at */ \
+ { 0x0004, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(7258) }, /* position */ \
+ { 0x0005, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(7266) }, /* playback speed */ \
+ { 0x0006, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(7274) }, /* seek range end */ \
+ { 0x0007, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(7282) }, /* seek range start */ \
+ { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
\
/* Endpoint: 1, Cluster: Media Input (server) */ \
- { 0x0000, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(7234) }, /* media input list */ \
+ { 0x0000, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(7290) }, /* media input list */ \
{ 0x0001, ZAP_TYPE(INT8U), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* current media input */ \
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
\
@@ -2505,27 +2559,27 @@
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
\
/* Endpoint: 1, Cluster: Content Launcher (server) */ \
- { 0x0000, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(7488) }, /* accepts header list */ \
- { 0x0001, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(7742) }, /* supported streaming types */ \
+ { 0x0000, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(7544) }, /* accepts header list */ \
+ { 0x0001, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(7798) }, /* supported streaming types */ \
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
\
/* Endpoint: 1, Cluster: Audio Output (server) */ \
- { 0x0000, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(7996) }, /* audio output list */ \
+ { 0x0000, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(8052) }, /* audio output list */ \
{ 0x0001, ZAP_TYPE(INT8U), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* current audio output */ \
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
\
/* Endpoint: 1, Cluster: Application Launcher (server) */ \
- { 0x0000, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(8250) }, /* application launcher list */ \
+ { 0x0000, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(8306) }, /* application launcher list */ \
{ 0x0001, ZAP_TYPE(INT8U), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* catalog vendor id */ \
{ 0x0002, ZAP_TYPE(INT8U), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* application id */ \
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
\
/* Endpoint: 1, Cluster: Application Basic (server) */ \
- { 0x0000, ZAP_TYPE(CHAR_STRING), 33, 0, ZAP_LONG_DEFAULTS_INDEX(8504) }, /* vendor name */ \
+ { 0x0000, ZAP_TYPE(CHAR_STRING), 33, 0, ZAP_LONG_DEFAULTS_INDEX(8560) }, /* vendor name */ \
{ 0x0001, ZAP_TYPE(INT16U), 2, 0, ZAP_EMPTY_DEFAULT() }, /* vendor id */ \
- { 0x0002, ZAP_TYPE(CHAR_STRING), 33, 0, ZAP_LONG_DEFAULTS_INDEX(8537) }, /* application name */ \
+ { 0x0002, ZAP_TYPE(CHAR_STRING), 33, 0, ZAP_LONG_DEFAULTS_INDEX(8593) }, /* application name */ \
{ 0x0003, ZAP_TYPE(INT16U), 2, 0, ZAP_EMPTY_DEFAULT() }, /* product id */ \
- { 0x0005, ZAP_TYPE(CHAR_STRING), 33, 0, ZAP_LONG_DEFAULTS_INDEX(8570) }, /* application id */ \
+ { 0x0005, ZAP_TYPE(CHAR_STRING), 33, 0, ZAP_LONG_DEFAULTS_INDEX(8626) }, /* application id */ \
{ 0x0006, ZAP_TYPE(INT16U), 2, 0, ZAP_EMPTY_DEFAULT() }, /* catalog vendor id */ \
{ 0x0007, ZAP_TYPE(ENUM8), 1, 0, ZAP_SIMPLE_DEFAULT(0x01) }, /* application status */ \
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
@@ -2537,33 +2591,33 @@
{ 0x0000, ZAP_TYPE(BOOLEAN), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(false) }, /* boolean */ \
{ 0x0001, ZAP_TYPE(BITMAP8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* bitmap8 */ \
{ 0x0002, ZAP_TYPE(BITMAP16), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* bitmap16 */ \
- { 0x0003, ZAP_TYPE(BITMAP32), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8603) }, /* bitmap32 */ \
- { 0x0004, ZAP_TYPE(BITMAP64), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8607) }, /* bitmap64 */ \
+ { 0x0003, ZAP_TYPE(BITMAP32), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8659) }, /* bitmap32 */ \
+ { 0x0004, ZAP_TYPE(BITMAP64), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8663) }, /* bitmap64 */ \
{ 0x0005, ZAP_TYPE(INT8U), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* int8u */ \
{ 0x0006, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* int16u */ \
- { 0x0008, ZAP_TYPE(INT32U), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8615) }, /* int32u */ \
- { 0x000C, ZAP_TYPE(INT64U), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8619) }, /* int64u */ \
+ { 0x0008, ZAP_TYPE(INT32U), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8671) }, /* int32u */ \
+ { 0x000C, ZAP_TYPE(INT64U), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8675) }, /* int64u */ \
{ 0x000D, ZAP_TYPE(INT8S), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* int8s */ \
{ 0x000E, ZAP_TYPE(INT16S), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* int16s */ \
- { 0x0010, ZAP_TYPE(INT32S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8627) }, /* int32s */ \
- { 0x0014, ZAP_TYPE(INT64S), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8631) }, /* int64s */ \
+ { 0x0010, ZAP_TYPE(INT32S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8683) }, /* int32s */ \
+ { 0x0014, ZAP_TYPE(INT64S), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(8687) }, /* int64s */ \
{ 0x0015, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* enum8 */ \
{ 0x0016, ZAP_TYPE(ENUM16), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* enum16 */ \
{ 0x0019, ZAP_TYPE(OCTET_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE), \
- ZAP_LONG_DEFAULTS_INDEX(8639) }, /* octet_string */ \
- { 0x001A, ZAP_TYPE(ARRAY), 10, 0, ZAP_LONG_DEFAULTS_INDEX(8650) }, /* list_int8u */ \
- { 0x001B, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(8660) }, /* list_octet_string */ \
- { 0x001C, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(8914) }, /* list_struct_octet_string */ \
+ ZAP_LONG_DEFAULTS_INDEX(8695) }, /* octet_string */ \
+ { 0x001A, ZAP_TYPE(ARRAY), 10, 0, ZAP_LONG_DEFAULTS_INDEX(8706) }, /* list_int8u */ \
+ { 0x001B, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(8716) }, /* list_octet_string */ \
+ { 0x001C, ZAP_TYPE(ARRAY), 254, 0, ZAP_LONG_DEFAULTS_INDEX(8970) }, /* list_struct_octet_string */ \
{ 0x001D, ZAP_TYPE(LONG_OCTET_STRING), 1002, ZAP_ATTRIBUTE_MASK(WRITABLE), \
- ZAP_LONG_DEFAULTS_INDEX(9168) }, /* long_octet_string */ \
- { 0x001E, ZAP_TYPE(CHAR_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(10170) }, /* char_string */ \
+ ZAP_LONG_DEFAULTS_INDEX(9224) }, /* long_octet_string */ \
+ { 0x001E, ZAP_TYPE(CHAR_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(10226) }, /* char_string */ \
{ 0x001F, ZAP_TYPE(LONG_CHAR_STRING), 1002, ZAP_ATTRIBUTE_MASK(WRITABLE), \
- ZAP_LONG_DEFAULTS_INDEX(10181) }, /* long_char_string */ \
+ ZAP_LONG_DEFAULTS_INDEX(10237) }, /* long_char_string */ \
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \
\
/* Endpoint: 1, Cluster: Electrical Measurement (server) */ \
- { 0x0000, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(11183) }, /* measurement type */ \
- { 0x0304, ZAP_TYPE(INT32S), 4, 0, ZAP_LONG_DEFAULTS_INDEX(11187) }, /* total active power */ \
+ { 0x0000, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(11239) }, /* measurement type */ \
+ { 0x0304, ZAP_TYPE(INT32S), 4, 0, ZAP_LONG_DEFAULTS_INDEX(11243) }, /* total active power */ \
{ 0x0505, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0xffff) }, /* rms voltage */ \
{ 0x0506, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x8000) }, /* rms voltage min */ \
{ 0x0507, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x8000) }, /* rms voltage max */ \
@@ -2584,7 +2638,7 @@
{ 0x4001, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* OnTime */ \
{ 0x4002, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* OffWaitTime */ \
{ 0x4003, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* StartUpOnOff */ \
- { 0xFFFC, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(11191) }, /* FeatureMap */ \
+ { 0xFFFC, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(11247) }, /* FeatureMap */ \
{ 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(2) }, /* ClusterRevision */ \
\
/* Endpoint: 2, Cluster: Occupancy Sensing (server) */ \
@@ -2810,49 +2864,49 @@
0x0505, ZAP_ATTRIBUTE_INDEX(329), 2, 256, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Target Navigator (server) */ \
{ \
- 0x0506, ZAP_ATTRIBUTE_INDEX(331), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x0506, ZAP_ATTRIBUTE_INDEX(331), 9, 59, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Media Playback (server) */ \
{ \
- 0x0507, ZAP_ATTRIBUTE_INDEX(332), 3, 257, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x0507, ZAP_ATTRIBUTE_INDEX(340), 3, 257, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Media Input (server) */ \
{ \
- 0x0508, ZAP_ATTRIBUTE_INDEX(335), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x0508, ZAP_ATTRIBUTE_INDEX(343), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Low Power (server) */ \
{ \
- 0x0509, ZAP_ATTRIBUTE_INDEX(336), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x0509, ZAP_ATTRIBUTE_INDEX(344), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Keypad Input (server) */ \
{ \
- 0x050A, ZAP_ATTRIBUTE_INDEX(337), 3, 510, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x050A, ZAP_ATTRIBUTE_INDEX(345), 3, 510, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Content Launcher (server) */ \
{ \
- 0x050B, ZAP_ATTRIBUTE_INDEX(340), 3, 257, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x050B, ZAP_ATTRIBUTE_INDEX(348), 3, 257, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Audio Output (server) */ \
{ \
- 0x050C, ZAP_ATTRIBUTE_INDEX(343), 4, 258, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x050C, ZAP_ATTRIBUTE_INDEX(351), 4, 258, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Application Launcher (server) */ \
{ \
- 0x050D, ZAP_ATTRIBUTE_INDEX(347), 8, 108, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x050D, ZAP_ATTRIBUTE_INDEX(355), 8, 108, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Application Basic (server) */ \
{ \
- 0x050E, ZAP_ATTRIBUTE_INDEX(355), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x050E, ZAP_ATTRIBUTE_INDEX(363), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Account Login (server) */ \
{ \
- 0x050F, ZAP_ATTRIBUTE_INDEX(356), 23, 2595, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x050F, ZAP_ATTRIBUTE_INDEX(364), 23, 2595, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Test Cluster (server) */ \
{ \
- 0x0B04, ZAP_ATTRIBUTE_INDEX(379), 12, 28, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0x0B04, ZAP_ATTRIBUTE_INDEX(387), 12, 28, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Electrical Measurement (server) */ \
{ \
- 0xF000, ZAP_ATTRIBUTE_INDEX(391), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
+ 0xF000, ZAP_ATTRIBUTE_INDEX(399), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \
}, /* Endpoint: 1, Cluster: Binding (server) */ \
{ 0x0006, \
- ZAP_ATTRIBUTE_INDEX(392), \
+ ZAP_ATTRIBUTE_INDEX(400), \
7, \
13, \
ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION), \
chipFuncArrayOnOffServer }, /* Endpoint: 2, Cluster: On/Off (server) */ \
{ 0x0406, \
- ZAP_ATTRIBUTE_INDEX(399), \
+ ZAP_ATTRIBUTE_INDEX(407), \
4, \
5, \
ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION), \
@@ -2864,7 +2918,7 @@
// This is an array of EmberAfEndpointType structures.
#define GENERATED_ENDPOINT_TYPES \
{ \
- { ZAP_CLUSTER_INDEX(0), 17, 4313 }, { ZAP_CLUSTER_INDEX(17), 39, 7311 }, { ZAP_CLUSTER_INDEX(56), 2, 18 }, \
+ { ZAP_CLUSTER_INDEX(0), 17, 4313 }, { ZAP_CLUSTER_INDEX(17), 39, 7368 }, { ZAP_CLUSTER_INDEX(56), 2, 18 }, \
}
// Largest attribute size is needed for various buffers
@@ -2874,7 +2928,7 @@
#define ATTRIBUTE_SINGLETONS_SIZE (1517)
// Total size of attribute storage
-#define ATTRIBUTE_MAX_SIZE (11642)
+#define ATTRIBUTE_MAX_SIZE (11699)
// Number of fixed endpoints
#define FIXED_ENDPOINT_COUNT (3)
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
index 416bd79b73c923..81fe8c16375505 100644
--- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
+++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.cpp
@@ -6509,22 +6509,23 @@ EmberAfStatus SetDuration(chip::EndpointId endpoint, uint64_t duration)
return emberAfWriteServerAttribute(endpoint, MediaPlayback::Id, Ids::Duration, (uint8_t *) &duration,
ZCL_INT64U_ATTRIBUTE_TYPE);
}
-EmberAfStatus GetUpdatedAt(chip::EndpointId endpoint, uint64_t * updatedAt)
+EmberAfStatus GetPositionUpdatedAt(chip::EndpointId endpoint, uint64_t * positionUpdatedAt)
{
- return emberAfReadServerAttribute(endpoint, MediaPlayback::Id, Ids::UpdatedAt, (uint8_t *) updatedAt, sizeof(*updatedAt));
+ return emberAfReadServerAttribute(endpoint, MediaPlayback::Id, Ids::PositionUpdatedAt, (uint8_t *) positionUpdatedAt,
+ sizeof(*positionUpdatedAt));
}
-EmberAfStatus SetUpdatedAt(chip::EndpointId endpoint, uint64_t updatedAt)
+EmberAfStatus SetPositionUpdatedAt(chip::EndpointId endpoint, uint64_t positionUpdatedAt)
{
- return emberAfWriteServerAttribute(endpoint, MediaPlayback::Id, Ids::UpdatedAt, (uint8_t *) &updatedAt,
+ return emberAfWriteServerAttribute(endpoint, MediaPlayback::Id, Ids::PositionUpdatedAt, (uint8_t *) &positionUpdatedAt,
ZCL_INT64U_ATTRIBUTE_TYPE);
}
-EmberAfStatus GetPosistion(chip::EndpointId endpoint, uint64_t * posistion)
+EmberAfStatus GetPosition(chip::EndpointId endpoint, uint64_t * position)
{
- return emberAfReadServerAttribute(endpoint, MediaPlayback::Id, Ids::Posistion, (uint8_t *) posistion, sizeof(*posistion));
+ return emberAfReadServerAttribute(endpoint, MediaPlayback::Id, Ids::Position, (uint8_t *) position, sizeof(*position));
}
-EmberAfStatus SetPosistion(chip::EndpointId endpoint, uint64_t posistion)
+EmberAfStatus SetPosition(chip::EndpointId endpoint, uint64_t position)
{
- return emberAfWriteServerAttribute(endpoint, MediaPlayback::Id, Ids::Posistion, (uint8_t *) &posistion,
+ return emberAfWriteServerAttribute(endpoint, MediaPlayback::Id, Ids::Position, (uint8_t *) &position,
ZCL_INT64U_ATTRIBUTE_TYPE);
}
EmberAfStatus GetPlaybackSpeed(chip::EndpointId endpoint, uint64_t * playbackSpeed)
diff --git a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
index 5faf14f6a6c634..5a7f531e40bed8 100644
--- a/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
+++ b/zzz_generated/app-common/app-common/zap-generated/attributes/Accessors.h
@@ -1781,10 +1781,10 @@ EmberAfStatus GetStartTime(chip::EndpointId endpoint, uint64_t * startTime); //
EmberAfStatus SetStartTime(chip::EndpointId endpoint, uint64_t startTime);
EmberAfStatus GetDuration(chip::EndpointId endpoint, uint64_t * duration); // int64u
EmberAfStatus SetDuration(chip::EndpointId endpoint, uint64_t duration);
-EmberAfStatus GetUpdatedAt(chip::EndpointId endpoint, uint64_t * updatedAt); // int64u
-EmberAfStatus SetUpdatedAt(chip::EndpointId endpoint, uint64_t updatedAt);
-EmberAfStatus GetPosistion(chip::EndpointId endpoint, uint64_t * posistion); // int64u
-EmberAfStatus SetPosistion(chip::EndpointId endpoint, uint64_t posistion);
+EmberAfStatus GetPositionUpdatedAt(chip::EndpointId endpoint, uint64_t * positionUpdatedAt); // int64u
+EmberAfStatus SetPositionUpdatedAt(chip::EndpointId endpoint, uint64_t positionUpdatedAt);
+EmberAfStatus GetPosition(chip::EndpointId endpoint, uint64_t * position); // int64u
+EmberAfStatus SetPosition(chip::EndpointId endpoint, uint64_t position);
EmberAfStatus GetPlaybackSpeed(chip::EndpointId endpoint, uint64_t * playbackSpeed); // int64u
EmberAfStatus SetPlaybackSpeed(chip::EndpointId endpoint, uint64_t playbackSpeed);
EmberAfStatus GetSeekRangeEnd(chip::EndpointId endpoint, uint64_t * seekRangeEnd); // int64u
diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
index b79a559cba383f..8da302c4775737 100644
--- a/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
+++ b/zzz_generated/app-common/app-common/zap-generated/ids/Attributes.h
@@ -1282,14 +1282,14 @@ static constexpr AttributeId CurrentNavigatorTarget = 0x00000001;
namespace MediaPlayback {
namespace Attributes {
namespace Ids {
-static constexpr AttributeId PlaybackState = 0x00000000;
-static constexpr AttributeId StartTime = 0x00000001;
-static constexpr AttributeId Duration = 0x00000002;
-static constexpr AttributeId UpdatedAt = 0x00000003;
-static constexpr AttributeId Posistion = 0x00000004;
-static constexpr AttributeId PlaybackSpeed = 0x00000005;
-static constexpr AttributeId SeekRangeEnd = 0x00000006;
-static constexpr AttributeId SeekRangeStart = 0x00000007;
+static constexpr AttributeId PlaybackState = 0x00000000;
+static constexpr AttributeId StartTime = 0x00000001;
+static constexpr AttributeId Duration = 0x00000002;
+static constexpr AttributeId PositionUpdatedAt = 0x00000003;
+static constexpr AttributeId Position = 0x00000004;
+static constexpr AttributeId PlaybackSpeed = 0x00000005;
+static constexpr AttributeId SeekRangeEnd = 0x00000006;
+static constexpr AttributeId SeekRangeStart = 0x00000007;
} // namespace Ids
} // namespace Attributes
} // namespace MediaPlayback
diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
index 7fe2f1f5cfd38c..1ce1d58206fa9c 100644
--- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
+++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h
@@ -12651,6 +12651,14 @@ class ReadMediaInputClusterRevision : public ModelCommand
| * MediaStop | 0x02 |
|------------------------------------------------------------------------------|
| Attributes: | |
+| * PlaybackState | 0x0000 |
+| * StartTime | 0x0001 |
+| * Duration | 0x0002 |
+| * PositionUpdatedAt | 0x0003 |
+| * Position | 0x0004 |
+| * PlaybackSpeed | 0x0005 |
+| * SeekRangeEnd | 0x0006 |
+| * SeekRangeStart | 0x0007 |
| * ClusterRevision | 0xFFFD |
\*----------------------------------------------------------------------------*/
@@ -13025,6 +13033,278 @@ class DiscoverMediaPlaybackAttributes : public ModelCommand
new chip::Callback::Callback(OnDefaultFailureResponse, this);
};
+/*
+ * Attribute PlaybackState
+ */
+class ReadMediaPlaybackPlaybackState : public ModelCommand
+{
+public:
+ ReadMediaPlaybackPlaybackState() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "playback-state");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadMediaPlaybackPlaybackState()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0506) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributePlaybackState(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback * onSuccessCallback =
+ new chip::Callback::Callback(OnInt8uAttributeResponse, this);
+ chip::Callback::Callback * onFailureCallback =
+ new chip::Callback::Callback(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute StartTime
+ */
+class ReadMediaPlaybackStartTime : public ModelCommand
+{
+public:
+ ReadMediaPlaybackStartTime() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "start-time");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadMediaPlaybackStartTime()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0506) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeStartTime(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback * onSuccessCallback =
+ new chip::Callback::Callback(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback * onFailureCallback =
+ new chip::Callback::Callback(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute Duration
+ */
+class ReadMediaPlaybackDuration : public ModelCommand
+{
+public:
+ ReadMediaPlaybackDuration() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "duration");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadMediaPlaybackDuration()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0506) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeDuration(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback * onSuccessCallback =
+ new chip::Callback::Callback(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback * onFailureCallback =
+ new chip::Callback::Callback(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute PositionUpdatedAt
+ */
+class ReadMediaPlaybackPositionUpdatedAt : public ModelCommand
+{
+public:
+ ReadMediaPlaybackPositionUpdatedAt() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "position-updated-at");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadMediaPlaybackPositionUpdatedAt()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0506) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributePositionUpdatedAt(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback * onSuccessCallback =
+ new chip::Callback::Callback(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback * onFailureCallback =
+ new chip::Callback::Callback(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute Position
+ */
+class ReadMediaPlaybackPosition : public ModelCommand
+{
+public:
+ ReadMediaPlaybackPosition() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "position");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadMediaPlaybackPosition()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0506) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributePosition(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback * onSuccessCallback =
+ new chip::Callback::Callback(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback * onFailureCallback =
+ new chip::Callback::Callback(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute PlaybackSpeed
+ */
+class ReadMediaPlaybackPlaybackSpeed : public ModelCommand
+{
+public:
+ ReadMediaPlaybackPlaybackSpeed() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "playback-speed");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadMediaPlaybackPlaybackSpeed()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0506) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributePlaybackSpeed(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback * onSuccessCallback =
+ new chip::Callback::Callback(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback * onFailureCallback =
+ new chip::Callback::Callback(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute SeekRangeEnd
+ */
+class ReadMediaPlaybackSeekRangeEnd : public ModelCommand
+{
+public:
+ ReadMediaPlaybackSeekRangeEnd() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "seek-range-end");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadMediaPlaybackSeekRangeEnd()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0506) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeSeekRangeEnd(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback * onSuccessCallback =
+ new chip::Callback::Callback(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback * onFailureCallback =
+ new chip::Callback::Callback(OnDefaultFailureResponse, this);
+};
+
+/*
+ * Attribute SeekRangeStart
+ */
+class ReadMediaPlaybackSeekRangeStart : public ModelCommand
+{
+public:
+ ReadMediaPlaybackSeekRangeStart() : ModelCommand("read")
+ {
+ AddArgument("attr-name", "seek-range-start");
+ ModelCommand::AddArguments();
+ }
+
+ ~ReadMediaPlaybackSeekRangeStart()
+ {
+ delete onSuccessCallback;
+ delete onFailureCallback;
+ }
+
+ CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override
+ {
+ ChipLogProgress(chipTool, "Sending cluster (0x0506) command (0x00) on endpoint %" PRIu8, endpointId);
+
+ chip::Controller::MediaPlaybackCluster cluster;
+ cluster.Associate(device, endpointId);
+ return cluster.ReadAttributeSeekRangeStart(onSuccessCallback->Cancel(), onFailureCallback->Cancel());
+ }
+
+private:
+ chip::Callback::Callback * onSuccessCallback =
+ new chip::Callback::Callback(OnInt64uAttributeResponse, this);
+ chip::Callback::Callback * onFailureCallback =
+ new chip::Callback::Callback(OnDefaultFailureResponse, this);
+};
+
/*
* Attribute ClusterRevision
*/
@@ -25432,19 +25712,27 @@ void registerClusterMediaPlayback(Commands & commands)
const char * clusterName = "MediaPlayback";
commands_list clusterCommands = {
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
- make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
+ make_unique(), //
};
commands.Register(clusterName, clusterCommands);
diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
index 705825ecfe65b4..798d86d3e81e6c 100644
--- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
+++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp
@@ -7117,6 +7117,102 @@ CHIP_ERROR MediaPlaybackCluster::DiscoverAttributes(Callback::Cancelable * onSuc
COMMAND_FOOTER();
}
+CHIP_ERROR MediaPlaybackCluster::ReadAttributePlaybackState(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000000;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter);
+}
+
+CHIP_ERROR MediaPlaybackCluster::ReadAttributeStartTime(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000001;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter);
+}
+
+CHIP_ERROR MediaPlaybackCluster::ReadAttributeDuration(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000002;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter);
+}
+
+CHIP_ERROR MediaPlaybackCluster::ReadAttributePositionUpdatedAt(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000003;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter);
+}
+
+CHIP_ERROR MediaPlaybackCluster::ReadAttributePosition(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000004;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter);
+}
+
+CHIP_ERROR MediaPlaybackCluster::ReadAttributePlaybackSpeed(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000005;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter);
+}
+
+CHIP_ERROR MediaPlaybackCluster::ReadAttributeSeekRangeEnd(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000006;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter);
+}
+
+CHIP_ERROR MediaPlaybackCluster::ReadAttributeSeekRangeStart(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback)
+{
+ app::AttributePathParams attributePath;
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = 0x00000007;
+ attributePath.mFlags.Set(app::AttributePathParams::Flags::kFieldIdValid);
+ return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback,
+ BasicAttributeFilter);
+}
+
CHIP_ERROR MediaPlaybackCluster::ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback)
{
diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
index 4a0248a880d69e..7cfcba9f4dc950 100644
--- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
+++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h
@@ -823,6 +823,14 @@ class DLL_EXPORT MediaPlaybackCluster : public ClusterBase
// Cluster Attributes
CHIP_ERROR DiscoverAttributes(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributePlaybackState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeStartTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeDuration(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributePositionUpdatedAt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributePosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributePlaybackSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeSeekRangeEnd(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
+ CHIP_ERROR ReadAttributeSeekRangeStart(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
CHIP_ERROR ReadAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback);
private:
diff --git a/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.cpp
index 51100eda49545c..0b23f835b2b51a 100644
--- a/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.cpp
+++ b/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.cpp
@@ -2407,6 +2407,143 @@ CHIP_ERROR MediaInputClusterTest::WriteAttributeClusterRevision(Callback::Cancel
return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
}
+CHIP_ERROR MediaPlaybackClusterTest::WriteAttributePlaybackState(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint8_t playbackState)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = MediaPlayback::Attributes::Ids::PlaybackState;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, playbackState));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR MediaPlaybackClusterTest::WriteAttributeStartTime(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint64_t startTime)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = MediaPlayback::Attributes::Ids::StartTime;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, startTime));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR MediaPlaybackClusterTest::WriteAttributeDuration(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint64_t duration)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = MediaPlayback::Attributes::Ids::Duration;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, duration));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR MediaPlaybackClusterTest::WriteAttributePositionUpdatedAt(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback,
+ uint64_t positionUpdatedAt)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = MediaPlayback::Attributes::Ids::PositionUpdatedAt;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, positionUpdatedAt));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR MediaPlaybackClusterTest::WriteAttributePosition(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint64_t position)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = MediaPlayback::Attributes::Ids::Position;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, position));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR MediaPlaybackClusterTest::WriteAttributePlaybackSpeed(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint64_t playbackSpeed)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = MediaPlayback::Attributes::Ids::PlaybackSpeed;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, playbackSpeed));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR MediaPlaybackClusterTest::WriteAttributeSeekRangeEnd(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint64_t seekRangeEnd)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = MediaPlayback::Attributes::Ids::SeekRangeEnd;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, seekRangeEnd));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
+CHIP_ERROR MediaPlaybackClusterTest::WriteAttributeSeekRangeStart(Callback::Cancelable * onSuccessCallback,
+ Callback::Cancelable * onFailureCallback, uint64_t seekRangeStart)
+{
+ app::WriteClientHandle handle;
+ chip::app::AttributePathParams attributePath;
+ attributePath.mNodeId = mDevice->GetDeviceId();
+ attributePath.mEndpointId = mEndpoint;
+ attributePath.mClusterId = mClusterId;
+ attributePath.mFieldId = MediaPlayback::Attributes::Ids::SeekRangeStart;
+ attributePath.mFlags.Set(chip::app::AttributePathParams::Flags::kFieldIdValid);
+
+ ReturnErrorOnFailure(app::InteractionModelEngine::GetInstance()->NewWriteClient(handle));
+ ReturnErrorOnFailure(handle.EncodeScalarAttributeWritePayload(attributePath, seekRangeStart));
+
+ return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback);
+}
+
CHIP_ERROR MediaPlaybackClusterTest::WriteAttributeClusterRevision(Callback::Cancelable * onSuccessCallback,
Callback::Cancelable * onFailureCallback,
uint16_t clusterRevision)
diff --git a/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.h
index eba4574c7265ce..53e4cc1cddb37d 100644
--- a/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.h
+++ b/zzz_generated/controller-clusters/zap-generated/tests/CHIPClusters.h
@@ -523,6 +523,22 @@ class DLL_EXPORT MediaPlaybackClusterTest : public MediaPlaybackCluster
MediaPlaybackClusterTest() : MediaPlaybackCluster() {}
~MediaPlaybackClusterTest() {}
+ CHIP_ERROR WriteAttributePlaybackState(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint8_t value);
+ CHIP_ERROR WriteAttributeStartTime(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
+ CHIP_ERROR WriteAttributeDuration(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
+ CHIP_ERROR WriteAttributePositionUpdatedAt(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
+ CHIP_ERROR WriteAttributePosition(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
+ CHIP_ERROR WriteAttributePlaybackSpeed(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
+ CHIP_ERROR WriteAttributeSeekRangeEnd(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
+ CHIP_ERROR WriteAttributeSeekRangeStart(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
+ uint64_t value);
CHIP_ERROR WriteAttributeClusterRevision(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback,
uint16_t value);
};
diff --git a/zzz_generated/tv-app/zap-generated/endpoint_config.h b/zzz_generated/tv-app/zap-generated/endpoint_config.h
index 4f45413cf3a5f2..9f7edc2b518eb9 100644
--- a/zzz_generated/tv-app/zap-generated/endpoint_config.h
+++ b/zzz_generated/tv-app/zap-generated/endpoint_config.h
@@ -606,10 +606,10 @@
/* 6060 - duration, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 6068 - updated at, */ \
+ /* 6068 - position updated at, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 6076 - posistion, */ \
+ /* 6076 - position, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
/* 6084 - playback speed, */ \
@@ -1315,10 +1315,10 @@
/* 6060 - duration, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 6068 - updated at, */ \
+ /* 6068 - position updated at, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
- /* 6076 - posistion, */ \
+ /* 6076 - position, */ \
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
\
/* 6084 - playback speed, */ \
@@ -1699,8 +1699,8 @@
{ 0x0000, ZAP_TYPE(ENUM8), 1, 0, ZAP_SIMPLE_DEFAULT(0x00) }, /* playback state */ \
{ 0x0001, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6052) }, /* start time */ \
{ 0x0002, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6060) }, /* duration */ \
- { 0x0003, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6068) }, /* updated at */ \
- { 0x0004, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6076) }, /* posistion */ \
+ { 0x0003, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6068) }, /* position updated at */ \
+ { 0x0004, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6076) }, /* position */ \
{ 0x0005, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6084) }, /* playback speed */ \
{ 0x0006, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6092) }, /* seek range end */ \
{ 0x0007, ZAP_TYPE(INT64U), 8, 0, ZAP_LONG_DEFAULTS_INDEX(6100) }, /* seek range start */ \