client.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <thread>
 
#include <grpcpp/channel.h>
 
#include <viam/sdk/common/pose.hpp>
#include <viam/sdk/common/utils.hpp>
#include <viam/sdk/common/world_state.hpp>
#include <viam/sdk/components/component.hpp>
#include <viam/sdk/registry/registry.hpp>
#include <viam/sdk/resource/resource.hpp>
#include <viam/sdk/rpc/dial.hpp>
#include <viam/sdk/services/service.hpp>
 
namespace viam {
namespace sdk {
 
using grpc::Channel;
 
 
class RobotClient {
   public:
    struct discovery_query {
        std::string subtype;
        std::string model;
        friend bool operator==(const discovery_query& lhs, const discovery_query& rhs);
    };
 
    struct discovery {
        discovery_query query;
        AttributeMap results;
        friend bool operator==(const discovery& lhs, const discovery& rhs);
    };
 
    struct frame_system_config {
        WorldState::transform frame;
        AttributeMap kinematics;
        friend bool operator==(const frame_system_config& lhs, const frame_system_config& rhs);
    };
 
    struct status {
        boost::optional<Name> name;
        AttributeMap status_map;
        // TODO: RSDK-6574: revisit time_point
        boost::optional<std::chrono::time_point<long long, std::chrono::nanoseconds>>
            last_reconfigured;
        friend bool operator==(const status& lhs, const status& rhs);
    };
 
    struct operation {
        std::string id;
        std::string method;
        boost::optional<std::string> session_id;
        AttributeMap arguments;
        // TODO: RSDK-6574: revisit time_point
        boost::optional<std::chrono::time_point<long long, std::chrono::nanoseconds>> started;
        friend bool operator==(const operation& lhs, const operation& rhs);
    };
 
    ~RobotClient();
    void refresh();
    void close();
 
    static std::shared_ptr<RobotClient> at_address(const std::string& address,
                                                   const Options& options);
 
    static std::shared_ptr<RobotClient> at_local_socket(const std::string& address,
                                                        const Options& options);
 
    static std::shared_ptr<RobotClient> with_channel(std::shared_ptr<ViamChannel> channel,
                                                     const Options& options);
    RobotClient(std::shared_ptr<ViamChannel> channel);
    std::vector<Name> resource_names() const;
 
    std::shared_ptr<Resource> resource_by_name(const Name& name);
 
    template <typename T>
    std::shared_ptr<T> resource_by_name(std::string name) {
        return std::dynamic_pointer_cast<T>(resource_by_name({API::get<T>(), "", std::move(name)}));
    }
 
    std::vector<frame_system_config> get_frame_system_config(
        const std::vector<WorldState::transform>& additional_transforms = {});
 
    std::vector<operation> get_operations();
 
    std::vector<status> get_status(std::vector<Name>& components);
 
    std::vector<status> get_status();
 
    std::vector<discovery> discover_components(const std::vector<discovery_query>& queries);
 
    pose_in_frame transform_pose(
        const pose_in_frame& query,
        std::string destination,
        const std::vector<WorldState::transform>& additional_transforms = {});
 
    void block_for_operation(std::string id);
 
    void stop_all();
 
    void stop_all(const std::unordered_map<Name, AttributeMap>& extra);
 
    void cancel_operation(std::string id);
 
   private:
    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<ViamChannel> viam_channel_;
    bool should_close_channel_;
    struct impl;
    std::unique_ptr<impl> impl_;
    mutable std::mutex lock_;
    std::vector<Name> resource_names_;
    ResourceManager resource_manager_;
    void refresh_every();
};
 
}  // namespace sdk
}  // namespace viam