SkillProxy.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <functional>
#include <mutex>
#include <optional>
#include <string>
#include <unordered_map>
 
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/Duration.h>
#include <ArmarXCore/core/time/Frequency.h>
#include <ArmarXCore/core/time/forward_declarations.h>
 
#include <RobotAPI/interface/skills/SkillManagerInterface.h>
#include <RobotAPI/libraries/aron/core/data/variant/container/Dict.h>
#include <RobotAPI/libraries/skills/core/SkillDescription.h>
#include <RobotAPI/libraries/skills/core/SkillExecutionID.h>
#include <RobotAPI/libraries/skills/core/SkillID.h>
#include <RobotAPI/libraries/skills/core/SkillStatusUpdate.h>
 
namespace armarx
{
    namespace skills
    {
        class SkillUpdateManager
        {
        public:
            using Callback = std::function<void(const skills::SkillStatusUpdate&)>;
            using CallbackID = std::uint64_t;
 
            CallbackID
            addCallback(Callback cb)
            {
                std::scoped_lock l{callbackMutex};
                CallbackID id = nextId++;
                callbacks[id] = cb;
                return id;
            }
 
            void
            removeCallback(CallbackID id)
            {
                std::scoped_lock l{callbackMutex};
                callbacks.erase(id);
            }
 
            void
            update(const skills::SkillStatusUpdate& statusUpdate)
            {
                std::scoped_lock l{callbackMutex};
                for (auto& [id, cb] : callbacks)
                {
                    cb(statusUpdate);
                }
            }
 
        private:
            std::mutex callbackMutex;
            std::unordered_map<CallbackID, Callback> callbacks;
            CallbackID nextId = 0;
        };
 
        extern SkillUpdateManager GlobalSkillUpdateManager;
 
        /* Manages the remote execution of a skill and converts the ice types */
        class SkillProxy : public armarx::Logging
        {
        public:
            /// We remove the default constructor as every skill proxy requires a manager
            SkillProxy() = delete;
 
            /// set the skill proxy using a skillId. Queries the manager to get the description.
            SkillProxy(const manager::dti::SkillManagerInterfacePrx& manager,
                       const SkillID& skillId);
 
            /// set the proxy using a skill description
            SkillProxy(const manager::dti::SkillManagerInterfacePrx& manager,
                       const SkillDescription& skillDesc);
 
            /// copy ctor
            SkillProxy(const SkillProxy&) = delete;
 
            // delete copy assignment
            SkillProxy& operator=(const SkillProxy&) = delete;
 
            ~SkillProxy();
 
            /// get the skill description
            SkillDescription getSkillDescription() const;
 
            /// get the skill id from the skill description
            SkillID getSkillId() const;
 
            // Provide a similar API as the skillprovider
            /// execute a skill and block until skill terminates
            TerminatedSkillStatusUpdate
            executeSkill(const std::string& executorName,
                         const aron::data::DictPtr& params = nullptr) const;
 
            /// execute a skill. Do not block during execution
            SkillExecutionID executeSkillAsync(const std::string& executorName,
                                               const aron::data::DictPtr& params = nullptr) const;
 
            /// poll execution status and block until its null or terminated
            std::optional<TerminatedSkillStatusUpdate>
            join(const SkillExecutionID& executionId,
                 armarx::Duration max_wait_time = armarx::Duration::Seconds(1),
                 armarx::Frequency check_frequency = armarx::Frequency::Hertz(20)) const;
 
            void updateSubSkillStatus(const skills::SkillStatusUpdate& statusUpdate);
 
            /// ask skill to abort ASAP. Blocks until skill stopped
            bool abortSkill(const SkillExecutionID& executionId) const;
 
            /// ask skill to abort ASAP
            bool abortSkillAsync(const SkillExecutionID& executionId) const;
 
            // Utiliy methods
            /// get the default parameters of the skill. TODO: Skill profiles in memory!
            aron::data::DictPtr getRootProfileParameters() const;
 
            std::optional<SkillStatusUpdate>
            getExecutionStatus(const SkillExecutionID& executionId) const;
 
        protected:
            manager::dti::SkillManagerInterfacePrx manager;
            SkillDescription skillDescription;
 
            mutable std::mutex lastUpdatesMutex;
            std::unordered_map<std::string, SkillStatusUpdate> lastUpdates;
            SkillUpdateManager::CallbackID callbackId;
        };
    } // namespace skills
} // namespace armarx