SkillDashboardWidgetController.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * \package    ArmarXGui::gui-plugins::OperatorViewWidgetController
 * \author     Leonie Leven
 * \date       2024
 * \copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "SkillDashboardWidgetController.h"
 
#include <string>
 
#include <QDebug>
#include <QHBoxLayout>
#include <QPalette>
#include <QStringList>
#include <QTimer>
 
#include <ArmarXCore/core/application/Application.h>
#include <ArmarXCore/core/system/ArmarXDataPath.h>
#include <ArmarXCore/core/time/LocalTimeServer.h>
#include <ArmarXCore/core/time/TimeUtil.h>
#include <ArmarXCore/observers/variant/SingleTypeVariantList.h>
 
 
// Qt headers
#include <cmath>
#include <fstream>
#include <iostream>
 
#include <QLabel>
#include <QLineEdit>
#include <QMessageBox>
#include <QPushButton>
#include <QString>
#include <QTimer>
#include <QToolButton>
#include <Qt>
#include <QtGlobal>
#include <QtWidgets/QSlider>
#include <QtWidgets/QTableWidgetItem>
 
#include <nlohmann/json.hpp>
 
static const std::string config_key_skilldashboard = "skilldashboard";
static const std::string config_key_start_in = "start_in";
 
namespace armarx
{
    SkillDashboardGuiPlugin::SkillDashboardGuiPlugin()
    {
        addWidget<SkillDashboardWidget>();
    }
 
    SkillDashboardWidget::SkillDashboardWidget() :
        DEFAULT_SETTINGS_PLUGIN_NAME("SkillDashboardGuiPlugin"),
        DEFAULT_SETTINGS_CUSTOM_TEXT("custom text")
    {
 
        // init gui
        ARMARX_INFO << "Setup UI";
        ui.setupUi(getWidget());
        this->shortcutLayout = new QVBoxLayout();
        this->dialog = new SkillDashboardConfigWindow();
        this->editModeAction = new QAction("Edit Mode", this);
        this->editModeAction->setCheckable(true);
        this->editModeAction->setToolTip("If toggled the shortcut config buttons and the reload, "
                                         "add and export button will be shown.");
 
        connect(this->editModeAction, SIGNAL(toggled(bool)), this, SLOT(editMode(bool)));
 
        connect(
            ui.addButton, &QPushButton::clicked, this, [this]() { openConfigWindow("", "", ""); });
        connect(ui.reloadButton, &QPushButton::clicked, this, &SkillDashboardWidget::loadButtons);
        connect(
            this, &SkillDashboardWidget::loadButtonInit, this, &SkillDashboardWidget::loadButtons);
        connect(ui.exportButton, &QPushButton::clicked, this, &SkillDashboardWidget::exportButtons);
 
        connect(this,
                &SkillDashboardWidget::skillFinished,
                this,
                &SkillDashboardWidget::activateButton);
 
        connect(this->dialog,
                &SkillDashboardConfigWindow::shortcutNameHasChanged,
                this,
                &SkillDashboardWidget::onShortcutNameChanged);
 
        this->editMode(true);
 
        ARMARX_INFO << "Done: Setup UI";
    }
 
    void
    SkillDashboardWidget::onInitComponent()
    {
        ARMARX_TRACE;
        if (not dashboardManagerName.empty())
        {
            usingProxy(dashboardManagerName);
        }
        else
        {
            ARMARX_IMPORTANT << "empty";
        }
        if (not this->skillManagerOberserverName.empty())
        {
            usingProxy(this->skillManagerOberserverName);
        }
        else
        {
            ARMARX_IMPORTANT << "empty";
        }
    }
 
    void
    SkillDashboardWidget::onConnectComponent()
    {
        ARMARX_TRACE;
        this->connected.store(true);
        getProxy(this->dashboardPrx, this->dashboardManagerName);
        getProxy(this->managerPrx, this->skillManagerOberserverName);
        this->exampleTask = std::thread([&] { exampleThreadMethod(); });
        emit loadButtonInit();
    }
 
    void
    SkillDashboardWidget::activateButton(const std::string& name)
    {
        this->shortcutButtons.at(name)->setDisabled(false);
    }
 
    void
    SkillDashboardWidget::exampleThreadMethod()
    {
        while (this->connected.load())
        {
            if (not this->runningSkills.empty())
            {
                for (auto it = this->runningSkills.cbegin(); it != this->runningSkills.cend();)
                {
                    skills::core::dto::Execution::Status status =
                        skills::core::dto::Execution::Status::Succeeded;
 
                    try
                    {
                        IceUtil::Optional<skills::manager::dto::SkillStatusUpdate> update =
                            this->managerPrx->getSkillExecutionStatus(it->second);
                        if (update)
                        {
                            status = update->status;
                        }
                    }
                    catch (Ice::Exception const&)
                    {
                        ARMARX_WARNING << "Could not get skill status." << deactivateSpam(10);
                    }
 
                    if (status == skills::core::dto::Execution::Status::Succeeded ||
                        status == skills::core::dto::Execution::Status::Failed ||
                        status == skills::core::dto::Execution::Status::Aborted)
                    {
                        emit skillFinished(it->first);
                        this->runningSkills.erase(it++);
                    }
                    else
                    {
                        ++it;
                    }
                }
            }
        }
    }
 
    void
    SkillDashboardWidget::onShortcutNameChanged()
    {
 
        if ((this->shortcutButtons.find(this->dialog->getShortcutName().toStdString()) !=
             this->shortcutButtons.end()) and
            (this->dialog->getShortcutName().toStdString() != this->currentShortcutName))
        {
            this->dialog->setInfoText(
                "A shortcut with this name already exists! The old one will be overwritten.");
            ARMARX_IMPORTANT
                << "A shortcut with this name already exists! The old one will be overwritten!";
        }
        else
        {
            this->dialog->setInfoText("");
        }
    }
 
    void
    SkillDashboardWidget::openConfigWindow(const std::string& name,
                                           const std::string& id,
                                           const std::string& args)
    {
 
        this->dialog->setShortcutName(name);
        this->dialog->setSkillId(id);
        this->dialog->setSkillConfig(args);
 
 
        if (this->dialog->exec() == QDialog::Accepted)
        {
            try
            {
                SkillShortcut newShortcut{
                    .shortcutName = this->dialog->getShortcutName().toStdString(),
                    .skillId = this->dialog->getSkillId().toStdString(),
                    .skillArgs = this->dialog->getSkillConfig().toStdString()};
                this->dashboardPrx->addNewShortcut(newShortcut);
            }
            catch (Ice::Exception const&)
            {
                ARMARX_WARNING << "Could not send new Shortcut." << deactivateSpam(10);
            }
            loadButtons();
        }
    }
 
    std::string
    getCurrentDateTime()
    {
        auto now = std::chrono::system_clock::now();
        std::time_t now_c = std::chrono::system_clock::to_time_t(now);
        std::tm local_tm;
        localtime_r(&now_c, &local_tm);
        std::ostringstream oss;
        oss << std::put_time(&local_tm, "%Y-%m-%d_%H-%M-%S");
        return oss.str();
    }
 
    void
    SkillDashboardWidget::exportButtons()
    {
        std::vector<SkillShortcut> shortcuts;
        try
        {
            shortcuts = this->dashboardPrx->getShortcuts();
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch default states." << deactivateSpam(10);
        }
 
        nlohmann::json j;
        for (const auto& shortcut : shortcuts)
        {
            nlohmann::json skillArgs_json = nlohmann::json::parse(shortcut.skillArgs);
 
            j["shortcuts"].push_back({{"skill_shortcut_name", shortcut.shortcutName},
                                      {"skill_id", shortcut.skillId},
                                      {"skill_args", skillArgs_json}});
        }
 
        std::string packageName = ui.packageEdit->text().toStdString();
        std::string folderName = ui.folderEdit->text().toStdString();
        std::string fileName = ui.fileNameEdit->text().toStdString();
 
        size_t pos = fileName.find("%TIMESTAMP%");
        if (pos != std::string::npos)
        {
            std::string timestamp = getCurrentDateTime();
            fileName.replace(pos, 11, timestamp); // 11 length of %TIMESTAMP%
        }
 
        std::string absoluteFilename;
        armarx::CMakePackageFinder finder(packageName);
        if (finder.packageFound())
        {
            ARMARX_INFO << "Package found...";
 
            std::string packageDataDir = finder.getDataDir();
 
            // add the data directory to the search list of ArmarXDataPath
            ArmarXDataPath::addDataPaths(packageDataDir);
            std::filesystem::create_directory(packageDataDir + "/" + folderName);
 
            std::string relativeFilename(folderName);
 
            if (ArmarXDataPath::getAbsolutePath(relativeFilename, absoluteFilename))
            {
                ARMARX_INFO << "Located file at:" << absoluteFilename;
                std::string filename = fileName + ".json";
                std::ofstream outFile(absoluteFilename + "/" + filename);
                outFile << std::setw(4) << j << std::endl;
                outFile.close();
                ARMARX_INFO << "JSON has been written";
            }
        }
    }
 
    void
    SkillDashboardWidget::loadButtons()
    {
        this->shortcutButtons.clear();
        this->configButtons.clear();
        this->deleteButtons.clear();
        std::vector<SkillShortcut> shortcuts;
        try
        {
            shortcuts = this->dashboardPrx->getShortcuts();
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch default states." << deactivateSpam(10);
        }
        clearLayout(this->shortcutLayout);
        QWidget* container = getWidget();
        QLayout* existingLayout = container->layout();
 
        for (SkillShortcut& shortcut : shortcuts)
        {
            QPushButton* button = new QPushButton(QString::fromStdString(shortcut.shortcutName));
            button->setStyleSheet("padding-right: 30px;");
 
            // Config-Button
            QToolButton* configButton = new QToolButton();
            QIcon iconConfig =
                getWidget()->style()->standardIcon(QStyle::SP_FileDialogContentsView);
            configButton->setIcon(iconConfig);
            configButton->setToolTip("Settings");
 
            // Delete-Button
            QToolButton* deleteButton = new QToolButton();
            QIcon iconDelete = getWidget()->style()->standardIcon(QStyle::QStyle::SP_TrashIcon);
            deleteButton->setIcon(iconDelete);
            deleteButton->setToolTip("Delete");
 
 
            QHBoxLayout* buttonLayout = new QHBoxLayout(button);
            buttonLayout->setContentsMargins(0, 0, 0, 0);
            buttonLayout->addStretch();
            buttonLayout->addWidget(configButton);
            buttonLayout->addWidget(deleteButton);
 
 
            this->shortcutLayout->addWidget(button);
            if (QVBoxLayout* hLayout = qobject_cast<QVBoxLayout*>(existingLayout))
            {
                hLayout->addLayout(this->shortcutLayout);
            }
 
            this->shortcutButtons[shortcut.shortcutName] = button;
            this->deleteButtons[shortcut.shortcutName] = deleteButton;
            this->configButtons[shortcut.shortcutName] = configButton;
 
            connect(button,
                    &QPushButton::clicked,
                    this,
                    [this, name = shortcut.shortcutName]() { executeSkill(name); });
            connect(configButton,
                    &QToolButton::clicked,
                    this,
                    [this, name = shortcut.shortcutName]() { editShortcut(name); });
 
            connect(deleteButton,
                    &QToolButton::clicked,
                    this,
                    [this, name = shortcut.shortcutName]() { deleteShortcut(name); });
        }
    }
 
    void
    SkillDashboardWidget::executeSkill(const std::string& name)
    {
        SkillShortcut shortcut;
        try
        {
            shortcut = this->dashboardPrx->getShortcut(name);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch shortcut." << deactivateSpam(10);
        }
 
        size_t pos = shortcut.skillId.find('/');
        std::string provider = "";
        std::string nameSkill = "";
        nlohmann::json json = nlohmann::json::parse(shortcut.skillArgs);
        aron::data::DictPtr data =
            aron::data::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject(json);
        aron::data::dto::DictPtr paramterDto = data->toAronDictDTO();
 
        if (pos != std::string::npos)
        {
            provider = shortcut.skillId.substr(0, pos);
            nameSkill = shortcut.skillId.substr(pos + 1);
            skills::manager::dto::ProviderID providerId{.providerName = provider};
 
            skills::manager::dto::SkillID skillId{.providerId = providerId, .skillName = nameSkill};
 
            char hostname[HOST_NAME_MAX];
            gethostname(hostname, HOST_NAME_MAX);
 
            skills::manager::dto::SkillExecutionRequest request{
                .skillId = skillId,
                .executorName = "Skills.Dashboard GUI (hostname: " + std::string(hostname) + ")",
                .parameters = paramterDto};
 
            try
            {
                skills::manager::dto::SkillExecutionID executionId =
                    this->managerPrx->executeSkillAsync(request);
                this->runningSkills[shortcut.shortcutName] = executionId;
                this->shortcutButtons.at(shortcut.shortcutName)->setDisabled(true);
            }
            catch (Ice::Exception const&)
            {
                ARMARX_WARNING << "Could not send execute request." << deactivateSpam(10);
            }
        }
        else
        {
            ARMARX_IMPORTANT << "Invalid SkillID";
        }
    }
 
    void
    SkillDashboardWidget::editShortcut(const std::string& name)
    {
        this->currentShortcutName = name;
 
        SkillShortcut shortcut;
        try
        {
            shortcut = this->dashboardPrx->getShortcut(name);
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not fetch shortcut." << deactivateSpam(10);
        }
        openConfigWindow(shortcut.shortcutName, shortcut.skillId, shortcut.skillArgs);
        this->currentShortcutName = "not set";
    }
 
    void
    SkillDashboardWidget::deleteShortcut(const std::string& name)
    {
        ARMARX_INFO << "delete shortcut: " << name;
        try
        {
            this->dashboardPrx->deleteShortcut(name);
            //this->shortcutButtons.erase(this->shortcutButtons.find(name));
        }
        catch (Ice::Exception const&)
        {
            ARMARX_WARNING << "Could not delete shortcut." << deactivateSpam(10);
        }
        loadButtons();
    }
 
    void
    SkillDashboardWidget::clearLayout(QLayout* layout)
    {
        if (!layout)
            return;
 
        while (QLayoutItem* item = layout->takeAt(0))
        {
            if (QWidget* widget = item->widget())
            {
                widget->deleteLater();
            }
            else if (QLayout* subLayout = item->layout())
            {
                clearLayout(subLayout);
            }
            delete item;
        }
    }
 
    QPointer<QWidget>
    SkillDashboardWidget::getCustomTitlebarWidget(QWidget* parent)
    {
        if (customToolbar)
        {
            if (parent != customToolbar->parent())
            {
                customToolbar->setParent(parent);
            }
 
            return customToolbar.data();
        }
 
        customToolbar = new QToolBar(parent);
        customToolbar->setIconSize(QSize(16, 16));
        customToolbar->addAction(editModeAction);
 
        return customToolbar.data();
    }
 
    void
    SkillDashboardWidget::editMode(bool edit)
    {
        if (edit)
        {
            for (const auto& button : this->deleteButtons)
            {
                button.second->setVisible(true);
            }
            for (const auto& button : this->configButtons)
            {
                button.second->setVisible(true);
            }
            ui.addButton->setVisible(true);
            ui.reloadButton->setVisible(true);
            ui.exportButton->setVisible(true);
        }
        else
        {
            for (const auto& button : this->deleteButtons)
            {
                button.second->setVisible(false);
            }
            for (const auto& button : this->configButtons)
            {
                button.second->setVisible(false);
            }
            ui.addButton->setVisible(false);
            ui.reloadButton->setVisible(false);
            ui.exportButton->setVisible(false);
        }
    }
 
    void
    SkillDashboardWidget::onDisconnectComponent()
    {
        this->connected.store(false);
        this->exampleTask.join();
    }
 
    void
    SkillDashboardWidget::onExitComponent()
    {
    }
 
    QPointer<QDialog>
    SkillDashboardWidget::getConfigDialog(QWidget* parent)
    {
        ARMARX_TRACE;
 
        if (not m_config_dialog)
        {
            m_config_dialog = new armarx::SimpleConfigDialog{parent};
            m_config_dialog->addProxyFinder<SkillDashboardInterfacePrx>(
                {::config_key_skilldashboard, "SkillDashboard", "*"});
            m_config_dialog->addProxyFinder<skills::manager::dti::SkillManagerInterfacePrx>(
                "SkillMemory", "", "SkillMem*");
        }
        return qobject_cast<QDialog*>(m_config_dialog);
    }
 
    void
    SkillDashboardWidget::loadSettings(QSettings* settings)
    {
        ARMARX_TRACE;
        dashboardManagerName = settings
                                   ->value(QString::fromStdString(::config_key_skilldashboard),
                                           "SkillDashboardInterface")
                                   .toString()
                                   .toStdString();
        this->skillManagerOberserverName =
            settings->value("SkillMemory", "SkillMemory").toString().toStdString();
    }
 
    void
    SkillDashboardWidget::saveSettings(QSettings* settings)
    {
        ARMARX_TRACE;
        settings->setValue(QString::fromStdString(::config_key_skilldashboard),
                           QString::fromStdString(dashboardManagerName));
        settings->setValue("SkillMemory", QString::fromStdString(this->skillManagerOberserverName));
    }
 
    void
    SkillDashboardWidget::configured()
    {
        ARMARX_TRACE;
        if (m_config_dialog)
        {
            this->dashboardManagerName = m_config_dialog->getProxyName(::config_key_skilldashboard);
            this->skillManagerOberserverName = m_config_dialog->getProxyName("SkillMemory");
        }
    }
 
 
} // namespace armarx