source: qutecom-coip/gui/src/call/callwidget.cpp @ 283:312974380d4f

#include "callwidget.h"
#include "ui_callwidget.h"

CallWidget::CallWidget(TCallSession * tCallSession,QWidget *parent) 
:QMainWindow(parent),_tCallSession(tCallSession),ui(new Ui::CallWidget)
{
        _timerIdProgressAnimation = 0; 
        _timerIdSession = 0;
        _durationSession = 0;
        
        _lastStatus = EnumPhoneCallState::PhoneCallStateIncoming;
        
   // ui->setupUi(this);

        _labelMsg = new QLabel;
        statusBar()->addWidget(_labelMsg);
        _labelMsg->setText("New Call...");
        
        _remoteVideoFrame = QPixmap(":/qute.png");
        
        connect(_tCallSession,
                                 SIGNAL(videoFrameReceivedSignal(QImage, QImage)),
                                 SLOT(videoFrameReceivedSlot(QImage, QImage)));
        
        connect(_tCallSession,
                                 SIGNAL(phoneCallStateChangedSignal(EnumPhoneCallState::PhoneCallState)),
                                 SLOT(phoneCallStateChangedSlot(EnumPhoneCallState::PhoneCallState)));
        _tCallSession->enableVideo(true);
        show();
}

CallWidget::CallWidget(Contact contact,QWidget *parent) 
:QMainWindow(parent),ui(new Ui::CallWidget)
{
        _timerIdProgressAnimation = 0;
        _timerIdSession = 0;
        _durationSession = 0;
        
        _lastStatus = EnumPhoneCallState::PhoneCallStateUnknown;
        
    ui->setupUi(this);
        
        _labelMsg = new QLabel;
        statusBar()->addWidget(_labelMsg);
        _labelMsg->setText("Dialing...");
        
        _remoteVideoFrame = QPixmap(":/qute.png");
        
        _tCallSession = Coip::self()->getTCallSessionManager().createTCallSession();
        
        connect(_tCallSession,
                                 SIGNAL(videoFrameReceivedSignal(QImage, QImage)),
                                 SLOT(videoFrameReceivedSlot(QImage, QImage)));
        
        connect(_tCallSession,
                                 SIGNAL(phoneCallStateChangedSignal(EnumPhoneCallState::PhoneCallState)),
                                 SLOT(phoneCallStateChangedSlot(EnumPhoneCallState::PhoneCallState)));
        
        _tCallSession->addContact(contact);
        _tCallSession->enableVideo(true);
        _tCallSession->start();

        show();
}

CallWidget::~CallWidget()
{
    delete ui;
        delete _tCallSession;
}

void CallWidget::changeEvent(QEvent *e)
{
    QMainWindow::changeEvent(e);
    switch (e->type()) {
    case QEvent::LanguageChange:
        ui->retranslateUi(this);
        break;
    default:
        break;
    }
}

void CallWidget::paintEvent(QPaintEvent*)
{
        QPainter painter(this);
        painter.setRenderHint(QPainter::Antialiasing, true);

        if(!_remoteVideoFrame.isNull())
        {
                QPixmap pix = _remoteVideoFrame.scaled(ui->label->size(),Qt::KeepAspectRatio,Qt::SmoothTransformation);
                QRect re(0,0,pix.width(),pix.height());
                re.moveCenter(ui->label->rect().center());
                painter.drawPixmap(re,pix);
        }
                
        if(!_localVideoFrame.isNull())
                painter.drawPixmap(ui->label->pos(),_localVideoFrame.scaled(ui->label->size()/6,Qt::KeepAspectRatio,Qt::SmoothTransformation));
        
        if(_lastStatus != EnumPhoneCallState::PhoneCallStateTalking)
        {
                painter.fillRect(centralWidget()->rect(),QColor(30,30,30,200));
        
                if(!_timerIdProgressAnimation && (_lastStatus == EnumPhoneCallState::PhoneCallStateIncoming || _lastStatus == EnumPhoneCallState::PhoneCallStateHold))
                {
                        painter.setPen(QPen(QColor(255,255,255,200), 3));
                        QRect re(0,0,50,50);
                        re.moveCenter(centralWidget()->rect().center());
                        painter.drawEllipse(re);
                
                        re.translate(re.width()/4, 0);
                        painter.setBrush(QColor(255,255,255,200));
                        painter.drawPie(re, 150 * 16, 60 * 16);
                }
        }       
        
        if(_timerIdProgressAnimation)
        {
                for (int i=0; i<9; i++)
        {
                        QColor color = Qt::white;
                        color.setAlphaF(1.0f - (i/9.0f));
                        painter.setPen(Qt::NoPen);
                        painter.setBrush(color);
                        painter.save();
                        painter.translate(centralWidget()->rect().center());
                        painter.rotate(_angleProgressAnimation - i*40.0f);
                        painter.drawRect(QRectF(5.5, 0.9, 21.5, 5));
                        painter.restore();
        }
        }
}

void CallWidget::mouseReleaseEvent(QMouseEvent *)
{
        if(_tCallSession->isStarted())
        {
                if(_lastStatus == EnumPhoneCallState::PhoneCallStateTalking)
                {
                        startProgressAnimation();
                        _tCallSession->pause();
                }
                else if(_lastStatus == EnumPhoneCallState::PhoneCallStateHold)
                {
                        startProgressAnimation();
                        _tCallSession->resume();
                }
                        
        }
        else if(_lastStatus == EnumPhoneCallState::PhoneCallStateIncoming)
        {
                startProgressAnimation();
                _tCallSession->start();
        }               
}

void CallWidget::timerEvent(QTimerEvent* event)
{
        if(event->timerId() == _timerIdProgressAnimation)
        {
                _angleProgressAnimation = (_angleProgressAnimation+30)%360;
                update();
        }
        else if(event->timerId() == _timerIdSession)
        {
                _durationSession++;
                QTime time;
                setWindowTitle(time.addSecs(_durationSession).toString());
        }
}

void CallWidget::startSessionTimer()
{
        _timerIdSession = startTimer(1000);
}

void CallWidget::stopSessionTimer()
{
        killTimer(_timerIdSession);
}

void CallWidget::startProgressAnimation()
{
        if(!_timerIdProgressAnimation)
                _timerIdProgressAnimation = startTimer(100);
}

void CallWidget::stopProgressAnimation()
{
        if(_timerIdProgressAnimation)
        {
                killTimer(_timerIdProgressAnimation);
                _timerIdProgressAnimation = 0;
        }
}


void CallWidget::hangUpButtonClicked() {

        _tCallSession->stop();
}

void CallWidget::videoFrameReceivedSlot(QImage remoteVideoFrame, QImage localVideoFrame) {

        if(!remoteVideoFrame.isNull())
                _remoteVideoFrame = QPixmap::fromImage(remoteVideoFrame);

        if(!localVideoFrame.isNull())
                _localVideoFrame = QPixmap::fromImage(localVideoFrame);

        update();
}

void CallWidget::phoneCallStateChangedSlot(EnumPhoneCallState::PhoneCallState state) {
        
        _lastStatus = state;
        
        switch(state) {
                        //case EnumPhoneCallState::PhoneCallStateUnknown:
                case EnumPhoneCallState::PhoneCallStateClosed:
                        stopProgressAnimation();
                        stopSessionTimer();
                        _labelMsg->setText("Closed...");                        
                        break;
                        
                case EnumPhoneCallState::PhoneCallStateError:
                        stopProgressAnimation();
                        stopSessionTimer();
                        _labelMsg->setText("Error...");                 
                        break;
                        
                case EnumPhoneCallState::PhoneCallStateTalking:
                        stopProgressAnimation();
                        startSessionTimer();
                        _labelMsg->setText("Talking...");
                        break;
                        
                case EnumPhoneCallState::PhoneCallStateDialing:
                        startProgressAnimation();
                        _labelMsg->setText("Dialing...");
                        break;
                        
                case EnumPhoneCallState::PhoneCallStateRinging:
                        _labelMsg->setText("Ringing...");
                        break;
                        
                case EnumPhoneCallState::PhoneCallStateHold:
                        stopProgressAnimation();
                        _labelMsg->setText("Hold...");
                        break;
                        
                case EnumPhoneCallState::PhoneCallStateResumed:
                        _labelMsg->setText("Resumed...");
                        break;
                        
                case EnumPhoneCallState::PhoneCallStateMissed:
                        stopProgressAnimation();
                        _labelMsg->setText("Missed...");
                        break;
                        
                case EnumPhoneCallState::PhoneCallStateRedirected:
                        stopProgressAnimation();
                        stopSessionTimer();
                        _labelMsg->setText("Redirected...");
                        break;
                        
                        //case EnumPhoneCallState::PhoneCallStateIncoming:
                        
                default:
                        break;
        }
        update();
}

void CallWidget::closeEvent(QCloseEvent*)
{
        stopCallSessionSignal(_tCallSession);
}

void CallWidget::callButtonClickedSlot()
{
        _tCallSession->start();
}