1 /*

     2 * Copyright (c) 2004 - 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:  Implementation of the CVtUiAppUi application UI class.

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include    "videotelui.hrh"

    22 #include    "CVtUiAppUi.h"

    23 #include    "CVtUiMainControl.h"

    24 #include    "CVtUiContextControl.h"

    25 #include    "CVtUiNumberEntryActivationControl.h"

    26 #include    "CVtUiNaviPane.h"

    27 #include    "VtUiLayout.h"

    28 #include    "MVtUiEngineCommandManager.h"

    29 #include    "CVtUiExecuteCmdDialog.h"

    30 #include    "CVtUiAllowVideoDialog.h"

    31 #include    "CVtUiBlankControl.h"

    32 #include    "VtUiLayout.h"

    33 #include    "VtUiUtility.h"

    34 #include    "VtUiPanic.h"

    35 #include    "CVtUiActivateBtHfDialog.h"

    36 #include    "CVtUiRemoteVideoControl.h"

    37 #include    "CVtUiEndCallButtonPane.h"

    38 #include    <csxhelp/incl.hlp.hrh>

    39 

    40 

    41 #include    <AknIncallBubbleNotify.h>

    42 #include    <AknsLayeredBackgroundControlContext.h>

    43 #include    <AknUtils.h>

    44 #include    <aknnavi.h>

    45 #include    <akntitle.h>

    46 #include    <AknDlgShut.h>

    47 #include    <aknnotedialog.h>

    48 #include    <aknnotewrappers.h>

    49 #include    <akncontext.h>

    50 #include    <eikspane.h>

    51 #include    <eikmenup.h>

    52 #include    <eikmenub.h>

    53 #include    <apgcli.h>

    54 #include    <featmgr.h>

    55 #include    <videotelui.rsg>

    56 #include    <hlplch.h>

    57 #include    <apgwgnam.h>

    58 #include    <StringLoader.h>

    59 #include    <AknDef.h>

    60 #include    <aknconsts.h>

    61 #include    <akntoolbar.h>

    62 

    63 #include    <e32property.h>

    64 #include    <ecom/ecom.h>

    65 #include    <coreapplicationuisdomainpskeys.h>

    66 #include    <UikonInternalPSKeys.h>

    67 #include    <centralrepository.h>

    68 #include    <videotelephonyinternalcrkeys.h>

    69 #include    <settingsinternalcrkeys.h>

    70 #include    <e32property.h>

    71 #include    <telcommsinfopskeys.h>

    72 #include    <telinformationpskeys.h>

    73 #include    <activeidle2domainpskeys.h>

    74 #include     <ctsydomainpskeys.h>

    75 

    76 #include    <AknQueryDialog.h>

    77 #include     <AknGlobalNote.h>

    78 #include     <aknsoundsystem.h>

    79 

    80 

    81 #include    <cvtlogger.h>

    82 #include    <cvtengmodel.h>

    83 #include    <mvtengeventobserver.h>

    84 #include    <mvtengcommandobserver.h>

    85 #include    <mvtengcommandhandler.h>

    86 #include    <mvtengframeobserver.h>

    87 #include    <mvtengaudio.h>

    88 #include    <mvtengsessioninfo.h>

    89 #include    <vtengevents.h>

    90 #include    <mvtengmedia.h>

    91 

    92 #include    "CVtUiBitmapManager.h"

    93 

    94 #include    <MGFetch.h>

    95 #include    <MMGFetchVerifier.h>

    96 #include    <caf/manager.h>

    97 #include    <caf/virtualpathptr.h>

    98 

    99 #include    "cvtuifeaturemanager.h"

   100 #include    "cvtuicomponentmanager.h"

   101 #include    "cvtuicommandmanager.h"

   102 #include    "tvtuistates.h"

   103 #include    "cvtuimenus.h"

   104 #include    "cvtuisoftkeys.h"

   105 #include    "cvtuitoolbarbase.h"

   106 #include    "cvtuiwhitebalance.h"

   107 #include    "cvtuicolortone.h"

   108 #include    "cvtuibrightness.h"

   109 #include    "cvtuicontrast.h"

   110 #include    <remconinterfaceselector.h>

   111 #include    <remconcoreapitarget.h>

   112 #include    <remconcoreapitargetobserver.h>

   113 #include    "tvtuiwsevent.h"

   114 #include    "mvtuinumbersource.h"

   115 #include    "tVtuifeaturevariation.h"

   116 #include    "cvtuidialer.h"

   117 #include    "tvtuiappstates.h"

   118 #include    "cvtuivolume.h"

   119 #include    "cvtuizoom.h"

   120 #include    "cvtuivolumecontrol.h"

   121 

   122 using namespace ContentAccess;

   123 

   124 // CONSTANTS

   125 

   126 // Engine orientation to application orientation map

   127 const CVtUiAppUi::TAppUiOrientation engToAppOrientation[] = {

   128     CVtUiAppUi::EAppUiOrientationLandscape,

   129     CVtUiAppUi::EAppUiOrientationPortrait,

   130     CVtUiAppUi::EAppUiOrientationUnspecified };

   131 

   132 // Amount of help contexts.

   133 const TInt KVtUiHelpContextAmount = 1;

   134 

   135 // UID of Video Telephone application.

   136 const TUid KVtUiAppUid = { KVtUiAppUidValue };

   137 

   138 // Granularity of command observer array.

   139 const TInt KVtUiCommandObserverArrayGranularity = 5;

   140 

   141 // Default call index.

   142 const TInt KVtUiDefaultCallId = 1;

   143 

   144 // Control priority for the blank control. Above all other controls.

   145 const TInt KVtUiBlankControlPriority =

   146     ECoeStackPriorityEnvironmentFilter + 100;

   147 

   148 // Exit timeout.

   149 const TInt KVtUiExitTimeout = 10000000;

   150 

   151 // UID of the main telephone application

   152 const TUid KVtUiTelephoneUid = { 0x100058B3 };

   153 

   154 // Reset value for volume

   155 const TInt  KVolumeResetValue = -1;

   156 

   157 // Remote video control normal priority

   158 const TInt KVtUiRemoteVideoControlOrdinalPriNormal = 0;

   159 

   160 // Remote video control high priority

   161 const TInt KVtUiRemoteVideoControlOrdinalPriHigh = 1;

   162 

   163 // Name of the EIKON server window group.

   164 _LIT( KVtUiEikonServer, "EikonServer" );

   165 

   166 // Name of the AknCapServer window group.

   167 _LIT( KVtUiAknCapServer, "*akncapserver*" );

   168 

   169 // Name of the AknNotifierServer window group.

   170 _LIT( KVtUiAknNotifierServer, "*aknnfysrv*" );

   171 

   172 // Volume repeat delay.

   173 const TInt KVtUiVolumeRepeatDelay = KAknStandardKeyboardRepeatRate;

   174 

   175 // Volume repeat long delay.

   176 const TInt KVtUiVolumeRepeatLongDelay = KAknKeyboardRepeatInitialDelay;

   177 

   178 // Start time for toolbar timer

   179 const TTimeIntervalMicroSeconds32 KStartTime( 600000 );

   180 

   181 // period time for toolbar timer

   182 const TTimeIntervalMicroSeconds32 KPeriodTime( 300000 );

   183 

   184 // The maximum frequency that user can swap image places.

   185 const TInt64 KVtUiMaxSwapImagesFreq( 1000000 );

   186 

   187 // Enumerates methods used in event handling. This enumeration MUST

   188 // match with methodArray local array.

   189 enum TVtUiHandleEvents

   190     {

   191     // Refresh states

   192     EVtUiRefreshStates =                    1 << 0,

   193     // Handle remote problem.

   194     EVtUiHandleVideoFrameRemoteProblem =    1 << 1,

   195     // Handle local problem.

   196     EVtUiHandleVideoFrameLocalProblem =     1 << 2,

   197     // Refresh navipane.

   198     EVtUiRefreshNaviPane =                  1 << 3,

   199     // Refresh softkeys.

   200     EVtUiRefreshSoftkeys =                  1 << 4,

   201     // Refresh blind icon status.

   202     EVtUiRefreshBlind =                     1 << 5,

   203     // Stop showing waiting image text.

   204     EVtUiStopWaitingImage =                 1 << 6,    

   205     // Rx resolution changed.

   206     EVtUiChangeRemoteVideoLayout =          1 << 7,

   207     // Show initializing image progress

   208     EVtUiShowImageInitializingProgress =    1 << 8,

   209     // Hide initializing image progress

   210     EVtUiHideImageInitializingProgress =    1 << 9,

   211     // Set camera orientation

   212     EVtUiSetOrientation =                   1 << 10,

   213     //Handle media status change

   214     EVtUiMediaStateChanged =                1 << 11,

   215     //Show decoding error note

   216     EVtUiShowDecodingError =                1 << 12,

   217     // Stop the white balance and color tone

   218     EVtUiStopWBOrColortone =                1 << 13,

   219     // refresh Menu

   220     EVtUiRefreshMenu =                      1 << 14,

   221     // Stop brightness and contrast slider

   222     EVtUiStopBrightnessOrContrast =         1 << 15,

   223     // refresh zoom popup

   224     EVtUiRefreshZoomPopup =                 1 << 16,

   225     // enable end call button

   226     EVtUiEnableEndCallButton =              1 << 17

   227     };

   228 

   229 // Enumerates states for CVtUiActiveExec.

   230 enum

   231     {

   232     // Operation finished. Must equal to zero.

   233     EVtUiAppUiNone,

   234 

   235     // Active execution states for iActiveExec:

   236 

   237     // Startup (prepare engine):

   238     EVtUiAppUiStartup = 100,                             // 100

   239     //     Close dialogs.

   240     EVtUiAppUiStartupCloseDialogs = EVtUiAppUiStartup,   // 100

   241     //     Initialise engine.

   242     EVtUiAppUiStartupInitEngine,                         // 101

   243     //     Prepare viewfinder.

   244     EVtUiAppUiStartupPrepareViewfinder,                  // 102

   245     //     Prepare remote render.

   246     EVtUiAppUiStartupPrepareRemoteRender,                // 103

   247     //     Remove blank.

   248     EVtUiAppUiStartupRemoveBlank,                        // 104

   249 

   250     // Shutdown (reset engine):

   251     EVtUiAppUiShutdown = 300,                            // 300

   252     //     Close dialogs.

   253     EVtUiAppUiShutdownCloseDialogs = EVtUiAppUiShutdown, // 300

   254     //     Hide application.

   255     EVtUiAppUiShutdownHideApplication,                   // 301

   256     //     Reset engine.

   257     EVtUiAppUiShutdownResetEngine,                       // 302

   258     //     Remove blank.

   259     EVtUiAppUiShutdownRemoveBlank,                       // 303

   260 

   261     // Answered:

   262     EVtUiAppUiAnswered = 500,                            // 500

   263     //     Show blank dialog.

   264     EVtUiAppUiAnsweredStart = EVtUiAppUiAnswered,        // 500

   265     //     Refresh navipane.

   266     EVtUiAppUiAnsweredRefreshNavi,                       // 501

   267     //     Refresh softkeys.

   268     EVtUiAppUiAnsweredRefreshSoftkeys,                   // 502

   269     //     Start remote render.

   270     EVtUiAppUiAnsweredStartRemoteRender,                 // 503

   271 

   272     //     Prepares camera

   273     EVtUiAppUiAnsweredCheckCamera,                       // 504

   274     //     Choose if it's needed to show query or directly activate camera.

   275     EVtUiAppUiAnsweredChoose,                            // 505

   276     //     Set still image as source.

   277     EVtUiAppUiAnsweredQuerySetupStill,                   // 506

   278     //     Set none as source.

   279     EVtUiAppUiAnsweredQuerySetupNone,                    // 507

   280     //     Start viewfinder.

   281     EVtUiAppUiAnsweredQuerySetupStart,                   // 508

   282     //     Show "allow video image" query.

   283     EVtUiAppUiAnsweredQueryShow,                         // 509

   284     //     Check if user allowed video image.

   285     EVtUiAppUiAnsweredQueryDecide,                       // 510

   286     //     Select camera as source.

   287     EVtUiAppUiAnsweredQuerySelectCamera,                 // 511

   288     //     Select still image as source.

   289     EVtUiAppUiAnsweredQuerySelectStill,                  // 512

   290     //     Select none as source.

   291     EVtUiAppUiAnsweredQuerySelectNone,                   // 513

   292     //     Start viewfinder.

   293     EVtUiAppUiAnsweredQueryStartViewfinder,              // 514

   294     //     Finish.

   295     EVtUiAppUiAnsweredQueryFinish,                       // 515

   296     //     Select camera as source.

   297     EVtUiAppUiAnsweredSelectCamera,                      // 516

   298     //     Select still image as source.

   299     EVtUiAppUiAnsweredSelectStill,                       // 517

   300     //     Select none as source.

   301     EVtUiAppUiAnsweredSelectNone,                        // 518

   302     //     Start viewfinder.

   303     EVtUiAppUiAnsweredStartViewfinder,                   // 519

   304     //     Finish.

   305     EVtUiAppUiAnsweredFinish,                            // 520

   306 

   307     //     Prepares camera

   308     EVtUiAppUiAnsweredDoPrepareCamera                   // 521

   309     };

   310 

   311 /**

   312 * Enumerates background layers

   313 */

   314 enum TVtUiBackgroundLayers

   315     {

   316     // Idle state background.

   317     EVtUiLayerBackground = 0,

   318     // Wallpaper layout.

   319     EVtUiLayerWallpaper = 1,

   320     // Amount of layers.

   321     EVtUiLayerCount = 2

   322     };

   323 

   324 // MODULE DATA STRUCTURES

   325 

   326 /**

   327 * Asynchronous command executor that does not use dialog for waiting the

   328 * execution completion.

   329 * @since Series 60 5.0

   330 */

   331 class CVtEngCmdExec : public CBase, private MVtEngCommandObserver

   332     {

   333 

   334 public:

   335     /**

   336     * Static constructor.

   337     */

   338     static CVtEngCmdExec* NewL( MVtEngCommandHandler& aCommandHandler,

   339         MVtUiEngineCommandManager& aCommandManager,

   340         CEikButtonGroupContainer& aCBA );

   341 

   342     /**

   343     * Executes given command asynchronously, waiting the command completion.

   344     */

   345     void ExecuteCmdLD( const TVtEngCommandId aCommandId );

   346 

   347     /**

   348     * Destructor.

   349     */

   350     ~CVtEngCmdExec();

   351 

   352 private: // from MVtEngCommandObserver

   353 

   354     /**

   355     * @see MVtEngCommandObserver::HandleVTCommandPerformedL

   356     */

   357     void HandleVTCommandPerformedL( TVtEngCommandId aCommand,

   358         const TInt aError );

   359 

   360 private:

   361 

   362     /**

   363     * Constructor.

   364     */

   365     CVtEngCmdExec( MVtEngCommandHandler& aCommandHandler,

   366         MVtUiEngineCommandManager& aCommandManager,

   367         CEikButtonGroupContainer& aCBA );

   368 

   369 private:

   370 

   371     CActiveSchedulerWait iWait;

   372 

   373     MVtEngCommandHandler& iCommandHandler;

   374 

   375     MVtUiEngineCommandManager& iCommandManager;

   376 

   377     TVtEngCommandId iCommandId;

   378 

   379     CEikButtonGroupContainer& iCBA;

   380 

   381     };

   382 

   383 // -----------------------------------------------------------------------------

   384 // CVtEngCmdExec::NewL

   385 // -----------------------------------------------------------------------------

   386 //

   387 CVtEngCmdExec* CVtEngCmdExec::NewL( MVtEngCommandHandler& aCommandHandler,

   388     MVtUiEngineCommandManager& aCommandManager, CEikButtonGroupContainer& aCBA )

   389     {

   390     CVtEngCmdExec* self = new ( ELeave ) CVtEngCmdExec( aCommandHandler,

   391         aCommandManager, aCBA );

   392     return self;

   393     }

   394 

   395 // -----------------------------------------------------------------------------

   396 // CVtEngCmdExec::ExecuteCmdLD

   397 // -----------------------------------------------------------------------------

   398 //

   399 void CVtEngCmdExec::ExecuteCmdLD( const TVtEngCommandId aCommandId )

   400     {

   401     __VTPRINTENTER("CVtEngCmdExec::ExecuteCmdLD")

   402     CleanupStack::PushL( this );

   403     iCommandId = aCommandId;

   404     iCommandManager.AddObserverL( *this );

   405     iCommandHandler.ExecuteL( aCommandId, NULL );

   406     iCBA.SetCommandSetL( R_VIDEOTELUI_SOFTKEYS_EMPTY );

   407     iCBA.DrawNow();

   408     iWait.Start();

   409     CleanupStack::PopAndDestroy(); // this

   410     __VTPRINTEXIT("CVtEngCmdExec::ExecuteCmdLD")

   411     }

   412 

   413 // -----------------------------------------------------------------------------

   414 // CVtEngCmdExec::~CVtEngCmdExec

   415 // -----------------------------------------------------------------------------

   416 //

   417 CVtEngCmdExec::~CVtEngCmdExec()

   418     {

   419     __VTPRINTENTER("CVtEngCmdExec::~CVtEngCmdExec")

   420     if ( iWait.IsStarted())

   421         {

   422         __VTPRINT(DEBUG_GEN, "CVtEngCmdExec::~CVtEngCmdExec AsyncStop")

   423         iWait.AsyncStop();

   424         }

   425     iCommandManager.RemoveObserver( *this );

   426     __VTPRINTEXIT("CVtEngCmdExec::~CVtEngCmdExec")

   427     }

   428 

   429 // -----------------------------------------------------------------------------

   430 // CVtEngCmdExec::HandleVTCommandPerformedL

   431 // -----------------------------------------------------------------------------

   432 //

   433 void CVtEngCmdExec::HandleVTCommandPerformedL( TVtEngCommandId aCommand,

   434         const TInt aError )

   435     {

   436     __VTPRINTENTER("CVtEngCmdExec::HandleVTCommandPerformedL")

   437     if ( iCommandId == aCommand )

   438         {

   439          if ( iWait.IsStarted())

   440             {

   441             __VTPRINT(DEBUG_GEN, "CVtEngCmdExec::HandleVTCommandPerformedL AsyncStop")

   442             iWait.AsyncStop();

   443             }

   444         else

   445             {

   446             // request already completed

   447             }

   448         }

   449     else

   450         {

   451         // wrong command ID

   452         }

   453     __VTPRINTEXIT("CVtEngCmdExec::HandleVTCommandPerformedL")

   454     }

   455 

   456 // -----------------------------------------------------------------------------

   457 // CVtEngCmdExec::CVtEngCmdExec

   458 // -----------------------------------------------------------------------------

   459 //

   460 CVtEngCmdExec::CVtEngCmdExec( MVtEngCommandHandler& aCommandHandler,

   461     MVtUiEngineCommandManager& aCommandManager, CEikButtonGroupContainer& aCBA )

   462     : iCommandHandler( aCommandHandler ),

   463       iCommandManager( aCommandManager ), iCBA( aCBA )

   464     {

   465     }

   466     

   467 /**

   468 * Encapsulates all instances related to user interface.

   469 * @since Series 60 2.6

   470 */

   471 class CVtUiAppUi::CInstance

   472     : public CBase

   473     {

   474     public: // Constructors and destructors

   475 

   476         /**

   477         * Two-phased constructor.

   478         * @param aAppUi reference to application UI.

   479         */

   480         static CInstance* NewL( CVtUiAppUi& aAppUi );

   481 

   482         /**

   483         * Destructor.

   484         */

   485         ~CInstance();

   486 

   487         /**

   488         * Called when side volume key is pressed.

   489         */

   490         void VolumeKeyPressedL();

   491 

   492         /**

   493         * Create remote video control.

   494         */        

   495         void CreateRemoteVideoControl();

   496 

   497     private:

   498 

   499         /**

   500         * Constructor.

   501         */

   502         CInstance( CVtUiAppUi& aAppUi );

   503 

   504         /**

   505         * Symbian OS constructor.

   506         */

   507         void ConstructL();

   508 

   509         /**

   510         * Relayout controls.

   511         */

   512         void LayoutChanged();

   513 

   514     private:

   515 

   516         // Parent can access members.

   517         friend class CVtUiAppUi;

   518 

   519         // Ref to application UI.

   520         CVtUiAppUi& iAppUi;

   521 

   522         // Owned bitmap manager.

   523         CVtUiBitmapManager* iBitmapManager;

   524 

   525         // ETrue if iMainControl has been added to stack.

   526         TBool iMainControlInStack;

   527 

   528         // Owned main pane control.

   529         CVtUiMainControl* iMainControl;

   530 

   531         // ETrue if iContextControl has been added to stack.

   532         TBool iContextControlInStack;

   533 

   534         // Owned context pane control.

   535         CVtUiContextControl* iContextControl;

   536 

   537         // Owned remote video control.

   538         CVtUiRemoteVideoControl* iRemoteVideoControl;

   539         

   540         //ETrue if iRemoteVideoControl has been added to stack.

   541         TBool iRemoteVideoControlInStack;

   542 

   543         // Owned navi pane controller.

   544         CVtUiNaviPane* iNaviPane;

   545 

   546         // ETrue if number entry has been added to stack.

   547         TBool iNumberEntryInStack;

   548 

   549         // Owned number entry activation control.

   550         CVtUiNumberEntryActivationControl* iNumberEntryActivation;

   551         

   552         // Owned button pane control

   553         CVtUiEndCallButtonPane* iEndCallButtonPane;

   554         

   555         // ETrue if iButtonPane has been added to stack.

   556         TBool iButtonPaneInStack;

   557 

   558     };

   559 

   560 /**

   561 * Encapsulates event handling.

   562 * @since Series 60 2.6

   563 */

   564 class CVtUiAppUi::CEventObserver

   565     : public CBase,

   566       public MVtUiEngineCommandManager,

   567       public MVtEngEventObserver,

   568       public MVtEngCommandObserver,

   569       public MVtEngFrameObserver,

   570       private MBeating,

   571       private MRemConCoreApiTargetObserver

   572     {

   573     public: // Constructors and destructors

   574 

   575         /**

   576         * Two-phased constructor.

   577         * @param aAppUi application UI.

   578         */

   579         static CEventObserver* NewL( CVtUiAppUi& aAppUi );

   580 

   581         /**

   582         * Destructor.

   583         */

   584         ~CEventObserver();

   585 

   586     public: // New functions

   587 

   588         /**

   589         * Returns engine model.

   590         * @return model instance.

   591         */

   592         inline CVtEngModel& Model();

   593         

   594         /**

   595         * Creates remote control framework session.

   596         */

   597         void CreateRemConSessionL();

   598 

   599         /**

   600         * Deletes remote control framework session.

   601         */

   602         void DeleteRemConSession();

   603 

   604         /**

   605         * Checks if command is supported by engine.

   606         * @param aCommandId command.

   607         * @return ETrue if supported, EFalse otherwise.

   608         */

   609         TBool CommandSupported( const TInt aCommandId ) const;

   610 

   611         /**

   612         * Checks if command is supported and synchronous.

   613         * @param aCommandId command.

   614         * @return ETrue if synchronous & supported, EFalse otherwise.

   615         */

   616         TBool CommandSupportedAndSynchronous(

   617             const TInt aCommandId ) const;

   618 

   619         /**

   620         * Starts heartbeat timer.

   621         */

   622         void StartBeatL();

   623 

   624         /**

   625         * Stops heartbeat timer.

   626         */

   627         void StopBeat();

   628 

   629         /**

   630         * Stops volume repeat handling timer.

   631         */

   632         void StopVolumeRepeatTimer();

   633         

   634         /**

   635         * Sends response to prepare.

   636         * @param aResult result code.

   637         */

   638         void SendPrepareResponse( const TInt aResult );

   639 

   640     public: // Functions from base classes

   641 

   642         /**

   643         * @see MVtUiCommandManager::AddObserverL.

   644         */

   645         virtual void AddObserverL( MVtEngCommandObserver& aObserver );

   646 

   647         /**

   648         * @see MVtUiCommandManager::RemoveObserver.

   649         */

   650         virtual void RemoveObserver( MVtEngCommandObserver& aObserver );

   651 

   652         /**

   653         * @see MVtEngEventObserver::HandleVtEventL.

   654         */

   655         virtual void HandleVtEventL( TInt aEvent );

   656 

   657         /**

   658         * @see MVtEngCommandObserver::HandleVTCommandPerformedL.

   659         */

   660         virtual void HandleVTCommandPerformedL(

   661             TVtEngCommandId aCommand,

   662             const TInt aError );

   663 

   664         /**

   665         * @see MVtEngFrameObserver::vtHandleFrameL.

   666         */

   667         virtual void vtHandleFrameL( TFrameType aType, CFbsBitmap* aBitmap );

   668 

   669         /**

   670         * @see MVtEngFrameObserver::vtSetFrame

   671         */

   672         virtual void vtSetFrame( TFrameType aType, CFbsBitmap* aBitmap );

   673 

   674         /**

   675         * @see MBeating::Beat.

   676         */

   677         virtual void Beat();

   678 

   679         /**

   680         * @see MBeating::Synchronize.

   681         */

   682         virtual void Synchronize();

   683 

   684 

   685     private:

   686 

   687         /**

   688         * Constructor.

   689         * @param aAppUi application UI.

   690         */

   691         CEventObserver( CVtUiAppUi& aAppUi );

   692 

   693         /**

   694         * Symbian OS constructor.

   695         */

   696         void ConstructL();

   697 

   698         /**

   699         * Executes CVtUiAppUi methods.

   700         * @param aBits sum of subset of TVtUiHandleEvents.

   701         */

   702         void DoExecuteL( TInt aBits );

   703         /**

   704         * Handles volume change.

   705         * @param aButtonAct button action.

   706         */

   707         void HandleVolumeChange(

   708             TRemConCoreApiButtonAction aButtonAct );

   709         /**

   710         * Handles mute change.

   711         * @param aButtonAct button action.

   712         */

   713         void HandleRemMuteChange(

   714             TRemConCoreApiButtonAction aButtonAct );

   715         /**

   716         * @see MRemConCoreApiTargetObserver::MrccatoCommand.

   717         */

   718         virtual void MrccatoCommand(

   719             TRemConCoreApiOperationId aOperationId,

   720             TRemConCoreApiButtonAction aButtonAct );

   721 

   722         /**

   723         * Callback function to handle volume repeat.

   724         * @param aAny pointer to an instance of this class.

   725         * @return KErrNone.

   726         */

   727         static TInt DoHandleVolumeRepeat( TAny* aAny );

   728 

   729     private:

   730 

   731         // Type definition for CVtUiAppUi member functions.

   732         typedef void (CVtUiAppUi::*TMethodL)();

   733 

   734         // Ref to application ui.

   735         CVtUiAppUi& iAppUi;

   736 

   737         // Engine model.

   738         CVtEngModel* iModel;

   739 

   740         // ETrue when command events are being sent.

   741         TBool iInCommandPerformed;

   742 

   743         // Owned array of observers.

   744         RPointerArray< MVtEngCommandObserver > iCommandObservers;

   745 

   746         // Owned heart beat timer to update call duration.

   747         CHeartbeat* iBeat;

   748         

   749 

   750         // Owned interface selector instance.

   751         CRemConInterfaceSelector* iRemConInterfaceSelector;

   752 

   753         // Pointer to target instance. Owned by iRemConInterfaceSelector.

   754         CRemConCoreApiTarget* iRemConCoreApiTarget;

   755 

   756         // Owned timer for volume repeat handling.

   757         CPeriodic* iRemConVolumeRepeatTimer;

   758 

   759         // Rencon operation id

   760         TRemConCoreApiOperationId iRCCAOperationId;

   761 

   762     };

   763 

   764 /**

   765 * Verifies objects fetched using media gallery. Only non DRM protected

   766 * objects are allowed.

   767 * @since Series 60 3.1

   768 */

   769 class CVtUiAppUi::CVtUiAppUiMGVerifier :

   770     public CBase,

   771     public MMGFetchVerifier

   772     {

   773     public:

   774 

   775             /**

   776             * Static constructor, pushes created instance into cleanup stack.

   777             */

   778         static CVtUiAppUiMGVerifier* NewLC(

   779             CVtUiAppUi& aAppUi, CCoeEnv& aCoeEnv );

   780 

   781             /**

   782             * Destructor.

   783             */

   784         ~CVtUiAppUiMGVerifier();

   785 

   786     public: // from MMGFetchVerifier

   787 

   788         /**

   789             * @see MMGFetchVerifier::VerifySelectionL

   790             */

   791         TBool VerifySelectionL( const MDesCArray* aSelectedFiles );

   792 

   793     private:

   794 

   795             /**

   796             * 2nd constructor in two phase construction.

   797             */

   798         void ConstructL();

   799 

   800         /**

   801             * Constructor.

   802             */

   803         CVtUiAppUiMGVerifier( CVtUiAppUi& aAppUi, CCoeEnv& aCoeEnv );

   804 

   805     private:

   806 

   807         // Reference to Application UI

   808         CVtUiAppUi& iAppUi;

   809 

   810         // Pointer to COE

   811         CCoeEnv* iCoeEnv;

   812 

   813         // Pointer to CManager which manages files and content access agents

   814         CManager* iManager;

   815     };

   816 

   817 // ============================ MEMBER FUNCTIONS ===============================

   818 

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

   820 // CVtUiAppUi::CVtUiAppUi

   821 // C++ default constructor can NOT contain any code, that

   822 // might leave.

   823 // -----------------------------------------------------------------------------

   824 //

   825 CVtUiAppUi::CVtUiAppUi()

   826     : iRenderingMode( ERenderingModeDefault ),

   827       iLoudspeakerVolume( KVolumeResetValue ),

   828       iHandsetVolume( KVolumeResetValue ),

   829       iActiveCommands( 1 ),

   830       iLayoutChg( EFalse ),

   831       iDelayedCmd( 0 )

   832     {

   833     }

   834 

   835 // -----------------------------------------------------------------------------

   836 // CVtUiAppUi::ConstructL

   837 // Symbian 2nd phase constructor.

   838 // -----------------------------------------------------------------------------

   839 //

   840 void CVtUiAppUi::ConstructL()

   841     {

   842     VTLOGINIT

   843     __VTPRINTENTER( "VtUi.ConstructL" )

   844 

   845     FeatureManager::InitializeLibL();

   846     BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

   847     

   848     iCba = Cba();

   849     // Must be done before creating features

   850     iVTVariation.ReadL();

   851 

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

   853     iUiStates = new ( ELeave ) TVtUiStates( iEventObserver->Model() );

   854     iUiStates->Update();

   855         iUiStates->SetViewFindersInitialPlaceContextPane( ETrue );

   856         

   857     TVtUiAppStateBase::SetInitialStateL( *this, *iUiStates );

   858 

   859     iCommandManager = CVtUiCommandManager::NewL( *iUiStates, *this );

   860 

   861     iComponentManager = CVtUiComponentManager::NewL();

   862 

   863     iFeatureManager = CVtUiFeatureManager::NewL( *this, *iUiStates,

   864          *iCommandManager, *iComponentManager );

   865 

   866     iInstance = CInstance::NewL( *this );

   867 

   868     CEikMenuBar* menu = iEikonEnv->AppUiFactory()->MenuBar();

   869     menu->SetContextMenuTitleResourceId( R_VIDEOTELUI_OK_MENUBAR );

   870 

   871 

   872 

   873     CEikonEnv& eikEnv = *( iEikonEnv );

   874     eikEnv.SetSystem( ETrue );

   875     eikEnv.WsSession().ComputeMode( RWsSession::EPriorityControlDisabled );

   876 

   877     iThisApplicationWgId = eikEnv.RootWin().Identifier();

   878     iEikonServerWgId =

   879         eikEnv.WsSession().FindWindowGroupIdentifier( 0, KVtUiEikonServer );

   880     iAknCapServerWgId =

   881         eikEnv.WsSession().FindWindowGroupIdentifier( 0, KVtUiAknCapServer );

   882     iAknNfyServerWgId =

   883         eikEnv.WsSession().FindWindowGroupIdentifier( 0,

   884             KVtUiAknNotifierServer );

   885 

   886     __ASSERT_ALWAYS(

   887         iEikonServerWgId != KErrNotFound,

   888         VtUiPanic::Panic( EVtUiPanicEikonServerNotFound ) );

   889     (void)eikEnv.RootWin().EnableFocusChangeEvents();

   890 

   891 

   892     iUplinkWindow = iInstance->iContextControl;

   893     iDownlinkWindow = iInstance->iMainControl;

   894 

   895 

   896     if ( iCba )

   897         {

   898         CCoeControl* control = iCba->ButtonGroup()->AsControl();

   899         static_cast< CEikCba* >( control )->

   900             SetSkinBackgroundId( KAknsIIDQsnBgAreaControlIdle );

   901         }

   902 

   903     iBlankControl = new ( ELeave ) CVtUiBlankControl;

   904     iBlankControl->ConstructL( ClientRect() );

   905     AddToStackL(

   906         iBlankControl,

   907         KVtUiBlankControlPriority,

   908         ECoeStackFlagRefusesFocus );

   909 

   910     iUiStates->SetBlankControlAdded( ETrue );

   911 

   912     iActiveExec =

   913         new ( ELeave ) CVtUiActiveExec( CActive::EPriorityHigh );

   914     SetCallIdL( KVtUiDefaultCallId );

   915 

   916     iExitTimer = CPeriodic::NewL( CActive::EPriorityHigh );

   917     CheckEngineFunctionality();

   918 

   919     iAsyncCallback =

   920         new ( ELeave ) CAsyncCallBack (

   921             TCallBack( &AsyncViewFinderToMainPaneAndShare, this ),

   922             CActive::EPriorityStandard );

   923 

   924     iLayoutChangeCallback =

   925         new ( ELeave ) CAsyncCallBack(

   926             TCallBack( &DelayedHandleLayoutChanged, this ),

   927             CActive::EPriorityStandard );

   928 

   929     iCurrentCameraOrientation = MVtEngMedia::EOrientationObeyLayoutSwitch;

   930 

   931     GetCameraOrientations();

   932 

   933     SetInitialCameraOrientationL();

   934 

   935     iVolCtrl= new ( ELeave )CVtUiVolumeControl(

   936         Model().CommandHandler(),

   937         Model().Audio(),

   938         *iEventObserver,

   939         *iFeatureManager);

   940     iVolCtrl->ConstructL();

   941 

   942     iIncallBubble = CAknIncallBubble::NewL();

   943 

   944     iIsWaitingCallState = EFalse;

   945     

   946     __VTPRINTEXIT( "VtUi.ConstructL" )

   947     }

   948 

   949 // -----------------------------------------------------------------------------

   950 // CVtUiAppUi::~CVtUiAppUi

   951 // -----------------------------------------------------------------------------

   952 //

   953 CVtUiAppUi::~CVtUiAppUi()

   954     {

   955     __VTPRINTENTER( "VtUi.~" )

   956 

   957     iActiveCommands.Close();

   958 

   959     delete iLayoutChangeCallback;

   960     delete iAsyncCallback;

   961 

   962     if ( iUiStates && iUiStates->IsBlankControlAdded() )

   963         {

   964         RemoveFromStack( iBlankControl );

   965         }

   966     TInt lightsValue = 0;

   967     if ( RProperty::Get( KPSUidCoreApplicationUIs,

   968             KLightsVTForcedLightsOn, lightsValue ) == KErrNone )

   969         {

   970         if ( lightsValue == EForcedLightsOn )

   971             {

   972             __VTPRINT( DEBUG_GEN, "VtUi.~ Good night!" )

   973             (void) RProperty::Set(

   974                 KPSUidCoreApplicationUIs,

   975                 KLightsVTForcedLightsOn,

   976                 EForcedLightsOff );

   977             }

   978         }

   979     delete iActiveExec;

   980     delete iInstance;

   981     delete iBlankControl;

   982     // Delete volume control before its dependencies are deleted.

   983     delete iVolCtrl;

   984     delete iEventObserver;

   985     delete iExitTimer;

   986     // Featuremanager must be destructed

   987     // before componentmanager and commandmanager

   988     delete iFeatureManager;

   989     delete iComponentManager;

   990     delete iCommandManager;

   991     delete iUiStates;

   992 

   993     if ( iTbPeriodic )

   994         {

   995         iTbPeriodic->Cancel();

   996         }

   997     delete iTbPeriodic;

   998 

   999     if ( iIncallBubble )

  1000         {

  1001         TRAP_IGNORE( iIncallBubble->SetIncallBubbleAllowedInUsualL( ETrue ) )    

  1002         }

  1003     delete iIncallBubble;

  1004 

  1005     // Close all RComm sessions to prevent memory leaks.

  1006     REComSession::FinalClose();

  1007 

  1008     FeatureManager::UnInitializeLib();

  1009     __VTPRINTEXIT( "VtUi.~" )

  1010     VTLOGUNINIT

  1011     }

  1012 

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

  1014 // CVtUiAppUi::SwitchLayoutToFlatStatusPaneL

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

  1016 //

  1017 void CVtUiAppUi::SwitchLayoutToFlatStatusPaneL( TBool aSwitch )

  1018     {

  1019     __VTPRINTENTER( "VtUi.SwitchLayoutToFlatStatusPaneL" )

  1020     CEikStatusPane* statusPane = StatusPane();

  1021 

  1022     const TInt idleResId(

  1023         VtUiLayout::IsLandscapeOrientation() ?

  1024             R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL :

  1025                 R_AVKON_STATUS_PANE_LAYOUT_USUAL );

  1026 

  1027     const TBool isStatusPaneFlat(

  1028         ( statusPane->CurrentLayoutResId() ==

  1029             R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT ) ||

  1030         ( statusPane->CurrentLayoutResId() ==

  1031             R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT ) );

  1032 

  1033     if ( aSwitch )

  1034         {

  1035         if ( isStatusPaneFlat && VtUiLayout::IsLandscapeOrientation() )

  1036             {

  1037             __VTPRINT( DEBUG_GEN,

  1038                 "VtUi.SwitchLayoutToFlatStatusPaneL LAYOUT USUAL" );

  1039             statusPane->SwitchLayoutL( idleResId );

  1040             }

  1041         else if ( !isStatusPaneFlat && !VtUiLayout::IsLandscapeOrientation() )

  1042             {

  1043             __VTPRINT( DEBUG_GEN,

  1044                 "VtUi.SwitchLayoutToFlatStatusPaneL USUAL FLAT" );

  1045             statusPane->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT );

  1046             }

  1047         }

  1048     else

  1049         {

  1050         if ( isStatusPaneFlat )

  1051             {

  1052             __VTPRINT( DEBUG_GEN,

  1053                 "VtUi.SwitchLayoutToFlatStatusPaneL LAYOUT IDLE" );

  1054             statusPane->SwitchLayoutL( idleResId );

  1055             }

  1056         }

  1057     // ApplyCurrentSettingsL is called whenever statuspane

  1058     // visibility status or pane layout changes.

  1059     statusPane->ApplyCurrentSettingsL();

  1060     statusPane->DrawNow();

  1061     // Make sure whole control is fully updated

  1062     iInstance->iMainControl->DrawNow();

  1063     __VTPRINTEXIT( "VtUi.SwitchLayoutToFlatStatusPaneL" )

  1064     }

  1065 

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

  1067 // CVtUiAppUi::RefreshL

  1068 // -----------------------------------------------------------------------------

  1069 //

  1070 void CVtUiAppUi::RefreshL()

  1071     {

  1072     __VTPRINTENTER( "VtUi.Refresh" )

  1073     RefreshBlind();

  1074     RefreshNaviPaneL();    

  1075     __VTPRINTEXIT( "VtUi.Refresh" )

  1076     }

  1077 

  1078 // -----------------------------------------------------------------------------

  1079 // CVtUiAppUi::RefreshNaviPaneL

  1080 // -----------------------------------------------------------------------------

  1081 //

  1082 void CVtUiAppUi::RefreshNaviPaneL()

  1083     {

  1084     // Update only if navi pane exists

  1085     if ( iInstance )

  1086         {

  1087         __VTPRINT( DEBUG_GEN, "VtUi.RefreshNavi" )

  1088         CVtUiNaviPane* navi = iInstance->iNaviPane;

  1089 

  1090         // Refresh muted state

  1091         MVtEngMedia& media = Model().Media();

  1092         TInt mediaAvail;

  1093         VtUiUtility::GetOutgoingMediaState( media, mediaAvail );

  1094         mediaAvail = ~mediaAvail;

  1095         navi->SetMuted( mediaAvail & MVtEngMedia::EMediaAudio );

  1096 

  1097         // Refresh call duration

  1098         MVtEngSessionInfo& session = Model().Session();

  1099         MVtEngSessionInfo::TDuration duration;

  1100         TBool enabled;

  1101         if ( session.GetDuration( duration, enabled ) != KErrNone )

  1102             {

  1103             enabled = EFalse;

  1104             }

  1105         navi->SetCallDuration( duration, enabled );

  1106 

  1107         // Update all changes

  1108         navi->CommitL();

  1109 

  1110         CheckBeatL( enabled );

  1111         }

  1112     }

  1113 

  1114 void CVtUiAppUi::StopBrightnessOrContrast()

  1115     {

  1116     

  1117     MVtUiFeature* br = iFeatureManager->GetFeatureById( EVtUiFeatureIdBrightness );

  1118     if ( br )

  1119         {

  1120         __VTPRINT( DEBUG_GEN, "VtUi.StopBrightness" )

  1121         if ( br->State() ==  MVtUiFeature::EActive )

  1122             {

  1123             __VTPRINT( DEBUG_GEN, "VtUi.StopBrightnessOrContrast br->STOP" )

  1124             br->Stop();

  1125             }

  1126         }

  1127     

  1128     MVtUiFeature* cr = iFeatureManager->GetFeatureById( EVtUiFeatureIdContrast );

  1129     if ( cr )

  1130         {

  1131         __VTPRINT( DEBUG_GEN, "VtUi.StopContrast" )

  1132         if ( cr->State() ==  MVtUiFeature::EActive )

  1133            {

  1134            __VTPRINT( DEBUG_GEN, "VtUi.StopBrightnessOrContrast cr->STOP" )