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 #include <centralrepository.h> 

    29 

    30 #include "clcvtsession.h"

    31 

    32 #include "cvtengmodel.h"

    33 

    34 #include "clcvtvideoplayerbase.h"

    35 #include "clcvtlocalvideoplayer.h"

    36 #include "clcvtremotevideoplayer.h"

    37 #include "tlcvtstates.h"

    38 #include "clcvtcmdexecutor.h"

    39 #include "mlcvtenginecommandmanager.h"

    40 #include "lcvtplugincommand.h"

    41 #include "lcvtutility.h"

    42 

    43 // User selectable Call answer status values

    44 const TInt KAllwaysQuery = 0;

    45 const TInt KAllwaysAllow = 2;

    46 

    47 // Default call index.

    48 const TInt KVtUiDefaultCallId = 1;

    49 

    50 // Granularity of command observer array.

    51 const TInt KLcVtCommandObserverArrayGranularity = 5;

    52 

    53 

    54 

    55 // Enumerates states for CLcVtActiveExec.

    56 enum

    57     {    

    58     // Operation finished. Must equal to zero.

    59     EVtSessionNone,

    60     

    61     // Active execution states for iActiveExec:

    62     

    63     //     Startup (prepare engine):

    64     EVtSessionStartup = 100,                                    // 100

    65     //     Initialise engine.

    66     EVtSessionStartupInitEngine = EVtSessionStartup,            // 100

    67     //     Prepare viewfinder.

    68     EVtSessionStartupPrepareViewfinder,                         // 101

    69     //     Prepare remote render.

    70     EVtSessionStartupPrepareRemoteRender,                       // 102

    71     //     Startup Finish 

    72     EVtSessionStartupFinish,                                    // 103

    73     

    74     //     Shutdown (reset engine):

    75     EVtSessionShutdown = 300,                                   // 300

    76     //     Hide application.

    77     EVtSessionShutdownHideApplication = EVtSessionShutdown,     // 300

    78     //     Reset engine.

    79     EVtSessionShutdownResetEngine,                              // 301

    80     

    81         

    82     //     Answered:

    83     EVtSessionAnswered = 500,                                   // 500    

    84     //     Start remote render.

    85     EVtSessionAnsweredStartRemoteRender = EVtSessionAnswered,   // 500    

    86     //     Prepare Camere

    87     EVtSessionAnsweredDoPrepareCamera,                          // 501

    88     //     Select camera as source.

    89     EVtSessionAnsweredSetlectCamera,                            // 502

    90     //     Select blank image as source.

    91     EVtSessionAnsweredSetlectNone,

    92     //     Start view finder

    93     EVtSessionAnsweredStartViewFinder,                          // 504

    94     //     Show Application 

    95     EVtSessionAnsweredBringToForeground,                        // 505

    96     

    97     //EVtSessionAnswered = 500,                                   // 500

    98     //EVtSessionAnsweredBringToForeground = EVtSessionAnswered,                        // 505

    99     

   100     //     Finish.

   101     EVtSessionAnsweredFinish                                    // 506    

   102     };

   103 

   104 

   105 /**

   106  * Encapsulates event handling.

   107  * @since Series 60 2.6

   108  */    

   109 class CLcVtSession::CEventObserver

   110     : public CBase,

   111       public MLcVtEngineCommandManager,

   112       public MVtEngEventObserver,

   113 #ifndef NGA_VIDEO_RENDER

   114       public MVtEngFrameObserver,

   115 #endif

   116       public MVtEngCommandObserver

   117     {    

   118     public: // Constructors and destructors

   119      

   120         /**

   121         * Two-phased constructor.

   122         * @param aSession plugin session.

   123         */        

   124         static CEventObserver* NewL(CLcVtSession& aSession);

   125         

   126         /**

   127         * Destructor.

   128         */        

   129         ~CEventObserver();

   130 

   131     public: // Functions from base classes

   132 

   133         /**

   134         * @see MLcVtEngineCommandManager::AddObserverL.

   135         */

   136         void AddObserverL( MVtEngCommandObserver& aObserver );

   137 

   138         /**

   139         * @see MLcVtEngineCommandManager::RemoveObserver.

   140         */

   141         void RemoveObserver( MVtEngCommandObserver& aObserver );

   142         

   143         /**

   144         * @see MVtEngEventObserver::HandleVtEventL.

   145         */        

   146         void HandleVtEventL( TInt aEvent );

   147         

   148         /**

   149         * @see MVtEngCommandObserver::HandleVTCommandPerformedL.

   150         */        

   151         void HandleVTCommandPerformedL(

   152                 TVtEngCommandId aCommand,

   153                 const TInt aError );

   154 #ifndef NGA_VIDEO_RENDER        

   155         /**

   156         * @see MVtEngFrameObserver::vtHandleFrameL.

   157         */        

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

   159         

   160         /**

   161         * @see MVtEngFrameObserver::vtSetFrame

   162         */        

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

   164 #endif                                       

   165     private:

   166         

   167         /**

   168         * Constructor.

   169         * @param aSession plugin session.

   170         */

   171         CEventObserver(CLcVtSession& aSession );

   172         

   173         /**

   174         * Symbian OS constructor.

   175         */        

   176         void ConstructL();        

   177           

   178     private:        

   179         

   180         // Ref to plugin session.

   181         CLcVtSession& iSession;    

   182         

   183         // ETrue when command events are being sent.

   184         TBool iInCommandPerformed;

   185 

   186         // Owned array of observers.

   187         RPointerArray< MVtEngCommandObserver > iCommandObservers;

   188         

   189     };

   190 

   191          

   192 // -----------------------------------------------------------------------------

   193 //

   194 // -----------------------------------------------------------------------------

   195 //

   196 CLcVtSession* CLcVtSession::NewL()

   197     {

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

   199     CleanupStack::PushL( self );

   200     self->ConstructL();

   201     CleanupStack::Pop( self );

   202     return self;

   203     }     

   204 

   205 // -----------------------------------------------------------------------------

   206 //

   207 // -----------------------------------------------------------------------------

   208 //

   209 CLcVtSession::CLcVtSession( ) 

   210     {

   211     }

   212 

   213 // -----------------------------------------------------------------------------

   214 //

   215 // -----------------------------------------------------------------------------

   216 //

   217 void CLcVtSession::ConstructL()

   218     {

   219     

   220     __VTPRINTENTER( "CLcVtSession.ConstructL" )  

   221       

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

   223     FeatureManager::InitializeLibL(); 

   224         

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

   226     iCameraHandler.SetSession(this);

   227     __VTPRINT( DEBUG_MEDIA , "iRemoteVideoPlayer = CLcVtRemoteVideoPlayer_NewL" )

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

   229     __VTPRINT( DEBUG_MEDIA , "iLocalVideoPlayer  = CLcVtLocalVideoPlayer_NewL" )

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

   231 

   232 #ifndef NGA_VIDEO_RENDER 

   233     iFbsStarted = EFalse;   

   234             

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

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

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

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

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

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

   241     

   242     __VTPRINT( DEBUG_MEDIA , "ConnectFbsServerL()" )

   243     ConnectFbsServerL();    

   244 #endif

   245     __VTPRINT( DEBUG_MEDIA , "iEventObserver = CEventObserver_NewL" )

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

   247 

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

   249 

   250     __VTPRINT( DEBUG_MEDIA , "iLcVtStates_new" )

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

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

   253     iLcVtStates->Update();    

   254     

   255     __VTPRINT( DEBUG_MEDIA , "new_iActiveExec" )

   256     iActiveExec =

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

   258         

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

   260     SetCallIdL( KVtUiDefaultCallId );

   261     

   262     __VTPRINT( DEBUG_MEDIA , "iAsyncCallback" )

   263     iAsyncCallback =

   264         new ( ELeave ) CAsyncCallBack (

   265             TCallBack( &DoExit, this ),

   266             CActive::EPriorityStandard );   

   267 #if 0    

   268     __VTPRINT( DEBUG_MEDIA , "iLayoutChangeCallback" )

   269     iLayoutChangeCallback =

   270         new ( ELeave ) CAsyncCallBack(

   271             TCallBack( &DelayedHandleLayoutChanged, this ),

   272             CActive::EPriorityStandard );   

   273 #endif    

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

   275 

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

   277         {

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

   279         }

   280     else

   281         {

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

   283         VideoSendingKey = KAllwaysAllow;

   284         }

   285     delete repository;

   286     

   287     iIndicatorCtr = new  ( ELeave ) LcVtIndicatorController();

   288     __VTPRINTEXIT( "CLcVtSession.ConstructL" )

   289     

   290     }

   291 

   292 // -----------------------------------------------------------------------------

   293 //

   294 // -----------------------------------------------------------------------------

   295 //

   296 CLcVtSession::~CLcVtSession()

   297     {

   298     __VTPRINTENTER( "CLcVtSession.~CLcVtSession" )  

   299 

   300     //delete iLayoutChangeCallback;

   301     delete iAsyncCallback;

   302 

   303 #ifndef NGA_VIDEO_RENDER    

   304     DisconnectFbsServer();

   305 #endif

   306     delete iActiveExec;

   307     delete iLcVtStates;

   308 

   309     delete iModel;

   310     

   311     delete iEventObserver;

   312     iEventObserver = NULL;

   313     

   314 #ifdef NGA_VIDEO_RENDER

   315     DestroyVideoWindows();

   316 #endif

   317 

   318     delete iLocalVideoPlayer;

   319     delete iRemoteVideoPlayer;

   320     

   321     delete iRemoteDisplayName;

   322     delete iRemoteDetails;

   323     if (iIndicatorCtr) {

   324         iIndicatorCtr->disableActiveCallIndicator();

   325         delete iIndicatorCtr;

   326     }    

   327     __VTPRINTEXIT( "CLcVtSession.~CLcVtSession" )

   328     FeatureManager::UnInitializeLib();  

   329     }

   330 

   331 #ifndef NGA_VIDEO_RENDER

   332 void CLcVtSession::ConnectFbsServerL()

   333     {

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

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

   336     TInt err( KErrNone );

   337     // Start Font&Bitmap server    

   338     err = FbsStartup();

   339     if ( err == KErrNone )

   340         {

   341        err = RFbsSession::Connect();

   342        if( err == KErrNone )

   343            {

   344            iFbsStarted = ETrue;

   345            }            

   346         }

   347     

   348     iDummy = new ( ELeave ) CFbsBitmap();  

   349     //CleanupStack::PushL( iDummy );

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

   351     

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

   353     //CleanupStack::PushL( iGc );

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

   355     

   356     //CleanupStack::Pop(2);

   357     }

   358 

   359 

   360 void CLcVtSession::DisconnectFbsServer()

   361     {

   362     delete iGc;

   363     delete iDummy;    

   364     if ( iFbsStarted )

   365         {

   366         RFbsSession::Disconnect();

   367         iFbsStarted = EFalse;        

   368         }    

   369     }

   370 #endif

   371 #ifdef NGA_VIDEO_RENDER

   372 

   373 _LIT(KVTWindowGroupName,"32VTPluginVideoWindow");

   374 

   375 void CLcVtSession::CreateVideoWindowsL()

   376     {

   377     __VTPRINTENTER( "CLcVtSession.CreateVideoWindowsL" ) 

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

   379 

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

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

   382     

   383     iRwGroup->SetName( KVTWindowGroupName );

   384     iRwGroup->SetOrdinalPosition( 1 , ECoeWinPriorityNeverAtFront );

   385     iRwGroup->AutoForeground(EFalse);

   386     

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

   388     iDev->Construct( ); 

   389     

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

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

   392     

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

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

   395     iRemoteVideoWindow->SetOrdinalPosition( 1, ECoeWinPriorityNeverAtFront );

   396     iRemoteVideoWindow->Activate();

   397     

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

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

   400     

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

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

   403     iLocalVideoWindow->SetOrdinalPosition( 1, ECoeWinPriorityNeverAtFront );

   404     iLocalVideoWindow->Activate();   

   405         

   406     iRwSession.Flush();  

   407 

   408     __VTPRINTEXIT( "CLcVtSession.CreateVideoWindowsL" )

   409     }

   410 

   411 void CLcVtSession::DestroyVideoWindows()

   412     {

   413     

   414     delete iDev;

   415     iDev = NULL;

   416     delete iRemoteVideoWindow;

   417     iRemoteVideoWindow = NULL;

   418     delete iLocalVideoWindow;

   419     iLocalVideoWindow = NULL;

   420     delete iRwGroup;

   421     iRwGroup = NULL;

   422     iRwSession.Close();

   423     }

   424 

   425 #endif

   426 

   427 

   428 void CLcVtSession::SetLcSessionObserver( MLcSessionObserver* aObserver )

   429     {

   430     iObserver = aObserver;

   431     }

   432 

   433 void CLcVtSession::SetLcUiProvider( MLcUiProvider* aUiProvider )

   434     {

   435     iUiProvider = aUiProvider;

   436     }

   437     

   438 TBool CLcVtSession::IsBackgroundStartup()

   439     {

   440     return ETrue;

   441     }

   442   

   443 TBool CLcVtSession::SendDialTone( TChar aKey )

   444     {

   445     iDtmfTone = aKey;

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

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

   448         {

   449         return EFalse;

   450         }

   451     else

   452         {

   453         return ETrue;

   454         }

   455     }

   456 

   457 void CLcVtSession::EstablishLcSessionL()

   458     {

   459     __VTPRINTENTER( "CLcVtSession.EstablishLcSessionL" )

   460     

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

   462     

   463     __VTPRINTEXIT( "CLcVtSession.EstablishLcSessionL" )

   464     }

   465 

   466 void CLcVtSession::TerminateLcSessionL()

   467     {

   468     __VTPRINTENTER( "CLcVtSession.TerminateLcSessionL" )    

   469     HandleCommandL( EPluginCmdEndActiveCall );

   470     __VTPRINTEXIT( "CLcVtSession.TerminateLcSessionL" )

   471     }

   472 

   473 MLcVideoPlayer* CLcVtSession::RemoteVideoPlayer()

   474     {

   475     return iRemoteVideoPlayer;

   476     }

   477 

   478 MLcVideoPlayer* CLcVtSession::LocalVideoPlayer()

   479     {

   480     return iLocalVideoPlayer;

   481     }

   482 

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

   484     {

   485     return iSessionState;

   486     }

   487 

   488 const TDesC& CLcVtSession::LocalDisplayName()

   489     {

   490     return KNullDesC;

   491     }

   492 const TDesC& CLcVtSession::RemoteDisplayName()

   493     {

   494     if ( iRemoteDisplayName )

   495         {

   496         return *iRemoteDisplayName;

   497         }

   498     return KNullDesC;

   499     }

   500     

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

   502     {

   503      if (aId == 0)

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

   505          

   506     return 0;

   507     }

   508 

   509 TInt CLcVtSession::ParameterValue( TInt aId )

   510     {

   511     return 0;

   512     }

   513 

   514 const TDesC& CLcVtSession::RemoteDetails()

   515     {

   516     if ( iRemoteDetails )

   517         {

   518         return *iRemoteDetails;

   519         }

   520     return KNullDesC;

   521     }

   522 

   523 void CLcVtSession::UpdateLcSessionL()

   524     {     

   525     __VTPRINTENTER( "CLcVtSession.UpdateLcSessionL" )

   526     

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

   528         {

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

   530         return;

   531         }

   532 #if 0    

   533     if(iLocalVideoPlayer->IsOrientationChanged())

   534         HandleLayoutChanged();

   535     else

   536         UpdateRenderingParametersL();

   537 #endif

   538     UpdateRenderingParametersL();

   539     __VTPRINTEXIT( "CLcVtSession.UpdateLcSessionL" )

   540     }

   541     

   542 // -----------------------------------------------------------------------------

   543 // From MLcAudioControl

   544 // -----------------------------------------------------------------------------

   545 //

   546 TBool CLcVtSession::IsLcAudioMutedL()

   547     {

   548     return EFalse;

   549     }

   550 

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

   552 // From MLcAudioControl

   553 // -----------------------------------------------------------------------------

   554 //

   555 void CLcVtSession::MuteLcAudioL( TBool aMute )

   556     {

   557     }

   558 

   559 // -----------------------------------------------------------------------------

   560 // From MLcAudioControl

   561 // -----------------------------------------------------------------------------

   562 //

   563 TBool CLcVtSession::IsLcMicMutedL()

   564     {    

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

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

   567     return result;  

   568     }

   569 

   570 // -----------------------------------------------------------------------------

   571 // From MLcAudioControl

   572 // -----------------------------------------------------------------------------

   573 //

   574 void CLcVtSession::MuteLcMicL( TBool aMute )

   575     {   

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

   577 

   578     if(aMute)

   579         {      

   580         HandleCommandL(EPluginCmdDisableAudio);

   581         }

   582     else

   583         {

   584         HandleCommandL(EPluginCmdEnableAudio);     

   585         }

   586     }

   587 

   588 // -----------------------------------------------------------------------------

   589 // From MLcAudioControl

   590 // -----------------------------------------------------------------------------

   591 //

   592 TBool CLcVtSession::IsEnablingLcLoudspeakerAllowed()

   593     {

   594     return ETrue;

   595     }

   596 

   597 // -----------------------------------------------------------------------------

   598 // From MLcAudioControl

   599 // -----------------------------------------------------------------------------

   600 //

   601 void CLcVtSession::EnableLcLoudspeakerL( TBool aEnabled )

   602     {

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

   604     

   605     if(aEnabled)

   606         {

   607         HandleCommandL(EPluginCmdActivateLoudspeaker);

   608         }

   609     else

   610         {

   611         HandleCommandL(EPluginCmdDeactivateLoudspeaker);

   612         }

   613     }

   614 

   615 // -----------------------------------------------------------------------------

   616 // From MLcAudioControl

   617 // -----------------------------------------------------------------------------

   618 //

   619 TBool CLcVtSession::IsLcLoudspeakerEnabled()

   620     {

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

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

   623     return result;    

   624     }

   625 

   626 // -----------------------------------------------------------------------------

   627 // From MLcAudioControl

   628 // -----------------------------------------------------------------------------

   629 //

   630 TInt CLcVtSession::LcVolumeL()

   631     {

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

   633     MVtEngAudio::TAudioRoutingState audioRouting;

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

   635     const TInt volume( audio.OutputVolume(

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

   637     

   638     return volume;

   639     }

   640 

   641 // -----------------------------------------------------------------------------

   642 // From MLcAudioControl

   643 // -----------------------------------------------------------------------------

   644 //

   645 void CLcVtSession::SetLcVolumeL( TInt aValue )

   646     {   

   647     __VTPRINTENTER( "CLcVtSession.SetLcVolumeL" )

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

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

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

   651     MVtEngAudio::TVtEngOutputVolume volume;

   652     volume.iHandsetVolume = HandsetVolume;

   653     volume.iHandsfreeVolume = HandsfreeVolume;

   654 

   655     MVtEngAudio::TAudioRoutingState audioRouting;

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

   657     if(audioRouting == MVtEngAudio::EAudioHandset)

   658         volume.iHandsetVolume = aValue;

   659     else

   660         volume.iHandsfreeVolume = aValue;    

   661     

   662     ExecuteCmdL( KVtEngSetAudioVolume, volume );

   663     __VTPRINTEXIT( "CLcVtSession.SetLcVolumeL" )

   664     }

   665 

   666 // -----------------------------------------------------------------------------

   667 // From MLcAudioControl

   668 // -----------------------------------------------------------------------------

   669 //

   670 void CLcVtSession::IncreaseLcVolumeL()

   671     {

   672     ExecuteCmdL( KVtEngIncreaseAudioVolume );

   673     }

   674 

   675 // -----------------------------------------------------------------------------

   676 // From MLcAudioControl

   677 // -----------------------------------------------------------------------------

   678 //

   679 void CLcVtSession::DecreaseLcVolumeL()

   680     {

   681     ExecuteCmdL( KVtEngDecreaseAudioVolume );

   682     }

   683 

   684 CVtEngModel& CLcVtSession::Model()

   685     {

   686     return *iModel;

   687     }

   688 

   689 

   690 void CLcVtSession::HandleCommandL(const TInt aCommand)

   691     {

   692     

   693     __VTPRINTENTER( "CLcVtSession.HandleCommandL" )

   694     

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

   696         {

   697         __VTPRINTEXIT( "CLcVtSession.HandleCommandL NOT ready" )

   698         return;

   699         }

   700     

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

   702         {

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

   704         return;

   705         }   

   706         

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

   708     

   709     switch ( aCommand )

   710         {

   711         case EPluginCmdEnableAudio:

   712             CmdEnableAudioL();

   713             break;

   714             

   715         case EPluginCmdDisableAudio:

   716             CmdDisableAudioL();

   717             break;

   718             

   719         case EPluginCmdUsePrimaryCamera:

   720             CmdUseCameraL( ETrue );

   721             break;

   722             

   723         case EPluginCmdUseSecondaryCamera:

   724             CmdUseCameraL( EFalse );

   725             break;

   726             

   727         case EPluginCmdEnableVideo:

   728             CmdEnableVideoL();

   729             break;

   730             

   731         case EPluginCmdDisableVideo:

   732             CmdDisableVideoL();

   733             break;

   734             

   735         case EPluginCmdActivateLoudspeaker:

   736             CmdActivateLoudspeakerL();

   737             break;

   738             

   739         case EPluginCmdDeactivateLoudspeaker:

   740             CmdDeactivateLoudspeakerL();

   741             break;

   742             

   743         }

   744     

   745     __VTPRINTEXIT( "CLcVtSession.HandleCommandL" )

   746     

   747     iLcVtStates->Update();

   748     }

   749 

   750 // -----------------------------------------------------------------------------

   751 // CLcVtSession::CmdEnableAudioL

   752 // -----------------------------------------------------------------------------

   753 //

   754 void CLcVtSession::CmdEnableAudioL()

   755     {

   756     ExecuteCmdL( KVtEngUnmuteOutgoingAudio );

   757     iLcVtStates->Update();

   758     }

   759 

   760 

   761 // -----------------------------------------------------------------------------

   762 // CLcVtSession::CmdDisableAudioL

   763 // -----------------------------------------------------------------------------

   764 //

   765 void CLcVtSession::CmdDisableAudioL()

   766     {

   767     ExecuteCmdL( KVtEngMuteOutgoingAudio );

   768     iLcVtStates->Update();

   769     }

   770 

   771 

   772 // -----------------------------------------------------------------------------

   773 // CLcVtSession::CmdUseCameraL

   774 // -----------------------------------------------------------------------------

   775 //

   776 void CLcVtSession::CmdUseCameraL( const TBool aPrimaryCamera )

   777     {

   778 

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

   780 

   781     MVtEngMedia::TMediaSource selectedSource =

   782         ( aPrimaryCamera ) ?

   783             MVtEngMedia::EMediaCameraPri : MVtEngMedia::EMediaCameraSec;

   784 

   785     TInt available = 0;

   786     LcVtUtility::GetOutgoingMediaState( media, available );

   787     if ( available & MVtEngMedia::EMediaVideo )

   788         {

   789         ExecuteCmdL( KVtEngStopViewFinder );

   790         

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

   792 

   793         if ( err == KErrNone )

   794             {

   795             ExecuteCmdL( KVtEngStartViewFinder );

   796             }

   797         else

   798             {

   799             //ShowOtherCameraNotUsableNoteL();

   800             }

   801         }

   802     else

   803         {

   804         /*

   805         MVtEngMedia::TPrepareCameraParams params;

   806         params.iMediaSource = selectedSource;

   807         params.iInitialize = EFalse;

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

   809         if ( err != KErrNone )

   810             {

   811             ShowOtherCameraNotUsableNoteL();

   812             }

   813             */

   814         }

   815     

   816     }

   817 

   818 

   819 // -----------------------------------------------------------------------------

   820 // CLcVtSession::CmdEnableVideoL

   821 // -----------------------------------------------------------------------------

   822 //

   823 void CLcVtSession::CmdEnableVideoL()

   824     {

   825     // if outgoing video is frozen

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

   827     if ( LcVtUtility::GetFreezeState( media ) )

   828         {

   829         ExecuteCmdL( KVtEngUnfreeze );

   830         // swap images if needed

   831         //RestoreViewFinderL();

   832         }

   833     else

   834         {

   835         ExecuteCmdL( KVtEngStopViewFinder );

   836         //iUplinkWindow->SetStreamBitmap( NULL );

   837         MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaCamera;

   838         ExecuteCmdL( KVtEngSetSource, source );

   839         MVtEngMedia::TCameraId id;

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

   841             {

   842             //ShowCameraInUseNoteL();

   843             }

   844         ExecuteCmdL( KVtEngStartViewFinder );

   845         }

   846     // update VB settings

   847     //UpdateVBSettingL();

   848     iLcVtStates->Update();

   849     }

   850 

   851 // -----------------------------------------------------------------------------

   852 // CLcVtSession::CmdDisableVideoL

   853 // -----------------------------------------------------------------------------

   854 //

   855 void CLcVtSession::CmdDisableVideoL()

   856     {

   857     ExecuteCmdL( KVtEngStopViewFinder );

   858 

   859     //iUplinkWindow->SetStreamBitmap( NULL );

   860 

   861     TInt err = KErrNotFound;

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

   863         {

   864         __VTPRINT( DEBUG_GEN, "CLcVtSession.CmdDisableVideoL.HasStill" )

   865         MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaStillImage;

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

   867         }

   868     if ( ( err != KErrNone ) )

   869         {

   870         __VTPRINT( DEBUG_GEN, "CLcVtSession.CmdDisableVideoL.MediaNone" )

   871         MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaNone;

   872         ExecuteCmdL( KVtEngSetSource, source );

   873         }

   874 

   875     ExecuteCmdL( KVtEngStartViewFinder );

   876     iLcVtStates->Update();

   877     }

   878 

   879 // -----------------------------------------------------------------------------

   880 // CLcVtSession::CmdActivateLoudspeakerL

   881 // -----------------------------------------------------------------------------

   882 //

   883 void CLcVtSession::CmdActivateLoudspeakerL()

   884     {

   885     MVtEngAudio::TVtEngRoutingSetting audioSetting =

   886         MVtEngAudio::EActivateHandsfree;

   887     ExecuteCmdL( KVtEngSetAudioRouting, audioSetting );

   888     iLcVtStates->Update();

   889     }

   890 

   891 // -----------------------------------------------------------------------------

   892 // CLcVtSession::CmdDeactivateLoudspeakerL

   893 // -----------------------------------------------------------------------------

   894 //

   895 void CLcVtSession::CmdDeactivateLoudspeakerL()

   896     {

   897     MVtEngAudio::TVtEngRoutingSetting audioSetting =

   898         MVtEngAudio::EDeactivateHansfree;

   899     ExecuteCmdL( KVtEngSetAudioRouting, audioSetting );

   900     iLcVtStates->Update();

   901     }

   902 

   903 

   904 // -----------------------------------------------------------------------------

   905 // CLcVtSession::SetZoomFactorL

   906 // -----------------------------------------------------------------------------

   907 //

   908 void CLcVtSession::SetZoomFactorL( TInt aZoomStep )

   909     {

   910     __VTPRINTENTER( "CLcVtSessionCLcVtSession.SetZoomFactorL" )

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

   912     if ( LcVtUtility::IsZoomAllowed( media ) )

   913         {

   914         ExecuteCmdL( KVtEngSetZoomStep, aZoomStep );

   915         }

   916     __VTPRINTEXIT( "CLcVtSession.SetZoomFactorL" )

   917     }

   918 

   919 #ifndef NGA_VIDEO_RENDER

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

   921 void CLcVtSession::vtHandleFrameL( CFbsBitmap* aBitmap )

   922     {

   923     __VTPRINTENTER( "CLcVtSession.vtHandleFrameL" )   

   924     

   925     /*    

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

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

   928     iMainWindow->Invalidate();

   929     iMainWindow->BeginRedraw();

   930     iGc->Activate( *iMainWindow );

   931     aBitmap->BeginDataAccess();

   932     aBitmap->EndDataAccess();

   933     iGc->BitBlt( KVFcordinate , aBitmap );

   934     iGc->Deactivate();

   935     iMainWindow->EndRedraw();

   936     */

   937     

   938     /*

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

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

   941     iLocalVideoWindow->Invalidate();

   942     iLocalVideoWindow->BeginRedraw();

   943     iGc->Activate( *iLocalVideoWindow );

   944     iGc->BitBlt( KVFcordinate , aBitmap );

   945     iGc->Deactivate();

   946     iLocalVideoWindow->EndRedraw();

   947     */   

   948         

   949     __VTPRINTEXIT("CLcVtSession.vtHandleFrameL")     

   950     }

   951 #endif

   952 

   953 TInt CLcVtSession::SetForegroundStatus( TBool aIsForeground )

   954 {

   955     __VTPRINTENTER( "CLcVtSession.SetForegroundStatus" )

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

   957 

   958     if ( iRwGroup )

   959         {

   960         TInt priority = aIsForeground ? ECoeWinPriorityNormal : ECoeWinPriorityNeverAtFront;

   961         iRwGroup->SetOrdinalPosition( 1 , priority );

   962         iRemoteVideoWindow->SetOrdinalPosition( 1 , priority );

   963         iLocalVideoWindow->SetOrdinalPosition( 1 , priority );

   964         iRwSession.Flush();

   965         }

   966     if ( aIsForeground )

   967        {

   968        iIndicatorCtr->disableActiveCallIndicator();

   969        }

   970     else {

   971        iIndicatorCtr->enableActiveCallIndicator();

   972        }

   973 

   974     __VTPRINTEXIT( "CLcVtSession.SetForegroundStatus" )

   975     

   976     return KErrNone;   

   977 }

   978 

   979 // -----------------------------------------------------------------------------

   980 // CLcVtSession::ShutdownL

   981 // -----------------------------------------------------------------------------

   982 //

   983 void CLcVtSession::ShutdownL()

   984     {

   985     __VTPRINTENTER( "CLcVtSession.ShutdownL" )

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

   987     __VTPRINTEXIT( "CLcVtSession.ShutdownL" )

   988     }

   989 

   990 // -----------------------------------------------------------------------------

   991 // CLcVtSession::StartupPhase1L

   992 // -----------------------------------------------------------------------------

   993 //

   994 void CLcVtSession::StartupPhase1L()

   995     {

   996     __VTPRINTENTER( "CLcVtSession.StartupPhase1L" )

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

   998     __VTPRINTEXIT( "CLcVtSession.StartupPhase1L" )

   999     }

  1000 

  1001 

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

  1003 // CLcVtSession::StartupPhase2L

  1004 // -----------------------------------------------------------------------------

  1005 //

  1006 void CLcVtSession::StartupPhase2L()

  1007     {

  1008     __VTPRINTENTER( "CLcVtSession.StartupPhase2L" )

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

  1010     __VTPRINTEXIT( "CLcVtSession.StartupPhase2L" )

  1011     }

  1012 

  1013 // -----------------------------------------------------------------------------

  1014 // CLcVtSession::ActiveExecExecuteL

  1015 // -----------------------------------------------------------------------------

  1016 //

  1017 TBool CLcVtSession::ActiveExecExecuteL(

  1018         CLcVtActiveExec& /*aActiveExec*/,

  1019         const TInt aState,

  1020         TInt& aNextState,

  1021         TRequestStatus& aRequest )

  1022     {

  1023     return ActiveExecInitExecuteL(

  1024             aState,

  1025             aNextState,

  1026             aRequest );

  1027     }

  1028 

  1029 // -----------------------------------------------------------------------------

  1030 // CLcVtSession::ActiveExecContinue

  1031 // -----------------------------------------------------------------------------

  1032 //

  1033 TBool CLcVtSession::ActiveExecContinue(

  1034         CLcVtActiveExec& /*aActiveExec*/,

  1035         TInt& aState,

  1036         const TInt aError )

  1037     {

  1038     return ActiveExecInitContinue( aState, aError );

  1039     }

  1040 

  1041 // -----------------------------------------------------------------------------

  1042 // CLcVtSession::ActiveExecCancel

  1043 // -----------------------------------------------------------------------------

  1044 //

  1045 void CLcVtSession::ActiveExecCancel(

  1046         CLcVtActiveExec& /*aActiveExec*/,

  1047         TInt aState )

  1048     {

  1049     ActiveExecInitCancel( aState );

  1050     }

  1051 

  1052 // -----------------------------------------------------------------------------

  1053 // CLcVtSession::ActiveExecDone

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

  1055 //

  1056 void CLcVtSession::ActiveExecDone(

  1057         CLcVtActiveExec& /*aActiveExec*/,

  1058         const TInt aInitialState )

  1059     {    

  1060     ActiveExecInitDone( aInitialState );

  1061     }

  1062 

  1063 

  1064 // -----------------------------------------------------------------------------

  1065 // CLcVtSession::ActiveExecInitCancel

  1066 // -----------------------------------------------------------------------------

  1067 //

  1068 void CLcVtSession::ActiveExecInitCancel(

  1069         const TInt /*aState*/ )

  1070     {

  1071     __VTPRINTENTER( "CLcVtSession.InitExecCancel" )

  1072     

  1073     delete iCmdExecutor;

  1074 

  1075     if ( iShutdownRequest )

  1076         {

  1077         User::RequestComplete( iShutdownRequest, KErrCancel );

  1078         iShutdownRequest = NULL;

  1079         }

  1080     __VTPRINTEXIT( "CLcVtSession.InitExecCancel" )

  1081     }

  1082 

  1083 // -----------------------------------------------------------------------------

  1084 // CLcVtSession::ActiveExecInitDone

  1085 // -----------------------------------------------------------------------------

  1086 //

  1087 void CLcVtSession::ActiveExecInitDone(

  1088         const TInt aInitialState )

  1089     {

  1090     __VTPRINTENTER( "CLcVtSession.ExecInitDone" )

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

  1092     // Operation succeeded

  1093     

  1094     // Now we have finished.

  1095     if ( iState )

  1096         {

  1097         if ( aInitialState == EVtSessionAnswered )

  1098             {

  1099             TRAP_IGNORE( iState->LcVtStartupPhase2DoneL() );

  1100 			iSessionState = EOpen;

  1101             iObserver->StateChanged( *this );             

  1102             }

  1103         else if ( aInitialState == EVtSessionShutdown )

  1104             {

  1105             TRAP_IGNORE( iState->ShutdownDoneL() );

  1106             }

  1107         else // EVtSessionStartup

  1108             {

  1109             TRAP_IGNORE( iState->LcVtStartupPhase1DoneL() );

  1110             }

  1111         }

  1112     __VTPRINTEXIT( "CLcVtSession.ExecInitDone" )

  1113     }

  1114 

  1115 

  1116 // -----------------------------------------------------------------------------

  1117 // CLcVtSession::ActiveExecInitExecuteL

  1118 // -----------------------------------------------------------------------------

  1119 //

  1120 TBool CLcVtSession::ActiveExecInitExecuteL(

  1121         const TInt aState,

  1122         TInt& aNextState,

  1123         TRequestStatus& aRequest )

  1124     {

  1125     __VTPRINTENTER( "CLcVtSession.ActiveExecInitExecuteL" )

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

  1127 

  1128     TBool synch = EFalse;

  1129 

  1130     switch ( aState )

  1131         {

  1132         // Startup chain:

  1133         case EVtSessionStartupInitEngine:

  1134             //ChangeApplicationFocus(ETrue);