Add greater dynamic profiling to matter switch

Author: hcarter-775

drivers/SmartThings/matter-switch/src/init.lua

@@ -101,7 +101,7 @@ function SwitchLifecycleHandlers.device_init(driver, device)
           id = math.max(id, dt.device_type_id)
         end
         for _, attr in pairs(fields.device_type_attribute_map[id] or {}) do
-          if id == fields.GENERIC_SWITCH_ID and
+          if id == fields.DEVICE_TYPE_ID.GENERIC_SWITCH and
              attr ~= clusters.PowerSource.attributes.BatPercentRemaining and
              attr ~= clusters.PowerSource.attributes.BatChargeLevel then
             device:add_subscribed_event(attr)

drivers/SmartThings/matter-switch/src/test/test_electrical_sensor.lua

@@ -56,7 +56,7 @@ local mock_device = test.mock_device.build_test_matter_device({
         {cluster_id = clusters.LevelControl.ID, cluster_type = "SERVER", feature_map = 2}
       },
       device_types = {
-        { device_type_id = 0x010A, device_type_revision = 1 } -- OnOff Plug
+        { device_type_id = 0x010B, device_type_revision = 1 }, -- Dimmable Plug In Unit
       }
     }
   },
@@ -88,10 +88,20 @@ local mock_device_periodic = test.mock_device.build_test_matter_device({
         { device_type_id = 0x0510, device_type_revision = 1 } -- Electrical Sensor
       }
     },
+    {
+      endpoint_id = 2,
+      clusters = {
+        { cluster_id = clusters.OnOff.ID, cluster_type = "SERVER", cluster_revision = 1, feature_map = 0, },
+      },
+      device_types = {
+        { device_type_id = 0x010A, device_type_revision = 1 }, -- On Off Plug In Unit
+      }
+    }
   },
 })
 
 local subscribed_attributes_periodic = {
+  clusters.OnOff.attributes.OnOff,
   clusters.ElectricalEnergyMeasurement.attributes.PeriodicEnergyImported,
   clusters.ElectricalEnergyMeasurement.attributes.CumulativeEnergyImported,
 }

drivers/SmartThings/matter-switch/src/test/test_matter_switch_device_types.lua

@@ -505,6 +505,7 @@ local function test_init_mounted_on_off_control()
   test.socket.matter:__expect_send({mock_device_mounted_on_off_control.id, subscribe_request})
 
   test.socket.device_lifecycle:__queue_receive({ mock_device_mounted_on_off_control.id, "doConfigure" })
+  mock_device_mounted_on_off_control:expect_metadata_update({ profile = "switch-binary" })
   mock_device_mounted_on_off_control:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 end
 
@@ -526,6 +527,7 @@ local function test_init_mounted_dimmable_load_control()
   test.socket.matter:__expect_send({mock_device_mounted_dimmable_load_control.id, subscribe_request})
 
   test.socket.device_lifecycle:__queue_receive({ mock_device_mounted_dimmable_load_control.id, "doConfigure" })
+  mock_device_mounted_dimmable_load_control:expect_metadata_update({ profile = "switch-level" })
   mock_device_mounted_dimmable_load_control:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 end
 
@@ -566,6 +568,7 @@ local function test_init_parent_child_different_types()
   test.socket.matter:__expect_send({mock_device_parent_child_different_types.id, subscribe_request})
 
   test.socket.device_lifecycle:__queue_receive({ mock_device_parent_child_different_types.id, "doConfigure" })
+  mock_device_parent_child_different_types:expect_metadata_update({ profile = "switch-binary" })
   mock_device_parent_child_different_types:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 
   mock_device_parent_child_different_types:expect_device_create({
@@ -617,6 +620,7 @@ local function test_init_light_level_motion()
   test.socket.matter:__expect_send({mock_device_light_level_motion.id, subscribe_request})
 
   test.socket.device_lifecycle:__queue_receive({ mock_device_light_level_motion.id, "doConfigure" })
+  mock_device_light_level_motion:expect_metadata_update({ profile = "light-level-motion" })
   mock_device_light_level_motion:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 end
 

drivers/SmartThings/matter-switch/src/test/test_multi_switch_parent_child_lights.lua

@@ -189,6 +189,7 @@ local function test_init()
   test.socket.matter:__expect_send({mock_device.id, subscribe_request})
 
   test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+  mock_device:expect_metadata_update({ profile = "light-binary" })
   mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 
   for _, child in pairs(mock_children) do
@@ -260,6 +261,7 @@ local function test_init_parent_child_endpoints_non_sequential()
   test.socket.matter:__expect_send({mock_device_parent_child_endpoints_non_sequential.id, subscribe_request})
 
   test.socket.device_lifecycle:__queue_receive({ mock_device_parent_child_endpoints_non_sequential.id, "doConfigure" })
+  mock_device_parent_child_endpoints_non_sequential:expect_metadata_update({ profile = "light-binary" })
   mock_device_parent_child_endpoints_non_sequential:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 
   for _, child in pairs(mock_children_non_sequential) do

drivers/SmartThings/matter-switch/src/test/test_multi_switch_parent_child_plugs.lua

@@ -146,6 +146,7 @@ local function test_init()
   test.socket.matter:__expect_send({mock_device.id, subscribe_request})
 
   test.socket.device_lifecycle:__queue_receive({ mock_device.id, "doConfigure" })
+  mock_device:expect_metadata_update({ profile = "plug-binary" })
   mock_device:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 
   for _, child in pairs(mock_children) do
@@ -196,6 +197,7 @@ local function test_init_child_profile_override()
   test.socket.matter:__expect_send({mock_device_child_profile_override.id, subscribe_request})
 
   test.socket.device_lifecycle:__queue_receive({ mock_device_child_profile_override.id, "doConfigure" })
+  mock_device_child_profile_override:expect_metadata_update({ profile = "switch-binary" })
   mock_device_child_profile_override:expect_metadata_update({ provisioning_state = "PROVISIONED" })
 
   for _, child in pairs(mock_children_child_profile_override) do

drivers/SmartThings/matter-switch/src/utils/device_configuration.lua

@@ -31,92 +31,57 @@ local DeviceConfiguration = {}
 local SwitchDeviceConfiguration = {}
 local ButtonDeviceConfiguration = {}
 
-function SwitchDeviceConfiguration.assign_child_profile(device, child_ep)
-  local profile
+function SwitchDeviceConfiguration.assign_profile_for_onoff_ep(device, server_onoff_ep_id, is_child_device)
+  local ep_info = switch_utils.get_endpoint_info(device, server_onoff_ep_id)
 
-  for _, ep in ipairs(device.endpoints) do
-    if ep.endpoint_id == child_ep then
-      -- Some devices report multiple device types which are a subset of
-      -- a superset device type (For example, Dimmable Light is a superset of
-      -- On/Off light). This mostly applies to the four light types, so we will want
-      -- to match the profile for the superset device type. This can be done by
-      -- matching to the device type with the highest ID
-      local id = 0
-      for _, dt in ipairs(ep.device_types) do
-        id = math.max(id, dt.device_type_id)
-      end
-      profile = fields.device_type_profile_map[id]
-      break
-    end
-  end
-
-  -- vendor override checks
-  if child_ep == switch_utils.get_product_override_field(device, "ep_id") or profile == switch_utils.get_product_override_field(device, "initial_profile") then
-    profile = switch_utils.get_product_override_field(device, "target_profile") or profile
-  end
+  -- per spec, the Switch device types support OnOff as CLIENT, though some vendors break spec and support it as SERVER.
+  local primary_dt_id = switch_utils.find_max_subset_device_type(ep_info, fields.DEVICE_TYPE_ID.LIGHT)
+    or switch_utils.find_max_subset_device_type(ep_info, fields.DEVICE_TYPE_ID.SWITCH)
+    or ep_info.device_types[1] and ep_info.device_types[1].device_type_id
 
-  -- default to "switch-binary" if no profile is found
-  return profile or "switch-binary"
-end
-
-function SwitchDeviceConfiguration.create_child_switch_devices(driver, device, main_endpoint)
-  local num_switch_server_eps = 0
-  local parent_child_device = false
-  local switch_eps = device:get_endpoints(clusters.OnOff.ID)
-  table.sort(switch_eps)
-  for idx, ep in ipairs(switch_eps) do
-    if device:supports_server_cluster(clusters.OnOff.ID, ep) then
-      num_switch_server_eps = num_switch_server_eps + 1
-      if ep ~= main_endpoint then -- don't create a child device that maps to the main endpoint
-        local name = string.format("%s %d", device.label, num_switch_server_eps)
-        local child_profile = SwitchDeviceConfiguration.assign_child_profile(device, ep)
-        driver:try_create_device(
-          {
-            type = "EDGE_CHILD",
-            label = name,
-            profile = child_profile,
-            parent_device_id = device.id,
-            parent_assigned_child_key = string.format("%d", ep),
-            vendor_provided_label = name
-          }
-        )
-        parent_child_device = true
-        if idx == 1 and string.find(child_profile, "energy") then
-          -- when energy management is defined in the root endpoint(0), replace it with the first switch endpoint and process it.
-          device:set_field(fields.ENERGY_MANAGEMENT_ENDPOINT, ep, {persist = true})
-        end
-      end
-    end
-  end
+  local generic_profile = fields.device_type_profile_map[primary_dt_id]
 
-  -- If the device is a parent child device, set the find_child function on init. This is persisted because initialize_buttons_and_switches
-  -- is only run once, but find_child function should be set on each driver init.
-  if parent_child_device then
-    device:set_field(fields.IS_PARENT_CHILD_DEVICE, true, {persist = true})
+  if is_child_device and (
+    server_onoff_ep_id == switch_utils.get_product_override_field(device, "ep_id") or
+    generic_profile == switch_utils.get_product_override_field(device, "initial_profile")
+  ) then
+    generic_profile = switch_utils.get_product_override_field(device, "target_profile") or generic_profile
   end
 
-  -- this is needed in initialize_buttons_and_switches
-  return num_switch_server_eps
+  -- if no supported device type is found, return switch-binary as a generic "OnOff EP" profile
+  return generic_profile or "switch-binary"
 end
 
-function SwitchDeviceConfiguration.update_devices_with_onOff_server_clusters(device, main_endpoint)
-  local cluster_id = 0
-  for _, ep in ipairs(device.endpoints) do
-    -- main_endpoint only supports server cluster by definition of get_endpoints()
-    if main_endpoint == ep.endpoint_id then
-      for _, dt in ipairs(ep.device_types) do
-        -- no device type that is not in the switch subset should be considered.
-        if (fields.ON_OFF_SWITCH_ID <= dt.device_type_id and dt.device_type_id <= fields.ON_OFF_COLOR_DIMMER_SWITCH_ID) then
-          cluster_id = math.max(cluster_id, dt.device_type_id)
-        end
+function SwitchDeviceConfiguration.create_child_devices(driver, device, onoff_ep_ids, main_endpoint_id)
+  if #onoff_ep_ids == 1 and onoff_ep_ids[1] == main_endpoint_id then -- no children will be created
+   return
+  end
+
+  local device_num = 0
+  table.sort(onoff_ep_ids)
+  for idx, ep_id in ipairs(onoff_ep_ids) do
+    device_num = device_num + 1
+    if ep_id ~= main_endpoint_id then -- don't create a child device that maps to the main endpoint
+      local name = string.format("%s %d", device.label, device_num)
+      local child_profile = SwitchDeviceConfiguration.assign_profile_for_onoff_ep(device, ep_id, true)
+      driver:try_create_device({
+        type = "EDGE_CHILD",
+        label = name,
+        profile = child_profile,
+        parent_device_id = device.id,
+        parent_assigned_child_key = string.format("%d", ep_id),
+        vendor_provided_label = name
+      })
+      if idx == 1 and string.find(child_profile, "energy") then
+        -- when energy management is defined in the root endpoint(0), replace it with the first switch endpoint and process it.
+        device:set_field(fields.ENERGY_MANAGEMENT_ENDPOINT, ep_id, {persist = true})
       end
-      break
     end
   end
 
-  if fields.device_type_profile_map[cluster_id] then
-    device:try_update_metadata({profile = fields.device_type_profile_map[cluster_id]})
-  end
+  -- Persist so that the find_child function is always set on each driver init.
+  device:set_field(fields.IS_PARENT_CHILD_DEVICE, true, {persist = true})
+  device:set_find_child(switch_utils.find_child)
 end
 
 function ButtonDeviceConfiguration.update_button_profile(device, main_endpoint, num_button_eps)
@@ -192,75 +157,61 @@ end
 
 -- [[ PROFILE MATCHING AND CONFIGURATIONS ]] --
 
-function DeviceConfiguration.initialize_buttons_and_switches(driver, device, main_endpoint)
-  local profile_found = false
-  local button_eps = device:get_endpoints(clusters.Switch.ID, {feature_bitmap=clusters.Switch.types.SwitchFeature.MOMENTARY_SWITCH})
-  if switch_utils.tbl_contains(fields.STATIC_BUTTON_PROFILE_SUPPORTED, #button_eps) then
-    ButtonDeviceConfiguration.update_button_profile(device, main_endpoint, #button_eps)
-    -- All button endpoints found will be added as additional components in the profile containing the main_endpoint.
-    -- The resulting endpoint to component map is saved in the COMPONENT_TO_ENDPOINT_MAP field
-    ButtonDeviceConfiguration.update_button_component_map(device, main_endpoint, button_eps)
-    ButtonDeviceConfiguration.configure_buttons(device)
-    profile_found = true
-  end
-
-  -- Without support for bindings, only clusters that are implemented as server are counted. This count is handled
-  -- while building switch child profiles
-  local num_switch_server_eps = SwitchDeviceConfiguration.create_child_switch_devices(driver, device, main_endpoint)
+function DeviceConfiguration.match_profile(driver, device)
+  local main_endpoint_id = switch_utils.find_default_endpoint(device)
+  local updated_profile = nil
 
-  -- We do not support the Light Switch device types because they require OnOff to be implemented as 'client', which requires us to support bindings.
-  -- However, this workaround profiles devices that claim to be Light Switches, but that break spec and implement OnOff as 'server'.
-  -- Note: since their device type isn't supported, these devices join as a matter-thing.
-  if num_switch_server_eps > 0 and switch_utils.detect_matter_thing(device) then
-    SwitchDeviceConfiguration.update_devices_with_onOff_server_clusters(device, main_endpoint)
-    profile_found = true
+  if #embedded_cluster_utils.get_endpoints(device, clusters.ValveConfigurationAndControl.ID) > 0 then
+    updated_profile = "water-valve"
+    if #embedded_cluster_utils.get_endpoints(device, clusters.ValveConfigurationAndControl.ID,
+      {feature_bitmap = clusters.ValveConfigurationAndControl.types.Feature.LEVEL}) > 0 then
+      updated_profile = updated_profile .. "-level"
+    end
   end
-  return profile_found
-end
 
-function DeviceConfiguration.match_profile(driver, device)
-  local main_endpoint = switch_utils.find_default_endpoint(device)
-  -- initialize the main device card with buttons if applicable, and create child devices as needed for multi-switch devices.
-  local profile_found = DeviceConfiguration.initialize_buttons_and_switches(driver, device, main_endpoint)
-  if device:get_field(fields.IS_PARENT_CHILD_DEVICE) then
-    device:set_find_child(switch_utils.find_child)
-  end
-  if profile_found then
-    return
+  local server_onoff_ep_ids = device:get_endpoints(clusters.OnOff.ID) -- get_endpoints defaults to return EPs supporting SERVER or BOTH
+  if #server_onoff_ep_ids > 0 then
+    SwitchDeviceConfiguration.create_child_devices(driver, device, server_onoff_ep_ids, main_endpoint_id)
   end
 
-  local fan_eps = device:get_endpoints(clusters.FanControl.ID)
-  local level_eps = device:get_endpoints(clusters.LevelControl.ID)
-  local energy_eps = embedded_cluster_utils.get_endpoints(device, clusters.ElectricalEnergyMeasurement.ID)
-  local power_eps = embedded_cluster_utils.get_endpoints(device, clusters.ElectricalPowerMeasurement.ID)
-  local valve_eps = embedded_cluster_utils.get_endpoints(device, clusters.ValveConfigurationAndControl.ID)
-  local profile_name = nil
-  local level_support = ""
-  if #level_eps > 0 then
-    level_support = "-level"
-  end
-  if #energy_eps > 0 and #power_eps > 0 then
-    profile_name = "plug" .. level_support .. "-power-energy-powerConsumption"
-  elseif #energy_eps > 0 then
-    profile_name = "plug" .. level_support .. "-energy-powerConsumption"
-  elseif #power_eps > 0 then
-    profile_name = "plug" .. level_support .. "-power"
-  elseif #valve_eps > 0 then
-    profile_name = "water-valve"
-    if #embedded_cluster_utils.get_endpoints(device, clusters.ValveConfigurationAndControl.ID,
-      {feature_bitmap = clusters.ValveConfigurationAndControl.types.Feature.LEVEL}) > 0 then
-      profile_name = profile_name .. "-level"
+  if switch_utils.tbl_contains(server_onoff_ep_ids, main_endpoint_id) then
+    updated_profile = SwitchDeviceConfiguration.assign_profile_for_onoff_ep(device, main_endpoint_id)
+    local generic_profile = function(s) return string.find(updated_profile or "", s, 1, true) end
+    if generic_profile("plug-binary") or generic_profile("plug-level") then
+      if switch_utils.check_switch_category_vendor_overrides(device) then
+        updated_profile = string.gsub(updated_profile, "plug", "switch")
+      else
+        local electrical_tags = ""
+        if #embedded_cluster_utils.get_endpoints(device, clusters.ElectricalPowerMeasurement.ID) > 0 then electrical_tags = electrical_tags .. "-power" end
+        if #embedded_cluster_utils.get_endpoints(device, clusters.ElectricalEnergyMeasurement.ID) > 0 then electrical_tags = electrical_tags .. "-energy-powerConsumption" end
+        if electrical_tags ~= "" then updated_profile = string.gsub(updated_profile, "-binary", "") .. electrical_tags end
+      end
+    elseif generic_profile("light-color-level") and #device:get_endpoints(clusters.FanControl.ID) > 0 then
+      updated_profile = "light-color-level-fan"
+    elseif generic_profile("light-level") and #device:get_endpoints(clusters.OccupancySensing.ID) > 0 then
+      updated_profile = "light-level-motion"
+    elseif generic_profile("light-level-colorTemperature") or generic_profile("light-color-level") then
+      -- ignore attempts to dynamically profile light-level-colorTemperature and light-color-level devices for now, since
+      -- these may lose fingerprinted Kelvin ranges when dynamically profiled.
+      return
     end
-  elseif #fan_eps > 0 then
-    profile_name = "light-color-level-fan"
   end
-  if profile_name then
-    device:try_update_metadata({ profile = profile_name })
+
+  -- initialize the main device card with buttons if applicable
+  local button_eps = device:get_endpoints(clusters.Switch.ID, {feature_bitmap=clusters.Switch.types.SwitchFeature.MOMENTARY_SWITCH})
+  if switch_utils.tbl_contains(fields.STATIC_BUTTON_PROFILE_SUPPORTED, #button_eps) then
+    ButtonDeviceConfiguration.update_button_profile(device, main_endpoint_id, #button_eps)
+    -- All button endpoints found will be added as additional components in the profile containing the main_endpoint.
+    ButtonDeviceConfiguration.update_button_component_map(device, main_endpoint_id, button_eps)
+    ButtonDeviceConfiguration.configure_buttons(device)
+    return
   end
+
+  device:try_update_metadata({ profile = updated_profile })
 end
 
 return {
   DeviceCfg = DeviceConfiguration,
   SwitchCfg = SwitchDeviceConfiguration,
   ButtonCfg = ButtonDeviceConfiguration
-}
+}