cxAcquisitionServiceProxy.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 "cxAcquisitionServiceProxy.h"

#include <boost/bind.hpp>
#include <ctkPluginContext.h>
#include "cxNullDeleter.h"
#include "cxLogger.h"

namespace cx
{

//AcquisitionServicePtr AcquisitionServiceProxy::create(ctkPluginContext *pluginContext)
//{
//      return AcquisitionServicePtr(new AcquisitionServiceProxy(pluginContext));
//}

AcquisitionServiceProxy::AcquisitionServiceProxy(ctkPluginContext *context) :
        mPluginContext(context),
        mAcquisitionService(AcquisitionService::getNullObject())
{
        this->initServiceListener();
}

void AcquisitionServiceProxy::initServiceListener()
{
        mServiceListener.reset(new ServiceTrackerListener<AcquisitionService>(
                                                                 mPluginContext,
                                                                 boost::bind(&AcquisitionServiceProxy::onServiceAdded, this, _1),
                                                                 boost::function<void (AcquisitionService*)>(),
                                                                 boost::bind(&AcquisitionServiceProxy::onServiceRemoved, this, _1)
                                                                 ));
        mServiceListener->open();
}
void AcquisitionServiceProxy::onServiceAdded(AcquisitionService* service)
{
        mAcquisitionService.reset(service, null_deleter());

        connect(service, &AcquisitionService::started, this, &AcquisitionService::started);
        connect(service, &AcquisitionService::cancelled, this, &AcquisitionService::cancelled);
        connect(service, &AcquisitionService::stateChanged, this, &AcquisitionService::stateChanged);
        connect(service, &AcquisitionService::usReadinessChanged, this, &AcquisitionService::usReadinessChanged);
        connect(service, &AcquisitionService::acquisitionStopped, this, &AcquisitionService::acquisitionStopped);
        connect(service, &AcquisitionService::recordedSessionsChanged, this, &AcquisitionService::recordedSessionsChanged);

        connect(service, &AcquisitionService::acquisitionDataReady, this, &AcquisitionService::acquisitionDataReady);
        connect(service, &AcquisitionService::saveDataCompleted, this, &AcquisitionService::saveDataCompleted);

        if(mAcquisitionService->isNull())
                reportWarning("AcquisitionServiceProxy::onServiceAdded mAcquisitionService->isNull()");

        emit stateChanged();
        emit usReadinessChanged();
        emit recordedSessionsChanged();
}

void AcquisitionServiceProxy::onServiceRemoved(AcquisitionService *service)
{
        disconnect(service, &AcquisitionService::started, this, &AcquisitionService::started);
        disconnect(service, &AcquisitionService::cancelled, this, &AcquisitionService::cancelled);
        disconnect(service, &AcquisitionService::stateChanged, this, &AcquisitionService::stateChanged);
        disconnect(service, &AcquisitionService::usReadinessChanged, this, &AcquisitionService::usReadinessChanged);
        disconnect(service, &AcquisitionService::acquisitionStopped, this, &AcquisitionService::acquisitionStopped);
        disconnect(service, &AcquisitionService::recordedSessionsChanged, this, &AcquisitionService::recordedSessionsChanged);

        disconnect(service, &AcquisitionService::acquisitionDataReady, this, &AcquisitionService::acquisitionDataReady);
        disconnect(service, &AcquisitionService::saveDataCompleted, this, &AcquisitionService::saveDataCompleted);

        mAcquisitionService = AcquisitionService::getNullObject();

        emit stateChanged();
        emit usReadinessChanged();
        emit recordedSessionsChanged();
}

bool AcquisitionServiceProxy::isNull()
{
        return mAcquisitionService->isNull();
}

RecordSessionPtr AcquisitionServiceProxy::getLatestSession()
{
        return mAcquisitionService->getLatestSession();
}

std::vector<RecordSessionPtr> AcquisitionServiceProxy::getSessions()
{
        return mAcquisitionService->getSessions();
}

bool AcquisitionServiceProxy::isReady(TYPES context) const
{
        return mAcquisitionService->isReady(context);
}

QString AcquisitionServiceProxy::getInfoText(TYPES context) const
{
        return mAcquisitionService->getInfoText(context);
}

AcquisitionService::STATE AcquisitionServiceProxy::getState() const
{
        return mAcquisitionService->getState();
}

void AcquisitionServiceProxy::startRecord(TYPES context, QString category, RecordSessionPtr session)
{
        mAcquisitionService->startRecord(context, category, session);
}

void AcquisitionServiceProxy::stopRecord()
{
        mAcquisitionService->stopRecord();
}

void AcquisitionServiceProxy::cancelRecord()
{
        mAcquisitionService->cancelRecord();
}

void AcquisitionServiceProxy::startPostProcessing()
{
        mAcquisitionService->startPostProcessing();
}

void AcquisitionServiceProxy::stopPostProcessing()
{
        mAcquisitionService->stopPostProcessing();
}

int AcquisitionServiceProxy::getNumberOfSavingThreads() const
{
        return mAcquisitionService->getNumberOfSavingThreads();
}

} //cx