/*

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

#include "lclogger.h"

#include "lcuiengine.h"

#include "lcuidefs.h"

#include "lcuicomponentrepository.h"

#include "lceffecthandler.h"

#include "lcvideowidget.h"

//SYSTEM

#include <hblabel.h>

#include <hbdialog.h>

#include <hbtransparentwindow.h>

#include <hbmessagebox.h>

#include <hbaction.h>

#include <hbmenu.h>

#include <hbpushbutton.h>

#include <hbtoolbar.h>

#include <hbinstance.h>

#include <hbzoomsliderpopup.h>

#include <hbeffect.h>

#include <qgraphicssceneevent.h>

#include <qtimer.h>

#include <hblineedit.h>

#include <dialpad.h>

#include <HbTapGesture>

#if ( defined __WINSCW__ ) || ( defined __WINS__ )

const int inActivityTimeout = 5000; //5 secs

#else

const int inActivityTimeout = 2000; //2 secs

#endif

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

// LcView::LcView

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

//

LcView::LcView(LcUiEngine& engine, LcUiComponentRepository& repository)

 : HbView(0),

   mEngine(engine),

   mRepository(repository),

   mRecipient(0),

   mDuration(0),

   mContactIcon(0),

   mBrandIcon(0),

   mSharedVideoWidget(0),

   mReceivedVideoWidget(0),

   mChangeCameraAction(0),

   mMuteAction(0),

   mSpeakerAction(0),

   mDisableCameraAction(0),

   mDisableCameraMenuAction(0),

   mNotSupportedNote(0),

   mZoomSlider(0),

   mEndCallButton(0),

   mReceivedVideoEffectOverlay(0),

   mSharedVideoEffectOverlay(0),

   mEffectHandler(0),

   mItemContextMenu(0),

   mLandscapeTimer(0),

   mIsOptionMenuOpen(false),

   mSoftKeyBackAction(0),

   mDialpad(0)

{

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

    createNotSupportedNote();

    // For LiveComms views Dock Wiget Item is explicitly hidden.

    hideItems(Hb::DockWidgetItem);

    //Subscribe to the gesture events.

    grabGesture(Qt::TapGesture);        

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

}

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

// LcView::~LcView

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

//

LcView::~LcView()

{

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

    // Un-subscribe to the gesture events.

    ungrabGesture(Qt::TapGesture);        

    delete mEffectHandler;

    delete mLandscapeTimer;

    delete mNotSupportedNote;

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

}

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

// LcView::init

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

//

void LcView::init()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::init()" )

    //find member widgets from repository

    //( can be also found by browsing this view itself )

    //due stubs in unit tests, qobject_cast cannot be used. Using static_cast instead

    mRecipient = 

        static_cast<HbLabel*>( mRepository.findWidget( lcLabelRecipientId ) );

    mDuration = 

        static_cast<HbLabel*>( mRepository.findWidget( lcLabelDurationId ) );

    mContactIcon = 

        static_cast<HbLabel*>( mRepository.findWidget( lcIconContactId ) );

    mBrandIcon = 

        static_cast<HbLabel*>( mRepository.findWidget( lcIconBrandId ) );

    mSharedVideoWidget = 

        static_cast<LcVideoWidget*>( 

                mRepository.findWidget( lcWidgetSendVideoId ) );

    mReceivedVideoWidget = 

        static_cast<LcVideoWidget*>( 

                mRepository.findWidget( lcWidgetRecvVideoId ) );

    mChangeCameraAction = 

        static_cast<HbAction*>( mRepository.findObject( lcActChangeCameraId ) );

    mMuteAction = 

        static_cast<HbAction*>( mRepository.findObject( lcActMuteId ) );

    mSpeakerAction = 

        static_cast<HbAction*>( mRepository.findObject( lcActSpeakerId ) );

    mDisableCameraAction = 

        static_cast<HbAction*>( mRepository.findObject( lcActDisableCameraId ) );

    mDisableCameraMenuAction =

        static_cast<HbAction*>( mRepository.findObject( lcActMenuDisableCameraId ) );

    mEndCallButton =

            static_cast<HbPushButton*>( mRepository.findObject( lcButtonEndCall ) );

    if ( mEndCallButton ) {

        connect( mEndCallButton, SIGNAL(clicked()), SLOT(endVideoSession()));

    }

    if ( mSharedVideoWidget ) {

        mZoomSlider = mRepository.zoomSlider();

        mSharedVideoEffectOverlay = static_cast<LcVideoWidget*>( 

                mRepository.findWidget( lcWidgetSendVideoId2 ) );

        if ( mSharedVideoEffectOverlay ) {

            mSharedVideoEffectOverlay->show();

        }

    }

    mReceivedVideoEffectOverlay = 

        static_cast<LcVideoWidget*>( mRepository.findWidget( lcWidgetRecvVideoId2 ) );

    if ( mReceivedVideoEffectOverlay ) {

        mReceivedVideoEffectOverlay->show();

    }

    mEffectHandler = new LcEffectHandler( mEngine,

            mSharedVideoWidget, mSharedVideoEffectOverlay, 

            mReceivedVideoWidget, mReceivedVideoEffectOverlay);

    connect( mEffectHandler, SIGNAL(swapCompleted()), this, SLOT(updateVideoRects()) );

    connect( mEffectHandler, SIGNAL(loadSwapLayout()), this, SLOT(updateSwapLayout()) );

    mLandscapeTimer = new QTimer();

    connect( mLandscapeTimer, SIGNAL(timeout()), this, SLOT(landscapeTimerTimeout()) );

    updateUiElements();

    if ( menu()) {

        connect( menu(), SIGNAL(aboutToShow()), this, SLOT(menuAboutToShow()) );

        connect( menu(), SIGNAL(aboutToHide()), this, SLOT(menuAboutToHide()) );

    }

    mSoftKeyBackAction = new HbAction(Hb::BackNaviAction, this);    

    connect(mSoftKeyBackAction, SIGNAL(triggered()), SLOT(back()));

    LC_QDEBUG( "livecomms [UI] <- LcView::init()" )

}

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

// LcView::updateVideoRects

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

//

void LcView::updateVideoRects()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::updateVideoRects()" )

    QRectF sharedContentRect;

    QRectF receivedContentRect;

    if ( mSharedVideoWidget ) {

        sharedContentRect = mSharedVideoWidget->geometry();  

        sharedContentRect.moveTop(

                sharedContentRect.y() + mapToParent(scenePos()).y());

        sharedContentRect = translateRectForOrientation(sharedContentRect);

        mEffectHandler->setVisibility(

                mSharedVideoWidget, mEngine.isLocalPlayerPlaying());

    }

    if ( mReceivedVideoWidget ) {

        receivedContentRect = mReceivedVideoWidget->geometry();

        receivedContentRect.moveTop(

                receivedContentRect.y() + mapToParent(scenePos()).y());

        receivedContentRect = translateRectForOrientation(receivedContentRect);

        mEffectHandler->setVisibility(

                mReceivedVideoWidget, mEngine.isRemotePlayerPlaying());

    }

    mEngine.setContentAreas( sharedContentRect, receivedContentRect );

    mEngine.setOrientation( HbInstance::instance()->allMainWindows().at(0)->orientation() );

    mEngine.updateSession();

    LC_QDEBUG( "livecomms [UI] <- LcView::updateVideoRects()" )

}

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

// LcView::swap

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

//

void LcView::swap()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::swap()" )

    if ( mEffectHandler ){

        mEffectHandler->swap();

    }

    LC_QDEBUG( "livecomms [UI] <- LcView::swap()" )

}

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

// LcView::updateSwapLayout

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

//

void LcView::updateSwapLayout()

{

    mRepository.loadLayout( currentLayout() );

    if ( isLandscapeOrientation() ){

        if ( mEngine.fullScreenMode() ){

            hideControl();

        } else {

            showControl();

        }

    }

}

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

// LcView::updateUiElements

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

//

void LcView::updateUiElements() 

{

    LC_QDEBUG( "livecomms [UI] -> LcView::updateUiElements()" )

    if ( isLandscapeOrientation() ) {

        setContentFullScreen( true );

        deActivateFullScreen();

    } else {

        setContentFullScreen( false );

        activatePortrait();

    }

    LC_QDEBUG( "livecomms [UI] <- LcView::updateUiElements()" )

}

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

// LcView::activated

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

//

void LcView::activated()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::activated()" )

    if ( navigationAction() != mSoftKeyBackAction ) {

        setNavigationAction(mSoftKeyBackAction);

    }

    updateVideoRects();

    //synchronize with engine

    if ( mEngine.mainCamera() ) {

        setCameraActionToSecondary();

    } else {

        setCameraActionToMain();

    }

    if ( mEngine.isMuted() ) {

        setMuteActionToUnmute();

    } else {

        setMuteActionToMute();

    }

    if ( mEngine.isSpeakerOn() ) {

        setSpeakerActionToHandset();

    } else {

        setSpeakerActionToSpeaker();

    }

    if ( mChangeCameraAction ) {

        connect( 

            &mEngine, SIGNAL(cameraChangedToMain()),

            this, SLOT(setCameraActionToSecondary()) );

        connect(

            &mEngine, SIGNAL(cameraChangedToSecondary()),

            this, SLOT(setCameraActionToMain()));           

    }

    if ( mMuteAction ) {

        connect( 

            &mEngine, SIGNAL(muted()),

            this, SLOT(setMuteActionToUnmute()) );

        connect(

            &mEngine, SIGNAL(unmuted()),

            this, SLOT(setMuteActionToMute()));

    }

    if ( mSpeakerAction ) {

        connect( &mEngine, SIGNAL(speakerEnabled()), 

            this, SLOT(setSpeakerActionToHandset()) );

        connect( &mEngine, SIGNAL(speakerDisabled()), 

            this, SLOT(setSpeakerActionToSpeaker()) );

    }

    if ( mDisableCameraAction ) {

        connect( 

            &mEngine, SIGNAL(cameraDisabled()),

            this, SLOT(setCameraActionToEnable()) );

        connect(

            &mEngine, SIGNAL(cameraEnabled()),

            this, SLOT(setCameraActionToDisable()));           

    }

    connect( &mEngine, SIGNAL(blocked()), this, SLOT(disableControls()) );

    connect( &mEngine, SIGNAL(unblocked()), this, SLOT(enableControls()) ); 

    if ( mDuration ) {

        // TODO: clearing is needed for label in order to

        // get text changed. Seems like bug in orbit side.

        // This causes that duration is not changed. Workaround

        // would be to call clear always when duration changes.

        mDuration->clear();

        connect( 

        &mEngine, SIGNAL(sessionDurationChanged(const QString &)),

        mDuration, SLOT(setPlainText(const QString &)) );

    }

    if ( mRecipient ){

        mRecipient->clear();

        mRecipient->setPlainText( mEngine.recipient() );

        connect( 

           &mEngine, SIGNAL(recipientChanged(const QString &)),

           mRecipient, SLOT(setPlainText(const QString &)) );

    }

    if ( mSharedVideoWidget ) {

        connect( &mEngine, SIGNAL(localPlayerPlaying()), 

                 mEffectHandler, SLOT(showSendWindow()) );

        connect( &mEngine, SIGNAL(localPlayerPaused()), 

                 mEffectHandler, SLOT(hideSendWindow()) );

    }

    if ( mReceivedVideoWidget ) {

        connect( &mEngine, SIGNAL(remotePlayerPlaying()), 

                 mEffectHandler, SLOT(showReceiveWindow()) );

        connect( &mEngine, SIGNAL(remotePlayerPaused()), 

                 mEffectHandler, SLOT(hideReceiveWindow()) );

    }

    mEngine.setCurrentView(this);

    LC_QDEBUG( "livecomms [UI] <- LcView::activated()" )

}

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

// LcView::deactivated

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

//

void LcView::deactivated()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::deactivated()" )

    QRectF sharedContentRect;//null area

    QRectF receivedContentRect;//null area

    mEngine.setContentAreas( sharedContentRect, receivedContentRect );

    disconnect( &mEngine, 0, this, 0 );

    LC_QDEBUG( "livecomms [UI] <- LcView::deactivated()" )

}

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

// LcView::notSupported

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

//

void LcView::notSupported()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::notSupported()" )

    mNotSupportedNote->show();

    resetLandscapeTimer();

    LC_QDEBUG( "livecomms [UI] <- LcView::notSupported()" )

}

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

// LcView::shareImage

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

//

void LcView::shareImage()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::shareImage()" )

    const char localImageName[] = "c:\\data\\local.jpg";

    QString fileName = QString::fromAscii(localImageName);

    mEngine.shareImage(fileName);

    LC_QDEBUG( "livecomms [UI] <- LcView::shareImage()" )

}

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

// LcView::changeOrientation_Temporary

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

//

void LcView::changeOrientation_Temporary()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::changeOrientation_Temporary()" )

    if ( isLandscapeOrientation() ) {

        HbInstance::instance()->allMainWindows().at(0)->setOrientation( Qt::Vertical ); 

    } else {

        HbInstance::instance()->allMainWindows().at(0)->setOrientation( Qt::Horizontal );

    }

    LC_QDEBUG( "livecomms [UI] <- LcView::changeOrientation_Temporary()" )

}

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

// LcView::endVideoSession

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

//

void LcView::endVideoSession()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::endVideoSession()" )

    mEngine.stop();

    LC_QDEBUG( "livecomms [UI] <- LcView::endVideoSession()" )

}

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

// LcView::disableCamera

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

//

void LcView::disableCamera()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::disableCamera()" )

    mEffectHandler->setDissappearEffect( LcEffectHandler::NormalDissappear );

    mEngine.toggleDisableCamera();

    resetLandscapeTimer();

    LC_QDEBUG( "livecomms [UI] <- LcView::disableCamera()" ) 

}

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

// LcView::mute

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

//

void LcView::mute()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::mute()" )

    mEngine.toggleMute();

    resetLandscapeTimer();

    LC_QDEBUG( "livecomms [UI] <- LcView::mute()" )

}

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

// LcView::changeCamera

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

//

void LcView::changeCamera()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::changeCamera()" )

    mEffectHandler->setDissappearEffect( LcEffectHandler::DissappearToFlip );

    mEngine.toggleCamera();

    resetLandscapeTimer();

    LC_QDEBUG( "livecomms [UI] <- LcView::changeCamera()" )

}

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

// LcView::switchToVoiceCall

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

//

void LcView::switchToVoiceCall()

{

    LC_QDEBUG( "livecomms [UI] -> LcView::switchToVoiceCall()" )

    mEngine.stop();

    LC_QDEBUG( "livecomms [UI] <- LcView::switchToVoiceCall()" )

}

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

// LcView::speaker

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