I’d like to make a focused Matter driver/API feature request:
Please expose a way for Hubitat Matter drivers to set EventPathIB.IsUrgent = true when subscribing to Matter event paths.
(This concerns a Matter driver/API capability needed by custom drivers: the ability for event-path subscriptions to request low-latency delivery through EventPathIB.IsUrgent.)
Motivation
This matters for Matter Generic Switch / button devices that report user interactions through the Switch cluster (0x003B) event stream.
There has already been some useful community work around this area, especially in the IKEA BILRESA Matter button driver discussion (here). That driver subscribes to Switch cluster events using matter.eventPath(...), and also subscribes to nearby Switch cluster attributes. The comment in that code notes that subscribing to Switch cluster attribute reports seems to be required to keep events flowing.
I think that observation makes sense as an implementation side effect, but it is not a reliable latency reduction mechanism.
My current understanding is:
-
Switch/button events are generated by the device.
-
If the event subscription is not urgent, the device/server may buffer and batch those events until the subscription max interval.
-
A subscribed attribute change on the same cluster can trigger a
ReportDatasooner. -
Some queued events may then appear to arrive “because” the attribute was subscribed.
-
But this is opportunistic partial draining, not a reliable way to request prompt event delivery.
That workaround can help in some cases, but it is not sufficient for latency-sensitive button use.
This interpretation also appears consistent with the Subscription Interaction overview in Matter Core Specification R1.4 § 8.5. Subscription reporting is designed to balance timeliness and efficiency, with reports generated according to the subscription parameters and implementation behavior. Attribute activity may create additional opportunities for reports to be sent, but that is not the same thing as explicitly requesting urgent delivery of a particular event stream. The EventPathIB.IsUrgent flag exists precisely to allow a subscriber to indicate that certain events should be reported with minimal delay.
Concrete example
I have been testing with an Inovelli White Series dimmer, model VTM31-SN, firmware 1.1.5, using Matter over Thread.
The relevant endpoints expose the Matter Switch cluster (0x003B) for paddle/config-button interactions. Hubitat can subscribe to these events and receive them through parse(...) as expected.
The problem is latency for some event-only interactions, especially multi-press summary events. Subscribing to adjacent Switch cluster attributes can cause some events to arrive sooner, but it does not reliably cause all relevant events to be included in the resulting report. In particular, the most actionable multipress event can still wait until the subscription max interval.
Explicit attribute reads do not solve this either, because an attribute-only read does not request event reports.
Independent verification
To separate device behavior from Hubitat behavior, I tested the same device using a test fabric and chip-tool.
Using chip-tool event subscriptions against the same VTM31-SN, I verified that the device does accept and respect the Matter EventPathIB.IsUrgent flag for Switch cluster (0x003B) events:
-
With
IsUrgent = true, events are delivered immediately after the device generates them. -
Without
IsUrgent, the same events are delayed until the subscription max interval or arrive opportunistically batched with other cluster reports. (This matches the delayed/non-urgent behavior I observe when subscribing to these events from a Hubitat driver today.)
So this does not appear to be an Inovelli inability to honor urgent event subscriptions. The missing piece appears to be that Hubitat drivers currently have no documented way to request urgent event paths.
Current Hubitat-facing API gap
Today we can do things like:
paths.add(matter.eventPath(ep, 0x003B, eventId))
sendHubCommand(new HubAction(matter.subscribe(0, 600, paths), Protocol.MATTER))
or manually build a command like:
he subscribe 0x0000 0x0258 [{"ep":"0x03","cluster":"0x003B","evt":"0x00000006"}]
But I do not see a documented way to set the IsUrgent field on the resulting Matter EventPathIB.
Suggested API shape
Any of these would be useful:
matter.eventPath(endpoint, cluster, event, true)
or:
matter.eventPath(endpoint, cluster, event, [isUrgent: true])
or support in the raw he subscribe JSON path form:
he subscribe 0x0000 0x0258 [{"ep":"0x03","cluster":"0x003B","evt":"0x00000006","isUrgent":true}]
I do not have a strong opinion about the exact API shape. The key request is simply that a Hubitat Matter driver be able to cause the outgoing Matter subscription to include:
EventPathIB {
Endpoint = ...
Cluster = 0x003B
Event = ...
IsUrgent = true
}
Why this seems important
This is a driver/API capability gap rather than a device-specific tuning request. Without access to this Matter Interaction Model field, Hubitat drivers cannot request prompt delivery of latency-sensitive event streams, which limits the ability to build Matter button/switch drivers with responsiveness comparable to equivalent Z-Wave devices.
For button/switch devices, especially Matter Generic Switch devices, delayed event delivery makes Hubitat automations feel unreliable or sluggish even when the device has already generated the event promptly.
The current workaround of subscribing to related attributes is not equivalent to urgent event subscription. It may create additional report opportunities, but it does not guarantee prompt delivery of the specific event path the driver actually needs.
This is especially important for drivers that need MultiPressComplete / multipress summary events rather than just raw current-position attributes or initial press edges.
More broadly, exposing IsUrgent would allow Hubitat Matter drivers to make use of a capability already defined by the Matter specification for latency-sensitive event streams. Given the growing reliance on Matter event subscriptions in custom drivers — as reflected in recent discussions around subscription behavior and re-subscription handling — having access to the full event subscription model seems increasingly valuable.
Request
Could Hubitat expose EventPathIB.IsUrgent for Matter event subscriptions, either through matter.eventPath(...), matter.subscribe(...), or the underlying he subscribe path JSON?
And if there is already an undocumented way to set this flag from a Groovy Matter driver, could someone point me in the right direction?
I am happy to provide more detail on the test setup or observed timing differences if useful.
[Edit: lightly revised wording to clarify that the request is about a Matter driver/API capability gap needed for low-latency event subscriptions.]