Create new ICD Manager in fabric-admin to service KeepActive Command

examples/fabric-admin/BUILD.gn

@@ -69,6 +69,8 @@ static_library("fabric-admin-utils") {
     "commands/common/Commands.h",
     "commands/common/CredentialIssuerCommands.h",
     "commands/common/HexConversion.h",
+    "commands/common/IcdManager.cpp",
+    "commands/common/IcdManager.h",
     "commands/common/RemoteDataModelLogger.cpp",
     "commands/common/RemoteDataModelLogger.h",
     "commands/fabric-sync/FabricSyncCommand.cpp",

examples/fabric-admin/commands/common/CHIPCommand.cpp

@@ -18,6 +18,7 @@
 
 #include "CHIPCommand.h"
 
+#include "IcdManager.h"
 #include <controller/CHIPDeviceControllerFactory.h>
 #include <credentials/attestation_verifier/FileAttestationTrustStore.h>
 #include <lib/core/CHIPConfig.h>
@@ -52,7 +53,6 @@ chip::Credentials::GroupDataProviderImpl CHIPCommand::sGroupDataProvider{ kMaxGr
 // All fabrics share the same ICD client storage.
 chip::app::DefaultICDClientStorage CHIPCommand::sICDClientStorage;
 chip::Crypto::RawKeySessionKeystore CHIPCommand::sSessionKeystore;
-chip::app::DefaultCheckInDelegate CHIPCommand::sCheckInDelegate;
 chip::app::CheckInHandler CHIPCommand::sCheckInHandler;
 
 namespace {
@@ -148,9 +148,9 @@ CHIP_ERROR CHIPCommand::MaybeSetUpStack()
 
     auto engine = chip::app::InteractionModelEngine::GetInstance();
     VerifyOrReturnError(engine != nullptr, CHIP_ERROR_INCORRECT_STATE);
-    ReturnLogErrorOnFailure(sCheckInDelegate.Init(&sICDClientStorage, engine));
+    ReturnLogErrorOnFailure(IcdManager::Instance().Init(&sICDClientStorage, engine));
     ReturnLogErrorOnFailure(sCheckInHandler.Init(DeviceControllerFactory::GetInstance().GetSystemState()->ExchangeMgr(),
-                                                 &sICDClientStorage, &sCheckInDelegate, engine));
+                                                 &sICDClientStorage, &IcdManager::Instance(), engine));
 
     CommissionerIdentity nullIdentity{ kIdentityNull, chip::kUndefinedNodeId };
     ReturnLogErrorOnFailure(InitializeCommissioner(nullIdentity, kIdentityNullFabricId));

examples/fabric-admin/commands/common/CHIPCommand.h

@@ -166,7 +166,6 @@ class CHIPCommand : public Command
 
     static chip::Credentials::GroupDataProviderImpl sGroupDataProvider;
     static chip::app::DefaultICDClientStorage sICDClientStorage;
-    static chip::app::DefaultCheckInDelegate sCheckInDelegate;
     static chip::app::CheckInHandler sCheckInHandler;
     CredentialIssuerCommands * mCredIssuerCmds;
 

examples/fabric-admin/commands/common/IcdManager.cpp

@@ -0,0 +1,44 @@
+/*
+ *   Copyright (c) 2024 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   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 "IcdManager.h"
+
+IcdManager IcdManager::sInstance;
+
+IcdManager & IcdManager::Instance()
+{
+    return sInstance;
+}
+
+void IcdManager::OnCheckInComplete(const chip::app::ICDClientInfo & clientInfo)
+{
+    DefaultCheckInDelegate::OnCheckInComplete(clientInfo);
+    if (mDelegate)
+    {
+        mDelegate->OnCheckInCompleted(clientInfo);
+    }
+}
+
+void IcdManager::SetDelegate(Delegate * delegate)
+{
+    // There is an assumption that there is only ever one delegate set and it's
+    // lifetime is identical to IcdManager.
+    VerifyOrDie(delegate);
+    VerifyOrDie(!mDelegate);
+    mDelegate = delegate;
+}

examples/fabric-admin/commands/common/IcdManager.h

@@ -0,0 +1,45 @@
+/*
+ *   Copyright (c) 2024 Project CHIP Authors
+ *   All rights reserved.
+ *
+ *   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 <map>
+
+#include <app/icd/client/DefaultCheckInDelegate.h>
+
+class IcdManager : public chip::app::DefaultCheckInDelegate
+{
+public:
+    class Delegate
+    {
+    public:
+        virtual ~Delegate()                                                          = default;
+        virtual void OnCheckInCompleted(const chip::app::ICDClientInfo & clientInfo) = 0;
+    };
+
+    static IcdManager & Instance();
+    void OnCheckInComplete(const chip::app::ICDClientInfo & clientInfo) override;
+
+    // There is an assumption delegate assigned only happens once and that it lives
+    // for the entirety of the lifetime of fabric admin.
+    void SetDelegate(Delegate * delegate);
+
+private:
+    static IcdManager sInstance;
+    Delegate * mDelegate = nullptr;
+};

examples/fabric-admin/rpc/RpcServer.cpp

@@ -20,10 +20,14 @@
 #include "pw_rpc_system_server/rpc_server.h"
 #include "pw_rpc_system_server/socket.h"
 
+#include <map>
+#include <thread>
+
+#include "RpcClient.h"
+#include <commands/common/IcdManager.h>
 #include <commands/fabric-sync/FabricSyncCommand.h>
 #include <commands/interactive/InteractiveCommands.h>
 #include <system/SystemClock.h>
-#include <thread>
 
 #if defined(PW_RPC_FABRIC_ADMIN_SERVICE) && PW_RPC_FABRIC_ADMIN_SERVICE
 #include "pigweed/rpc_services/FabricAdmin.h"
@@ -34,9 +38,24 @@ using namespace ::chip;
 namespace {
 
 #if defined(PW_RPC_FABRIC_ADMIN_SERVICE) && PW_RPC_FABRIC_ADMIN_SERVICE
-class FabricAdmin final : public rpc::FabricAdmin
+class FabricAdmin final : public rpc::FabricAdmin, public IcdManager::Delegate
 {
 public:
+    void OnCheckInCompleted(const chip::app::ICDClientInfo & clientInfo) override
+    {
+        chip::NodeId nodeId = clientInfo.peer_node.GetNodeId();
+        auto it             = mPendingKeepActive.find(nodeId);
+        VerifyOrReturn(it != mPendingKeepActive.end());
+        // TODO(#33221): We also need a mechanism here to drop KeepActive
+        // request if they were recieved over 60 mins ago.
+        uint32_t stayActiveDurationMs = it->second;
+        mPendingKeepActive.erase(nodeId);
+
+        // TODO(#33221): Send the StayActiveRequest command for realy to the device. Right now we
+        // pretending that we got a StayActiveResponse.
+        ActiveChanged(nodeId, stayActiveDurationMs);
+    }
+
     pw::Status OpenCommissioningWindow(const chip_rpc_DeviceCommissioningWindowInfo & request,
                                        chip_rpc_OperationStatus & response) override
     {
@@ -69,14 +88,18 @@ class FabricAdmin final : public rpc::FabricAdmin
     pw::Status KeepActive(const chip_rpc_KeepActiveParameters & request, pw_protobuf_Empty & response) override
     {
         ChipLogProgress(NotSpecified, "Received KeepActive request: 0x%lx, %u", request.node_id, request.stay_active_duration_ms);
-        // TODO(#33221): When we get this command hopefully we are already registered with an ICD device to be
-        // notified when it wakes up. We will need to add in hooks there to make sure we send the StayActiveRequest
-        // Important thing to note:
-        //  * If we get this call multiple times before we get a wakeup from ICD, we only send out one StayActiveRequest command
-        //  * After 60 mins from last exipry we no longer will send out a StayActiveRequest.
+        // TODO(#33221):
+        //   1. Is there an imporvement to check if the device is already active?
+        //   2. We should really be using ScopedNode, but that requires larger fixes
 
+        // We are okay with overriding an existing entry
+        // TODO we should likely make sure we are called from the Matter event loop.
+        mPendingKeepActive[request.node_id] = request.stay_active_duration_ms;
         return pw::OkStatus();
     }
+
+private:
+    std::map<chip::NodeId, uint32_t> mPendingKeepActive;
 };
 
 FabricAdmin fabric_admin_service;
@@ -86,6 +109,7 @@ void RegisterServices(pw::rpc::Server & server)
 {
 #if defined(PW_RPC_FABRIC_ADMIN_SERVICE) && PW_RPC_FABRIC_ADMIN_SERVICE
     server.RegisterService(fabric_admin_service);
+    IcdManager::Instance().SetDelegate(&fabric_admin_service);
 #endif
 }