ViewSelection.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include <ArmarXCore/core/Component.h>
 
#include <RobotAPI/libraries/armem/client/MemoryNameSystem.h>
#include <RobotAPI/libraries/armem/client/Reader.h>
#include <RobotAPI/libraries/armem/client/Writer.h>
#include <RobotAPI/libraries/armem/client/plugins.h>
#include <RobotAPI/libraries/armem/client/plugins/PluginUser.h>
#include <RobotAPI/libraries/armem/core/MemoryID.h>
#include <RobotAPI/libraries/armem/core/error/mns.h>
#include <RobotAPI/libraries/armem_robot_state/client/common/VirtualRobotReader.h>
 
#include <armarx/view_selection/client/GazeTargetWaiter.h>
#include <armarx/view_selection/gaze_targets.h>
#include <armarx/view_selection/gaze_targets/GazeTarget.h>
#include <armarx/view_selection/gaze_targets/GazeTargetStatus.h>
 
namespace armarx::view_selection::client
{
    class MemoryStatusHandlerBase;
 
    /// How gaze target status updates reach this client.
    enum class StatusDelivery
    {
        /// Pushed by the memory. Requires the owning component to derive from
        /// armarx::armem::client::plugins::ListeningPluginUser.
        Subscription,
        /// Queried every 100 ms. Works anywhere, at the cost of up to one poll period of latency.
        Polling
    };
 
    class ViewSelection
    {
    public:
        ViewSelection(armarx::armem::client::MemoryNameSystem& mns,
                      std::string providerSegmentName);
        ~ViewSelection();
 
        void connect(StatusDelivery statusDelivery = StatusDelivery::Subscription);
 
        std::optional<gaze_targets::GazeTarget> readGazeTarget(const std::string& name);
 
        /// The lifecycle of the named target, as far as the scheduler has published it.
        std::optional<gaze_targets::GazeTargetStatus>
        readGazeTargetStatus(const std::string& name);
 
        /// @return The memory ID of the committed request, invalid if the commit failed.
        armarx::armem::MemoryID commitGazeTarget(const gaze_targets::GazeTarget& target);
        void commitGazeTargets(const std::vector<gaze_targets::GazeTarget>& targets);
 
        /**
         * @brief Commit a gaze target and block until the robot's gaze is fixed on it.
         *
         * Arms the wait before committing, so a status update that arrives immediately is not
         * missed.
         *
         * @param timeout      A non-positive duration waits indefinitely.
         * @param shouldAbort  Polled while waiting; typically a skill's shouldSkillTerminate().
         */
        GazeTargetWaiter::Result
        commitGazeTargetAndWait(const gaze_targets::GazeTarget& target,
                                const armarx::Duration& timeout,
                                const std::function<bool()>& shouldAbort = {});
 
        /// Give up a target: lowest priority, no duration, not kept in the queue.
        void releaseGazeTarget(const gaze_targets::GazeTarget& target);
 
    private:
        // Private member variables go here.
        armarx::armem::client::MemoryNameSystem& memoryNameSystem;
        std::string providerSegmentName;
        const armarx::armem::MemoryID coreSegmentID;
        const armarx::armem::MemoryID statusCoreSegmentID;
        armarx::armem::client::Writer memoryWriter;
        armarx::armem::client::Reader memoryReader;
 
        std::unique_ptr<MemoryStatusHandlerBase> statusHandler;
        std::optional<GazeTargetWaiter> waiter;
    };
 
} // namespace armarx::view_selection::client