/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

//USER

#include "lcuiengine_p.h"

#include "lcuidefs.h"

#include "lclogger.h"

#include "lcuienginesimulator.h"

//SYSTEM

#include <QTimer>

#include <hbdialog.h>

#include <hblineedit.h>

#include <hbinstance.h>

#define LC_VTPLUGIN_NAME "Videotelephony";

const char localMovieName[] = "c:\\data\\local.3gp";

const char local2MovieName[] = "c:\\data\\local2.mpeg";

const char remoteMovieName[] = "c:\\data\\remote.3gp";

const char mPlayer[] = "c:\\data\\mplayer.exe";

const char msPaint[] = "mspaint";

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::LcUiEnginePrivate

// -----------------------------------------------------------------------------

//

LcUiEnginePrivate::LcUiEnginePrivate( LcUiEngine& uiEngine,

                                      const QString& engineName,

                                      const QString& applicationDisplayName)

    :mUiEngine( uiEngine )

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::LcUiEnginePrivate()" )                 

    mSimulator = new LcUiEngineSimulator( *this );

    mViewLayout = (LcViewLayoutHint)mSimulator->layout();

    mSessionTitle = mSimulator->sessionTitle();

    mRecipient =  mSimulator->remoteAddress();

    mPhoneNumber = mSimulator->phoneNo();        

    mLocalPlayerProcess = new QProcess();

    mRemotePlayerProcess = new QProcess();

    mProgram = QString::fromAscii(mPlayer);

    mProgramImage = QString::fromAscii(msPaint);

    mLocalMovieName = QString::fromAscii(localMovieName);

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::LcUiEnginePrivate()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::~LcUiEnginePrivate

// -----------------------------------------------------------------------------

//

LcUiEnginePrivate::~LcUiEnginePrivate()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::~LcUiEnginePrivate()" )

    delete mSimulator;

    delete mLocalPlayerProcess;

    delete mRemotePlayerProcess;    

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::~LcUiEnginePrivate()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::zoom

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::zoom( int value )

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::zoom()" )

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::zoom()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::stop

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::stop()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::stop()" )    

    mSimulator->stop();    

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::stop()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::start

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::start()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::start()" )

    mSimulator->start();

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::start()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::sessionTitle

// -----------------------------------------------------------------------------

//

const QString& LcUiEnginePrivate::sessionTitle() const

{

    return mSessionTitle;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::recipient

// -----------------------------------------------------------------------------

//

const QString& LcUiEnginePrivate::recipient() const

{

    return mRecipient;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::phoneNumber

// -----------------------------------------------------------------------------

//

const QString& LcUiEnginePrivate::phoneNumber() const

{

    return mPhoneNumber;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::viewLayout

// -----------------------------------------------------------------------------

//

LcViewLayoutHint LcUiEnginePrivate::viewLayout() const

{

    return mViewLayout;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::setContentAreas

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::setContentAreas( const QRectF& sharedContent,

                                  const QRectF& receivedContent )

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::setContentAreas()" )

    LC_QDEBUG_2( "livecomms [UI] shared window: ",  sharedContent )

    LC_QDEBUG_2( "livecomms [UI] received window: ",  receivedContent )    

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::setContentAreas()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::setOrientation

// -----------------------------------------------------------------------------

//

bool LcUiEnginePrivate::setOrientation( Qt::Orientation orientation )

{

    bool ok( false );

    return ok;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::setUiComponents

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::setUiComponents(

        HbDialog* invitingNote,

        HbDialog* waitingNote,

        HbDialog* acceptQuery,

        HbDialog* recipientQuery )

{

    mInvitingNote = invitingNote;

    mWaitingNote = waitingNote;

    mAcceptQuery = acceptQuery;

    mRecipientQuery = recipientQuery;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::toggleMute

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::toggleMute()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::toggleMute()" )        

    if( mMuteState ){

        unmuted();

    }else{

        muted();

    }

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::toggleMute()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::isMuted

// -----------------------------------------------------------------------------

//

bool LcUiEnginePrivate::isMuted() const

{

    return mMuteState;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::toggleSpeaker

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::toggleSpeaker()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::toggleSpeaker()" )

    if ( mSpeakerState ){

        speakerDisabled();

    }else{

        speakerEnabled();

    }

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::toggleSpeaker()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::isSpeakerOn

// -----------------------------------------------------------------------------

//

bool LcUiEnginePrivate::isSpeakerOn() const

{    

    return mSpeakerState;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::zoomValues

// -----------------------------------------------------------------------------

//

int LcUiEnginePrivate::zoomValues( LcControlValues& values ) const

{

    int err( 1 );

    return err;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::toggleEnableCamera

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::toggleDisableCamera()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::toggleDisableCamera()" )            

    if( mPlayerStateLocal == EPlaying ){

        localPlayerPaused();

        cameraDisabled();

    }else if( mPlayerStateLocal == EPaused){

        localPlayerPlaying();

        cameraEnabled();

    }

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::toggleDisableCamera()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::setCameraMain

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::setMainCamera(const bool aMainCamera)

{

    LC_QDEBUG_2( "livecomms [UI] -> LcUiEnginePrivate::setCameraMain()", aMainCamera )

    if(aMainCamera){

        cameraChangedToMain();

    }else{

        cameraChangedToSecondary();

    }

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::setCameraMain()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::cameraIndex

// -----------------------------------------------------------------------------

//

bool LcUiEnginePrivate::mainCamera() const

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::mainCamera()" )

    LC_QDEBUG_2( "livecomms [UI] <- LcUiEnginePrivate::mainCamera()", mMainCamera )

    return mMainCamera;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::toggleCamera

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::toggleCamera()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::toggleCamera()" )

    if( mMainCamera ){

        cameraChangedToSecondary();

    }else{

        cameraChangedToMain();

    }

    if( mPlayerStateLocal==EPlaying ){

        localPlayerPaused();

        mSimulator->setSimulation(2);

        mSimulator->start();

    }

    LC_QDEBUG_2( "livecomms [UI] <- LcUiEnginePrivate::toggleCamera(), mainCamera:", mMainCamera )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::fullScreenMode

// -----------------------------------------------------------------------------

//

bool LcUiEnginePrivate::fullScreenMode()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::fullScreenMode()" )

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::fullScreenMode()" )

    return mFullScreen;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::setFullScreenMode

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::setFullScreenMode(bool aMode)

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::setFullScreenMode()" )

    mFullScreen = aMode;

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::setFullScreenMode()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::updateSession

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::updateSession()

{

    LC_QDEBUG( "livecomms [UI] -> LcUiEnginePrivate::updateSession()" )

    LC_QDEBUG( "livecomms [UI] <- LcUiEnginePrivate::updateSession()" )

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::isLocalPlayerPlaying

// -----------------------------------------------------------------------------

//

bool LcUiEnginePrivate::isLocalPlayerPlaying() const

{

    return ( mPlayerStateLocal == EPlaying )? true : false;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::isRemotePlayerPlaying

// -----------------------------------------------------------------------------

//

bool LcUiEnginePrivate::isRemotePlayerPlaying() const

{

    return ( mSimulatorRemote == EPlaying )? true : false;

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::localPlayerPlaying

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::localPlayerPlaying()

{    

    QStringList args;

    args << mLocalMovieName;

    mLocalPlayerProcess->start(mProgram,args);        

    mPlayerStateLocal=EPlaying;

    emit mUiEngine.localPlayerPlaying();

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::remotePlayerPlaying

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::remotePlayerPlaying()

{

    QStringList args;

    args << QString::fromAscii(remoteMovieName);    

    mRemotePlayerProcess->start(mProgram,args);    

    mSimulatorRemote=EPlaying;

    emit mUiEngine.remotePlayerPlaying();

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::localPlayerPaused

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::localPlayerPaused()

{    

    mLocalPlayerProcess->close();       

    mPlayerStateLocal=EPaused;

    emit mUiEngine.localPlayerPaused();

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::remotePlayerPaused

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::remotePlayerPaused()

{    

    mRemotePlayerProcess->close();    

    mSimulatorRemote=EPaused;

    emit mUiEngine.remotePlayerPaused();

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::cameraChangedToSecondary

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::cameraChangedToSecondary()

{

    mLocalMovieName= QString::fromAscii(local2MovieName);

    mMainCamera=false;

    emit mUiEngine.cameraChangedToSecondary();

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::cameraChangedToSecondary

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::cameraChangedToMain()

{

    mLocalMovieName= QString::fromAscii(localMovieName);

    mMainCamera=true;

    emit mUiEngine.cameraChangedToMain();

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::isMinimized

// -----------------------------------------------------------------------------

//

bool LcUiEnginePrivate::isMinimized() const

{

    return (QApplication::activeWindow()->windowState()==Qt::WindowMinimized);

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::minimize

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::minimize()

{

    QApplication::activeWindow()->setWindowState(Qt::WindowMinimized);

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::maximize

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::maximize()

{

    QApplication::activeWindow()->setWindowState(Qt::WindowMaximized);

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::shareImage

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::shareImage(const QString& fileName)

{

    localPlayerPaused();    

    QStringList args;

    args << fileName;

    mLocalPlayerProcess->start(mProgramImage,args);

    mPlayerStateLocal=EPlaying;

    emit mUiEngine.localPlayerPlaying();

}

// -----------------------------------------------------------------------------

// LcUiEnginePrivate::shareCamera

// -----------------------------------------------------------------------------

//

void LcUiEnginePrivate::shareCamera()

{

    localPlayerPaused();

    localPlayerPlaying();

}

// End of File