Plugin.cpp

Go to the documentation of this file.

#include "Plugin.h"
 
#include <ArmarXCore/core/Component.h>
 
namespace armarx
{
 
    RobotNameServiceComponentPluginUser::RobotNameServiceComponentPluginUser()
    {
        addPlugin(plugin);
    }
} // namespace armarx
 
namespace armarx::plugins
{
 
    void
    RobotNameServiceComponentPlugin::postOnInitComponent()
    {
        using namespace armarx::robot_name_service::client::constants;
 
        ARMARX_INFO << "Got as config: " << properties.configJson;
 
        nlohmann::json config = nlohmann::json::parse(properties.configJson);
 
        if (config.contains(CONFIG_ROBOT_NAME))
        {
            robot.name = config[CONFIG_ROBOT_NAME];
        }
 
        if (config.contains(CONFIG_XML_PACKAGE_PATH))
        {
            auto config_pp = config[CONFIG_XML_PACKAGE_PATH];
            if (config_pp.contains(CONFIG_XML_PACKAGE_PATH_PACKAGE))
            {
                robot.xmlPackagePath.package = config_pp[CONFIG_XML_PACKAGE_PATH_PACKAGE];
            }
            if (config_pp.contains(CONFIG_XML_PACKAGE_PATH_PATH))
            {
                robot.xmlPackagePath.path = config_pp[CONFIG_XML_PACKAGE_PATH_PATH];
            }
        }
        auto& p = parent<RobotNameServiceComponentPluginUser>();
 
        if (config.contains(CONFIG_MNS_PRX))
        {
            p.usingProxy(config[CONFIG_MNS_PRX]);
        }
        if (config.contains(CONFIG_SKILLS_MANAGER_PRX))
        {
            p.usingProxy(config[CONFIG_SKILLS_MANAGER_PRX]);
        }
 
        if (config.contains(CONFIG_ARMS))
        {
            for (const auto& [k, config_arm] : config[CONFIG_ARMS].items())
            {
                auto& arm = robot.armInfos[k];
 
                if (config_arm.contains(CONFIG_ARM_KINEMATIC_CHAIN_NAME))
                {
                    arm.kinematicChainName = config_arm[CONFIG_ARM_KINEMATIC_CHAIN_NAME];
                }
 
                if (config_arm.contains(CONFIG_ARM_HAND))
                {
                    auto config_hand = config_arm[CONFIG_ARM_HAND];
 
                    if (config_hand.contains(CONFIG_ARM_HAND_NAME))
                    {
                        arm.hand.name = config_hand[CONFIG_ARM_HAND_NAME];
                    }
                    if (config_hand.contains(CONFIG_ARM_HAND_FT_NAME))
                    {
                        arm.hand.ft_name = config_hand[CONFIG_ARM_HAND_FT_NAME];
                    }
 
                    if (config_hand.contains(CONFIG_ARM_HAND_PRX))
                    {
                        p.usingProxy(config_hand[CONFIG_ARM_HAND_PRX]);
                    }
                }
            }
        }
    }
 
    void
    RobotNameServiceComponentPlugin::preOnConnectComponent()
    {
        using namespace armarx::robot_name_service::client::constants;
 
        nlohmann::json config = nlohmann::json::parse(properties.configJson);
 
        auto& p = parent<RobotNameServiceComponentPluginUser>();
 
        if (config.contains(CONFIG_MNS_PRX))
        {
            auto mns = p.getProxy<armarx::armem::mns::MemoryNameSystemInterfacePrx>(
                config[CONFIG_MNS_PRX]);
            robot.memoryNameSystem = armarx::armem::client::MemoryNameSystem(mns, &p);
        }
 
        if (config.contains(CONFIG_SKILLS_MANAGER_PRX))
        {
            auto skill_manager = p.getProxy<armarx::skills::manager::dti::SkillManagerInterfacePrx>(
                config[CONFIG_SKILLS_MANAGER_PRX]);
            robot.skillManager = skill_manager;
        }
 
        if (config.contains(CONFIG_ARMS))
        {
            for (const auto& [k, config_arm] : config[CONFIG_ARMS].items())
            {
                auto& arm = robot.armInfos[k];
 
                if (config_arm.contains(CONFIG_ARM_HAND))
                {
                    auto config_hand = config_arm[CONFIG_ARM_HAND];
 
                    if (config_hand.contains(CONFIG_ARM_HAND_PRX))
                    {
                        auto hand_prx = p.getProxy<armarx::HandUnitInterfacePrx>(
                            config_hand[CONFIG_ARM_HAND_PRX]);
                        arm.hand.handUnitInterface = hand_prx;
                    }
                }
            }
        }
 
        // finally commit robot
        properties.rns->registerRobotInfo(robot.toIce());
    }
 
    void
    RobotNameServiceComponentPlugin::postCreatePropertyDefinitions(PropertyDefinitionsPtr& def)
    {
        def->optional(properties.configJson, "robotConfigJson");
        def->component(properties.rns);
    }
 
    void
    RobotNameServiceComponentPlugin::preOnDisconnectComponent()
    {
        properties.rns->unregisterRobotInfo(robot.name);
    }
 
} // namespace armarx::plugins