Example Demo Qt5 Player Control View

Table of Contents

• Description
• Prebuilt Binaries
• Source Code
  • Library
  • UI Service
  • UI Application

Description

Shows how to create an UI service or application to remote access the player interface.

Note

This is demonstration purpose only!
For please use the integrated player functionality in Qt5 ADTF XSystem UI Service.

Prebuilt Binaries

• Demo Qt5 Player Control View

Source Code

./examples/demo_adtfplugins/demo_qt5_player_control_view/

Library

demo_player_control_widget.h

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#pragma once
 
#include <plugins/player_intf.h>
#include <unordered_set>
#include <QWidget>
#include <QLabel>
#include <QSlider>
#include <QPushButton>
 
class IPlayerControlView;
 
class cPlayerControlWidget : public QWidget
{
    Q_OBJECT
 
public:
    explicit cPlayerControlWidget(QWidget* pParent, IPlayerControlView& oControlView);
    ~cPlayerControlWidget();
 
    struct tPlayerInfo
    {
        tPlayerInfo():
            bPlayerPresent(false),
            strFile(""),
            eState(adtf::services::ant::IPlayer::Closed),
            tmBegin(0),
            tmEnd(0),
            tmCurrent(0),
            eLevel(adtf::base::tADTFRunLevel::RL_Shutdown)
 
        {};
        bool bPlayerPresent;
        QString strFile;
        adtf::services::ant::IPlayer::tState eState;
        tTimeStamp tmBegin;
        tTimeStamp tmEnd;
        tTimeStamp tmCurrent;
        adtf::base::tADTFRunLevel eLevel;
    };
 
    tResult Update(const tPlayerInfo& sPlayerInfo, tTimeStamp nMinInterval = 25000);
 
private:
    tTimeStamp m_tmLastUpdate = 0;
    IPlayerControlView& m_oControlView;
 
    struct tUIElems
    {
        tUIElems() = delete;
        explicit tUIElems(QWidget* pWidget);
        virtual ~tUIElems();
        QLabel* m_pCurrentFile;
 
        QPushButton* m_pPausePlay;
        QPushButton* m_pRunStop;
        QPushButton* m_pOpen;
 
        QLabel* m_pBeginTime;
        QLabel* m_pEndTime;
        QLabel* m_pCurrentTime;
        QSlider* m_pCurrentPos;
 
        void EnableByState(const tPlayerInfo& sPlayerInfo);
        void UpdateTimes(const tPlayerInfo& sPlayerInfo);
        void Disable();
 
        tPlayerInfo m_sPlayerInfo;
    };
 
    tUIElems* m_pUI = nullptr;
    adtf::util::cFilename m_strLastFolder;
 
protected slots:
    void OnClickedPauseResume();
    void OnClickedOpen();
    void OnClickedPlayStop();
    void OnTimeValueChanged(int nValue);
};

demo_player_control_widget.cpp

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#include "demo_player_control_widget.h"
 
#include "demo_player_control_view_intf.h"
 
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGroupBox>
#include <QPushButton>
#include <QFileDialog>
#include <QLabel>
 
using namespace adtf::util;
 
#define RUN_STR  QString("Run")
#define STOP_STR QString("Stop")
 
#define PAUSE_STR QString("Pause")
#define PLAY_STR  QString("Play")
 
#define OPEN_STR QString("Open .adtfdat ...")
 
namespace
{
cString calculate_time_string(tTimeStamp tmStreamTime)
{
    char strBuf[32];
 
    int nDurationHou = (int) (tmStreamTime / 1000000 / 60 / 60);
    int nDurationMin = (int) (tmStreamTime / 1000000 / 60 - (nDurationHou * 60));
    int nDurationSec = (int) (tmStreamTime / 1000000 - (nDurationMin * 60) - (nDurationHou * 60 * 60));
    int nDurationMil =
        (int) (tmStreamTime / 1000 - (nDurationHou * 60 * 60000) - (nDurationMin * 60000) - (nDurationSec * 1000));
 
    // compiling with cl may cause warning C4996 for function 'sprintf'.
    // So on windows platforms we use the sprintf_s equivalent.
#ifdef _WIN32
    sprintf_s(strBuf, "%02d:%02d:%02d.%03d", nDurationHou, nDurationMin, nDurationSec, nDurationMil);
#else
    sprintf(strBuf, "%02d:%02d:%02d.%03d", nDurationHou, nDurationMin, nDurationSec, nDurationMil);
#endif
 
    if (nDurationHou > 24)
    {
        int nDurationDay = nDurationHou / 24;
        nDurationHou = nDurationHou - (nDurationDay * 24);
        return cString::Format("[%dd] %02d:%02d:%02d.%03d", nDurationDay, nDurationHou, nDurationMin, nDurationSec,
                               nDurationMil);
    }
 
    return cString(strBuf);
}
} // namespace
 
cPlayerControlWidget::tUIElems::tUIElems(QWidget* pWidget)
{
    QVBoxLayout* pVbox = new QVBoxLayout();
 
    QGroupBox* pGroupBox = new QGroupBox();
    pGroupBox->setMinimumHeight(70);
    pGroupBox->setMaximumHeight(70);
    QHBoxLayout* pLayout = new QHBoxLayout();
    m_pRunStop = new QPushButton(RUN_STR);
    m_pPausePlay = new QPushButton(PAUSE_STR);
    m_pOpen = new QPushButton(OPEN_STR);
    pLayout->addWidget(m_pRunStop);
    pLayout->addWidget(m_pPausePlay);
    pLayout->addWidget(m_pOpen);
    pGroupBox->setLayout(pLayout);
    pVbox->addWidget(pGroupBox);
 
    pGroupBox = new QGroupBox();
    pGroupBox->setMinimumHeight(70);
    pGroupBox->setMaximumHeight(70);
    pLayout = new QHBoxLayout();
    m_pBeginTime = new QLabel();
    m_pEndTime = new QLabel();
    pLayout->addWidget(m_pBeginTime);
    pLayout->addWidget(m_pEndTime);
    pGroupBox->setLayout(pLayout);
    pVbox->addWidget(pGroupBox);
 
    pGroupBox = new QGroupBox();
    pGroupBox->setMinimumHeight(70);
    pGroupBox->setMaximumHeight(70);
    pLayout = new QHBoxLayout();
    m_pCurrentTime = new QLabel();
    m_pCurrentPos = new QSlider(Qt::Horizontal);
    pLayout->addWidget(m_pCurrentTime);
    pLayout->addWidget(m_pCurrentPos);
    m_pCurrentPos->setRange(0, 100);
    pGroupBox->setLayout(pLayout);
    pVbox->addWidget(pGroupBox);
 
    pGroupBox = new QGroupBox();
    pLayout = new QHBoxLayout();
    m_pCurrentFile = new QLabel("");
    pLayout->addWidget(m_pCurrentFile);
    pGroupBox->setLayout(pLayout);
    pVbox->addWidget(pGroupBox);
 
    pWidget->setLayout(pVbox);
 
    Disable();
}
 
cPlayerControlWidget::tUIElems::~tUIElems() = default;
 
void cPlayerControlWidget::tUIElems::EnableByState(const tPlayerInfo& sPlayerInfo)
{
    QString strCurrentFile = sPlayerInfo.strFile;
    ;
    strCurrentFile.detach();
    bool bFileNameSet = !strCurrentFile.isEmpty();
 
    if (strCurrentFile.count() > 40)
    {
        m_pCurrentFile->setText("..." + strCurrentFile.right(37));
    }
    else
    {
        m_pCurrentFile->setText(strCurrentFile);
    }
    strCurrentFile.replace(",", "\n");
    m_pCurrentFile->setToolTip(strCurrentFile);
 
    if (sPlayerInfo.eState == adtf::services::ant::IPlayer::Closed)
    {
        if (bFileNameSet)
        {
            m_pRunStop->setEnabled(true);
            m_pRunStop->setText(RUN_STR);
        }
        else
        {
            m_pRunStop->setEnabled(false);
            m_pRunStop->setText(RUN_STR);
        }
 
        m_pPausePlay->setEnabled(false);
        m_pPausePlay->setText(PAUSE_STR);
 
        m_pCurrentPos->setEnabled(false);
    }
    else if (sPlayerInfo.eState == adtf::services::ant::IPlayer::Streaming)
    {
        m_pRunStop->setEnabled(true);
        m_pRunStop->setText(STOP_STR);
 
        m_pPausePlay->setEnabled(true);
        m_pPausePlay->setText(PAUSE_STR);
 
        m_pCurrentPos->setEnabled(true);
        UpdateTimes(sPlayerInfo);
    }
    else if (sPlayerInfo.eState == adtf::services::ant::IPlayer::Paused)
    {
        if (sPlayerInfo.eLevel < adtf::base::tADTFRunLevel::RL_Running)
        {
            m_pRunStop->setEnabled(true);
            m_pRunStop->setText(RUN_STR);
 
            m_pPausePlay->setEnabled(false);
            m_pPausePlay->setText(PLAY_STR);
        }
        else
        {
            m_pRunStop->setEnabled(true);
            m_pRunStop->setText(STOP_STR);
 
            m_pPausePlay->setEnabled(true);
            m_pPausePlay->setText(PLAY_STR);
        }
 
        m_pCurrentPos->setEnabled(true);
        UpdateTimes(sPlayerInfo);
    }
    m_pOpen->setEnabled(true);
 
    m_sPlayerInfo = sPlayerInfo;
}
 
void cPlayerControlWidget::tUIElems::UpdateTimes(const tPlayerInfo& sPlayerInfo)
{
    if (sPlayerInfo.tmCurrent >= sPlayerInfo.tmBegin && sPlayerInfo.tmCurrent < sPlayerInfo.tmEnd)
    {
        QString strCurrent = calculate_time_string(sPlayerInfo.tmCurrent).GetPtr();
        m_pCurrentTime->setText(strCurrent);
    }
    else
    {
        QString strCurrent = calculate_time_string(0).GetPtr();
        m_pCurrentTime->setText(strCurrent);
    }
 
    QString strBegin = calculate_time_string(sPlayerInfo.tmBegin).GetPtr();
    QString strEnd = calculate_time_string(sPlayerInfo.tmEnd).GetPtr();
    m_pBeginTime->setText(strBegin);
    m_pEndTime->setText(strEnd);
 
    tTimeStamp tmDiff = sPlayerInfo.tmEnd - sPlayerInfo.tmBegin;
    if (tmDiff < 0)
    {
        tmDiff = 0;
    }
    int nPos = 0;
    if (tmDiff != 0)
    {
        nPos = ((sPlayerInfo.tmCurrent - sPlayerInfo.tmBegin) * 100) / tmDiff;
    }
    m_pCurrentPos->setValue(nPos);
}
 
void cPlayerControlWidget::tUIElems::Disable()
{
    m_pRunStop->setEnabled(false);
    m_pRunStop->setText(RUN_STR);
    m_pPausePlay->setEnabled(false);
    m_pPausePlay->setText(PAUSE_STR);
    m_pOpen->setEnabled(false);
 
    m_pCurrentPos->setEnabled(false);
    m_pCurrentPos->setValue(0);
 
    m_pCurrentTime->setText(calculate_time_string(0).GetPtr());
    m_pBeginTime->setText(calculate_time_string(0).GetPtr());
    m_pEndTime->setText(calculate_time_string(0).GetPtr());
 
    m_pCurrentFile->setText("No Player found");
}
 
cPlayerControlWidget::cPlayerControlWidget(QWidget* pParent, IPlayerControlView& oControl):
    QWidget(pParent), m_oControlView(oControl)
{
    m_pUI = new tUIElems(this);
    QObject::connect(m_pUI->m_pPausePlay, SIGNAL(clicked()), this, SLOT(OnClickedPauseResume()));
    QObject::connect(m_pUI->m_pOpen, SIGNAL(clicked()), this, SLOT(OnClickedOpen()));
    QObject::connect(m_pUI->m_pRunStop, SIGNAL(clicked()), this, SLOT(OnClickedPlayStop()));
    QObject::connect(m_pUI->m_pCurrentPos, SIGNAL(valueChanged(int)), this, SLOT(OnTimeValueChanged(int)));
}
 
cPlayerControlWidget::~cPlayerControlWidget()
{
    delete m_pUI;
}
 
tResult cPlayerControlWidget::Update(const tPlayerInfo& sPlayerInfo, tTimeStamp nMinInterval)
{
    // Use 25ms update interval to limit CPU usage
    if (cHighResTimer::GetTime() - m_tmLastUpdate < nMinInterval)
    {
        RETURN_ERROR(ERR_NOERROR);
    }
 
    setUpdatesEnabled(false);
 
    if (sPlayerInfo.bPlayerPresent)
    {
        m_pUI->EnableByState(sPlayerInfo);
    }
    else
    {
        m_pUI->Disable();
    }
 
    setUpdatesEnabled(true);
 
    m_tmLastUpdate = cHighResTimer::GetTime();
    RETURN_NOERROR;
}
 
void cPlayerControlWidget::OnClickedPauseResume()
{
    if (m_pUI->m_pPausePlay->text() == PAUSE_STR)
    {
        m_oControlView.Pause();
    }
    else
    {
        m_oControlView.Play();
    }
}
 
void cPlayerControlWidget::OnClickedOpen()
{
    if (m_strLastFolder.IsEmpty())
    {
        cMacroResolver oRes;
        m_strLastFolder = oRes.Resolve("$(HOME)");
    }
    QString strFileName = QFileDialog::getOpenFileName(this, tr("Open ADTF DAT File"), m_strLastFolder.GetPtr(),
                                                       tr("ADTF DAT File (*.adtfdat *dat)"));
    if (!strFileName.isEmpty())
    {
        m_strLastFolder = static_cast<const char*>(strFileName.toUtf8());
        m_strLastFolder = m_strLastFolder.GetPath();
        m_oControlView.OpenFile(strFileName);
    }
}
 
void cPlayerControlWidget::OnClickedPlayStop()
{
    if (m_pUI->m_pRunStop->text() == RUN_STR)
    {
        m_oControlView.Run();
    }
    else
    {
        m_oControlView.Stop();
    }
}
 
void cPlayerControlWidget::OnTimeValueChanged(int nValue)
{
    if (updatesEnabled() && m_pUI->m_pCurrentPos->isSliderDown())
    {
        tTimeStamp tmTimeDiff = (m_pUI->m_sPlayerInfo.tmEnd - m_pUI->m_sPlayerInfo.tmBegin);
        if (tmTimeDiff < 0)
        {
            tmTimeDiff = 0;
        }
 
        tmTimeDiff = (nValue * tmTimeDiff) / 100 + m_pUI->m_sPlayerInfo.tmBegin;
 
        if (tmTimeDiff <= m_pUI->m_sPlayerInfo.tmEnd)
        {
            m_oControlView.SeekToTime(tmTimeDiff);
        }
        else
        {
            m_oControlView.SeekToTime(m_pUI->m_sPlayerInfo.tmEnd);
        }
    }
}

UI Service

demo_player_control_view.h

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#pragma once
 
#include <adtf_systemsdk.h>
#include <adtf_ui.h>
#include <plugins/player_intf.h>
 
#include <demo_player_control_view_intf.h>
 
class cPlayerControlWidget;
 
#ifndef ADTF_EXAMPLES_CID
    #define ADTF_EXAMPLES_CID ".local.cid"
#endif
 
class cPlayerControlViewSrv : public adtf::ui::cQtUIService, public IPlayerControlView
{
public:
    ADTF_CLASS_ID_NAME(cPlayerControlViewSrv,
                       "demo_qt_player_control_view.ui_service" ADTF_EXAMPLES_CID,
                       "Demo Qt5 Player Control View");
    ADTF_CLASS_DEPENDENCIES(REQUIRE_INTERFACE(adtf::ui::IQtXSystem), REQUIRE_INTERFACE(adtf::services::IPlayer));
 
protected:
    cPlayerControlWidget* m_pWidget;
    adtf::ucom::object_ptr<adtf::services::IPlayer> m_pPlayer;
 
    tTimeStamp m_tmLastUpdate = 0;
    tTimeStamp m_tmMinInterval = 200000;
 
public:
    cPlayerControlViewSrv();
    ~cPlayerControlViewSrv() override;
 
    tResult ServiceEvent(int nEventId,
                         uint32_t ui32Param1 = 0,
                         uint32_t ui32Param2 = 0,
                         void* pvData = nullptr,
                         int szData = 0) override;
 
protected:
    QWidget* CreateView() override;
    void ReleaseView() override;
    tResult OnIdle() override;
 
public:
    void OpenFile(const QString& strFile) override;
    void Run() override;
    void Pause() override;
    void Play() override;
    void Stop() override;
    void SeekToTime(tTimeStamp tmTime) override;
};

demo_player_control_view.cpp

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#include "demo_player_control_view.h"
 
#include <demo_player_control_widget.h>
 
ADTF_PLUGIN("Demo Qt5 Player Control View Plugin", cPlayerControlViewSrv)
 
#ifdef GetObject
    #undef GetObject
#endif
 
#ifdef GetCurrentTime
    #undef GetCurrentTime
#endif
 
namespace
{
void show_result(QWidget* pWidget, tResult nRes)
{
    LOG_RESULT(nRes);
    QMessageBox::critical(
        pWidget,
        adtf::util::cString::Format("Error %d - [%s] ", nRes.GetErrorCode().value, nRes.GetErrorString()).GetPtr(),
        nRes.GetDescription());
}
 
tResult local_set_run_level(QWidget* pWidget, adtf::base::tADTFRunLevel eLevel)
{
    tResult nRes = _runtime->SetRunLevel(eLevel);
    if (IS_FAILED(nRes))
    {
        show_result(pWidget, nRes);
    }
    return nRes;
}
} // namespace
 
cPlayerControlViewSrv::cPlayerControlViewSrv()
{
    m_strTitle = adtf::util::cString("Demo Player Control");
    m_pWidget = nullptr;
    SetDefaultRunlevel(adtf::base::tADTFRunLevel::RL_FilterGraph);
 
    // sets a short description for the component
    SetDescription(
        "Use this UI Service to extend the ADTF System with a User Interface to control the ADTFDAT File Player.");
 
    // set help link to jump to documentation from ADTF Configuration Editor
    SetHelpLink("$(ADTF_QT5_DIR)/doc/html/page_demo_qt5_player_control_view.html");
}
 
cPlayerControlViewSrv::~cPlayerControlViewSrv() = default;
 
QWidget* cPlayerControlViewSrv::CreateView()
{
    m_pWidget = new cPlayerControlWidget(nullptr, *this);
    return m_pWidget;
}
 
void cPlayerControlViewSrv::ReleaseView()
{
    delete m_pWidget;
    m_pWidget = nullptr;
}
 
tResult cPlayerControlViewSrv::OnIdle()
{
    RETURN_IF_POINTER_NULL(m_pWidget);
 
    if (adtf::util::cHighResTimer::GetTime() - m_tmLastUpdate < m_tmMinInterval)
    {
        RETURN_NOERROR;
    }
 
    if (m_pWidget)
    {
        cPlayerControlWidget::tPlayerInfo sInfo;
        if (m_pPlayer)
        {
            sInfo.bPlayerPresent = true;
            sInfo.eState = m_pPlayer->GetCurrentState();
            sInfo.eLevel = static_cast<adtf::base::tADTFRunLevel>(_runtime->GetRunLevel());
 
            // do not check ret val, they are intialized already
            m_pPlayer->GetTimeRange(sInfo.tmBegin, sInfo.tmEnd);
 
            sInfo.tmCurrent = m_pPlayer->GetCurrentTime();
            // do not check ret val, they are intialized already
            m_pPlayer->GetCurrentFileNames(adtf_string_intf(sInfo.strFile));
        }
 
        m_pWidget->Update(sInfo);
    }
    m_tmLastUpdate = adtf::util::cHighResTimer::GetTime();
    RETURN_NOERROR;
}
 
tResult cPlayerControlViewSrv::ServiceEvent(
    int nEventId, uint32_t ui32Param1, uint32_t ui32Param2, void* pvData, int szData)
{
    if (nEventId == IService::SE_ChangeRunLevel)
    {
        adtf::base::tADTFRunLevel eLevel = static_cast<adtf::base::tADTFRunLevel>(ui32Param1);
        if (ui32Param2 == adtf::ucom::IRuntime::CRLF_PostIncrementLevel ||
            ui32Param2 == adtf::ucom::IRuntime::CRLF_PostDecrementLevel)
        {
            // we do not synchronize this since ServiceEvent is always called within main context!
            // OnIdle is within GUI context too
            _runtime->GetObject(m_pPlayer);
        }
        else if (ui32Param2 == adtf::ucom::IRuntime::CRLF_PreDecrementLevel)
        {
            if (eLevel == adtf::base::tADTFRunLevel::RL_Running)
            {
                Pause();
            }
        }
    }
    return adtf::ui::cQtUIService::ServiceEvent(nEventId, ui32Param1, ui32Param2, pvData, szData);
}
 
void cPlayerControlViewSrv::OpenFile(const QString& strFile)
{
    if (m_pPlayer)
    {
        adtf::base::tADTFRunLevel eOldLevel = static_cast<adtf::base::tADTFRunLevel>(_runtime->GetRunLevel());
        local_set_run_level(m_pWidget, adtf::base::tADTFRunLevel::RL_Session);
        if (m_pPlayer)
        {
            tResult nRes = m_pPlayer->Open(static_cast<const char*>(strFile.toUtf8()), true);
            if (IS_FAILED(nRes))
            {
                show_result(m_pWidget, nRes);
            }
            else
            {
                local_set_run_level(m_pWidget, eOldLevel);
            }
        }
    }
}
 
void cPlayerControlViewSrv::Run()
{
    local_set_run_level(m_pWidget, adtf::base::tADTFRunLevel::RL_Running);
}
 
void cPlayerControlViewSrv::Pause()
{
    if (m_pPlayer)
    {
        m_pPlayer->Pause();
    }
}
 
void cPlayerControlViewSrv::Play()
{
    if (m_pPlayer)
    {
        m_pPlayer->Play();
    }
}
 
void cPlayerControlViewSrv::Stop()
{
    local_set_run_level(m_pWidget, adtf::base::tADTFRunLevel::RL_FilterGraph);
}
 
void cPlayerControlViewSrv::SeekToTime(tTimeStamp tmTime)
{
    if (m_pPlayer)
    {
        m_pPlayer->SeekToTime(tmTime);
    }
}

UI Application

demo_player_control_app.h

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#pragma once
 
#include <adtfremotesdk/rpc_object_client.h>
#include <adtfremotesdk/adtf_remote_system.h>
#include <adtfremotesdk/adtf_remote_system_intf.h>
#include <adtfremotesdk/adtf_remote_player_intf.h>
 
#include <demo_player_control_view_intf.h>
 
#include <a_utils/base/types.h>
#include <a_utils/core/string.h>
 
#include <QTimer>
#include <QPushButton>
#include <QLineEdit>
 
#include <memory>
 
class cPlayerControlWidget;
 
class cPlayerControlAppWindow : public QWidget, public IPlayerControlView
{
    Q_OBJECT
private:
    cPlayerControlWidget* m_pWidget;
    tTimeStamp m_tmMinInterval = 200000;
 
    adtf::util::cString m_strADTFControlURL;
    std::unique_ptr<adtf::remote::cADTFRemoteSystem> m_pSystem = nullptr;
 
    QTimer m_oTimer;
    QPushButton* m_pConnectButton;
    QLineEdit* m_pURL;
 
public:
    explicit cPlayerControlAppWindow(const adtf::util::cString& strADTFControlURL);
    ~cPlayerControlAppWindow();
    tResult Connect();
 
public:
    void OpenFile(const QString& strFile) override;
    void Run() override;
    void Pause() override;
    void Play() override;
    void Stop() override;
    void SeekToTime(tTimeStamp tmTime) override;
 
public slots:
    void OnTimer();
    void OnConnect();
 
private:
    bool GetSystem(adtf::remote::rpc_object_client_ptr<adtf::remote::ISystem>& pSystem);
    bool GetPlayer(adtf::remote::rpc_object_client_ptr<adtf::remote::IPlayer>& pPlayer);
};

demo_player_control_app.cpp

 
/*
 * This file depends on Qt which is licensed under LGPLv3.
 * See ADTF_DIR/3rdparty/qt5 and doc/license for detailed information.
 */
 
#include "demo_player_control_app.h"
 
#include "demo_player_control_widget.h"
 
#include <QApplication>
#include <QMessageBox>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QVBoxLayout>
 
#ifdef GetCurrentTime
    #undef GetCurrentTime
#endif // GetCurrentTime
 
 
void DisplayError(QWidget* pWidget, tResult nRes)
{
    LOG_RESULT(nRes);
    QMessageBox::critical(
        pWidget,
        adtf::util::cString::Format("Error %d - [%s] ", nRes.GetErrorCode().value, nRes.GetErrorString()).GetPtr(),
        nRes.GetDescription());
}
 
tResult remote_set_run_level(QWidget* pWidget, adtf::remote::ISystem* pSystem, adtf::base::tADTFRunLevel eLevel)
{
    tResult nRes = pSystem->SetRunlevel(eLevel);
    if (IS_FAILED(nRes))
    {
        DisplayError(pWidget, nRes);
    }
    return nRes;
}
 
cPlayerControlAppWindow::cPlayerControlAppWindow(const adtf::util::cString& strADTFControlURL):
    QWidget(), m_strADTFControlURL(strADTFControlURL)
{
    QGroupBox* pGroupBox = new QGroupBox();
    pGroupBox->setMaximumHeight(70);
    pGroupBox->setMinimumWidth(70);
    QHBoxLayout* pHLayout = new QHBoxLayout();
    m_pConnectButton = new QPushButton("Connect");
    m_pURL = new QLineEdit(strADTFControlURL.GetPtr(), nullptr);
    pHLayout->setSpacing(1);
    pHLayout->addWidget(m_pConnectButton);
    pHLayout->addWidget(m_pURL);
    pGroupBox->setLayout(pHLayout);
 
    QVBoxLayout* pVLayout = new QVBoxLayout();
    m_pWidget = new cPlayerControlWidget(nullptr, *this);
    pVLayout->addWidget(pGroupBox);
    pVLayout->addWidget(m_pWidget);
 
    setLayout(pVLayout);
    setWindowTitle("Demo Player Control App ... ");
 
    QObject::connect(&m_oTimer, SIGNAL(timeout()), this, SLOT(OnTimer()));
    QObject::connect(m_pConnectButton, SIGNAL(clicked()), this, SLOT(OnConnect()));
 
    m_oTimer.setInterval(m_tmMinInterval / 1000);
    m_oTimer.start();
}
 
cPlayerControlAppWindow::~cPlayerControlAppWindow()
{
    m_oTimer.stop();
}
 
void cPlayerControlAppWindow::OnConnect()
{
    tResult nRes = Connect();
    if (nRes.IsFailed())
    {
        DisplayError(this, nRes);
    }
}
 
void cPlayerControlAppWindow::OnTimer()
{
    cPlayerControlWidget::tPlayerInfo sInfo;
    bool bIsConnected = false;
    if (m_pSystem)
    {
        bIsConnected = IS_OK(m_pSystem->Ping());
        if (bIsConnected)
        {
            adtf::remote::rpc_object_client_ptr<adtf::remote::ISystem> pSystem;
            if (IS_OK(m_pSystem->GetObjectClient(adtf::remote::ISystem::DEFAULT_NAME, pSystem)))
            {
                adtf::remote::rpc_object_client_ptr<adtf::remote::IPlayer> pPlayer;
                if (IS_OK(m_pSystem->GetObjectClient(adtf::remote::IPlayer::DEFAULT_NAME, pPlayer)))
                {
                    sInfo.bPlayerPresent = true;
                    sInfo.eState = static_cast<adtf::services::IPlayer::tState>(pPlayer->GetState());
                    sInfo.eLevel = static_cast<adtf::base::tADTFRunLevel>(pSystem->GetRunlevel());
 
                    // do not check ret val, they are intialized already
                    sInfo.tmBegin = pPlayer->GetFirstTime();
                    sInfo.tmEnd = pPlayer->GetLastTime();
 
                    sInfo.tmCurrent = pPlayer->GetCurrentTime();
                    // do not check ret val, they are intialized already
                    sInfo.strFile = pPlayer->GetCurrentFileNames();
                }
            }
            m_oTimer.setInterval(m_tmMinInterval / 1000);
        }
        else
        {
            m_oTimer.setInterval(1000);
        }
    }
    else
    {
        bIsConnected = IS_OK(Connect());
    }
 
    setUpdatesEnabled(false);
    if (bIsConnected)
    {
        QString strTitle = "Demo Player Control App ... connected to ";
        strTitle.append(m_strADTFControlURL);
        setWindowTitle(strTitle);
    }
    else
    {
        QString strTitle = "Demo Player Control App ... NOT CONNECTED TO ";
        strTitle.append(m_strADTFControlURL);
        setWindowTitle(strTitle);
    }
    m_pWidget->Update(sInfo);
    setUpdatesEnabled(true);
}
 
tResult cPlayerControlAppWindow::Connect()
{
    m_strADTFControlURL = static_cast<const char*>(m_pURL->text().toUtf8());
    if (!m_pSystem)
    {
        m_pSystem.reset(new adtf::remote::cADTFRemoteSystem(m_strADTFControlURL));
    }
    else if (!m_pSystem->GetHostURL().IsEqual(m_strADTFControlURL))
    {
        // connected to wrong remote system, re-establish connection
        m_pSystem.reset(new adtf::remote::cADTFRemoteSystem(m_strADTFControlURL));
    }
 
    if (!m_pSystem)
    {
        RETURN_ERROR_DESC(ERR_NOT_CONNECTED, "ADTF unreachable");
    }
 
    return m_pSystem->Ping();
}
 
bool cPlayerControlAppWindow::GetSystem(adtf::remote::rpc_object_client_ptr<adtf::remote::ISystem>& pSystem)
{
    if (m_pSystem)
    {
        return IS_OK(m_pSystem->GetObjectClient(adtf::remote::ISystem::DEFAULT_NAME, pSystem));
    }
    return false;
}
 
bool cPlayerControlAppWindow::GetPlayer(adtf::remote::rpc_object_client_ptr<adtf::remote::IPlayer>& pPlayer)
{
    if (m_pSystem)
    {
        return IS_OK(m_pSystem->GetObjectClient(adtf::remote::IPlayer::DEFAULT_NAME, pPlayer));
    }
    return false;
}
 
void cPlayerControlAppWindow::OpenFile(const QString& strFile)
{
    adtf::remote::rpc_object_client_ptr<adtf::remote::ISystem> pSystem;
    adtf::remote::rpc_object_client_ptr<adtf::remote::IPlayer> pPlayer;
    if (GetSystem(pSystem) && GetPlayer(pPlayer))
    {
        adtf::base::tADTFRunLevel eOldLevel = static_cast<adtf::base::tADTFRunLevel>(pSystem->GetRunlevel());
        remote_set_run_level(this, &pSystem.GetInterface(), adtf::base::tADTFRunLevel::RL_Session);
 
        tResult nRes = pPlayer->Open(static_cast<const char*>(strFile.toUtf8()));
        if (IS_FAILED(nRes))
        {
            DisplayError(m_pWidget, nRes);
        }
        else
        {
            remote_set_run_level(m_pWidget, &pSystem.GetInterface(), eOldLevel);
        }
    }
}
 
void cPlayerControlAppWindow::Run()
{
    adtf::remote::rpc_object_client_ptr<adtf::remote::ISystem> pSystem;
    if (GetSystem(pSystem))
    {
        tResult nRes = remote_set_run_level(m_pWidget, &pSystem.GetInterface(), adtf::base::tADTFRunLevel::RL_Running);
    }
}
 
void cPlayerControlAppWindow::Pause()
{
    adtf::remote::rpc_object_client_ptr<adtf::remote::IPlayer> pPlayer;
    if (GetPlayer(pPlayer))
    {
        pPlayer->Pause();
    }
}
void cPlayerControlAppWindow::Play()
{
    adtf::remote::rpc_object_client_ptr<adtf::remote::IPlayer> pPlayer;
    if (GetPlayer(pPlayer))
    {
        pPlayer->Play();
    }
}
 
void cPlayerControlAppWindow::Stop()
{
    adtf::remote::rpc_object_client_ptr<adtf::remote::ISystem> pSystem;
    if (GetSystem(pSystem))
    {
        remote_set_run_level(m_pWidget, &pSystem.GetInterface(), adtf::base::tADTFRunLevel::RL_FilterGraph);
    }
}
 
void cPlayerControlAppWindow::SeekToTime(tTimeStamp tmTime)
{
    adtf::remote::rpc_object_client_ptr<adtf::remote::IPlayer> pPlayer;
    if (GetPlayer(pPlayer))
    {
        pPlayer->SeekToTime(tmTime);
    }
}
 
int main(int argc, char* argv[])
{
    adtf::util::cCommandLine oCommand(argc, (const char**) argv);
 
    adtf::util::cString strURL = oCommand.GetProperty("control-url");
    if (strURL.IsEmpty())
    {
        strURL = adtf::remote::cADTFRemoteSystem::DEFAULT_HOST_URL;
    }
    QApplication app(argc, argv);
    cPlayerControlAppWindow oMyApp(strURL);
    oMyApp.show();
    return app.exec();
}