client.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <string>
#include <thread>
 
#include <viam/sdk/common/grpc_fwd.hpp>
#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 {
 
namespace impl {
struct LogBackend;
}
 
 
class RobotClient {
   public:
    enum class status : uint8_t {
        k_initializing,
        k_running,
        k_unspecified,
    };
 
    friend std::ostream& operator<<(std::ostream& os, const status& v);
 
    struct frame_system_config {
        WorldState::transform frame;
        ProtoStruct kinematics;
        friend bool operator==(const frame_system_config& lhs, const frame_system_config& rhs);
    };
 
    struct operation {
        std::string id;
        std::string method;
        boost::optional<std::string> session_id;
        ProtoStruct arguments;
        boost::optional<time_pt> 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();
 
    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, ProtoStruct>& extra);
 
    void cancel_operation(std::string id);
 
    status get_machine_status() const;
 
   private:
    friend class ModuleService;
    friend struct impl::LogBackend;
 
    void log(const std::string& name,
             const std::string& level,
             const std::string& message,
             time_pt time);
 
    void connect_logging();
 
    void refresh_every();
 
    std::vector<std::shared_ptr<std::thread>> threads_;
 
    std::atomic<bool> should_refresh_;
    unsigned int refresh_interval_;
 
    std::shared_ptr<GrpcChannel> 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_;
};
 
}  // namespace sdk
}  // namespace viam