/*

* 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 "lcactivitymanager.h"

//SYSTEM

#include <w32std.h>

#include <e32err.h>

#include <bacline.h>

#include <coecntrl.h>

#include <apgtask.h>

#include <eikenv.h>

#include <QTimer>

#include <QChar>

#include <hbdialog.h>

#include <hbaction.h>

#include <hblabel.h>

#include <hblineedit.h>

#include <hbinstance.h>

#include <xqserviceutil.h>

#include <QApplication>

#include <hbview.h>

#include <hbmessagebox.h>

#include <hbprogressdialog.h>

#include <lcvideoplayer.h>

#include <lcwindow.h>

#include <lcaudiocontrol.h>

#include <lcsession.h>

#include <lczoomcontrol.h>

#include <lccameracontrol.h>

#define LC_VTPLUGIN_NAME "Videotelephony";

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

// LcUiEnginePrivate::LcUiEnginePrivate

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

//

LcUiEnginePrivate::LcUiEnginePrivate(LcUiEngine& uiEngine,

                                     const QString& engineName,

                                     const QString& applicationDisplayName)

    : mEngineName( engineName.toUtf8() ),

      mSessionTitle( applicationDisplayName ),

      mViewLayout( Lc_IdleViewLayout ),

      mLiveCommsEngine( 0 ),

      mCloseTimer(0),

      mInvitingNote(0),

      mWaitingNote(0),

      mAcceptQuery(0),

      mRecipientQuery(0),

      mShareOwnVideoQuery(0),

      mBlocked(false),

      mFullScreen(false),

      mSessionDurationTimerId(0),

      mMainCamera(true),

      mUiEngine( uiEngine ),

      mIsMinimized(false),

      mFirstForegroundSwitch(true),

      mCurrentView(0),

      mActivityManager(0)

{

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

    mPendingAction.clear();

    TPtrC8 name( reinterpret_cast< const TUint8* >( mEngineName.constData() ) );

    // TODO: 

    // Replace the TRAPs with QT_TRANSLATE_SYMBIAN_LEAVE_TO_EXCEPTION (Qt4.5.2)

    TRAPD( err, mLiveCommsEngine = CLcEngine::NewL( name ) );

    if ( err != KErrNone ) {

        // Cannot proceed with the execution, exit the application

        LC_QDEBUG_2( "livecomms [UI] <- LcUiEnginePrivate::LcUiEnginePrivate(), failed:", err )

        qApp->exit(err);

		return;

    }

    mLiveCommsEngine->Session().SetLcSessionObserver( this );

    mLiveCommsEngine->Session().SetLcUiProvider( this );

    fillRemoteInfo( false );

    if ( usingVideoTelephoneEngine() ) {

        mViewLayout = Lc_AllInOneViewLayout;

    }

    LC_QDEBUG( "livecomms [UI] Setting window for plug-in" )

    CCoeControl* coeControl = 

        reinterpret_cast<CCoeControl*>( 

            HbInstance::instance()->allMainWindows().at(0)->winId());

    if ( coeControl ) {

        TInt windowPtr = reinterpret_cast<TInt>(coeControl->DrawableWindow());

        // Return value ignored as plugin may not be interested about window

        mLiveCommsEngine->Session().SetParameter(0,windowPtr);

    }

    mActivityManager = new LcActivityManager;

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

}

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

// LcUiEnginePrivate::~LcUiEnginePrivate

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

//

LcUiEnginePrivate::~LcUiEnginePrivate()

{

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

    delete mLiveCommsEngine;

    delete mCloseTimer;

    delete mActivityManager;

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

}

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

// LcUiEnginePrivate::zoom

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

//

void LcUiEnginePrivate::zoom( int value )

{

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

    // TODO: Replace TRAP with QT_TRANSLATE_SYMBIAN_LEAVE_TO_EXCEPTION (Qt4.5.2)

    MLcZoomControl* zoom = zoomControl();

    if ( zoom ) {

        TRAP_IGNORE( zoom->SetLcZoomValueL( value ) ); 

    }

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

}

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

// LcUiEnginePrivate::stop

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

//

void LcUiEnginePrivate::stop()

{

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

    mActivityManager->enableActivitySimulation(false);

    stopSessionDurationTimer();

    cancelCloseTimer();

    hideNotes( true );    

    // Start guard timer already before terminate call just in case

    // something goes horribly wrong in termination

    startStopGuardTimer();

    int err = terminateSession();

    if ( !err && session().LcSessionState() ==  MLcSession::EClosing ) {        

        LC_QDEBUG( "livecomms [UI] not closing UI yet, waiting for session termination..." )

    } else {

        LC_QDEBUG( "livecomms [UI] closing UI..." )

        emit mUiEngine.stopped();

    }

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

}

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

// LcUiEnginePrivate::start

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

//

void LcUiEnginePrivate::start()

{

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

    mActivityManager->enableActivitySimulation(true);

    if ( session().LcSessionState() != MLcSession::EReceived ) {

        startLiveContent();

    } else {

        //wait callback

        LC_QDEBUG( "livecomms [UI] MT start waiting callback" )

    }

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

}

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

// LcUiEnginePrivate::sessionTitle

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

//

const QString& LcUiEnginePrivate::sessionTitle() const

{

    return mSessionTitle;

}

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

// LcUiEnginePrivate::recipient

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

//

const QString& LcUiEnginePrivate::recipient() const

{

    return ( mRecipient.isEmpty() ) ? mPhoneNumber : 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 )

    mLocalRect = TRect();

    mRemoteRect = TRect();

    if ( sharedContent.height() != 0 ) {

        mLocalRect.SetRect( sharedContent.topLeft().x(), 

                           sharedContent.topLeft().y(),

                           sharedContent.bottomRight().x(),

                           sharedContent.bottomRight().y() );

    }

    if ( receivedContent.height() != 0 ) {

        mRemoteRect.SetRect( receivedContent.topLeft().x(), 

                           receivedContent.topLeft().y(),

                           receivedContent.bottomRight().x(),

                           receivedContent.bottomRight().y() );

    }

    setWindowRect( session().LocalVideoPlayer(), mLocalRect );

    setWindowRect( session().RemoteVideoPlayer(), mRemoteRect );

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

}

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

// LcUiEnginePrivate::setOrientation

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

//

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

{

    bool ok( false );

    TInt error1( KErrNone );

    TInt error2( KErrNone );

    MLcVideoPlayer* localPlayer = session().LocalVideoPlayer();

    MLcVideoPlayer* remotePlayer = session().RemoteVideoPlayer();

    if ( localPlayer && localPlayer->LcWindow() ) {

    }

    if ( remotePlayer && remotePlayer->LcWindow() ) {

    }

    if ( (error1 == KErrNone) && (error2 == KErrNone) ) {

        ok = true;

    }

    return ok;

}

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

// LcUiEnginePrivate::setUiComponents

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

//

void LcUiEnginePrivate::setUiComponents(

        HbProgressDialog* invitingNote,

        HbProgressDialog* waitingNote,

        HbDialog* acceptQuery,

        HbDialog* recipientQuery,

        HbDialog* shareOwnVideoQuery )

{

    mInvitingNote = invitingNote;

    mWaitingNote = waitingNote;

    mAcceptQuery = acceptQuery;

    mRecipientQuery = recipientQuery;

    mShareOwnVideoQuery = shareOwnVideoQuery;

    if (mAcceptQuery && (mAcceptQuery->actions().size() == 2)) {

        connect(mAcceptQuery->actions().at(0), SIGNAL(triggered()), 

                this, SLOT(startReceiving()) );

        connect(mAcceptQuery->actions().at(1), SIGNAL(triggered()), 

                this, SLOT(stop()) );

    }

    if (mInvitingNote && (mInvitingNote->actions().size() == 1)) {

        connect(mInvitingNote->actions().at(0), SIGNAL(triggered()), 

                this, SLOT(stop()) );

    }

    if (mWaitingNote && (mWaitingNote->actions().size() == 1)) {

        connect(mWaitingNote->actions().at(0), SIGNAL(triggered()), 

                this, SLOT(stop()) );

    }   

    if(mShareOwnVideoQuery && (mShareOwnVideoQuery->actions().size() == 2)) {

        connect(mShareOwnVideoQuery->actions().at(0), SIGNAL(triggered()), 

                this, SLOT(startLocalVideo()) );

        connect(mShareOwnVideoQuery->actions().at(1), SIGNAL(triggered()), 

                this, SLOT(stopLocalVideo()) );

    }

}

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

// LcUiEnginePrivate::toggleMute

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

//

void LcUiEnginePrivate::toggleMute()

{

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

    bool mute( !isMuted() );

    muteMic( mute );

    // Muting / unmuting the microphone is an asynchronous operation.

    // Assuming here that the operation will eventually succeed.  

    if ( mute ) {

        completeAction( lcEngSignalNameMuted );

    } else {

        completeAction( lcEngSignalNameUnmuted );

    }       

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

}

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

// LcUiEnginePrivate::isMuted

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

//

bool LcUiEnginePrivate::isMuted() const

{

    bool micMuted( false );

    MLcAudioControl* audio = audioControl();

    // TODO: Replace TRAP with QT_TRANSLATE_SYMBIAN_LEAVE_TO_EXCEPTION (Qt4.5.2)

    if ( audio ) {

        TRAP_IGNORE( micMuted = audio->IsLcMicMutedL() );

    }

    return micMuted;      

}

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

// LcUiEnginePrivate::toggleSpeaker

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

//

void LcUiEnginePrivate::toggleSpeaker()

{

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

    bool enable( !isSpeakerOn() );

    enableSpeaker( enable );        

    // Enabling / disabling the speaker is an asynchronous operation.

    // Assuming here that the operation will eventually succeed.    

    if ( enable ) {

        completeAction( lcEngSignalNameSpeakerEnabled );

    } else {

        completeAction( lcEngSignalNameSpeakerDisabled );

    }       

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

}

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

// LcUiEnginePrivate::isSpeakerOn

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

//

bool LcUiEnginePrivate::isSpeakerOn() const

{

    return audioControl()->IsLcLoudspeakerEnabled();

}

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

// LcUiEnginePrivate::zoomValues

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

//

int LcUiEnginePrivate::zoomValues( LcControlValues& values ) const

{

    int err( -1 );

    // TODO: Replace TRAP with QT_TRANSLATE_SYMBIAN_LEAVE_TO_EXCEPTION (Qt4.5.2)

    MLcZoomControl* zoom = zoomControl();

    if ( zoom ) {

        TRAP( err,

              values.mMaxValue = zoom->MaxLcZoomL();

              values.mMinValue = zoom->MinLcZoomL();

              values.mValue = zoom->LcZoomValueL(); );

    }

    return err;

}

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

// LcUiEnginePrivate::toggleEnableCamera

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

//

void LcUiEnginePrivate::toggleDisableCamera()

{

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

    MLcVideoPlayer* player = visibleLocalPlayer();

    if( player ) {

        pause( session().LocalVideoPlayer() );

        completeAction( lcEngSignalNameCameraDisabled );

    } else {

        play( session().LocalVideoPlayer() );

        completeAction( lcEngSignalNameCameraEnabled );

    }

    emitViewLayoutChanged();

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

}

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

// LcUiEnginePrivate::setCameraMain

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

//

void LcUiEnginePrivate::setMainCamera(const bool aMainCamera)

{

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

    mMainCamera = aMainCamera;

    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()" )

    MLcVideoPlayer* localPlayer = session().LocalVideoPlayer();

    // TODO: Replace TRAP with QT_TRANSLATE_SYMBIAN_LEAVE_TO_EXCEPTION (Qt4.5.2)

    if ( localPlayer && localPlayer->LcCameraControl() ) {

        TRAP_IGNORE( localPlayer->LcCameraControl()->ToggleLcCameraL() );

    }

    setMainCamera( !mMainCamera );

    // Enabling / disabling the camera is an asynchronous operation.

    // Assuming here that the operation will eventually succeed.  

    if ( mMainCamera ) {

        completeAction( lcEngSignalNameCameraChangedToMain );

    } else {

        completeAction( lcEngSignalNameCameraChangedToSecondary );

    }

    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()" )

    // TODO: Replace TRAP with QT_TRANSLATE_SYMBIAN_LEAVE_TO_EXCEPTION (Qt4.5.2)

    TRAP_IGNORE( session().UpdateLcSessionL() );

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

}