refer to grpc::Channel by forward decl

src/viam/sdk/common/grpc_client_fwd.hpp.in

@@ -9,6 +9,8 @@
 
 namespace grpc {
 
+class Channel;
+
 class ClientContext;
 
 template <typename>
@@ -19,6 +21,8 @@ class ClientReaderInterface;
 namespace viam {
 namespace sdk {
 
+using GrpcChannel = ::grpc::Channel;
+
 using GrpcClientContext = ::grpc::ClientContext;
 
 template <typename T>
@@ -34,6 +38,8 @@ using GrpcClientReaderInterface = ::grpc::ClientReaderInterface<T>;
 
 namespace grpc_impl {
 
+class Channel;
+
 class ClientContext;
 
 template <typename>
@@ -44,6 +50,8 @@ class ClientReaderInterface;
 namespace viam {
 namespace sdk {
 
+using GrpcChannel = ::grpc_impl::Channel;
+
 using GrpcClientContext = ::grpc_impl::ClientContext;
 
 template <typename T>

src/viam/sdk/module/module.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <viam/sdk/common/grpc_client_fwd.hpp>
 #include <viam/sdk/module/handler_map.hpp>
 #include <viam/sdk/resource/resource.hpp>
 #include <viam/sdk/resource/resource_manager.hpp>
@@ -18,14 +19,14 @@ class Module {
     bool ready() const;
     const HandlerMap_& handles() const;
     HandlerMap_& mutable_handles();
-    const std::shared_ptr<grpc::Channel>& channel() const;
+    const std::shared_ptr<GrpcChannel>& channel() const;
 
    private:
     std::string name_;
     std::string addr_;
     bool ready_;
     HandlerMap_ handles_;
-    std::shared_ptr<grpc::Channel> channel_;
+    std::shared_ptr<GrpcChannel> channel_;
 };
 
 }  // namespace sdk

src/viam/sdk/registry/registry.cpp

@@ -55,9 +55,32 @@
 namespace viam {
 namespace sdk {
 
+ResourceServerRegistration::ResourceServerRegistration(
+    const google::protobuf::ServiceDescriptor* service_descriptor)
+    : service_descriptor_(service_descriptor) {}
+
 ResourceServerRegistration::~ResourceServerRegistration() = default;
 ResourceClientRegistration::~ResourceClientRegistration() = default;
 
+ModelRegistration::ModelRegistration(
+    API api,
+    Model model,
+    std::function<std::shared_ptr<Resource>(Dependencies, ResourceConfig)> constructor)
+    : construct_resource(std::move(constructor)),
+      validate(default_validator),
+      model_(std::move(model)),
+      api_(std::move(api)) {}
+
+ModelRegistration::ModelRegistration(
+    API api,
+    Model model,
+    std::function<std::shared_ptr<Resource>(Dependencies, ResourceConfig)> constructor,
+    std::function<std::vector<std::string>(ResourceConfig)> validator)
+    : construct_resource(std::move(constructor)),
+      validate(std::move(validator)),
+      model_(std::move(model)),
+      api_(std::move(api)) {}
+
 const API& ModelRegistration::api() const {
     return api_;
 };

src/viam/sdk/registry/registry.hpp

@@ -7,10 +7,10 @@
 
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/message.h>
-#include <grpcpp/channel.h>
 #include <grpcpp/impl/service_type.h>
 #include <grpcpp/server.h>
 
+#include <viam/sdk/common/grpc_client_fwd.hpp>
 #include <viam/sdk/config/resource.hpp>
 #include <viam/sdk/resource/resource.hpp>
 #include <viam/sdk/resource/resource_api.hpp>
@@ -24,6 +24,8 @@ namespace sdk {
 // TODO(RSDK-6617): one class per header
 class ResourceServerRegistration {
    public:
+    ResourceServerRegistration(const google::protobuf::ServiceDescriptor* service_descriptor);
+
     virtual ~ResourceServerRegistration();
 
     /// @brief Create a resource's gRPC server.
@@ -36,9 +38,6 @@ class ResourceServerRegistration {
     /// @brief Returns a reference to the `ResourceServerRegistration`'s service descriptor.
     const google::protobuf::ServiceDescriptor* service_descriptor() const;
 
-    ResourceServerRegistration(const google::protobuf::ServiceDescriptor* service_descriptor)
-        : service_descriptor_(service_descriptor){};
-
    private:
     const google::protobuf::ServiceDescriptor* service_descriptor_;
 };
@@ -47,16 +46,16 @@ class ResourceServerRegistration {
 /// @brief Defines registered `Resource` client creation functionality.
 class ResourceClientRegistration {
    public:
+    ResourceClientRegistration() = default;
+
     virtual ~ResourceClientRegistration();
 
     /// @brief Create gRPC client to a resource.
     /// @param name The name of the resource.
     /// @param channel A channel connected to the client.
     /// @return A `shared_ptr` to the resource client.
     virtual std::shared_ptr<Resource> create_rpc_client(
-        std::string name, std::shared_ptr<grpc::Channel> channel) const = 0;
-
-    ResourceClientRegistration() = default;
+        std::string name, std::shared_ptr<GrpcChannel> channel) const = 0;
 };
 
 // TODO(RSDK-6616): instead of std::functions, consider making these functions
@@ -68,21 +67,13 @@ class ModelRegistration {
     ModelRegistration(
         API api,
         Model model,
-        std::function<std::shared_ptr<Resource>(Dependencies, ResourceConfig)> constructor)
-        : construct_resource(std::move(constructor)),
-          validate(default_validator),
-          model_(std::move(model)),
-          api_(std::move(api)){};
+        std::function<std::shared_ptr<Resource>(Dependencies, ResourceConfig)> constructor);
 
     ModelRegistration(
         API api,
         Model model,
         std::function<std::shared_ptr<Resource>(Dependencies, ResourceConfig)> constructor,
-        std::function<std::vector<std::string>(ResourceConfig)> validator)
-        : construct_resource(std::move(constructor)),
-          validate(std::move(validator)),
-          model_(std::move(model)),
-          api_(std::move(api)){};
+        std::function<std::vector<std::string>(ResourceConfig)> validator);
 
     const API& api() const;
     const Model& model() const;
@@ -134,7 +125,7 @@ class Registry {
             using ResourceClientRegistration::ResourceClientRegistration;
 
             std::shared_ptr<Resource> create_rpc_client(
-                std::string name, std::shared_ptr<grpc::Channel> chan) const override {
+                std::string name, std::shared_ptr<GrpcChannel> chan) const override {
                 return std::make_shared<ResourceClientT>(std::move(name), std::move(chan));
             }
         };

src/viam/sdk/robot/client.hpp

@@ -6,8 +6,7 @@
 #include <string>
 #include <thread>
 
-#include <grpcpp/channel.h>
-
+#include <viam/sdk/common/grpc_client_fwd.hpp>
 #include <viam/sdk/common/pose.hpp>
 #include <viam/sdk/common/utils.hpp>
 #include <viam/sdk/common/world_state.hpp>
@@ -20,8 +19,6 @@
 namespace viam {
 namespace sdk {
 
-using grpc::Channel;
-
 /// @defgroup Robot Classes related to a Robot representation.
 
 /// @class RobotClient client.hpp "robot/client.hpp"
@@ -152,7 +149,7 @@ class RobotClient {
     std::vector<std::shared_ptr<std::thread>> threads_;
     std::atomic<bool> should_refresh_;
     unsigned int refresh_interval_;
-    std::shared_ptr<Channel> channel_;
+    std::shared_ptr<GrpcChannel> channel_;
     std::shared_ptr<ViamChannel> viam_channel_;
     bool should_close_channel_;
     struct impl;

src/viam/sdk/rpc/dial.hpp

@@ -1,10 +1,12 @@
 #pragma once
 
+#include <chrono>
 #include <memory>
 #include <string>
 
 #include <boost/optional.hpp>
-#include <grpcpp/channel.h>
+
+#include <viam/sdk/common/grpc_client_fwd.hpp>
 
 namespace viam {
 namespace sdk {
@@ -13,14 +15,14 @@ class DialOptions;
 class ViamChannel {
    public:
     void close();
-    ViamChannel(std::shared_ptr<grpc::Channel> channel, const char* path, void* runtime);
+    ViamChannel(std::shared_ptr<GrpcChannel> channel, const char* path, void* runtime);
     static std::shared_ptr<ViamChannel> dial(const char* uri,
                                              const boost::optional<DialOptions>& options);
 
-    const std::shared_ptr<grpc::Channel>& channel() const;
+    const std::shared_ptr<GrpcChannel>& channel() const;
 
    private:
-    std::shared_ptr<grpc::Channel> channel_;
+    std::shared_ptr<GrpcChannel> channel_;
     const char* path_;
     bool closed_;
     void* rust_runtime_;