cxVideoServiceProxy.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#include "cxVideoServiceProxy.h"
 
#include <boost/bind.hpp>
#include <ctkPluginContext.h>
#include "cxNullDeleter.h"
 
#include "cxStreamerService.h"
//#include "cxTypeConversions.h"
 
namespace cx
{
 
VideoServicePtr VideoServiceProxy::create(ctkPluginContext *pluginContext)
{
        return VideoServicePtr(new VideoServiceProxy(pluginContext));
}
 
VideoServiceProxy::VideoServiceProxy(ctkPluginContext *pluginContext) :
        mPluginContext(pluginContext),
        mVideoService(VideoService::getNullObject())
{
        this->initServiceListener();
}
 
void VideoServiceProxy::initServiceListener()
{
        mVideoServiceListener.reset(new ServiceTrackerListener<VideoService>(
                                                                 mPluginContext,
                                                                 boost::bind(&VideoServiceProxy::onVideoServiceAdded, this, _1),
                                                                 boost::function<void (VideoService*)>(),
                                                                 boost::bind(&VideoServiceProxy::onVideoServiceRemoved, this, _1)
                                                                 ));
        mVideoServiceListener->open();
}
 
void VideoServiceProxy::onVideoServiceAdded(VideoService* service)
{
        mVideoService.reset(service, null_deleter());
 
        connect(service, &VideoService::connected, this, &VideoService::connected);
        connect(service, &VideoService::connectionMethodChanged, this, &VideoService::connectionMethodChanged);
        connect(service, &VideoService::activeVideoSourceChanged, this, &VideoService::activeVideoSourceChanged);
        connect(service, &VideoService::fps, this, &VideoService::fps);
 
        emit activeVideoSourceChanged();
}
 
void VideoServiceProxy::onVideoServiceRemoved(VideoService *service)
{
        disconnect(service, &VideoService::connected, this, &VideoService::connected);
        disconnect(service, &VideoService::connectionMethodChanged, this, &VideoService::connectionMethodChanged);
        disconnect(service, &VideoService::activeVideoSourceChanged, this, &VideoService::activeVideoSourceChanged);
        disconnect(service, &VideoService::fps, this, &VideoService::fps);
 
        mVideoService = VideoService::getNullObject();
 
        emit connected(false);
        emit activeVideoSourceChanged();
}
 
bool VideoServiceProxy::isNull()
{
        return mVideoService->isNull();
}
 
StreamerServicePtr VideoServiceProxy::getStreamerService(QString uid)
{
    return mVideoService->getStreamerService(uid);
}
 
QList<StreamerServicePtr> VideoServiceProxy::getStreamerServices()
{
        return mVideoService->getStreamerServices();
}
 
void VideoServiceProxy::setActiveVideoSource(QString uid)
{
        mVideoService->setActiveVideoSource(uid);
}
 
VideoSourcePtr VideoServiceProxy::getActiveVideoSource()
{
        return mVideoService->getActiveVideoSource();
}
 
std::vector<VideoSourcePtr> VideoServiceProxy::getVideoSources()
{
        return mVideoService->getVideoSources();
}
 
void VideoServiceProxy::setConnectionMethod(QString connectionMethod)
{
        mVideoService->setConnectionMethod(connectionMethod);
}
 
QString VideoServiceProxy::getConnectionMethod()
{
        return mVideoService->getConnectionMethod();
}
 
void VideoServiceProxy::openConnection()
{
        mVideoService->openConnection();
}
 
void VideoServiceProxy::closeConnection()
{
        mVideoService->closeConnection();
}
 
bool VideoServiceProxy::isConnected() const
{
        return mVideoService->isConnected();
}
 
void VideoServiceProxy::setPlaybackMode(PlaybackTimePtr controller)
{
        mVideoService->setPlaybackMode(controller);
}
 
std::vector<TimelineEvent> VideoServiceProxy::getPlaybackEvents()
{
    return mVideoService->getPlaybackEvents();
}
 
 
 
} //cx