1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  LiveComm Videotelephony Plugin session Class

    15 *

    16 */

    17 

    18 #include <e32base.h>

    19 #include <e32std.h>

    20 #include <e32cmn.h>

    21 #include <featmgr.h>

    22  

    23 #include <w32std.h>

    24 #include <coecntrl.h>

    25 #include <eikenv.h>

    26 #include <eikappui.h>

    27 #include <apgcli.h>

    28 

    29 #include "clcvtsession.h"

    30 

    31 #include "cvtengmodel.h"

    32 

    33 #include "clcvtvideoplayerbase.h"

    34 #include "clcvtlocalvideoplayer.h"

    35 #include "clcvtremotevideoplayer.h"

    36 #include "tlcvtstates.h"

    37 #include "clcvtcmdexecutor.h"

    38 #include "mlcvtenginecommandmanager.h"

    39 #include "lcvtplugincommand.h"

    40 #include "lcvtutility.h"

    41 

    42 // Default call index.

    43 const TInt KVtUiDefaultCallId = 1;

    44 

    45 // Granularity of command observer array.

    46 const TInt KLcVtCommandObserverArrayGranularity = 5;

    47 

    48 

    49 

    50 // Enumerates states for CLcVtActiveExec.

    51 enum

    52     {    

    53     // Operation finished. Must equal to zero.

    54     EVtSessionNone,

    55     

    56     // Active execution states for iActiveExec:

    57     

    58     //     Startup (prepare engine):

    59     EVtSessionStartup = 100,                                    // 100

    60     //     Initialise engine.

    61     EVtSessionStartupInitEngine = EVtSessionStartup,            // 100

    62     //     Prepare viewfinder.

    63     EVtSessionStartupPrepareViewfinder,                         // 101

    64     //     Prepare remote render.

    65     EVtSessionStartupPrepareRemoteRender,                       // 102

    66     //     Startup Finish 

    67     EVtSessionStartupFinish,                                    // 103

    68     

    69     //     Shutdown (reset engine):

    70     EVtSessionShutdown = 300,                                   // 300

    71     //     Hide application.

    72     EVtSessionShutdownHideApplication = EVtSessionShutdown,     // 300

    73     //     Reset engine.

    74     EVtSessionShutdownResetEngine,                              // 301

    75     

    76         

    77     //     Answered:

    78     EVtSessionAnswered = 500,                                   // 500    

    79     //     Start remote render.

    80     EVtSessionAnsweredStartRemoteRender = EVtSessionAnswered,   // 500    

    81     //     Prepare Camere

    82     EVtSessionAnsweredDoPrepareCamera,                          // 501

    83     //     Select camera as source.

    84     EVtSessionAnsweredSetlectCamera,                            // 502

    85     //     Select blank image as source.

    86     EVtSessionAnsweredSetlectNone,

    87     //     Start view finder

    88     EVtSessionAnsweredStartViewFinder,                          // 504

    89     //     Show Application 

    90     EVtSessionAnsweredBringToForeground,                        // 505

    91     

    92     //EVtSessionAnswered = 500,                                   // 500

    93     //EVtSessionAnsweredBringToForeground = EVtSessionAnswered,                        // 505

    94     

    95     //     Finish.

    96     EVtSessionAnsweredFinish                                    // 506    

    97     };

    98 

    99 

   100 /**

   101  * Encapsulates event handling.

   102  * @since Series 60 2.6

   103  */    

   104 class CLcVtSession::CEventObserver

   105     : public CBase,

   106       public MLcVtEngineCommandManager,

   107       public MVtEngEventObserver,

   108 #ifndef NGA_VIDEO_RENDER

   109       public MVtEngFrameObserver,

   110 #endif

   111       public MVtEngCommandObserver

   112     {    

   113     public: // Constructors and destructors

   114      

   115         /**

   116         * Two-phased constructor.

   117         * @param aSession plugin session.

   118         */        

   119         static CEventObserver* NewL(CLcVtSession& aSession);

   120         

   121         /**

   122         * Destructor.

   123         */        

   124         ~CEventObserver();

   125 

   126     public: // Functions from base classes

   127 

   128         /**

   129         * @see MLcVtEngineCommandManager::AddObserverL.

   130         */

   131         void AddObserverL( MVtEngCommandObserver& aObserver );

   132 

   133         /**

   134         * @see MLcVtEngineCommandManager::RemoveObserver.

   135         */

   136         void RemoveObserver( MVtEngCommandObserver& aObserver );

   137         

   138         /**

   139         * @see MVtEngEventObserver::HandleVtEventL.

   140         */        

   141         void HandleVtEventL( TInt aEvent );

   142         

   143         /**

   144         * @see MVtEngCommandObserver::HandleVTCommandPerformedL.

   145         */        

   146         void HandleVTCommandPerformedL(

   147                 TVtEngCommandId aCommand,

   148                 const TInt aError );

   149 #ifndef NGA_VIDEO_RENDER        

   150         /**

   151         * @see MVtEngFrameObserver::vtHandleFrameL.

   152         */        

   153         void vtHandleFrameL( TFrameType aType, CFbsBitmap* aBitmap );

   154         

   155         /**

   156         * @see MVtEngFrameObserver::vtSetFrame

   157         */        

   158         void vtSetFrame( TFrameType aType, CFbsBitmap* aBitmap );                 

   159 #endif                                       

   160     private:

   161         

   162         /**

   163         * Constructor.

   164         * @param aSession plugin session.

   165         */

   166         CEventObserver(CLcVtSession& aSession );

   167         

   168         /**

   169         * Symbian OS constructor.

   170         */        

   171         void ConstructL();        

   172           

   173     private:        

   174         

   175         // Ref to plugin session.

   176         CLcVtSession& iSession;    

   177         

   178         // ETrue when command events are being sent.

   179         TBool iInCommandPerformed;

   180 

   181         // Owned array of observers.

   182         RPointerArray< MVtEngCommandObserver > iCommandObservers;

   183         

   184     };

   185 

   186          

   187 // -----------------------------------------------------------------------------

   188 //

   189 // -----------------------------------------------------------------------------

   190 //

   191 CLcVtSession* CLcVtSession::NewL()

   192     {

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

   194     CleanupStack::PushL( self );

   195     self->ConstructL();

   196     CleanupStack::Pop( self );

   197     return self;

   198     }     

   199 

   200 // -----------------------------------------------------------------------------

   201 //

   202 // -----------------------------------------------------------------------------

   203 //

   204 CLcVtSession::CLcVtSession( ) 

   205     {

   206     }

   207 

   208 // -----------------------------------------------------------------------------

   209 //

   210 // -----------------------------------------------------------------------------

   211 //

   212 void CLcVtSession::ConstructL()

   213     {

   214     

   215     __VTPRINTENTER( "CLcVtSession.ConstructL" )  

   216       

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

   218     FeatureManager::InitializeLibL(); 

   219         

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

   221     iCameraHandler.SetSession(this);

   222     __VTPRINT( DEBUG_MEDIA , "iRemoteVideoPlayer = CLcVtRemoteVideoPlayer_NewL" )

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

   224     __VTPRINT( DEBUG_MEDIA , "iLocalVideoPlayer  = CLcVtLocalVideoPlayer_NewL" )

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

   226 

   227 #ifndef NGA_VIDEO_RENDER 

   228     iFbsStarted = EFalse;   

   229             

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

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

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

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

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

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

   236     

   237     __VTPRINT( DEBUG_MEDIA , "ConnectFbsServerL()" )

   238     ConnectFbsServerL();    

   239 #endif

   240     __VTPRINT( DEBUG_MEDIA , "iEventObserver = CEventObserver_NewL" )

   241     iEventObserver = CEventObserver::NewL( *this );

   242 

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

   244 

   245     __VTPRINT( DEBUG_MEDIA , "iLcVtStates_new" )

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

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

   248     iLcVtStates->Update();    

   249     

   250     __VTPRINT( DEBUG_MEDIA , "new_iActiveExec" )

   251     iActiveExec =

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

   253         

   254     __VTPRINT( DEBUG_MEDIA , "SetCallIdL( KVtUiDefaultCallId )" )

   255     SetCallIdL( KVtUiDefaultCallId );

   256     

   257     __VTPRINT( DEBUG_MEDIA , "iAsyncCallback" )

   258     iAsyncCallback =

   259         new ( ELeave ) CAsyncCallBack (

   260             TCallBack( &DoExit, this ),

   261             CActive::EPriorityStandard );   

   262 #if 0    

   263     __VTPRINT( DEBUG_MEDIA , "iLayoutChangeCallback" )

   264     iLayoutChangeCallback =

   265         new ( ELeave ) CAsyncCallBack(

   266             TCallBack( &DelayedHandleLayoutChanged, this ),

   267             CActive::EPriorityStandard );   

   268 #endif    

   269     __VTPRINTEXIT( "CLcVtSession.ConstructL" )

   270     

   271     }

   272 

   273 // -----------------------------------------------------------------------------

   274 //

   275 // -----------------------------------------------------------------------------

   276 //

   277 CLcVtSession::~CLcVtSession()

   278     {

   279     __VTPRINTENTER( "CLcVtSession.~CLcVtSession" )  

   280 

   281     //delete iLayoutChangeCallback;

   282     delete iAsyncCallback;

   283 

   284 #ifndef NGA_VIDEO_RENDER    

   285     DisconnectFbsServer();

   286 #endif

   287     delete iActiveExec;

   288     delete iLcVtStates;

   289 

   290     delete iModel;

   291     

   292     delete iEventObserver;

   293     iEventObserver = NULL;

   294     

   295 #ifdef NGA_VIDEO_RENDER

   296     DestroyVideoWindows();

   297 #endif

   298 

   299     delete iLocalVideoPlayer;

   300     delete iRemoteVideoPlayer;

   301     

   302     delete iRemoteDisplayName;

   303     delete iRemoteDetails;

   304     __VTPRINTEXIT( "CLcVtSession.~CLcVtSession" )

   305     FeatureManager::UnInitializeLib();  

   306     }

   307 

   308 #ifndef NGA_VIDEO_RENDER

   309 void CLcVtSession::ConnectFbsServerL()

   310     {

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

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

   313     TInt err( KErrNone );

   314     // Start Font&Bitmap server    

   315     err = FbsStartup();

   316     if ( err == KErrNone )

   317         {

   318        err = RFbsSession::Connect();

   319        if( err == KErrNone )

   320            {

   321            iFbsStarted = ETrue;

   322            }            

   323         }

   324     

   325     iDummy = new ( ELeave ) CFbsBitmap();  

   326     //CleanupStack::PushL( iDummy );

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

   328     

   329     iGc = new (ELeave) CWindowGc( iWsSessionScreenDev );

   330     //CleanupStack::PushL( iGc );

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

   332     

   333     //CleanupStack::Pop(2);

   334     }

   335 

   336 

   337 void CLcVtSession::DisconnectFbsServer()

   338     {

   339     delete iGc;

   340     delete iDummy;    

   341     if ( iFbsStarted )

   342         {

   343         RFbsSession::Disconnect();

   344         iFbsStarted = EFalse;        

   345         }    

   346     }

   347 #endif

   348 #ifdef NGA_VIDEO_RENDER

   349 

   350 _LIT(KVTWindowGroupName,"32VTPluginVideoWindow");

   351 

   352 void CLcVtSession::CreateVideoWindowsL()

   353     {

   354     __VTPRINTENTER( "CLcVtSession.CreateVideoWindowsL" ) 

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

   356 

   357     iRwGroup = new (ELeave) RWindowGroup( iRwSession ) ;        

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

   359     

   360     iRwGroup->SetName( KVTWindowGroupName );

   361     iRwGroup->SetOrdinalPosition( 1 , ECoeWinPriorityNeverAtFront );

   362     iRwGroup->AutoForeground(EFalse);

   363     

   364     iDev = new (ELeave) CWsScreenDevice( iRwSession );

   365     iDev->Construct( ); 

   366     

   367     iRemoteVideoWindow = new (ELeave) RWindow( iRwSession );

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

   369     

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

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

   372     iRemoteVideoWindow->SetOrdinalPosition( 1, ECoeWinPriorityNeverAtFront );

   373     iRemoteVideoWindow->Activate();

   374     

   375     iLocalVideoWindow = new (ELeave) RWindow( iRwSession );

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

   377     

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

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

   380     iLocalVideoWindow->SetOrdinalPosition( 1, ECoeWinPriorityNeverAtFront );

   381     iLocalVideoWindow->Activate();   

   382         

   383     iRwSession.Flush();  

   384 

   385     __VTPRINTEXIT( "CLcVtSession.CreateVideoWindowsL" )

   386     }

   387 

   388 void CLcVtSession::DestroyVideoWindows()

   389     {

   390     

   391     delete iDev;

   392     iDev = NULL;

   393     delete iRemoteVideoWindow;

   394     iRemoteVideoWindow = NULL;

   395     delete iLocalVideoWindow;

   396     iLocalVideoWindow = NULL;

   397     delete iRwGroup;

   398     iRwGroup = NULL;

   399     iRwSession.Close();

   400     }

   401 

   402 #endif

   403 

   404 

   405 void CLcVtSession::SetLcSessionObserver( MLcSessionObserver* aObserver )

   406     {

   407     iObserver = aObserver;

   408     }

   409 

   410 void CLcVtSession::SetLcUiProvider( MLcUiProvider* aUiProvider )

   411     {

   412     iUiProvider = aUiProvider;

   413     }

   414     

   415 TBool CLcVtSession::IsBackgroundStartup()

   416     {

   417     return ETrue;

   418     }

   419   

   420 TBool CLcVtSession::SendDialTone( TChar aKey )

   421     {

   422     iDtmfTone = aKey;

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

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

   425         {

   426         return EFalse;

   427         }

   428     else

   429         {

   430         return ETrue;

   431         }

   432     }

   433 

   434 void CLcVtSession::EstablishLcSessionL()

   435     {

   436     __VTPRINTENTER( "CLcVtSession.EstablishLcSessionL" )

   437     

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

   439     

   440     __VTPRINTEXIT( "CLcVtSession.EstablishLcSessionL" )

   441     }

   442 

   443 void CLcVtSession::TerminateLcSessionL()

   444     {

   445     __VTPRINTENTER( "CLcVtSession.TerminateLcSessionL" )    

   446     

   447     HandleCommandL( EPluginCmdEndActiveCall );

   448     

   449     __VTPRINTEXIT( "CLcVtSession.TerminateLcSessionL" )

   450     }

   451 

   452 MLcVideoPlayer* CLcVtSession::RemoteVideoPlayer()

   453     {

   454     return iRemoteVideoPlayer;

   455     }

   456 

   457 MLcVideoPlayer* CLcVtSession::LocalVideoPlayer()

   458     {

   459     return iLocalVideoPlayer;

   460     }

   461 

   462 MLcSession::TLcSessionState CLcVtSession::LcSessionState() const

   463     {

   464     return iSessionState;

   465     }

   466 

   467 const TDesC& CLcVtSession::LocalDisplayName()

   468     {

   469     return KNullDesC;

   470     }

   471 const TDesC& CLcVtSession::RemoteDisplayName()

   472     {

   473     if ( iRemoteDisplayName )

   474         {

   475         return *iRemoteDisplayName;

   476         }

   477     return KNullDesC;

   478     }

   479     

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

   481     {

   482      if (aId == 0)

   483          iMainWindow = reinterpret_cast<RWindow*>(aValue);

   484          

   485     return 0;

   486     }

   487 

   488 TInt CLcVtSession::ParameterValue( TInt aId )

   489     {

   490     return 0;

   491     }

   492 

   493 const TDesC& CLcVtSession::RemoteDetails()

   494     {

   495     if ( iRemoteDetails )

   496         {

   497         return *iRemoteDetails;

   498         }

   499     return KNullDesC;

   500     }

   501 

   502 void CLcVtSession::UpdateLcSessionL()

   503     {     

   504     __VTPRINTENTER( "CLcVtSession.UpdateLcSessionL" )

   505     

   506     if(iLcVtStates->ExecState() != TLcVtStates::EExecStateRunning )

   507         {

   508         __VTPRINTEXIT( "CLcVtSession.UpdateLcSessionL -- State Not OK" )

   509         return;

   510         }

   511 #if 0    

   512     if(iLocalVideoPlayer->IsOrientationChanged())

   513         HandleLayoutChanged();

   514     else

   515         UpdateRenderingParametersL();

   516 #endif

   517     UpdateRenderingParametersL();

   518     __VTPRINTEXIT( "CLcVtSession.UpdateLcSessionL" )

   519     }

   520     

   521 // -----------------------------------------------------------------------------

   522 // From MLcAudioControl

   523 // -----------------------------------------------------------------------------

   524 //

   525 TBool CLcVtSession::IsLcAudioMutedL()

   526     {

   527     return EFalse;

   528     }

   529 

   530 // -----------------------------------------------------------------------------

   531 // From MLcAudioControl

   532 // -----------------------------------------------------------------------------

   533 //

   534 void CLcVtSession::MuteLcAudioL( TBool aMute )

   535     {

   536     }

   537 

   538 // -----------------------------------------------------------------------------

   539 // From MLcAudioControl

   540 // -----------------------------------------------------------------------------

   541 //

   542 TBool CLcVtSession::IsLcMicMutedL()

   543     {    

   544     TBool result = !(iLcVtStates->AudioState().IsAudio());

   545     __VTPRINT2( DEBUG_GEN, "CLcVtSession.IsLcMicMutedL = %d", result )

   546     return result;  

   547     }

   548 

   549 // -----------------------------------------------------------------------------

   550 // From MLcAudioControl

   551 // -----------------------------------------------------------------------------

   552 //

   553 void CLcVtSession::MuteLcMicL( TBool aMute )

   554     {   

   555     __VTPRINT2( DEBUG_GEN, "CLcVtSession.MuteLcMicL aMute =  %d", aMute )

   556 

   557     if(aMute)

   558         {      

   559         HandleCommandL(EPluginCmdDisableAudio);

   560         }

   561     else

   562         {

   563         HandleCommandL(EPluginCmdEnableAudio);     

   564         }

   565     }

   566 

   567 // -----------------------------------------------------------------------------

   568 // From MLcAudioControl

   569 // -----------------------------------------------------------------------------

   570 //

   571 TBool CLcVtSession::IsEnablingLcLoudspeakerAllowed()

   572     {

   573     return ETrue;

   574     }

   575 

   576 // -----------------------------------------------------------------------------

   577 // From MLcAudioControl

   578 // -----------------------------------------------------------------------------

   579 //

   580 void CLcVtSession::EnableLcLoudspeakerL( TBool aEnabled )

   581     {

   582     __VTPRINT2( DEBUG_GEN, "CLcVtSession.EnableLcLoudspeakerL aEnabled =  %d", aEnabled )    

   583     

   584     if(aEnabled)

   585         {

   586         HandleCommandL(EPluginCmdActivateLoudspeaker);

   587         }

   588     else

   589         {

   590         HandleCommandL(EPluginCmdDeactivateLoudspeaker);

   591         }

   592     }

   593 

   594 // -----------------------------------------------------------------------------

   595 // From MLcAudioControl

   596 // -----------------------------------------------------------------------------

   597 //

   598 TBool CLcVtSession::IsLcLoudspeakerEnabled()

   599     {

   600     TBool result = !(iLcVtStates->AudioState().CanActivateLoudspeaker());

   601     __VTPRINT2( DEBUG_GEN, "CLcVtSession.IsLcLoudspeakerEnabled = %d", result )

   602     return result;    

   603     }

   604 

   605 // -----------------------------------------------------------------------------

   606 // From MLcAudioControl

   607 // -----------------------------------------------------------------------------

   608 //

   609 TInt CLcVtSession::LcVolumeL()

   610     {

   611     MVtEngAudio& audio = iModel->Audio();

   612     MVtEngAudio::TAudioRoutingState audioRouting;

   613     User::LeaveIfError( audio.GetRoutingState( audioRouting ) );

   614     const TInt volume( audio.OutputVolume(

   615         !( audioRouting == MVtEngAudio::EAudioLoudspeaker ) ) );

   616     

   617     return volume;

   618     }

   619 

   620 // -----------------------------------------------------------------------------

   621 // From MLcAudioControl

   622 // -----------------------------------------------------------------------------

   623 //

   624 void CLcVtSession::SetLcVolumeL( TInt aValue )

   625     {   

   626     __VTPRINTENTER( "CLcVtSession.SetLcVolumeL" )

   627     MVtEngAudio& audio = iModel->Audio();

   628     const TInt HandsetVolume( audio.OutputVolume(ETrue) );    

   629     const TInt HandsfreeVolume( audio.OutputVolume(EFalse) );    

   630     MVtEngAudio::TVtEngOutputVolume volume;

   631     volume.iHandsetVolume = HandsetVolume;

   632     volume.iHandsfreeVolume = HandsfreeVolume;

   633 

   634     MVtEngAudio::TAudioRoutingState audioRouting;

   635     User::LeaveIfError( audio.GetRoutingState( audioRouting ) );    

   636     if(audioRouting == MVtEngAudio::EAudioHandset)

   637         volume.iHandsetVolume = aValue;

   638     else

   639         volume.iHandsfreeVolume = aValue;    

   640     

   641     ExecuteCmdL( KVtEngSetAudioVolume, volume );

   642     __VTPRINTEXIT( "CLcVtSession.SetLcVolumeL" )

   643     }

   644 

   645 // -----------------------------------------------------------------------------

   646 // From MLcAudioControl

   647 // -----------------------------------------------------------------------------

   648 //

   649 void CLcVtSession::IncreaseLcVolumeL()

   650     {

   651     ExecuteCmdL( KVtEngIncreaseAudioVolume );

   652     }

   653 

   654 // -----------------------------------------------------------------------------

   655 // From MLcAudioControl

   656 // -----------------------------------------------------------------------------

   657 //

   658 void CLcVtSession::DecreaseLcVolumeL()

   659     {

   660     ExecuteCmdL( KVtEngDecreaseAudioVolume );

   661     }

   662 

   663 CVtEngModel& CLcVtSession::Model()

   664     {

   665     return *iModel;

   666     }

   667 

   668 

   669 void CLcVtSession::HandleCommandL(const TInt aCommand)

   670     {

   671     

   672     __VTPRINTENTER( "CLcVtSession.HandleCommandL" )

   673     

   674     if ( iLcVtStates->ExecState() != TLcVtStates::EExecStateRunning )

   675         {

   676         __VTPRINTEXIT( "CLcVtSession.HandleCommandL NOT ready" )

   677         return;

   678         }

   679     

   680     if (  iState->HandleCommandL( aCommand ) == TLcVtStateBase::EEventHandled )

   681         {

   682         __VTPRINTEXIT( "CLcVtSession.HandleCommandL <silently ignoring> 0" )

   683         return;

   684         }   

   685         

   686     __VTPRINT2( DEBUG_GEN, "CLcVtSession.HandleCommandL command =  %d", aCommand )

   687     

   688     switch ( aCommand )

   689         {

   690         case EPluginCmdEnableAudio:

   691             CmdEnableAudioL();

   692             break;

   693             

   694         case EPluginCmdDisableAudio:

   695             CmdDisableAudioL();

   696             break;

   697             

   698         case EPluginCmdUsePrimaryCamera:

   699             CmdUseCameraL( ETrue );

   700             break;

   701             

   702         case EPluginCmdUseSecondaryCamera:

   703             CmdUseCameraL( EFalse );

   704             break;

   705             

   706         case EPluginCmdEnableVideo:

   707             CmdEnableVideoL();

   708             break;

   709             

   710         case EPluginCmdDisableVideo:

   711             CmdDisableVideoL();

   712             break;

   713             

   714         case EPluginCmdActivateLoudspeaker:

   715             CmdActivateLoudspeakerL();

   716             break;

   717             

   718         case EPluginCmdDeactivateLoudspeaker:

   719             CmdDeactivateLoudspeakerL();

   720             break;

   721             

   722         }

   723     

   724     __VTPRINTEXIT( "CLcVtSession.HandleCommandL" )

   725     

   726     iLcVtStates->Update();

   727     }

   728 

   729 // -----------------------------------------------------------------------------

   730 // CLcVtSession::CmdEnableAudioL

   731 // -----------------------------------------------------------------------------

   732 //

   733 void CLcVtSession::CmdEnableAudioL()

   734     {

   735     ExecuteCmdL( KVtEngUnmuteOutgoingAudio );

   736     iLcVtStates->Update();

   737     }

   738 

   739 

   740 // -----------------------------------------------------------------------------

   741 // CLcVtSession::CmdDisableAudioL

   742 // -----------------------------------------------------------------------------

   743 //

   744 void CLcVtSession::CmdDisableAudioL()

   745     {

   746     ExecuteCmdL( KVtEngMuteOutgoingAudio );

   747     iLcVtStates->Update();

   748     }

   749 

   750 

   751 // -----------------------------------------------------------------------------

   752 // CLcVtSession::CmdUseCameraL

   753 // -----------------------------------------------------------------------------

   754 //

   755 void CLcVtSession::CmdUseCameraL( const TBool aPrimaryCamera )

   756     {

   757 

   758     MVtEngMedia& media = iModel->Media();

   759 

   760     MVtEngMedia::TMediaSource selectedSource =

   761         ( aPrimaryCamera ) ?

   762             MVtEngMedia::EMediaCameraPri : MVtEngMedia::EMediaCameraSec;

   763 

   764     TInt available = 0;

   765     LcVtUtility::GetOutgoingMediaState( media, available );

   766     if ( available & MVtEngMedia::EMediaVideo )

   767         {

   768         ExecuteCmdL( KVtEngStopViewFinder );

   769         

   770         TRAPD( err, ExecuteCmdL( KVtEngSetSource, selectedSource ) );

   771 

   772         if ( err == KErrNone )

   773             {

   774             ExecuteCmdL( KVtEngStartViewFinder );

   775             }

   776         else

   777             {

   778             //ShowOtherCameraNotUsableNoteL();

   779             }

   780         }

   781     else

   782         {

   783         /*

   784         MVtEngMedia::TPrepareCameraParams params;

   785         params.iMediaSource = selectedSource;

   786         params.iInitialize = EFalse;

   787         TRAPD( err, ExecuteCmdL( KVtEngPrepareCamera, params ) );

   788         if ( err != KErrNone )

   789             {

   790             ShowOtherCameraNotUsableNoteL();

   791             }

   792             */

   793         }

   794     

   795     }

   796 

   797 

   798 // -----------------------------------------------------------------------------

   799 // CLcVtSession::CmdEnableVideoL

   800 // -----------------------------------------------------------------------------

   801 //

   802 void CLcVtSession::CmdEnableVideoL()

   803     {

   804     // if outgoing video is frozen

   805     MVtEngMedia& media = iModel->Media();

   806     if ( LcVtUtility::GetFreezeState( media ) )

   807         {

   808         ExecuteCmdL( KVtEngUnfreeze );

   809         // swap images if needed

   810         //RestoreViewFinderL();

   811         }

   812     else

   813         {

   814         ExecuteCmdL( KVtEngStopViewFinder );

   815         //iUplinkWindow->SetStreamBitmap( NULL );

   816         MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaCamera;

   817         ExecuteCmdL( KVtEngSetSource, source );

   818         MVtEngMedia::TCameraId id;

   819         if ( iModel->Media().GetCurrentCameraId( id ) == KErrInUse )

   820             {

   821             //ShowCameraInUseNoteL();

   822             }

   823         ExecuteCmdL( KVtEngStartViewFinder );

   824         }

   825     // update VB settings

   826     //UpdateVBSettingL();

   827     iLcVtStates->Update();

   828     }

   829 

   830 // -----------------------------------------------------------------------------

   831 // CLcVtSession::CmdDisableVideoL

   832 // -----------------------------------------------------------------------------

   833 //

   834 void CLcVtSession::CmdDisableVideoL()

   835     {

   836     ExecuteCmdL( KVtEngStopViewFinder );

   837 

   838     //iUplinkWindow->SetStreamBitmap( NULL );

   839 

   840     TInt err = KErrNotFound;

   841     if ( LcVtUtility::HasStillImage( iModel->Media() ) )

   842         {

   843         __VTPRINT( DEBUG_GEN, "VtUi.:CmdDisableVideoL.HasStill" )

   844         MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaStillImage;

   845         TRAP( err, ExecuteCmdL( KVtEngSetSource, source ) );

   846         }

   847     if ( ( err != KErrNone ) )

   848         {

   849         __VTPRINT( DEBUG_GEN, "VtUi.:CmdDisableVideoL.MediaNone" )

   850         MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaNone;

   851         ExecuteCmdL( KVtEngSetSource, source );

   852         }

   853 

   854     ExecuteCmdL( KVtEngStartViewFinder );

   855     iLcVtStates->Update();

   856     }

   857 

   858 // -----------------------------------------------------------------------------

   859 // CLcVtSession::CmdActivateLoudspeakerL

   860 // -----------------------------------------------------------------------------

   861 //

   862 void CLcVtSession::CmdActivateLoudspeakerL()

   863     {

   864     MVtEngAudio::TVtEngRoutingSetting audioSetting =

   865         MVtEngAudio::EActivateHandsfree;

   866     ExecuteCmdL( KVtEngSetAudioRouting, audioSetting );

   867     iLcVtStates->Update();

   868     }

   869 

   870 // -----------------------------------------------------------------------------

   871 // CLcVtSession::CmdDeactivateLoudspeakerL

   872 // -----------------------------------------------------------------------------

   873 //

   874 void CLcVtSession::CmdDeactivateLoudspeakerL()

   875     {

   876     MVtEngAudio::TVtEngRoutingSetting audioSetting =

   877         MVtEngAudio::EDeactivateHansfree;

   878     ExecuteCmdL( KVtEngSetAudioRouting, audioSetting );

   879     iLcVtStates->Update();

   880     }

   881 

   882 

   883 // -----------------------------------------------------------------------------

   884 // CLcVtSession::SetZoomFactorL

   885 // -----------------------------------------------------------------------------

   886 //

   887 void CLcVtSession::SetZoomFactorL( TInt aZoomStep )

   888     {

   889     __VTPRINTENTER( "CLcVtSessionCLcVtSession.SetZoomFactorL" )

   890     MVtEngMedia& media = iModel->Media();

   891     if ( LcVtUtility::IsZoomAllowed( media ) )

   892         {

   893         ExecuteCmdL( KVtEngSetZoomStep, aZoomStep );

   894         }

   895     __VTPRINTEXIT( "CLcVtSession.SetZoomFactorL" )

   896     }

   897 

   898 #ifndef NGA_VIDEO_RENDER

   899 //local video display, VT use bitmaps vf now, and maybe replace by direct vf later

   900 void CLcVtSession::vtHandleFrameL( CFbsBitmap* aBitmap )

   901     {

   902     __VTPRINTENTER( "CLcVtSession.vtHandleFrameL" )   

   903     

   904     /*    

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

   906     const TPoint KVFcordinate( VFRect.iTl.iX,  VFRect.iTl.iY );    

   907     iMainWindow->Invalidate();

   908     iMainWindow->BeginRedraw();

   909     iGc->Activate( *iMainWindow );

   910     aBitmap->BeginDataAccess();

   911     aBitmap->EndDataAccess();

   912     iGc->BitBlt( KVFcordinate , aBitmap );

   913     iGc->Deactivate();

   914     iMainWindow->EndRedraw();

   915     */

   916     

   917     /*

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

   919     const TPoint KVFcordinate( VFRect.iTl.iX -2 ,  VFRect.iTl.iY - 168 );

   920     iLocalVideoWindow->Invalidate();

   921     iLocalVideoWindow->BeginRedraw();

   922     iGc->Activate( *iLocalVideoWindow );

   923     iGc->BitBlt( KVFcordinate , aBitmap );

   924     iGc->Deactivate();

   925     iLocalVideoWindow->EndRedraw();

   926     */   

   927         

   928     __VTPRINTEXIT("CLcVtSession.vtHandleFrameL")     

   929     }

   930 #endif

   931 

   932 TInt CLcVtSession::SetForegroundStatus( TBool aIsForeground )

   933 {

   934     __VTPRINTENTER( "CLcVtSession.SetForegroundStatus" )

   935     __VTPRINT2( DEBUG_MEDIA , "    foreground: %d", aIsForeground )

   936 

   937     if ( iRwGroup )

   938         {

   939         TInt priority = aIsForeground ? ECoeWinPriorityNormal : ECoeWinPriorityNeverAtFront;

   940         iRwGroup->SetOrdinalPosition( 1 , priority );

   941         iRemoteVideoWindow->SetOrdinalPosition( 1 , priority );

   942         iLocalVideoWindow->SetOrdinalPosition( 1 , priority );

   943         iRwSession.Flush();

   944         }

   945     __VTPRINTEXIT( "CLcVtSession.SetForegroundStatus" )

   946     

   947     return KErrNone;   

   948 }

   949 

   950 // -----------------------------------------------------------------------------

   951 // CLcVtSession::ShutdownL

   952 // -----------------------------------------------------------------------------

   953 //

   954 void CLcVtSession::ShutdownL()

   955     {

   956     __VTPRINTENTER( "CLcVtSession.ShutdownL" )

   957     iActiveExec->Start( EVtSessionShutdown, *this );

   958     __VTPRINTEXIT( "CLcVtSession.ShutdownL" )

   959     }

   960 

   961 // -----------------------------------------------------------------------------

   962 // CLcVtSession::StartupPhase1L

   963 // -----------------------------------------------------------------------------

   964 //

   965 void CLcVtSession::StartupPhase1L()

   966     {

   967     __VTPRINTENTER( "CLcVtSession.StartupPhase1L" )

   968     iActiveExec->Start( EVtSessionStartup, *this );

   969     __VTPRINTEXIT( "CLcVtSession.StartupPhase1L" )

   970     }

   971 

   972 

   973 // -----------------------------------------------------------------------------

   974 // CLcVtSession::StartupPhase2L

   975 // -----------------------------------------------------------------------------

   976 //

   977 void CLcVtSession::StartupPhase2L()

   978     {

   979     __VTPRINTENTER( "CLcVtSession.StartupPhase2L" )

   980     iActiveExec->Start( EVtSessionAnswered, *this );

   981     __VTPRINTEXIT( "CLcVtSession.StartupPhase2L" )

   982     }

   983 

   984 // -----------------------------------------------------------------------------

   985 // CLcVtSession::ActiveExecExecuteL

   986 // -----------------------------------------------------------------------------

   987 //

   988 TBool CLcVtSession::ActiveExecExecuteL(

   989         CLcVtActiveExec& /*aActiveExec*/,

   990         const TInt aState,

   991         TInt& aNextState,

   992         TRequestStatus& aRequest )

   993     {

   994     return ActiveExecInitExecuteL(

   995             aState,

   996             aNextState,

   997             aRequest );

   998     }

   999 

  1000 // -----------------------------------------------------------------------------

  1001 // CLcVtSession::ActiveExecContinue

  1002 // -----------------------------------------------------------------------------

  1003 //

  1004 TBool CLcVtSession::ActiveExecContinue(

  1005         CLcVtActiveExec& /*aActiveExec*/,

  1006         TInt& aState,

  1007         const TInt aError )

  1008     {

  1009     return ActiveExecInitContinue( aState, aError );

  1010     }

  1011 

  1012 // -----------------------------------------------------------------------------

  1013 // CLcVtSession::ActiveExecCancel

  1014 // -----------------------------------------------------------------------------

  1015 //

  1016 void CLcVtSession::ActiveExecCancel(

  1017         CLcVtActiveExec& /*aActiveExec*/,

  1018         TInt aState )

  1019     {

  1020     ActiveExecInitCancel( aState );

  1021     }

  1022 

  1023 // -----------------------------------------------------------------------------

  1024 // CLcVtSession::ActiveExecDone

  1025 // -----------------------------------------------------------------------------

  1026 //

  1027 void CLcVtSession::ActiveExecDone(

  1028         CLcVtActiveExec& /*aActiveExec*/,

  1029         const TInt aInitialState )

  1030     {    

  1031     ActiveExecInitDone( aInitialState );

  1032     }

  1033 

  1034 

  1035 // -----------------------------------------------------------------------------

  1036 // CLcVtSession::ActiveExecInitCancel

  1037 // -----------------------------------------------------------------------------

  1038 //

  1039 void CLcVtSession::ActiveExecInitCancel(

  1040         const TInt /*aState*/ )

  1041     {

  1042     __VTPRINTENTER( "CLcVtSession.InitExecCancel" )

  1043     

  1044     delete iCmdExecutor;

  1045 

  1046     if ( iShutdownRequest )

  1047         {

  1048         User::RequestComplete( iShutdownRequest, KErrCancel );

  1049         iShutdownRequest = NULL;

  1050         }

  1051     __VTPRINTEXIT( "CLcVtSession.InitExecCancel" )

  1052     }

  1053 

  1054 // -----------------------------------------------------------------------------

  1055 // CLcVtSession::ActiveExecInitDone

  1056 // -----------------------------------------------------------------------------

  1057 //

  1058 void CLcVtSession::ActiveExecInitDone(

  1059         const TInt aInitialState )

  1060     {

  1061     __VTPRINTENTER( "CLcVtSession.ExecInitDone" )

  1062     __VTPRINT2( DEBUG_GEN, "CLcVtSession.InitExecDone.ini=%d", aInitialState )

  1063     // Operation succeeded

  1064     

  1065     // Now we have finished.

  1066     if ( iState )

  1067         {

  1068         if ( aInitialState == EVtSessionAnswered )

  1069             {

  1070             TRAP_IGNORE( iState->LcVtStartupPhase2DoneL() );

  1071 			iSessionState = EOpen;

  1072             iObserver->StateChanged( *this );             

  1073             }

  1074         else if ( aInitialState == EVtSessionShutdown )

  1075             {

  1076             TRAP_IGNORE( iState->ShutdownDoneL() );

  1077             }

  1078         else // EVtSessionStartup

  1079             {

  1080             TRAP_IGNORE( iState->LcVtStartupPhase1DoneL() );

  1081             }

  1082         }

  1083     __VTPRINTEXIT( "CLcVtSession.ExecInitDone" )

  1084     }

  1085 

  1086 

  1087 // -----------------------------------------------------------------------------

  1088 // CLcVtSession::ActiveExecInitExecuteL

  1089 // -----------------------------------------------------------------------------

  1090 //

  1091 TBool CLcVtSession::ActiveExecInitExecuteL(

  1092         const TInt aState,

  1093         TInt& aNextState,

  1094         TRequestStatus& aRequest )

  1095     {

  1096     __VTPRINTENTER( "CLcVtSession.ActiveExecInitExecuteL" )

  1097     __VTPRINT2( DEBUG_GEN, "CLcVtSession.ActiveExecInitExecuteL.st=%d", aState )

  1098 

  1099     TBool synch = EFalse;

  1100 

  1101     switch ( aState )

  1102         {

  1103         // Startup chain:

  1104         case EVtSessionStartupInitEngine:

  1105             //ChangeApplicationFocus(ETrue);

  1106 #if defined (__WINS__)

  1107             ActiveExecInitExecuteCommandL( KVtEngInitializeEngineDiag, aRequest );

  1108 #else            

  1109             ActiveExecInitExecuteCommandL( KVtEngInitializeEngine, aRequest );

  1110 #endif            

  1111             aNextState = EVtSessionStartupPrepareViewfinder; 

  1112             //aNextState = EVtSessionStartupFinish;            

  1113             break;

  1114             

  1115         case EVtSessionStartupPrepareViewfinder:

  1116             //iSessionState = EOpen;

  1117             //iObserver->StateChanged( *this );          

  1118                         

  1119 #ifdef NGA_VIDEO_RENDER

  1120             CreateVideoWindowsL();

  1121 #endif           

  1122             ActiveExecInitPrepareViewFinderL( aRequest );            

  1123             aNextState = EVtSessionStartupPrepareRemoteRender;

  1124             break;

  1125 

  1126         case EVtSessionStartupPrepareRemoteRender:

  1127             ActiveExecInitPrepareRemoteRenderL( aRequest );

  1128             aNextState = EVtSessionStartupFinish;

  1129             break;

  1130             

  1131         case EVtSessionStartupFinish:

  1132             aNextState = EVtSessionNone;

  1133             synch = ETrue;

  1134             break;