Implement Occupancy Sensor Device in All-Devices App & Refactor DeviceFactory (project-chip#42404)

* Add occupancy sensor to all devices app

* fix device factory; log errors

* Fix TC_OCC test run

* Add all-devices-app occupancy sensor tests to CI

* code review suggestions

* restyle

* Apply review suggestions

* Address Andrei's review suggestions and remove unnecessary public_configs

* restyle

* remove redundant comment

* move timer start/stop to register/unregister

* make constant seconds16

* simplify toggling-occupancy-sensor target name

Author: soares-sergio

examples/all-devices-app/all-devices-common/devices/boolean-state-sensor/BUILD.gn

@@ -29,9 +29,4 @@ source_set("boolean-state-sensor") {
     "${chip_root}/src/lib/core:error",
     "${chip_root}/src/lib/support",
   ]
-
-  public_configs = [
-    "${chip_root}/examples/all-devices-app/all-devices-common/devices/:includes",
-    "${chip_root}/src:includes",
-  ]
 }

examples/all-devices-app/all-devices-common/devices/device-factory/BUILD.gn

@@ -20,12 +20,7 @@ source_set("device-factory") {
 
   public_deps = [
     "${chip_root}/examples/all-devices-app/all-devices-common/devices/boolean-state-sensor",
-    "${chip_root}/src/lib/core:error",
-    "${chip_root}/zzz_generated/app-common/devices/",
-  ]
-
-  public_configs = [
-    "${chip_root}/examples/all-devices-app/all-devices-common/devices/:includes",
-    "${chip_root}/src:includes",
+    "${chip_root}/examples/all-devices-app/all-devices-common/devices/occupancy-sensor/impl:toggling",
+    "${chip_root}/src/lib/support",
   ]
 }

examples/all-devices-app/all-devices-common/devices/device-factory/DeviceFactory.h

@@ -19,6 +19,7 @@
 
 #include <devices/Types.h>
 #include <devices/boolean-state-sensor/BooleanStateSensorDevice.h>
+#include <devices/occupancy-sensor/impl/TogglingOccupancySensorDevice.h>
 #include <functional>
 #include <lib/core/CHIPError.h>
 #include <map>
@@ -77,6 +78,7 @@ class DeviceFactory
             return std::make_unique<BooleanStateSensorDevice>(
                 &timer, Span<const DataModel::DeviceTypeEntry>(&Device::Type::kWaterLeakDetector, 1));
         };
+        mRegistry["occupancy-sensor"] = []() { return std::make_unique<TogglingOccupancySensorDevice>(); };
     }
 };
 

examples/all-devices-app/all-devices-common/devices/interface/BUILD.gn

@@ -47,9 +47,4 @@ source_set("single-endpoint-device") {
     "${chip_root}/src/lib/core:error",
     "${chip_root}/src/lib/support",
   ]
-
-  public_configs = [
-    "${chip_root}/examples/all-devices-app/all-devices-common/devices/:includes",
-    "${chip_root}/src:includes",
-  ]
 }

examples/all-devices-app/all-devices-common/devices/occupancy-sensor/BUILD.gn

@@ -0,0 +1,33 @@
+# Copyright (c) 2025 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.
+
+import("//build_overrides/build.gni")
+import("//build_overrides/chip.gni")
+
+source_set("occupancy-sensor") {
+  sources = [
+    "OccupancySensorDevice.cpp",
+    "OccupancySensorDevice.h",
+  ]
+
+  public_deps = [
+    "${chip_root}/examples/all-devices-app/all-devices-common/devices/interface:single-endpoint-device",
+    "${chip_root}/src/app/clusters/identify-server",
+    "${chip_root}/src/app/clusters/occupancy-sensor-server",
+    "${chip_root}/src/data-model-providers/codedriven",
+    "${chip_root}/src/lib/core:error",
+    "${chip_root}/src/lib/support",
+    "${chip_root}/zzz_generated/app-common/devices/",
+  ]
+}

examples/all-devices-app/all-devices-common/devices/occupancy-sensor/OccupancySensorDevice.cpp

@@ -0,0 +1,65 @@
+/*
+ *
+ *    Copyright (c) 2025 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.
+ */
+#include <devices/Types.h>
+#include <devices/occupancy-sensor/OccupancySensorDevice.h>
+#include <lib/support/logging/CHIPLogging.h>
+
+using namespace chip::app::Clusters;
+
+namespace chip {
+namespace app {
+
+OccupancySensorDevice::OccupancySensorDevice(OccupancySensingConfig config, TimerDelegate & timerDelegate) :
+    SingleEndpointDevice(Span<const DataModel::DeviceTypeEntry>(&Device::Type::kOccupancySensor, 1)), mConfig(config),
+    mTimerDelegate(timerDelegate)
+{}
+
+CHIP_ERROR OccupancySensorDevice::Register(chip::EndpointId endpoint, CodeDrivenDataModelProvider & provider, EndpointId parentId)
+{
+    ReturnErrorOnFailure(SingleEndpointRegistration(endpoint, provider, parentId));
+
+    // Create the identify cluster.
+    mIdentifyCluster.Create(IdentifyCluster::Config(endpoint, mTimerDelegate));
+    ReturnErrorOnFailure(provider.AddCluster(mIdentifyCluster.Registration()));
+
+    // Update the config with the actual endpoint ID
+    mConfig.mEndpointId = endpoint;
+
+    // Create the occupancy sensing cluster
+    mOccupancySensingCluster.Create(mConfig);
+    ReturnErrorOnFailure(provider.AddCluster(mOccupancySensingCluster.Registration()));
+
+    return provider.AddEndpoint(mEndpointRegistration);
+}
+
+void OccupancySensorDevice::UnRegister(CodeDrivenDataModelProvider & provider)
+{
+    SingleEndpointUnregistration(provider);
+    if (mOccupancySensingCluster.IsConstructed())
+    {
+        LogErrorOnFailure(provider.RemoveCluster(&mOccupancySensingCluster.Cluster()));
+        mOccupancySensingCluster.Destroy();
+    }
+    if (mIdentifyCluster.IsConstructed())
+    {
+        LogErrorOnFailure(provider.RemoveCluster(&mIdentifyCluster.Cluster()));
+        mIdentifyCluster.Destroy();
+    }
+}
+
+} // namespace app
+} // namespace chip

examples/all-devices-app/all-devices-common/devices/occupancy-sensor/OccupancySensorDevice.h

@@ -0,0 +1,49 @@
+/*
+ *
+ *    Copyright (c) 2025 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.
+ */
+#pragma once
+
+#include <app/clusters/identify-server/IdentifyCluster.h>
+#include <app/clusters/occupancy-sensor-server/OccupancySensingCluster.h>
+#include <devices/interface/SingleEndpointDevice.h>
+#include <lib/support/TimerDelegate.h>
+
+namespace chip {
+namespace app {
+
+class OccupancySensorDevice : public SingleEndpointDevice
+{
+public:
+    using OccupancySensingConfig = Clusters::OccupancySensingCluster::Config;
+
+    OccupancySensorDevice(OccupancySensingConfig config, TimerDelegate & timerDelegate);
+    ~OccupancySensorDevice() override = default;
+
+    CHIP_ERROR Register(chip::EndpointId endpoint, CodeDrivenDataModelProvider & provider,
+                        EndpointId parentId = kInvalidEndpointId) override;
+    void UnRegister(CodeDrivenDataModelProvider & provider) override;
+
+    Clusters::OccupancySensingCluster & OccupancySensingCluster() { return mOccupancySensingCluster.Cluster(); }
+
+protected:
+    OccupancySensingConfig mConfig;
+    TimerDelegate & mTimerDelegate;
+    LazyRegisteredServerCluster<Clusters::IdentifyCluster> mIdentifyCluster;
+    LazyRegisteredServerCluster<Clusters::OccupancySensingCluster> mOccupancySensingCluster;
+};
+
+} // namespace app
+} // namespace chip

examples/all-devices-app/all-devices-common/devices/occupancy-sensor/impl/BUILD.gn

@@ -0,0 +1,29 @@
+# Copyright (c) 2025 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.
+
+import("//build_overrides/build.gni")
+import("//build_overrides/chip.gni")
+
+source_set("toggling") {
+  sources = [
+    "TogglingOccupancySensorDevice.cpp",
+    "TogglingOccupancySensorDevice.h",
+  ]
+
+  public_deps = [
+    "${chip_root}/examples/all-devices-app/all-devices-common/devices/occupancy-sensor",
+    "${chip_root}/src/lib/support",
+    "${chip_root}/src/platform",
+  ]
+}

examples/all-devices-app/all-devices-common/devices/occupancy-sensor/impl/TogglingOccupancySensorDevice.cpp

@@ -0,0 +1,89 @@
+/*
+ *
+ *    Copyright (c) 2025 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.
+ */
+#include "TogglingOccupancySensorDevice.h"
+#include <lib/support/CodeUtils.h>
+#include <lib/support/logging/CHIPLogging.h>
+#include <platform/CHIPDeviceLayer.h>
+
+using namespace chip::app::Clusters;
+
+namespace chip {
+namespace app {
+
+namespace {
+constexpr System::Clock::Seconds16 kOccupancyStateChangeIntervalSec = System::Clock::Seconds16(30);
+} // namespace
+
+TogglingOccupancySensorDevice::TogglingOccupancySensorDevice() :
+    OccupancySensorDevice(
+        // Initialize with kInvalidEndpointId. The actual endpoint ID will be set
+        // when Register() is called by the application with a valid endpoint ID.
+        OccupancySensingCluster::Config(kInvalidEndpointId)
+            .WithFeatures(OccupancySensing::Feature::kPassiveInfrared)
+            .WithHoldTime(10,
+                          {
+                              .holdTimeMin     = 1,
+                              .holdTimeMax     = 300,
+                              .holdTimeDefault = 10,
+                          },
+                          mTimerDelegate)
+            .WithDelegate(this),
+        mTimerDelegate)
+{}
+
+TogglingOccupancySensorDevice::~TogglingOccupancySensorDevice()
+{
+    mTimerDelegate.CancelTimer(this);
+}
+
+CHIP_ERROR TogglingOccupancySensorDevice::Register(EndpointId endpoint, CodeDrivenDataModelProvider & provider, EndpointId parentId)
+{
+    ReturnErrorOnFailure(OccupancySensorDevice::Register(endpoint, provider, parentId));
+    // Kick off the timer loop to flip occupancy every few seconds
+    return mTimerDelegate.StartTimer(this, kOccupancyStateChangeIntervalSec);
+}
+
+void TogglingOccupancySensorDevice::UnRegister(CodeDrivenDataModelProvider & provider)
+{
+    mTimerDelegate.CancelTimer(this);
+    OccupancySensorDevice::UnRegister(provider);
+}
+
+void TogglingOccupancySensorDevice::OnOccupancyChanged(bool occupied)
+{
+    ChipLogProgress(AppServer, "TogglingOccupancySensorDevice::OnOccupancyChanged: %s", occupied ? "Occupied" : "Unoccupied");
+}
+
+void TogglingOccupancySensorDevice::OnHoldTimeChanged(uint16_t holdTime)
+{
+    ChipLogProgress(AppServer, "TogglingOccupancySensorDevice::OnHoldTimeChanged: %u", holdTime);
+}
+
+void TogglingOccupancySensorDevice::TimerFired()
+{
+    // Flips the occupancy state every kOccupancyStateChangeIntervalSec seconds
+
+    bool nextState = !mOccupancySensingCluster.Cluster().IsOccupied();
+
+    ChipLogProgress(AppServer, "TogglingOccupancySensorDevice: Toggling occupancy to %s", nextState ? "Occupied" : "Unoccupied");
+    mOccupancySensingCluster.Cluster().SetOccupancy(nextState);
+
+    VerifyOrDie(mTimerDelegate.StartTimer(this, kOccupancyStateChangeIntervalSec) == CHIP_NO_ERROR);
+}
+
+} // namespace app
+} // namespace chip

examples/all-devices-app/all-devices-common/devices/occupancy-sensor/impl/TogglingOccupancySensorDevice.h

@@ -0,0 +1,56 @@
+/*
+ *
+ *    Copyright (c) 2025 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.
+ */
+#pragma once
+
+#include <app/clusters/occupancy-sensor-server/OccupancySensingCluster.h>
+#include <data-model-providers/codedriven/CodeDrivenDataModelProvider.h>
+#include <devices/occupancy-sensor/OccupancySensorDevice.h>
+#include <platform/DefaultTimerDelegate.h>
+
+namespace chip {
+namespace app {
+
+/**
+ * @brief An implementation of an Occupancy Sensor Device.
+ *
+ * This class serves as a simple example of an occupancy sensor. It emulates
+ * occupancy state changes by toggling between "Occupied" and "Unoccupied"
+ * states every 30 seconds using a timer.
+ */
+class TogglingOccupancySensorDevice : public OccupancySensorDevice, public Clusters::OccupancySensingDelegate, public TimerContext
+{
+public:
+    TogglingOccupancySensorDevice();
+    ~TogglingOccupancySensorDevice() override;
+
+    CHIP_ERROR Register(EndpointId endpoint, CodeDrivenDataModelProvider & provider,
+                        EndpointId parentId = kInvalidEndpointId) override;
+    void UnRegister(CodeDrivenDataModelProvider & provider) override;
+
+    // OccupancySensingDelegate
+    void OnOccupancyChanged(bool occupied) override;
+    void OnHoldTimeChanged(uint16_t holdTime) override;
+
+    // TimerContext
+    void TimerFired() override;
+
+private:
+    DefaultTimerDelegate mTimerDelegate;
+};
+
+} // namespace app
+} // namespace chip