Restyle Refactor CHIPDevice class to Operational and Commissionee device proxy

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/PairingCommand.cpp

@@ -92,7 +92,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();
@@ -153,8 +153,7 @@ CHIP_ERROR PairingCommand::PairWithMdns(NodeId remoteId)
 
 CHIP_ERROR PairingCommand::PairWithoutSecurity(NodeId remoteId, PeerAddress address)
 {
-    ChipSerializedDevice serializedTestDevice;
-    return mController.PairTestDeviceWithoutSecurity(remoteId, address, serializedTestDevice);
+    return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR PairingCommand::Unpair(NodeId remoteId)
@@ -166,7 +165,9 @@ CHIP_ERROR PairingCommand::Unpair(NodeId remoteId)
 
 CHIP_ERROR PairingCommand::OpenCommissioningWindow()
 {
-    CHIP_ERROR err = mController.OpenCommissioningWindow(mNodeId, mTimeout, mIteration, mDiscriminator, mCommissioningWindowOption);
+    SetupPayload payload;
+    CHIP_ERROR err =
+        mController.OpenCommissioningWindow(mNodeId, mTimeout, mIteration, mDiscriminator, mCommissioningWindowOption, payload);
     SetCommandExitStatus(err);
     return err;
 }
@@ -246,7 +247,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

@@ -214,13 +214,13 @@ 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);
 
-    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/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

@@ -50,7 +50,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);
 
@@ -179,8 +179,8 @@ class TestCommand : public CHIPCommand
 
     bool CheckValueAsString(const char * itemName, chip::CharSpan current, const char * expected);
 
-    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/main.cpp

@@ -19,8 +19,8 @@
 #include <app-common/zap-generated/enums.h>
 #include <app/server/Server.h>
 #include <app/util/util.h>
-#include <controller/CHIPDevice.h>
 #include <controller/CHIPDeviceControllerFactory.h>
+#include <controller/CommissioneeDeviceProxy.h>
 #include <controller/ExampleOperationalCredentialsIssuer.h>
 #include <credentials/DeviceAttestationCredsProvider.h>
 #include <credentials/examples/DeviceAttestationCredsExample.h>
@@ -49,6 +49,8 @@
 using chip::ByteSpan;
 using chip::CharSpan;
 using chip::EndpointId;
+using chip::OnDeviceConnected;
+using chip::OnDeviceConnectionFailure;
 using chip::VendorId;
 using chip::ArgParser::HelpOptions;
 using chip::ArgParser::OptionDef;
@@ -59,8 +61,6 @@ using chip::Callback::Callback;
 using chip::Controller::Device;
 using chip::Controller::DeviceController;
 using chip::Controller::ExampleOperationalCredentialsIssuer;
-using chip::Controller::OnDeviceConnected;
-using chip::Controller::OnDeviceConnectionFailure;
 
 // TODO: would be nicer to encapsulate these globals and the callbacks in some sort of class
 chip::Messaging::ExchangeContext * exchangeCtx = nullptr;

src/app/BUILD.gn

@@ -39,6 +39,7 @@ static_library("app") {
     "Command.h",
     "CommandHandler.cpp",
     "CommandSender.cpp",
+    "DeviceProxy.h",
     "EventManagement.cpp",
     "InteractionModelEngine.cpp",
     "MessageDef/AttributeDataElement.cpp",
@@ -93,6 +94,8 @@ static_library("app") {
     "MessageDef/TimedRequest.cpp",
     "MessageDef/WriteRequest.cpp",
     "MessageDef/WriteResponse.cpp",
+    "OperationalDeviceProxy.cpp",
+    "OperationalDeviceProxy.h",
     "ReadClient.cpp",
     "ReadHandler.cpp",
     "WriteClient.cpp",
@@ -112,6 +115,7 @@ static_library("app") {
 
   public_deps = [
     ":app_buildconfig",
+    "${chip_root}/src/app/util:device_callbacks_manager",
     "${chip_root}/src/lib/support",
     "${chip_root}/src/messaging",
     "${chip_root}/src/protocols/secure_channel",

src/app/DeviceProxy.h

@@ -0,0 +1,128 @@
+/*
+ *
+ *    Copyright (c) 2020-2021 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.
+ */
+
+/**
+ *  @file
+ *    This file contains definitions for DeviceProxy base class. The objects of this
+ *    class will be used by applications to interact with peer CHIP devices.
+ *    The class provides mechanism to construct, send and receive messages to and
+ *    from the corresponding CHIP devices.
+ */
+
+#pragma once
+
+#include <app/CommandSender.h>
+#include <app/DeviceControllerInteractionModelDelegate.h>
+#include <app/InteractionModelEngine.h>
+#include <app/util/CHIPDeviceCallbacksMgr.h>
+#include <lib/core/CHIPCallback.h>
+#include <lib/core/CHIPCore.h>
+#include <lib/support/DLLUtil.h>
+
+namespace chip {
+
+class DLL_EXPORT DeviceProxy
+{
+public:
+    virtual ~DeviceProxy() {}
+    DeviceProxy() {}
+
+    /**
+     *   Called when a connection is closing.
+     *   The object releases all resources associated with the connection.
+     */
+    virtual void OnConnectionExpired(SessionHandle session) = 0;
+
+    /**
+     *  Mark any open session with the device as expired.
+     */
+    virtual CHIP_ERROR Disconnect() = 0;
+
+    virtual NodeId GetDeviceId() const = 0;
+
+    virtual bool GetAddress(Inet::IPAddress & addr, uint16_t & port) const { return false; }
+
+    virtual CHIP_ERROR SendReadAttributeRequest(app::AttributePathParams aPath, Callback::Cancelable * onSuccessCallback,
+                                                Callback::Cancelable * onFailureCallback, app::TLVDataFilter aTlvDataFilter) = 0;
+
+    virtual CHIP_ERROR SendSubscribeAttributeRequest(app::AttributePathParams aPath, uint16_t mMinIntervalFloorSeconds,
+                                                     uint16_t mMaxIntervalCeilingSeconds, Callback::Cancelable * onSuccessCallback,
+                                                     Callback::Cancelable * onFailureCallback) = 0;
+
+    virtual CHIP_ERROR SendWriteAttributeRequest(app::WriteClientHandle aHandle, Callback::Cancelable * onSuccessCallback,
+                                                 Callback::Cancelable * onFailureCallback) = 0;
+
+    virtual CHIP_ERROR SendCommands(app::CommandSender * commandObj) = 0;
+
+    virtual void AddReportHandler(EndpointId endpoint, ClusterId cluster, AttributeId attribute,
+                                  Callback::Cancelable * onReportCallback, app::TLVDataFilter tlvDataFilter) = 0;
+
+    // These two functions are pretty tricky, it is used to bridge the response, we need to implement interaction model delegate
+    // on the app side instead of register callbacks here. The IM delegate can provide more infomation then callback and it is
+    // type-safe.
+    // TODO: Implement interaction model delegate in the application.
+    virtual void AddIMResponseHandler(app::CommandSender * commandObj, Callback::Cancelable * onSuccessCallback,
+                                      Callback::Cancelable * onFailureCallback) = 0;
+
+    virtual void CancelIMResponseHandler(app::CommandSender * commandObj) = 0;
+
+    virtual Controller::DeviceControllerInteractionModelDelegate * GetInteractionModelDelegate() = 0;
+
+    virtual Messaging::ExchangeManager * GetExchangeManager() const = 0;
+
+    virtual chip::Optional<SessionHandle> GetSecureSession() const = 0;
+
+    virtual bool IsActive() const { return true; }
+};
+
+/**
+ * This class defines an interface for an object that the user of Device
+ * can register as a delegate. The delegate object will be called by the
+ * Device when a new message or status update is received from the corresponding
+ * CHIP device.
+ */
+class DLL_EXPORT DeviceStatusDelegate
+{
+public:
+    virtual ~DeviceStatusDelegate() {}
+
+    /**
+     * @brief
+     *   Called when a message is received from the device.
+     *
+     * @param[in] msg Received message buffer.
+     */
+    virtual void OnMessage(System::PacketBufferHandle && msg) = 0;
+
+    /**
+     * @brief
+     *   Called when response to OpenPairingWindow is received from the device.
+     *
+     * @param[in] status CHIP_NO_ERROR on success, or corresponding error.
+     */
+    virtual void OnPairingWindowOpenStatus(CHIP_ERROR status){};
+
+    /**
+     * @brief
+     *   Called when device status is updated.
+     *
+     */
+    virtual void OnStatusChange(void){};
+};
+
+} // namespace chip