diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml
index 308d0a688a46fe..fcd314e5de3b64 100644
--- a/.github/workflows/tests.yaml
+++ b/.github/workflows/tests.yaml
@@ -117,6 +117,7 @@ jobs:
src/app/zap-templates/zcl/data-model/chip/microwave-oven-mode-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/microwave-oven-control-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/door-lock-cluster.xml \
+ src/app/zap-templates/zcl/data-model/chip/energy-evse-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/ethernet-network-diagnostics-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/fan-control-cluster.xml \
src/app/zap-templates/zcl/data-model/chip/fault-injection-cluster.xml \
diff --git a/examples/chip-tool/templates/logging/DataModelLogger-src.zapt b/examples/chip-tool/templates/logging/DataModelLogger-src.zapt
index 167021f49577d2..e6c735465dbfc2 100644
--- a/examples/chip-tool/templates/logging/DataModelLogger-src.zapt
+++ b/examples/chip-tool/templates/logging/DataModelLogger-src.zapt
@@ -162,7 +162,7 @@ CHIP_ERROR DataModelLogger::LogEvent(const chip::app::EventHeader & header, chip
{{/first}}
case {{asUpperCamelCase parent.name}}::Events::{{asUpperCamelCase name}}::Id:
{
- {{zapTypeToDecodableClusterObjectType name ns=parent.name forceNotOptional=true}} value;
+ {{asUpperCamelCase parent.name}}::Events::{{asUpperCamelCase name}}::DecodableType value;
ReturnErrorOnFailure(chip::app::DataModel::Decode(*data, value));
return DataModelLogger::LogValue("{{name}}", 1, value);
}
diff --git a/scripts/rules.matterlint b/scripts/rules.matterlint
index 5f6883198c57f9..e5220517096ac1 100644
--- a/scripts/rules.matterlint
+++ b/scripts/rules.matterlint
@@ -28,6 +28,7 @@ load "../src/app/zap-templates/zcl/data-model/chip/dishwasher-mode-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/microwave-oven-mode-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/microwave-oven-control-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/door-lock-cluster.xml";
+load "../src/app/zap-templates/zcl/data-model/chip/energy-evse-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/ethernet-network-diagnostics-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/fan-control-cluster.xml";
load "../src/app/zap-templates/zcl/data-model/chip/fixed-label-cluster.xml";
diff --git a/src/app/zap-templates/zcl/data-model/all.xml b/src/app/zap-templates/zcl/data-model/all.xml
index dcb87db9350b50..d099283ba7f8da 100644
--- a/src/app/zap-templates/zcl/data-model/all.xml
+++ b/src/app/zap-templates/zcl/data-model/all.xml
@@ -28,6 +28,7 @@
+
diff --git a/src/app/zap-templates/zcl/data-model/chip/energy-evse-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/energy-evse-cluster.xml
new file mode 100644
index 00000000000000..8eed118f9ef953
--- /dev/null
+++ b/src/app/zap-templates/zcl/data-model/chip/energy-evse-cluster.xml
@@ -0,0 +1,224 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Energy EVSE
+ Energy Management
+ 0x0099
+ ENERGY_EVSE_CLUSTER
+ true
+ true
+ Electric Vehicle Supply Equipment (EVSE) is equipment used to charge an Electric Vehicle (EV) or Plug-In Hybrid Electric Vehicle. This cluster provides an interface to the functionality of Electric Vehicle Supply Equipment (EVSE) management.
+
+
+
+
+ State
+ SupplyState
+ FaultState
+ ChargingEnabledUntil
+
+ DischargingEnabledUntil
+ CircuitCapacity
+ MinimumChargeCurrent
+ MaximumChargeCurrent
+
+ MaximumDischargeCurrent
+
+
+
+ UserMaximumChargeCurrent
+
+
+
+
+ RandomizationDelayWindow
+
+
+ NumberOfWeeklyTargets
+
+ NumberOfDailyTargets
+
+ NextChargeStartTime
+
+ NextChargeTargetTime
+
+ NextChargeRequiredEnergy
+
+ NextChargeTargetSoC
+
+
+
+
+ ApproximateEVEfficiency
+
+
+ StateOfCharge
+
+ BatteryCapacity
+
+ VehicleID
+ SessionID
+ SessionDuration
+ SessionEnergyCharged
+
+ SessionEnergyDischarged
+
+
+ Allows a client to disable the EVSE from charging and discharging.
+
+
+
+
+
+
+ Allows a client to enable the EVSE to charge an EV.
+
+
+
+
+
+ Allows a client to enable the EVSE to discharge an EV.
+
+
+
+ Allows a client to put the EVSE into a self-diagnostics mode.
+
+
+
+
+
+ Allows a client to set the user specified charging targets.
+
+
+
+
+ Allows a client to retrieve the user specified charging targets.
+
+
+
+ Allows a client to clear all stored charging targets.
+
+
+
+
+ The GetTargetsResponse is sent in response to the GetTargets Command.
+
+
+ EVConnected
+
+
+
+ EVNotDetected
+
+
+
+
+
+
+
+ EnergyTransferStarted
+
+
+
+
+
+ EnergyTransferStopped
+
+
+
+
+
+
+ Fault
+
+
+
+
+
+
+ RFID
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/app/zap-templates/zcl/zcl-with-test-extensions.json b/src/app/zap-templates/zcl/zcl-with-test-extensions.json
index 2655fdad6367de..639a1311ced5bc 100644
--- a/src/app/zap-templates/zcl/zcl-with-test-extensions.json
+++ b/src/app/zap-templates/zcl/zcl-with-test-extensions.json
@@ -43,6 +43,7 @@
"microwave-oven-control-cluster.xml",
"door-lock-cluster.xml",
"electrical-measurement-cluster.xml",
+ "energy-evse-cluster.xml",
"ethernet-network-diagnostics-cluster.xml",
"fan-control-cluster.xml",
"fault-injection-cluster.xml",
diff --git a/src/app/zap-templates/zcl/zcl.json b/src/app/zap-templates/zcl/zcl.json
index 143615c32f8942..377ebd67b3b67a 100644
--- a/src/app/zap-templates/zcl/zcl.json
+++ b/src/app/zap-templates/zcl/zcl.json
@@ -41,6 +41,7 @@
"door-lock-cluster.xml",
"drlc-cluster.xml",
"electrical-measurement-cluster.xml",
+ "energy-evse-cluster.xml",
"ethernet-network-diagnostics-cluster.xml",
"fan-control-cluster.xml",
"fault-injection-cluster.xml",
diff --git a/src/app/zap_cluster_list.json b/src/app/zap_cluster_list.json
index 87b88730322461..c5c1feb7746e59 100644
--- a/src/app/zap_cluster_list.json
+++ b/src/app/zap_cluster_list.json
@@ -33,6 +33,7 @@
"MICROWAVE_OVEN_MODE_CLUSTER": [],
"DOOR_LOCK_CLUSTER": [],
"ELECTRICAL_MEASUREMENT_CLUSTER": [],
+ "ENERGY_EVSE_CLUSTER": [],
"ETHERNET_NETWORK_DIAGNOSTICS_CLUSTER": [],
"FAN_CONTROL_CLUSTER": [],
"FAULT_INJECTION_CLUSTER": [],
@@ -163,6 +164,7 @@
"MICROWAVE_OVEN_MODE_CLUSTER": ["mode-base-server"],
"DOOR_LOCK_CLUSTER": ["door-lock-server"],
"ELECTRICAL_MEASUREMENT_CLUSTER": [],
+ "ENERGY_EVSE_CLUSTER": ["energy-evse-server"],
"ETHERNET_NETWORK_DIAGNOSTICS_CLUSTER": [
"ethernet-network-diagnostics-server"
],
diff --git a/src/controller/data_model/BUILD.gn b/src/controller/data_model/BUILD.gn
index e65596de2d483e..7f1cb17fd75c55 100644
--- a/src/controller/data_model/BUILD.gn
+++ b/src/controller/data_model/BUILD.gn
@@ -124,6 +124,8 @@ if (current_os == "android" || matter_enable_java_compilation) {
"jni/ElectricalMeasurementClient-ReadImpl.cpp",
"jni/EthernetNetworkDiagnosticsClient-InvokeSubscribeImpl.cpp",
"jni/EthernetNetworkDiagnosticsClient-ReadImpl.cpp",
+ "jni/EnergyEvseClient-InvokeSubscribeImpl.cpp",
+ "jni/EnergyEvseClient-ReadImpl.cpp",
"jni/FanControlClient-InvokeSubscribeImpl.cpp",
"jni/FanControlClient-ReadImpl.cpp",
"jni/FaultInjectionClient-InvokeSubscribeImpl.cpp",
diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter
index 74c6b6f2502701..395161df94d592 100644
--- a/src/controller/data_model/controller-clusters.matter
+++ b/src/controller/data_model/controller-clusters.matter
@@ -4235,6 +4235,187 @@ provisional client cluster DemandResponseLoadControl = 150 {
command ClearLoadControlEventsRequest(): DefaultSuccess = 4;
}
+/** Electric Vehicle Supply Equipment (EVSE) is equipment used to charge an Electric Vehicle (EV) or Plug-In Hybrid Electric Vehicle. This cluster provides an interface to the functionality of Electric Vehicle Supply Equipment (EVSE) management. */
+provisional client cluster EnergyEvse = 153 {
+ revision 1; // NOTE: Default/not specifically set
+
+ enum EnergyTransferStoppedReasonEnum : enum8 {
+ kEVStopped = 0;
+ kEVSEStopped = 1;
+ kOther = 2;
+ }
+
+ enum FaultStateEnum : enum8 {
+ kNoError = 0;
+ kMeterFailure = 1;
+ kOverVoltage = 2;
+ kUnderVoltage = 3;
+ kOverCurrent = 4;
+ kContactWetFailure = 5;
+ kContactDryFailure = 6;
+ kGroundFault = 7;
+ kPowerLoss = 8;
+ kPowerQuality = 9;
+ kPilotShortCircuit = 10;
+ kEmergencyStop = 11;
+ kEVDisconnected = 12;
+ kWrongPowerSupply = 13;
+ kLiveNeutralSwap = 14;
+ kOverTemperature = 15;
+ kOther = 255;
+ }
+
+ enum StateEnum : enum8 {
+ kNotPluggedIn = 0;
+ kPluggedInNoDemand = 1;
+ kPluggedInDemand = 2;
+ kPluggedInCharging = 3;
+ kPluggedInDischarging = 4;
+ kSessionEnding = 5;
+ kFault = 6;
+ }
+
+ enum SupplyStateEnum : enum8 {
+ kDisabled = 0;
+ kChargingEnabled = 1;
+ kDischargingEnabled = 2;
+ kDisabledError = 3;
+ kDisabledDiagnostics = 4;
+ }
+
+ bitmap Feature : bitmap32 {
+ kChargingPreferences = 0x1;
+ kSoCReporting = 0x2;
+ kPlugAndCharge = 0x4;
+ kRFID = 0x8;
+ kV2X = 0x10;
+ }
+
+ bitmap TargetDayOfWeekBitmap : bitmap8 {
+ kSunday = 0x1;
+ kMonday = 0x2;
+ kTuesday = 0x4;
+ kWednesday = 0x8;
+ kThursday = 0x10;
+ kFriday = 0x20;
+ kSaturday = 0x40;
+ }
+
+ struct ChargingTargetStruct {
+ int16u targetTime = 0;
+ optional percent targetSoC = 1;
+ optional int64s addedEnergy = 2;
+ }
+
+ info event EVConnected = 0 {
+ int32u sessionID = 0;
+ }
+
+ info event EVNotDetected = 1 {
+ int32u sessionID = 0;
+ StateEnum state = 1;
+ elapsed_s sessionDuration = 2;
+ int64s sessionEnergyCharged = 3;
+ optional int64s sessionEnergyDischarged = 4;
+ }
+
+ info event EnergyTransferStarted = 2 {
+ int32u sessionID = 0;
+ StateEnum state = 1;
+ int64s maximumCurrent = 2;
+ }
+
+ info event EnergyTransferStopped = 3 {
+ int32u sessionID = 0;
+ StateEnum state = 1;
+ EnergyTransferStoppedReasonEnum reason = 2;
+ int64s energyTransferred = 4;
+ }
+
+ critical event Fault = 4 {
+ int32u sessionID = 0;
+ StateEnum state = 1;
+ FaultStateEnum faultStatePreviousState = 2;
+ FaultStateEnum faultStateCurrentState = 4;
+ }
+
+ info event RFID = 5 {
+ octet_string uid = 0;
+ }
+
+ readonly attribute nullable StateEnum state = 0;
+ readonly attribute SupplyStateEnum supplyState = 1;
+ readonly attribute FaultStateEnum faultState = 2;
+ readonly attribute nullable epoch_s chargingEnabledUntil = 3;
+ readonly attribute optional nullable epoch_s dischargingEnabledUntil = 4;
+ readonly attribute int64s circuitCapacity = 5;
+ readonly attribute int64s minimumChargeCurrent = 6;
+ readonly attribute int64s maximumChargeCurrent = 7;
+ readonly attribute optional int64s maximumDischargeCurrent = 8;
+ attribute access(write: manage) optional int64s userMaximumChargeCurrent = 9;
+ attribute access(write: manage) optional elapsed_s randomizationDelayWindow = 10;
+ readonly attribute optional int8u numberOfWeeklyTargets = 33;
+ readonly attribute optional int8u numberOfDailyTargets = 34;
+ readonly attribute optional nullable epoch_s nextChargeStartTime = 35;
+ readonly attribute optional nullable epoch_s nextChargeTargetTime = 36;
+ readonly attribute optional nullable int64s nextChargeRequiredEnergy = 37;
+ readonly attribute optional nullable percent nextChargeTargetSoC = 38;
+ attribute access(write: manage) optional nullable int16u approximateEVEfficiency = 39;
+ readonly attribute optional nullable percent stateOfCharge = 48;
+ readonly attribute optional nullable int64s batteryCapacity = 49;
+ readonly attribute optional nullable char_string<32> vehicleID = 50;
+ readonly attribute nullable int32u sessionID = 64;
+ readonly attribute elapsed_s sessionDuration = 65;
+ readonly attribute int64s sessionEnergyCharged = 66;
+ readonly attribute optional int64s sessionEnergyDischarged = 67;
+ readonly attribute command_id generatedCommandList[] = 65528;
+ readonly attribute command_id acceptedCommandList[] = 65529;
+ readonly attribute event_id eventList[] = 65530;
+ readonly attribute attrib_id attributeList[] = 65531;
+ readonly attribute bitmap32 featureMap = 65532;
+ readonly attribute int16u clusterRevision = 65533;
+
+ response struct GetTargetsResponse = 0 {
+ TargetDayOfWeekBitmap dayOfWeekforSequence = 0;
+ ChargingTargetStruct chargingTargets[] = 1;
+ }
+
+ request struct EnableChargingRequest {
+ nullable epoch_s chargingEnabledUntil = 0;
+ int64s minimumChargeCurrent = 1;
+ int64s maximumChargeCurrent = 2;
+ }
+
+ request struct EnableDischargingRequest {
+ nullable epoch_s dischargingEnabledUntil = 0;
+ int64s maximumDischargeCurrent = 1;
+ }
+
+ request struct SetTargetsRequest {
+ TargetDayOfWeekBitmap dayOfWeekforSequence = 0;
+ ChargingTargetStruct chargingTargets[] = 1;
+ }
+
+ request struct GetTargetsRequest {
+ TargetDayOfWeekBitmap daysToReturn = 0;
+ }
+
+ /** Allows a client to disable the EVSE from charging and discharging. */
+ timed command Disable(): DefaultSuccess = 1;
+ /** Allows a client to enable the EVSE to charge an EV. */
+ timed command EnableCharging(EnableChargingRequest): DefaultSuccess = 2;
+ /** Allows a client to enable the EVSE to discharge an EV. */
+ timed command EnableDischarging(EnableDischargingRequest): DefaultSuccess = 3;
+ /** Allows a client to put the EVSE into a self-diagnostics mode. */
+ timed command StartDiagnostics(): DefaultSuccess = 4;
+ /** Allows a client to set the user specified charging targets. */
+ timed command SetTargets(SetTargetsRequest): DefaultSuccess = 5;
+ /** Allows a client to retrieve the user specified charging targets. */
+ timed command GetTargets(GetTargetsRequest): GetTargetsResponse = 6;
+ /** Allows a client to clear all stored charging targets. */
+ timed command ClearTargets(): DefaultSuccess = 7;
+}
+
/** An interface to a generic way to secure a door */
client cluster DoorLock = 257 {
revision 7;
diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap
index 181e669291f113..446e4b5fefc228 100644
--- a/src/controller/data_model/controller-clusters.zap
+++ b/src/controller/data_model/controller-clusters.zap
@@ -17,12 +17,6 @@
}
],
"package": [
- {
- "pathRelativity": "relativeToZap",
- "path": "../../app/zap-templates/app-templates.json",
- "type": "gen-templates-json",
- "version": "chip-v1"
- },
{
"pathRelativity": "relativeToZap",
"path": "../../app/zap-templates/zcl/zcl.json",
@@ -30,6 +24,12 @@
"category": "matter",
"version": 1,
"description": "Matter SDK ZCL data"
+ },
+ {
+ "pathRelativity": "relativeToZap",
+ "path": "../../app/zap-templates/app-templates.json",
+ "type": "gen-templates-json",
+ "version": "chip-v1"
}
],
"endpointTypes": [
@@ -3026,6 +3026,67 @@
}
]
},
+ {
+ "name": "Energy EVSE",
+ "code": 153,
+ "mfgCode": null,
+ "define": "ENERGY_EVSE_CLUSTER",
+ "side": "client",
+ "enabled": 1,
+ "apiMaturity": "provisional",
+ "commands": [
+ {
+ "name": "Disable",
+ "code": 1,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 0,
+ "isEnabled": 1
+ },
+ {
+ "name": "EnableCharging",
+ "code": 2,
+ "mfgCode": null,
+ "source": "client",
+ "isIncoming": 0,
+ "isEnabled": 1
+ }
+ ],
+ "attributes": [
+ {
+ "name": "FeatureMap",
+ "code": 65532,
+ "mfgCode": null,
+ "side": "client",
+ "type": "bitmap32",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "0",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ },
+ {
+ "name": "ClusterRevision",
+ "code": 65533,
+ "mfgCode": null,
+ "side": "client",
+ "type": "int16u",
+ "included": 1,
+ "storageOption": "RAM",
+ "singleton": 0,
+ "bounded": 0,
+ "defaultValue": "1",
+ "reportable": 1,
+ "minInterval": 1,
+ "maxInterval": 65534,
+ "reportableChange": 0
+ }
+ ]
+ },
{
"name": "Door Lock",
"code": 257,
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
index 6a3327b98b45ed..07abc1d8db6a68 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ChipClusters.java
@@ -28365,6 +28365,1062 @@ public void onSuccess(byte[] tlv) {
}
}
+ public static class EnergyEvseCluster extends BaseChipCluster {
+ public static final long CLUSTER_ID = 153L;
+
+ private static final long STATE_ATTRIBUTE_ID = 0L;
+ private static final long SUPPLY_STATE_ATTRIBUTE_ID = 1L;
+ private static final long FAULT_STATE_ATTRIBUTE_ID = 2L;
+ private static final long CHARGING_ENABLED_UNTIL_ATTRIBUTE_ID = 3L;
+ private static final long DISCHARGING_ENABLED_UNTIL_ATTRIBUTE_ID = 4L;
+ private static final long CIRCUIT_CAPACITY_ATTRIBUTE_ID = 5L;
+ private static final long MINIMUM_CHARGE_CURRENT_ATTRIBUTE_ID = 6L;
+ private static final long MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID = 7L;
+ private static final long MAXIMUM_DISCHARGE_CURRENT_ATTRIBUTE_ID = 8L;
+ private static final long USER_MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID = 9L;
+ private static final long RANDOMIZATION_DELAY_WINDOW_ATTRIBUTE_ID = 10L;
+ private static final long NUMBER_OF_WEEKLY_TARGETS_ATTRIBUTE_ID = 33L;
+ private static final long NUMBER_OF_DAILY_TARGETS_ATTRIBUTE_ID = 34L;
+ private static final long NEXT_CHARGE_START_TIME_ATTRIBUTE_ID = 35L;
+ private static final long NEXT_CHARGE_TARGET_TIME_ATTRIBUTE_ID = 36L;
+ private static final long NEXT_CHARGE_REQUIRED_ENERGY_ATTRIBUTE_ID = 37L;
+ private static final long NEXT_CHARGE_TARGET_SO_C_ATTRIBUTE_ID = 38L;
+ private static final long APPROXIMATE_E_V_EFFICIENCY_ATTRIBUTE_ID = 39L;
+ private static final long STATE_OF_CHARGE_ATTRIBUTE_ID = 48L;
+ private static final long BATTERY_CAPACITY_ATTRIBUTE_ID = 49L;
+ private static final long VEHICLE_I_D_ATTRIBUTE_ID = 50L;
+ private static final long SESSION_I_D_ATTRIBUTE_ID = 64L;
+ private static final long SESSION_DURATION_ATTRIBUTE_ID = 65L;
+ private static final long SESSION_ENERGY_CHARGED_ATTRIBUTE_ID = 66L;
+ private static final long SESSION_ENERGY_DISCHARGED_ATTRIBUTE_ID = 67L;
+ private static final long GENERATED_COMMAND_LIST_ATTRIBUTE_ID = 65528L;
+ private static final long ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID = 65529L;
+ private static final long EVENT_LIST_ATTRIBUTE_ID = 65530L;
+ private static final long ATTRIBUTE_LIST_ATTRIBUTE_ID = 65531L;
+ private static final long FEATURE_MAP_ATTRIBUTE_ID = 65532L;
+ private static final long CLUSTER_REVISION_ATTRIBUTE_ID = 65533L;
+
+ public EnergyEvseCluster(long devicePtr, int endpointId) {
+ super(devicePtr, endpointId, CLUSTER_ID);
+ }
+
+ @Override
+ @Deprecated
+ public long initWithDevice(long devicePtr, int endpointId) {
+ return 0L;
+ }
+
+
+ public void disable(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+ final long commandId = 1L;
+
+ ArrayList elements = new ArrayList<>();
+ StructType value = new StructType(elements);
+ invoke(new InvokeCallbackImpl(callback) {
+ @Override
+ public void onResponse(StructType invokeStructValue) {
+ callback.onSuccess();
+ }}, commandId, value, timedInvokeTimeoutMs);
+ }
+
+
+ public void enableCharging(DefaultClusterCallback callback, @Nullable Long chargingEnabledUntil, Long minimumChargeCurrent, Long maximumChargeCurrent, int timedInvokeTimeoutMs) {
+ final long commandId = 2L;
+
+ ArrayList elements = new ArrayList<>();
+ final long chargingEnabledUntilFieldID = 0L;
+ BaseTLVType chargingEnabledUntiltlvValue = chargingEnabledUntil != null ? new UIntType(chargingEnabledUntil) : new NullType();
+ elements.add(new StructElement(chargingEnabledUntilFieldID, chargingEnabledUntiltlvValue));
+
+ final long minimumChargeCurrentFieldID = 1L;
+ BaseTLVType minimumChargeCurrenttlvValue = new IntType(minimumChargeCurrent);
+ elements.add(new StructElement(minimumChargeCurrentFieldID, minimumChargeCurrenttlvValue));
+
+ final long maximumChargeCurrentFieldID = 2L;
+ BaseTLVType maximumChargeCurrenttlvValue = new IntType(maximumChargeCurrent);
+ elements.add(new StructElement(maximumChargeCurrentFieldID, maximumChargeCurrenttlvValue));
+
+ StructType value = new StructType(elements);
+ invoke(new InvokeCallbackImpl(callback) {
+ @Override
+ public void onResponse(StructType invokeStructValue) {
+ callback.onSuccess();
+ }}, commandId, value, timedInvokeTimeoutMs);
+ }
+
+
+ public void enableDischarging(DefaultClusterCallback callback, @Nullable Long dischargingEnabledUntil, Long maximumDischargeCurrent, int timedInvokeTimeoutMs) {
+ final long commandId = 3L;
+
+ ArrayList elements = new ArrayList<>();
+ final long dischargingEnabledUntilFieldID = 0L;
+ BaseTLVType dischargingEnabledUntiltlvValue = dischargingEnabledUntil != null ? new UIntType(dischargingEnabledUntil) : new NullType();
+ elements.add(new StructElement(dischargingEnabledUntilFieldID, dischargingEnabledUntiltlvValue));
+
+ final long maximumDischargeCurrentFieldID = 1L;
+ BaseTLVType maximumDischargeCurrenttlvValue = new IntType(maximumDischargeCurrent);
+ elements.add(new StructElement(maximumDischargeCurrentFieldID, maximumDischargeCurrenttlvValue));
+
+ StructType value = new StructType(elements);
+ invoke(new InvokeCallbackImpl(callback) {
+ @Override
+ public void onResponse(StructType invokeStructValue) {
+ callback.onSuccess();
+ }}, commandId, value, timedInvokeTimeoutMs);
+ }
+
+
+ public void startDiagnostics(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+ final long commandId = 4L;
+
+ ArrayList elements = new ArrayList<>();
+ StructType value = new StructType(elements);
+ invoke(new InvokeCallbackImpl(callback) {
+ @Override
+ public void onResponse(StructType invokeStructValue) {
+ callback.onSuccess();
+ }}, commandId, value, timedInvokeTimeoutMs);
+ }
+
+
+ public void setTargets(DefaultClusterCallback callback, Integer dayOfWeekforSequence, ArrayList chargingTargets, int timedInvokeTimeoutMs) {
+ final long commandId = 5L;
+
+ ArrayList elements = new ArrayList<>();
+ final long dayOfWeekforSequenceFieldID = 0L;
+ BaseTLVType dayOfWeekforSequencetlvValue = new UIntType(dayOfWeekforSequence);
+ elements.add(new StructElement(dayOfWeekforSequenceFieldID, dayOfWeekforSequencetlvValue));
+
+ final long chargingTargetsFieldID = 1L;
+ BaseTLVType chargingTargetstlvValue = ArrayType.generateArrayType(chargingTargets, (elementchargingTargets) -> elementchargingTargets.encodeTlv());
+ elements.add(new StructElement(chargingTargetsFieldID, chargingTargetstlvValue));
+
+ StructType value = new StructType(elements);
+ invoke(new InvokeCallbackImpl(callback) {
+ @Override
+ public void onResponse(StructType invokeStructValue) {
+ callback.onSuccess();
+ }}, commandId, value, timedInvokeTimeoutMs);
+ }
+
+
+ public void getTargets(GetTargetsResponseCallback callback, Integer daysToReturn, int timedInvokeTimeoutMs) {
+ final long commandId = 6L;
+
+ ArrayList elements = new ArrayList<>();
+ final long daysToReturnFieldID = 0L;
+ BaseTLVType daysToReturntlvValue = new UIntType(daysToReturn);
+ elements.add(new StructElement(daysToReturnFieldID, daysToReturntlvValue));
+
+ StructType value = new StructType(elements);
+ invoke(new InvokeCallbackImpl(callback) {
+ @Override
+ public void onResponse(StructType invokeStructValue) {
+ final long dayOfWeekforSequenceFieldID = 0L;
+ Integer dayOfWeekforSequence = null;
+ final long chargingTargetsFieldID = 1L;
+ ArrayList chargingTargets = null;
+ for (StructElement element: invokeStructValue.value()) {
+ if (element.contextTagNum() == dayOfWeekforSequenceFieldID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ dayOfWeekforSequence = castingValue.value(Integer.class);
+ }
+ } else if (element.contextTagNum() == chargingTargetsFieldID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.Array) {
+ ArrayType castingValue = element.value(ArrayType.class);
+ chargingTargets = castingValue.map((elementcastingValue) -> ChipStructs.EnergyEvseClusterChargingTargetStruct.decodeTlv(elementcastingValue));
+ }
+ }
+ }
+ callback.onSuccess(dayOfWeekforSequence, chargingTargets);
+ }}, commandId, value, timedInvokeTimeoutMs);
+ }
+
+
+ public void clearTargets(DefaultClusterCallback callback, int timedInvokeTimeoutMs) {
+ final long commandId = 7L;
+
+ ArrayList elements = new ArrayList<>();
+ StructType value = new StructType(elements);
+ invoke(new InvokeCallbackImpl(callback) {
+ @Override
+ public void onResponse(StructType invokeStructValue) {
+ callback.onSuccess();
+ }}, commandId, value, timedInvokeTimeoutMs);
+ }
+
+ public interface GetTargetsResponseCallback extends BaseClusterCallback {
+ void onSuccess(Integer dayOfWeekforSequence, ArrayList chargingTargets);
+ }
+
+ public interface StateAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Integer value);
+ }
+
+ public interface ChargingEnabledUntilAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Long value);
+ }
+
+ public interface DischargingEnabledUntilAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Long value);
+ }
+
+ public interface NextChargeStartTimeAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Long value);
+ }
+
+ public interface NextChargeTargetTimeAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Long value);
+ }
+
+ public interface NextChargeRequiredEnergyAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Long value);
+ }
+
+ public interface NextChargeTargetSoCAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Integer value);
+ }
+
+ public interface ApproximateEVEfficiencyAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Integer value);
+ }
+
+ public interface StateOfChargeAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Integer value);
+ }
+
+ public interface BatteryCapacityAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Long value);
+ }
+
+ public interface VehicleIDAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable String value);
+ }
+
+ public interface SessionIDAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(@Nullable Long value);
+ }
+
+ public interface GeneratedCommandListAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(List value);
+ }
+
+ public interface AcceptedCommandListAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(List value);
+ }
+
+ public interface EventListAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(List value);
+ }
+
+ public interface AttributeListAttributeCallback extends BaseAttributeCallback {
+ void onSuccess(List value);
+ }
+
+ public void readStateAttribute(
+ StateAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, STATE_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeStateAttribute(
+ StateAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, STATE_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readSupplyStateAttribute(
+ IntegerAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPLY_STATE_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, SUPPLY_STATE_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeSupplyStateAttribute(
+ IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SUPPLY_STATE_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, SUPPLY_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readFaultStateAttribute(
+ IntegerAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FAULT_STATE_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, FAULT_STATE_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeFaultStateAttribute(
+ IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FAULT_STATE_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, FAULT_STATE_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readChargingEnabledUntilAttribute(
+ ChargingEnabledUntilAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHARGING_ENABLED_UNTIL_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, CHARGING_ENABLED_UNTIL_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeChargingEnabledUntilAttribute(
+ ChargingEnabledUntilAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CHARGING_ENABLED_UNTIL_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, CHARGING_ENABLED_UNTIL_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readDischargingEnabledUntilAttribute(
+ DischargingEnabledUntilAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DISCHARGING_ENABLED_UNTIL_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, DISCHARGING_ENABLED_UNTIL_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeDischargingEnabledUntilAttribute(
+ DischargingEnabledUntilAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, DISCHARGING_ENABLED_UNTIL_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, DISCHARGING_ENABLED_UNTIL_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readCircuitCapacityAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CIRCUIT_CAPACITY_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, CIRCUIT_CAPACITY_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeCircuitCapacityAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CIRCUIT_CAPACITY_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, CIRCUIT_CAPACITY_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readMinimumChargeCurrentAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MINIMUM_CHARGE_CURRENT_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, MINIMUM_CHARGE_CURRENT_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeMinimumChargeCurrentAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MINIMUM_CHARGE_CURRENT_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, MINIMUM_CHARGE_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readMaximumChargeCurrentAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeMaximumChargeCurrentAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readMaximumDischargeCurrentAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAXIMUM_DISCHARGE_CURRENT_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, MAXIMUM_DISCHARGE_CURRENT_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeMaximumDischargeCurrentAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, MAXIMUM_DISCHARGE_CURRENT_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, MAXIMUM_DISCHARGE_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readUserMaximumChargeCurrentAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, USER_MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, USER_MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID, true);
+ }
+
+ public void writeUserMaximumChargeCurrentAttribute(DefaultClusterCallback callback, Long value) {
+ writeUserMaximumChargeCurrentAttribute(callback, value, 0);
+ }
+
+ public void writeUserMaximumChargeCurrentAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+ BaseTLVType tlvValue = new IntType(value);
+ writeAttribute(new WriteAttributesCallbackImpl(callback), USER_MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+ }
+
+ public void subscribeUserMaximumChargeCurrentAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, USER_MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, USER_MAXIMUM_CHARGE_CURRENT_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readRandomizationDelayWindowAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANDOMIZATION_DELAY_WINDOW_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, RANDOMIZATION_DELAY_WINDOW_ATTRIBUTE_ID, true);
+ }
+
+ public void writeRandomizationDelayWindowAttribute(DefaultClusterCallback callback, Long value) {
+ writeRandomizationDelayWindowAttribute(callback, value, 0);
+ }
+
+ public void writeRandomizationDelayWindowAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) {
+ BaseTLVType tlvValue = new UIntType(value);
+ writeAttribute(new WriteAttributesCallbackImpl(callback), RANDOMIZATION_DELAY_WINDOW_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+ }
+
+ public void subscribeRandomizationDelayWindowAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, RANDOMIZATION_DELAY_WINDOW_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, RANDOMIZATION_DELAY_WINDOW_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readNumberOfWeeklyTargetsAttribute(
+ IntegerAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_WEEKLY_TARGETS_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, NUMBER_OF_WEEKLY_TARGETS_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeNumberOfWeeklyTargetsAttribute(
+ IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_WEEKLY_TARGETS_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, NUMBER_OF_WEEKLY_TARGETS_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readNumberOfDailyTargetsAttribute(
+ IntegerAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_DAILY_TARGETS_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, NUMBER_OF_DAILY_TARGETS_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeNumberOfDailyTargetsAttribute(
+ IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NUMBER_OF_DAILY_TARGETS_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, NUMBER_OF_DAILY_TARGETS_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readNextChargeStartTimeAttribute(
+ NextChargeStartTimeAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEXT_CHARGE_START_TIME_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, NEXT_CHARGE_START_TIME_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeNextChargeStartTimeAttribute(
+ NextChargeStartTimeAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEXT_CHARGE_START_TIME_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, NEXT_CHARGE_START_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readNextChargeTargetTimeAttribute(
+ NextChargeTargetTimeAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEXT_CHARGE_TARGET_TIME_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, NEXT_CHARGE_TARGET_TIME_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeNextChargeTargetTimeAttribute(
+ NextChargeTargetTimeAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEXT_CHARGE_TARGET_TIME_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, NEXT_CHARGE_TARGET_TIME_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readNextChargeRequiredEnergyAttribute(
+ NextChargeRequiredEnergyAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEXT_CHARGE_REQUIRED_ENERGY_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, NEXT_CHARGE_REQUIRED_ENERGY_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeNextChargeRequiredEnergyAttribute(
+ NextChargeRequiredEnergyAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEXT_CHARGE_REQUIRED_ENERGY_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, NEXT_CHARGE_REQUIRED_ENERGY_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readNextChargeTargetSoCAttribute(
+ NextChargeTargetSoCAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEXT_CHARGE_TARGET_SO_C_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, NEXT_CHARGE_TARGET_SO_C_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeNextChargeTargetSoCAttribute(
+ NextChargeTargetSoCAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, NEXT_CHARGE_TARGET_SO_C_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, NEXT_CHARGE_TARGET_SO_C_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readApproximateEVEfficiencyAttribute(
+ ApproximateEVEfficiencyAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPROXIMATE_E_V_EFFICIENCY_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, APPROXIMATE_E_V_EFFICIENCY_ATTRIBUTE_ID, true);
+ }
+
+ public void writeApproximateEVEfficiencyAttribute(DefaultClusterCallback callback, Integer value) {
+ writeApproximateEVEfficiencyAttribute(callback, value, 0);
+ }
+
+ public void writeApproximateEVEfficiencyAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) {
+ BaseTLVType tlvValue = value != null ? new UIntType(value) : new NullType();
+ writeAttribute(new WriteAttributesCallbackImpl(callback), APPROXIMATE_E_V_EFFICIENCY_ATTRIBUTE_ID, tlvValue, timedWriteTimeoutMs);
+ }
+
+ public void subscribeApproximateEVEfficiencyAttribute(
+ ApproximateEVEfficiencyAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, APPROXIMATE_E_V_EFFICIENCY_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, APPROXIMATE_E_V_EFFICIENCY_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readStateOfChargeAttribute(
+ StateOfChargeAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_OF_CHARGE_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, STATE_OF_CHARGE_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeStateOfChargeAttribute(
+ StateOfChargeAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, STATE_OF_CHARGE_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, STATE_OF_CHARGE_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readBatteryCapacityAttribute(
+ BatteryCapacityAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BATTERY_CAPACITY_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, BATTERY_CAPACITY_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeBatteryCapacityAttribute(
+ BatteryCapacityAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, BATTERY_CAPACITY_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, BATTERY_CAPACITY_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readVehicleIDAttribute(
+ VehicleIDAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VEHICLE_I_D_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, VEHICLE_I_D_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeVehicleIDAttribute(
+ VehicleIDAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, VEHICLE_I_D_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable String value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, VEHICLE_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readSessionIDAttribute(
+ SessionIDAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SESSION_I_D_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, SESSION_I_D_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeSessionIDAttribute(
+ SessionIDAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SESSION_I_D_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ @Nullable Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, SESSION_I_D_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readSessionDurationAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SESSION_DURATION_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, SESSION_DURATION_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeSessionDurationAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SESSION_DURATION_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, SESSION_DURATION_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readSessionEnergyChargedAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SESSION_ENERGY_CHARGED_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, SESSION_ENERGY_CHARGED_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeSessionEnergyChargedAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SESSION_ENERGY_CHARGED_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, SESSION_ENERGY_CHARGED_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readSessionEnergyDischargedAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SESSION_ENERGY_DISCHARGED_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, SESSION_ENERGY_DISCHARGED_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeSessionEnergyDischargedAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, SESSION_ENERGY_DISCHARGED_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, SESSION_ENERGY_DISCHARGED_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readGeneratedCommandListAttribute(
+ GeneratedCommandListAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeGeneratedCommandListAttribute(
+ GeneratedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, GENERATED_COMMAND_LIST_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, GENERATED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readAcceptedCommandListAttribute(
+ AcceptedCommandListAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeAcceptedCommandListAttribute(
+ AcceptedCommandListAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, ACCEPTED_COMMAND_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readEventListAttribute(
+ EventListAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, EVENT_LIST_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeEventListAttribute(
+ EventListAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, EVENT_LIST_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, EVENT_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readAttributeListAttribute(
+ AttributeListAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, ATTRIBUTE_LIST_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeAttributeListAttribute(
+ AttributeListAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, ATTRIBUTE_LIST_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ List value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, ATTRIBUTE_LIST_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readFeatureMapAttribute(
+ LongAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, FEATURE_MAP_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeFeatureMapAttribute(
+ LongAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, FEATURE_MAP_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Long value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, FEATURE_MAP_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+
+ public void readClusterRevisionAttribute(
+ IntegerAttributeCallback callback) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+ readAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ callback.onSuccess(value);
+ }
+ }, CLUSTER_REVISION_ATTRIBUTE_ID, true);
+ }
+
+ public void subscribeClusterRevisionAttribute(
+ IntegerAttributeCallback callback, int minInterval, int maxInterval) {
+ ChipAttributePath path = ChipAttributePath.newInstance(endpointId, clusterId, CLUSTER_REVISION_ATTRIBUTE_ID);
+
+ subscribeAttribute(new ReportCallbackImpl(callback, path) {
+ @Override
+ public void onSuccess(byte[] tlv) {
+ Integer value = ChipTLVValueDecoder.decodeAttributeValue(path, tlv);
+ }
+ }, CLUSTER_REVISION_ATTRIBUTE_ID, minInterval, maxInterval);
+ }
+ }
+
public static class DoorLockCluster extends BaseChipCluster {
public static final long CLUSTER_ID = 257L;
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
index 9c48ad3dcdcb70..47cdeb84a31298 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ChipEventStructs.java
@@ -3119,6 +3119,462 @@ public String toString() {
return output.toString();
}
}
+public static class EnergyEvseClusterEVConnectedEvent {
+ public Long sessionID;
+ private static final long SESSION_I_D_ID = 0L;
+
+ public EnergyEvseClusterEVConnectedEvent(
+ Long sessionID
+ ) {
+ this.sessionID = sessionID;
+ }
+
+ public StructType encodeTlv() {
+ ArrayList values = new ArrayList<>();
+ values.add(new StructElement(SESSION_I_D_ID, new UIntType(sessionID)));
+
+ return new StructType(values);
+ }
+
+ public static EnergyEvseClusterEVConnectedEvent decodeTlv(BaseTLVType tlvValue) {
+ if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+ return null;
+ }
+ Long sessionID = null;
+ for (StructElement element: ((StructType)tlvValue).value()) {
+ if (element.contextTagNum() == SESSION_I_D_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ sessionID = castingValue.value(Long.class);
+ }
+ }
+ }
+ return new EnergyEvseClusterEVConnectedEvent(
+ sessionID
+ );
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder output = new StringBuilder();
+ output.append("EnergyEvseClusterEVConnectedEvent {\n");
+ output.append("\tsessionID: ");
+ output.append(sessionID);
+ output.append("\n");
+ output.append("}\n");
+ return output.toString();
+ }
+}
+public static class EnergyEvseClusterEVNotDetectedEvent {
+ public Long sessionID;
+ public Integer state;
+ public Long sessionDuration;
+ public Long sessionEnergyCharged;
+ public Optional sessionEnergyDischarged;
+ private static final long SESSION_I_D_ID = 0L;
+ private static final long STATE_ID = 1L;
+ private static final long SESSION_DURATION_ID = 2L;
+ private static final long SESSION_ENERGY_CHARGED_ID = 3L;
+ private static final long SESSION_ENERGY_DISCHARGED_ID = 4L;
+
+ public EnergyEvseClusterEVNotDetectedEvent(
+ Long sessionID,
+ Integer state,
+ Long sessionDuration,
+ Long sessionEnergyCharged,
+ Optional sessionEnergyDischarged
+ ) {
+ this.sessionID = sessionID;
+ this.state = state;
+ this.sessionDuration = sessionDuration;
+ this.sessionEnergyCharged = sessionEnergyCharged;
+ this.sessionEnergyDischarged = sessionEnergyDischarged;
+ }
+
+ public StructType encodeTlv() {
+ ArrayList values = new ArrayList<>();
+ values.add(new StructElement(SESSION_I_D_ID, new UIntType(sessionID)));
+ values.add(new StructElement(STATE_ID, new UIntType(state)));
+ values.add(new StructElement(SESSION_DURATION_ID, new UIntType(sessionDuration)));
+ values.add(new StructElement(SESSION_ENERGY_CHARGED_ID, new IntType(sessionEnergyCharged)));
+ values.add(new StructElement(SESSION_ENERGY_DISCHARGED_ID, sessionEnergyDischarged.map((nonOptionalsessionEnergyDischarged) -> new IntType(nonOptionalsessionEnergyDischarged)).orElse(new EmptyType())));
+
+ return new StructType(values);
+ }
+
+ public static EnergyEvseClusterEVNotDetectedEvent decodeTlv(BaseTLVType tlvValue) {
+ if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+ return null;
+ }
+ Long sessionID = null;
+ Integer state = null;
+ Long sessionDuration = null;
+ Long sessionEnergyCharged = null;
+ Optional sessionEnergyDischarged = Optional.empty();
+ for (StructElement element: ((StructType)tlvValue).value()) {
+ if (element.contextTagNum() == SESSION_I_D_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ sessionID = castingValue.value(Long.class);
+ }
+ } else if (element.contextTagNum() == STATE_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ state = castingValue.value(Integer.class);
+ }
+ } else if (element.contextTagNum() == SESSION_DURATION_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ sessionDuration = castingValue.value(Long.class);
+ }
+ } else if (element.contextTagNum() == SESSION_ENERGY_CHARGED_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+ IntType castingValue = element.value(IntType.class);
+ sessionEnergyCharged = castingValue.value(Long.class);
+ }
+ } else if (element.contextTagNum() == SESSION_ENERGY_DISCHARGED_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+ IntType castingValue = element.value(IntType.class);
+ sessionEnergyDischarged = Optional.of(castingValue.value(Long.class));
+ }
+ }
+ }
+ return new EnergyEvseClusterEVNotDetectedEvent(
+ sessionID,
+ state,
+ sessionDuration,
+ sessionEnergyCharged,
+ sessionEnergyDischarged
+ );
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder output = new StringBuilder();
+ output.append("EnergyEvseClusterEVNotDetectedEvent {\n");
+ output.append("\tsessionID: ");
+ output.append(sessionID);
+ output.append("\n");
+ output.append("\tstate: ");
+ output.append(state);
+ output.append("\n");
+ output.append("\tsessionDuration: ");
+ output.append(sessionDuration);
+ output.append("\n");
+ output.append("\tsessionEnergyCharged: ");
+ output.append(sessionEnergyCharged);
+ output.append("\n");
+ output.append("\tsessionEnergyDischarged: ");
+ output.append(sessionEnergyDischarged);
+ output.append("\n");
+ output.append("}\n");
+ return output.toString();
+ }
+}
+public static class EnergyEvseClusterEnergyTransferStartedEvent {
+ public Long sessionID;
+ public Integer state;
+ public Long maximumCurrent;
+ private static final long SESSION_I_D_ID = 0L;
+ private static final long STATE_ID = 1L;
+ private static final long MAXIMUM_CURRENT_ID = 2L;
+
+ public EnergyEvseClusterEnergyTransferStartedEvent(
+ Long sessionID,
+ Integer state,
+ Long maximumCurrent
+ ) {
+ this.sessionID = sessionID;
+ this.state = state;
+ this.maximumCurrent = maximumCurrent;
+ }
+
+ public StructType encodeTlv() {
+ ArrayList values = new ArrayList<>();
+ values.add(new StructElement(SESSION_I_D_ID, new UIntType(sessionID)));
+ values.add(new StructElement(STATE_ID, new UIntType(state)));
+ values.add(new StructElement(MAXIMUM_CURRENT_ID, new IntType(maximumCurrent)));
+
+ return new StructType(values);
+ }
+
+ public static EnergyEvseClusterEnergyTransferStartedEvent decodeTlv(BaseTLVType tlvValue) {
+ if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+ return null;
+ }
+ Long sessionID = null;
+ Integer state = null;
+ Long maximumCurrent = null;
+ for (StructElement element: ((StructType)tlvValue).value()) {
+ if (element.contextTagNum() == SESSION_I_D_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ sessionID = castingValue.value(Long.class);
+ }
+ } else if (element.contextTagNum() == STATE_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ state = castingValue.value(Integer.class);
+ }
+ } else if (element.contextTagNum() == MAXIMUM_CURRENT_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+ IntType castingValue = element.value(IntType.class);
+ maximumCurrent = castingValue.value(Long.class);
+ }
+ }
+ }
+ return new EnergyEvseClusterEnergyTransferStartedEvent(
+ sessionID,
+ state,
+ maximumCurrent
+ );
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder output = new StringBuilder();
+ output.append("EnergyEvseClusterEnergyTransferStartedEvent {\n");
+ output.append("\tsessionID: ");
+ output.append(sessionID);
+ output.append("\n");
+ output.append("\tstate: ");
+ output.append(state);
+ output.append("\n");
+ output.append("\tmaximumCurrent: ");
+ output.append(maximumCurrent);
+ output.append("\n");
+ output.append("}\n");
+ return output.toString();
+ }
+}
+public static class EnergyEvseClusterEnergyTransferStoppedEvent {
+ public Long sessionID;
+ public Integer state;
+ public Integer reason;
+ public Long energyTransferred;
+ private static final long SESSION_I_D_ID = 0L;
+ private static final long STATE_ID = 1L;
+ private static final long REASON_ID = 2L;
+ private static final long ENERGY_TRANSFERRED_ID = 4L;
+
+ public EnergyEvseClusterEnergyTransferStoppedEvent(
+ Long sessionID,
+ Integer state,
+ Integer reason,
+ Long energyTransferred
+ ) {
+ this.sessionID = sessionID;
+ this.state = state;
+ this.reason = reason;
+ this.energyTransferred = energyTransferred;
+ }
+
+ public StructType encodeTlv() {
+ ArrayList values = new ArrayList<>();
+ values.add(new StructElement(SESSION_I_D_ID, new UIntType(sessionID)));
+ values.add(new StructElement(STATE_ID, new UIntType(state)));
+ values.add(new StructElement(REASON_ID, new UIntType(reason)));
+ values.add(new StructElement(ENERGY_TRANSFERRED_ID, new IntType(energyTransferred)));
+
+ return new StructType(values);
+ }
+
+ public static EnergyEvseClusterEnergyTransferStoppedEvent decodeTlv(BaseTLVType tlvValue) {
+ if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+ return null;
+ }
+ Long sessionID = null;
+ Integer state = null;
+ Integer reason = null;
+ Long energyTransferred = null;
+ for (StructElement element: ((StructType)tlvValue).value()) {
+ if (element.contextTagNum() == SESSION_I_D_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ sessionID = castingValue.value(Long.class);
+ }
+ } else if (element.contextTagNum() == STATE_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ state = castingValue.value(Integer.class);
+ }
+ } else if (element.contextTagNum() == REASON_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ reason = castingValue.value(Integer.class);
+ }
+ } else if (element.contextTagNum() == ENERGY_TRANSFERRED_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+ IntType castingValue = element.value(IntType.class);
+ energyTransferred = castingValue.value(Long.class);
+ }
+ }
+ }
+ return new EnergyEvseClusterEnergyTransferStoppedEvent(
+ sessionID,
+ state,
+ reason,
+ energyTransferred
+ );
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder output = new StringBuilder();
+ output.append("EnergyEvseClusterEnergyTransferStoppedEvent {\n");
+ output.append("\tsessionID: ");
+ output.append(sessionID);
+ output.append("\n");
+ output.append("\tstate: ");
+ output.append(state);
+ output.append("\n");
+ output.append("\treason: ");
+ output.append(reason);
+ output.append("\n");
+ output.append("\tenergyTransferred: ");
+ output.append(energyTransferred);
+ output.append("\n");
+ output.append("}\n");
+ return output.toString();
+ }
+}
+public static class EnergyEvseClusterFaultEvent {
+ public Long sessionID;
+ public Integer state;
+ public Integer faultStatePreviousState;
+ public Integer faultStateCurrentState;
+ private static final long SESSION_I_D_ID = 0L;
+ private static final long STATE_ID = 1L;
+ private static final long FAULT_STATE_PREVIOUS_STATE_ID = 2L;
+ private static final long FAULT_STATE_CURRENT_STATE_ID = 4L;
+
+ public EnergyEvseClusterFaultEvent(
+ Long sessionID,
+ Integer state,
+ Integer faultStatePreviousState,
+ Integer faultStateCurrentState
+ ) {
+ this.sessionID = sessionID;
+ this.state = state;
+ this.faultStatePreviousState = faultStatePreviousState;
+ this.faultStateCurrentState = faultStateCurrentState;
+ }
+
+ public StructType encodeTlv() {
+ ArrayList values = new ArrayList<>();
+ values.add(new StructElement(SESSION_I_D_ID, new UIntType(sessionID)));
+ values.add(new StructElement(STATE_ID, new UIntType(state)));
+ values.add(new StructElement(FAULT_STATE_PREVIOUS_STATE_ID, new UIntType(faultStatePreviousState)));
+ values.add(new StructElement(FAULT_STATE_CURRENT_STATE_ID, new UIntType(faultStateCurrentState)));
+
+ return new StructType(values);
+ }
+
+ public static EnergyEvseClusterFaultEvent decodeTlv(BaseTLVType tlvValue) {
+ if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+ return null;
+ }
+ Long sessionID = null;
+ Integer state = null;
+ Integer faultStatePreviousState = null;
+ Integer faultStateCurrentState = null;
+ for (StructElement element: ((StructType)tlvValue).value()) {
+ if (element.contextTagNum() == SESSION_I_D_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ sessionID = castingValue.value(Long.class);
+ }
+ } else if (element.contextTagNum() == STATE_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ state = castingValue.value(Integer.class);
+ }
+ } else if (element.contextTagNum() == FAULT_STATE_PREVIOUS_STATE_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ faultStatePreviousState = castingValue.value(Integer.class);
+ }
+ } else if (element.contextTagNum() == FAULT_STATE_CURRENT_STATE_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ faultStateCurrentState = castingValue.value(Integer.class);
+ }
+ }
+ }
+ return new EnergyEvseClusterFaultEvent(
+ sessionID,
+ state,
+ faultStatePreviousState,
+ faultStateCurrentState
+ );
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder output = new StringBuilder();
+ output.append("EnergyEvseClusterFaultEvent {\n");
+ output.append("\tsessionID: ");
+ output.append(sessionID);
+ output.append("\n");
+ output.append("\tstate: ");
+ output.append(state);
+ output.append("\n");
+ output.append("\tfaultStatePreviousState: ");
+ output.append(faultStatePreviousState);
+ output.append("\n");
+ output.append("\tfaultStateCurrentState: ");
+ output.append(faultStateCurrentState);
+ output.append("\n");
+ output.append("}\n");
+ return output.toString();
+ }
+}
+public static class EnergyEvseClusterRFIDEvent {
+ public byte[] uid;
+ private static final long UID_ID = 0L;
+
+ public EnergyEvseClusterRFIDEvent(
+ byte[] uid
+ ) {
+ this.uid = uid;
+ }
+
+ public StructType encodeTlv() {
+ ArrayList values = new ArrayList<>();
+ values.add(new StructElement(UID_ID, new ByteArrayType(uid)));
+
+ return new StructType(values);
+ }
+
+ public static EnergyEvseClusterRFIDEvent decodeTlv(BaseTLVType tlvValue) {
+ if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+ return null;
+ }
+ byte[] uid = null;
+ for (StructElement element: ((StructType)tlvValue).value()) {
+ if (element.contextTagNum() == UID_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.ByteArray) {
+ ByteArrayType castingValue = element.value(ByteArrayType.class);
+ uid = castingValue.value(byte[].class);
+ }
+ }
+ }
+ return new EnergyEvseClusterRFIDEvent(
+ uid
+ );
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder output = new StringBuilder();
+ output.append("EnergyEvseClusterRFIDEvent {\n");
+ output.append("\tuid: ");
+ output.append(Arrays.toString(uid));
+ output.append("\n");
+ output.append("}\n");
+ return output.toString();
+ }
+}
public static class DoorLockClusterDoorLockAlarmEvent {
public Integer alarmCode;
private static final long ALARM_CODE_ID = 0L;
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java
index 843b68318831b9..404e1d1c76c643 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ChipStructs.java
@@ -5959,6 +5959,82 @@ public String toString() {
return output.toString();
}
}
+public static class EnergyEvseClusterChargingTargetStruct {
+ public Integer targetTime;
+ public Optional targetSoC;
+ public Optional addedEnergy;
+ private static final long TARGET_TIME_ID = 0L;
+ private static final long TARGET_SO_C_ID = 1L;
+ private static final long ADDED_ENERGY_ID = 2L;
+
+ public EnergyEvseClusterChargingTargetStruct(
+ Integer targetTime,
+ Optional targetSoC,
+ Optional addedEnergy
+ ) {
+ this.targetTime = targetTime;
+ this.targetSoC = targetSoC;
+ this.addedEnergy = addedEnergy;
+ }
+
+ public StructType encodeTlv() {
+ ArrayList values = new ArrayList<>();
+ values.add(new StructElement(TARGET_TIME_ID, new UIntType(targetTime)));
+ values.add(new StructElement(TARGET_SO_C_ID, targetSoC.map((nonOptionaltargetSoC) -> new UIntType(nonOptionaltargetSoC)).orElse(new EmptyType())));
+ values.add(new StructElement(ADDED_ENERGY_ID, addedEnergy.map((nonOptionaladdedEnergy) -> new IntType(nonOptionaladdedEnergy)).orElse(new EmptyType())));
+
+ return new StructType(values);
+ }
+
+ public static EnergyEvseClusterChargingTargetStruct decodeTlv(BaseTLVType tlvValue) {
+ if (tlvValue == null || tlvValue.type() != TLVType.Struct) {
+ return null;
+ }
+ Integer targetTime = null;
+ Optional targetSoC = Optional.empty();
+ Optional addedEnergy = Optional.empty();
+ for (StructElement element: ((StructType)tlvValue).value()) {
+ if (element.contextTagNum() == TARGET_TIME_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ targetTime = castingValue.value(Integer.class);
+ }
+ } else if (element.contextTagNum() == TARGET_SO_C_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.UInt) {
+ UIntType castingValue = element.value(UIntType.class);
+ targetSoC = Optional.of(castingValue.value(Integer.class));
+ }
+ } else if (element.contextTagNum() == ADDED_ENERGY_ID) {
+ if (element.value(BaseTLVType.class).type() == TLVType.Int) {
+ IntType castingValue = element.value(IntType.class);
+ addedEnergy = Optional.of(castingValue.value(Long.class));
+ }
+ }
+ }
+ return new EnergyEvseClusterChargingTargetStruct(
+ targetTime,
+ targetSoC,
+ addedEnergy
+ );
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder output = new StringBuilder();
+ output.append("EnergyEvseClusterChargingTargetStruct {\n");
+ output.append("\ttargetTime: ");
+ output.append(targetTime);
+ output.append("\n");
+ output.append("\ttargetSoC: ");
+ output.append(targetSoC);
+ output.append("\n");
+ output.append("\taddedEnergy: ");
+ output.append(addedEnergy);
+ output.append("\n");
+ output.append("}\n");
+ return output.toString();
+ }
+}
public static class DoorLockClusterCredentialStruct {
public Integer credentialType;
public Integer credentialIndex;
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java
index 89ea408254a0c7..95cf77037d5f08 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterIDMapping.java
@@ -223,6 +223,9 @@ public static BaseCluster getCluster(long clusterId) {
if (clusterId == DemandResponseLoadControl.ID) {
return new DemandResponseLoadControl();
}
+ if (clusterId == EnergyEvse.ID) {
+ return new EnergyEvse();
+ }
if (clusterId == DoorLock.ID) {
return new DoorLock();
}
@@ -9093,6 +9096,212 @@ public long getCommandID(String name) throws IllegalArgumentException {
return Command.valueOf(name).getID();
}
}
+ public static class EnergyEvse implements BaseCluster {
+ public static final long ID = 153L;
+ public long getID() {
+ return ID;
+ }
+
+ public enum Attribute {
+ State(0L),
+ SupplyState(1L),
+ FaultState(2L),
+ ChargingEnabledUntil(3L),
+ DischargingEnabledUntil(4L),
+ CircuitCapacity(5L),
+ MinimumChargeCurrent(6L),
+ MaximumChargeCurrent(7L),
+ MaximumDischargeCurrent(8L),
+ UserMaximumChargeCurrent(9L),
+ RandomizationDelayWindow(10L),
+ NumberOfWeeklyTargets(33L),
+ NumberOfDailyTargets(34L),
+ NextChargeStartTime(35L),
+ NextChargeTargetTime(36L),
+ NextChargeRequiredEnergy(37L),
+ NextChargeTargetSoC(38L),
+ ApproximateEVEfficiency(39L),
+ StateOfCharge(48L),
+ BatteryCapacity(49L),
+ VehicleID(50L),
+ SessionID(64L),
+ SessionDuration(65L),
+ SessionEnergyCharged(66L),
+ SessionEnergyDischarged(67L),
+ GeneratedCommandList(65528L),
+ AcceptedCommandList(65529L),
+ EventList(65530L),
+ AttributeList(65531L),
+ FeatureMap(65532L),
+ ClusterRevision(65533L),;
+ private final long id;
+ Attribute(long id) {
+ this.id = id;
+ }
+
+ public long getID() {
+ return id;
+ }
+
+ public static Attribute value(long id) throws NoSuchFieldError {
+ for (Attribute attribute : Attribute.values()) {
+ if (attribute.getID() == id) {
+ return attribute;
+ }
+ }
+ throw new NoSuchFieldError();
+ }
+ }
+
+ public enum Event {
+ EVConnected(0L),
+ EVNotDetected(1L),
+ EnergyTransferStarted(2L),
+ EnergyTransferStopped(3L),
+ Fault(4L),
+ RFID(5L),;
+ private final long id;
+ Event(long id) {
+ this.id = id;
+ }
+
+ public long getID() {
+ return id;
+ }
+
+ public static Event value(long id) throws NoSuchFieldError {
+ for (Event event : Event.values()) {
+ if (event.getID() == id) {
+ return event;
+ }
+ }
+ throw new NoSuchFieldError();
+ }
+ }
+
+ public enum Command {
+ Disable(1L),
+ EnableCharging(2L),
+ EnableDischarging(3L),
+ StartDiagnostics(4L),
+ SetTargets(5L),
+ GetTargets(6L),
+ ClearTargets(7L),;
+ private final long id;
+ Command(long id) {
+ this.id = id;
+ }
+
+ public long getID() {
+ return id;
+ }
+
+ public static Command value(long id) throws NoSuchFieldError {
+ for (Command command : Command.values()) {
+ if (command.getID() == id) {
+ return command;
+ }
+ }
+ throw new NoSuchFieldError();
+ }
+ }public enum EnableChargingCommandField {ChargingEnabledUntil(0),MinimumChargeCurrent(1),MaximumChargeCurrent(2),;
+ private final int id;
+ EnableChargingCommandField(int id) {
+ this.id = id;
+ }
+
+ public int getID() {
+ return id;
+ }
+ public static EnableChargingCommandField value(int id) throws NoSuchFieldError {
+ for (EnableChargingCommandField field : EnableChargingCommandField.values()) {
+ if (field.getID() == id) {
+ return field;
+ }
+ }
+ throw new NoSuchFieldError();
+ }
+ }public enum EnableDischargingCommandField {DischargingEnabledUntil(0),MaximumDischargeCurrent(1),;
+ private final int id;
+ EnableDischargingCommandField(int id) {
+ this.id = id;
+ }
+
+ public int getID() {
+ return id;
+ }
+ public static EnableDischargingCommandField value(int id) throws NoSuchFieldError {
+ for (EnableDischargingCommandField field : EnableDischargingCommandField.values()) {
+ if (field.getID() == id) {
+ return field;
+ }
+ }
+ throw new NoSuchFieldError();
+ }
+ }public enum SetTargetsCommandField {DayOfWeekforSequence(0),ChargingTargets(1),;
+ private final int id;
+ SetTargetsCommandField(int id) {
+ this.id = id;
+ }
+
+ public int getID() {
+ return id;
+ }
+ public static SetTargetsCommandField value(int id) throws NoSuchFieldError {
+ for (SetTargetsCommandField field : SetTargetsCommandField.values()) {
+ if (field.getID() == id) {
+ return field;
+ }
+ }
+ throw new NoSuchFieldError();
+ }
+ }public enum GetTargetsCommandField {DaysToReturn(0),;
+ private final int id;
+ GetTargetsCommandField(int id) {
+ this.id = id;
+ }
+
+ public int getID() {
+ return id;
+ }
+ public static GetTargetsCommandField value(int id) throws NoSuchFieldError {
+ for (GetTargetsCommandField field : GetTargetsCommandField.values()) {
+ if (field.getID() == id) {
+ return field;
+ }
+ }
+ throw new NoSuchFieldError();
+ }
+ }@Override
+ public String getAttributeName(long id) throws NoSuchFieldError {
+ return Attribute.value(id).toString();
+ }
+
+ @Override
+ public String getEventName(long id) throws NoSuchFieldError {
+ return Event.value(id).toString();
+ }
+
+ @Override
+ public String getCommandName(long id) throws NoSuchFieldError {
+ return Command.value(id).toString();
+ }
+
+ @Override
+ public long getAttributeID(String name) throws IllegalArgumentException {
+ return Attribute.valueOf(name).getID();
+ }
+
+ @Override
+ public long getEventID(String name) throws IllegalArgumentException {
+ return Event.valueOf(name).getID();
+ }
+
+ @Override
+ public long getCommandID(String name) throws IllegalArgumentException {
+ return Command.valueOf(name).getID();
+ }
+ }
public static class DoorLock implements BaseCluster {
public static final long ID = 257L;
public long getID() {
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java
index ba0190ef3abdfd..d544a8da73ace3 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterInfoMapping.java
@@ -9945,6 +9945,367 @@ public void onError(Exception ex) {
}
+ public static class DelegatedEnergyEvseClusterGetTargetsResponseCallback implements ChipClusters.EnergyEvseCluster.GetTargetsResponseCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(Integer dayOfWeekforSequence, ArrayList chargingTargets) {
+ Map responseValues = new LinkedHashMap<>();
+
+ CommandResponseInfo dayOfWeekforSequenceResponseValue = new CommandResponseInfo("dayOfWeekforSequence", "Integer");
+ responseValues.put(dayOfWeekforSequenceResponseValue, dayOfWeekforSequence);
+ // chargingTargets: ChargingTargetStruct
+ // Conversion from this type to Java is not properly implemented yet
+
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception error) {
+ callback.onFailure(error);
+ }
+ }
+ public static class DelegatedEnergyEvseClusterStateAttributeCallback implements ChipClusters.EnergyEvseCluster.StateAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Integer value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterChargingEnabledUntilAttributeCallback implements ChipClusters.EnergyEvseCluster.ChargingEnabledUntilAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Long value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterDischargingEnabledUntilAttributeCallback implements ChipClusters.EnergyEvseCluster.DischargingEnabledUntilAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Long value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterNextChargeStartTimeAttributeCallback implements ChipClusters.EnergyEvseCluster.NextChargeStartTimeAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Long value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterNextChargeTargetTimeAttributeCallback implements ChipClusters.EnergyEvseCluster.NextChargeTargetTimeAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Long value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterNextChargeRequiredEnergyAttributeCallback implements ChipClusters.EnergyEvseCluster.NextChargeRequiredEnergyAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Long value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterNextChargeTargetSoCAttributeCallback implements ChipClusters.EnergyEvseCluster.NextChargeTargetSoCAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Integer value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterApproximateEVEfficiencyAttributeCallback implements ChipClusters.EnergyEvseCluster.ApproximateEVEfficiencyAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Integer value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterStateOfChargeAttributeCallback implements ChipClusters.EnergyEvseCluster.StateOfChargeAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Integer value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Integer");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterBatteryCapacityAttributeCallback implements ChipClusters.EnergyEvseCluster.BatteryCapacityAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Long value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterVehicleIDAttributeCallback implements ChipClusters.EnergyEvseCluster.VehicleIDAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable String value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "String");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterSessionIDAttributeCallback implements ChipClusters.EnergyEvseCluster.SessionIDAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(@Nullable Long value) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("value", "Long");
+ responseValues.put(commandResponseInfo, value);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterGeneratedCommandListAttributeCallback implements ChipClusters.EnergyEvseCluster.GeneratedCommandListAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(List valueList) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List");
+ responseValues.put(commandResponseInfo, valueList);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterAcceptedCommandListAttributeCallback implements ChipClusters.EnergyEvseCluster.AcceptedCommandListAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(List valueList) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List");
+ responseValues.put(commandResponseInfo, valueList);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterEventListAttributeCallback implements ChipClusters.EnergyEvseCluster.EventListAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(List valueList) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List");
+ responseValues.put(commandResponseInfo, valueList);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+ public static class DelegatedEnergyEvseClusterAttributeListAttributeCallback implements ChipClusters.EnergyEvseCluster.AttributeListAttributeCallback, DelegatedClusterCallback {
+ private ClusterCommandCallback callback;
+ @Override
+ public void setCallbackDelegate(ClusterCommandCallback callback) {
+ this.callback = callback;
+ }
+
+ @Override
+ public void onSuccess(List valueList) {
+ Map responseValues = new LinkedHashMap<>();
+ CommandResponseInfo commandResponseInfo = new CommandResponseInfo("valueList", "List");
+ responseValues.put(commandResponseInfo, valueList);
+ callback.onSuccess(responseValues);
+ }
+
+ @Override
+ public void onError(Exception ex) {
+ callback.onFailure(ex);
+ }
+ }
+
+
public static class DelegatedDoorLockClusterGetWeekDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, DelegatedClusterCallback {
private ClusterCommandCallback callback;
@Override
@@ -18237,6 +18598,10 @@ public Map initializeClusterMap() {
(ptr, endpointId) -> new ChipClusters.DemandResponseLoadControlCluster(ptr, endpointId), new HashMap<>());
clusterMap.put("demandResponseLoadControl", demandResponseLoadControlClusterInfo);
+ ClusterInfo energyEvseClusterInfo = new ClusterInfo(
+ (ptr, endpointId) -> new ChipClusters.EnergyEvseCluster(ptr, endpointId), new HashMap<>());
+ clusterMap.put("energyEvse", energyEvseClusterInfo);
+
ClusterInfo doorLockClusterInfo = new ClusterInfo(
(ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), new HashMap<>());
clusterMap.put("doorLock", doorLockClusterInfo);
@@ -18470,6 +18835,7 @@ public void combineCommand(Map destination, Map> getCommandMap() {
commandMap.put("demandResponseLoadControl", demandResponseLoadControlClusterInteractionInfoMap);
+ Map energyEvseClusterInteractionInfoMap = new LinkedHashMap<>();
+
+ Map energyEvsedisableCommandParams = new LinkedHashMap();
+ InteractionInfo energyEvsedisableInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster)
+ .disable((DefaultClusterCallback) callback, 10000
+ );
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ energyEvsedisableCommandParams
+ );
+ energyEvseClusterInteractionInfoMap.put("disable", energyEvsedisableInteractionInfo);
+
+ Map energyEvseenableChargingCommandParams = new LinkedHashMap();
+
+ CommandParameterInfo energyEvseenableChargingchargingEnabledUntilCommandParameterInfo = new CommandParameterInfo("chargingEnabledUntil", Long.class, Long.class);
+ energyEvseenableChargingCommandParams.put("chargingEnabledUntil",energyEvseenableChargingchargingEnabledUntilCommandParameterInfo);
+
+ CommandParameterInfo energyEvseenableChargingminimumChargeCurrentCommandParameterInfo = new CommandParameterInfo("minimumChargeCurrent", Long.class, Long.class);
+ energyEvseenableChargingCommandParams.put("minimumChargeCurrent",energyEvseenableChargingminimumChargeCurrentCommandParameterInfo);
+
+ CommandParameterInfo energyEvseenableChargingmaximumChargeCurrentCommandParameterInfo = new CommandParameterInfo("maximumChargeCurrent", Long.class, Long.class);
+ energyEvseenableChargingCommandParams.put("maximumChargeCurrent",energyEvseenableChargingmaximumChargeCurrentCommandParameterInfo);
+ InteractionInfo energyEvseenableChargingInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster)
+ .enableCharging((DefaultClusterCallback) callback
+ , (Long)
+ commandArguments.get("chargingEnabledUntil")
+ , (Long)
+ commandArguments.get("minimumChargeCurrent")
+ , (Long)
+ commandArguments.get("maximumChargeCurrent"), 10000
+ );
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ energyEvseenableChargingCommandParams
+ );
+ energyEvseClusterInteractionInfoMap.put("enableCharging", energyEvseenableChargingInteractionInfo);
+
+ Map energyEvseenableDischargingCommandParams = new LinkedHashMap();
+
+ CommandParameterInfo energyEvseenableDischargingdischargingEnabledUntilCommandParameterInfo = new CommandParameterInfo("dischargingEnabledUntil", Long.class, Long.class);
+ energyEvseenableDischargingCommandParams.put("dischargingEnabledUntil",energyEvseenableDischargingdischargingEnabledUntilCommandParameterInfo);
+
+ CommandParameterInfo energyEvseenableDischargingmaximumDischargeCurrentCommandParameterInfo = new CommandParameterInfo("maximumDischargeCurrent", Long.class, Long.class);
+ energyEvseenableDischargingCommandParams.put("maximumDischargeCurrent",energyEvseenableDischargingmaximumDischargeCurrentCommandParameterInfo);
+ InteractionInfo energyEvseenableDischargingInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster)
+ .enableDischarging((DefaultClusterCallback) callback
+ , (Long)
+ commandArguments.get("dischargingEnabledUntil")
+ , (Long)
+ commandArguments.get("maximumDischargeCurrent"), 10000
+ );
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ energyEvseenableDischargingCommandParams
+ );
+ energyEvseClusterInteractionInfoMap.put("enableDischarging", energyEvseenableDischargingInteractionInfo);
+
+ Map energyEvsestartDiagnosticsCommandParams = new LinkedHashMap();
+ InteractionInfo energyEvsestartDiagnosticsInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster)
+ .startDiagnostics((DefaultClusterCallback) callback, 10000
+ );
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ energyEvsestartDiagnosticsCommandParams
+ );
+ energyEvseClusterInteractionInfoMap.put("startDiagnostics", energyEvsestartDiagnosticsInteractionInfo);
+
+ Map energyEvsesetTargetsCommandParams = new LinkedHashMap();
+
+ CommandParameterInfo energyEvsesetTargetsdayOfWeekforSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekforSequence", Integer.class, Integer.class);
+ energyEvsesetTargetsCommandParams.put("dayOfWeekforSequence",energyEvsesetTargetsdayOfWeekforSequenceCommandParameterInfo);
+
+ InteractionInfo energyEvsesetTargetsInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster)
+ .setTargets((DefaultClusterCallback) callback
+ , (Integer)
+ commandArguments.get("dayOfWeekforSequence")
+ , (ArrayList)
+ commandArguments.get("chargingTargets"), 10000
+ );
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ energyEvsesetTargetsCommandParams
+ );
+ energyEvseClusterInteractionInfoMap.put("setTargets", energyEvsesetTargetsInteractionInfo);
+
+ Map energyEvsegetTargetsCommandParams = new LinkedHashMap();
+
+ CommandParameterInfo energyEvsegetTargetsdaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class, Integer.class);
+ energyEvsegetTargetsCommandParams.put("daysToReturn",energyEvsegetTargetsdaysToReturnCommandParameterInfo);
+ InteractionInfo energyEvsegetTargetsInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster)
+ .getTargets((ChipClusters.EnergyEvseCluster.GetTargetsResponseCallback) callback
+ , (Integer)
+ commandArguments.get("daysToReturn")
+
+ , 10000);
+ },
+ () -> new DelegatedEnergyEvseClusterGetTargetsResponseCallback(),
+ energyEvsegetTargetsCommandParams
+ );
+ energyEvseClusterInteractionInfoMap.put("getTargets", energyEvsegetTargetsInteractionInfo);
+
+ Map energyEvseclearTargetsCommandParams = new LinkedHashMap();
+ InteractionInfo energyEvseclearTargetsInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster)
+ .clearTargets((DefaultClusterCallback) callback, 10000
+ );
+ },
+ () -> new DelegatedDefaultClusterCallback(),
+ energyEvseclearTargetsCommandParams
+ );
+ energyEvseClusterInteractionInfoMap.put("clearTargets", energyEvseclearTargetsInteractionInfo);
+
+ commandMap.put("energyEvse", energyEvseClusterInteractionInfoMap);
+
Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>();
Map doorLocklockDoorCommandParams = new LinkedHashMap();
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
index 7219a083cad761..0f9c22e2ccd7d4 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterReadMapping.java
@@ -8964,6 +8964,351 @@ private static Map readDemandResponseLoadControlInterac
return result;
}
+ private static Map readEnergyEvseInteractionInfo() {
+ Map result = new LinkedHashMap<>();Map readEnergyEvseStateCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseStateAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readStateAttribute(
+ (ChipClusters.EnergyEvseCluster.StateAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterStateAttributeCallback(),
+ readEnergyEvseStateCommandParams
+ );
+ result.put("readStateAttribute", readEnergyEvseStateAttributeInteractionInfo);
+ Map readEnergyEvseSupplyStateCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseSupplyStateAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readSupplyStateAttribute(
+ (ChipClusters.IntegerAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(),
+ readEnergyEvseSupplyStateCommandParams
+ );
+ result.put("readSupplyStateAttribute", readEnergyEvseSupplyStateAttributeInteractionInfo);
+ Map readEnergyEvseFaultStateCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseFaultStateAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readFaultStateAttribute(
+ (ChipClusters.IntegerAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(),
+ readEnergyEvseFaultStateCommandParams
+ );
+ result.put("readFaultStateAttribute", readEnergyEvseFaultStateAttributeInteractionInfo);
+ Map readEnergyEvseChargingEnabledUntilCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseChargingEnabledUntilAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readChargingEnabledUntilAttribute(
+ (ChipClusters.EnergyEvseCluster.ChargingEnabledUntilAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterChargingEnabledUntilAttributeCallback(),
+ readEnergyEvseChargingEnabledUntilCommandParams
+ );
+ result.put("readChargingEnabledUntilAttribute", readEnergyEvseChargingEnabledUntilAttributeInteractionInfo);
+ Map readEnergyEvseDischargingEnabledUntilCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseDischargingEnabledUntilAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readDischargingEnabledUntilAttribute(
+ (ChipClusters.EnergyEvseCluster.DischargingEnabledUntilAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterDischargingEnabledUntilAttributeCallback(),
+ readEnergyEvseDischargingEnabledUntilCommandParams
+ );
+ result.put("readDischargingEnabledUntilAttribute", readEnergyEvseDischargingEnabledUntilAttributeInteractionInfo);
+ Map readEnergyEvseCircuitCapacityCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseCircuitCapacityAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readCircuitCapacityAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseCircuitCapacityCommandParams
+ );
+ result.put("readCircuitCapacityAttribute", readEnergyEvseCircuitCapacityAttributeInteractionInfo);
+ Map readEnergyEvseMinimumChargeCurrentCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseMinimumChargeCurrentAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readMinimumChargeCurrentAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseMinimumChargeCurrentCommandParams
+ );
+ result.put("readMinimumChargeCurrentAttribute", readEnergyEvseMinimumChargeCurrentAttributeInteractionInfo);
+ Map readEnergyEvseMaximumChargeCurrentCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseMaximumChargeCurrentAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readMaximumChargeCurrentAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseMaximumChargeCurrentCommandParams
+ );
+ result.put("readMaximumChargeCurrentAttribute", readEnergyEvseMaximumChargeCurrentAttributeInteractionInfo);
+ Map readEnergyEvseMaximumDischargeCurrentCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseMaximumDischargeCurrentAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readMaximumDischargeCurrentAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseMaximumDischargeCurrentCommandParams
+ );
+ result.put("readMaximumDischargeCurrentAttribute", readEnergyEvseMaximumDischargeCurrentAttributeInteractionInfo);
+ Map readEnergyEvseUserMaximumChargeCurrentCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseUserMaximumChargeCurrentAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readUserMaximumChargeCurrentAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseUserMaximumChargeCurrentCommandParams
+ );
+ result.put("readUserMaximumChargeCurrentAttribute", readEnergyEvseUserMaximumChargeCurrentAttributeInteractionInfo);
+ Map readEnergyEvseRandomizationDelayWindowCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseRandomizationDelayWindowAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readRandomizationDelayWindowAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseRandomizationDelayWindowCommandParams
+ );
+ result.put("readRandomizationDelayWindowAttribute", readEnergyEvseRandomizationDelayWindowAttributeInteractionInfo);
+ Map readEnergyEvseNumberOfWeeklyTargetsCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseNumberOfWeeklyTargetsAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readNumberOfWeeklyTargetsAttribute(
+ (ChipClusters.IntegerAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(),
+ readEnergyEvseNumberOfWeeklyTargetsCommandParams
+ );
+ result.put("readNumberOfWeeklyTargetsAttribute", readEnergyEvseNumberOfWeeklyTargetsAttributeInteractionInfo);
+ Map readEnergyEvseNumberOfDailyTargetsCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseNumberOfDailyTargetsAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readNumberOfDailyTargetsAttribute(
+ (ChipClusters.IntegerAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(),
+ readEnergyEvseNumberOfDailyTargetsCommandParams
+ );
+ result.put("readNumberOfDailyTargetsAttribute", readEnergyEvseNumberOfDailyTargetsAttributeInteractionInfo);
+ Map readEnergyEvseNextChargeStartTimeCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseNextChargeStartTimeAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readNextChargeStartTimeAttribute(
+ (ChipClusters.EnergyEvseCluster.NextChargeStartTimeAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterNextChargeStartTimeAttributeCallback(),
+ readEnergyEvseNextChargeStartTimeCommandParams
+ );
+ result.put("readNextChargeStartTimeAttribute", readEnergyEvseNextChargeStartTimeAttributeInteractionInfo);
+ Map readEnergyEvseNextChargeTargetTimeCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseNextChargeTargetTimeAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readNextChargeTargetTimeAttribute(
+ (ChipClusters.EnergyEvseCluster.NextChargeTargetTimeAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterNextChargeTargetTimeAttributeCallback(),
+ readEnergyEvseNextChargeTargetTimeCommandParams
+ );
+ result.put("readNextChargeTargetTimeAttribute", readEnergyEvseNextChargeTargetTimeAttributeInteractionInfo);
+ Map readEnergyEvseNextChargeRequiredEnergyCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseNextChargeRequiredEnergyAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readNextChargeRequiredEnergyAttribute(
+ (ChipClusters.EnergyEvseCluster.NextChargeRequiredEnergyAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterNextChargeRequiredEnergyAttributeCallback(),
+ readEnergyEvseNextChargeRequiredEnergyCommandParams
+ );
+ result.put("readNextChargeRequiredEnergyAttribute", readEnergyEvseNextChargeRequiredEnergyAttributeInteractionInfo);
+ Map readEnergyEvseNextChargeTargetSoCCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseNextChargeTargetSoCAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readNextChargeTargetSoCAttribute(
+ (ChipClusters.EnergyEvseCluster.NextChargeTargetSoCAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterNextChargeTargetSoCAttributeCallback(),
+ readEnergyEvseNextChargeTargetSoCCommandParams
+ );
+ result.put("readNextChargeTargetSoCAttribute", readEnergyEvseNextChargeTargetSoCAttributeInteractionInfo);
+ Map readEnergyEvseApproximateEVEfficiencyCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseApproximateEVEfficiencyAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readApproximateEVEfficiencyAttribute(
+ (ChipClusters.EnergyEvseCluster.ApproximateEVEfficiencyAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterApproximateEVEfficiencyAttributeCallback(),
+ readEnergyEvseApproximateEVEfficiencyCommandParams
+ );
+ result.put("readApproximateEVEfficiencyAttribute", readEnergyEvseApproximateEVEfficiencyAttributeInteractionInfo);
+ Map readEnergyEvseStateOfChargeCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseStateOfChargeAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readStateOfChargeAttribute(
+ (ChipClusters.EnergyEvseCluster.StateOfChargeAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterStateOfChargeAttributeCallback(),
+ readEnergyEvseStateOfChargeCommandParams
+ );
+ result.put("readStateOfChargeAttribute", readEnergyEvseStateOfChargeAttributeInteractionInfo);
+ Map readEnergyEvseBatteryCapacityCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseBatteryCapacityAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readBatteryCapacityAttribute(
+ (ChipClusters.EnergyEvseCluster.BatteryCapacityAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterBatteryCapacityAttributeCallback(),
+ readEnergyEvseBatteryCapacityCommandParams
+ );
+ result.put("readBatteryCapacityAttribute", readEnergyEvseBatteryCapacityAttributeInteractionInfo);
+ Map readEnergyEvseVehicleIDCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseVehicleIDAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readVehicleIDAttribute(
+ (ChipClusters.EnergyEvseCluster.VehicleIDAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterVehicleIDAttributeCallback(),
+ readEnergyEvseVehicleIDCommandParams
+ );
+ result.put("readVehicleIDAttribute", readEnergyEvseVehicleIDAttributeInteractionInfo);
+ Map readEnergyEvseSessionIDCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseSessionIDAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readSessionIDAttribute(
+ (ChipClusters.EnergyEvseCluster.SessionIDAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterSessionIDAttributeCallback(),
+ readEnergyEvseSessionIDCommandParams
+ );
+ result.put("readSessionIDAttribute", readEnergyEvseSessionIDAttributeInteractionInfo);
+ Map readEnergyEvseSessionDurationCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseSessionDurationAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readSessionDurationAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseSessionDurationCommandParams
+ );
+ result.put("readSessionDurationAttribute", readEnergyEvseSessionDurationAttributeInteractionInfo);
+ Map readEnergyEvseSessionEnergyChargedCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseSessionEnergyChargedAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readSessionEnergyChargedAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseSessionEnergyChargedCommandParams
+ );
+ result.put("readSessionEnergyChargedAttribute", readEnergyEvseSessionEnergyChargedAttributeInteractionInfo);
+ Map readEnergyEvseSessionEnergyDischargedCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseSessionEnergyDischargedAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readSessionEnergyDischargedAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseSessionEnergyDischargedCommandParams
+ );
+ result.put("readSessionEnergyDischargedAttribute", readEnergyEvseSessionEnergyDischargedAttributeInteractionInfo);
+ Map readEnergyEvseGeneratedCommandListCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseGeneratedCommandListAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readGeneratedCommandListAttribute(
+ (ChipClusters.EnergyEvseCluster.GeneratedCommandListAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterGeneratedCommandListAttributeCallback(),
+ readEnergyEvseGeneratedCommandListCommandParams
+ );
+ result.put("readGeneratedCommandListAttribute", readEnergyEvseGeneratedCommandListAttributeInteractionInfo);
+ Map readEnergyEvseAcceptedCommandListCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseAcceptedCommandListAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readAcceptedCommandListAttribute(
+ (ChipClusters.EnergyEvseCluster.AcceptedCommandListAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterAcceptedCommandListAttributeCallback(),
+ readEnergyEvseAcceptedCommandListCommandParams
+ );
+ result.put("readAcceptedCommandListAttribute", readEnergyEvseAcceptedCommandListAttributeInteractionInfo);
+ Map readEnergyEvseEventListCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseEventListAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readEventListAttribute(
+ (ChipClusters.EnergyEvseCluster.EventListAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterEventListAttributeCallback(),
+ readEnergyEvseEventListCommandParams
+ );
+ result.put("readEventListAttribute", readEnergyEvseEventListAttributeInteractionInfo);
+ Map readEnergyEvseAttributeListCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseAttributeListAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readAttributeListAttribute(
+ (ChipClusters.EnergyEvseCluster.AttributeListAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedEnergyEvseClusterAttributeListAttributeCallback(),
+ readEnergyEvseAttributeListCommandParams
+ );
+ result.put("readAttributeListAttribute", readEnergyEvseAttributeListAttributeInteractionInfo);
+ Map readEnergyEvseFeatureMapCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseFeatureMapAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readFeatureMapAttribute(
+ (ChipClusters.LongAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(),
+ readEnergyEvseFeatureMapCommandParams
+ );
+ result.put("readFeatureMapAttribute", readEnergyEvseFeatureMapAttributeInteractionInfo);
+ Map readEnergyEvseClusterRevisionCommandParams = new LinkedHashMap();
+ InteractionInfo readEnergyEvseClusterRevisionAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).readClusterRevisionAttribute(
+ (ChipClusters.IntegerAttributeCallback) callback
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(),
+ readEnergyEvseClusterRevisionCommandParams
+ );
+ result.put("readClusterRevisionAttribute", readEnergyEvseClusterRevisionAttributeInteractionInfo);
+
+ return result;
+ }
private static Map readDoorLockInteractionInfo() {
Map result = new LinkedHashMap<>();Map readDoorLockLockStateCommandParams = new LinkedHashMap();
InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo(
@@ -18536,6 +18881,7 @@ public Map> getReadAttributeMap() {
put("booleanSensorConfiguration", readBooleanSensorConfigurationInteractionInfo());
put("valveConfigurationAndControl", readValveConfigurationAndControlInteractionInfo());
put("demandResponseLoadControl", readDemandResponseLoadControlInteractionInfo());
+ put("energyEvse", readEnergyEvseInteractionInfo());
put("doorLock", readDoorLockInteractionInfo());
put("windowCovering", readWindowCoveringInteractionInfo());
put("barrierControl", readBarrierControlInteractionInfo());
diff --git a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
index 1516fa1a7efa9a..5b4238c63be532 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
+++ b/src/controller/java/generated/java/chip/devicecontroller/ClusterWriteMapping.java
@@ -1322,6 +1322,74 @@ public Map> getWriteAttributeMap() {
);
writeDemandResponseLoadControlInteractionInfo.put("writeDefaultRandomDurationAttribute", writeDemandResponseLoadControlDefaultRandomDurationAttributeInteractionInfo);
writeAttributeMap.put("demandResponseLoadControl", writeDemandResponseLoadControlInteractionInfo);
+ Map writeEnergyEvseInteractionInfo = new LinkedHashMap<>();
+ Map writeEnergyEvseUserMaximumChargeCurrentCommandParams = new LinkedHashMap();
+ CommandParameterInfo energyEvseuserMaximumChargeCurrentCommandParameterInfo =
+ new CommandParameterInfo(
+ "value",
+ Long.class,
+ Long.class
+ );
+ writeEnergyEvseUserMaximumChargeCurrentCommandParams.put(
+ "value",
+ energyEvseuserMaximumChargeCurrentCommandParameterInfo
+ );
+ InteractionInfo writeEnergyEvseUserMaximumChargeCurrentAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).writeUserMaximumChargeCurrentAttribute(
+ (DefaultClusterCallback) callback,
+ (Long) commandArguments.get("value")
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(),
+ writeEnergyEvseUserMaximumChargeCurrentCommandParams
+ );
+ writeEnergyEvseInteractionInfo.put("writeUserMaximumChargeCurrentAttribute", writeEnergyEvseUserMaximumChargeCurrentAttributeInteractionInfo);
+ Map writeEnergyEvseRandomizationDelayWindowCommandParams = new LinkedHashMap();
+ CommandParameterInfo energyEvserandomizationDelayWindowCommandParameterInfo =
+ new CommandParameterInfo(
+ "value",
+ Long.class,
+ Long.class
+ );
+ writeEnergyEvseRandomizationDelayWindowCommandParams.put(
+ "value",
+ energyEvserandomizationDelayWindowCommandParameterInfo
+ );
+ InteractionInfo writeEnergyEvseRandomizationDelayWindowAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).writeRandomizationDelayWindowAttribute(
+ (DefaultClusterCallback) callback,
+ (Long) commandArguments.get("value")
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(),
+ writeEnergyEvseRandomizationDelayWindowCommandParams
+ );
+ writeEnergyEvseInteractionInfo.put("writeRandomizationDelayWindowAttribute", writeEnergyEvseRandomizationDelayWindowAttributeInteractionInfo);
+ Map writeEnergyEvseApproximateEVEfficiencyCommandParams = new LinkedHashMap();
+ CommandParameterInfo energyEvseapproximateEVEfficiencyCommandParameterInfo =
+ new CommandParameterInfo(
+ "value",
+ Integer.class,
+ Integer.class
+ );
+ writeEnergyEvseApproximateEVEfficiencyCommandParams.put(
+ "value",
+ energyEvseapproximateEVEfficiencyCommandParameterInfo
+ );
+ InteractionInfo writeEnergyEvseApproximateEVEfficiencyAttributeInteractionInfo = new InteractionInfo(
+ (cluster, callback, commandArguments) -> {
+ ((ChipClusters.EnergyEvseCluster) cluster).writeApproximateEVEfficiencyAttribute(
+ (DefaultClusterCallback) callback,
+ (Integer) commandArguments.get("value")
+ );
+ },
+ () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(),
+ writeEnergyEvseApproximateEVEfficiencyCommandParams
+ );
+ writeEnergyEvseInteractionInfo.put("writeApproximateEVEfficiencyAttribute", writeEnergyEvseApproximateEVEfficiencyAttributeInteractionInfo);
+ writeAttributeMap.put("energyEvse", writeEnergyEvseInteractionInfo);
Map writeDoorLockInteractionInfo = new LinkedHashMap<>();
Map writeDoorLockDoorOpenEventsCommandParams = new LinkedHashMap();
CommandParameterInfo doorLockdoorOpenEventsCommandParameterInfo =
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVConnectedEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVConnectedEvent.kt
new file mode 100644
index 00000000000000..37d91a3291a9f2
--- /dev/null
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVConnectedEvent.kt
@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package chip.devicecontroller.cluster.eventstructs
+
+import chip.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterEVConnectedEvent(val sessionID: ULong) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterEVConnectedEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterEVConnectedEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getULong(ContextSpecificTag(TAG_SESSION_I_D))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterEVConnectedEvent(sessionID)
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVNotDetectedEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVNotDetectedEvent.kt
new file mode 100644
index 00000000000000..5720d4469df39c
--- /dev/null
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVNotDetectedEvent.kt
@@ -0,0 +1,89 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package chip.devicecontroller.cluster.eventstructs
+
+import chip.devicecontroller.cluster.*
+import java.util.Optional
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterEVNotDetectedEvent(
+ val sessionID: ULong,
+ val state: UInt,
+ val sessionDuration: ULong,
+ val sessionEnergyCharged: Long,
+ val sessionEnergyDischarged: Optional
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterEVNotDetectedEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("\tstate : $state\n")
+ append("\tsessionDuration : $sessionDuration\n")
+ append("\tsessionEnergyCharged : $sessionEnergyCharged\n")
+ append("\tsessionEnergyDischarged : $sessionEnergyDischarged\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ put(ContextSpecificTag(TAG_STATE), state)
+ put(ContextSpecificTag(TAG_SESSION_DURATION), sessionDuration)
+ put(ContextSpecificTag(TAG_SESSION_ENERGY_CHARGED), sessionEnergyCharged)
+ if (sessionEnergyDischarged.isPresent) {
+ val optsessionEnergyDischarged = sessionEnergyDischarged.get()
+ put(ContextSpecificTag(TAG_SESSION_ENERGY_DISCHARGED), optsessionEnergyDischarged)
+ }
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+ private const val TAG_STATE = 1
+ private const val TAG_SESSION_DURATION = 2
+ private const val TAG_SESSION_ENERGY_CHARGED = 3
+ private const val TAG_SESSION_ENERGY_DISCHARGED = 4
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterEVNotDetectedEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getULong(ContextSpecificTag(TAG_SESSION_I_D))
+ val state = tlvReader.getUInt(ContextSpecificTag(TAG_STATE))
+ val sessionDuration = tlvReader.getULong(ContextSpecificTag(TAG_SESSION_DURATION))
+ val sessionEnergyCharged = tlvReader.getLong(ContextSpecificTag(TAG_SESSION_ENERGY_CHARGED))
+ val sessionEnergyDischarged =
+ if (tlvReader.isNextTag(ContextSpecificTag(TAG_SESSION_ENERGY_DISCHARGED))) {
+ Optional.of(tlvReader.getLong(ContextSpecificTag(TAG_SESSION_ENERGY_DISCHARGED)))
+ } else {
+ Optional.empty()
+ }
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterEVNotDetectedEvent(
+ sessionID,
+ state,
+ sessionDuration,
+ sessionEnergyCharged,
+ sessionEnergyDischarged
+ )
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStartedEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStartedEvent.kt
new file mode 100644
index 00000000000000..7843215518c11d
--- /dev/null
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStartedEvent.kt
@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package chip.devicecontroller.cluster.eventstructs
+
+import chip.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterEnergyTransferStartedEvent(
+ val sessionID: ULong,
+ val state: UInt,
+ val maximumCurrent: Long
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterEnergyTransferStartedEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("\tstate : $state\n")
+ append("\tmaximumCurrent : $maximumCurrent\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ put(ContextSpecificTag(TAG_STATE), state)
+ put(ContextSpecificTag(TAG_MAXIMUM_CURRENT), maximumCurrent)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+ private const val TAG_STATE = 1
+ private const val TAG_MAXIMUM_CURRENT = 2
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterEnergyTransferStartedEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getULong(ContextSpecificTag(TAG_SESSION_I_D))
+ val state = tlvReader.getUInt(ContextSpecificTag(TAG_STATE))
+ val maximumCurrent = tlvReader.getLong(ContextSpecificTag(TAG_MAXIMUM_CURRENT))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterEnergyTransferStartedEvent(sessionID, state, maximumCurrent)
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStoppedEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStoppedEvent.kt
new file mode 100644
index 00000000000000..642bbc9b5e7a04
--- /dev/null
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStoppedEvent.kt
@@ -0,0 +1,74 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package chip.devicecontroller.cluster.eventstructs
+
+import chip.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterEnergyTransferStoppedEvent(
+ val sessionID: ULong,
+ val state: UInt,
+ val reason: UInt,
+ val energyTransferred: Long
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterEnergyTransferStoppedEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("\tstate : $state\n")
+ append("\treason : $reason\n")
+ append("\tenergyTransferred : $energyTransferred\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ put(ContextSpecificTag(TAG_STATE), state)
+ put(ContextSpecificTag(TAG_REASON), reason)
+ put(ContextSpecificTag(TAG_ENERGY_TRANSFERRED), energyTransferred)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+ private const val TAG_STATE = 1
+ private const val TAG_REASON = 2
+ private const val TAG_ENERGY_TRANSFERRED = 4
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterEnergyTransferStoppedEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getULong(ContextSpecificTag(TAG_SESSION_I_D))
+ val state = tlvReader.getUInt(ContextSpecificTag(TAG_STATE))
+ val reason = tlvReader.getUInt(ContextSpecificTag(TAG_REASON))
+ val energyTransferred = tlvReader.getLong(ContextSpecificTag(TAG_ENERGY_TRANSFERRED))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterEnergyTransferStoppedEvent(
+ sessionID,
+ state,
+ reason,
+ energyTransferred
+ )
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterFaultEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterFaultEvent.kt
new file mode 100644
index 00000000000000..2b82c363aa442c
--- /dev/null
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterFaultEvent.kt
@@ -0,0 +1,76 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package chip.devicecontroller.cluster.eventstructs
+
+import chip.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterFaultEvent(
+ val sessionID: ULong,
+ val state: UInt,
+ val faultStatePreviousState: UInt,
+ val faultStateCurrentState: UInt
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterFaultEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("\tstate : $state\n")
+ append("\tfaultStatePreviousState : $faultStatePreviousState\n")
+ append("\tfaultStateCurrentState : $faultStateCurrentState\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ put(ContextSpecificTag(TAG_STATE), state)
+ put(ContextSpecificTag(TAG_FAULT_STATE_PREVIOUS_STATE), faultStatePreviousState)
+ put(ContextSpecificTag(TAG_FAULT_STATE_CURRENT_STATE), faultStateCurrentState)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+ private const val TAG_STATE = 1
+ private const val TAG_FAULT_STATE_PREVIOUS_STATE = 2
+ private const val TAG_FAULT_STATE_CURRENT_STATE = 4
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterFaultEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getULong(ContextSpecificTag(TAG_SESSION_I_D))
+ val state = tlvReader.getUInt(ContextSpecificTag(TAG_STATE))
+ val faultStatePreviousState =
+ tlvReader.getUInt(ContextSpecificTag(TAG_FAULT_STATE_PREVIOUS_STATE))
+ val faultStateCurrentState =
+ tlvReader.getUInt(ContextSpecificTag(TAG_FAULT_STATE_CURRENT_STATE))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterFaultEvent(
+ sessionID,
+ state,
+ faultStatePreviousState,
+ faultStateCurrentState
+ )
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterRFIDEvent.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterRFIDEvent.kt
new file mode 100644
index 00000000000000..760bc2cd92b2eb
--- /dev/null
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterRFIDEvent.kt
@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package chip.devicecontroller.cluster.eventstructs
+
+import chip.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterRFIDEvent(val uid: ByteArray) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterRFIDEvent {\n")
+ append("\tuid : $uid\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_UID), uid)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_UID = 0
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterRFIDEvent {
+ tlvReader.enterStructure(tlvTag)
+ val uid = tlvReader.getByteArray(ContextSpecificTag(TAG_UID))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterRFIDEvent(uid)
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni
index 3efc1df1f73f16..5e4c85f35334ea 100644
--- a/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/files.gni
@@ -37,6 +37,7 @@ structs_sources = [
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/DishwasherModeClusterModeOptionStruct.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/DishwasherModeClusterModeTagStruct.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/DoorLockClusterCredentialStruct.kt",
+ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/FixedLabelClusterLabelStruct.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/GeneralCommissioningClusterBasicCommissioningInfo.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/GeneralDiagnosticsClusterNetworkInterface.kt",
@@ -117,6 +118,12 @@ eventstructs_sources = [
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/DoorLockClusterLockOperationEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/DoorLockClusterLockOperationErrorEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/DoorLockClusterLockUserChangeEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStartedEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStoppedEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVConnectedEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVNotDetectedEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterFaultEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/EnergyEvseClusterRFIDEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterBootReasonEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterHardwareFaultChangeEvent.kt",
"${chip_root}/src/controller/java/generated/java/chip/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterNetworkFaultChangeEvent.kt",
diff --git a/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt
new file mode 100644
index 00000000000000..f457f066ff27bc
--- /dev/null
+++ b/src/controller/java/generated/java/chip/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt
@@ -0,0 +1,81 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package chip.devicecontroller.cluster.structs
+
+import chip.devicecontroller.cluster.*
+import java.util.Optional
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterChargingTargetStruct(
+ val targetTime: UInt,
+ val targetSoC: Optional,
+ val addedEnergy: Optional
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterChargingTargetStruct {\n")
+ append("\ttargetTime : $targetTime\n")
+ append("\ttargetSoC : $targetSoC\n")
+ append("\taddedEnergy : $addedEnergy\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_TARGET_TIME), targetTime)
+ if (targetSoC.isPresent) {
+ val opttargetSoC = targetSoC.get()
+ put(ContextSpecificTag(TAG_TARGET_SO_C), opttargetSoC)
+ }
+ if (addedEnergy.isPresent) {
+ val optaddedEnergy = addedEnergy.get()
+ put(ContextSpecificTag(TAG_ADDED_ENERGY), optaddedEnergy)
+ }
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_TARGET_TIME = 0
+ private const val TAG_TARGET_SO_C = 1
+ private const val TAG_ADDED_ENERGY = 2
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterChargingTargetStruct {
+ tlvReader.enterStructure(tlvTag)
+ val targetTime = tlvReader.getUInt(ContextSpecificTag(TAG_TARGET_TIME))
+ val targetSoC =
+ if (tlvReader.isNextTag(ContextSpecificTag(TAG_TARGET_SO_C))) {
+ Optional.of(tlvReader.getUInt(ContextSpecificTag(TAG_TARGET_SO_C)))
+ } else {
+ Optional.empty()
+ }
+ val addedEnergy =
+ if (tlvReader.isNextTag(ContextSpecificTag(TAG_ADDED_ENERGY))) {
+ Optional.of(tlvReader.getLong(ContextSpecificTag(TAG_ADDED_ENERGY)))
+ } else {
+ Optional.empty()
+ }
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterChargingTargetStruct(targetTime, targetSoC, addedEnergy)
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/EnergyEvseCluster.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/EnergyEvseCluster.kt
new file mode 100644
index 00000000000000..8e5208cee1d2b4
--- /dev/null
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/EnergyEvseCluster.kt
@@ -0,0 +1,436 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package matter.devicecontroller.cluster.clusters
+
+import matter.controller.MatterController
+import matter.devicecontroller.cluster.structs.*
+
+class EnergyEvseCluster(private val controller: MatterController, private val endpointId: UShort) {
+ class GetTargetsResponse(
+ val dayOfWeekforSequence: UInt,
+ val chargingTargets: List
+ )
+
+ class StateAttribute(val value: UInt?)
+
+ class ChargingEnabledUntilAttribute(val value: UInt?)
+
+ class DischargingEnabledUntilAttribute(val value: UInt?)
+
+ class NextChargeStartTimeAttribute(val value: UInt?)
+
+ class NextChargeTargetTimeAttribute(val value: UInt?)
+
+ class NextChargeRequiredEnergyAttribute(val value: Long?)
+
+ class NextChargeTargetSoCAttribute(val value: UByte?)
+
+ class ApproximateEVEfficiencyAttribute(val value: UShort?)
+
+ class StateOfChargeAttribute(val value: UByte?)
+
+ class BatteryCapacityAttribute(val value: Long?)
+
+ class VehicleIDAttribute(val value: String?)
+
+ class SessionIDAttribute(val value: UInt?)
+
+ class GeneratedCommandListAttribute(val value: List)
+
+ class AcceptedCommandListAttribute(val value: List)
+
+ class EventListAttribute(val value: List)
+
+ class AttributeListAttribute(val value: List)
+
+ suspend fun disable(timedInvokeTimeoutMs: Int) {
+ val commandId = 1L
+
+ // Implementation needs to be added here
+ }
+
+ suspend fun enableCharging(
+ chargingEnabledUntil: UInt?,
+ minimumChargeCurrent: Long,
+ maximumChargeCurrent: Long,
+ timedInvokeTimeoutMs: Int
+ ) {
+ val commandId = 2L
+
+ // Implementation needs to be added here
+ }
+
+ suspend fun enableDischarging(
+ dischargingEnabledUntil: UInt?,
+ maximumDischargeCurrent: Long,
+ timedInvokeTimeoutMs: Int
+ ) {
+ val commandId = 3L
+
+ // Implementation needs to be added here
+ }
+
+ suspend fun startDiagnostics(timedInvokeTimeoutMs: Int) {
+ val commandId = 4L
+
+ // Implementation needs to be added here
+ }
+
+ suspend fun setTargets(
+ dayOfWeekforSequence: UInt,
+ chargingTargets: List,
+ timedInvokeTimeoutMs: Int
+ ) {
+ val commandId = 5L
+
+ // Implementation needs to be added here
+ }
+
+ suspend fun getTargets(daysToReturn: UInt, timedInvokeTimeoutMs: Int): GetTargetsResponse {
+ val commandId = 6L
+
+ // Implementation needs to be added here
+ }
+
+ suspend fun clearTargets(timedInvokeTimeoutMs: Int) {
+ val commandId = 7L
+
+ // Implementation needs to be added here
+ }
+
+ suspend fun readStateAttribute(): StateAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeStateAttribute(minInterval: Int, maxInterval: Int): StateAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readSupplyStateAttribute(): UByte {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeSupplyStateAttribute(minInterval: Int, maxInterval: Int): UByte {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readFaultStateAttribute(): UByte {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeFaultStateAttribute(minInterval: Int, maxInterval: Int): UByte {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readChargingEnabledUntilAttribute(): ChargingEnabledUntilAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeChargingEnabledUntilAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): ChargingEnabledUntilAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readDischargingEnabledUntilAttribute(): DischargingEnabledUntilAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeDischargingEnabledUntilAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): DischargingEnabledUntilAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readCircuitCapacityAttribute(): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeCircuitCapacityAttribute(minInterval: Int, maxInterval: Int): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readMinimumChargeCurrentAttribute(): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeMinimumChargeCurrentAttribute(minInterval: Int, maxInterval: Int): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readMaximumChargeCurrentAttribute(): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeMaximumChargeCurrentAttribute(minInterval: Int, maxInterval: Int): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readMaximumDischargeCurrentAttribute(): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeMaximumDischargeCurrentAttribute(minInterval: Int, maxInterval: Int): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readUserMaximumChargeCurrentAttribute(): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun writeUserMaximumChargeCurrentAttribute(
+ value: Long,
+ timedWriteTimeoutMs: Int? = null
+ ) {
+ if (timedWriteTimeoutMs != null) {
+ // Do the action with timedWriteTimeoutMs
+ } else {
+ // Do the action without timedWriteTimeoutMs
+ }
+ }
+
+ suspend fun subscribeUserMaximumChargeCurrentAttribute(minInterval: Int, maxInterval: Int): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readRandomizationDelayWindowAttribute(): UInt {
+ // Implementation needs to be added here
+ }
+
+ suspend fun writeRandomizationDelayWindowAttribute(
+ value: UInt,
+ timedWriteTimeoutMs: Int? = null
+ ) {
+ if (timedWriteTimeoutMs != null) {
+ // Do the action with timedWriteTimeoutMs
+ } else {
+ // Do the action without timedWriteTimeoutMs
+ }
+ }
+
+ suspend fun subscribeRandomizationDelayWindowAttribute(minInterval: Int, maxInterval: Int): UInt {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readNumberOfWeeklyTargetsAttribute(): UByte {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeNumberOfWeeklyTargetsAttribute(minInterval: Int, maxInterval: Int): UByte {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readNumberOfDailyTargetsAttribute(): UByte {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeNumberOfDailyTargetsAttribute(minInterval: Int, maxInterval: Int): UByte {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readNextChargeStartTimeAttribute(): NextChargeStartTimeAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeNextChargeStartTimeAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): NextChargeStartTimeAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readNextChargeTargetTimeAttribute(): NextChargeTargetTimeAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeNextChargeTargetTimeAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): NextChargeTargetTimeAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readNextChargeRequiredEnergyAttribute(): NextChargeRequiredEnergyAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeNextChargeRequiredEnergyAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): NextChargeRequiredEnergyAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readNextChargeTargetSoCAttribute(): NextChargeTargetSoCAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeNextChargeTargetSoCAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): NextChargeTargetSoCAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readApproximateEVEfficiencyAttribute(): ApproximateEVEfficiencyAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun writeApproximateEVEfficiencyAttribute(
+ value: UShort,
+ timedWriteTimeoutMs: Int? = null
+ ) {
+ if (timedWriteTimeoutMs != null) {
+ // Do the action with timedWriteTimeoutMs
+ } else {
+ // Do the action without timedWriteTimeoutMs
+ }
+ }
+
+ suspend fun subscribeApproximateEVEfficiencyAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): ApproximateEVEfficiencyAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readStateOfChargeAttribute(): StateOfChargeAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeStateOfChargeAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): StateOfChargeAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readBatteryCapacityAttribute(): BatteryCapacityAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeBatteryCapacityAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): BatteryCapacityAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readVehicleIDAttribute(): VehicleIDAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeVehicleIDAttribute(minInterval: Int, maxInterval: Int): VehicleIDAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readSessionIDAttribute(): SessionIDAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeSessionIDAttribute(minInterval: Int, maxInterval: Int): SessionIDAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readSessionDurationAttribute(): UInt {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeSessionDurationAttribute(minInterval: Int, maxInterval: Int): UInt {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readSessionEnergyChargedAttribute(): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeSessionEnergyChargedAttribute(minInterval: Int, maxInterval: Int): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readSessionEnergyDischargedAttribute(): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeSessionEnergyDischargedAttribute(minInterval: Int, maxInterval: Int): Long {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readGeneratedCommandListAttribute(): GeneratedCommandListAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeGeneratedCommandListAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): GeneratedCommandListAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readAcceptedCommandListAttribute(): AcceptedCommandListAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeAcceptedCommandListAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): AcceptedCommandListAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readEventListAttribute(): EventListAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeEventListAttribute(minInterval: Int, maxInterval: Int): EventListAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readAttributeListAttribute(): AttributeListAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeAttributeListAttribute(
+ minInterval: Int,
+ maxInterval: Int
+ ): AttributeListAttribute {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readFeatureMapAttribute(): UInt {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeFeatureMapAttribute(minInterval: Int, maxInterval: Int): UInt {
+ // Implementation needs to be added here
+ }
+
+ suspend fun readClusterRevisionAttribute(): UShort {
+ // Implementation needs to be added here
+ }
+
+ suspend fun subscribeClusterRevisionAttribute(minInterval: Int, maxInterval: Int): UShort {
+ // Implementation needs to be added here
+ }
+
+ companion object {
+ const val CLUSTER_ID: UInt = 153u
+ }
+}
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVConnectedEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVConnectedEvent.kt
new file mode 100644
index 00000000000000..d3357439368b80
--- /dev/null
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVConnectedEvent.kt
@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package matter.devicecontroller.cluster.eventstructs
+
+import matter.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterEVConnectedEvent(val sessionID: UInt) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterEVConnectedEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterEVConnectedEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getUInt(ContextSpecificTag(TAG_SESSION_I_D))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterEVConnectedEvent(sessionID)
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVNotDetectedEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVNotDetectedEvent.kt
new file mode 100644
index 00000000000000..8f38fc18fdbacf
--- /dev/null
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVNotDetectedEvent.kt
@@ -0,0 +1,89 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package matter.devicecontroller.cluster.eventstructs
+
+import java.util.Optional
+import matter.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterEVNotDetectedEvent(
+ val sessionID: UInt,
+ val state: UInt,
+ val sessionDuration: UInt,
+ val sessionEnergyCharged: Long,
+ val sessionEnergyDischarged: Optional
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterEVNotDetectedEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("\tstate : $state\n")
+ append("\tsessionDuration : $sessionDuration\n")
+ append("\tsessionEnergyCharged : $sessionEnergyCharged\n")
+ append("\tsessionEnergyDischarged : $sessionEnergyDischarged\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ put(ContextSpecificTag(TAG_STATE), state)
+ put(ContextSpecificTag(TAG_SESSION_DURATION), sessionDuration)
+ put(ContextSpecificTag(TAG_SESSION_ENERGY_CHARGED), sessionEnergyCharged)
+ if (sessionEnergyDischarged.isPresent) {
+ val optsessionEnergyDischarged = sessionEnergyDischarged.get()
+ put(ContextSpecificTag(TAG_SESSION_ENERGY_DISCHARGED), optsessionEnergyDischarged)
+ }
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+ private const val TAG_STATE = 1
+ private const val TAG_SESSION_DURATION = 2
+ private const val TAG_SESSION_ENERGY_CHARGED = 3
+ private const val TAG_SESSION_ENERGY_DISCHARGED = 4
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterEVNotDetectedEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getUInt(ContextSpecificTag(TAG_SESSION_I_D))
+ val state = tlvReader.getUInt(ContextSpecificTag(TAG_STATE))
+ val sessionDuration = tlvReader.getUInt(ContextSpecificTag(TAG_SESSION_DURATION))
+ val sessionEnergyCharged = tlvReader.getLong(ContextSpecificTag(TAG_SESSION_ENERGY_CHARGED))
+ val sessionEnergyDischarged =
+ if (tlvReader.isNextTag(ContextSpecificTag(TAG_SESSION_ENERGY_DISCHARGED))) {
+ Optional.of(tlvReader.getLong(ContextSpecificTag(TAG_SESSION_ENERGY_DISCHARGED)))
+ } else {
+ Optional.empty()
+ }
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterEVNotDetectedEvent(
+ sessionID,
+ state,
+ sessionDuration,
+ sessionEnergyCharged,
+ sessionEnergyDischarged
+ )
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStartedEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStartedEvent.kt
new file mode 100644
index 00000000000000..14630d9043c38d
--- /dev/null
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStartedEvent.kt
@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package matter.devicecontroller.cluster.eventstructs
+
+import matter.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterEnergyTransferStartedEvent(
+ val sessionID: UInt,
+ val state: UInt,
+ val maximumCurrent: Long
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterEnergyTransferStartedEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("\tstate : $state\n")
+ append("\tmaximumCurrent : $maximumCurrent\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ put(ContextSpecificTag(TAG_STATE), state)
+ put(ContextSpecificTag(TAG_MAXIMUM_CURRENT), maximumCurrent)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+ private const val TAG_STATE = 1
+ private const val TAG_MAXIMUM_CURRENT = 2
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterEnergyTransferStartedEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getUInt(ContextSpecificTag(TAG_SESSION_I_D))
+ val state = tlvReader.getUInt(ContextSpecificTag(TAG_STATE))
+ val maximumCurrent = tlvReader.getLong(ContextSpecificTag(TAG_MAXIMUM_CURRENT))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterEnergyTransferStartedEvent(sessionID, state, maximumCurrent)
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStoppedEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStoppedEvent.kt
new file mode 100644
index 00000000000000..8ce39cc2ccef2c
--- /dev/null
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStoppedEvent.kt
@@ -0,0 +1,74 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package matter.devicecontroller.cluster.eventstructs
+
+import matter.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterEnergyTransferStoppedEvent(
+ val sessionID: UInt,
+ val state: UInt,
+ val reason: UInt,
+ val energyTransferred: Long
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterEnergyTransferStoppedEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("\tstate : $state\n")
+ append("\treason : $reason\n")
+ append("\tenergyTransferred : $energyTransferred\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ put(ContextSpecificTag(TAG_STATE), state)
+ put(ContextSpecificTag(TAG_REASON), reason)
+ put(ContextSpecificTag(TAG_ENERGY_TRANSFERRED), energyTransferred)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+ private const val TAG_STATE = 1
+ private const val TAG_REASON = 2
+ private const val TAG_ENERGY_TRANSFERRED = 4
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterEnergyTransferStoppedEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getUInt(ContextSpecificTag(TAG_SESSION_I_D))
+ val state = tlvReader.getUInt(ContextSpecificTag(TAG_STATE))
+ val reason = tlvReader.getUInt(ContextSpecificTag(TAG_REASON))
+ val energyTransferred = tlvReader.getLong(ContextSpecificTag(TAG_ENERGY_TRANSFERRED))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterEnergyTransferStoppedEvent(
+ sessionID,
+ state,
+ reason,
+ energyTransferred
+ )
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterFaultEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterFaultEvent.kt
new file mode 100644
index 00000000000000..71cdcae9dc193f
--- /dev/null
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterFaultEvent.kt
@@ -0,0 +1,76 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package matter.devicecontroller.cluster.eventstructs
+
+import matter.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterFaultEvent(
+ val sessionID: UInt,
+ val state: UInt,
+ val faultStatePreviousState: UInt,
+ val faultStateCurrentState: UInt
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterFaultEvent {\n")
+ append("\tsessionID : $sessionID\n")
+ append("\tstate : $state\n")
+ append("\tfaultStatePreviousState : $faultStatePreviousState\n")
+ append("\tfaultStateCurrentState : $faultStateCurrentState\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_SESSION_I_D), sessionID)
+ put(ContextSpecificTag(TAG_STATE), state)
+ put(ContextSpecificTag(TAG_FAULT_STATE_PREVIOUS_STATE), faultStatePreviousState)
+ put(ContextSpecificTag(TAG_FAULT_STATE_CURRENT_STATE), faultStateCurrentState)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_SESSION_I_D = 0
+ private const val TAG_STATE = 1
+ private const val TAG_FAULT_STATE_PREVIOUS_STATE = 2
+ private const val TAG_FAULT_STATE_CURRENT_STATE = 4
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterFaultEvent {
+ tlvReader.enterStructure(tlvTag)
+ val sessionID = tlvReader.getUInt(ContextSpecificTag(TAG_SESSION_I_D))
+ val state = tlvReader.getUInt(ContextSpecificTag(TAG_STATE))
+ val faultStatePreviousState =
+ tlvReader.getUInt(ContextSpecificTag(TAG_FAULT_STATE_PREVIOUS_STATE))
+ val faultStateCurrentState =
+ tlvReader.getUInt(ContextSpecificTag(TAG_FAULT_STATE_CURRENT_STATE))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterFaultEvent(
+ sessionID,
+ state,
+ faultStatePreviousState,
+ faultStateCurrentState
+ )
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterRFIDEvent.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterRFIDEvent.kt
new file mode 100644
index 00000000000000..65558cac9a6b7a
--- /dev/null
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterRFIDEvent.kt
@@ -0,0 +1,52 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package matter.devicecontroller.cluster.eventstructs
+
+import matter.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterRFIDEvent(val uid: ByteArray) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterRFIDEvent {\n")
+ append("\tuid : $uid\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_UID), uid)
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_UID = 0
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterRFIDEvent {
+ tlvReader.enterStructure(tlvTag)
+ val uid = tlvReader.getByteArray(ContextSpecificTag(TAG_UID))
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterRFIDEvent(uid)
+ }
+ }
+}
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni b/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni
index b7b954def5b75e..ff4d4116b610cc 100644
--- a/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/files.gni
@@ -37,6 +37,7 @@ matter_structs_sources = [
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DishwasherModeClusterModeOptionStruct.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DishwasherModeClusterModeTagStruct.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/DoorLockClusterCredentialStruct.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/FixedLabelClusterLabelStruct.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GeneralCommissioningClusterBasicCommissioningInfo.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/GeneralDiagnosticsClusterNetworkInterface.kt",
@@ -117,6 +118,12 @@ matter_eventstructs_sources = [
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockOperationEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockOperationErrorEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/DoorLockClusterLockUserChangeEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStartedEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEnergyTransferStoppedEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVConnectedEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterEVNotDetectedEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterFaultEvent.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/EnergyEvseClusterRFIDEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterBootReasonEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterHardwareFaultChangeEvent.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/eventstructs/GeneralDiagnosticsClusterNetworkFaultChangeEvent.kt",
@@ -188,6 +195,7 @@ matter_clusters_sources = [
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DishwasherModeCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/DoorLockCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/ElectricalMeasurementCluster.kt",
+ "${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/EnergyEvseCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/EthernetNetworkDiagnosticsCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FanControlCluster.kt",
"${chip_root}/src/controller/java/generated/java/matter/devicecontroller/cluster/clusters/FaultInjectionCluster.kt",
diff --git a/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt b/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt
new file mode 100644
index 00000000000000..a81f4c8716c8e8
--- /dev/null
+++ b/src/controller/java/generated/java/matter/devicecontroller/cluster/structs/EnergyEvseClusterChargingTargetStruct.kt
@@ -0,0 +1,81 @@
+/*
+ *
+ * Copyright (c) 2023 Project CHIP Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package matter.devicecontroller.cluster.structs
+
+import java.util.Optional
+import matter.devicecontroller.cluster.*
+import matter.tlv.ContextSpecificTag
+import matter.tlv.Tag
+import matter.tlv.TlvReader
+import matter.tlv.TlvWriter
+
+class EnergyEvseClusterChargingTargetStruct(
+ val targetTime: UShort,
+ val targetSoC: Optional,
+ val addedEnergy: Optional
+) {
+ override fun toString(): String = buildString {
+ append("EnergyEvseClusterChargingTargetStruct {\n")
+ append("\ttargetTime : $targetTime\n")
+ append("\ttargetSoC : $targetSoC\n")
+ append("\taddedEnergy : $addedEnergy\n")
+ append("}\n")
+ }
+
+ fun toTlv(tlvTag: Tag, tlvWriter: TlvWriter) {
+ tlvWriter.apply {
+ startStructure(tlvTag)
+ put(ContextSpecificTag(TAG_TARGET_TIME), targetTime)
+ if (targetSoC.isPresent) {
+ val opttargetSoC = targetSoC.get()
+ put(ContextSpecificTag(TAG_TARGET_SO_C), opttargetSoC)
+ }
+ if (addedEnergy.isPresent) {
+ val optaddedEnergy = addedEnergy.get()
+ put(ContextSpecificTag(TAG_ADDED_ENERGY), optaddedEnergy)
+ }
+ endStructure()
+ }
+ }
+
+ companion object {
+ private const val TAG_TARGET_TIME = 0
+ private const val TAG_TARGET_SO_C = 1
+ private const val TAG_ADDED_ENERGY = 2
+
+ fun fromTlv(tlvTag: Tag, tlvReader: TlvReader): EnergyEvseClusterChargingTargetStruct {
+ tlvReader.enterStructure(tlvTag)
+ val targetTime = tlvReader.getUShort(ContextSpecificTag(TAG_TARGET_TIME))
+ val targetSoC =
+ if (tlvReader.isNextTag(ContextSpecificTag(TAG_TARGET_SO_C))) {
+ Optional.of(tlvReader.getUByte(ContextSpecificTag(TAG_TARGET_SO_C)))
+ } else {
+ Optional.empty()
+ }
+ val addedEnergy =
+ if (tlvReader.isNextTag(ContextSpecificTag(TAG_ADDED_ENERGY))) {
+ Optional.of(tlvReader.getLong(ContextSpecificTag(TAG_ADDED_ENERGY)))
+ } else {
+ Optional.empty()
+ }
+
+ tlvReader.exitContainer()
+
+ return EnergyEvseClusterChargingTargetStruct(targetTime, targetSoC, addedEnergy)
+ }
+ }
+}
diff --git a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
index 578272e2e515c4..f9f0cb6e56e6d4 100644
--- a/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
+++ b/src/controller/java/zap-generated/CHIPAttributeTLVValueDecoder.cpp
@@ -20357,6 +20357,628 @@ jobject DecodeAttributeValue(const app::ConcreteAttributePath & aPath, TLV::TLVR
}
break;
}
+ case app::Clusters::EnergyEvse::Id: {
+ using namespace app::Clusters::EnergyEvse;
+ switch (aPath.mAttributeId)
+ {
+ case Attributes::State::Id: {
+ using TypeInfo = Attributes::State::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::SupplyState::Id: {
+ using TypeInfo = Attributes::SupplyState::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue,
+ value);
+ return value;
+ }
+ case Attributes::FaultState::Id: {
+ using TypeInfo = Attributes::FaultState::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue,
+ value);
+ return value;
+ }
+ case Attributes::ChargingEnabledUntil::Id: {
+ using TypeInfo = Attributes::ChargingEnabledUntil::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::DischargingEnabledUntil::Id: {
+ using TypeInfo = Attributes::DischargingEnabledUntil::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::CircuitCapacity::Id: {
+ using TypeInfo = Attributes::CircuitCapacity::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::MinimumChargeCurrent::Id: {
+ using TypeInfo = Attributes::MinimumChargeCurrent::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::MaximumChargeCurrent::Id: {
+ using TypeInfo = Attributes::MaximumChargeCurrent::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::MaximumDischargeCurrent::Id: {
+ using TypeInfo = Attributes::MaximumDischargeCurrent::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::UserMaximumChargeCurrent::Id: {
+ using TypeInfo = Attributes::UserMaximumChargeCurrent::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::RandomizationDelayWindow::Id: {
+ using TypeInfo = Attributes::RandomizationDelayWindow::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::NumberOfWeeklyTargets::Id: {
+ using TypeInfo = Attributes::NumberOfWeeklyTargets::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue,
+ value);
+ return value;
+ }
+ case Attributes::NumberOfDailyTargets::Id: {
+ using TypeInfo = Attributes::NumberOfDailyTargets::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue,
+ value);
+ return value;
+ }
+ case Attributes::NextChargeStartTime::Id: {
+ using TypeInfo = Attributes::NextChargeStartTime::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::NextChargeTargetTime::Id: {
+ using TypeInfo = Attributes::NextChargeTargetTime::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::NextChargeRequiredEnergy::Id: {
+ using TypeInfo = Attributes::NextChargeRequiredEnergy::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::NextChargeTargetSoC::Id: {
+ using TypeInfo = Attributes::NextChargeTargetSoC::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::ApproximateEVEfficiency::Id: {
+ using TypeInfo = Attributes::ApproximateEVEfficiency::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::StateOfCharge::Id: {
+ using TypeInfo = Attributes::StateOfCharge::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::BatteryCapacity::Id: {
+ using TypeInfo = Attributes::BatteryCapacity::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::VehicleID::Id: {
+ using TypeInfo = Attributes::VehicleID::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ LogErrorOnFailure(chip::JniReferences::GetInstance().CharToStringUTF(cppValue.Value(), value));
+ }
+ return value;
+ }
+ case Attributes::SessionID::Id: {
+ using TypeInfo = Attributes::SessionID::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ if (cppValue.IsNull())
+ {
+ value = nullptr;
+ }
+ else
+ {
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue.Value());
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ }
+ return value;
+ }
+ case Attributes::SessionDuration::Id: {
+ using TypeInfo = Attributes::SessionDuration::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::SessionEnergyCharged::Id: {
+ using TypeInfo = Attributes::SessionEnergyCharged::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::SessionEnergyDischarged::Id: {
+ using TypeInfo = Attributes::SessionEnergyDischarged::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::GeneratedCommandList::Id: {
+ using TypeInfo = Attributes::GeneratedCommandList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ chip::JniReferences::GetInstance().CreateArrayList(value);
+
+ auto iter_value_0 = cppValue.begin();
+ while (iter_value_0.Next())
+ {
+ auto & entry_0 = iter_value_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ jlong jninewElement_0 = static_cast(entry_0);
+ chip::JniReferences::GetInstance().CreateBoxedObject(
+ newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(value, newElement_0);
+ }
+ return value;
+ }
+ case Attributes::AcceptedCommandList::Id: {
+ using TypeInfo = Attributes::AcceptedCommandList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ chip::JniReferences::GetInstance().CreateArrayList(value);
+
+ auto iter_value_0 = cppValue.begin();
+ while (iter_value_0.Next())
+ {
+ auto & entry_0 = iter_value_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ jlong jninewElement_0 = static_cast(entry_0);
+ chip::JniReferences::GetInstance().CreateBoxedObject(
+ newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(value, newElement_0);
+ }
+ return value;
+ }
+ case Attributes::EventList::Id: {
+ using TypeInfo = Attributes::EventList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ chip::JniReferences::GetInstance().CreateArrayList(value);
+
+ auto iter_value_0 = cppValue.begin();
+ while (iter_value_0.Next())
+ {
+ auto & entry_0 = iter_value_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ jlong jninewElement_0 = static_cast(entry_0);
+ chip::JniReferences::GetInstance().CreateBoxedObject(
+ newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(value, newElement_0);
+ }
+ return value;
+ }
+ case Attributes::AttributeList::Id: {
+ using TypeInfo = Attributes::AttributeList::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ chip::JniReferences::GetInstance().CreateArrayList(value);
+
+ auto iter_value_0 = cppValue.begin();
+ while (iter_value_0.Next())
+ {
+ auto & entry_0 = iter_value_0.GetValue();
+ jobject newElement_0;
+ std::string newElement_0ClassName = "java/lang/Long";
+ std::string newElement_0CtorSignature = "(J)V";
+ jlong jninewElement_0 = static_cast(entry_0);
+ chip::JniReferences::GetInstance().CreateBoxedObject(
+ newElement_0ClassName.c_str(), newElement_0CtorSignature.c_str(), jninewElement_0, newElement_0);
+ chip::JniReferences::GetInstance().AddToList(value, newElement_0);
+ }
+ return value;
+ }
+ case Attributes::FeatureMap::Id: {
+ using TypeInfo = Attributes::FeatureMap::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Long";
+ std::string valueCtorSignature = "(J)V";
+ jlong jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(),
+ jnivalue, value);
+ return value;
+ }
+ case Attributes::ClusterRevision::Id: {
+ using TypeInfo = Attributes::ClusterRevision::TypeInfo;
+ TypeInfo::DecodableType cppValue;
+ *aError = app::DataModel::Decode(aReader, cppValue);
+ if (*aError != CHIP_NO_ERROR)
+ {
+ return nullptr;
+ }
+ jobject value;
+ std::string valueClassName = "java/lang/Integer";
+ std::string valueCtorSignature = "(I)V";
+ jint jnivalue = static_cast(cppValue);
+ chip::JniReferences::GetInstance().CreateBoxedObject(valueClassName.c_str(), valueCtorSignature.c_str(), jnivalue,
+ value);
+ return value;
+ }
+ default:
+ *aError = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB;
+ break;
+ }
+ break;
+ }
case app::Clusters::DoorLock::Id: {
using namespace app::Clusters::DoorLock;
switch (aPath.mAttributeId)
diff --git a/src/controller/java/zap-generated/CHIPClientCallbacks.h b/src/controller/java/zap-generated/CHIPClientCallbacks.h
index 4c0cabbb1152d4..b2ad57495245dd 100644
--- a/src/controller/java/zap-generated/CHIPClientCallbacks.h
+++ b/src/controller/java/zap-generated/CHIPClientCallbacks.h
@@ -735,6 +735,14 @@ typedef void (*DemandResponseLoadControlEventListListAttributeCallback)(
void * context, const chip::app::DataModel::DecodableList & data);
typedef void (*DemandResponseLoadControlAttributeListListAttributeCallback)(
void * context, const chip::app::DataModel::DecodableList & data);
+typedef void (*EnergyEvseGeneratedCommandListListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList & data);
+typedef void (*EnergyEvseAcceptedCommandListListAttributeCallback)(
+ void * context, const chip::app::DataModel::DecodableList & data);
+typedef void (*EnergyEvseEventListListAttributeCallback)(void * context,
+ const chip::app::DataModel::DecodableList & data);
+typedef void (*EnergyEvseAttributeListListAttributeCallback)(void * context,
+ const chip::app::DataModel::DecodableList & data);
typedef void (*DoorLockGeneratedCommandListListAttributeCallback)(
void * context, const chip::app::DataModel::DecodableList & data);
typedef void (*DoorLockAcceptedCommandListListAttributeCallback)(void * context,
diff --git a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp
index 579273d56daea5..e55f6a63f9297c 100644
--- a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp
+++ b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp
@@ -3668,6 +3668,168 @@ JNI_METHOD(void, DemandResponseLoadControlCluster, writeDefaultRandomDurationAtt
onFailure.release();
}
+JNI_METHOD(void, EnergyEvseCluster, writeUserMaximumChargeCurrentAttribute)
+(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs)
+{
+ chip::DeviceLayer::StackLock lock;
+ ListFreer listFreer;
+ using TypeInfo = chip::app::Clusters::EnergyEvse::Attributes::UserMaximumChargeCurrent::TypeInfo;
+ TypeInfo::Type cppValue;
+
+ std::vector> cleanupByteArrays;
+ std::vector> cleanupStrings;
+
+ cppValue = static_cast>(chip::JniReferences::GetInstance().LongToPrimitive(value));
+
+ std::unique_ptr onSuccess(
+ Platform::New(callback), Platform::Delete