/*

* Copyright (c) 2008 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:  LiveComm Videotelephony Plugin session Class

*

*/

#include <e32base.h>

#include <e32std.h>

#include <e32cmn.h>

#include <featmgr.h>

#include <w32std.h>

#include <coecntrl.h>

#include <eikenv.h>

#include <eikappui.h>

#include <apgcli.h>

#include <centralrepository.h> 

#include "clcvtsession.h"

#include "cvtengmodel.h"

#include "clcvtvideoplayerbase.h"

#include "clcvtlocalvideoplayer.h"

#include "clcvtremotevideoplayer.h"

#include "tlcvtstates.h"

#include "clcvtcmdexecutor.h"

#include "mlcvtenginecommandmanager.h"

#include "lcvtplugincommand.h"

#include "lcvtutility.h"

// User selectable Call answer status values

const TInt KAllwaysQuery = 0;

const TInt KAllwaysAllow = 2;

// Default call index.

const TInt KVtUiDefaultCallId = 1;

// Granularity of command observer array.

const TInt KLcVtCommandObserverArrayGranularity = 5;

// Enumerates states for CLcVtActiveExec.

enum

    {    

    // Operation finished. Must equal to zero.

    EVtSessionNone,

    // Active execution states for iActiveExec:

    //     Startup (prepare engine):

    EVtSessionStartup = 100,                                    // 100

    //     Initialise engine.

    EVtSessionStartupInitEngine = EVtSessionStartup,            // 100

    //     Prepare viewfinder.

    EVtSessionStartupPrepareViewfinder,                         // 101

    //     Prepare remote render.

    EVtSessionStartupPrepareRemoteRender,                       // 102

    //     Startup Finish 

    EVtSessionStartupFinish,                                    // 103

    //     Shutdown (reset engine):

    EVtSessionShutdown = 300,                                   // 300

    //     Hide application.

    EVtSessionShutdownHideApplication = EVtSessionShutdown,     // 300

    //     Reset engine.

    EVtSessionShutdownResetEngine,                              // 301

    //     Answered:

    EVtSessionAnswered = 500,                                   // 500    

    //     Start remote render.

    EVtSessionAnsweredStartRemoteRender = EVtSessionAnswered,   // 500    

    //     Prepare Camere

    EVtSessionAnsweredDoPrepareCamera,                          // 501

    //     Select camera as source.

    EVtSessionAnsweredSetlectCamera,                            // 502

    //     Select blank image as source.

    EVtSessionAnsweredSetlectNone,

    //     Start view finder

    EVtSessionAnsweredStartViewFinder,                          // 504

    //     Show Application 

    EVtSessionAnsweredBringToForeground,                        // 505

    //EVtSessionAnswered = 500,                                   // 500

    //EVtSessionAnsweredBringToForeground = EVtSessionAnswered,                        // 505

    //     Finish.

    EVtSessionAnsweredFinish                                    // 506    

    };

/**

 * Encapsulates event handling.

 * @since Series 60 2.6

 */    

class CLcVtSession::CEventObserver

    : public CBase,

      public MLcVtEngineCommandManager,

      public MVtEngEventObserver,

#ifndef NGA_VIDEO_RENDER

      public MVtEngFrameObserver,

#endif

      public MVtEngCommandObserver

    {    

    public: // Constructors and destructors

        /**

        * Two-phased constructor.

        * @param aSession plugin session.

        */        

        static CEventObserver* NewL(CLcVtSession& aSession);

        /**

        * Destructor.

        */        

        ~CEventObserver();

    public: // Functions from base classes

        /**

        * @see MLcVtEngineCommandManager::AddObserverL.

        */

        void AddObserverL( MVtEngCommandObserver& aObserver );

        /**

        * @see MLcVtEngineCommandManager::RemoveObserver.

        */

        void RemoveObserver( MVtEngCommandObserver& aObserver );

        /**

        * @see MVtEngEventObserver::HandleVtEventL.

        */        

        void HandleVtEventL( TInt aEvent );

        /**

        * @see MVtEngCommandObserver::HandleVTCommandPerformedL.

        */        

        void HandleVTCommandPerformedL(

                TVtEngCommandId aCommand,

                const TInt aError );

#ifndef NGA_VIDEO_RENDER        

        /**

        * @see MVtEngFrameObserver::vtHandleFrameL.

        */        

        void vtHandleFrameL( TFrameType aType, CFbsBitmap* aBitmap );

        /**

        * @see MVtEngFrameObserver::vtSetFrame

        */        

        void vtSetFrame( TFrameType aType, CFbsBitmap* aBitmap );                 

#endif                                       

    private:

        /**

        * Constructor.

        * @param aSession plugin session.

        */

        CEventObserver(CLcVtSession& aSession );

        /**

        * Symbian OS constructor.

        */        

        void ConstructL();        

    private:        

        // Ref to plugin session.

        CLcVtSession& iSession;    

        // ETrue when command events are being sent.

        TBool iInCommandPerformed;

        // Owned array of observers.

        RPointerArray< MVtEngCommandObserver > iCommandObservers;

    };

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

//

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

//

CLcVtSession* CLcVtSession::NewL()

    {

    CLcVtSession* self = new ( ELeave ) CLcVtSession();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }     

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

//

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

//

CLcVtSession::CLcVtSession( ) 

    {

    }

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

//

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

//

void CLcVtSession::ConstructL()

    {

    __VTPRINTENTER( "CLcVtSession.ConstructL" )  

    __VTPRINT( DEBUG_MEDIA , "FeatureManager::InitializeLibL()" )

    FeatureManager::InitializeLibL(); 

    __VTPRINT( DEBUG_MEDIA , "iCameraHandler.SetSession(this)" )

    iCameraHandler.SetSession(this);

    __VTPRINT( DEBUG_MEDIA , "iRemoteVideoPlayer = CLcVtRemoteVideoPlayer_NewL" )

    iRemoteVideoPlayer = CLcVtRemoteVideoPlayer::NewL(this, *this);

    __VTPRINT( DEBUG_MEDIA , "iLocalVideoPlayer  = CLcVtLocalVideoPlayer_NewL" )

    iLocalVideoPlayer  = CLcVtLocalVideoPlayer::NewL(this, *this, iCameraHandler);  

#ifndef NGA_VIDEO_RENDER 

    iFbsStarted = EFalse;   

    __VTPRINT( DEBUG_MEDIA , "iWsSession = &(CCoeEnv::Static()->WsSession())" )

    iWsSession = &(CCoeEnv::Static()->WsSession());

    __VTPRINT( DEBUG_MEDIA , "iWsSessionScreenDev = CCoeEnv::Static()->ScreenDevice()" )

    iWsSessionScreenDev = CCoeEnv::Static()->ScreenDevice();

    __VTPRINT( DEBUG_MEDIA , "iRootWin = &(CCoeEnv::Static()->RootWin())" )

    iRootWin = &(CCoeEnv::Static()->RootWin());

    __VTPRINT( DEBUG_MEDIA , "ConnectFbsServerL()" )

    ConnectFbsServerL();    

#endif

    __VTPRINT( DEBUG_MEDIA , "iEventObserver = CEventObserver_NewL" )

    iEventObserver = CEventObserver::NewL( *this );

    iModel = CVtEngModel::NewL( *iEventObserver, *iEventObserver );

    __VTPRINT( DEBUG_MEDIA , "iLcVtStates_new" )

    iLcVtStates = new ( ELeave ) TLcVtStates( *iModel );

    __VTPRINT( DEBUG_MEDIA , "iLcVtStates->Update()" )

    iLcVtStates->Update();    

    __VTPRINT( DEBUG_MEDIA , "new_iActiveExec" )

    iActiveExec =

        new ( ELeave ) CLcVtActiveExec( CActive::EPriorityHigh );  

    __VTPRINT( DEBUG_MEDIA , "SetCallIdL( KVtUiDefaultCallId )" )

    SetCallIdL( KVtUiDefaultCallId );

    __VTPRINT( DEBUG_MEDIA , "iAsyncCallback" )

    iAsyncCallback =

        new ( ELeave ) CAsyncCallBack (

            TCallBack( &DoExit, this ),

            CActive::EPriorityStandard );   

#if 0    

    __VTPRINT( DEBUG_MEDIA , "iLayoutChangeCallback" )

    iLayoutChangeCallback =

        new ( ELeave ) CAsyncCallBack(

            TCallBack( &DelayedHandleLayoutChanged, this ),

            CActive::EPriorityStandard );   

#endif    

    CRepository* repository = CRepository::NewL( KCRUidTelephonySettings );

    if ( repository->Get( KSettingsVTVideoSending, VideoSendingKey ) == KErrNone )

        {

        __VTPRINT2( DEBUG_GEN, "CLcVtSession.IsFeatureSupported get key=%d", VideoSendingKey )

        }

    else

        {

        __VTPRINT( DEBUG_GEN, "CLcVtSession.IsFeatureSupported set key to default KAllwaysAllow" )

        VideoSendingKey = KAllwaysAllow;

        }

    delete repository;

    iIndicatorCtr = new  ( ELeave ) LcVtIndicatorController();

    iForeGroundStatus = EFalse;

    __VTPRINTEXIT( "CLcVtSession.ConstructL" )

    }

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

//

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

//

CLcVtSession::~CLcVtSession()

    {

    __VTPRINTENTER( "CLcVtSession.~CLcVtSession" )  

    //delete iLayoutChangeCallback;

    delete iAsyncCallback;

#ifndef NGA_VIDEO_RENDER    

    DisconnectFbsServer();

#endif

    delete iActiveExec;

    delete iLcVtStates;

    delete iModel;

    delete iEventObserver;

    iEventObserver = NULL;

#ifdef NGA_VIDEO_RENDER

    DestroyVideoWindows();

#endif

    delete iLocalVideoPlayer;

    delete iRemoteVideoPlayer;

    delete iRemoteDisplayName;

    delete iRemoteDetails;

    if (iIndicatorCtr) {

        iIndicatorCtr->disableActiveCallIndicator();

        delete iIndicatorCtr;

    }    

    __VTPRINTEXIT( "CLcVtSession.~CLcVtSession" )

    FeatureManager::UnInitializeLib();  

    }

#ifndef NGA_VIDEO_RENDER

void CLcVtSession::ConnectFbsServerL()

    {

    // VT use bitmaps viewfinder now, So we start FBS server for proto demo  

    // and later we will use Qt image object to implement bitmaps view finder or we will use direct view finder    

    TInt err( KErrNone );

    // Start Font&Bitmap server    

    err = FbsStartup();

    if ( err == KErrNone )

        {

       err = RFbsSession::Connect();

       if( err == KErrNone )

           {

           iFbsStarted = ETrue;

           }            

        }

    iDummy = new ( ELeave ) CFbsBitmap();  

    //CleanupStack::PushL( iDummy );

    User::LeaveIfError( iDummy->Create( TSize( 4096, 1 ), EColor64K ) );      

    iGc = new (ELeave) CWindowGc( iWsSessionScreenDev );

    //CleanupStack::PushL( iGc );

    User::LeaveIfError( iGc->Construct());

    //CleanupStack::Pop(2);

    }

void CLcVtSession::DisconnectFbsServer()

    {

    delete iGc;

    delete iDummy;    

    if ( iFbsStarted )

        {

        RFbsSession::Disconnect();

        iFbsStarted = EFalse;        

        }    

    }

#endif

#ifdef NGA_VIDEO_RENDER

_LIT(KVTWindowGroupName,"32VTPluginVideoWindow");

void CLcVtSession::CreateVideoWindowsL()

    {

    __VTPRINTENTER( "CLcVtSession.CreateVideoWindowsL" ) 

    User::LeaveIfError( iRwSession.Connect() );  

    iRwGroup = new (ELeave) RWindowGroup( iRwSession ) ;        

    iRwGroup->Construct( (TUint32)iRwGroup, EFalse );

    iRwGroup->SetName( KVTWindowGroupName );

    iRwGroup->SetOrdinalPosition( 1 , ECoeWinPriorityNeverAtFront );

    iRwGroup->AutoForeground(EFalse);

    iDev = new (ELeave) CWsScreenDevice( iRwSession );

    iDev->Construct( ); 

    iRemoteVideoWindow = new (ELeave) RWindow( iRwSession );

    iRemoteVideoWindow->Construct( *iRwGroup, (TUint32)iRemoteVideoWindow );

    TRect RMRect = RemoteVideoPlayer()->LcWindow()->LcWindowRect();

    iRemoteVideoWindow->SetExtent( RMRect.iTl, RMRect.Size() );

    iRemoteVideoWindow->SetOrdinalPosition( 1, ECoeWinPriorityNeverAtFront );

    iRemoteVideoWindow->Activate();

    iLocalVideoWindow = new (ELeave) RWindow( iRwSession );

    iLocalVideoWindow->Construct( *iRwGroup, (TUint32)iLocalVideoWindow );

    TRect VFRect = LocalVideoPlayer()->LcWindow()->LcWindowRect();

    iLocalVideoWindow->SetExtent( VFRect.iTl, VFRect.Size() );

    iLocalVideoWindow->SetOrdinalPosition( 1, ECoeWinPriorityNeverAtFront );

    iLocalVideoWindow->Activate();   

    iRwSession.Flush();  

    __VTPRINTEXIT( "CLcVtSession.CreateVideoWindowsL" )

    }

void CLcVtSession::DestroyVideoWindows()

    {

    delete iDev;

    iDev = NULL;

    delete iRemoteVideoWindow;

    iRemoteVideoWindow = NULL;

    delete iLocalVideoWindow;

    iLocalVideoWindow = NULL;

    delete iRwGroup;

    iRwGroup = NULL;

    iRwSession.Close();

    }

#endif

void CLcVtSession::SetLcSessionObserver( MLcSessionObserver* aObserver )

    {

    iObserver = aObserver;

    }

void CLcVtSession::SetLcUiProvider( MLcUiProvider* aUiProvider )

    {

    iUiProvider = aUiProvider;

    }

TBool CLcVtSession::IsBackgroundStartup()

    {

    return ETrue;

    }

TBool CLcVtSession::SendDialTone( TChar aKey )

    {

    iDtmfTone = aKey;

    __VTPRINT2( DEBUG_GEN, "CLcVtSession.SendDialTone: %d", iDtmfTone() )

    if ( Execute( KVtEngStartDtmfTone, &iDtmfTone ) != KErrNone )

        {

        return EFalse;

        }

    else

        {

        return ETrue;

        }

    }

void CLcVtSession::EstablishLcSessionL()

    {

    __VTPRINTENTER( "CLcVtSession.EstablishLcSessionL" )

    TLcVtStateBase::SetInitialStateL( *this, *iLcVtStates );

    __VTPRINTEXIT( "CLcVtSession.EstablishLcSessionL" )

    }

void CLcVtSession::TerminateLcSessionL()

    {

    __VTPRINTENTER( "CLcVtSession.TerminateLcSessionL" )    

    HandleCommandL( EPluginCmdEndActiveCall );

    __VTPRINTEXIT( "CLcVtSession.TerminateLcSessionL" )

    }

MLcVideoPlayer* CLcVtSession::RemoteVideoPlayer()

    {

    return iRemoteVideoPlayer;

    }

MLcVideoPlayer* CLcVtSession::LocalVideoPlayer()

    {

    return iLocalVideoPlayer;

    }

MLcSession::TLcSessionState CLcVtSession::LcSessionState() const

    {

    return iSessionState;

    }

const TDesC& CLcVtSession::LocalDisplayName()

    {

    return KNullDesC;

    }

const TDesC& CLcVtSession::RemoteDisplayName()

    {

    if ( iRemoteDisplayName )

        {

        return *iRemoteDisplayName;

        }

    return KNullDesC;

    }

TInt CLcVtSession::SetParameter( TInt aId, TInt aValue )

    {

     if (aId == 0)

         iMainWindow = reinterpret_cast<RWindow*>(aValue);

    return 0;

    }

TInt CLcVtSession::ParameterValue( TInt aId )

    {

    return 0;

    }

const TDesC& CLcVtSession::RemoteDetails()

    {

    if ( iRemoteDetails )

        {

        return *iRemoteDetails;

        }

    return KNullDesC;

    }

void CLcVtSession::UpdateLcSessionL()