cxReporterThread.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 "cxReporterThread.h"
#include "cxReporter.h"
#include "cxLogger.h"
#include <QtGlobal>
#include <iostream>
#include "boost/bind.hpp"
#include "boost/shared_ptr.hpp"
#include <QString>
#include <QMutex>
#include <QSound>
#include <QDir>
#include <QTextStream>
#include <QTimer>
#include "cxTime.h"
#include "cxMessageListener.h"

#include "cxLogQDebugRedirecter.h"
#include "cxLogIOStreamRedirecter.h"
#include "cxReporterMessageRepository.h"
#include "cxTime.h"
#include "cxLogFile.h"

namespace cx
{

ReporterThread::ReporterThread(QObject *parent) :
        LogThread(parent)
{
        qInstallMessageHandler(convertQtMessagesToCxMessages);
        qRegisterMetaType<Message>("Message");

        connect(this, &LogThread::emittedMessage, this, &ReporterThread::onMessageEmitted);

        // make sure streams are closed properly before reconnecting.
        mCout.reset();
        mCerr.reset();

        mCout.reset(new SingleStreamerImpl(std::cout, mlCOUT));
        mCerr.reset(new SingleStreamerImpl(std::cerr, mlCERR));
}

ReporterThread::~ReporterThread()
{
        qInstallMessageHandler(0);
        mCout.reset();
        mCerr.reset();
}

bool ReporterThread::initializeLogFile(LogFile file)
{
        QString filename = file.getFilename();
        if (mInitializedFiles.contains(filename))
                return true;

        mInitializedFiles << filename;

        file.writeHeader();

        if (!file.isWritable())
        {
                this->processMessage(Message("Failed to open log file " + filename, mlERROR));
                return false;
        }

        return true;
}

void ReporterThread::executeSetLoggingFolder(QString absoluteLoggingFolderPath)
{
        mLogPath = absoluteLoggingFolderPath;

        QFileInfo(mLogPath+"/").absoluteDir().mkpath(".");

//      this->initializeLogFile(this->getFilenameForChannel("console"));
//      this->initializeLogFile(this->getFilenameForChannel("all"));

        this->initializeLogFile(LogFile::fromChannel(mLogPath, "console"));
        this->initializeLogFile(LogFile::fromChannel(mLogPath, "all"));
}

void ReporterThread::logMessage(Message msg)
{
        // send in calling thread- this helps if the app
        // is about to crash and we need debug info.
        this->sendToCout(msg);

        QMetaObject::invokeMethod(this, "processMessage",
                                                          Qt::QueuedConnection,
                                                          Q_ARG(Message, msg));
}

void ReporterThread::onMessageEmitted(Message msg)
{
        //      this->sendToCout(message);
        this->sendToFile(msg);
}

void ReporterThread::sendToFile(Message message)
{
        if (message.getMessageLevel()==mlVOLATILE)
                return;

//      QString channelFile = this->getFilenameForChannel(message.mChannel);
        LogFile channelLog = LogFile::fromChannel(mLogPath, message.mChannel);
        LogFile allLog = LogFile::fromChannel(mLogPath, "all");

        this->initializeLogFile(channelLog);

        channelLog.write(message);
        allLog.write(message);
}

void ReporterThread::sendToCout(Message message)
{
        if (!mCout)
                return;
        if (message.getMessageLevel()==mlVOLATILE)
                return;
        if (( message.getMessageLevel() == mlCOUT )||( message.getMessageLevel() == mlCERR ))
                return;

        mCout->sendUnredirected(message.getPrintableMessage()+"\n");
}

void ReporterThread::stopQtMessages()
{
        qInstallMessageHandler(silenceQtMessages);
}

void ReporterThread::startQtMessages()
{
        qInstallMessageHandler(convertQtMessagesToCxMessages);
}


} //End namespace cx