[icd] Add steps for checking ICD during commissioning

src/controller/AutoCommissioner.cpp

@@ -392,6 +392,13 @@ CommissioningStage AutoCommissioner::GetNextCommissioningStageInternal(Commissio
         }
         return CommissioningStage::kFindOperational;
     case CommissioningStage::kFindOperational:
+        if (mParams.GetICDRegistrationStrategy() != ICDRegistrationStrategy::kIgnore)
+        {
+            return CommissioningStage::kICDIdentification;
+        }
+        return CommissioningStage::kSendComplete;
+    case CommissioningStage::kICDIdentification:
+        // TODO(#29385): Register to the ICD.
         return CommissioningStage::kSendComplete;
     case CommissioningStage::kSendComplete:
         return CommissioningStage::kCleanup;
@@ -705,6 +712,15 @@ CHIP_ERROR AutoCommissioner::CommissioningStepFinished(CHIP_ERROR err, Commissio
         case CommissioningStage::kFindOperational:
             mOperationalDeviceProxy = report.Get<OperationalNodeFoundData>().operationalProxy;
             break;
+        case CommissioningStage::kICDIdentification: {
+            IcdInfo icdInfo = report.Get<IcdInfo>();
+            if (icdInfo.isIcd)
+            {
+                mNeedIcdRegistraion = true;
+                ChipLogDetail(Controller, "AutoCommissioner: Device is ICD");
+            }
+            break;
+        }
         case CommissioningStage::kCleanup:
             ReleasePAI();
             ReleaseDAC();

src/controller/AutoCommissioner.h

@@ -106,6 +106,8 @@ class AutoCommissioner : public CommissioningDelegate
     ReadCommissioningInfo mDeviceCommissioningInfo;
     bool mNeedsDST = false;
 
+    bool mNeedIcdRegistraion = false;
+
     // TODO: Why were the nonces statically allocated, but the certs dynamically allocated?
     uint8_t * mDAC   = nullptr;
     uint16_t mDACLen = 0;

src/controller/CHIPDeviceController.cpp

@@ -1880,6 +1880,9 @@ void DeviceCommissioner::OnDone(app::ReadClient *)
     case CommissioningStage::kCheckForMatchingFabric:
         ParseFabrics();
         break;
+    case CommissioningStage::kICDIdentification:
+        ParseICDInfo();
+        break;
     default:
         // We're not trying to read anything here, just exit
         break;
@@ -2175,6 +2178,45 @@ void DeviceCommissioner::ParseFabrics()
     CommissioningStageComplete(return_err, report);
 }
 
+void DeviceCommissioner::ParseICDInfo()
+{
+    CHIP_ERROR err;
+    IcdInfo info;
+    IcdManagement::Attributes::FeatureMap::TypeInfo::DecodableType featureMap;
+
+    // TODO(#29382): We probably want to read "ActiveMode" attribute (to be implemented) for ICD.
+    err = mAttributeCache->Get<IcdManagement::Attributes::FeatureMap::TypeInfo>(kRootEndpointId, featureMap);
+    if (err == CHIP_NO_ERROR)
+    {
+        info.isIcd                  = true;
+        info.checkInProtocolSupport = !!(featureMap & to_underlying(IcdManagement::Feature::kCheckInProtocolSupport));
+    }
+    else if (err == CHIP_ERROR_IM_STATUS_CODE_RECEIVED)
+    {
+        app::StatusIB statusIB;
+        err = mAttributeCache->GetStatus(
+            app::ConcreteAttributePath(kRootEndpointId, IcdManagement::Id, IcdManagement::Attributes::FeatureMap::Id), statusIB);
+        if (err == CHIP_NO_ERROR)
+        {
+            if (statusIB.mStatus == Protocols::InteractionModel::Status::UnsupportedCluster)
+            {
+                info.isIcd = false;
+            }
+            else
+            {
+                err = statusIB.ToChipError();
+            }
+        }
+    }
+
+    CommissioningDelegate::CommissioningReport report;
+    if (err == CHIP_NO_ERROR)
+    {
+        report.Set<IcdInfo>(info);
+    }
+    CommissioningStageComplete(err, report);
+}
+
 void DeviceCommissioner::OnArmFailSafe(void * context,
                                        const GeneralCommissioning::Commands::ArmFailSafeResponse::DecodableType & data)
 {
@@ -2782,6 +2824,14 @@ void DeviceCommissioner::PerformCommissioningStep(DeviceProxy * proxy, Commissio
         );
     }
     break;
+    case CommissioningStage::kICDIdentification: {
+        app::AttributePathParams readPaths[1];
+        // TODO(#29382): We probably want to read "ActiveMode" attribute (to be implemented) for ICD.
+        readPaths[0] = app::AttributePathParams(endpoint, app::Clusters::IcdManagement::Id,
+                                                app::Clusters::IcdManagement::Attributes::FeatureMap::Id);
+        SendCommissioningReadRequest(proxy, timeout, readPaths, 1);
+    }
+    break;
     case CommissioningStage::kSendComplete: {
         GeneralCommissioning::Commands::CommissioningComplete::Type request;
         SendCommand(proxy, request, OnCommissioningCompleteResponse, OnBasicFailure, endpoint, timeout);

src/controller/CHIPDeviceController.h

@@ -938,6 +938,7 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController,
     void ParseFabrics();
     // Called by ParseCommissioningInfo
     void ParseTimeSyncInfo(ReadCommissioningInfo & info);
+    void ParseICDInfo();
 #endif // CHIP_CONFIG_ENABLE_READ_CLIENT
 
     static CHIP_ERROR

src/controller/CommissioningDelegate.cpp

@@ -137,6 +137,10 @@ const char * StageToString(CommissioningStage stage)
         return "FindOperational";
         break;
 
+    case kICDIdentification:
+        return "ICDIdentification";
+        break;
+
     case kSendComplete:
         return "SendComplete";
         break;

src/controller/CommissioningDelegate.h

@@ -59,8 +59,12 @@ enum CommissioningStage : uint8_t
     kWiFiNetworkEnable,          ///< Send ConnectNetwork (0x31:6) command to the device for the WiFi network
     kThreadNetworkEnable,        ///< Send ConnectNetwork (0x31:6) command to the device for the Thread network
     kFindOperational,            ///< Perform operational discovery and establish a CASE session with the device
-    kSendComplete,               ///< Send CommissioningComplete (0x30:4) command to the device
-    kCleanup,                    ///< Call delegates with status, free memory, clear timers and state
+    /// Optional steps for ICD
+    kICDIdentification, ///< Check whether the device is an ICD
+    /// TODO(#29384): Finish ICD registration implementation in commissioner
+    /// End of optional steps for ICD
+    kSendComplete, ///< Send CommissioningComplete (0x30:4) command to the device
+    kCleanup,      ///< Call delegates with status, free memory, clear timers and state
     /// Send ScanNetworks (0x31:0) command to the device.
     /// ScanNetworks can happen anytime after kArmFailsafe.
     /// However, the cirque tests fail if it is earlier in the list
@@ -71,6 +75,13 @@ enum CommissioningStage : uint8_t
     kNeedsNetworkCreds,
 };
 
+enum ICDRegistrationStrategy
+{
+    kIgnore,         ///< Do not check whether the device is an ICD during commissioning
+    kBeforeComplete, ///< Do commissioner self-registration or external controller registration,
+                     ///< Controller should provide a ICDKey manager for generating symmetric key
+};
+
 const char * StageToString(CommissioningStage stage);
 
 struct WiFiCredentials
@@ -493,6 +504,13 @@ class CommissioningParameters
         return *this;
     }
 
+    ICDRegistrationStrategy GetICDRegistrationStrategy() const { return mICDRegistrationStrategy; }
+    CommissioningParameters & SetICDRegistrationStrategy(ICDRegistrationStrategy icdRegistrationStrategy)
+    {
+        mICDRegistrationStrategy = icdRegistrationStrategy;
+        return *this;
+    }
+
     // Clear all members that depend on some sort of external buffer.  Can be
     // used to make sure that we are not holding any dangling pointers.
     void ClearExternalBufferDependentValues()
@@ -550,7 +568,8 @@ class CommissioningParameters
     Optional<bool> mAttemptWiFiNetworkScan;
     Optional<bool> mAttemptThreadNetworkScan; // This automatically gets set to false when a ThreadOperationalDataset is set
     Optional<bool> mSkipCommissioningComplete;
-    bool mCheckForMatchingFabric = false;
+    ICDRegistrationStrategy mICDRegistrationStrategy = ICDRegistrationStrategy::kBeforeComplete;
+    bool mCheckForMatchingFabric                     = false;
 };
 
 struct RequestedCertificate
@@ -632,6 +651,13 @@ struct ReadCommissioningInfo
     uint8_t maxTimeZoneSize        = 1;
     uint8_t maxDSTSize             = 1;
 };
+
+struct IcdInfo
+{
+    bool isIcd                  = false;
+    bool checkInProtocolSupport = false;
+};
+
 struct MatchingFabricInfo
 {
     NodeId nodeId = kUndefinedNodeId;
@@ -694,7 +720,7 @@ class CommissioningDelegate
      */
     struct CommissioningReport : Variant<RequestedCertificate, AttestationResponse, CSRResponse, NocChain, OperationalNodeFoundData,
                                          ReadCommissioningInfo, AttestationErrorInfo, CommissioningErrorInfo,
-                                         NetworkCommissioningStatusInfo, MatchingFabricInfo, TimeZoneResponseInfo>
+                                         NetworkCommissioningStatusInfo, MatchingFabricInfo, TimeZoneResponseInfo, IcdInfo>
     {
         CommissioningReport() : stageCompleted(CommissioningStage::kError) {}
         CommissioningStage stageCompleted;