Refactor CHIPDevice class to Operational and Commissionee device proxy (

#10808)

* Refactor CHIPDevice class to Operational and Commissionee device proxy

* Remove use of storage and serializable in CommissioneeDeviceProxy

* address review comments

* fix build errors

* Fix build of ameba platform

* rebase and fixes

* fixes after rebase

* fix Linux build

examples/chip-tool/BUILD.gn

@@ -34,8 +34,10 @@ executable("chip-tool") {
  "commands/discover/DiscoverCommand.cpp",
  "commands/discover/DiscoverCommissionablesCommand.cpp",
  "commands/discover/DiscoverCommissionersCommand.cpp",
- "commands/pairing/CommissionedListCommand.cpp",
- "commands/pairing/CommissionedListCommand.h",
+
+ # TODO - enable CommissionedListCommand once DNS Cache is implemented
+ # "commands/pairing/CommissionedListCommand.cpp",
+ # "commands/pairing/CommissionedListCommand.h",
  "commands/pairing/PairingCommand.cpp",
  "commands/payload/AdditionalDataParseCommand.cpp",
  "commands/payload/SetupPayloadParseCommand.cpp",

examples/chip-tool/commands/clusters/ModelCommand.cpp

@@ -36,7 +36,7 @@ CHIP_ERROR ModelCommand::RunCommand()
  return err;
 }
 
-void ModelCommand::OnDeviceConnectedFn(void * context, chip::Controller::Device * device)
+void ModelCommand::OnDeviceConnectedFn(void * context, ChipDevice * device)
 {
  ModelCommand * command = reinterpret_cast<ModelCommand *>(context);
  VerifyOrReturn(command != nullptr,

examples/chip-tool/commands/clusters/ModelCommand.h

@@ -31,7 +31,7 @@
 class ModelCommand : public CHIPCommand
 {
 public:
- using ChipDevice = ::chip::Controller::Device;
+ using ChipDevice = ::chip::DeviceProxy;
 
  ModelCommand(const char * commandName) :
  CHIPCommand(commandName), mOnDeviceConnectedCallback(OnDeviceConnectedFn, this),
@@ -57,6 +57,6 @@ class ModelCommand : public CHIPCommand
  static void OnDeviceConnectedFn(void * context, ChipDevice * device);
  static void OnDeviceConnectionFailureFn(void * context, NodeId deviceId, CHIP_ERROR error);
 
- chip::Callback::Callback<chip::Controller::OnDeviceConnected> mOnDeviceConnectedCallback;
- chip::Callback::Callback<chip::Controller::OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
+ chip::Callback::Callback<chip::OnDeviceConnected> mOnDeviceConnectedCallback;
+ chip::Callback::Callback<chip::OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
 };

examples/chip-tool/commands/common/CHIPCommand.h

@@ -28,10 +28,9 @@ class PersistentStorage;
 class CHIPCommand : public Command
 {
 public:
- using ChipDevice = ::chip::Controller::Device;
+ using ChipDevice = ::chip::DeviceProxy;
  using ChipDeviceCommissioner = ::chip::Controller::DeviceCommissioner;
  using ChipDeviceController = ::chip::Controller::DeviceController;
- using ChipSerializedDevice = ::chip::Controller::SerializedDevice;
  using IPAddress = ::chip::Inet::IPAddress;
  using NodeId = ::chip::NodeId;
  using PeerAddress = ::chip::Transport::PeerAddress;

examples/chip-tool/commands/pairing/Commands.h

@@ -170,7 +170,8 @@ void registerCommandsPairing(Commands & commands)
  make_unique<PairOnNetworkDeviceType>(),
  make_unique<PairOnNetworkInstanceName>(),
  make_unique<OpenCommissioningWindow>(),
- make_unique<CommissionedListCommand>(),
+ // TODO - enable CommissionedListCommand once DNS Cache is implemented
+ // make_unique<CommissionedListCommand>(),
  };
 
  commands.Register(clusterName, clusterCommands);

examples/chip-tool/commands/pairing/PairingCommand.cpp

@@ -89,7 +89,7 @@ CHIP_ERROR PairingCommand::RunInternal(NodeId remoteId)
  return err;
 }
 
-void PairingCommand::OnDeviceConnectedFn(void * context, chip::Controller::Device * device)
+void PairingCommand::OnDeviceConnectedFn(void * context, chip::DeviceProxy * device)
 {
  PairingCommand * command = reinterpret_cast<PairingCommand *>(context);
  command->OpenCommissioningWindow();
@@ -248,7 +248,7 @@ CHIP_ERROR PairingCommand::SetupNetwork()
  break;
  case PairingNetworkType::WiFi:
  case PairingNetworkType::Thread:
- err = mController.GetDevice(mNodeId, &mDevice);
+ err = mController.GetDeviceBeingCommissioned(mNodeId, &mDevice);
  VerifyOrExit(err == CHIP_NO_ERROR, ChipLogError(chipTool, "Setup failure! No pairing for device: %" PRIu64, mNodeId));
 
  mCluster.Associate(mDevice, mEndpointId);

examples/chip-tool/commands/pairing/PairingCommand.h

@@ -210,15 +210,15 @@ class PairingCommand : public CHIPCommand,
  chip::Callback::Callback<NetworkCommissioningClusterAddWiFiNetworkResponseCallback> * mOnAddWiFiNetworkCallback = nullptr;
  chip::Callback::Callback<NetworkCommissioningClusterEnableNetworkResponseCallback> * mOnEnableNetworkCallback = nullptr;
  chip::Callback::Callback<DefaultFailureCallback> * mOnFailureCallback = nullptr;
- ChipDevice * mDevice;
+ chip::CommissioneeDeviceProxy * mDevice;
  chip::Controller::NetworkCommissioningCluster mCluster;
  chip::EndpointId mEndpointId = 0;
 
- static void OnDeviceConnectedFn(void * context, chip::Controller::Device * device);
+ static void OnDeviceConnectedFn(void * context, chip::DeviceProxy * device);
  static void OnDeviceConnectionFailureFn(void * context, NodeId deviceId, CHIP_ERROR error);
  static void OnOpenCommissioningWindowResponse(void * context, NodeId deviceId, CHIP_ERROR status, chip::SetupPayload payload);
 
- chip::Callback::Callback<chip::Controller::OnDeviceConnected> mOnDeviceConnectedCallback;
- chip::Callback::Callback<chip::Controller::OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
+ chip::Callback::Callback<chip::OnDeviceConnected> mOnDeviceConnectedCallback;
+ chip::Callback::Callback<chip::OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
  chip::Callback::Callback<chip::Controller::OnOpenCommissioningWindow> mOnOpenCommissioningWindowCallback;
 };

examples/chip-tool/commands/reporting/ReportingCommand.cpp

@@ -35,7 +35,7 @@ CHIP_ERROR ReportingCommand::RunCommand()
  return err;
 }
 
-void ReportingCommand::OnDeviceConnectedFn(void * context, chip::Controller::Device * device)
+void ReportingCommand::OnDeviceConnectedFn(void * context, chip::DeviceProxy * device)
 {
  ReportingCommand * command = reinterpret_cast<ReportingCommand *>(context);
  VerifyOrReturn(command != nullptr,

examples/chip-tool/commands/reporting/ReportingCommand.h

@@ -48,9 +48,9 @@ class ReportingCommand : public CHIPCommand
  NodeId mNodeId;
  uint8_t mEndPointId;
 
- static void OnDeviceConnectedFn(void * context, chip::Controller::Device * device);
+ static void OnDeviceConnectedFn(void * context, chip::DeviceProxy * device);
  static void OnDeviceConnectionFailureFn(void * context, NodeId deviceId, CHIP_ERROR error);
 
- chip::Callback::Callback<chip::Controller::OnDeviceConnected> mOnDeviceConnectedCallback;
- chip::Callback::Callback<chip::Controller::OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
+ chip::Callback::Callback<chip::OnDeviceConnected> mOnDeviceConnectedCallback;
+ chip::Callback::Callback<chip::OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
 };

examples/chip-tool/commands/tests/TestCommand.cpp

@@ -23,7 +23,7 @@ CHIP_ERROR TestCommand::RunCommand()
  return mController.GetConnectedDevice(mNodeId, &mOnDeviceConnectedCallback, &mOnDeviceConnectionFailureCallback);
 }
 
-void TestCommand::OnDeviceConnectedFn(void * context, chip::Controller::Device * device)
+void TestCommand::OnDeviceConnectedFn(void * context, chip::DeviceProxy * device)
 {
  ChipLogProgress(chipTool, " **** Test Setup: Device Connected\n");
  auto * command = static_cast<TestCommand *>(context);

examples/chip-tool/commands/tests/TestCommand.h

@@ -53,7 +53,7 @@ class TestCommand : public CHIPCommand
  ChipDevice * mDevice;
  chip::NodeId mNodeId;
 
- static void OnDeviceConnectedFn(void * context, chip::Controller::Device * device);
+ static void OnDeviceConnectedFn(void * context, chip::DeviceProxy * device);
  static void OnDeviceConnectionFailureFn(void * context, NodeId deviceId, CHIP_ERROR error);
  static void OnWaitForMsFn(chip::System::Layer * systemLayer, void * context);
 
@@ -230,8 +230,8 @@ class TestCommand : public CHIPCommand
  return false;
  }
 
- chip::Callback::Callback<chip::Controller::OnDeviceConnected> mOnDeviceConnectedCallback;
- chip::Callback::Callback<chip::Controller::OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
+ chip::Callback::Callback<chip::OnDeviceConnected> mOnDeviceConnectedCallback;
+ chip::Callback::Callback<chip::OnDeviceConnectionFailure> mOnDeviceConnectionFailureCallback;
 
  void Wait()
  {

examples/ota-requestor-app/linux/BUILD.gn

@@ -21,7 +21,6 @@ executable("chip-ota-requestor-app") {
  deps = [
  "${chip_root}/examples/ota-requestor-app/ota-requestor-common",
  "${chip_root}/examples/platform/linux:app-main",
- "${chip_root}/src/app/device",
  "${chip_root}/src/app/server",
  "${chip_root}/src/lib",
  ]

examples/ota-requestor-app/linux/main.cpp

@@ -18,8 +18,13 @@
 
 #include <app-common/zap-generated/callback.h>
 #include <app-common/zap-generated/cluster-objects.h>
-#include <app/device/OperationalDeviceProxy.h>
+#include <app/OperationalDeviceProxy.h>
 #include <app/server/Server.h>
+#include <app/util/util.h>
+#include <controller/CHIPDeviceControllerFactory.h>
+#include <controller/CommissioneeDeviceProxy.h>
+#include <controller/ExampleOperationalCredentialsIssuer.h>
+#include <credentials/DeviceAttestationCredsProvider.h>
 #include <credentials/examples/DeviceAttestationCredsExample.h>
 #include <lib/support/CHIPArgParser.hpp>
 #include <platform/CHIPDeviceLayer.h>
@@ -31,9 +36,13 @@
 
 using chip::ByteSpan;
 using chip::CharSpan;
+using chip::DeviceProxy;
 using chip::EndpointId;
 using chip::FabricIndex;
 using chip::NodeId;
+using chip::OnDeviceConnected;
+using chip::OnDeviceConnectionFailure;
+using chip::PeerId;
 using chip::Server;
 using chip::VendorId;
 using chip::bdx::TransferSession;
@@ -43,21 +52,19 @@ using chip::System::Layer;
 using chip::Transport::PeerAddress;
 using namespace chip::ArgParser;
 using namespace chip::Messaging;
-using namespace chip::app::device;
 using namespace chip::app::Clusters::OtaSoftwareUpdateProvider::Commands;
 
 void OnQueryImageResponse(void * context, const QueryImageResponse::DecodableType & response);
 void OnQueryImageFailure(void * context, EmberAfStatus status);
-void OnConnected(void * context, OperationalDeviceProxy * operationalDeviceProxy);
-void OnConnectionFailure(void * context, OperationalDeviceProxy * operationalDeviceProxy, CHIP_ERROR error);
+void OnConnected(void * context, chip::DeviceProxy * deviceProxy);
+void OnConnectionFailure(void * context, NodeId deviceId, CHIP_ERROR error);
 bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue);
 
 // TODO: would be nicer to encapsulate these globals and the callbacks in some sort of class
-OperationalDeviceProxy gOperationalDeviceProxy;
 ExchangeContext * exchangeCtx = nullptr;
 BdxDownloader bdxDownloader;
-Callback<OnOperationalDeviceConnected> mOnConnectedCallback(OnConnected, nullptr);
-Callback<OnOperationalDeviceConnectionFailure> mOnConnectionFailureCallback(OnConnectionFailure, nullptr);
+Callback<OnDeviceConnected> mOnConnectedCallback(OnConnected, nullptr);
+Callback<OnDeviceConnectionFailure> mOnConnectionFailureCallback(OnConnectionFailure, nullptr);
 
 constexpr uint16_t kOptionProviderNodeId = 'n';
 constexpr uint16_t kOptionProviderFabricIndex = 'f';
@@ -117,9 +124,11 @@ void OnQueryImageResponse(void * context, const QueryImageResponse::DecodableTyp
  initOptions.FileDesLength = static_cast<uint16_t>(strlen(testFileDes));
  initOptions.FileDesignator = reinterpret_cast<uint8_t *>(testFileDes);
 
+ chip::OperationalDeviceProxy * operationalDeviceProxy = Server::GetInstance().GetOperationalDeviceProxy();
+ if (operationalDeviceProxy != nullptr)
  {
- chip::Messaging::ExchangeManager * exchangeMgr = gOperationalDeviceProxy.GetDevice().GetExchangeManager();
- chip::Optional<chip::SessionHandle> session = gOperationalDeviceProxy.GetDevice().GetSecureSession();
+ chip::Messaging::ExchangeManager * exchangeMgr = operationalDeviceProxy->GetExchangeManager();
+ chip::Optional<chip::SessionHandle> session = operationalDeviceProxy->GetSecureSession();
  if (exchangeMgr != nullptr && session.HasValue())
  {
  exchangeCtx = exchangeMgr->NewContext(session.Value(), &bdxDownloader);
@@ -144,7 +153,7 @@ void OnQueryImageFailure(void * context, EmberAfStatus status)
  ChipLogDetail(SoftwareUpdate, "QueryImage failure response %" PRIu8, status);
 }
 
-void OnConnected(void * context, OperationalDeviceProxy * operationalDeviceProxy)
+void OnConnected(void * context, chip::DeviceProxy * deviceProxy)
 {
  CHIP_ERROR err = CHIP_NO_ERROR;
  chip::Controller::OtaSoftwareUpdateProviderCluster cluster;
@@ -161,7 +170,7 @@ void OnConnected(void * context, OperationalDeviceProxy * operationalDeviceProxy
  constexpr bool kExampleClientCanConsent = false;
  ByteSpan metadata;
 
- err = cluster.Associate(&(operationalDeviceProxy->GetDevice()), kOtaProviderEndpoint);
+ err = cluster.Associate(deviceProxy, kOtaProviderEndpoint);
  if (err != CHIP_NO_ERROR)
  {
  ChipLogError(SoftwareUpdate, "Associate() failed: %" CHIP_ERROR_FORMAT, err.Format());
@@ -183,9 +192,9 @@ void OnConnected(void * context, OperationalDeviceProxy * operationalDeviceProxy
  }
 }
 
-void OnConnectionFailure(void * context, OperationalDeviceProxy * operationalDeviceProxy, CHIP_ERROR error)
+void OnConnectionFailure(void * context, NodeId deviceId, CHIP_ERROR error)
 {
- ChipLogError(SoftwareUpdate, "failed to connect: %" CHIP_ERROR_FORMAT, error.Format());
+ ChipLogError(SoftwareUpdate, "failed to connect to 0x%" PRIX64 ": %" CHIP_ERROR_FORMAT, deviceId, error.Format());
 }
 
 bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue)
@@ -245,24 +254,32 @@ bool HandleOptions(const char * aProgram, OptionSet * aOptions, int aIdentifier,
 
 void SendQueryImageCommand(chip::NodeId peerNodeId = providerNodeId, chip::FabricIndex peerFabricIndex = providerFabricIndex)
 {
- // Explicitly calling UpdateAddress() should not be needed once OperationalDeviceProxy can resolve IP address from node ID and
- // fabric index
- IPAddress ipAddr;
- IPAddress::FromString(ipAddress, ipAddr);
- PeerAddress addr = PeerAddress::UDP(ipAddr, CHIP_PORT);
- gOperationalDeviceProxy.UpdateAddress(addr);
-
- Server * server = &(Server::GetInstance());
- OperationalDeviceProxyInitParams initParams = {
+ Server * server = &(Server::GetInstance());
+ chip::DeviceProxyInitParams initParams = {
  .sessionManager = &(server->GetSecureSessionManager()),
  .exchangeMgr = &(server->GetExchangeManager()),
  .idAllocator = &(server->GetSessionIDAllocator()),
- .fabricsTable = &(server->GetFabricTable()),
+ .fabricInfo = server->GetFabricTable().FindFabricWithIndex(providerFabricIndex),
+ // TODO: Determine where this should be instantiated
+ .imDelegate = chip::Platform::New<chip::Controller::DeviceControllerInteractionModelDelegate>(),
  };
 
+ chip::OperationalDeviceProxy * operationalDeviceProxy =
+ new chip::OperationalDeviceProxy(initParams, PeerId().SetNodeId(providerNodeId));
+ server->SetOperationalDeviceProxy(operationalDeviceProxy);
+
+ // Explicitly calling UpdateDeviceData() should not be needed once OperationalDeviceProxy can resolve IP address from node ID
+ // and fabric index
+ IPAddress ipAddr;
+ IPAddress::FromString(ipAddress, ipAddr);
+ PeerAddress addr = PeerAddress::UDP(ipAddr, CHIP_PORT);
+ uint32_t idleInterval;
+ uint32_t activeInterval;
+ operationalDeviceProxy->GetMRPIntervals(idleInterval, activeInterval);
+ operationalDeviceProxy->UpdateDeviceData(addr, idleInterval, activeInterval);
+
  CHIP_ERROR err = CHIP_NO_ERROR;
- gOperationalDeviceProxy.Init(peerNodeId, peerFabricIndex, initParams);
- err = gOperationalDeviceProxy.Connect(&mOnConnectedCallback, &mOnConnectionFailureCallback);
+ err = operationalDeviceProxy->Connect(&mOnConnectedCallback, &mOnConnectionFailureCallback);
  if (err != CHIP_NO_ERROR)
  {
  ChipLogError(SoftwareUpdate, "Cannot establish connection to peer device: %" CHIP_ERROR_FORMAT, err.Format());

examples/ota-requestor-app/ota-requestor-common/ExampleOTARequestor.cpp

@@ -18,19 +18,8 @@
 
 #include <ExampleOTARequestor.h>
 
-#include <app-common/zap-generated/enums.h>
-#include <app/util/af-enums.h>
 #include <app/util/util.h>
-#include <controller/CHIPDevice.h>
-#include <lib/core/NodeId.h>
-#include <lib/support/BufferReader.h>
-#include <lib/support/Span.h>
-#include <lib/support/logging/CHIPLogging.h>
 #include <platform/CHIPDeviceLayer.h>
-#include <system/SystemClock.h>
-#include <transport/FabricTable.h>
-
-using chip::FabricInfo;
 
 ExampleOTARequestor ExampleOTARequestor::sInstance;
 
@@ -53,9 +42,8 @@ ExampleOTARequestor::ExampleOTARequestor()
  mProviderFabricIndex = chip::kUndefinedFabricIndex;
 }
 
-void ExampleOTARequestor::Init(chip::Controller::ControllerDeviceInitParams connectParams, uint32_t startDelayMs)
+void ExampleOTARequestor::Init(uint32_t startDelayMs)
 {
- mConnectParams = connectParams;
  mOtaStartDelayMs = startDelayMs;
 }
 
@@ -128,14 +116,3 @@ void ExampleOTARequestor::StartDelayTimerHandler(chip::System::Layer * systemLay
  VerifyOrReturn(appState != nullptr);
  static_cast<ExampleOTARequestor *>(appState)->ConnectToProvider();
 }
-
-chip::FabricInfo * ExampleOTARequestor::GetProviderFabricInfo()
-{
- if (mConnectParams.fabricsTable == nullptr)
- {
- ChipLogError(SoftwareUpdate, "FabricTable is null!");
- return nullptr;
- }
-
- return mConnectParams.fabricsTable->FindFabricWithIndex(mProviderFabricIndex);
-}

examples/ota-requestor-app/ota-requestor-common/ExampleOTARequestor.h

@@ -19,11 +19,9 @@
 #pragma once
 
 #include <app-common/zap-generated/cluster-objects.h>
-#include <app/Command.h>
-#include <app/util/basic-types.h>
-#include <controller/CHIPDevice.h>
-#include <lib/core/NodeId.h>
-#include <lib/core/Optional.h>
+#include <app/CommandHandler.h>
+#include <app/util/af-enums.h>
+#include <transport/FabricTable.h>
 
 // An example implementation for how an application might handle receiving an AnnounceOTAProvider command. In this case, the
 // AnnounceOTAProvider command will be used as a trigger to send a QueryImage command and begin the OTA process. This class also
@@ -33,7 +31,7 @@ class ExampleOTARequestor
 public:
  static ExampleOTARequestor & GetInstance() { return sInstance; }
 
- void Init(chip::Controller::ControllerDeviceInitParams connectParams, uint32_t startDelayMs);
+ void Init(uint32_t startDelayMs);
 
  EmberAfStatus HandleAnnounceOTAProvider(
  chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath,
@@ -47,12 +45,9 @@ class ExampleOTARequestor
 
  static void StartDelayTimerHandler(chip::System::Layer * systemLayer, void * appState);
  void ConnectToProvider();
- chip::FabricInfo * GetProviderFabricInfo();
 
  static ExampleOTARequestor sInstance;
 
- chip::Controller::Device mProviderDevice;
- chip::Controller::ControllerDeviceInitParams mConnectParams;
  chip::NodeId mProviderNodeId;
  chip::FabricIndex mProviderFabricIndex;
  uint32_t mOtaStartDelayMs;