--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vtuis/videotelui/src/CVtUiAppUi.cpp Mon Nov 23 14:47:47 2009 +0200
@@ -0,0 +1,7302 @@
+/*
+* Copyright (c) 2004 - 2008 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Implementation of the CVtUiAppUi application UI class.
+*
+*/
+
+
+
+// INCLUDE FILES
+#include "videotelui.hrh"
+#include "CVtUiAppUi.h"
+#include "CVtUiMainControl.h"
+#include "CVtUiContextControl.h"
+#include "CVtUiNumberEntryActivationControl.h"
+#include "CVtUiNaviPane.h"
+#include "VtUiLayout.h"
+#include "MVtUiEngineCommandManager.h"
+#include "CVtUiExecuteCmdDialog.h"
+#include "CVtUiAllowVideoDialog.h"
+#include "CVtUiBlankControl.h"
+#include "VtUiLayout.h"
+#include "VtUiUtility.h"
+#include "VtUiPanic.h"
+#include "CVtUiActivateBtHfDialog.h"
+#include "CVtUiRemoteVideoControl.h"
+#include <csxhelp/incl.hlp.hrh>
+
+
+#include <aknincallbubblenotify.h>
+#include <aknslayeredbackgroundcontrolcontext.h>
+#include <aknutils.h>
+#include <aknnavi.h>
+#include <akntitle.h>
+#include <akndlgshut.h>
+#include <aknnotedialog.h>
+#include <aknnotewrappers.h>
+#include <akncontext.h>
+#include <eikspane.h>
+#include <eikmenup.h>
+#include <eikmenub.h>
+#include <apgcli.h>
+#include <featmgr.h>
+#include <videotelui.rsg>
+#include <hlplch.h>
+#include <apgwgnam.h>
+#include <stringloader.h>
+#include <akndef.h>
+#include <aknconsts.h>
+
+
+#include <e32property.h>
+#include <ecom/ecom.h>
+#include <coreapplicationuisdomainpskeys.h>
+#include <uikoninternalpskeys.h>
+#include <centralrepository.h>
+#include <videotelephonyinternalcrkeys.h>
+#include <settingsinternalcrkeys.h>
+#include <e32property.h>
+#include <telcommsinfopskeys.h>
+#include <telinformationpskeys.h>
+#include <activeidle2domainpskeys.h>
+#include <ctsydomainpskeys.h>
+
+#include <aknquerydialog.h>
+#include <aknglobalnote.h>
+#include <aknsoundsystem.h>
+
+
+#include <cvtlogger.h>
+#include <cvtengmodel.h>
+#include <mvtengeventobserver.h>
+#include <mvtengcommandobserver.h>
+#include <mvtengcommandhandler.h>
+#include <mvtengframeobserver.h>
+#include <mvtengaudio.h>
+#include <mvtengsessioninfo.h>
+#include <vtengevents.h>
+#include <mvtengmedia.h>
+
+#include "CVtUiBitmapManager.h"
+
+#include <mgfetch.h>
+#include <mmgfetchverifier.h>
+#include <caf/manager.h>
+#include <caf/virtualpathptr.h>
+
+#include "cvtuifeaturemanager.h"
+#include "cvtuicomponentmanager.h"
+#include "cvtuicommandmanager.h"
+#include "tvtuistates.h"
+#include "cvtuimenus.h"
+#include "cvtuisoftkeys.h"
+#include "cvtuitoolbarbase.h"
+#include "cvtuiwhitebalance.h"
+#include "cvtuicolortone.h"
+#include "cvtuibrightness.h"
+#include "cvtuicontrast.h"
+#include <remconinterfaceselector.h>
+#include <remconcoreapitarget.h>
+#include <remconcoreapitargetobserver.h>
+#include "tvtuiwsevent.h"
+#include "mvtuinumbersource.h"
+#include "tVtuifeaturevariation.h"
+#include "cvtuidialer.h"
+#include "tvtuiappstates.h"
+#include "cvtuivolume.h"
+#include "cvtuizoom.h"
+#include "cvtuivolumecontrol.h"
+
+using namespace ContentAccess;
+
+// CONSTANTS
+
+// Engine orientation to application orientation map
+const CVtUiAppUi::TAppUiOrientation engToAppOrientation[] = {
+ CVtUiAppUi::EAppUiOrientationLandscape,
+ CVtUiAppUi::EAppUiOrientationPortrait,
+ CVtUiAppUi::EAppUiOrientationUnspecified };
+
+// Amount of help contexts.
+const TInt KVtUiHelpContextAmount = 1;
+
+// UID of Video Telephone application.
+const TUid KVtUiAppUid = { KVtUiAppUidValue };
+
+// Granularity of command observer array.
+const TInt KVtUiCommandObserverArrayGranularity = 5;
+
+// Default call index.
+const TInt KVtUiDefaultCallId = 1;
+
+// Control priority for the blank control. Above all other controls.
+const TInt KVtUiBlankControlPriority =
+ ECoeStackPriorityEnvironmentFilter + 100;
+
+// Exit timeout.
+const TInt KVtUiExitTimeout = 10000000;
+
+// UID of the main telephone application
+const TUid KVtUiTelephoneUid = { 0x100058B3 };
+
+// Reset value for volume
+const TInt KVolumeResetValue = -1;
+
+
+// Name of the EIKON server window group.
+_LIT( KVtUiEikonServer, "EikonServer" );
+
+// Name of the AknCapServer window group.
+_LIT( KVtUiAknCapServer, "*akncapserver*" );
+
+// Name of the AknNotifierServer window group.
+_LIT( KVtUiAknNotifierServer, "*aknnfysrv*" );
+
+// Volume repeat delay.
+const TInt KVtUiVolumeRepeatDelay = KAknStandardKeyboardRepeatRate;
+
+// Volume repeat long delay.
+const TInt KVtUiVolumeRepeatLongDelay = KAknKeyboardRepeatInitialDelay;
+
+// Start time for toolbar timer
+const TTimeIntervalMicroSeconds32 KStartTime( 600000 );
+
+// period time for toolbar timer
+const TTimeIntervalMicroSeconds32 KPeriodTime( 300000 );
+
+// The maximum frequency that user can swap image places.
+const TInt64 KVtUiMaxSwapImagesFreq( 1000000 );
+
+// Enumerates methods used in event handling. This enumeration MUST
+// match with methodArray local array.
+enum TVtUiHandleEvents
+ {
+ // Refresh states
+ EVtUiRefreshStates = 1 << 0,
+ // Handle remote problem.
+ EVtUiHandleVideoFrameRemoteProblem = 1 << 1,
+ // Handle local problem.
+ EVtUiHandleVideoFrameLocalProblem = 1 << 2,
+ // Refresh navipane.
+ EVtUiRefreshNaviPane = 1 << 3,
+ // Refresh softkeys.
+ EVtUiRefreshSoftkeys = 1 << 4,
+ // Refresh blind icon status.
+ EVtUiRefreshBlind = 1 << 5,
+ // Stop showing waiting image text.
+ EVtUiStopWaitingImage = 1 << 6,
+ // Rx resolution changed.
+ EVtUiChangeRemoteVideoLayout = 1 << 7,
+ // Show initializing image progress
+ EVtUiShowImageInitializingProgress = 1 << 8,
+ // Hide initializing image progress
+ EVtUiHideImageInitializingProgress = 1 << 9,
+ // Set camera orientation
+ EVtUiSetOrientation = 1 << 10,
+ //Handle media status change
+ EVtUiMediaStateChanged = 1 << 11,
+ //Show decoding error note
+ EVtUiShowDecodingError = 1 << 12,
+ // Stop the white balance and color tone
+ EVtUiStopWBOrColortone = 1 << 13,
+ // refresh Menu
+ EVtUiRefreshMenu = 1 << 14,
+ // Stop brightness and contrast slider
+ EVtUiStopBrightnessOrContrast = 1 << 15,
+ // refresh zoom popup
+ EVtUiRefreshZoomPopup = 1 << 16
+ };
+
+// Enumerates states for CVtUiActiveExec.
+enum
+ {
+ // Operation finished. Must equal to zero.
+ EVtUiAppUiNone,
+
+ // Active execution states for iActiveExec:
+
+ // Startup (prepare engine):
+ EVtUiAppUiStartup = 100, // 100
+ // Close dialogs.
+ EVtUiAppUiStartupCloseDialogs = EVtUiAppUiStartup, // 100
+ // Initialise engine.
+ EVtUiAppUiStartupInitEngine, // 101
+ // Prepare viewfinder.
+ EVtUiAppUiStartupPrepareViewfinder, // 102
+ // Prepare remote render.
+ EVtUiAppUiStartupPrepareRemoteRender, // 103
+ // Remove blank.
+ EVtUiAppUiStartupRemoveBlank, // 104
+
+ // Shutdown (reset engine):
+ EVtUiAppUiShutdown = 300, // 300
+ // Close dialogs.
+ EVtUiAppUiShutdownCloseDialogs = EVtUiAppUiShutdown, // 300
+ // Hide application.
+ EVtUiAppUiShutdownHideApplication, // 301
+ // Reset engine.
+ EVtUiAppUiShutdownResetEngine, // 302
+ // Remove blank.
+ EVtUiAppUiShutdownRemoveBlank, // 303
+
+ // Answered:
+ EVtUiAppUiAnswered = 500, // 500
+ // Show blank dialog.
+ EVtUiAppUiAnsweredStart = EVtUiAppUiAnswered, // 500
+ // Refresh navipane.
+ EVtUiAppUiAnsweredRefreshNavi, // 501
+ // Refresh softkeys.
+ EVtUiAppUiAnsweredRefreshSoftkeys, // 502
+ // Start remote render.
+ EVtUiAppUiAnsweredStartRemoteRender, // 503
+
+ // Prepares camera
+ EVtUiAppUiAnsweredCheckCamera, // 504
+ // Choose if it's needed to show query or directly activate camera.
+ EVtUiAppUiAnsweredChoose, // 505
+ // Set still image as source.
+ EVtUiAppUiAnsweredQuerySetupStill, // 506
+ // Set none as source.
+ EVtUiAppUiAnsweredQuerySetupNone, // 507
+ // Start viewfinder.
+ EVtUiAppUiAnsweredQuerySetupStart, // 508
+ // Show "allow video image" query.
+ EVtUiAppUiAnsweredQueryShow, // 509
+ // Check if user allowed video image.
+ EVtUiAppUiAnsweredQueryDecide, // 510
+ // Select camera as source.
+ EVtUiAppUiAnsweredQuerySelectCamera, // 511
+ // Select still image as source.
+ EVtUiAppUiAnsweredQuerySelectStill, // 512
+ // Select none as source.
+ EVtUiAppUiAnsweredQuerySelectNone, // 513
+ // Start viewfinder.
+ EVtUiAppUiAnsweredQueryStartViewfinder, // 514
+ // Finish.
+ EVtUiAppUiAnsweredQueryFinish, // 515
+ // Select camera as source.
+ EVtUiAppUiAnsweredSelectCamera, // 516
+ // Select still image as source.
+ EVtUiAppUiAnsweredSelectStill, // 517
+ // Select none as source.
+ EVtUiAppUiAnsweredSelectNone, // 518
+ // Start viewfinder.
+ EVtUiAppUiAnsweredStartViewfinder, // 519
+ // Finish.
+ EVtUiAppUiAnsweredFinish, // 520
+
+ // Prepares camera
+ EVtUiAppUiAnsweredDoPrepareCamera // 521
+ };
+
+/**
+* Enumerates background layers
+*/
+enum TVtUiBackgroundLayers
+ {
+ // Idle state background.
+ EVtUiLayerBackground = 0,
+ // Wallpaper layout.
+ EVtUiLayerWallpaper = 1,
+ // Amount of layers.
+ EVtUiLayerCount = 2
+ };
+
+// MODULE DATA STRUCTURES
+
+/**
+* Asynchronous command executor that does not use dialog for waiting the
+* execution completion.
+* @since Series 60 5.0
+*/
+class CVtEngCmdExec : public CBase, private MVtEngCommandObserver
+ {
+
+public:
+ /**
+ * Static constructor.
+ */
+ static CVtEngCmdExec* NewL( MVtEngCommandHandler& aCommandHandler,
+ MVtUiEngineCommandManager& aCommandManager,
+ CEikButtonGroupContainer& aCBA );
+
+ /**
+ * Executes given command asynchronously, waiting the command completion.
+ */
+ void ExecuteCmdLD( const TVtEngCommandId aCommandId );
+
+ /**
+ * Destructor.
+ */
+ ~CVtEngCmdExec();
+
+private: // from MVtEngCommandObserver
+
+ /**
+ * @see MVtEngCommandObserver::HandleVTCommandPerformedL
+ */
+ void HandleVTCommandPerformedL( TVtEngCommandId aCommand,
+ const TInt aError );
+
+private:
+
+ /**
+ * Constructor.
+ */
+ CVtEngCmdExec( MVtEngCommandHandler& aCommandHandler,
+ MVtUiEngineCommandManager& aCommandManager,
+ CEikButtonGroupContainer& aCBA );
+
+private:
+
+ CActiveSchedulerWait iWait;
+
+ MVtEngCommandHandler& iCommandHandler;
+
+ MVtUiEngineCommandManager& iCommandManager;
+
+ TVtEngCommandId iCommandId;
+
+ CEikButtonGroupContainer& iCBA;
+
+ };
+
+// -----------------------------------------------------------------------------
+// CVtEngCmdExec::NewL
+// -----------------------------------------------------------------------------
+//
+CVtEngCmdExec* CVtEngCmdExec::NewL( MVtEngCommandHandler& aCommandHandler,
+ MVtUiEngineCommandManager& aCommandManager, CEikButtonGroupContainer& aCBA )
+ {
+ CVtEngCmdExec* self = new ( ELeave ) CVtEngCmdExec( aCommandHandler,
+ aCommandManager, aCBA );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngCmdExec::ExecuteCmdLD
+// -----------------------------------------------------------------------------
+//
+void CVtEngCmdExec::ExecuteCmdLD( const TVtEngCommandId aCommandId )
+ {
+ __VTPRINTENTER("CVtEngCmdExec::ExecuteCmdLD")
+ CleanupStack::PushL( this );
+ iCommandId = aCommandId;
+ iCommandManager.AddObserverL( *this );
+ iCommandHandler.ExecuteL( aCommandId, NULL );
+ iCBA.SetCommandSetL( R_VIDEOTELUI_SOFTKEYS_EMPTY );
+ iCBA.DrawNow();
+ iWait.Start();
+ CleanupStack::PopAndDestroy(); // this
+ __VTPRINTEXIT("CVtEngCmdExec::ExecuteCmdLD")
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngCmdExec::~CVtEngCmdExec
+// -----------------------------------------------------------------------------
+//
+CVtEngCmdExec::~CVtEngCmdExec()
+ {
+ __VTPRINTENTER("CVtEngCmdExec::~CVtEngCmdExec")
+ if ( iWait.IsStarted())
+ {
+ __VTPRINT(DEBUG_GEN, "CVtEngCmdExec::~CVtEngCmdExec AsyncStop")
+ iWait.AsyncStop();
+ }
+ iCommandManager.RemoveObserver( *this );
+ __VTPRINTEXIT("CVtEngCmdExec::~CVtEngCmdExec")
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngCmdExec::HandleVTCommandPerformedL
+// -----------------------------------------------------------------------------
+//
+void CVtEngCmdExec::HandleVTCommandPerformedL( TVtEngCommandId aCommand,
+ const TInt aError )
+ {
+ __VTPRINTENTER("CVtEngCmdExec::HandleVTCommandPerformedL")
+ if ( iCommandId == aCommand )
+ {
+ if ( iWait.IsStarted())
+ {
+ __VTPRINT(DEBUG_GEN, "CVtEngCmdExec::HandleVTCommandPerformedL AsyncStop")
+ iWait.AsyncStop();
+ }
+ else
+ {
+ // request already completed
+ }
+ }
+ else
+ {
+ // wrong command ID
+ }
+ __VTPRINTEXIT("CVtEngCmdExec::HandleVTCommandPerformedL")
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngCmdExec::CVtEngCmdExec
+// -----------------------------------------------------------------------------
+//
+CVtEngCmdExec::CVtEngCmdExec( MVtEngCommandHandler& aCommandHandler,
+ MVtUiEngineCommandManager& aCommandManager, CEikButtonGroupContainer& aCBA )
+ : iCommandHandler( aCommandHandler ),
+ iCommandManager( aCommandManager ), iCBA( aCBA )
+ {
+ }
+
+/**
+* Encapsulates all instances related to user interface.
+* @since Series 60 2.6
+*/
+class CVtUiAppUi::CInstance
+ : public CBase
+ {
+ public: // Constructors and destructors
+
+ /**
+ * Two-phased constructor.
+ * @param aAppUi reference to application UI.
+ */
+ static CInstance* NewL( CVtUiAppUi& aAppUi );
+
+ /**
+ * Destructor.
+ */
+ ~CInstance();
+
+ /**
+ * Called when side volume key is pressed.
+ */
+ void VolumeKeyPressedL();
+
+ /**
+ * Create remote video control.
+ */
+ void CreateRemoteVideoControl();
+
+ private:
+
+ /**
+ * Constructor.
+ */
+ CInstance( CVtUiAppUi& aAppUi );
+
+ /**
+ * Symbian OS constructor.
+ */
+ void ConstructL();
+
+ /**
+ * Relayout controls.
+ */
+ void LayoutChanged();
+
+ private:
+
+ // Parent can access members.
+ friend class CVtUiAppUi;
+
+ // Ref to application UI.
+ CVtUiAppUi& iAppUi;
+
+ // Owned bitmap manager.
+ CVtUiBitmapManager* iBitmapManager;
+
+ // ETrue if iMainControl has been added to stack.
+ TBool iMainControlInStack;
+
+ // Owned main pane control.
+ CVtUiMainControl* iMainControl;
+
+ // ETrue if iContextControl has been added to stack.
+ TBool iContextControlInStack;
+
+ // Owned context pane control.
+ CVtUiContextControl* iContextControl;
+
+ // Owned remote video control.
+ CVtUiRemoteVideoControl* iRemoteVideoControl;
+
+ //ETrue if iRemoteVideoControl has been added to stack.
+ TBool iRemoteVideoControlInStack;
+
+ // Owned navi pane controller.
+ CVtUiNaviPane* iNaviPane;
+
+ // ETrue if number entry has been added to stack.
+ TBool iNumberEntryInStack;
+
+ // Owned number entry activation control.
+ CVtUiNumberEntryActivationControl* iNumberEntryActivation;
+
+ };
+
+/**
+* Encapsulates event handling.
+* @since Series 60 2.6
+*/
+class CVtUiAppUi::CEventObserver
+ : public CBase,
+ public MVtUiEngineCommandManager,
+ public MVtEngEventObserver,
+ public MVtEngCommandObserver,
+ public MVtEngFrameObserver,
+ private MBeating,
+ private MRemConCoreApiTargetObserver
+ {
+ public: // Constructors and destructors
+
+ /**
+ * Two-phased constructor.
+ * @param aAppUi application UI.
+ */
+ static CEventObserver* NewL( CVtUiAppUi& aAppUi );
+
+ /**
+ * Destructor.
+ */
+ ~CEventObserver();
+
+ public: // New functions
+
+ /**
+ * Returns engine model.
+ * @return model instance.
+ */
+ inline CVtEngModel& Model();
+
+ /**
+ * Creates remote control framework session.
+ */
+ void CreateRemConSessionL();
+
+ /**
+ * Deletes remote control framework session.
+ */
+ void DeleteRemConSession();
+
+ /**
+ * Checks if command is supported by engine.
+ * @param aCommandId command.
+ * @return ETrue if supported, EFalse otherwise.
+ */
+ TBool CommandSupported( const TInt aCommandId ) const;
+
+ /**
+ * Checks if command is supported and synchronous.
+ * @param aCommandId command.
+ * @return ETrue if synchronous & supported, EFalse otherwise.
+ */
+ TBool CommandSupportedAndSynchronous(
+ const TInt aCommandId ) const;
+
+ /**
+ * Starts heartbeat timer.
+ */
+ void StartBeatL();
+
+ /**
+ * Stops heartbeat timer.
+ */
+ void StopBeat();
+
+ /**
+ * Stops volume repeat handling timer.
+ */
+ void StopVolumeRepeatTimer();
+
+ /**
+ * Sends response to prepare.
+ * @param aResult result code.
+ */
+ void SendPrepareResponse( const TInt aResult );
+
+ public: // Functions from base classes
+
+ /**
+ * @see MVtUiCommandManager::AddObserverL.
+ */
+ virtual void AddObserverL( MVtEngCommandObserver& aObserver );
+
+ /**
+ * @see MVtUiCommandManager::RemoveObserver.
+ */
+ virtual void RemoveObserver( MVtEngCommandObserver& aObserver );
+
+ /**
+ * @see MVtEngEventObserver::HandleVtEventL.
+ */
+ virtual void HandleVtEventL( TInt aEvent );
+
+ /**
+ * @see MVtEngCommandObserver::HandleVTCommandPerformedL.
+ */
+ virtual void HandleVTCommandPerformedL(
+ TVtEngCommandId aCommand,
+ const TInt aError );
+
+ /**
+ * @see MVtEngFrameObserver::vtHandleFrameL.
+ */
+ virtual void vtHandleFrameL( TFrameType aType, CFbsBitmap* aBitmap );
+
+ /**
+ * @see MVtEngFrameObserver::vtSetFrame
+ */
+ virtual void vtSetFrame( TFrameType aType, CFbsBitmap* aBitmap );
+
+ /**
+ * @see MBeating::Beat.
+ */
+ virtual void Beat();
+
+ /**
+ * @see MBeating::Synchronize.
+ */
+ virtual void Synchronize();
+
+
+ private:
+
+ /**
+ * Constructor.
+ * @param aAppUi application UI.
+ */
+ CEventObserver( CVtUiAppUi& aAppUi );
+
+ /**
+ * Symbian OS constructor.
+ */
+ void ConstructL();
+
+ /**
+ * Executes CVtUiAppUi methods.
+ * @param aBits sum of subset of TVtUiHandleEvents.
+ */
+ void DoExecuteL( TInt aBits );
+ /**
+ * Handles volume change.
+ * @param aButtonAct button action.
+ */
+ void HandleVolumeChange(
+ TRemConCoreApiButtonAction aButtonAct );
+ /**
+ * Handles mute change.
+ * @param aButtonAct button action.
+ */
+ void HandleRemMuteChange(
+ TRemConCoreApiButtonAction aButtonAct );
+ /**
+ * @see MRemConCoreApiTargetObserver::MrccatoCommand.
+ */
+ virtual void MrccatoCommand(
+ TRemConCoreApiOperationId aOperationId,
+ TRemConCoreApiButtonAction aButtonAct );
+
+ /**
+ * Callback function to handle volume repeat.
+ * @param aAny pointer to an instance of this class.
+ * @return KErrNone.
+ */
+ static TInt DoHandleVolumeRepeat( TAny* aAny );
+
+ private:
+
+ // Type definition for CVtUiAppUi member functions.
+ typedef void (CVtUiAppUi::*TMethodL)();
+
+ // Ref to application ui.
+ CVtUiAppUi& iAppUi;
+
+ // Engine model.
+ CVtEngModel* iModel;
+
+ // ETrue when command events are being sent.
+ TBool iInCommandPerformed;
+
+ // Owned array of observers.
+ RPointerArray< MVtEngCommandObserver > iCommandObservers;
+
+ // Owned heart beat timer to update call duration.
+ CHeartbeat* iBeat;
+
+
+ // Owned interface selector instance.
+ CRemConInterfaceSelector* iRemConInterfaceSelector;
+
+ // Pointer to target instance. Owned by iRemConInterfaceSelector.
+ CRemConCoreApiTarget* iRemConCoreApiTarget;
+
+ // Owned timer for volume repeat handling.
+ CPeriodic* iRemConVolumeRepeatTimer;
+
+ // Rencon operation id
+ TRemConCoreApiOperationId iRCCAOperationId;
+
+ };
+
+/**
+* Verifies objects fetched using media gallery. Only non DRM protected
+* objects are allowed.
+* @since Series 60 3.1
+*/
+class CVtUiAppUi::CVtUiAppUiMGVerifier :
+ public CBase,
+ public MMGFetchVerifier
+ {
+ public:
+
+ /**
+ * Static constructor, pushes created instance into cleanup stack.
+ */
+ static CVtUiAppUiMGVerifier* NewLC(
+ CVtUiAppUi& aAppUi, CCoeEnv& aCoeEnv );
+
+ /**
+ * Destructor.
+ */
+ ~CVtUiAppUiMGVerifier();
+
+ public: // from MMGFetchVerifier
+
+ /**
+ * @see MMGFetchVerifier::VerifySelectionL
+ */
+ TBool VerifySelectionL( const MDesCArray* aSelectedFiles );
+
+ private:
+
+ /**
+ * 2nd constructor in two phase construction.
+ */
+ void ConstructL();
+
+ /**
+ * Constructor.
+ */
+ CVtUiAppUiMGVerifier( CVtUiAppUi& aAppUi, CCoeEnv& aCoeEnv );
+
+ private:
+
+ // Reference to Application UI
+ CVtUiAppUi& iAppUi;
+
+ // Pointer to COE
+ CCoeEnv* iCoeEnv;
+
+ // Pointer to CManager which manages files and content access agents
+ CManager* iManager;
+ };
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CVtUiAppUi
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CVtUiAppUi()
+ : iRenderingMode( ERenderingModeDefault ),
+ iLoudspeakerVolume( KVolumeResetValue ),
+ iHandsetVolume( KVolumeResetValue ),
+ iActiveCommands( 1 ),
+ iLayoutChg( EFalse ),
+ iDelayedCmd( 0 )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ConstructL
+// Symbian 2nd phase constructor.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ConstructL()
+ {
+ VTLOGINIT
+ __VTPRINTENTER( "VtUi.ConstructL" )
+
+ FeatureManager::InitializeLibL();
+ BaseConstructL( EAknEnableSkin | EAknEnableMSK );
+
+ iCba = Cba();
+ // Must be done before creating features
+ iVTVariation.ReadL();
+
+ iEventObserver = CEventObserver::NewL( *this );
+ iUiStates = new ( ELeave ) TVtUiStates( iEventObserver->Model() );
+ iUiStates->Update();
+ iUiStates->SetViewFindersInitialPlaceContextPane( ETrue );
+
+ TVtUiAppStateBase::SetInitialStateL( *this, *iUiStates );
+
+ iCommandManager = CVtUiCommandManager::NewL( *iUiStates, *this );
+
+ iComponentManager = CVtUiComponentManager::NewL();
+
+ iFeatureManager = CVtUiFeatureManager::NewL( *this, *iUiStates,
+ *iCommandManager, *iComponentManager );
+
+ iInstance = CInstance::NewL( *this );
+
+ CEikMenuBar* menu = iEikonEnv->AppUiFactory()->MenuBar();
+ menu->SetContextMenuTitleResourceId( R_VIDEOTELUI_OK_MENUBAR );
+
+
+
+ CEikonEnv& eikEnv = *( iEikonEnv );
+ eikEnv.SetSystem( ETrue );
+ eikEnv.WsSession().ComputeMode( RWsSession::EPriorityControlDisabled );
+
+ iThisApplicationWgId = eikEnv.RootWin().Identifier();
+ iEikonServerWgId =
+ eikEnv.WsSession().FindWindowGroupIdentifier( 0, KVtUiEikonServer );
+ iAknCapServerWgId =
+ eikEnv.WsSession().FindWindowGroupIdentifier( 0, KVtUiAknCapServer );
+ iAknNfyServerWgId =
+ eikEnv.WsSession().FindWindowGroupIdentifier( 0,
+ KVtUiAknNotifierServer );
+
+ __ASSERT_ALWAYS(
+ iEikonServerWgId != KErrNotFound,
+ VtUiPanic::Panic( EVtUiPanicEikonServerNotFound ) );
+ (void)eikEnv.RootWin().EnableFocusChangeEvents();
+
+
+ iUplinkWindow = iInstance->iContextControl;
+ iDownlinkWindow = iInstance->iMainControl;
+
+
+ if ( iCba )
+ {
+ CCoeControl* control = iCba->ButtonGroup()->AsControl();
+ static_cast< CEikCba* >( control )->
+ SetSkinBackgroundId( KAknsIIDQsnBgAreaControlIdle );
+ }
+
+ iBlankControl = new ( ELeave ) CVtUiBlankControl;
+ iBlankControl->ConstructL( ClientRect() );
+ AddToStackL(
+ iBlankControl,
+ KVtUiBlankControlPriority,
+ ECoeStackFlagRefusesFocus );
+
+ iUiStates->SetBlankControlAdded( ETrue );
+
+ iActiveExec =
+ new ( ELeave ) CVtUiActiveExec( CActive::EPriorityHigh );
+ SetCallIdL( KVtUiDefaultCallId );
+
+ iExitTimer = CPeriodic::NewL( CActive::EPriorityHigh );
+ CheckEngineFunctionality();
+
+ iAsyncCallback =
+ new ( ELeave ) CAsyncCallBack (
+ TCallBack( &AsyncViewFinderToMainPaneAndShare, this ),
+ CActive::EPriorityStandard );
+
+ iLayoutChangeCallback =
+ new ( ELeave ) CAsyncCallBack(
+ TCallBack( &DelayedHandleLayoutChanged, this ),
+ CActive::EPriorityStandard );
+
+ iCurrentCameraOrientation = MVtEngMedia::EOrientationObeyLayoutSwitch;
+
+ GetCameraOrientations();
+
+ SetInitialCameraOrientationL();
+
+ iVolCtrl= new ( ELeave )CVtUiVolumeControl(
+ Model().CommandHandler(),
+ Model().Audio(),
+ *iEventObserver,
+ *iFeatureManager);
+ iVolCtrl->ConstructL();
+
+ iIncallBubble = CAknIncallBubble::NewL();
+
+ iIsWaitingCallState = EFalse;
+
+ __VTPRINTEXIT( "VtUi.ConstructL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::~CVtUiAppUi
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::~CVtUiAppUi()
+ {
+ __VTPRINTENTER( "VtUi.~" )
+
+ iActiveCommands.Close();
+
+ delete iLayoutChangeCallback;
+ delete iAsyncCallback;
+
+ if ( iUiStates && iUiStates->IsBlankControlAdded() )
+ {
+ RemoveFromStack( iBlankControl );
+ }
+ TInt lightsValue = 0;
+ if ( RProperty::Get( KPSUidCoreApplicationUIs,
+ KLightsVTForcedLightsOn, lightsValue ) == KErrNone )
+ {
+ if ( lightsValue == EForcedLightsOn )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.~ Good night!" )
+ (void) RProperty::Set(
+ KPSUidCoreApplicationUIs,
+ KLightsVTForcedLightsOn,
+ EForcedLightsOff );
+ }
+ }
+ delete iActiveExec;
+ delete iInstance;
+ delete iBlankControl;
+ // Delete volume control before its dependencies are deleted.
+ delete iVolCtrl;
+ delete iEventObserver;
+ delete iExitTimer;
+ // Featuremanager must be destructed
+ // before componentmanager and commandmanager
+ delete iFeatureManager;
+ delete iComponentManager;
+ delete iCommandManager;
+ delete iUiStates;
+
+ if ( iTbPeriodic )
+ {
+ iTbPeriodic->Cancel();
+ }
+ delete iTbPeriodic;
+
+ if ( iIncallBubble )
+ {
+ TRAP_IGNORE( iIncallBubble->SetIncallBubbleAllowedInUsualL( ETrue ) )
+ }
+ delete iIncallBubble;
+
+ // Close all RComm sessions to prevent memory leaks.
+ REComSession::FinalClose();
+
+ FeatureManager::UnInitializeLib();
+ __VTPRINTEXIT( "VtUi.~" )
+ VTLOGUNINIT
+ }
+
+// -----------------------------------------------------------
+// CVtUiAppUi::SwitchLayoutToFlatStatusPaneL
+// -----------------------------------------------------------
+//
+void CVtUiAppUi::SwitchLayoutToFlatStatusPaneL( TBool aSwitch )
+ {
+ __VTPRINTENTER( "VtUi.SwitchLayoutToFlatStatusPaneL" )
+ CEikStatusPane* statusPane = StatusPane();
+
+ const TInt idleResId(
+ VtUiLayout::IsLandscapeOrientation() ?
+ R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL :
+ R_AVKON_STATUS_PANE_LAYOUT_USUAL );
+
+ const TBool isStatusPaneFlat(
+ ( statusPane->CurrentLayoutResId() ==
+ R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT ) ||
+ ( statusPane->CurrentLayoutResId() ==
+ R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT ) );
+
+ if ( aSwitch )
+ {
+ if ( isStatusPaneFlat && VtUiLayout::IsLandscapeOrientation() )
+ {
+ __VTPRINT( DEBUG_GEN,
+ "VtUi.SwitchLayoutToFlatStatusPaneL LAYOUT USUAL" );
+ NaviPaneL()->Pop();
+ statusPane->SwitchLayoutL( idleResId );
+ }
+ else if ( !isStatusPaneFlat && !VtUiLayout::IsLandscapeOrientation() )
+ {
+ __VTPRINT( DEBUG_GEN,
+ "VtUi.SwitchLayoutToFlatStatusPaneL USUAL FLAT" );
+ NaviPaneL()->PushDefaultL();
+ statusPane->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT );
+ }
+ }
+ else
+ {
+ if ( isStatusPaneFlat )
+ {
+ __VTPRINT( DEBUG_GEN,
+ "VtUi.SwitchLayoutToFlatStatusPaneL LAYOUT IDLE" );
+ NaviPaneL()->Pop();
+ statusPane->SwitchLayoutL( idleResId );
+ }
+ }
+ // ApplyCurrentSettingsL is called whenever statuspane
+ // visibility status or pane layout changes.
+ statusPane->ApplyCurrentSettingsL();
+ statusPane->DrawNow();
+ // Make sure whole control is fully updated
+ iInstance->iMainControl->DrawNow();
+ __VTPRINTEXIT( "VtUi.SwitchLayoutToFlatStatusPaneL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshL()
+ {
+ __VTPRINTENTER( "VtUi.Refresh" )
+ RefreshBlind();
+ RefreshNaviPaneL();
+ __VTPRINTEXIT( "VtUi.Refresh" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshNaviPaneL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshNaviPaneL()
+ {
+ // Update only if navi pane exists
+ if ( iInstance )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.RefreshNavi" )
+ CVtUiNaviPane* navi = iInstance->iNaviPane;
+
+ // Refresh muted state
+ MVtEngMedia& media = Model().Media();
+ TInt mediaAvail;
+ VtUiUtility::GetOutgoingMediaState( media, mediaAvail );
+ mediaAvail = ~mediaAvail;
+ navi->SetMuted( mediaAvail & MVtEngMedia::EMediaAudio );
+
+ // Refresh call duration
+ MVtEngSessionInfo& session = Model().Session();
+ MVtEngSessionInfo::TDuration duration;
+ TBool enabled;
+ if ( session.GetDuration( duration, enabled ) != KErrNone )
+ {
+ enabled = EFalse;
+ }
+ navi->SetCallDuration( duration, enabled );
+
+ // Update all changes
+ navi->CommitL();
+
+ CheckBeatL( enabled );
+ }
+ }
+
+void CVtUiAppUi::StopBrightnessOrContrast()
+ {
+
+ MVtUiFeature* br = iFeatureManager->GetFeatureById( EVtUiFeatureIdBrightness );
+ if ( br )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.StopBrightness" )
+ if ( br->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.StopBrightnessOrContrast br->STOP" )
+ br->Stop();
+ }
+ }
+
+ MVtUiFeature* cr = iFeatureManager->GetFeatureById( EVtUiFeatureIdContrast );
+ if ( cr )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.StopContrast" )
+ if ( cr->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.StopBrightnessOrContrast cr->STOP" )
+ cr->Stop();
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshZoomPopupL()
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshZoomPopupL()
+ {
+ CVtUiZoom* zm = static_cast< CVtUiZoom* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdZoom ) );
+ if( zm && iUiStates->IsZoomModeOn())
+ zm->RefreshL();
+ }
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshMenuL()
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshMenuL()
+ {
+
+ CVtUiMenus* menus = static_cast< CVtUiMenus* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdMenu ) );
+ if ( menus )
+ {
+ iUiStates->Update();
+ __VTPRINT( DEBUG_GEN, "VtUi.RefreshMenuL" )
+ menus->RefreshL();
+ CAknAppUi::ProcessCommandL( EEikCmdCanceled ); // does not leave
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshSoftkeysL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshSoftkeysL()
+ {
+ if ( iUiStates->IsThisApplicationForeground() )
+ {
+ CVtUiSoftkeys* sk = static_cast< CVtUiSoftkeys* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdSoftkey ) );
+ if ( sk )
+ {
+ sk->RefreshL();
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshBlind
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshBlind()
+ {
+ if ( iInstance && !iUiStates->IsDisableBlindSetting() )
+ {
+ __VTPRINTENTER( "VtUi.RefreshBlind" )
+ TInt avail;
+ MVtEngMedia& media = Model().Media();
+
+ // Update blind flags.for outgoing media:
+ VtUiUtility::GetOutgoingMediaState( media, avail );
+ avail = ~avail;
+ TBool noVideo( avail & MVtEngMedia::EMediaVideo );
+ const TBool isFrozen( VtUiUtility::GetFreezeState ( media ) );
+ MVtEngMedia::TMediaSource source( MVtEngMedia::EMediaNone );
+ media.GetSource( source );
+ if ( noVideo && !isFrozen &&
+ ( source != MVtEngMedia::EMediaStillImage ) )
+ {
+ iUplinkWindow->SetStreamBitmap( NULL );
+ }
+
+ iUplinkWindow->SetBlind( noVideo );
+ iUplinkWindow->SetWaiting( EFalse );
+
+ if ( iUiStates->IsThisApplicationForeground() )
+ {
+ // Update blind flags for incoming media:
+ VtUiUtility::GetIncomingMediaState( media, avail );
+ avail = ~avail;
+ noVideo = ( avail & MVtEngMedia::EMediaVideo );
+ if ( noVideo )
+ {
+ iDownlinkWindow->SetStreamBitmap( NULL );
+ }
+ iDownlinkWindow->SetBlind( noVideo );
+ }
+ iDownlinkWindow->SetWaiting( iUiStates->IsWaitingForFirstFrame() );
+ __VTPRINTEXIT( "VtUi.RefreshBlind" )
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::OpenNumberEntryL
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::OpenNumberEntryL()
+ {
+ __VTPRINTENTER( "VtUi.OpenNumberEntryL" )
+
+ CEikMenuBar* menuBar = iEikonEnv->AppUiFactory()->MenuBar();
+ if ( IsDisplayingDialog() || ( menuBar && menuBar->IsDisplayed() ) )
+ {
+ __VTPRINTEXIT( "VtUi.OpenNumberEntryL" )
+ return EFalse;
+ }
+
+ TInt error( KErrNotFound );
+
+ MVtUiFeature* numberEntry =
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdNumberEntry );
+
+ MVtUiFeature* dialer =
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdDialer );
+
+ const TBool dialerActive( dialer &&
+ ( dialer->State() == MVtUiFeature::EActive ) );
+
+ if ( numberEntry && !dialerActive )
+ {
+ TRAP( error, numberEntry->StartL() );
+ }
+
+ const TBool result( !error );
+
+ if ( result )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.NumberEntry.StopZ" )
+ RefreshSoftkeysL();
+ }
+
+ __VTPRINTEXITR( "VtUi.OpenNumberEntryL %d", result )
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandlePhoneSendKeyL
+// Handles EKeyPhoneSend key events.
+// -----------------------------------------------------------------------------
+//
+TKeyResponse CVtUiAppUi::HandlePhoneSendKeyL( const TKeyEvent& /*aKeyEvent*/,
+ TEventCode aType )
+ {
+ __VTPRINTENTER( "VtUi.HandlePhoneSendKeyL" )
+ CEikMenuBar* menuBar = iEikonEnv->AppUiFactory()->MenuBar();
+ if ( !( IsDisplayingDialog() || ( menuBar && menuBar->IsDisplayed() ) ) )
+ {
+ const TBool isNumberSource( iUiStates->IsNumberEntryOpen() ||
+ iUiStates->IsDialerOpen() );
+ if ( ( aType == EEventKey ) && isNumberSource )
+ {
+ ProcessCommandL( EVtUiCmdDialEmergency );
+ }
+ }
+ __VTPRINTEXIT( "VtUi.HandlePhoneSendKeyL" )
+ return EKeyWasConsumed;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::StartDtmfTone
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::StartDtmfTone( const TChar& aTone )
+ {
+ // should be called only through current application state
+ iDtmfTone = aTone;
+ __VTPRINT2( DEBUG_GEN, "VtUi.DTMF.Start.%d", iDtmfTone() )
+ if ( Execute( KVtEngStartDtmfTone, &iDtmfTone ) != KErrNone )
+ {
+ iDtmfTone = 0;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::StopDtmfTone
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::StopDtmfTone()
+ {
+ // should be called only through current application state
+ if ( iDtmfTone() )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.DTMF.STOP" )
+ (void) Execute( KVtEngStopDtmfTone, NULL );
+ iDtmfTone = 0;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleWsEventL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleWsEventL(
+ const TWsEvent& aEvent,
+ CCoeControl* aDestination )
+ {
+ __VTPRINTENTER( "VtUi.HandleWsEventL" )
+ const TInt type = aEvent.Type();
+ __VTPRINT2( DEBUG_GEN, "VtUi.HandleWsEventL type = %d", type );
+
+ // Zoom-in and Zoom-out keys need specific handling because keyup and
+ // keydown events cannot be checked from iCode field of TKeyEvent
+ if ( PreHandleKeyEventL( aEvent ) )
+ {
+ __VTPRINTEXIT( "VtUi.HandleWsEventL (PreHandleKeyEventL)" )
+ return;
+ }
+
+ // Zoom mode is dismissed if some interrupting event happens prior timeout.
+ // Zoom mode can be interrupted with a keypress i.e. any keypress, except
+ // keys that are reserved for adjusting zoom dismiss zoom mode. Also any
+ // system event e.g. note or waiting call dismiss zoom mode.
+ if ( iUiStates->IsZoomModeOn() )
+ {
+ if ( ProcessWsEventIfZoomModeIsActiveL( aEvent ) )
+ {
+ __VTPRINTEXIT( "VtUi.HandleWsEventL (IsZoomModeOn)" )
+ return;
+ }
+ }
+ // Zoom mode can be also activated with up and down arrow keys.
+ switch ( type )
+ {
+ case EEventKey:
+ case EEventKeyUp:
+ case EEventKeyDown:
+ {
+ const TKeyEvent* keyEvent = aEvent.Key();
+ const TBool isHwZoomKey(
+ keyEvent->iCode == EKeyZoomIn ||
+ keyEvent->iCode == EKeyZoomOut );
+ const TBool isZoomKey(
+ keyEvent->iScanCode == EStdKeyUpArrow ||
+ keyEvent->iScanCode == EStdKeyDownArrow ||
+ isHwZoomKey );
+
+ // Zoom mode can be also activated with up and down arrow keys.
+ if ( isZoomKey )
+ {
+ const TBool isZoomAllowed(
+ !iEikonEnv->AppUiFactory()->MenuBar()->IsDisplayed() &&
+ !iUiStates->MediaState().IsSharing() &&
+ !iUiStates->MediaState().IsFrozen() &&
+ !iUiStates->IsSelectingShare() &&
+ VtUiUtility::IsZoomAllowed( Model().Media() ) &&
+ !( iUiStates->IsNumberEntryOpen() && ShowNumberEntry() ) &&
+ //there must not be the command which may switch provider to None
+ !IsActiveCommand( EVtUiCmdDisableVideo )&&
+ !IsActiveCommand( EVtUiCmdDisableBoth )&&
+ !IsActiveCommand( EVtUiCmdUsePrimaryCamera )&&
+ !IsActiveCommand( EVtUiCmdUseSecondaryCamera) );
+
+ if ( isZoomAllowed )
+ {
+ // If menu is open, toolbar is available, video is frozen,
+ // sharing is on or user is selecting a file to be shared
+ // do not set zoom mode on. If HW zoom key was pressed,
+ // then zoom mode is activated even if toolbar is present.
+ if ( isHwZoomKey || !iUiStates->IsToolbarAvailable() )
+ {
+ SetZoomModeL( ETrue );
+ }
+ }
+ }
+ }
+ break;
+ default:
+ break;
+ }
+
+ TBool partialForeGroundlost( EFalse );
+ switch ( type )
+ {
+ // Enter new rendering mode
+ case EVtUiWsEventBeginRenderingMode:
+ {
+ const TVtUiWsEvent< TRenderingMode >& event(
+ static_cast< const TVtUiWsEvent< TRenderingMode >& >
+ ( aEvent ) );
+ MVtUiDialer* dialer = static_cast< CVtUiDialer* > (
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdDialer ) );
+ __ASSERT_ALWAYS( dialer,
+ VtUiPanic::Panic( EVtUiPanicRendererNotFound ) );
+ iInstance->iContextControl->MakeVisible( EFalse );
+ SetRenderingModeL( *event.Data(), &dialer->VideoWindow() );
+ }
+ break;
+
+ // End rendering mode -> revert to previous
+ case EVtUiWsEventEndRenderingMode:
+ {
+ SetRenderingModeL( ERenderingModeDefault, iStoredDownlinkWindow );
+ iInstance->iContextControl->MakeVisible( ETrue );
+ iStoredDownlinkWindow = NULL;
+ }
+ break;
+
+ // New number source have been activated
+ case EVtUiWsEventNumberSourceActivate:
+ {
+ const TVtUiWsEvent< MVtUiNumberSource >& event(
+ static_cast< const TVtUiWsEvent< MVtUiNumberSource >& >
+ ( aEvent ) );
+ iNumberSource = event.Data();
+ }
+ break;
+
+ case EVtUiWsEventNumberSourceDeactivate:
+ {
+ const TVtUiWsEvent< MVtUiNumberSource >& event(
+ static_cast< const TVtUiWsEvent< MVtUiNumberSource >& >
+ ( aEvent ) );
+ if ( iNumberSource == event.Data() )
+ {
+ iNumberSource = NULL;
+ }
+ }
+ break;
+
+
+ // VT goes background e.g. selected application from fastswap
+ case KAknFullOrPartialForegroundLost:
+ {
+ // If capture mode is on stop it
+ if ( iUiStates->IsCaptureModeOn() )
+ {
+ CmdCancelCaptureL();
+ }
+ SetIncallBubbleAllowedInUsualL( ETrue );
+ const TInt windowGroupId =
+ iCoeEnv->WsSession().GetFocusWindowGroup();
+
+ // In S60 5.0 we get PartialFocusLost also for some notes and
+ // overally items that are somehow overlapping screen instead of
+ // FocusLost. In those cases we should not put app to background.
+ if( ( windowGroupId != iThisApplicationWgId ) &&
+ ( windowGroupId != iEikonServerWgId ) &&
+ ( windowGroupId != iAknCapServerWgId ) &&
+ ( windowGroupId != iAknNfyServerWgId ) )
+ {
+ partialForeGroundlost = ETrue;
+ }
+
+ // Fall through to EEventFocusLost event
+ }
+ case EEventFocusLost:
+ {
+ // If focus window group is not this application nor window server,
+ // then this application can not be in focus.
+ const TInt windowGroupId =
+ iCoeEnv->WsSession().GetFocusWindowGroup();
+
+ if ( ( windowGroupId != iThisApplicationWgId ) &&
+ ( windowGroupId != iEikonServerWgId ) &&
+ ( windowGroupId != iAknCapServerWgId ) &&
+ ( windowGroupId != iAknNfyServerWgId ) || partialForeGroundlost )
+ {
+ iCoeEnv->RootWin().DisableFocusChangeEvents();
+
+ TBool old = iUiStates->IsThisApplicationForeground();
+ if ( old )
+ {
+ TRAP_IGNORE( HandleForegroundChangedL( EFalse ) );
+ }
+ }
+ }
+ break;
+
+ case KAknFullOrPartialForegroundGained:
+ {
+ SetIncallBubbleAllowedInUsualL( EFalse );
+ // Now this application is focused.
+ (void)iCoeEnv->RootWin().EnableFocusChangeEvents();
+ TBool old = iUiStates->IsThisApplicationForeground();
+
+ if ( !old )
+ {
+ (void) HandleLayoutChanged();
+ TRAP_IGNORE( HandleForegroundChangedL( ETrue ) );
+ }
+ }
+ break;
+
+ case EEventKey:
+ case EEventKeyUp:
+ case EEventKeyDown:
+ {
+ // Key events with EModifierSpecial are received via FEP.
+ const TKeyEvent* keyEvent = aEvent.Key();
+ if ( keyEvent->iModifiers & EModifierSpecial )
+ {
+ TChar dtmfTone;
+ if ( VtUiUtility::IsDTMFEvent( *keyEvent, dtmfTone ) )
+ {
+ if ( type == EEventKey )
+ {
+ StartDtmfTone( dtmfTone );
+ }
+ else if ( type == EEventKeyUp )
+ {
+ StopDtmfTone();
+ }
+ }
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+ // Offer event to component manager
+ iComponentManager->HandleWsEventL( aEvent, aDestination );
+
+ // All events are sent to base class.
+ CAknAppUi::HandleWsEventL( aEvent, aDestination );
+ __VTPRINTEXIT( "VtUi.HandleWsEventL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::PreHandleKeyEventL
+//
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::PreHandleKeyEventL( const TWsEvent& aEvent )
+ {
+ __VTPRINTENTER( "VtUi.PreHandleKeyEventL" )
+ TBool consumed( EFalse );
+ switch( aEvent.Type() )
+ {
+
+ case EEventKey:
+ {
+ // when both these are set, then it's our simulated key press
+ const TInt
+ modifiers( EModifierKeypad | EModifierSpecial );
+
+ const TKeyEvent* ptrKeyEventC =
+ aEvent.Key();
+
+ const TBool isHwZoomKey(
+ ptrKeyEventC->iCode == EKeyZoomIn ||
+ ptrKeyEventC->iCode == EKeyZoomOut );
+
+ if ( isHwZoomKey &&
+ ( ptrKeyEventC->iModifiers & modifiers ) != modifiers )
+ {
+ __VTPRINT3( DEBUG_GEN, "VtUi.PreHandleKeyEventL keyc=%d scanc=%d",
+ ptrKeyEventC->iCode, ptrKeyEventC->iScanCode )
+ consumed = ETrue;
+
+ // Send EEventKeyDown only when iRepeats is 0
+ if ( !ptrKeyEventC->iRepeats )
+ {
+ TKeyEvent keyDownEvent( *ptrKeyEventC );
+ keyDownEvent.iRepeats = 0;
+ iCoeEnv->SimulateKeyEventL( keyDownEvent, EEventKeyDown );
+ }
+
+ // Send EEventKey always
+ TKeyEvent keyEvent( *ptrKeyEventC );
+ keyEvent.iModifiers |= modifiers;
+ iCoeEnv->SimulateKeyEventL( keyEvent, EEventKey );
+
+ // Que EEventKeyUp
+ TKeyEvent keyUpEvent( *ptrKeyEventC );
+ keyUpEvent.iRepeats = 0;
+ StoreKeyEventL( keyUpEvent );
+ }
+ else if ( ( ptrKeyEventC->iModifiers & modifiers ) == modifiers )
+ {
+ __VTPRINT( DEBUG_GEN,
+ "VtUi.PreHandleKeyEventL own event spotted, removing mods" )
+ // event is generated by us, remove modifiers
+ TKeyEvent* ptrKeyEvent = const_cast< TKeyEvent* >( ptrKeyEventC );
+ ptrKeyEvent->iModifiers &= ~modifiers;
+ }
+ }
+ break;
+
+ case EEventKeyUp:
+ if ( iIsStoredKeyEvent )
+ {
+ if ( iStoredKeyEvent.iScanCode == aEvent.Key()->iScanCode )
+ {
+ consumed = ETrue;
+ SimulateStoredKeyEventL( EEventKeyUp );
+ }
+ }
+ break;
+
+ default:
+ break;
+
+ }
+
+ __VTPRINTEXITR( "VtUi.PreHandleKeyEventL %d", consumed )
+ return consumed;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SimulateStoredKeyEventL
+//
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SimulateStoredKeyEventL( const TEventCode aEventCode )
+ {
+ __VTPRINTENTER( "VtUi.SimulateStoredKeyEventL" )
+ if ( iIsStoredKeyEvent )
+ {
+ // Reset flag first because SimulateKeyEventL() is synchronous
+ iIsStoredKeyEvent = EFalse;
+ iCoeEnv->SimulateKeyEventL( iStoredKeyEvent, aEventCode );
+ }
+ __VTPRINTEXITR( "VtUi.SimulateStoredKeyEventL %d", iIsStoredKeyEvent )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::StoreKeyEventL
+//
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::StoreKeyEventL( const TKeyEvent& aKeyEvent )
+ {
+ __VTPRINTENTER( "VtUi.StoreKeyEventL" )
+ if ( iIsStoredKeyEvent && ( iStoredKeyEvent.iCode != aKeyEvent.iCode ) )
+ {
+ SimulateStoredKeyEventL( EEventKeyUp );
+ }
+
+ if ( !iIsStoredKeyEvent )
+ {
+ iIsStoredKeyEvent = ETrue;
+ iStoredKeyEvent = aKeyEvent;
+ }
+ __VTPRINTEXITR( "VtUi.StoreKeyEventL %d", iIsStoredKeyEvent )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoTryToStartTb
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::DoTryToStartTbL( TAny* aAny )
+ {
+ CVtUiAppUi* self = static_cast< CVtUiAppUi* >( aAny );
+ self->TryToStartTbL();
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::UpdateVBSettingL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::UpdateVBSettingL()
+ {
+ // If white balance or color tone setting
+ // feauture exists update setting
+ CVtUiWhiteBalance* wb = static_cast< CVtUiWhiteBalance* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdWhiteBalance ) );
+
+ CVtUiColorTone* ct = static_cast< CVtUiColorTone* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdColourTone ) );
+
+ // If brightness or contrast slider
+ // feauture exists update them
+ CVtUiBrightness* br = static_cast< CVtUiBrightness* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdBrightness ) );
+
+ CVtUiContrast* contr = static_cast< CVtUiContrast* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdContrast ) );
+
+
+
+ if ( wb && iUiStates->IsWhiteBalanceSettingAvailable() )
+ {
+ __VTPRINT( DEBUG_GEN,"VtUi.UpdateVBSettingL WB update" )
+ wb->UpdateSettingL();
+ }
+
+ if ( ct && iUiStates->IsColorToneSettingAvailable() )
+ {
+ __VTPRINT( DEBUG_GEN,"VtUi.UpdateVBSettingL CT update" )
+ ct->UpdateSettingL();
+ }
+
+ if ( br && iUiStates->IsBrightnessSettingAvailable() )
+ {
+ __VTPRINT( DEBUG_GEN,"VtUi.UpdateVBSettingL br update" )
+ br->UpdateSlider();
+ }
+
+ if ( contr && iUiStates->IsContrastSettingAvailable() )
+ {
+ __VTPRINT( DEBUG_GEN,"VtUi.UpdateVBSettingL contract update" )
+ contr->UpdateSlider();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::TryToStartTb
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::TryToStartTbL()
+ {
+ __VTPRINTENTER( "VtUi.TryToStartTbL" )
+ CVtUiToolbarBase* tb = static_cast< CVtUiToolbarBase* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdToolbar ) );
+ if ( tb )
+ {
+ // If menu, dialog or dialer is displayed do not start the toolbar,
+ // but let the timer run another round
+ CEikMenuBar* menuBar = iEikonEnv->AppUiFactory()->MenuBar();
+ if ( !( menuBar && menuBar->IsDisplayed() ) &&
+ !IsDisplayingDialog() &&
+ !(
+ iUiStates->IsDialerActivating() ||
+ iUiStates->IsDialerOpen() ||
+ iUiStates->IsWhiteBalanceModeOn() ||
+ iUiStates->IsColorToneModeOn() ||
+ iUiStates->IsBrightnessModeOn() ||
+ iUiStates->IsContrastModeOn() ||
+ iUiStates->IsZoomModeOn() ||
+ iUiStates->IsVolumeModeOn() ||
+ iUiStates->IsCaptureModeOn() )
+ )
+ {
+ if ( iTbPeriodic )
+ {
+ iTbPeriodic->Cancel();
+ }
+ tb->StartL();
+ }
+ }
+ __VTPRINTEXIT( "VtUi.TryToStartTbL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetRenderingModeL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetRenderingModeL( const TRenderingMode aMode,
+ MVtUiVideoWindow* aNewDownlink )
+ {
+ __VTPRINTENTER( "VtUi.SetRenderingModeL" )
+ __VTPRINT2( DEBUG_GEN, "VtUi.SetRenderingModeL=%d", aMode );
+ iRenderingMode = aMode;
+ if ( aNewDownlink )
+ {
+ if ( iDownlinkWindow != aNewDownlink )
+ {
+ iStoredDownlinkWindow = iDownlinkWindow;
+ iDownlinkWindow = aNewDownlink;
+ iStoredDownlinkWindow->SetRemoteVideoControl(NULL);
+ iDownlinkWindow->SetRemoteVideoControl(iInstance->iRemoteVideoControl);
+ iDownlinkWindow->LayoutRemoteVideo();
+ }
+ }
+ RefreshBlind();
+ UpdateRenderingParametersL();
+ __VTPRINTEXIT( "VtUi.SetRenderingModeL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::UpdateRenderingParametersL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::UpdateRenderingParametersL()
+ {
+ __VTPRINTENTER( "VtUi.UpdateRenderingParametersL" )
+
+ MVtEngMedia& media = Model().Media();
+ const TBool viewFinderStarted =
+ media.RenderingStarted( MVtEngMedia::EMediaOutgoing );
+ const TBool remoteRenderStarted =
+ media.RenderingStarted( MVtEngMedia::EMediaIncoming );
+
+ // Clear bitmaps
+ iInstance->iContextControl->SetStreamBitmap( NULL );
+ iInstance->iMainControl->SetStreamBitmap( NULL );
+
+ // Stop viewfinder & remote render.
+ if( viewFinderStarted )
+ {
+ ExecuteCmdL( KVtEngStopViewFinder );
+ }
+ ExecuteCmdL( KVtEngStopRenderRemote );
+
+ const TBool uplinkWindowEqualsContextControl =
+ ( iUplinkWindow == iInstance->iContextControl );
+
+ // Prepare viewfinder.
+ TVtEngRenderingOptions configViewfinder(
+ uplinkWindowEqualsContextControl ?
+ DetermineContextControlOptions() :
+ DetermineMainControlOptions( EFalse ) );
+ ExecuteCmdL( KVtEngPrepareViewFinder, configViewfinder );
+
+ // Prepare remote render.
+ TRAPD ( err, {
+ TVtEngRenderingOptionsNGA configRemoteRenderNGA(
+ DetermineRemoteVideoControlOptionsNGA() );
+ ExecuteCmdL(
+ KVtEngPrepareRemoteRenderNGA,
+ configRemoteRenderNGA );
+ } );
+ if ( err != KErrNone )
+ {
+ if ( viewFinderStarted )
+ {
+ // Start viewfinder.
+ ExecuteCmdL( KVtEngStartViewFinder );
+ }
+ User::Leave ( err );
+ }
+
+ // Start remote render.
+ TRAP_IGNORE( ExecuteCmdL( KVtEngStartRenderRemote ) );
+
+ if ( viewFinderStarted )
+ {
+ // Start viewfinder.
+ ExecuteCmdL( KVtEngStartViewFinder );
+ }
+
+ // Redraw remote video last frame to make sure that in layout change
+ // situation we still have something on screen.
+ iDownlinkWindow->Redraw();
+ __VTPRINTEXIT( "VtUi.UpdateRenderingParametersL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::MediaStateChangedL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::MediaStateChangedL()
+ {
+ CEikMenuBar* menuBar = iEikonEnv->AppUiFactory()->MenuBar();
+ // close menu if it is shown
+ if ( menuBar && menuBar->IsDisplayed() )
+ {
+ TKeyEvent keyEvent;
+ keyEvent.iCode = EKeyEscape;
+ menuBar->OfferKeyEventL( keyEvent, EEventKey );
+ }
+ // Refresh toolbar
+ CVtUiToolbarBase* tb = static_cast< CVtUiToolbarBase* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdToolbar ) );
+ if ( tb )
+ {
+ tb->RefreshL();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ProcessCommandL
+// Processes commands.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ProcessCommandL(
+ TInt aCommand )
+ {
+ __VTPRINTENTER( "VtUi.ProcessCommandL" )
+ MVtEngCommandHandler& command = Model().CommandHandler();
+ command.ExecuteL( KVtEngRequestLastRemoteFrame, NULL );
+
+ // only with fixed toolbar
+ if ( AknLayoutUtils::PenEnabled() )
+ {
+ if ( iUiStates->IsFixedToolbarVisible())
+ {
+ // When option menu is opened fixed toolbar should
+ // be set hidden
+ iUiStates->SetIsFixedToolbarVisible( EFalse );
+ // Stop toolbar
+ MVtUiFeature* tb =
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdToolbar );
+ if ( tb )
+ {
+ // timer could be active
+ if ( iTbPeriodic )
+ {
+ iTbPeriodic->Cancel();
+ }
+ tb->Stop();
+ }
+ if ( !iTbPeriodic )
+ {
+ iTbPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );
+ }
+ // Toolbar doesn't come visible until options menu is closed.
+ iTbPeriodic->Start( KStartTime, KPeriodTime, TCallBack( DoTryToStartTbL, this ) );
+ }
+ }
+ else
+ {
+ StopSliders();
+ }
+
+ iInstance->iMainControl->SetSize( iInstance->iMainControl->Size() );
+ iInstance->iMainControl->DrawNow();
+
+ // Handle OK options menu.
+ const TInt menuResource =
+ iUiStates->IsLaunchOkOptionsMenu() ?
+ R_VIDEOTELUI_OK_MENUBAR :
+ R_VIDEOTELUI_MENUBAR;
+
+ iUiStates->SetLaunchOkOptionsMenu( EFalse );
+
+ CEikMenuBar* menu = iEikonEnv->AppUiFactory()->MenuBar();
+ if ( menu )
+ {
+ menu->SetMenuTitleResourceId( menuResource );
+ //Here we again set back the type of menu to "Options" when pressed LSK
+ menu->SetMenuType( CEikMenuBar::EMenuOptions );
+ }
+ CAknAppUi::ProcessCommandL( aCommand );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::IsActiveCommand
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::IsActiveCommand( TInt aCommand ) const
+ {
+ return ( iActiveCommands.FindInOrder( aCommand ) != KErrNotFound );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::State
+// -----------------------------------------------------------------------------
+//
+TVtUiAppStateBase& CVtUiAppUi::State()
+ {
+ return *iState;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::BitmapManager
+// -----------------------------------------------------------------------------
+//
+CVtUiBitmapManager& CVtUiAppUi::BitmapManager()
+ {
+ return *iInstance->iBitmapManager;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::TActiveCommand::TActiveCommand
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::TActiveCommand::TActiveCommand( RArray< TInt >& aActiveCommands,
+ TInt aCommandId )
+ : iActiveCommands( aActiveCommands ), iCommandId( aCommandId )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::TActiveCommand::~TActiveCommand
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::TActiveCommand::~TActiveCommand()
+ {
+ Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::TActiveCommand::OpenL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::TActiveCommand::OpenL()
+ {
+ iActiveCommands.InsertInOrderL( iCommandId );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::TActiveCommand::Close
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::TActiveCommand::Close()
+ {
+ TInt index( iActiveCommands.FindInOrder( iCommandId ) );
+ if ( index != KErrNotFound )
+ {
+ iActiveCommands.Remove( index );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleCommandL
+// Handles commands.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleCommandL(
+ TInt aCommand )
+ {
+ __VTPRINTENTER( "VtUi.HandleCommand" )
+
+ // Check if same command is already being performed.
+ if ( IsActiveCommand( aCommand ) || ( iState &&
+ iState->HandleCommandL( aCommand ) ==
+ TVtUiAppStateBase::EEventHandled ) )
+ {
+ __VTPRINTEXIT( "VtUi.HandleCommand <silently ignoring> 0" )
+ return;
+ }
+
+ // Check if command is allowed to be performed.
+ if ( !IsCommandAllowedL( aCommand ) )
+ {
+ ShowNotAllowedNoteL();
+ __VTPRINTEXITR( "VtUi.HandleCommand %d", KErrAccessDenied )
+ return;
+ }
+
+ // delay mute cmd received during layout change (EGWG-7QQ3GZ)
+ if ( (aCommand == EVtUiCmdDisableAudio) || (aCommand == EVtUiCmdUsePrimaryCamera)
+ ||(aCommand == EVtUiCmdUseSecondaryCamera)
+ ||(aCommand == EVtUiCmdDisableVideo) )
+ {
+ if ( iLayoutChg )
+ {
+ iDelayedCmd = aCommand;
+ __VTPRINTEXIT( "VtUi.HandleCommand mute delayed due to LayoutChange" )
+ return;
+ }
+ }
+
+ TActiveCommand activeCommand( iActiveCommands, aCommand );
+ // Close() will be called by the destructor, when instance goes out of
+ // scope
+ activeCommand.OpenL();
+
+ TBool refresh = EFalse;
+ CleanupPushRefreshL();
+
+ // Execute command
+ switch ( aCommand )
+ {
+ case EAknCmdHelp:
+ CmdHelpL();
+ break;
+
+ case EVtUiCmdOkOptions:
+ iUiStates->SetLaunchOkOptionsMenu( ETrue );
+ ProcessCommandL( EAknSoftkeyOptions );
+ break;
+
+ case EVtUiCmdEnableMain:
+ case EVtUiCmdDisableMain:
+ // Submenu is opened automatically.
+ break;
+
+ case EVtUiCmdEnableVideo:
+ {
+ MVtEngMedia::TShareObjectState shareObjectState;
+ VtUiUtility::GetObjectSharingState( Model().Media(),
+ shareObjectState );
+ if( shareObjectState != MVtEngMedia::ESharingImage )
+ {
+ refresh = ETrue;
+ EnableCommandActivatingAndCleanupPushL();
+ CmdEnableVideoL();
+ CleanupStack::PopAndDestroy();
+ }
+ else
+ {
+ CmdStopShareImageL( refresh );
+ EnableCommandActivatingAndCleanupPushL();
+ CmdEnableVideoL();
+ CleanupStack::PopAndDestroy();
+ }
+ }
+ break;
+
+ case EVtUiCmdEnableAudio:
+ refresh = ETrue;
+ CmdEnableAudioL();
+ break;
+
+ case EVtUiCmdEnableBoth:
+ EnableCommandActivatingAndCleanupPushL();
+ CmdEnableAudioL();
+ MVtEngMedia::TShareObjectState shareObjectState;
+ VtUiUtility::GetObjectSharingState( Model().Media(),
+ shareObjectState );
+ if( shareObjectState != MVtEngMedia::ESharingImage )
+ {
+ refresh = ETrue;
+ CmdEnableVideoL();
+ }
+ else
+ {
+ CmdStopShareImageL( refresh );
+ CmdEnableVideoL();
+ }
+ // EnableCommandActivatingAndCleanupPushL
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdDisableVideo:
+ refresh = ETrue;
+ EnableCommandActivatingAndCleanupPushL();
+ CmdDisableVideoL();
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdDisableAudio:
+ refresh = ETrue;
+ EnableCommandActivatingAndCleanupPushL();
+ CmdDisableAudioL();
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdDisableBoth:
+ HandleCommandL( EVtUiCmdDisableAudio );
+ HandleCommandL( EVtUiCmdDisableVideo );
+ break;
+
+ case EVtUiCmdActivateBT:
+ refresh = ETrue;
+ EnableCommandActivatingAndCleanupPushL();
+ CmdActivateBtL();
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdDeactivateBT:
+ refresh = ETrue;
+ EnableCommandActivatingAndCleanupPushL();
+ CmdDeactivateBtL();
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdActivateLoudspeaker:
+ case EVtUiCmdSwitchFromBTToIHF:
+ refresh = ETrue;
+ EnableCommandActivatingAndCleanupPushL();
+ CmdActivateLoudspeakerL();
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdDeactivateLoudspeaker:
+ refresh = ETrue;
+ EnableCommandActivatingAndCleanupPushL();
+ CmdDeactivateLoudspeakerL();
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdUsePrimaryCamera:
+ refresh = ETrue;
+ CmdUseCameraL( ETrue );
+ break;
+
+ case EVtUiCmdUseSecondaryCamera:
+ refresh = ETrue;
+ CmdUseCameraL( EFalse );
+ break;
+
+ case EVtUiCmdSwapImagesPlaces:
+ refresh = ETrue;
+ CleanupPushEnableBlindL();
+ iUiStates->SetDisableBlindSetting( ETrue );
+ CmdSwapImagesPlacesL();
+ CleanupStack::PopAndDestroy(); // CleanupPushEnableBlindL
+ break;
+
+ case EVtUiCmdZoom:
+ refresh = ETrue;
+ // Toolbar uses this same command to set zoom on and off
+ // therefore this works as a toggle button
+ SetZoomModeL( !iUiStates->IsZoomModeOn() );
+
+ break;
+
+ case EAknSoftkeyBack:
+ {
+ refresh = ETrue;
+ MVtUiFeature* numberEntry =
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdNumberEntry );
+ if ( numberEntry )
+ {
+ numberEntry->Stop();
+ }
+ }
+ break;
+
+ case EVtUiCmdSnapshot:
+ EnableCommandActivatingAndCleanupPushL();
+ CmdSnapshotL();
+ // EnableCommandActivatingAndCleanupPushL
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdCapture:
+ CmdCaptureL();
+ break;
+
+ case EVtUiCmdCancelCapture:
+ CmdCancelCaptureL();
+ break;
+
+ case EVtUiCmdGoToIdle:
+ CmdGoToIdleL();
+ break;
+
+ // Object sharing related
+
+ case EVtUiCmdShareObjectImage:
+ CmdInitializeShareImageL( refresh );
+ break;
+
+ case EVtUiCmdStopSharingObjectImage:
+ EnableCommandActivatingAndCleanupPushL();
+ CmdStopShareImageL( refresh );
+ // EnableCommandActivatingAndCleanupPushL
+ CleanupStack::PopAndDestroy();
+ break;
+
+ case EVtUiCmdAdjustVideoVideoQuality:
+ case EVtUiCmdAdjustVideoWhiteBalance:
+ case EVtUiCmdAdjustVideoBrightness:
+ case EVtUiCmdAdjustVideoContrast:
+ case EVtUiCmdAdjustVideoColourTone:
+ __VTPRINT( DEBUG_GEN, "VtUiHandleCommand.CmdAdjustVideoL" );
+ CmdAdjustVideoL( aCommand );
+ break;
+
+ case EAknSoftkeyExit:
+ case EAknCmdExit:
+ case EEikCmdExit:
+ // handled by state
+ break;
+
+ default:
+ iCommandManager->HandleCommandL( aCommand );
+ break;
+ }
+
+ if ( refresh )
+ {
+ CleanupStack::PopAndDestroy(); // CleanupPushRefreshL
+ }
+ else
+ {
+ CleanupStack::Pop(); // CleanupPushRefreshL
+ }
+ __VTPRINTEXITR( "VtUi.HandleCommand %d", KErrNone )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DynInitMenuPaneL
+// Initialises menu pane dynamically.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::DynInitMenuPaneL(
+ TInt,
+ CEikMenuPane* aMenuPane )
+ {
+ __VTPRINTENTER( "VtUi.DynInitMenuPaneL" )
+
+ CVtUiMenus* menus = static_cast< CVtUiMenus* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdMenu ) );
+ if ( menus )
+ {
+ iUiStates->Update();
+ menus->SetMenuPane( aMenuPane );
+ menus->RefreshL();
+ }
+ __VTPRINTEXIT( "VtUi.DynInitMenuPaneL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleKeyEventL
+// Handles key events.
+// -----------------------------------------------------------------------------
+//
+TKeyResponse CVtUiAppUi::HandleKeyEventL(
+ const TKeyEvent& aKeyEvent,
+ TEventCode aType )
+ {
+ __VTPRINTENTER( "VtUi.HandleKeyEventL" )
+
+ TKeyResponse resp( EKeyWasNotConsumed );
+
+ if ( !iUiStates->IsNumberEntryOpen() ||
+ ( iUiStates->IsNumberEntryOpen() && !ShowNumberEntry() ) )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.ToZoom" )
+
+ const TBool isHwZoomKey( aKeyEvent.iCode == EKeyZoomIn ||
+ aKeyEvent.iCode == EKeyZoomOut );
+
+ // if outgoing video is frozen disable zoom
+ MVtEngMedia& media = Model().Media();
+ if ( VtUiUtility::GetFreezeState ( media ) )
+ {
+ if ( aKeyEvent.iScanCode == EStdKeyUpArrow ||
+ aKeyEvent.iScanCode == EStdKeyDownArrow ||
+ isHwZoomKey )
+ {
+ __VTPRINTEXITR( "VtUi.HandleKeyEventL %d", EKeyWasConsumed )
+ return EKeyWasConsumed;
+ }
+ }
+
+ // Handle volume up & down
+
+ }
+
+ // If key event it not yet consumed, offer it to component manager
+ if ( resp == EKeyWasNotConsumed )
+ {
+ resp = iComponentManager->OfferKeyEventL( aKeyEvent, aType );
+ }
+
+ __VTPRINTEXITR( "VtUi.HandleKeyEventL %d", resp )
+ return resp;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleResourceChangeL
+// Handles change of a resource.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleResourceChangeL(
+ TInt aType )
+ {
+ __VTPRINTENTER( "VtUi.HandleResourceChangeL" )
+ const TBool layoutChange =
+ aType == KEikDynamicLayoutVariantSwitch ||
+ aType == KAknsMessageSkinChange;
+ if ( iInstance && layoutChange )
+ {
+ iInstance->iBitmapManager->InvalidateBitmaps();
+ }
+
+ CAknAppUi::HandleResourceChangeL( aType );
+
+ if ( iInstance )
+ {
+ if ( layoutChange )
+ {
+ CVtUiToolbarBase* tb = static_cast< CVtUiToolbarBase* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdToolbar ) );
+ if( tb )
+ {
+ tb->HandleLayoutChangeL();
+ }
+ // Relayout controls
+ iBlankControl->SetRect( ClientRect() );
+ iInstance->LayoutChanged();
+ }
+ if ( iInstance->iNaviPane )
+ {
+ iInstance->iNaviPane->HandleResourceChange( aType );
+ }
+ if ( layoutChange )
+ {
+ (void) HandleLayoutChanged();
+ }
+ }
+
+ iComponentManager->HandleResourceChangeL( aType );
+
+ __VTPRINTEXIT( "VtUi.HandleResourceChangeL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleForegroundEventL
+// Handles foreground status change.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleForegroundEventL( TBool aForeground )
+ {
+ CAknAppUi::HandleForegroundEventL( aForeground );
+
+ if ( !aForeground )
+ {
+ StopDtmfTone();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::GetEikonEnv
+// -----------------------------------------------------------------------------
+//
+CEikonEnv* CVtUiAppUi::GetEikonEnv()
+ {
+ return iEikonEnv;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::GetCba
+// -----------------------------------------------------------------------------
+//
+CEikButtonGroupContainer* CVtUiAppUi::GetCba()
+ {
+ return iCba;
+ }
+
+//
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetZoomModeL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetZoomModeL( const TBool aEnableZoomMode,
+ const TBool aIsPermanent )
+ {
+ __VTPRINTENTER( "VtUi.SetZoomModeL" )
+ __VTPRINT2( DEBUG_GEN, "VtUi.SetZoomMo=%d", aEnableZoomMode );
+ // If capture mode is on zoom mode cannot be changed
+ if ( iUiStates->IsCaptureModeOn() )
+ {
+ __VTPRINTEXIT( "VtUi.SetZoomModeL.CaptureOn" )
+ return;
+ }
+ CVtUiZoom* zoom = static_cast< CVtUiZoom* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdZoom ) );
+ if ( zoom )
+ {
+ if ( aEnableZoomMode )
+ {
+ if( aIsPermanent )
+ {
+ zoom->SetPermanenVisibility( aEnableZoomMode );
+ }
+ zoom->StartL();
+ }
+ else
+ {
+ if( aIsPermanent )
+ {
+ zoom->SetPermanenVisibility( aEnableZoomMode );
+ }
+ zoom->Stop();
+ }
+ }
+ iUiStates->SetZoomModeOn( aEnableZoomMode );
+ CVtUiToolbarBase* tb = static_cast< CVtUiToolbarBase* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdToolbar ) );
+ if ( tb )
+ {
+ tb->RefreshL();
+ }
+
+ __VTPRINTEXIT( "VtUi.SetZoomModeL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HelpContextL
+// Returns help context array.
+// -----------------------------------------------------------------------------
+//
+CArrayFix<TCoeHelpContext>* CVtUiAppUi::HelpContextL() const
+ {
+ CArrayFix<TCoeHelpContext>* array =
+ new ( ELeave ) CArrayFixFlat<TCoeHelpContext>( KVtUiHelpContextAmount );
+ CleanupStack::PushL( array );
+
+ array->AppendL(
+ TCoeHelpContext(
+ KVtUiTelephoneUid,
+ KINCAL_HLP_VIDEO_CALL ) );
+
+ CleanupStack::Pop( array );
+ return array;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecExecuteL
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::ActiveExecExecuteL(
+ CVtUiActiveExec& /*aActiveExec*/,
+ const TInt aState,
+ TInt& aNextState,
+ TRequestStatus& aRequest )
+ {
+ return ActiveExecInitExecuteL(
+ aState,
+ aNextState,
+ aRequest );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecContinue
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::ActiveExecContinue(
+ CVtUiActiveExec& /*aActiveExec*/,
+ TInt& aState,
+ const TInt aError )
+ {
+ return ActiveExecInitContinue( aState, aError );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecCancel
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecCancel(
+ CVtUiActiveExec& /*aActiveExec*/,
+ TInt aState )
+ {
+ ActiveExecInitCancel( aState );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecDone
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecDone(
+ CVtUiActiveExec& /*aActiveExec*/,
+ const TInt aInitialState )
+ {
+ ActiveExecInitDone( aInitialState );
+ }
+
+// state object service handlers
+
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShutdownL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShutdownL()
+ {
+ __VTPRINTENTER( "VtUi.ShutdownL" )
+
+ CVtUiWhiteBalance* wb = static_cast< CVtUiWhiteBalance* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdWhiteBalance ) );
+ CVtUiColorTone* ct = static_cast< CVtUiColorTone* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdColourTone ) );
+
+ if ( wb->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "CVtUiWhiteBalance::DoDeactivateL" );
+ wb->DoDeactivateL ();
+ }
+ if ( ct->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "CVtUiColorTone::DoDeactivateL" );
+ ct->DoDeactivateL( );
+ }
+
+ // close volume slider
+ CVtUiVolume* volume = static_cast< CVtUiVolume* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdVolume ) );
+ if ( volume )
+ {
+ volume->Stop();
+ }
+ // if capture mode is on stop the zoom
+ if ( iUiStates->IsCaptureModeOn() )
+ {
+ CVtUiZoom* zoom = static_cast< CVtUiZoom* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdZoom ) );
+ if ( zoom )
+ {
+ zoom->Stop();
+ }
+ }
+
+ iActiveExec->Start( EVtUiAppUiShutdown, *this );
+ __VTPRINTEXIT( "VtUi.ShutdownL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::StartupPhase1L
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::StartupPhase1L()
+ {
+ __VTPRINTENTER( "VtUi.StartupPhase1L" )
+ iActiveExec->Start( EVtUiAppUiStartup, *this );
+ __VTPRINTEXIT( "VtUi.StartupPhase1L" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::StartupPhase2L
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::StartupPhase2L()
+ {
+ __VTPRINTENTER( "VtUi.StartupPhase2L" )
+ iActiveExec->Start( EVtUiAppUiAnswered, *this );
+ __VTPRINTEXIT( "VtUi.StartupPhase2L" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ChangeState
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ChangeState( TVtUiAppStateBase* aState )
+ {
+ __VTPRINTENTER( "VtUi.ChangeState" )
+ iState = aState;
+ __VTPRINTEXIT( "VtUi.ChangeState" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::IsCommandAllowedL
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::IsCommandAllowedL( const TInt aCommand )
+ {
+ return iCommandManager->IsCommandAllowedL( aCommand );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshDisabledFlagsL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshDisabledFlagsL()
+ {
+ // Refresh iDisabledFlags according to the current state.
+ TInt avail;
+ MVtEngMedia& media = Model().Media();
+ VtUiUtility::GetOutgoingMediaState( media, avail );
+ avail = ~avail;
+
+ iDisabledFlags = 0;
+ if ( avail & MVtEngMedia::EMediaAudio )
+ {
+ iDisabledFlags |= EDisabledAudio;
+ }
+ if ( avail & MVtEngMedia::EMediaVideo )
+ {
+ iDisabledFlags |= EDisabledVideo;
+ }
+
+ // If there are not cameras, then video options should be disabled.
+ if ( !VtUiUtility::HasCameras( media ) )
+ {
+ iDisabledFlags |= EVideoOptionsDisabled;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshCameraOptionAvailability
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshCameraOptionAvailability(
+ TBool& aUsePrimaryCameraNotAllowed,
+ TBool& aUseSecondaryCameraNotAllowed )
+ {
+ aUsePrimaryCameraNotAllowed = ETrue;
+ aUseSecondaryCameraNotAllowed = ETrue;
+
+ // Check sources caps and current camera to see which
+ // items should be included to the menu.
+
+ TInt sourcesCaps = 0;
+ MVtEngMedia& media = Model().Media();
+ (void) media.GetSourcesCaps( sourcesCaps );
+
+ MVtEngMedia::TCameraId cameraId;
+ const TBool hasCameraId =
+ ( media.GetCurrentCameraId( cameraId ) == KErrNone );
+
+ if ( hasCameraId )
+ {
+ // Camera is in use. Now selected camera is not included
+ // to the menu.
+ switch ( cameraId )
+ {
+ case MVtEngMedia::EPrimaryCamera:
+ sourcesCaps &=
+ ~MVtEngMedia::ESourceCapsPrimaryCamera;
+ break;
+
+ case MVtEngMedia::ESecondaryCamera:
+ sourcesCaps &=
+ ~MVtEngMedia::ESourceCapsSecondaryCamera;
+ break;
+
+ default:
+ sourcesCaps = 0;
+ break;
+ }
+ }
+ else
+ {
+ // If camera is not in use, then the "enable video" option
+ // will automatically use one of the existing cameras.
+ // However, if there are two cameras, then we need
+ // to include secondary to the menu.
+
+ const TInt bothCameras =
+ ( MVtEngMedia::ESourceCapsPrimaryCamera |
+ MVtEngMedia::ESourceCapsSecondaryCamera );
+ sourcesCaps &= ~bothCameras;
+ if ( sourcesCaps == bothCameras )
+ {
+ sourcesCaps &=
+ ~MVtEngMedia::ESourceCapsPrimaryCamera;
+ }
+ else
+ {
+ sourcesCaps = 0;
+ }
+ }
+
+ sourcesCaps = ~sourcesCaps;
+ aUsePrimaryCameraNotAllowed =
+ ( sourcesCaps & MVtEngMedia::ESourceCapsPrimaryCamera );
+ aUseSecondaryCameraNotAllowed =
+ ( sourcesCaps & MVtEngMedia::ESourceCapsSecondaryCamera );
+ }
+
+// -----------------------------------------------------------------------------
+// VtUiAppUi::CmdCaptureL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdCaptureL()
+ {
+ //firstly need to know if underlying provider supports KVtEngFreeze
+ MVtEngCommandHandler& command = Model().CommandHandler();
+ const TInt caps = command.GetCommandCaps( KVtEngFreeze );
+ if ( (caps & MVtEngCommandHandler::EAttribEnabled) == 0)
+ {
+ return;
+ }
+ // end capture mode, image captured
+ iUiStates->SetCaptureModeOn( EFalse );
+ // end zoom mode
+ SetZoomModeL( EFalse, ETrue );
+ // freeze outgoing video
+ ExecuteCmdL( KVtEngFreeze );
+ RefreshBlind();
+ }
+
+// -----------------------------------------------------------------------------
+// VtUiAppUi::CmdSnapshotL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdSnapshotL()
+ {
+ __VTPRINTENTER( "VtUi.CmdSnapshotL" )
+
+ // zoom mode must be set on before capture mode is set on
+ SetZoomModeL( ETrue, ETrue );
+
+ // if outgoing video is already frozen
+ MVtEngMedia& media = Model().Media();
+ const TBool isFrozen( VtUiUtility::GetFreezeState( media ) );
+ if ( isFrozen )
+ {
+ ExecuteCmdL( KVtEngUnfreeze );
+ }
+ if ( !IsViewFinderInMainPane() )
+ {
+ SwitchViewFinderToMainPaneL( !isFrozen );
+ }
+ else if ( !isFrozen )
+ {
+ iUiStates->SetViewFindersInitialPlaceContextPane( EFalse );
+ }
+
+ // set capture mode on
+
+ iUiStates->SetCaptureModeOn( ETrue );
+ RefreshStatesL();
+ RefreshBlind();
+ __VTPRINTEXIT( "VtUi.CmdSnapshotL" )
+ }
+
+// -----------------------------------------------------------------------------
+// VtUiAppUi::CmdCancelCaptureL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdCancelCaptureL()
+ {
+ __VTPRINTENTER( "VtUi.CmdCancelCaptureL" )
+ // end capture mode, image capture canceled
+ iUiStates->SetCaptureModeOn( EFalse );
+ SetZoomModeL( EFalse, ETrue );
+ RefreshStatesL();
+ RestoreViewFinderL();
+ RefreshBlind();
+ __VTPRINTEXIT( "VtUi.CmdCancelCaptureL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdEnableVideoL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdEnableVideoL()
+ {
+ // if outgoing video is frozen
+ MVtEngMedia& media = Model().Media();
+ if ( VtUiUtility::GetFreezeState( media ) )
+ {
+ ExecuteCmdL( KVtEngUnfreeze );
+ // swap images if needed
+ RestoreViewFinderL();
+ }
+ else
+ {
+ ExecuteCmdL( KVtEngStopViewFinder );
+ iUplinkWindow->SetStreamBitmap( NULL );
+ MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaCamera;
+ ExecuteCmdL( KVtEngSetSource, source );
+ MVtEngMedia::TCameraId id;
+ if ( Model().Media().GetCurrentCameraId( id ) == KErrInUse )
+ {
+ ShowCameraInUseNoteL();
+ }
+ ExecuteCmdL( KVtEngStartViewFinder );
+ }
+ // update VB settings
+ UpdateVBSettingL();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdEnableAudioL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdEnableAudioL()
+ {
+ ExecuteCmdL( KVtEngUnmuteOutgoingAudio );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdDisableVideoL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdDisableVideoL()
+ {
+
+ if( iUiStates->IsZoomModeOn() )
+ {
+ // if zoom feature is active, stop that
+ MVtUiFeature* zm = iFeatureManager->GetFeatureById( EVtUiFeatureIdZoom );
+ if ( zm )
+ {
+ if ( zm->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.CmdDisableVideoL zm->STOP" )
+ zm->Stop();
+ }
+ }
+ }
+
+ ExecuteCmdL( KVtEngStopViewFinder );
+
+ iUplinkWindow->SetStreamBitmap( NULL );
+
+ TInt err = KErrNotFound;
+ if ( VtUiUtility::HasStillImage( Model().Media() ) )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.:CmdDisableVideoL.HasStill" )
+ MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaStillImage;
+ TRAP( err, ExecuteCmdL( KVtEngSetSource, source ) );
+ }
+ if ( ( err != KErrNone ) )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.:CmdDisableVideoL.MediaNone" )
+ MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaNone;
+ ExecuteCmdL( KVtEngSetSource, source );
+ }
+
+ ExecuteCmdL( KVtEngStartViewFinder );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdDisableAudioL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdDisableAudioL()
+ {
+ ExecuteCmdL( KVtEngMuteOutgoingAudio );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdActivateBtL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdActivateBtL()
+ {
+ TInt error = KErrNone;
+ CVtUiActivateBtHfDialog* dialog =
+ new ( ELeave ) CVtUiActivateBtHfDialog(
+ NULL,
+ &error,
+ Model().CommandHandler(),
+ *iEventObserver );
+ dialog->ExecuteDialogLD();
+
+ if ( error != KErrCancel )
+ {
+ switch ( error )
+ {
+ case KErrNone:
+ break;
+
+ case KErrNoMemory:
+ case KErrNotSupported:
+ // Clear failure - to be handled in active scheduler.
+ User::Leave( error );
+ break;
+
+ default:
+ // Failed - still show local information note in error situation.
+ {
+ HBufC* prompt =
+ StringLoader::LoadLC(
+ R_VIDEOTELUI_QTN_BT_DEVICE_NOT_AVAIL );
+ CAknInformationNote* note =
+ new ( ELeave ) CAknInformationNote( ETrue );
+ note->ExecuteLD( *prompt );
+ CleanupStack::PopAndDestroy( prompt );
+ }
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdDeactivateBtL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdDeactivateBtL()
+ {
+ // Command to Video tel engine
+ MVtEngAudio::TVtEngRoutingSetting audioSetting =
+ MVtEngAudio::EDeactivateBT;
+
+ ExecuteCmdL( KVtEngSetAudioRouting, audioSetting );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdActivateLoudspeakerL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdActivateLoudspeakerL()
+ {
+ MVtEngAudio::TVtEngRoutingSetting audioSetting =
+ MVtEngAudio::EActivateHandsfree;
+ ExecuteCmdL( KVtEngSetAudioRouting, audioSetting );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdDeactivateLoudspeakerL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdDeactivateLoudspeakerL()
+ {
+ MVtEngAudio::TVtEngRoutingSetting audioSetting =
+ MVtEngAudio::EDeactivateHansfree;
+ ExecuteCmdL( KVtEngSetAudioRouting, audioSetting );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdSwapImagesPlacesL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdSwapImagesPlacesL()
+ {
+ __VTPRINTENTER( "VtUi.Swap" )
+
+ MVtEngMedia& media = Model().Media();
+ const TBool viewFinderStarted =
+ media.RenderingStarted( MVtEngMedia::EMediaOutgoing );
+ const TBool remoteRenderStarted =
+ media.RenderingStarted( MVtEngMedia::EMediaIncoming );
+
+ if ( viewFinderStarted )
+ {
+ // Stop viewfinder.
+ __VTPRINT( DEBUG_GEN, "VtUi.Swap.VF.down" )
+ ExecuteCmdL( KVtEngStopViewFinder );
+ }
+ // Stop remote render.
+ __VTPRINT( DEBUG_GEN, "VtUi.Swap.RR.down" )
+ ExecuteCmdL( KVtEngStopRenderRemote );
+
+ // Clear windows.
+ iUplinkWindow->Reset();
+ iDownlinkWindow->Reset();
+
+ const TBool uplinkWindowEqualsContextControl =
+ ( iUplinkWindow == iInstance->iContextControl );
+
+ // Prepare viewfinder.
+ __VTPRINT( DEBUG_GEN, "VtUi.Swap.VF.upd" )
+ TVtEngRenderingOptions configViewfinder(
+ uplinkWindowEqualsContextControl ?
+ DetermineMainControlOptions( EFalse ) :
+ DetermineContextControlOptions() );
+ ExecuteCmdL( KVtEngPrepareViewFinder, configViewfinder );
+
+ // Swap windows.
+ if ( ERenderingModeDialer == iRenderingMode )
+ {
+ MVtUiVideoWindow* tmpWindow = iUplinkWindow;
+ iUplinkWindow = iStoredDownlinkWindow;
+ iStoredDownlinkWindow = tmpWindow;
+ }
+ else
+ {
+ MVtUiVideoWindow* tmpWindow = iUplinkWindow;
+ iUplinkWindow = iDownlinkWindow;
+ iDownlinkWindow = tmpWindow;
+ }
+ iUplinkWindow->SetRemoteVideoControl(NULL);
+ iDownlinkWindow->SetRemoteVideoControl(iInstance->iRemoteVideoControl);
+ iDownlinkWindow->LayoutRemoteVideo();
+
+ // Prepare remote render.
+ __VTPRINT( DEBUG_GEN, "VtUi.Swap.RR.upd" )
+ TRAPD ( err, {
+ TVtEngRenderingOptionsNGA configRemoteRenderNGA(
+ DetermineRemoteVideoControlOptionsNGA() );
+ ExecuteCmdL(
+ KVtEngPrepareRemoteRenderNGA,
+ configRemoteRenderNGA );
+ } );
+
+ if ( err != KErrNone )
+ {
+ if ( viewFinderStarted )
+ {
+ // Start viewfinder.
+ ExecuteCmdL( KVtEngStartViewFinder );
+ }
+ User::Leave ( err );
+ }
+ // Start remote render.
+ __VTPRINT( DEBUG_GEN, "VtUi.Swap.RR.up" )
+ if ( remoteRenderStarted )
+ {
+ ExecuteCmdL( KVtEngStartRenderRemote );
+ }
+
+ __VTPRINT( DEBUG_GEN, "VtUi.Swap.VF.up" )
+ if ( viewFinderStarted )
+ {
+ // Start viewfinder.
+ ExecuteCmdL( KVtEngStartViewFinder );
+ }
+
+ iDownlinkWindow->Redraw();
+
+ // Refresh blind & waiting will be handled in HandleCommandL.
+ __VTPRINTEXIT( "VtUi.Swap" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdUseCameraL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdUseCameraL( const TBool aPrimaryCamera )
+ {
+ EnableCommandActivatingAndCleanupPushL();
+ MVtEngMedia& media = Model().Media();
+
+ MVtEngMedia::TMediaSource selectedSource =
+ ( aPrimaryCamera ) ?
+ MVtEngMedia::EMediaCameraPri : MVtEngMedia::EMediaCameraSec;
+
+ TInt available = 0;
+ VtUiUtility::GetOutgoingMediaState( media, available );
+ if ( available & MVtEngMedia::EMediaVideo )
+ {
+ ExecuteCmdL( KVtEngStopViewFinder );
+
+ iUplinkWindow->SetStreamBitmap( NULL );
+ TRAPD( err, ExecuteCmdL( KVtEngSetSource, selectedSource ) );
+
+ if ( err == KErrNone )
+ {
+ ExecuteCmdL( KVtEngStartViewFinder );
+ }
+ else
+ {
+ ShowOtherCameraNotUsableNoteL();
+ }
+ }
+ else
+ {
+ MVtEngMedia::TPrepareCameraParams params;
+ params.iMediaSource = selectedSource;
+ params.iInitialize = EFalse;
+ TRAPD( err, ExecuteCmdL( KVtEngPrepareCamera, params ) );
+ if ( err != KErrNone )
+ {
+ ShowOtherCameraNotUsableNoteL();
+ }
+ }
+ CleanupStack::PopAndDestroy(); // EnableCommandActivatingAndCleanupPushL
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdHelpL
+// Launches help application.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdHelpL()
+ {
+ HlpLauncher::LaunchHelpApplicationL(
+ iEikonEnv->WsSession(),
+ AppHelpContextL() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::PrepareExitL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::PrepareExitL()
+ {
+ __VTPRINTENTER( "VtUi.PrepareExitL" )
+ // Cancel progress dialog
+ HideProgressDialogL();
+ // Cancel menu.
+ CAknAppUi::ProcessCommandL( EEikCmdCanceled ); // does not leave
+
+ if ( !iExitTimer->IsActive() )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.Exit.Timer.Go" )
+ iExitTimer->Start(
+ KVtUiExitTimeout,
+ KVtUiExitTimeout,
+ TCallBack( DoHandleExitTimeout, this ) );
+ }
+
+ // Asynchronous shutdown - execute command.
+ iBlankControl->SetActive( ETrue );
+ __VTPRINTEXIT( "VtUi.PrepareExitL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdUpdateZoomL
+// This method is called to update zoom step to the Video Telephone engine
+// side from the HandleKeyEventL method.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdUpdateZoomL()
+ {
+ __VTPRINTENTER( "VtUi.UpdZm" )
+
+ __VTPRINTEXIT( "VtUi.UpdZm" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetZoomFactorL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetZoomFactorL( TInt aZoomStep )
+ {
+ __VTPRINTENTER( "VtUi.SetZoomFactorL" )
+ MVtEngMedia& media = Model().Media();
+ if ( VtUiUtility::IsZoomAllowed( media ) )
+ {
+ ExecuteCmdL( KVtEngSetZoomStep, aZoomStep );
+ }
+ __VTPRINTEXIT( "VtUi.SetZoomFactorL" )
+ }
+
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdUpdateVolumeL
+// This method is called to update volume to the Video Telephone engine
+// side
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdUpdateVolumeL( MVtEngAudio::TVtEngOutputVolume aVolume )
+ {
+ __VTPRINTENTER( "VtUi.CmdUpdateVolumeL" )
+ iVolCtrl->AdjustVolumeL( aVolume );
+ __VTPRINTEXIT( "VtUi.CmdUpdateVolumeL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdGoToIdleL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdGoToIdleL()
+ {
+ __VTPRINTENTER( "VtUi.CmdGoToIdleL" )
+ TInt idleUid = 0;
+ if ( RProperty::Get(
+ KPSUidAiInformation,
+ KActiveIdleUid,
+ idleUid ) == KErrNone )
+ {
+ __VTPRINT2( DEBUG_GEN, "Idle UID: %d", idleUid )
+ TApaTaskList taskList( iEikonEnv->WsSession() );
+ TApaTask task = taskList.FindApp( TUid::Uid( idleUid ) );
+ if ( task.Exists() )
+ {
+ __VTPRINT( DEBUG_GEN, "Idle task found")
+ RProperty::Set( KPSUidUikon, KUikVideoCallTopApp, KVtUiAppUid.iUid );
+ task.BringToForeground();
+ }
+ }
+ __VTPRINTEXIT( "VtUi.CmdGoToIdleL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdInitializeShareImageL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdInitializeShareImageL( TBool& aNeedRefresh )
+ {
+ __VTPRINTENTER( "VtUi.CmdInitializeShareImageL" )
+ EnableCommandActivatingAndCleanupPushL();
+
+ MVtUiFeature* tb =
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdToolbar );
+ if ( tb )
+ {
+ // timer could be active
+ if ( iTbPeriodic )
+ {
+ iTbPeriodic->Cancel();
+ }
+ tb->Stop();
+ }
+ CDesCArray* selectedFiles = new ( ELeave ) CDesCArrayFlat( 1 );
+ CleanupStack::PushL( selectedFiles );
+ CVtUiAppUi::CVtUiAppUiMGVerifier* verifier =
+ CVtUiAppUi::CVtUiAppUiMGVerifier::NewLC( *this, *iCoeEnv );
+
+ // number erntry is not availabe while media gallery is open
+ iInstance->iNumberEntryActivation->SetActive( EFalse );
+ iUiStates->SetSelectingShare( ETrue );
+
+ TBool result( EFalse );
+ TRAPD( err, result =
+ MGFetch::RunL( *selectedFiles, EImageFile, EFalse, verifier ) );
+
+ // leave occured
+ if ( err != KErrNone )
+ {
+ if ( iUiStates->ExecState() == TVtUiStates::EExecStateRunning )
+ {
+ ShowUnableToOpenNoteL();
+ }
+ else
+ {
+ __VTPRINTEXIT( "VtUi.CmdInitializeShareImageL 1" )
+ Exit();
+ }
+ }
+
+ if ( result && ( selectedFiles->Count() > 0 ) )
+ {
+ MVtEngMedia::TShareObjectState shareObjectState;
+ VtUiUtility::GetObjectSharingState( Model().Media(), shareObjectState );
+ iUiStates->SetViewFinderToMainPane(
+ shareObjectState == MVtEngMedia::ENotSharing );
+ MVtEngMedia::TShareObjectImageParameters
+ parameters( selectedFiles->operator[]( 0 ) );
+ ExecuteCmdL( KVtEngInitializeShareImage, parameters );
+ aNeedRefresh = ETrue;
+ }
+ else // selection canceled start toolbar timer
+ {
+ if ( !iTbPeriodic )
+ {
+ iTbPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );
+ }
+ iTbPeriodic->Cancel();
+ iTbPeriodic->Start( KStartTime, KPeriodTime, TCallBack( DoTryToStartTbL, this ) );
+ }
+ CleanupStack::PopAndDestroy( 2 ); // selectedFiles, verifier
+ // number entry is availabe again
+ iInstance->iNumberEntryActivation->SetActive( ETrue );
+ iUiStates->SetSelectingShare( EFalse );
+ CleanupStack::PopAndDestroy(); // EnableCommandActivatingAndCleanupPushL();
+
+ __VTPRINTEXIT( "VtUi.CmdInitializeShareImageL 0" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdShareImageL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdShareImageL()
+ {
+ ExecuteCmdL( KVtEngStartShareImage );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdStopShareImageL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CmdStopShareImageL( TBool& aNeedRefresh )
+ {
+ ExecuteCmdL( KVtEngStopShareImage );
+ RestoreViewFinderL();
+ aNeedRefresh = ETrue;
+ // update VB settings
+ UpdateVBSettingL();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleWaitingStateChange
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleWaitingStateChange( TBool aIsWaiting )
+ {
+ // Dialer must be closed in case of waiting call
+ MVtUiFeature* dialer =
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdDialer );
+ if ( dialer )
+ {
+ dialer->Stop();
+ }
+ iUiStates->SetWaitingCall( aIsWaiting );
+ if (aIsWaiting == EFalse &&
+ iIsWaitingCallState != EFalse &&
+ !iUiStates->IsThisApplicationForeground() )
+ {
+ iIsWaitingCallState = EFalse;
+ ChangeApplicationFocus( ETrue );
+ TRAP_IGNORE ( SetHiddenL( EFalse ) );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitExecuteL
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::ActiveExecInitExecuteL(
+ const TInt aState,
+ TInt& aNextState,
+ TRequestStatus& aRequest )
+ {
+ __VTPRINTENTER( "VtUi.InitExec" )
+ __VTPRINT2( DEBUG_GEN, "VtUi.InitExec.st=%d", aState )
+
+ TBool synch = EFalse;
+
+ switch ( aState )
+ {
+ // Startup chain:
+ case EVtUiAppUiStartupCloseDialogs:
+ // Close all dialogs.
+ iBlankControl->SetActive( EFalse );
+ AknDialogShutter::ShutDialogsL( *iEikonEnv );
+ iBlankControl->SetActive( ETrue );
+
+ synch = ETrue;
+ aNextState = EVtUiAppUiStartupInitEngine;
+ break;
+
+ case EVtUiAppUiStartupInitEngine:
+ iUplinkWindow = iInstance->iContextControl;
+ iDownlinkWindow = iInstance->iMainControl;
+ ActiveExecInitExecuteCommandL( KVtEngInitializeEngine, aRequest );
+ aNextState = EVtUiAppUiStartupPrepareViewfinder;
+ break;
+
+ case EVtUiAppUiStartupPrepareViewfinder:
+ ActiveExecInitPrepareViewFinderL( aRequest );
+ iUplinkWindow->SetStreamBitmap( NULL );
+ aNextState = EVtUiAppUiStartupPrepareRemoteRender;
+ break;
+
+ case EVtUiAppUiStartupPrepareRemoteRender:
+
+ iInstance->CreateRemoteVideoControl();
+ ActiveExecInitPrepareRemoteRenderL( aRequest );
+ iDownlinkWindow->SetStreamBitmap( NULL );
+ aNextState = EVtUiAppUiStartupRemoveBlank;
+ break;
+
+ case EVtUiAppUiStartupRemoveBlank:
+ // Finally remove blank control.
+ iBlankControl->SetActive( EFalse );
+ aNextState = EVtUiAppUiNone;
+ synch = ETrue;
+ break;
+
+ // Shutdown chain:
+ case EVtUiAppUiShutdownCloseDialogs:
+ {
+ // Close all dialogs.
+ iBlankControl->SetActive( EFalse );
+ AknDialogShutter::ShutDialogsL( *iEikonEnv );
+ iBlankControl->SetActive( ETrue );
+
+ MVtUiFeature* numberEntry = iFeatureManager->GetFeatureById(
+ EVtUiFeatureIdNumberEntry );
+ // Number entry may be active if its deactivation timer is still
+ // pending. Stop performs some cleanup which is needed before AppUi
+ // cleanup.
+ if ( numberEntry )
+ {
+ numberEntry->Stop();
+ }
+
+ synch = ETrue;
+ aNextState = EVtUiAppUiShutdownHideApplication;
+ }
+ break;
+
+ case EVtUiAppUiShutdownHideApplication:
+ if ( iUiStates->IsThisApplicationForeground() )
+ {
+ BringTelephoneToForeground();
+ }
+ else
+ {
+ ChangeApplicationFocus( EFalse );
+ }
+ iDownlinkWindow->SetStreamBitmap( NULL );
+ iUplinkWindow->SetStreamBitmap( NULL );
+ SetHiddenL( ETrue );
+ iEventObserver->DeleteRemConSession();
+
+ synch = ETrue;
+ aNextState = EVtUiAppUiShutdownResetEngine;
+ break;
+
+ case EVtUiAppUiShutdownResetEngine:
+ {
+ aRequest = KRequestPending;
+
+ MVtEngCommandHandler& command = Model().CommandHandler();
+ // There should not be any commands ongoing because
+ // we have canceled all dialogs (and this should
+ // be the only command without dialog).
+ command.CancelCommand( command.PendingCommand() ); // ignore error
+ command.ExecuteL( KVtEngResetEngine, NULL );
+ iShutdownRequest = &aRequest;
+
+ aNextState = EVtUiAppUiShutdownRemoveBlank;
+ }
+ break;
+
+ case EVtUiAppUiShutdownRemoveBlank:
+ // Finally remove blank control.
+ iBlankControl->SetActive( EFalse );
+
+ synch = ETrue;
+ aNextState = EVtUiAppUiNone;
+ break;
+
+ // Answered chain:
+ case EVtUiAppUiAnsweredStart:
+ {
+ CVtUiBlankDialog* dialog =
+ new ( ELeave ) CVtUiBlankDialog( &iExecBlankDialog );
+ dialog->ExecuteDialogNoWaitLD();
+ iExecBlankDialog = dialog;
+
+ synch = ETrue;
+ if ( iUiStates->IsLayoutChangeNeeded() )
+ {
+ (void) HandleLayoutChanged();
+ }
+ aNextState = EVtUiAppUiAnsweredRefreshNavi;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredRefreshNavi:
+ RefreshNaviPaneL();
+ iEventObserver->CreateRemConSessionL();
+
+ synch = ETrue;
+ aNextState = EVtUiAppUiAnsweredRefreshSoftkeys;
+ break;
+
+ case EVtUiAppUiAnsweredRefreshSoftkeys:
+ RefreshSoftkeysL();
+
+ synch = ETrue;
+ aNextState = EVtUiAppUiAnsweredStartRemoteRender;
+ break;
+
+ case EVtUiAppUiAnsweredStartRemoteRender:
+ {
+ // Set waiting text to main control and start remote rendering.
+ // Video Telephone application should get KVtEngRemoteVideoStarted
+ // event when the first frame is received.
+ iDownlinkWindow->SetWaiting( ETrue );
+ iUiStates->SetWaitingForFirstFrame( ETrue );
+ //Must check if orientation changed between prepare remote render and start remote render
+ //If changed, update render parameter firstly
+ if ( iIsLandScapeOrientation != VtUiLayout::IsLandscapeOrientation() )
+ {
+ __VTPRINT( DEBUG_GEN, "layout has been changed before start RemoteRender" )
+ UpdateRenderingParametersL();
+ }
+
+ ActiveExecInitExecuteCommandL( KVtEngStartRenderRemote,
+ aRequest );
+
+ aNextState = EVtUiAppUiAnsweredCheckCamera;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredCheckCamera:
+ {
+ MVtEngMedia& media = Model().Media();
+ if ( VtUiUtility::HasCameras( media ) )
+ {
+ aNextState = EVtUiAppUiAnsweredChoose;
+ synch = ETrue;
+ }
+ else
+ {
+ if ( VtUiUtility::HasStillImage( media ) )
+ {
+ aNextState = EVtUiAppUiAnsweredSelectStill;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiAnsweredSelectNone;
+ }
+
+ synch = ETrue;
+ }
+ }
+ break;
+
+ case EVtUiAppUiAnsweredChoose:
+ {
+ // If camera is in use, then show note,
+ // select still image, stop.
+ //
+ // If call is mobile terminated, then show query.
+ // If user answers 'yes' to the query,
+ // then activate camera.
+ // If user answers 'no' to the query,
+ // then choose still image.
+ //
+ // If call is mobile originated, then select camera.
+ //
+ // If selecting a camera fails, then select still image.
+ // If selecting still image fails, then select none.
+ //
+ CVtEngModel& model = Model();
+ MVtEngSessionInfo& session = model.Session();
+ MVtEngMedia& media = model.Media();
+
+ MVtEngMedia::TCameraId id;
+ TInt cameraErr = model.Media().GetCurrentCameraId( id );
+ if ( cameraErr == KErrInUse )
+ {
+ // Camera is in use.
+ iUiStates->SetExecShowCameraInUse( ETrue );
+
+ if ( VtUiUtility::HasStillImage( media ) )
+ {
+ aNextState = EVtUiAppUiAnsweredSelectStill;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiAnsweredSelectNone;
+ }
+ }
+ else
+ {
+ // Check the direction of the call.
+ iUiStates->SetExecShowCameraInUse( EFalse );
+ MVtEngSessionInfo::TDirection direction;
+ if ( session.GetDirection( direction ) != KErrNone )
+ {
+ direction = MVtEngSessionInfo::EDirectionMT;
+ }
+
+ if ( direction == MVtEngSessionInfo::EDirectionMT )
+ {
+ // Start steps towards the "Allow video" query.
+ if ( VtUiUtility::HasStillImage( media ) )
+ {
+ aNextState = EVtUiAppUiAnsweredQuerySetupStill;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiAnsweredQuerySetupNone;
+ }
+ }
+ else
+ {
+ aNextState = EVtUiAppUiAnsweredDoPrepareCamera;
+ }
+ }
+ synch = ETrue;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredQuerySetupStill:
+ ActiveExecInitSetSourceL( MVtEngMedia::EMediaStillImage, aRequest );
+ aNextState = EVtUiAppUiAnsweredQuerySetupStart;
+ break;
+
+ case EVtUiAppUiAnsweredQuerySetupNone:
+ ActiveExecInitSetSourceL( MVtEngMedia::EMediaNone, aRequest );
+ aNextState = EVtUiAppUiAnsweredQuerySetupStart;
+ break;
+
+ case EVtUiAppUiAnsweredQuerySetupStart:
+ ActiveExecInitExecuteCommandL( KVtEngStartViewFinder, aRequest );
+ aNextState = EVtUiAppUiAnsweredQueryShow;
+ break;
+
+ case EVtUiAppUiAnsweredQueryShow:
+ {
+ RefreshL();
+ TInt state = EPSCTsyCallStateUninitialized;
+ TInt err = RProperty::Get(
+ KPSUidCtsyCallInformation,
+ KCTsyCallState,
+ state );
+ __VTPRINT3( DEBUG_GEN, "VtUi.InitExec WaitingCall State=%d, err=%d",
+ state, err )
+ if ( EPSCTsyCallStateRinging != state )
+ {
+ ChangeApplicationFocus( ETrue );
+ SetHiddenL( EFalse );
+ }
+ else
+ {
+ iIsWaitingCallState = ETrue;
+ }
+
+ // User selectable call answer mute.
+ // In GS one can set call ansewer status
+ // eighter to query user, allways show, allways mute.
+ // GS values are checked from CR key ( KSettingsVTVideoSending )
+ // (default value is 0 = allways query).
+ TVtUiGsMuteVariation camute;
+ __VTPRINT2( DEBUG_GEN, "VtUi.InitExe GS CR key KSettingsVTVideoSending querystate=%d", camute.GsMuteState() )
+ if ( camute.GsMuteState() == KAllwaysQuery && !iUiStates->IsDeviceLockOn() && EPSCTsyCallStateRinging != state)
+ {
+ CVtUiAllowVideoDialog* dialog =
+ new ( ELeave ) CVtUiAllowVideoDialog(
+ &iExecDialog,
+ CAknQueryDialog::ENoTone );
+ dialog->ExecuteDialogLD( aRequest );
+ iExecDialog = dialog;
+ aNextState = EVtUiAppUiAnsweredQueryDecide;
+ }
+ else if ( camute.GsMuteState() == KAllwaysAllow )
+ {
+ aNextState = EVtUiAppUiAnsweredDoPrepareCamera;
+ synch = ETrue;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiNone;
+ synch = ETrue;
+ }
+
+ }
+ break;
+
+ case EVtUiAppUiAnsweredQueryDecide:
+ {
+ delete iExecDialog;
+ iExecDialog = NULL;
+
+ if ( iActiveExec->RequestStatus() ==
+ CVtUiAllowVideoDialog::EUserAllowed )
+ {
+ aNextState = EVtUiAppUiAnsweredDoPrepareCamera;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiNone;
+ }
+
+ synch = ETrue;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredDoPrepareCamera:
+ {
+ MVtEngMedia& media = Model().Media();
+ MVtEngMedia::TMediaSource source = MVtEngMedia::EMediaCamera;
+ ActiveExecInitPrepareCameraL( source, aRequest );
+ aNextState = EVtUiAppUiAnsweredSelectCamera;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredQuerySelectCamera:
+ case EVtUiAppUiAnsweredSelectCamera:
+ ActiveExecInitSetSourceL( MVtEngMedia::EMediaCamera, aRequest );
+ if ( aState == EVtUiAppUiAnsweredSelectCamera )
+ {
+ aNextState = EVtUiAppUiAnsweredStartViewfinder;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiAnsweredQueryStartViewfinder;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredQuerySelectStill:
+ case EVtUiAppUiAnsweredSelectStill:
+ ActiveExecInitSetSourceL( MVtEngMedia::EMediaStillImage, aRequest );
+
+ if ( aState == EVtUiAppUiAnsweredSelectStill )
+ {
+ aNextState = EVtUiAppUiAnsweredStartViewfinder;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiAnsweredQueryStartViewfinder;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredQuerySelectNone:
+ case EVtUiAppUiAnsweredSelectNone:
+ ActiveExecInitSetSourceL( MVtEngMedia::EMediaNone, aRequest );
+
+ if ( aState == EVtUiAppUiAnsweredSelectNone )
+ {
+ aNextState = EVtUiAppUiAnsweredStartViewfinder;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiAnsweredQueryStartViewfinder;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredQueryStartViewfinder:
+ case EVtUiAppUiAnsweredStartViewfinder:
+ ActiveExecInitExecuteCommandL( KVtEngStartViewFinder, aRequest );
+
+ if ( aState == EVtUiAppUiAnsweredStartViewfinder )
+ {
+ aNextState = EVtUiAppUiAnsweredFinish;
+ }
+ else
+ {
+ aNextState = EVtUiAppUiAnsweredQueryFinish;
+ }
+ break;
+
+ case EVtUiAppUiAnsweredQueryFinish:
+ case EVtUiAppUiAnsweredFinish:
+ RefreshL();
+ if ( iUiStates->IsExecShowCameraInUse() )
+ {
+ ShowCameraInUseNoteL();
+ }
+
+ if ( aState != EVtUiAppUiAnsweredQueryFinish )
+ {
+ ChangeApplicationFocus( ETrue );
+ }
+ SetHiddenL( EFalse );
+
+ synch = ETrue;
+ aNextState = EVtUiAppUiNone;
+ break;
+
+ default:
+ User::Leave( KErrNotSupported );
+ break;
+ }
+
+ __VTPRINT2( DEBUG_GEN, "VtUi.InitExec.sync=%d", synch )
+ __VTPRINT2( DEBUG_GEN, "VtUi.InitExec.next=%d", aNextState )
+ __VTPRINTEXITR( "VtUi.InitExec %d", synch )
+ return synch;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitContinue
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::ActiveExecInitContinue(
+ TInt& aState,
+ const TInt aError )
+ {
+ __VTPRINTENTER( "VtUi.InitExecCont" )
+ __VTPRINT2( DEBUG_GEN, "VtUi.InitExecCont.st=%d", aState )
+ //__VTPRINT2( DEBUG_GEN, "VtUi.InitExecCont.err=%d", aError )
+
+ const TInt state = aState;
+ switch ( state )
+ {
+ case EVtUiAppUiStartupCloseDialogs:
+ case EVtUiAppUiStartupInitEngine:
+ case EVtUiAppUiStartupPrepareViewfinder:
+ case EVtUiAppUiStartupPrepareRemoteRender:
+ case EVtUiAppUiStartupRemoveBlank:
+ // Prepare failed.
+ break;
+
+ case EVtUiAppUiShutdownCloseDialogs:
+ if( KErrNotReady == aError )
+ {
+ aState = EVtUiAppUiShutdownHideApplication;
+ break;
+ }
+ case EVtUiAppUiShutdownResetEngine:
+ case EVtUiAppUiShutdownRemoveBlank:
+ // shutdown failed
+ break;
+
+ case EVtUiAppUiShutdownHideApplication:
+ aState = EVtUiAppUiShutdownResetEngine;
+ break;
+
+
+ case EVtUiAppUiAnsweredStart:
+ aState = EVtUiAppUiAnsweredRefreshNavi;
+ break;
+
+ case EVtUiAppUiAnsweredRefreshNavi:
+ aState = EVtUiAppUiAnsweredRefreshSoftkeys;
+ break;
+
+ case EVtUiAppUiAnsweredRefreshSoftkeys:
+ aState = EVtUiAppUiAnsweredStartRemoteRender;
+ break;
+
+ case EVtUiAppUiAnsweredStartRemoteRender:
+ case EVtUiAppUiAnsweredStartViewfinder:
+ case EVtUiAppUiAnsweredSelectNone:
+ case EVtUiAppUiAnsweredFinish:
+ case EVtUiAppUiAnsweredQueryStartViewfinder:
+ case EVtUiAppUiAnsweredQuerySelectNone:
+ case EVtUiAppUiAnsweredQueryFinish:
+ // Answered failed.
+ break;
+
+ case EVtUiAppUiAnsweredCheckCamera:
+ aState = EVtUiAppUiAnsweredChoose;
+ break;
+
+ case EVtUiAppUiAnsweredChoose:
+ aState = EVtUiAppUiAnsweredQuerySetupStill;
+ break;
+
+ case EVtUiAppUiAnsweredQuerySetupStill:
+ aState = EVtUiAppUiAnsweredQuerySetupNone;
+ break;
+
+ case EVtUiAppUiAnsweredQuerySetupStart:
+ case EVtUiAppUiAnsweredQuerySetupNone:
+ aState = EVtUiAppUiAnsweredQueryShow;
+ break;
+
+ case EVtUiAppUiAnsweredQueryShow:
+ case EVtUiAppUiAnsweredQueryDecide:
+ case EVtUiAppUiAnsweredSelectCamera:
+ aState = EVtUiAppUiAnsweredSelectStill;
+ break;
+
+ case EVtUiAppUiAnsweredQuerySelectCamera:
+ aState = EVtUiAppUiAnsweredQuerySelectStill;
+ break;
+
+ case EVtUiAppUiAnsweredQuerySelectStill:
+ aState = EVtUiAppUiAnsweredQuerySelectNone;
+ break;
+
+ case EVtUiAppUiAnsweredSelectStill:
+ aState = EVtUiAppUiAnsweredSelectNone;
+ break;
+
+ default:
+ break;
+ }
+
+ const TBool cont = ( aState != state );
+ __VTPRINT2( DEBUG_GEN, "VtUi.InitExecCont.cont=%d", cont )
+
+ if ( !cont )
+ {
+ delete iExecBlankDialog;
+ iExecBlankDialog = NULL;
+ // Operation failed.
+ if ( iState )
+ {
+ TRAP_IGNORE( iState->AppUiStartupFailedL() );
+ }
+ }
+ __VTPRINTEXITR( "VtUi.InitExecCont %d", cont )
+ return cont;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitCancel
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecInitCancel(
+ const TInt /*aState*/ )
+ {
+ __VTPRINTENTER( "VtUi.InitExecCancel" )
+
+ iBlankControl->SetActive( EFalse );
+ delete iExecDialog;
+ delete iExecBlankDialog;
+
+ if ( iShutdownRequest )
+ {
+ User::RequestComplete( iShutdownRequest, KErrCancel );
+ iShutdownRequest = NULL;
+ }
+ __VTPRINTEXIT( "VtUi.InitExecCancel" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitDone
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecInitDone(
+ const TInt aInitialState )
+ {
+ __VTPRINTENTER( "VtUi.ExecInitDone" )
+ __VTPRINT2( DEBUG_GEN, "VtUi.InitExecDone.ini=%d", aInitialState )
+ delete iExecBlankDialog;
+ iExecBlankDialog = NULL;
+ // Operation succeeded
+
+ // Now we have finished.
+ if ( iState )
+ {
+ if ( aInitialState == EVtUiAppUiAnswered )
+ {
+ TRAP_IGNORE( iState->AppUiStartupPhase2DoneL() );
+ TRAP_IGNORE( AppUiInitDoneDoPostInitL() );
+ }
+ else if ( aInitialState == EVtUiAppUiShutdown )
+ {
+ TRAP_IGNORE( iState->ShutdownDoneL() );
+ }
+ else // EVtUiAppUiStartup
+ {
+ TRAP_IGNORE( iState->AppUiStartupPhase1DoneL() );
+ }
+ }
+ __VTPRINTEXIT( "VtUi.ExecInitDone" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitExecuteCommandL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecInitExecuteCommandL(
+ const TVtEngCommandId aCommand,
+ TRequestStatus& aRequest )
+ {
+ iExecDialog =
+ ExecuteCmdAsyncL(
+ &iExecDialog,
+ aCommand,
+ aRequest );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitExecuteCommandL
+// -----------------------------------------------------------------------------
+//
+template < class T >
+void CVtUiAppUi::ActiveExecInitExecuteCommandL(
+ const TVtEngCommandId aCommand,
+ T& aParam,
+ TRequestStatus& aRequest )
+ {
+ iExecDialog =
+ ExecuteCmdAsyncL(
+ &iExecDialog,
+ aCommand,
+ aParam,
+ aRequest );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitPrepareCameraL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecInitPrepareCameraL(
+ const MVtEngMedia::TMediaSource aSource,
+ TRequestStatus& aRequest )
+ {
+ MVtEngMedia::TPrepareCameraParams params;
+ params.iMediaSource = aSource;
+ params.iInitialize = ETrue;
+ iExecDialog =
+ ExecuteCmdAsyncL(
+ &iExecDialog,
+ KVtEngPrepareCamera,
+ params,
+ aRequest );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitSetSourceL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecInitSetSourceL(
+ const MVtEngMedia::TMediaSource aSource,
+ TRequestStatus& aRequest )
+ {
+ MVtEngMedia::TMediaSource source =
+ aSource;
+ iExecDialog =
+ ExecuteCmdAsyncL(
+ &iExecDialog,
+ KVtEngSetSource,
+ source,
+ aRequest );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitPrepareViewFinderL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecInitPrepareViewFinderL(
+ TRequestStatus& aRequest )
+ {
+ // Configure view finder to context pane.
+ if ( iEventObserver->CommandSupported( KVtEngPrepareViewFinder ) )
+ {
+ TVtEngRenderingOptions configViewfinder(
+ DetermineContextControlOptions() );
+
+ iExecDialog =
+ ExecuteCmdAsyncL(
+ &iExecDialog,
+ KVtEngPrepareViewFinder,
+ configViewfinder,
+ aRequest );
+ }
+ else
+ {
+ // Viewfinder does not support DSA - panic.
+ VtUiPanic::Panic( EVtUiPanicPrepareViewFinderNotSupported );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecInitPrepareRemoteRenderL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecInitPrepareRemoteRenderL(
+ TRequestStatus& aRequest )
+ {
+ if ( iEventObserver->CommandSupported( KVtEngPrepareRemoteRenderNGA ) )
+ {
+ // Cropping is performed when we draw the picture.
+ TVtEngRenderingOptionsNGA configRemoteRenderNGA(
+ DetermineRemoteVideoControlOptionsNGA() );
+
+ iExecDialog =
+ ExecuteCmdAsyncL(
+ &iExecDialog,
+ KVtEngPrepareRemoteRenderNGA,
+ configRemoteRenderNGA,
+ aRequest );
+ }
+ else
+ {
+ // Neither supported - panic.
+ VtUiPanic::Panic( EVtUiPanicPrepareRemoteRenderNotSupported );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecCmdExecuteCommandL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecCmdExecuteCommandL(
+ const TVtEngCommandId aCommand,
+ TRequestStatus& aRequest )
+ {
+ iCmdExecDialog =
+ ExecuteCmdAsyncL(
+ &iCmdExecDialog,
+ aCommand,
+ aRequest );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecCmdSetSourceL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecCmdSetSourceL(
+ const MVtEngMedia::TMediaSource aSource,
+ TRequestStatus& aRequest )
+ {
+ MVtEngMedia::TMediaSource source = aSource;
+ iCmdExecDialog =
+ ExecuteCmdAsyncL(
+ &iCmdExecDialog,
+ KVtEngSetSource,
+ source,
+ aRequest );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ActiveExecCmdPrepareCameraL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ActiveExecCmdPrepareCameraL(
+ const MVtEngMedia::TMediaSource aSource,
+ TRequestStatus& aRequest )
+ {
+ MVtEngMedia::TPrepareCameraParams params;
+ params.iMediaSource = aSource;
+ params.iInitialize = ETrue;
+ iCmdExecDialog =
+ ExecuteCmdAsyncL(
+ &iCmdExecDialog,
+ KVtEngPrepareCamera,
+ params,
+ aRequest );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineMainControlOptions
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptions
+ CVtUiAppUi::DetermineMainControlOptions( TBool aRemoteVideo )
+ {
+ // Determine main pane options.
+ TRect screen;
+ TAknWindowLineLayout stream;
+ TAknLayoutRect rect;
+
+ screen = iInstance->iMainControl->Rect();
+ VtUiLayout::GetSecondWindowStreamWholeLayout(
+ stream, aRemoteVideo && iUiStates->IsUseSQCif() );
+
+ rect.LayoutRect( screen, stream );
+ screen = rect.Rect();
+
+ return TVtEngRenderingOptions( *iEventObserver, screen.Size() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineContextControlOptions
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptions CVtUiAppUi::DetermineContextControlOptions()
+ {
+ // Determine context pane options.
+ TRect screen;
+ TRect clip;
+ TAknWindowLineLayout stream;
+ TAknLayoutRect rect;
+
+ VtUiLayout::GetApplicationParentRect( screen );
+ VtUiLayout::GetFirstWindowBackgroundLayout( stream );
+ rect.LayoutRect( screen, stream );
+ TRect background = rect.Rect();
+
+ VtUiLayout::GetFirstWindowStreamLayout( stream );
+ rect.LayoutRect( screen, stream );
+
+ // No cropping is performed, thus clip == screen.
+ clip = rect.Rect();
+ clip.iTl -= background.iTl;
+ clip.iBr -= background.iTl;
+
+ screen = clip;
+
+ return
+ TVtEngRenderingOptions(
+ *iEventObserver,
+ screen.Size() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineDialerControlOptions
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptions CVtUiAppUi::DetermineDialerControlOptions()
+ {
+ MVtUiDialer* dialer = static_cast< CVtUiDialer* > (
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdDialer ) );
+
+ __ASSERT_ALWAYS( dialer, VtUiPanic::Panic( EVtUiPanicRendererNotFound ) );
+
+ return
+ TVtEngRenderingOptions(
+ *iEventObserver,
+ dialer->VideoControl().Size() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineMainControlOptions
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptionsDSA
+ CVtUiAppUi::DetermineMainControlOptionsDSA( TBool aRemoteVideo )
+ {
+ // Determine main pane options.
+ TRect screen;
+ TRect clip;
+ TAknWindowLineLayout stream;
+ TAknLayoutRect rect;
+ const TBool usesSQCif( aRemoteVideo && iUiStates->IsUseSQCif() );
+ screen = iInstance->iMainControl->Rect();
+ VtUiLayout::GetSecondWindowStreamLayout( stream,
+ iUiStates->IsToolbarAvailable(), usesSQCif );
+ rect.LayoutRect( screen, stream );
+ clip = rect.Rect();
+
+ VtUiLayout::GetSecondWindowStreamWholeLayout( stream,
+ iUiStates->IsToolbarAvailable(), usesSQCif );
+ rect.LayoutRect( screen, stream );
+ screen = rect.Rect();
+
+ return
+ TVtEngRenderingOptionsDSA(
+ *iEventObserver,
+ iEikonEnv->WsSession(),
+ *( iEikonEnv->ScreenDevice() ),
+ *( iInstance->iMainControl->DrawableWindow() ),
+ clip,
+ screen );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineContextControlOptionsDSA
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptionsDSA CVtUiAppUi::DetermineContextControlOptionsDSA()
+ {
+ // Determine context pane options.
+ TRect screen;
+ TRect clip;
+ TAknWindowLineLayout stream;
+ TAknLayoutRect rect;
+
+ VtUiLayout::GetApplicationParentRect( screen );
+ VtUiLayout::GetFirstWindowBackgroundLayout( stream );
+ rect.LayoutRect( screen, stream );
+ TRect background = rect.Rect();
+
+ VtUiLayout::GetFirstWindowStreamLayout( stream );
+ rect.LayoutRect( screen, stream );
+
+ // No cropping is performed, thus clip == screen.
+ clip = rect.Rect();
+ clip.iTl -= background.iTl;
+ clip.iBr -= background.iTl;
+
+ screen = clip;
+
+ return
+ TVtEngRenderingOptionsDSA(
+ *iEventObserver,
+ iEikonEnv->WsSession(),
+ *( iEikonEnv->ScreenDevice() ),
+ *( iInstance->iContextControl->DrawableWindow() ),
+ screen,
+ clip );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineDialerControlOptionsDSA
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptionsDSA CVtUiAppUi::DetermineDialerControlOptionsDSA()
+ {
+ MVtUiDialer* dialer = static_cast< CVtUiDialer* > (
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdDialer ) );
+
+ __ASSERT_ALWAYS( dialer, VtUiPanic::Panic( EVtUiPanicRendererNotFound ) );
+
+ CCoeControl& videoWindow( dialer->VideoControl() );
+
+ return
+ TVtEngRenderingOptionsDSA(
+ *iEventObserver,
+ iEikonEnv->WsSession(),
+ *( iEikonEnv->ScreenDevice() ),
+ *( videoWindow.DrawableWindow() ),
+ videoWindow.Rect(),
+ videoWindow.Rect() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineMainControlOptionsDP
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptionsDP
+ CVtUiAppUi::DetermineMainControlOptionsDP( TBool aRemoteVideo )
+ {
+ // Determine main pane options.
+ const TRect screen( iInstance->iMainControl->Rect() );
+ TAknWindowLineLayout stream;
+ const TBool usesSQCif( aRemoteVideo && iUiStates->IsUseSQCif() );
+
+ // Even if the name is whole layout, this layout is (due to problem
+ // in layouts) video stream layout
+ TAknLayoutRect whole;
+ VtUiLayout::GetSecondWindowStreamWholeLayout( stream,
+ iUiStates->IsToolbarAvailable(), usesSQCif );
+ whole.LayoutRect( screen, stream );
+
+ // Even if the name is actual layout, this layout is (due to problem
+ // in layouts) whole == clipping layout
+ TAknLayoutRect actual;
+ VtUiLayout::GetSecondWindowStreamLayout( stream,
+ iUiStates->IsToolbarAvailable(), usesSQCif );
+ actual.LayoutRect( screen, stream );
+
+ return
+ TVtEngRenderingOptionsDP(
+ *iEventObserver,
+ iEikonEnv->WsSession(),
+ *( iEikonEnv->ScreenDevice() ),
+ *( iInstance->iMainControl->DrawableWindow() ),
+ actual.Rect(),
+ whole.Rect(),
+ iInstance->iMainControl->PositionRelativeToScreen() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineContextControlOptionsDP
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptionsDP CVtUiAppUi::DetermineContextControlOptionsDP()
+ {
+ // Determine context pane options.
+ TAknWindowLineLayout stream;
+ TAknLayoutRect rect;
+
+ TRect screen;
+ VtUiLayout::GetApplicationParentRect( screen );
+ VtUiLayout::GetFirstWindowBackgroundLayout( stream );
+ rect.LayoutRect( screen, stream );
+ const TRect background( rect.Rect() );
+
+ VtUiLayout::GetFirstWindowStreamLayout( stream );
+ rect.LayoutRect( screen, stream );
+
+ // No cropping is performed, thus clip == screen.
+ TRect clip( rect.Rect() );
+ clip.iTl -= background.iTl;
+ clip.iBr -= background.iTl;
+
+ return
+ TVtEngRenderingOptionsDP(
+ *iEventObserver,
+ iEikonEnv->WsSession(),
+ *( iEikonEnv->ScreenDevice() ),
+ *( iInstance->iContextControl->DrawableWindow() ),
+ clip,
+ clip,
+ iInstance->iContextControl->PositionRelativeToScreen() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineDialerControlOptionsDP
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptionsDP CVtUiAppUi::DetermineDialerControlOptionsDP()
+ {
+ MVtUiDialer* dialer = static_cast< CVtUiDialer* > (
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdDialer ) );
+
+ __ASSERT_ALWAYS( dialer, VtUiPanic::Panic( EVtUiPanicRendererNotFound ) );
+
+ CCoeControl& videoWindow( dialer->VideoControl() );
+
+ TPoint offs( videoWindow.DrawableWindow()->AbsPosition() );
+ TRect rect( videoWindow.Rect() );
+ return
+ TVtEngRenderingOptionsDP(
+ *iEventObserver,
+ iEikonEnv->WsSession(),
+ *( iEikonEnv->ScreenDevice() ),
+ *( videoWindow.DrawableWindow() ),
+ rect,
+ rect,
+ offs );
+ }
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DetermineRemoteVideoControlOptionsNGA
+// -----------------------------------------------------------------------------
+//
+TVtEngRenderingOptionsNGA
+ CVtUiAppUi::DetermineRemoteVideoControlOptionsNGA()
+ {
+ return TVtEngRenderingOptionsNGA( *iEventObserver,
+ iInstance->iRemoteVideoControl ->GetRWindow() , iEikonEnv->WsSession());
+ }
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ExecuteCmdL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ExecuteCmdL( const TVtEngCommandId aCommand )
+ {
+ DoExecuteCmdL( aCommand, NULL );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ExecuteCmdL
+// -----------------------------------------------------------------------------
+//
+template< class T >
+void CVtUiAppUi::ExecuteCmdL(
+ const TVtEngCommandId aCommand,
+ T& aParam )
+ {
+ TPtrC8 params( reinterpret_cast< TUint8* >( &aParam ), sizeof( T ) );
+ DoExecuteCmdL( aCommand, ¶ms );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoExecuteCmdL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::DoExecuteCmdL(
+ const TVtEngCommandId aCommand,
+ TDesC8* aParams )
+ {
+ __VTPRINT2( DEBUG_GEN, "VtUi.DoExec.cmd=%d", aCommand )
+ MVtEngCommandHandler& command = Model().CommandHandler();
+ const TInt caps = command.GetCommandCaps( aCommand );
+
+ if ( caps >= KErrNone )
+ {
+ const TBool asynchronous =
+ ( caps & MVtEngCommandHandler::EAttribAsync );
+
+ if ( asynchronous )
+ {
+ if ( aCommand == KVtEngHandleLayoutChange )
+ {
+ CVtEngCmdExec* cmdExec = CVtEngCmdExec::NewL(
+ Model().CommandHandler(), *iEventObserver, *GetCba() );
+ cmdExec->ExecuteCmdLD( aCommand );
+ }
+ else
+ {
+ CVtUiExecuteCmdDialog* dlg =
+ new ( ELeave ) CVtUiExecuteCmdDialog(
+ NULL,
+ Model().CommandHandler(),
+ *iEventObserver );
+ dlg->ExecuteCmdLD( aCommand, aParams, NULL );
+ }
+ }
+ else
+ {
+ command.ExecuteL( aCommand, aParams );
+ RefreshStatesL();
+ }
+ }
+ else
+ {
+ // Failed.
+ User::Leave( caps );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleShutdownReady
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleShutdownReady()
+ {
+ __VTPRINTENTER( "VtUi.HandleShutdownReady" )
+
+ if(iAsyncCallback->IsActive())
+ {
+ iAsyncCallback->Cancel();
+ }
+
+ iAsyncCallback->Set(
+ TCallBack( &DoExit, this ) );
+ iAsyncCallback->CallBack();
+ __VTPRINTEXIT( "VtUi.HandleShutdownReady" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ContextControl
+// -----------------------------------------------------------------------------
+//
+CVtUiContextControl& CVtUiAppUi::ContextControl()
+ {
+ __VTPRINTENTER( "VtUi.ContextControl" )
+ __VTPRINTEXIT( "VtUi.ContextControl" )
+ return *iInstance->iContextControl;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::MainControl
+// -----------------------------------------------------------------------------
+//
+CVtUiMainControl& CVtUiAppUi::MainControl()
+ {
+ __VTPRINTENTER( "VtUi.MainControl" )
+ __VTPRINTEXIT( "VtUi.MainControl" )
+ return *iInstance->iMainControl;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RemoteVideoControl
+// -----------------------------------------------------------------------------
+//
+CVtUiRemoteVideoControl& CVtUiAppUi::RemoteVideoControl()
+ {
+ __VTPRINTENTER( "VtUi.RemoteVideoControl" )
+ __VTPRINTEXIT( "VtUi.RemoteVideoControl" )
+ return *iInstance->iRemoteVideoControl;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoExit
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::DoExit( TAny* aAppUi )
+ {
+ __VTPRINTENTER( "VtUi.DoExit" )
+ CVtUiAppUi* self = static_cast< CVtUiAppUi* >( aAppUi );
+ self->iAsyncCallback->Cancel();
+ // Before exiting ensure there are no pending actions.
+ self->ActiveExecInitCancel( 0 );
+ self->Exit();
+ __VTPRINTEXIT( "VtUi.DoExit" )
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ExecuteCmdAsyncL
+// -----------------------------------------------------------------------------
+//
+CEikDialog* CVtUiAppUi::ExecuteCmdAsyncL(
+ CEikDialog** aDialogPtr,
+ const TVtEngCommandId aCommand,
+ TRequestStatus& aStatus )
+ {
+ return DoExecuteCmdAsyncL( aDialogPtr, aCommand, NULL, aStatus );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ExecuteCmdAsyncL
+// -----------------------------------------------------------------------------
+//
+template< class T >
+CEikDialog* CVtUiAppUi::ExecuteCmdAsyncL(
+ CEikDialog** aDialogPtr,
+ const TVtEngCommandId aCommand,
+ T& aParam,
+ TRequestStatus& aStatus )
+ {
+ TPtrC8 params( reinterpret_cast< TUint8* >( &aParam ), sizeof( T ) );
+ return DoExecuteCmdAsyncL( aDialogPtr, aCommand, ¶ms, aStatus );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoExecuteCmdAsyncL
+// -----------------------------------------------------------------------------
+//
+CEikDialog* CVtUiAppUi::DoExecuteCmdAsyncL(
+ CEikDialog** aDialogPtr,
+ const TVtEngCommandId aCommand,
+ TDesC8* aParams,
+ TRequestStatus& aStatus )
+ {
+ __VTPRINT2( DEBUG_GEN, "VtUi.DoExecAsync.cmd=%d", aCommand )
+ MVtEngCommandHandler& command = Model().CommandHandler();
+ const TInt caps = command.GetCommandCaps( aCommand );
+
+ if ( caps >= KErrNone )
+ {
+ const TBool asynchronous =
+ ( caps & MVtEngCommandHandler::EAttribAsync );
+
+ if ( asynchronous )
+ {
+ CVtUiExecuteCmdDialog* dlg =
+ new ( ELeave ) CVtUiExecuteCmdDialog(
+ aDialogPtr,
+ Model().CommandHandler(),
+ *iEventObserver );
+ dlg->ExecuteCmdLD( aCommand, aParams, &aStatus );
+ return dlg;
+ }
+ else
+ {
+ command.ExecuteL( aCommand, aParams );
+ RefreshStatesL();
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, KErrNone );
+ }
+ }
+ else
+ {
+ // Failed.
+ User::Leave( caps );
+ }
+
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::Execute
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::Execute( const TVtEngCommandId aCommand, TDesC8* aParam )
+ {
+ MVtEngCommandHandler& command = Model().CommandHandler();
+ TRAPD( err, command.ExecuteL( aCommand, aParam ) );
+#ifdef VTDEBUG
+ if ( err != KErrNone )
+ {
+ __VTPRINT3( DEBUG_GEN, "VtUi.Execute.Nok.cmd=%d,err=%d", aCommand, err )
+ }
+#endif // VTDEBUG
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleForegroundChangedL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleForegroundChangedL(
+ TBool aIsForeground )
+ {
+ __VTPRINTENTER( "VtUi.HandleForegroundChangedL" )
+ __VTPRINT2( DEBUG_GEN, "VtUi.foreground=%d", (TInt) aIsForeground )
+
+
+ // Let the Engine know that Application's foregorund
+ // has changed. Then Engine can do some initalize/uninitalize
+ // before rendering due to the foreground state.
+ iState->PreHandleForegroundChangedL(aIsForeground);
+
+ // These operations must be done before
+ // sending KVtEngSetUIForeground command to engine i.e. calling
+ // iState->HandleForegroundChangedL( aIsForeground )
+ if ( !aIsForeground )
+ {
+ // if capture mode is on stop it
+ if ( iUiStates->IsCaptureModeOn() )
+ {
+ CmdCancelCaptureL();
+ }
+ // if brightness or contrast feature is active stop those
+ MVtUiFeature* br = iFeatureManager->GetFeatureById( EVtUiFeatureIdBrightness );
+ if ( br )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.HandleForegroundChangedL br" )
+ if ( br->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.HandleForegroundChangedL br->STOP" )
+ br->Stop();
+ }
+ }
+
+ MVtUiFeature* cr = iFeatureManager->GetFeatureById( EVtUiFeatureIdContrast );
+ if ( cr )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.HandleForegroundChangedL cr" )
+ if ( cr->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.HandleForegroundChangedL cr->STOP" )
+ cr->Stop();
+ }
+ }
+
+ }
+
+ TBool foregroundAndReady = EFalse;
+ if ( iState )
+ {
+ foregroundAndReady = iState->HandleForegroundChangedL( aIsForeground );
+ iUiStates->SetThisApplicationForeground( aIsForeground );
+ }
+ if ( foregroundAndReady )
+ {
+ // Refresh navi pane. This will start call duration updating
+ // if necessary.
+ RefreshNaviPaneL();
+ }
+ else if ( !aIsForeground )
+ {
+
+
+ iEventObserver->StopBeat();
+ }
+ SetIncallBubbleAllowedInUsualL( !foregroundAndReady );
+ __VTPRINTEXIT( "VtUi.HandleForegroundChangedL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshL( const TInt aRefreshFlags )
+ {
+ if ( aRefreshFlags & EUiStates )
+ {
+ RefreshNaviPaneL();
+ }
+ if ( aRefreshFlags & EBlind )
+ {
+ RefreshBlind();
+ }
+ if ( aRefreshFlags & ENaviPane )
+ {
+ RefreshNaviPaneL();
+ }
+ if ( aRefreshFlags & ESoftkeys )
+ {
+ RefreshSoftkeysL();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleEngineResetL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleEngineResetL()
+ {
+ __VTPRINTENTER( "VtUi.HandleEngineResetL" )
+ if ( iShutdownRequest )
+ {
+ __VTPRINT( DEBUG_GEN, " VtUi.HandleEngineResetL shutdown" )
+ User::RequestComplete( iShutdownRequest, KErrNone );
+ iShutdownRequest = NULL;
+ }
+ __VTPRINTEXIT( "VtUi.HandleEngineResetL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::StopWaitingImage
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::StopWaitingImage()
+ {
+ if ( iInstance )
+ {
+ iDownlinkWindow->SetWaiting( EFalse );
+ iUiStates->SetWaitingForFirstFrame( EFalse );
+ RemoteVideoControl().MakeVisible(ETrue);
+ }
+ }
+
+void CVtUiAppUi::StopWhiteBalanceOrColortone()
+ {
+ if( iEventObserver )
+ {
+ MVtEngMedia::TCameraId currentCamId;
+ //CVtEngMediaHandler& mediaHandler = iEventObserver->Model().Media();
+ ///mediaHandler.GetCurrentCameraId( currentCamId );
+ iEventObserver->Model().Media().GetCurrentCameraId( currentCamId );
+ __VTPRINT2( DEBUG_GEN, " CVtUiAppUi::StopWhiteBalance currentCamId is %d", currentCamId);
+
+ CVtUiWhiteBalance* wb = static_cast< CVtUiWhiteBalance* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdWhiteBalance ) );
+ CVtUiColorTone* ct = static_cast< CVtUiColorTone* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdColourTone ) );
+
+ // only when the current camera switch to the Primary to stop the wb
+ if( currentCamId == MVtEngMedia::EPrimaryCamera )
+ {
+
+ if( wb && ( wb->State() == MVtUiFeature::EActive ) )
+ {
+
+ wb->Stop();
+ }
+
+ if( ct && ( ct->State() == MVtUiFeature::EActive ) )
+ {
+ ct->Stop();
+ }
+
+ return;
+ }
+ if( currentCamId == MVtEngMedia::ESecondaryCamera )
+ {
+ if( wb->IsPendingCmd() )
+ wb->HandlePendingCmdL();
+ if( ct->IsPendingCmd() )
+ ct->HandlePendingCmdL();
+ }
+ }
+ }
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleLayoutChanged
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::HandleLayoutChanged()
+ {
+ iLayoutChangeCallback->CallBack();
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DelayedHandleLayoutChanged
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::DelayedHandleLayoutChanged( TAny* aPtr )
+ {
+ CVtUiAppUi* self = reinterpret_cast< CVtUiAppUi* > ( aPtr );
+ self->iUiStates->SetDisableBlindSetting( ETrue );
+ TRAPD( err, self->HandleLayoutChangedL() );
+ self->iUiStates->SetDisableBlindSetting( EFalse );
+ self->RefreshBlind();
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleLayoutChangedL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleLayoutChangedL()
+ {
+ __VTPRINTENTER( "VtUi.LayoutChg" )
+ if ( iState )
+ {
+ iState->HandleLayoutChangedL();
+ }
+ __VTPRINTEXIT( "VtUi.LayoutChg" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoHandleLayoutChangedL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::DoHandleLayoutChangedL()
+ {
+ __VTPRINTENTER( "VtUi.DoLayoutChg" )
+ // Fully update rendering parameters
+ UpdateRenderingParametersL();
+ // Notify engine about layout change
+ iLayoutChg = ETrue;
+ TRAPD( error, ExecuteCmdL( KVtEngHandleLayoutChange ) );
+ iLayoutChg = EFalse;
+
+ // Not ready error is allowed to happen (e.g. when sharing)
+ if ( error && ( error != KErrNotReady ) )
+ {
+ User::Leave( error );
+ }
+ else
+ {
+ __VTPRINT( DEBUG_GEN,
+ "VtUi.DoLayoutChg KVtEngHandleLayoutChange == KErrNotReady (ok)" )
+ TVtEngCommandId pendingCommand = Model().CommandHandler().PendingCommand();
+ if ( pendingCommand == KVtEngMuteOutgoingAudio ||
+ pendingCommand == KVtEngUnmuteOutgoingAudio ||
+ pendingCommand == KVtEngSetAudioRouting ||
+ pendingCommand == KVtEngSetAudioVolume ||
+ pendingCommand == KVtEngSetSource ||
+ pendingCommand == KVtEngPrepareCamera ||
+ pendingCommand == KVtEngUnfreeze )
+ {
+ iUiStates->SetLayoutChangeNeeded( ETrue );
+ }
+ }
+ // Notify component manager
+ iComponentManager->HandleLayoutChangeL();
+ MVtUiFeature* dialer =
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdDialer );
+ const TBool dialerActive( dialer &&
+ ( dialer->State() == MVtUiFeature::EActive ) );
+ SwitchLayoutToFlatStatusPaneL( dialerActive );
+
+ // Update the cam's whiteBalance and colorTone cause layoutchange will renew the camera,so
+ // restore the last user setting
+ UpdateVBSettingL();
+
+
+ if ( iDelayedCmd != 0 )
+ {
+ __VTPRINT2( DEBUG_GEN, "VtUi.DoLayoutChg reexecute the delayed cmd=%d", iDelayedCmd);
+ HandleCommandL( iDelayedCmd );
+ iDelayedCmd = 0;
+ }
+ __VTPRINTEXIT( "VtUi.DoLayoutChg" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleVideoFrameL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleVideoFrameL(
+ const TBool aLocal,
+ CFbsBitmap* aBitmap )
+ {
+ if ( aLocal )
+ {
+ iUplinkWindow->SetStreamBitmap( aBitmap );
+
+ if ( aBitmap )
+ {
+ // If white balance or color tone setting feauture is
+ // active update feature's setting page's background.
+ CVtUiWhiteBalance* wb = static_cast< CVtUiWhiteBalance* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdWhiteBalance ) );
+
+ CVtUiColorTone* ct = static_cast< CVtUiColorTone* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdColourTone ) );
+
+ if ( wb )
+ {
+ __VTPRINT( DEBUG_GEN,"VtUi.HandleVideoFrameL WB" )
+ if ( wb->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN,"VtUi.HandleVideoFrameL WB update" )
+ wb->UpdateBackground( aBitmap );
+ }
+ }
+ if ( ct )
+ {
+ __VTPRINT( DEBUG_GEN,"VtUi.HandleVideoFrameL CT" )
+ if (ct->State() == MVtUiFeature::EActive)
+ {
+ __VTPRINT( DEBUG_GEN,"VtUi.HandleVideoFrameL CT update" )
+ ct->UpdateBackground( aBitmap );
+ }
+ }
+ }
+ }
+ else
+ {
+ iDownlinkWindow->SetStreamBitmap( aBitmap );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetVideoFrame
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetVideoFrame(
+ const TBool aLocal,
+ CFbsBitmap* aBitmap )
+ {
+ if ( aLocal )
+ {
+ }
+ else
+ {
+ iDownlinkWindow->SetStreamBitmapReserve( aBitmap );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleVideoFrameRemoteProblemL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleVideoFrameRemoteProblemL()
+ {
+ __VTPRINTENTER( "VtUi.HandleRemote" )
+ HandleVideoFrameL( EFalse, NULL );
+ __VTPRINTEXIT( "VtUi.HandleRemote" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleVideoFrameLocalProblemL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleVideoFrameLocalProblemL()
+ {
+ __VTPRINTENTER( "VtUi.HandleLocal" )
+ // Camera might have changed - better to stop zoom.
+ HandleVideoFrameL( ETrue, NULL );
+ __VTPRINTEXIT( "VtUi.HandleLocal" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RemoteVideoIsSQCif
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RemoteVideoIsSQCif( TBool aIsSQCif )
+ {
+ iUiStates->SetUseSQCif( aIsSQCif );
+ if ( iDownlinkWindow == iInstance->iMainControl )
+ {
+ ControlUsesSQCif( aIsSQCif );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ControlUsesSQCif
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ControlUsesSQCif( TBool aIsSQCif )
+ {
+ iInstance->iMainControl->SupportSQCif( aIsSQCif );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ChangeRemoteVideoLayoutL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ChangeRemoteVideoLayoutL()
+ {
+ HandleLayoutChanged();
+ if ( iDownlinkWindow == iInstance->iMainControl )
+ {
+ iDownlinkWindow->SetBlind( EFalse );
+ StopWaitingImage();
+ iInstance->iMainControl->DrawNow();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowImageInitializeProgressL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowImageInitializeProgressL()
+ {
+ __VTPRINTENTER( "VtUi.ShowImageInitializeProgressL" )
+ ShowProgressDialogL( R_PROGRESS_DECODING_IMAGE_WAIT_NOTE, this );
+ __VTPRINTEXIT( "VtUi.ShowImageInitializeProgressL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HideImageInitializeProgressL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HideImageInitializeProgressL()
+ {
+ __VTPRINTENTER( "VtUi.HideImageInitializeProgressL" )
+ // if volume slider is visible hide it
+ CVtUiVolume* volume = static_cast< CVtUiVolume* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdVolume ) );
+ if ( volume )
+ {
+ volume->Stop();
+ }
+ HideProgressDialogL();
+ __VTPRINTEXIT( "VtUi.HideImageInitializeProgressL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CheckBeatL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CheckBeatL( const TBool aCallDurationEnabled )
+ {
+ // Update call duration periodically if necessary.
+ const MVtEngSessionInfo::TSessionState state = Model().Session().State( EFalse );
+ const TBool timerEnable =
+ ( aCallDurationEnabled ) &&
+ ( ( state == MVtEngSessionInfo::EConnected ) ||
+ ( state == MVtEngSessionInfo::ENegotiating ) ||
+ ( state == MVtEngSessionInfo::EOpen ) );
+
+ if ( timerEnable && iUiStates->IsThisApplicationForeground() )
+ {
+ iEventObserver->StartBeatL();
+ }
+ else
+ {
+ iEventObserver->StopBeat();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleBeat
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleBeat()
+ {
+ TRAP_IGNORE( RefreshNaviPaneL(); );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowCameraInUseNoteL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowCameraInUseNoteL() const
+ {
+ // The note must not be blocking.
+
+ CAknNoteDialog* dlg = new ( ELeave ) CAknNoteDialog( NULL );
+
+ dlg->PrepareLC( R_VIDEOTELUI_INFORMATION_NOTE );
+ dlg->ButtonGroupContainer().SetCommandSetL( R_AVKON_SOFTKEYS_OK_EMPTY );
+
+ HBufC* buf = StringLoader::LoadLC( R_VIDEOTELUI_QTN_INCAL_CLOSE_CAMCORDER );
+ dlg->SetTextL( *buf );
+ CleanupStack::PopAndDestroy( buf );
+
+ dlg->SetTone( CAknNoteDialog::EConfirmationTone );
+ dlg->SetTimeout( CAknNoteDialog::EUndefinedTimeout );
+ dlg->RunLD();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowNotAllowedNoteL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowNotAllowedNoteL() const
+ {
+ HBufC* prompt =
+ StringLoader::LoadLC(
+ R_VIDEOTELUI_TEXT_NOT_ALLOWED );
+
+ CAknInformationNote* note =
+ new ( ELeave ) CAknInformationNote( ETrue );
+ note->ExecuteLD( *prompt );
+ CleanupStack::PopAndDestroy( prompt );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowCallNotAllowedNoteL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowCallNotAllowedNoteL() const
+ {
+ HBufC* prompt =
+ StringLoader::LoadLC(
+ R_VIDEOTELUI_TEXT_CALL_NOT_ALLOWED );
+
+ CAknInformationNote* note =
+ new ( ELeave ) CAknInformationNote( ETrue );
+ note->ExecuteLD( *prompt );
+ CleanupStack::PopAndDestroy( prompt );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowOtherCameraNotUsableNoteL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowOtherCameraNotUsableNoteL() const
+ {
+ HBufC* prompt =
+ StringLoader::LoadLC(
+ R_VIDEOTELUI_QTN_ERR_CAM_SWAP );
+
+ CAknInformationNote* note =
+ new ( ELeave ) CAknInformationNote( ETrue );
+ note->ExecuteLD( *prompt );
+ CleanupStack::PopAndDestroy( prompt );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowUnableToOpenNoteL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowUnableToOpenNoteL() const
+ {
+ HBufC* prompt =
+ StringLoader::LoadLC(
+ R_VIDEOTELUI_QTN_ERR_UNABLE_TO_OPEN_IMAGE );
+ CAknInformationNote* note =
+ new ( ELeave ) CAknInformationNote( ETrue );
+ note->ExecuteLD( *prompt );
+ CleanupStack::PopAndDestroy( prompt );
+ }
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowImageDecodingErrorNoteL()
+ {
+ HBufC* prompt =
+ StringLoader::LoadLC(
+ R_VIDEOTELUI_QTN_INCAL_NOTE_DECODING_FAILED );
+ CAknInformationNote* note =
+ new ( ELeave ) CAknInformationNote( ETrue );
+ note->ExecuteLD( *prompt );
+ CleanupStack::PopAndDestroy( prompt );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowDRMNotAllowedNoteL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowDRMNotAllowedNoteL() const
+ {
+ HBufC* prompt =
+ StringLoader::LoadLC(
+ R_VIDEOTELUI_QTN_ERR_DRM_NOT_ALLOWED );
+ CAknInformationNote* note =
+ new ( ELeave ) CAknInformationNote( ETrue );
+ note->ExecuteLD( *prompt );
+ CleanupStack::PopAndDestroy( prompt );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetSoftkeysL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetSoftkeysL( const TInt aSoftkeyResourceId )
+ {
+ if ( iCurrentSoftkeys != aSoftkeyResourceId )
+ {
+ if ( iCba )
+ {
+ iCba->SetCommandSetL( aSoftkeyResourceId );
+ iCba->DrawNow();
+ }
+ iCurrentSoftkeys = aSoftkeyResourceId;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetHiddenL
+// Makes application visible / invisible in fast swap window.
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetHiddenL(
+ const TBool aHidden )
+ {
+ CEikonEnv* eikonEnv = iEikonEnv;
+ CApaWindowGroupName* windowGroupName =
+ CApaWindowGroupName::NewLC(
+ eikonEnv->WsSession(),
+ iThisApplicationWgId );
+ windowGroupName->SetHidden( aHidden );
+ User::LeaveIfError(
+ windowGroupName->SetWindowGroupName(
+ eikonEnv->RootWin() ) );
+ CleanupStack::PopAndDestroy( windowGroupName );
+
+ // Update application UID.
+ TUid applicationUid = KVtUiAppUid;
+ if ( aHidden )
+ {
+ applicationUid.iUid = KVtUiTelephoneUid.iUid;
+ }
+ __VTPRINT2( DEBUG_GEN, "VtUi.SetHiddenL applicationUid.iUid=%x",
+ applicationUid.iUid )
+ // Set application that is "default top application"
+ TInt originalTopAppUid = 0;
+ TInt err = RProperty::Get(
+ KPSUidUikon,
+ KUikVideoCallTopApp,
+ originalTopAppUid );
+ __VTPRINT3( DEBUG_GEN, "VtUi.SetHiddenL orig. topApp=%x, err=%d",
+ originalTopAppUid, err )
+ if ( originalTopAppUid != applicationUid.iUid &&
+ iUiStates->IsDetailsReceived() )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.SetHiddenL Do write KUikVideoCallTopApp" )
+ // Update key only if differs from original value and call
+ // has been answered
+ RProperty::Set(
+ KPSUidUikon,
+ KUikVideoCallTopApp,
+ applicationUid.iUid );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetCallIdL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetCallIdL( const TInt aCallId )
+ {
+ HBufC* titlePane =
+ StringLoader::LoadLC( R_VIDEOTELUI_QTN_CALL_NUMBER_VIDEO, aCallId );
+ TPtr ptr = titlePane->Des();
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );
+ TitlePaneL()->SetText( titlePane );
+ CleanupStack::Pop( titlePane );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetCallNameL
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::SetCallNameL( const TDesC& aName )
+ {
+ HBufC* nameBuf = aName.Alloc();
+ if ( nameBuf )
+ {
+ TPtr ptr = nameBuf->Des();
+ AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );
+ TitlePaneL()->SetText( nameBuf );
+ }
+
+ return ( nameBuf != NULL );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::BringTelephoneForeground
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::BringTelephoneToForeground()
+ {
+ __VTPRINTENTER( "VtUi.BringTelephoneToForeground" )
+ // If Telephone application is running, then
+ // bring it to the foreground.
+ const TInt windowGroupId = TelephoneApplicationWgId();
+ if ( windowGroupId )
+ {
+ CEikonEnv* eikonEnv = iEikonEnv;
+ TApaTask task( eikonEnv->WsSession() );
+ task.SetWgId( windowGroupId );
+ task.BringToForeground();
+ }
+
+ // In any case, send this application to the background.
+ ChangeApplicationFocus( EFalse );
+ __VTPRINTEXIT( "VtUi.BringTelephoneToForeground" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ChangeApplicationFocus
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ChangeApplicationFocus( const TBool aForeground )
+ {
+ __VTPRINTENTER( "VtUi.ChangeApplicationFocus" )
+ CEikonEnv* eikonEnv = iEikonEnv;
+ TApaTask task( eikonEnv->WsSession() );
+ task.SetWgId( iThisApplicationWgId );
+ if ( !aForeground )
+ {
+ task.SendToBackground();
+ }
+ else if ( !iUiStates->IsDeviceLockOn() )
+ {
+ task.BringToForeground();
+ }
+ __VTPRINTEXIT( "VtUi.ChangeApplicationFocus" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::TelephoneApplicationWgId
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::TelephoneApplicationWgId()
+ {
+ TInt resultWgId = 0;
+
+ TApaTaskList taskList( iEikonEnv->WsSession() );
+ TInt appUid = 0;
+
+ // Try first Telephone application.
+ if ( RProperty::Get(
+ KPSUidTelInformation,
+ KTelPhoneUid,
+ appUid ) == KErrNone )
+ {
+ TApaTask task = taskList.FindApp( TUid::Uid( appUid ) );
+ if ( task.Exists() )
+ {
+ resultWgId = task.WgId();
+ }
+ }
+
+ // Then Idle application.
+ if ( !resultWgId &&
+ ( RProperty::Get(
+ KPSUidAiInformation,
+ KActiveIdleUid,
+ appUid ) == KErrNone ) )
+ {
+ TApaTask task = taskList.FindApp( TUid::Uid( appUid ) );
+ if ( task.Exists() )
+ {
+ resultWgId = task.WgId();
+ }
+ }
+
+ return resultWgId;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowNumberEntry
+// -----------------------------------------------------------------------------
+//
+inline TBool CVtUiAppUi::ShowNumberEntry() const
+ {
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::IsActiveIdleEnabledL
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::IsActiveIdleEnabledL() const
+ {
+ TVtUiActiveIdleVariation activeIdleVariation;
+ return activeIdleVariation.IsActiveIdleEnabled();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CheckEngineFunctionality
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CheckEngineFunctionality()
+ {
+ const TBool prepareViewFinder =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngPrepareViewFinder );
+ const TBool prepareRemoteRender =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngPrepareRemoteRender );
+ const TBool prepareRemoteRenderDSA =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngPrepareRemoteRenderDSA );
+ const TBool prepareRemoteRenderDP =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngPrepareRemoteRenderDP );
+ const TBool stopViewFinder =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngStopViewFinder );
+ const TBool startViewFinder =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngStartViewFinder );
+ const TBool stopRemoteRender =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngStopRenderRemote );
+ const TBool startRemoteRender =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngStartRenderRemote );
+ const TBool setUIForeground =
+ iEventObserver->CommandSupportedAndSynchronous(
+ KVtEngSetUIForeground );
+
+ TVtUiDPVariation dpvariation;
+ TBool dpSupported( dpvariation.IsDPSupported() );
+
+ if ( !prepareViewFinder ||
+ ( !prepareRemoteRender && !prepareRemoteRenderDSA && !dpSupported ) ||
+ ( !prepareRemoteRender && !prepareRemoteRenderDP && dpSupported ) ||
+ !stopViewFinder ||
+ !startViewFinder ||
+ !stopRemoteRender ||
+ !startRemoteRender ||
+ !setUIForeground )
+ {
+ // Not supported - should never occur.
+ __VTPRINT( DEBUG_GEN, "VtUi.EngineFunc.ASSERT" )
+ VtUiPanic::Panic( EVtUiPanicEngineFunctionalityAssert );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::Model
+// -----------------------------------------------------------------------------
+//
+CVtEngModel& CVtUiAppUi::Model()
+ {
+ return iEventObserver->Model();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::VideoTelephonyVariation
+// -----------------------------------------------------------------------------
+//
+const TVtUiVideoTelephonyVariation& CVtUiAppUi::VideoTelephonyVariation() const
+ {
+ return iVTVariation;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::NumberSource
+// -----------------------------------------------------------------------------
+//
+MVtUiNumberSource* CVtUiAppUi::NumberSource() const
+ {
+ return iNumberSource;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::NaviPaneL
+// -----------------------------------------------------------------------------
+//
+inline CAknNavigationControlContainer* CVtUiAppUi::NaviPaneL()
+ {
+ return
+ static_cast< CAknNavigationControlContainer* >
+ ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::TitlePaneL
+// -----------------------------------------------------------------------------
+//
+inline CAknTitlePane* CVtUiAppUi::TitlePaneL()
+ {
+ return
+ static_cast< CAknTitlePane* >
+ ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CleanupPushRefreshL
+// -----------------------------------------------------------------------------
+//
+inline void CVtUiAppUi::CleanupPushRefreshL()
+ {
+ CleanupStack::PushL(
+ TCleanupItem( DoRefresh, this ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CleanupPushEnableBlindL
+// -----------------------------------------------------------------------------
+//
+inline void CVtUiAppUi::CleanupPushEnableBlindL()
+ {
+ CleanupStack::PushL(
+ TCleanupItem( DoEnableBlindSetting, this ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::EnableCommandActivatingAndCleanupPushL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::EnableCommandActivatingAndCleanupPushL()
+ {
+ __VTPRINTENTER( "VtUi.EnableCommandActivatingAndCleanupPushL" )
+ // add anyway to cleanup stack to avoid caring about stack balance
+ CleanupStack::PushL(
+ TCleanupItem( DoDisableCommandActivating, this ) );
+ // but in case of consecutive calls on this don't refresh (avoid flicker)
+ const TBool alreadyActivating( iUiStates->IsCommandActivating() );
+ // increases ref.count if alread set as activating
+ iUiStates->SetIsCommandActivating( ETrue );
+ if ( !alreadyActivating )
+ {
+ // refresh only when ref.count incremented from zero.
+ iCommandManager->RefreshL();
+ }
+ __VTPRINTEXIT( "VtUi.EnableCommandActivatingAndCleanupPushL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoDisableCommandActivating
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::DoDisableCommandActivating( TAny* aAny )
+ {
+ CVtUiAppUi* self =
+ reinterpret_cast< CVtUiAppUi* >( aAny );
+ TRAP_IGNORE( self->HandleCommandDeactivationL() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HandleCommandDeactivationL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HandleCommandDeactivationL()
+ {
+ __VTPRINTENTER( "VtUi.HandleCommandDeactivationL" )
+ iUiStates->SetIsCommandActivating( EFalse );
+ if ( !iUiStates->IsCommandActivating() )
+ {
+ RefreshStatesL();
+ }
+ __VTPRINTEXIT( "VtUi.HandleCommandDeactivationL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoEnableBlindSetting
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::DoEnableBlindSetting( TAny* aAny )
+ {
+ CVtUiAppUi* self =
+ reinterpret_cast< CVtUiAppUi* >( aAny );
+ self->iUiStates->SetDisableBlindSetting( EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoRefresh
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::DoRefresh( TAny* aAny )
+ {
+ CVtUiAppUi* self =
+ reinterpret_cast< CVtUiAppUi* >( aAny );
+ TRAP_IGNORE( self->RefreshL() );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DoHandleExitTimeout
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::DoHandleExitTimeout( TAny* /*aAny*/ )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.Exit.Timer.EXPIRED!" )
+ VtUiPanic::Panic( EVtUiPanicApplicationShutdownTimeout );
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// VtUiAppUi::IsViewFinderInMainPane
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::IsViewFinderInMainPane() const
+ {
+ return !( IsViewFinderInContextPane() );
+ }
+
+// -----------------------------------------------------------------------------
+// VtUiAppUi::IsViewFinderInContextPane
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::IsViewFinderInContextPane() const
+ {
+ return ( iUplinkWindow == iInstance->iContextControl );
+ }
+
+// -----------------------------------------------------------------------------
+// VtUiAppUi::SwitchViewFinderToMainPaneL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SwitchViewFinderToMainPaneL( TBool aUpdateState )
+ {
+ __VTPRINTENTER( "VtUi.SwitchViewFinderToMainPaneL" )
+ //change local video in to main pane
+ if( IsViewFinderInContextPane() )
+ {
+ //flag indicates the initial position of uplink window before freeze
+ if ( aUpdateState )
+ {
+ iUiStates->SetViewFindersInitialPlaceContextPane( ETrue );
+ }
+ HandleCommandL( EVtUiCmdSwapImagesPlaces );
+ }
+ else
+ {
+ if ( aUpdateState )
+ {
+ iUiStates->SetViewFindersInitialPlaceContextPane( EFalse );
+ }
+ }
+ __VTPRINTEXIT( "VtUi.SwitchViewFinderToMainPaneL" )
+ }
+
+// -----------------------------------------------------------------------------
+// VtUiAppUi::SwitchViewFinderToContextPaneL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SwitchViewFinderToContextPaneL( TBool aUpdateState )
+ {
+ __VTPRINTENTER( "VtUi.SwitchViewFinderToContextPaneL" )
+ //change local video in to context pane
+ if( !IsViewFinderInContextPane() )
+ {
+ //flag indicates the initial position of uplink window before freeze
+ if ( aUpdateState )
+ {
+ iUiStates->SetViewFindersInitialPlaceContextPane( EFalse );
+ }
+ HandleCommandL( EVtUiCmdSwapImagesPlaces );
+ }
+ else
+ {
+ if ( aUpdateState )
+ {
+ iUiStates->SetViewFindersInitialPlaceContextPane( ETrue );
+ }
+ }
+ __VTPRINTEXIT( "VtUi.SwitchViewFinderToContextPaneL" )
+ }
+
+// -----------------------------------------------------------------------------
+// VtUiAppUi::RestoreViewFinderL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RestoreViewFinderL()
+ {
+ __VTPRINTENTER( "VtUi.RestoreViewFinderL" )
+ if( IsViewFinderInContextPane() )
+ {
+ if( !iUiStates->IsViewFindersInitialPlaceContextPane() )
+ {
+ SwitchViewFinderToMainPaneL( EFalse );
+ }
+ }
+ else
+ {
+ if( iUiStates->IsViewFindersInitialPlaceContextPane() )
+ {
+ SwitchViewFinderToContextPaneL( EFalse );
+ }
+ }
+ __VTPRINTEXIT( "VtUi.RestoreViewFinderL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::DialogDismissedL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::DialogDismissedL( TInt )
+ {
+ __VTPRINTENTER( "VtUi.DialogDismissedL" )
+ MVtUiFeature* tb =
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdToolbar );
+ if ( tb )
+ {
+ if ( !iTbPeriodic )
+ {
+ iTbPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );
+ }
+ iTbPeriodic->Cancel();
+ // try to strat toolbar feature immediately
+ iTbPeriodic->Start( 0, KPeriodTime, TCallBack( DoTryToStartTbL, this ) );
+ }
+ __VTPRINTEXIT( "VtUi.DialogDismissedL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::UpdateContextPaneIconL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::UpdateContextPaneIconL()
+ {
+ CEikStatusPane* statusPane = StatusPane();
+
+ if ( statusPane )
+ {
+ if ( statusPane->PaneCapabilities(
+ TUid::Uid( EEikStatusPaneUidContext ) ).IsPresent() )
+ {
+ CAknContextPane* contextPane = NULL;
+ TRAPD ( err, contextPane = static_cast<CAknContextPane*> (
+ statusPane->ControlL( TUid::Uid( EEikStatusPaneUidContext ) ) ) );
+ if ( err != KErrNone || ! contextPane )
+ {
+ return;
+ }
+
+ // Set a new context pane icon
+ CFbsBitmap* newBitmap = new(ELeave) CFbsBitmap;
+ CleanupStack::PushL( newBitmap );
+ User::LeaveIfError( newBitmap->Create( TSize( 1, 1 ), EGray2 ) );
+
+ CFbsBitmap* newMask = new(ELeave) CFbsBitmap;
+ CleanupStack::PushL( newMask );
+ User::LeaveIfError( newMask->Create( TSize( 1, 1 ), EGray2 ) );
+
+ // create an off-screen device and context
+ CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( newMask );
+ CleanupStack::PushL( bitmapDevice );
+ CFbsBitGc* maskGc = NULL;
+ User::LeaveIfError( bitmapDevice->CreateContext( maskGc ) );
+ User::LeaveIfNull( maskGc );
+ CleanupStack::PushL( maskGc );
+ maskGc->SetPenStyle( CGraphicsContext::ENullPen );
+ maskGc->SetBrushColor( TRgb::Gray2( 1 ) ); // transparency
+ maskGc->SetBrushStyle( CGraphicsContext::ESolidBrush );
+ maskGc->Clear();
+ CleanupStack::PopAndDestroy( 2 ); // maskGc, bitmapDevice
+
+ // newBitmap, new Mask ownership transfer
+ contextPane->SetPicture( newBitmap, newMask );
+ CleanupStack::Pop( 2 ); // newBitmap, newMask
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetIncallBubbleAllowedInUsualL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetIncallBubbleAllowedInUsualL( TBool aAllowed )
+ {
+ __VTPRINT2( DEBUG_GEN, "Ui.SetIncallBubbleAllowedInUsualL: %d", aAllowed )
+
+ // If call is being disconnected, we do not want to show in-call bubble
+ // anymore but dismiss it.
+ if( iUiStates->ExecState() == TVtUiStates::EExecStateResetting ||
+ iUiStates->ExecState() == TVtUiStates:: EExecStateFinalized )
+ {
+ __VTPRINT2( DEBUG_GEN, "Ui.SetIncallBubbleAllowedInUsualL forced to false: %d", aAllowed )
+ aAllowed = EFalse;
+ }
+
+ if ( iIncallBubble )
+ {
+ iIncallBubble->SetIncallBubbleAllowedInUsualL( aAllowed );
+ }
+ __VTPRINT( DEBUG_GEN, "Ui.SetIncallBubbleAllowedInUsualL>" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ShowProgressDialogL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::ShowProgressDialogL( TInt aResourceId,
+ MProgressDialogCallback* aCallback )
+ {
+ __VTPRINTENTER( "VtUi.ShowProgressDialogL" )
+ if( iProgressDlg )
+ {
+ User::Leave( KErrNotReady );
+ }
+ iProgressDlg = new ( ELeave ) CAknProgressDialog(
+ reinterpret_cast< CEikDialog** >( &iProgressDlg ), ETrue );
+ iProgressDlg->SetCallback( aCallback );
+ iProgressDlg->ExecuteLD( aResourceId );
+ __VTPRINTEXIT( "VtUi.ShowProgressDialogL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::HideProgressDialogL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::HideProgressDialogL()
+ {
+ __VTPRINTENTER( "VtUi.HideProgressDialogL" )
+ if( iProgressDlg )
+ {
+ iProgressDlg->ProcessFinishedL();
+ }
+ __VTPRINTEXIT( "VtUi.HideProgressDialogL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::AsyncViewFinderToMainPaneAndShare
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::AsyncViewFinderToMainPaneAndShare( TAny* aPtr )
+ {
+ __VTPRINTENTER( "VtUi.AsyncViewFinderToMainPaneAndShare" )
+ CVtUiAppUi* self = reinterpret_cast< CVtUiAppUi* >( aPtr );
+
+ TRAPD( result, { self->SwitchViewFinderToMainPaneL();
+ self->CmdShareImageL();} );
+ __VTPRINTEXITR( "VtUi.AsyncViewFinderToMainPaneAndShare %d", result )
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::AsyncShare
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::AsyncShare( TAny* aPtr )
+ {
+ __VTPRINTENTER( "VtUi.AsyncShare" )
+ CVtUiAppUi* self = reinterpret_cast< CVtUiAppUi* >( aPtr );
+ TRAPD( result, self->CmdShareImageL() );
+ __VTPRINTEXITR( "VtUi.AsyncShare %d", result )
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::AsyncShowErrorAndRestartShare
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::AsyncShowErrorAndRestartShare( TAny* aPtr )
+ {
+ __VTPRINTENTER( "VtUi.AsyncShowErrorAndRestartShare" )
+ CVtUiAppUi* self = reinterpret_cast< CVtUiAppUi* >( aPtr );
+ TRAPD( result, { self->ShowUnableToOpenNoteL();
+ self->HandleCommandL( EVtUiCmdShareObjectImage ); } );
+ __VTPRINTEXITR( "VtUi.AsyncShowErrorAndRestartShare %d", result )
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::GetCameraOrientations
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::GetCameraOrientations()
+ {
+ __VTPRINTENTER( "VtUi.GetCameraOrientations" )
+ MVtEngMedia& media = Model().Media();
+ media.GetCameraOrientations( iPrimaryCameraOrientation,
+ iSecondaryCameraOrientation );
+ __VTPRINTEXIT( "VtUi.GetCameraOrientations" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetInitialCameraOrientationL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetInitialCameraOrientationL()
+ {
+ __VTPRINTENTER( "VtUi.SetInitialCameraOrientationL" )
+ MVtEngMedia::TCameraId cameraId;
+ MVtEngMedia& media( Model().Media() );
+ media.GetCurrentCameraId( cameraId );
+ MVtEngMedia::TCameraOrientation targetOrientation(
+ cameraId == MVtEngMedia::EPrimaryCamera ?
+ iPrimaryCameraOrientation :
+ ( cameraId == MVtEngMedia::ESecondaryCamera ?
+ iSecondaryCameraOrientation :
+ iCurrentCameraOrientation ) );
+ if ( iCurrentCameraOrientation != targetOrientation )
+ {
+ __VTPRINT3( DEBUG_GEN,
+ "VtUi.SetInitialCameraOrientationL Old=%d New=%d",
+ iCurrentCameraOrientation,
+ targetOrientation )
+ SetOrientationL( engToAppOrientation[ targetOrientation ] );
+ iCurrentCameraOrientation = targetOrientation;
+ }
+ __VTPRINTEXIT( "VtUi.SetInitialCameraOrientationL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::SetCameraOrientationL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::SetCameraOrientationL()
+ {
+ __VTPRINTENTER( "VtUi.SetCameraOrientationL" )
+ MVtEngMedia::TCameraOrientation newOrientation = iCurrentCameraOrientation;
+ MVtEngMedia::TCameraId cameraId;
+ MVtEngMedia& media = Model().Media();
+ if ( media.GetCurrentCameraId( cameraId ) == KErrNone )
+ {
+ switch ( cameraId )
+ {
+ case MVtEngMedia::EPrimaryCamera:
+ __VTPRINT( DEBUG_GEN, "VtUi.SetCameraOrient.Primary")
+ if( iCurrentCameraOrientation != iPrimaryCameraOrientation )
+ {
+ newOrientation = iPrimaryCameraOrientation;
+ }
+ break;
+
+ case MVtEngMedia::ESecondaryCamera:
+ __VTPRINT( DEBUG_GEN, "VtUi.SetCameraOrient.Secondary")
+ if ( iCurrentCameraOrientation != iSecondaryCameraOrientation )
+ {
+ newOrientation = iSecondaryCameraOrientation;
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ __VTPRINT2( DEBUG_GEN, "VtUi.SetCameraOrient.Cur=%d",
+ iCurrentCameraOrientation )
+ __VTPRINT2( DEBUG_GEN, "VtUi.SetCameraOrient.New=%d",
+ newOrientation )
+
+ if ( iCurrentCameraOrientation != newOrientation )
+ {
+ // map camera orientation to appui layout orientation
+ TAppUiOrientation newAppUiOrientation;
+ if ( newOrientation == MVtEngMedia::EOrientationLandscape )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.SetCameraOrient=LS")
+ newAppUiOrientation = EAppUiOrientationLandscape;
+ }
+ else if ( newOrientation == MVtEngMedia::EOrientationPortrait )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.SetCameraOrient=PR")
+ newAppUiOrientation = EAppUiOrientationPortrait;
+ }
+ else
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.SetCameraOrient=OL")
+ newAppUiOrientation = EAppUiOrientationUnspecified;
+ }
+ SetOrientationL( newAppUiOrientation );
+ }
+ __VTPRINTEXIT( "VtUi.SetCameraOrientationL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshStatesL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshStatesL()
+ {
+ __VTPRINTENTER( "VtUi.RefreshStatesL" )
+ // If transaction (set of commands) is pending refresh in delayed until
+ // all of them are processed.
+ if ( !iUiStates->IsCommandActivating() )
+ {
+ iUiStates->Update();
+ if ( iUiStates->IsThisApplicationForeground() )
+ {
+ iCommandManager->RefreshL();
+ }
+ }
+ __VTPRINTEXIT( "VtUi.RefreshStatesL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CmdAdjustVideoL
+// -----------------------------------------------------------------------------
+//
+ void CVtUiAppUi::CmdAdjustVideoL( TInt aCommand )
+ {
+ __VTPRINTENTER( "VtUi.CmdAdjustVideoL" )
+ TInt featureId( -1 );
+ switch ( aCommand )
+ {
+ case EVtUiCmdAdjustVideoVideoQuality:
+ featureId = EVtUiFeatureIdVideoQuality;
+ break;
+ case EVtUiCmdAdjustVideoWhiteBalance:
+ featureId = EVtUiFeatureIdWhiteBalance;
+ break;
+ case EVtUiCmdAdjustVideoBrightness:
+ featureId = EVtUiFeatureIdBrightness;
+ break;
+ case EVtUiCmdAdjustVideoContrast:
+ featureId = EVtUiFeatureIdContrast;
+ break;
+ case EVtUiCmdAdjustVideoColourTone:
+ featureId = EVtUiFeatureIdColourTone;
+ break;
+ default:
+ break;
+ }
+ MVtUiFeature* vb = iFeatureManager->GetFeatureById( featureId );
+ if ( vb )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.CmdAdjustVideoL.StartL" );
+ vb->StartL();
+ }
+ __VTPRINTEXIT( "VtUi.CmdAdjustVideoL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::AppUiInitDoneDoPostInitL
+// -----------------------------------------------------------------------------
+//
+ void CVtUiAppUi::AppUiInitDoneDoPostInitL()
+ {
+ MVtUiFeature* tb = iFeatureManager->GetFeatureById( EVtUiFeatureIdToolbar );
+ if ( tb )
+ {
+ if ( !iTbPeriodic )
+ {
+ iTbPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );
+ }
+ iTbPeriodic->Cancel();
+ // try to strat toolbar feature immediately
+ iTbPeriodic->Start( 0, KPeriodTime, TCallBack( DoTryToStartTbL, this ) );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::ProcessWsEventIfZoomModeIsActiveL
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::ProcessWsEventIfZoomModeIsActiveL( const TWsEvent& aEvent )
+ {
+ __VTPRINTENTER( "VtUi.ProWsEvtIfZoomActivedL" )
+ const TInt type = aEvent.Type();
+ switch( type )
+ {
+ case EEventKey:
+ case EEventKeyUp:
+ case EEventKeyDown:
+ {
+ const TKeyEvent* keyEvent = aEvent.Key();
+
+
+ // Up and down arrow key events does the zooming,
+ // and should be forwarded to appui's key event handler.
+ // Also ETrue must be returned, so that other controls
+ // would not get these key events.
+ TEventCode eventCode = (TEventCode)aEvent.Type();
+ if ( keyEvent->iScanCode == EStdKeyUpArrow ||
+ keyEvent->iScanCode == EStdKeyDownArrow ||
+ keyEvent->iCode == EKeyZoomIn ||
+ keyEvent->iCode == EKeyZoomOut )
+ {
+ HandleKeyEventL( *keyEvent, eventCode );
+ __VTPRINTEXIT( "VtUi.ProWsEvtIfZoomActivedL" )
+ return ETrue;
+ }
+ __VTPRINT( DEBUG_GEN, "VtUi.HandleWsEventL zoom mode set" );
+ // If user selects zoom mode from options menu EEventKeyUp
+ // will be generated after that. Therefore this event must be
+ // ignored. Also EEventKeyDown are ignored. This means that
+ // only EEventKey events can dismiss the zoom mode.
+ if ( type != EEventKeyUp && type != EEventKeyDown )
+ {
+ // If zoom mode is on only zoom mode button is available in
+ // toolbar. Pressing the zoom mode button in toolbar
+ // should not dismiss the zoom mode, that is why this events
+ // are ignored. If toolbar is not available and
+ // also EKeyDevice3 (selection key) event should dismiss
+ // the zoom mode.
+ if ( keyEvent->iCode != EKeyDevice3 ||
+ ( keyEvent->iCode == EKeyDevice3 &&
+ !iUiStates->IsToolbarAvailable() ) )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.ProWsEvtIfZoomActivedL.EKeyDevice3" );
+ SetZoomModeL( EFalse );
+ }
+ }
+ }
+ break;
+
+ case EEventPointer:
+ __VTPRINT( DEBUG_GEN, "VtUi.ProWsEvtIfZoomActivedL.EEventPointer" );
+ break;
+
+ case KAknHardwareLayoutSwitch:
+ // Window server event used when layout changes
+ __VTPRINT( DEBUG_GEN, "VtUi.ProcessWsEventIfZoomModeIsActiveL.LayoutSwitch" );
+ break;
+
+ case EEventScreenDeviceChanged:
+ // The screen size mode has changed, for instance when the cover on a phone
+ // that supports screen flipping is opened or closed.
+ __VTPRINT( DEBUG_GEN, "VtUi.ProcessWsEventIfZoomModeIsActiveL.ScreenChanged" );
+ break;
+
+ case EVtUiWsEventNumberSourceDeactivate:
+ // Number source deactivated
+ __VTPRINT( DEBUG_GEN, "VtUi.ProWsEvtIfZoomActivedL.NumberDeactivate" );
+ break;
+
+ default:
+ __VTPRINT( DEBUG_GEN, "VtUi.ProWsEvtIfZoomActivedL.default" );
+ // EVtUiWsEventNumberSourceActivate could be generated through number buttons
+ // and execution runs to default statement
+ SetZoomModeL( EFalse );
+ break;
+ }
+ __VTPRINTEXIT( "VtUi.ProWsEvtIfZoomActivedL2" )
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::StopSliders()
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::StopSliders()
+ {
+ __VTPRINTENTER( "VtUi.StopSliders" )
+ if( iUiStates->IsBrightnessModeOn() )
+ {
+ // if brightness feature is active, stop that
+ MVtUiFeature* br = iFeatureManager->GetFeatureById( EVtUiFeatureIdBrightness );
+ if ( br )
+ {
+ if ( br->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.StopSliders br->STOP" )
+ br->Stop();
+ }
+ }
+ }
+ // if contrast feature is active, stop that
+ if( iUiStates->IsContrastModeOn() )
+ {
+ // if contrast feature is active, stop that
+ MVtUiFeature* cr = iFeatureManager->GetFeatureById( EVtUiFeatureIdContrast );
+ if ( cr )
+ {
+ if ( cr->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.StopSliders cr->STOP" )
+ cr->Stop();
+ }
+ }
+ }
+ // if volume feature is active, stop that
+ if( iUiStates->IsVolumeModeOn() )
+ {
+ // if volume feature is active, stop that
+ MVtUiFeature* vl = iFeatureManager->GetFeatureById( EVtUiFeatureIdVolume );
+ if ( vl )
+ {
+ if ( vl->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.StopSliders vl->STOP" )
+ vl->Stop();
+ }
+ }
+ }
+ // if zoom feature is active, stop that
+ if( iUiStates->IsZoomModeOn() )
+ {
+ // if zoom feature is active, stop that
+ MVtUiFeature* zm = iFeatureManager->GetFeatureById( EVtUiFeatureIdZoom );
+ if ( zm )
+ {
+ if ( zm->State() == MVtUiFeature::EActive )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.StopSliders zm->STOP" )
+ zm->Stop();
+ }
+ }
+ }
+ __VTPRINTEXIT( "VtUi.StopSliders" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CanSwapImagePlaces()
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::CanSwapImagePlaces()
+ {
+ __VTPRINTENTER( "VtUi.CanSwapImagePlaces" )
+ TTime now;
+ now.HomeTime();
+ // User can swap image places if the frequency is lower than maximum frequency.
+ if ( now.MicroSecondsFrom( iLastSwapTime ).Int64() >= KVtUiMaxSwapImagesFreq )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.Swap can swap image" )
+ iLastSwapTime = now;
+ return ETrue;
+ }
+ else
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.Swap can not swap image" )
+ return EFalse;
+ }
+ __VTPRINTEXIT( "VtUi.CanSwapImagePlaces" )
+ }
+
+// Implementation of CVtUiAppUi::CInstance
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CInstance::CInstance
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CInstance::CInstance( CVtUiAppUi& aAppUi )
+ : iAppUi( aAppUi )
+ {
+ }
+
+void CVtUiAppUi::CInstance::CreateRemoteVideoControl()
+ {
+ iRemoteVideoControl = CVtUiRemoteVideoControl::NewL( iAppUi );
+ iRemoteVideoControl->MakeVisible(EFalse);
+ iMainControl->SetRemoteVideoControl( iRemoteVideoControl );
+ iMainControl->LayoutRemoteVideo();
+
+ iAppUi.AddToStackL( iRemoteVideoControl );
+
+ iRemoteVideoControlInStack = ETrue;
+
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CInstance::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CInstance::ConstructL()
+ {
+ iBitmapManager = new ( ELeave ) CVtUiBitmapManager;
+
+ TRect parent;
+ TAknWindowLineLayout control;
+
+ VtUiLayout::GetApplicationParentRect( parent );
+ iMainControl = CVtUiMainControl::NewL( *iBitmapManager,
+ *iAppUi.iUiStates );
+
+ VtUiLayout::GetMainPaneLayout( control );
+ AknLayoutUtils::LayoutControl( iMainControl, parent, control );
+
+ iAppUi.AddToStackL( iMainControl );
+ iMainControlInStack = ETrue;
+
+ TAknLayoutRect layout;
+ layout.LayoutRect( parent, control );
+ iNumberEntryActivation =
+ new ( ELeave ) CVtUiNumberEntryActivationControl( iAppUi );
+ iNumberEntryActivation->ConstructL( layout.Rect() );
+
+ iContextControl = CVtUiContextControl::NewL(
+ *iBitmapManager,
+ iAppUi,
+ *iAppUi.iUiStates );
+
+ VtUiLayout::GetFirstWindowBackgroundLayout(
+ control );
+ AknLayoutUtils::LayoutControl( iContextControl, parent, control );
+ iAppUi.AddToStackL( iContextControl );
+ iContextControlInStack = ETrue;
+
+ iNaviPane =
+ CVtUiNaviPane::NewL(
+ *( iAppUi.NaviPaneL() ),
+ iAppUi );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CInstance::LayoutChanged
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CInstance::LayoutChanged()
+ {
+ // Layout controls.
+ TRect parent;
+ TAknWindowLineLayout control;
+ VtUiLayout::GetApplicationParentRect( parent );
+ VtUiLayout::GetMainPaneLayout( control );
+ AknLayoutUtils::LayoutControl( iMainControl, parent, control );
+ if(iMainControl)
+ iMainControl->LayoutRemoteVideo();
+ AknLayoutUtils::LayoutControl( iNumberEntryActivation, parent, control );
+ VtUiLayout::GetFirstWindowBackgroundLayout( control );
+ AknLayoutUtils::LayoutControl( iContextControl, parent, control );
+ if(iContextControl)
+ iContextControl->LayoutRemoteVideo();
+
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CInstance::VolumeKeyPressedL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CInstance::VolumeKeyPressedL()
+ {
+ __VTPRINTENTER( "CVtUiAppUi.VolumeKeyPressedL" )
+ // if the application is in foreground show volume sliders
+ if ( iAppUi.IsForeground() )
+ {
+ // If application is shutting down, no need to show volume popup
+ if ( iAppUi.iState == NULL ||
+ iAppUi.iState ==
+ TVtUiStateResetting::InstanceL( iAppUi, *iAppUi.iUiStates ) )
+ {
+ return;
+ }
+
+ CVtUiVolume* volume = static_cast< CVtUiVolume* >(
+ iAppUi.iFeatureManager->GetFeatureById( EVtUiFeatureIdVolume ) );
+ if ( volume )
+ {
+ // If the capture mode is on we should
+ // end the capture mode
+ if( iAppUi.iUiStates->IsCaptureModeOn() )
+ {
+ iAppUi.CmdCancelCaptureL();
+ }
+ volume->StartL();
+ }
+ }
+ __VTPRINTEXIT( "CVtUiAppUi.VolumeKeyPressedL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CInstance::NewL
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CInstance* CVtUiAppUi::CInstance::NewL( CVtUiAppUi& aAppUi )
+ {
+ CInstance* self = new ( ELeave ) CInstance( aAppUi );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CInstance::~CInstance
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CInstance::~CInstance()
+ {
+ if ( iMainControl && iMainControlInStack )
+ {
+ iAppUi.RemoveFromStack( iMainControl );
+ }
+ if ( iContextControl && iContextControlInStack )
+ {
+ iAppUi.RemoveFromStack( iContextControl );
+ }
+ if(iRemoteVideoControl &&iRemoteVideoControlInStack)
+ {
+ iAppUi.RemoveFromStack( iRemoteVideoControl );
+ }
+ delete iMainControl;
+ delete iContextControl;
+ delete iRemoteVideoControl;
+ delete iNumberEntryActivation;
+ delete iNaviPane;
+ delete iBitmapManager;
+ }
+
+// Implementation of CVtUiAppUi::CEventObserver
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::CEventObserver
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CEventObserver::CEventObserver( CVtUiAppUi& aAppUi )
+ : iAppUi( aAppUi ),
+ iCommandObservers( KVtUiCommandObserverArrayGranularity )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::ConstructL()
+ {
+ iModel = CVtEngModel::NewL( *this, *this );
+
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::NewL
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CEventObserver* CVtUiAppUi::CEventObserver::NewL(
+ CVtUiAppUi& aAppUi )
+ {
+ CEventObserver* self = new ( ELeave ) CEventObserver( aAppUi );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::~CEventObserver
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CEventObserver::~CEventObserver()
+ {
+ iCommandObservers.Close();
+
+ delete iModel;
+ delete iBeat;
+
+ delete iRemConInterfaceSelector;
+ iRemConCoreApiTarget = NULL; // not owned.
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::Model
+// -----------------------------------------------------------------------------
+//
+inline CVtEngModel& CVtUiAppUi::CEventObserver::Model()
+ {
+ return *iModel;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::CreateRemConSessionL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::CreateRemConSessionL()
+ {
+ __VTPRINTENTER( "VtUiComms.CreateRemCon" )
+ // If one of the iRemCon* pointers equals to NULL, then all of them are
+ // NULL.
+ if ( !iRemConInterfaceSelector )
+ {
+ CRemConInterfaceSelector* interfaceSelector =
+ CRemConInterfaceSelector::NewL();
+ CleanupStack::PushL( interfaceSelector );
+
+ CRemConCoreApiTarget* coreApiTarget =
+ CRemConCoreApiTarget::NewL( *interfaceSelector, *this );
+ // The coreApiTarget instance is owned by interfaceSelector instance.
+ // This instance must implement MRemConCoreApiTargetObserver interface.
+ CleanupStack::PushL( coreApiTarget );
+ interfaceSelector->OpenTargetL();
+
+ iRemConVolumeRepeatTimer = CPeriodic::NewL( CActive::EPriorityHigh );
+
+ CleanupStack::Pop( coreApiTarget );
+ CleanupStack::Pop( interfaceSelector );
+
+ iRemConInterfaceSelector = interfaceSelector;
+ iRemConCoreApiTarget = coreApiTarget;
+ }
+ __VTPRINTEXIT( "VtUiComms.CreateRemCon" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::DeleteRemConSession
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::DeleteRemConSession()
+ {
+ delete iRemConVolumeRepeatTimer;
+ iRemConVolumeRepeatTimer = NULL;
+
+ delete iRemConInterfaceSelector;
+ iRemConInterfaceSelector = NULL;
+
+ iRemConCoreApiTarget = NULL; // not owned.
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::CommandSupported
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::CEventObserver::CommandSupported(
+ const TInt aCommandId ) const
+ {
+ const TInt caps = iModel->CommandHandler().GetCommandCaps( aCommandId );
+ return
+ ( caps >= KErrNone ) &&
+ ( caps & MVtEngCommandHandler::EAttribSupported );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::CommandSupportedAndSynchronous
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::CEventObserver::CommandSupportedAndSynchronous(
+ const TInt aCommandId ) const
+ {
+ const TInt caps = iModel->CommandHandler().GetCommandCaps( aCommandId );
+ return
+ ( caps >= KErrNone ) &&
+ ( caps & MVtEngCommandHandler::EAttribSupported ) &&
+ ( ~caps & MVtEngCommandHandler::EAttribAsync );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::AddObserverL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::AddObserverL(
+ MVtEngCommandObserver& aObserver )
+ {
+ User::LeaveIfError(
+ iCommandObservers.Append( &aObserver ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::RemoveObserver
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::RemoveObserver(
+ MVtEngCommandObserver& aObserver )
+ {
+ const TInt pos = iCommandObservers.Find( &aObserver );
+ if ( pos != KErrNotFound )
+ {
+ if ( !iInCommandPerformed )
+ {
+ iCommandObservers.Remove( pos );
+ }
+ else
+ {
+ iCommandObservers[ pos ] = NULL;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::StartBeatL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::StartBeatL()
+ {
+ if ( !iBeat )
+ {
+ iBeat = CHeartbeat::NewL( CActive::EPriorityStandard );
+ }
+
+ if ( !iBeat->IsActive() )
+ {
+ iBeat->Start( ETwelveOClock, this );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::StopBeat
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::StopBeat()
+ {
+ delete iBeat;
+ iBeat = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::StopVolumeRepeatTimer
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::StopVolumeRepeatTimer()
+ {
+ iRemConVolumeRepeatTimer->Cancel();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::HandleVtEventL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::HandleVtEventL(
+ TInt aEvent )
+ {
+ __VTPRINTENTER( "VtUiComms.HandleVtEventL" )
+ __VTPRINT2( DEBUG_GEN, "VtUi.HandleEvt=%d", aEvent )
+
+ /** Allow application state to handle event first. It may also deny further
+ * handling by indicating the event was handled */
+ if ( iAppUi.iState &&
+ iAppUi.iState->HandleVtEventL( aEvent )
+ == TVtUiAppStateBase::EEventHandled )
+ {
+ __VTPRINTEXITR( "VtUiComms.HandleVtEventL %d", 0 )
+ return;
+ }
+
+ TInt callBits = EVtUiRefreshStates;
+
+ // New camera orientation
+ switch( aEvent )
+ {
+ case KVtEngSourceChanged:
+ callBits |= EVtUiSetOrientation;
+ break;
+ default:
+ break;
+ }
+
+ switch( aEvent )
+ {
+ case KVtEngSourceChanged:
+ callBits |= EVtUiStopWBOrColortone;
+ break;
+ default:
+ break;
+ }
+
+ switch( aEvent )
+ {
+ case KVtEngSessionWaitingCallActive:
+ case KVtEngSessionWaitingCallInactive:
+ iAppUi.HandleWaitingStateChange(
+ aEvent == KVtEngSessionWaitingCallActive );
+ break;
+ default:
+ break;
+ }
+ switch( aEvent )
+ {
+ case KVtEngShareImageInitializeBegin:
+ callBits |= EVtUiShowImageInitializingProgress;
+ break;
+
+ case KVtEngShareImageInitializeEnd:
+ callBits |= EVtUiHideImageInitializingProgress;
+ break;
+
+ case KVtEngShareImageDecodingError:
+ callBits |= EVtUiShowDecodingError;
+ break;
+
+ default:
+ break;
+ }
+
+ // Handle rendering problems.
+ switch ( aEvent )
+ {
+ case KVtEngRemoteRenderingProblem:
+ callBits |= EVtUiHandleVideoFrameRemoteProblem;
+ break;
+
+ case KVtEngViewFinderStopped:
+ case KVtEngLocalRenderingProblem:
+ callBits |= EVtUiHandleVideoFrameLocalProblem;
+ break;
+
+ default:
+ break;
+ }
+
+ // Refresh navipane.
+ switch ( aEvent )
+ {
+ case KVtEngSourceChanged:
+ case KVtEngCameraChanged:
+ case KVtEngSessionStateChanged:
+ case KVtEngDurationSettingChanged:
+ case KVtEngAudioOutputVolumeChanged:
+ case KVtEngAudioRoutingChanged:
+ case KVtEngAudioMuted:
+ case KVtEngAudioUnmuted:
+ callBits |= EVtUiRefreshNaviPane;
+ break;
+
+ default:
+ break;
+ }
+
+ // Refresh softkeys.
+ switch ( aEvent )
+ {
+ case KVtEngSourceChanged:
+ case KVtEngSourceCapsChanged:
+ case KVtEngSessionAnswerPossible:
+ case KVtEngSessionStateChanged:
+ case KVtEngAudioRoutingChanged:
+ case KVtEngAudioRoutingAvailabilityChanged:
+ case KVtEngAudioMuted:
+ case KVtEngAudioUnmuted:
+ case KVtEngLCHProviderSwitchDone:
+ callBits |= EVtUiRefreshSoftkeys;
+ break;
+
+ default:
+ break;
+ }
+
+ // Refresh blind status
+ switch ( aEvent )
+ {
+ case KVtEngSourceChanged:
+ case KVtEngRemoteVideoPaused:
+ case KVtEngRemoteVideoResumed:
+ case KVtEngRemoteVideoStarted:
+ case KVtEngRemoteVideoStopped:
+ case KVtEngLCHProviderSwitchDone:
+ callBits |= EVtUiRefreshBlind;
+ break;
+
+ default:
+ break;
+ }
+
+ // Check if it's required to stop "waiting image" display.
+ switch ( aEvent )
+ {
+ case KVtEngRemoteVideoResumed:
+ case KVtEngRemoteVideoStarted:
+ callBits |= EVtUiStopWaitingImage;
+ break;
+
+ default:
+ break;
+ }
+
+ // Check if it is needed to set a new layout for remote renderer.
+ switch ( aEvent )
+ {
+ case KVtEngResolutionToQCIF:
+ callBits |= EVtUiChangeRemoteVideoLayout;
+ iAppUi.RemoteVideoIsSQCif( EFalse );
+ break;
+ case KVtEngResolutionToSQCIF:
+ callBits |= EVtUiChangeRemoteVideoLayout;
+ iAppUi.RemoteVideoIsSQCif( ETrue );
+ break;
+ default:
+ break;
+ }
+
+ switch ( aEvent )
+ {
+ case KVtEngAudioRoutingChanged:
+ case KVtEngAudioRoutingAvailabilityChanged:
+ case KVtEngMediaOutgoingVideoChannelStatusChanged:
+ case KVtEngMediaOutgoingAudioChannelStatusChanged:
+ callBits |= EVtUiMediaStateChanged;
+ break;
+
+ case KVtEngAudioVolumeMin:
+ iAppUi.KeySounds()->PlaySound( EAvkonSIDVolumeMinTone );
+ break;
+
+ case KVtEngAudioVolumeMax:
+ iAppUi.KeySounds()->PlaySound( EAvkonSIDVolumeMaxTone );
+ break;
+
+ default:
+ break;
+ }
+
+ // Refresh Menu.
+ switch ( aEvent )
+ {
+ case KVtEngSourceChanged:
+ callBits |= EVtUiRefreshMenu;
+ callBits |= EVtUiStopBrightnessOrContrast;
+ callBits |= EVtUiRefreshZoomPopup;
+ break;
+ default:
+ break;
+ }
+
+ TRAP_IGNORE ( DoExecuteL( callBits ) );
+ __VTPRINTEXITR( "VtUiComms.HandleVtEventL %d", 1 )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::HandleVTCommandPerformedL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::HandleVTCommandPerformedL(
+ TVtEngCommandId aCommand,
+ const TInt aError )
+ {
+ __VTPRINTENTER( "VtUiComms.HandleVTCommandPerformedL" )
+
+ if ( iAppUi.iState &&
+ iAppUi.iState->HandleVTCommandPerformedL( aCommand, aError ) ==
+ TVtUiAppStateBase::EEventHandled )
+ {
+ // state didn't allow further processing of command completion
+ __VTPRINTEXITR( "VtUiComms.HandleVTCommandPerformedL %d", 0 )
+ return;
+ }
+ iAppUi.RefreshStatesL();
+
+ if ( aCommand == KVtEngMuteOutgoingAudio ||
+ aCommand == KVtEngUnmuteOutgoingAudio )
+ {
+ iAppUi.RefreshL();
+ }
+
+ const TInt count = iCommandObservers.Count();
+ TInt nullPosition = KErrNotFound;
+
+ iInCommandPerformed = ETrue;
+
+ // iInCommandPerformed equals ETrue while inside the following loop;
+ // Exceptions must not be raised.
+ for ( TInt index = 0; index < count; index++ )
+ {
+ MVtEngCommandObserver* obs = iCommandObservers[ index ];
+ if ( obs )
+ {
+ TRAP_IGNORE( obs->HandleVTCommandPerformedL( aCommand, aError ) );
+ }
+ else
+ {
+ // We store only one position; eventually all NULL elements of the
+ // array will be removed.
+ nullPosition = index;
+ }
+ }
+ iInCommandPerformed = EFalse;
+
+ if ( nullPosition != KErrNotFound )
+ {
+ iCommandObservers.Remove( nullPosition );
+ }
+
+ // Specific handling of some commands:
+ if ( aCommand == KVtEngResetEngine ) // Engine has been reset
+ {
+ __ASSERT_ALWAYS( !aError, VtUiPanic::Panic( EVtUiPanicResetFailed ) );
+ iAppUi.HandleEngineResetL();
+ }
+ else if ( ( aCommand == KVtEngInitializeShareImage ) ||
+ ( aCommand == KVtEngStartShareImage ) )
+ {
+ __VTPRINT3( DEBUG_GEN,
+ "VtUi.HandleVTCommandPerformedL cmd=%d err=%d", aCommand, aError );
+ if( aError != KErrNone )
+ {
+ // stop toolbar feature to prevent drawing over error dialog
+ MVtUiFeature* tb = iAppUi.iFeatureManager->
+ GetFeatureById( EVtUiFeatureIdToolbar );
+ if ( tb )
+ {
+ tb->Stop();
+ }
+ iAppUi.iAsyncCallback->Set(
+ TCallBack( &AsyncShowErrorAndRestartShare, &iAppUi ) );
+ iAppUi.iAsyncCallback->CallBack();
+ }
+ else if( aCommand == KVtEngInitializeShareImage )
+ {
+ if ( iAppUi.iUiStates->IsViewFinderToMainPane() )
+ {
+ iAppUi.iAsyncCallback->Set(
+ TCallBack( &AsyncViewFinderToMainPaneAndShare, &iAppUi ) );
+ }
+ else
+ {
+ iAppUi.iAsyncCallback->Set(
+ TCallBack( &AsyncShare, &iAppUi ) );
+ }
+ iAppUi.iAsyncCallback->CallBack();
+ }
+ }
+ else if ( iAppUi.iUiStates->IsLayoutChangeNeeded() &&
+ ( aCommand == KVtEngMuteOutgoingAudio ||
+ aCommand == KVtEngUnmuteOutgoingAudio ||
+ aCommand == KVtEngSetAudioRouting ||
+ aCommand == KVtEngSetAudioVolume ||
+ aCommand == KVtEngSetSource ||
+ aCommand == KVtEngPrepareCamera ||
+ aCommand == KVtEngUnfreeze ) )
+ {
+ iAppUi.iUiStates->SetLayoutChangeNeeded( EFalse );
+ iAppUi.DoHandleLayoutChangedL();
+ }
+ __VTPRINTEXITR( "VtUiComms.HandleVTCommandPerformedL %d", 1 )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::vtHandleFrameL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::vtHandleFrameL(
+ TFrameType aType,
+ CFbsBitmap* aBitmap )
+ {
+ static TUint32 lastTick = 0;
+ static TBool flag = EFalse;
+
+
+ CEikMenuBar* menuBar = (STATIC_CAST(CEikonEnv*, this->iAppUi.iCoeEnv))->AppUiFactory()->MenuBar();
+ if ( menuBar && menuBar->IsDisplayed() )
+ {
+ if ( !flag )
+ {
+ flag = ETrue;
+ lastTick = User::NTickCount();
+ }
+ else
+ {
+ TUint32 newTick = User::NTickCount();
+
+ //don't consider time wrap
+ //one frame per 200ms
+ if ( newTick - lastTick < 400 )
+ {
+ __VTPRINTEXITR( "CVtUiAppUi::CEventObserver::vtSetFrame %d", 0 )
+ return;
+ }
+ else
+ {
+ lastTick = newTick;
+ }
+ }
+ }
+ else
+ {
+ flag = EFalse;
+ }
+
+ TBool local = EFalse;
+ switch ( aType )
+ {
+ case ELocalVideoFrame:
+ local = ETrue;
+ break;
+
+ case ERemoteVideoFrame:
+ default:
+ break;
+ }
+
+ iAppUi.HandleVideoFrameL( local, aBitmap );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::vtSetFrame
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::vtSetFrame(
+ TFrameType aType,
+ CFbsBitmap* aBitmap )
+ {
+ TBool local = EFalse;
+ switch ( aType )
+ {
+ case ELocalVideoFrame:
+ local = ETrue;
+ break;
+
+ case ERemoteVideoFrame:
+ default:
+ break;
+ }
+
+ iAppUi.SetVideoFrame( local, aBitmap );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::Beat
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::Beat()
+ {
+ iAppUi.HandleBeat();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::Synchronize
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::Synchronize()
+ {
+ iAppUi.HandleBeat();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::DoExecuteL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::DoExecuteL( TInt aBits )
+ {
+ __VTPRINT2( DEBUG_GEN, "VtUi.DoExec.bits=%d", aBits )
+
+ // Array of methods - leaving methods are allowed.
+ const TMethodL methodArray[] =
+ {
+ &CVtUiAppUi::RefreshStatesL,
+ &CVtUiAppUi::HandleVideoFrameRemoteProblemL,
+ &CVtUiAppUi::HandleVideoFrameLocalProblemL,
+ &CVtUiAppUi::RefreshNaviPaneL,
+ &CVtUiAppUi::RefreshSoftkeysL,
+ &CVtUiAppUi::RefreshBlind,
+ &CVtUiAppUi::StopWaitingImage,
+ &CVtUiAppUi::ChangeRemoteVideoLayoutL,
+ &CVtUiAppUi::ShowImageInitializeProgressL,
+ &CVtUiAppUi::HideImageInitializeProgressL,
+ &CVtUiAppUi::SetCameraOrientationL,
+ &CVtUiAppUi::MediaStateChangedL,
+ &CVtUiAppUi::ShowImageDecodingErrorNoteL,
+ &CVtUiAppUi::StopWhiteBalanceOrColortone,
+ &CVtUiAppUi::RefreshMenuL,
+ &CVtUiAppUi::StopBrightnessOrContrast,
+ &CVtUiAppUi::RefreshZoomPopupL
+ };
+ const TInt count = ( sizeof( methodArray ) / sizeof ( TMethodL ) );
+
+ // Execute selected methods.
+ while ( aBits )
+ {
+ for ( TInt index = 0; ( index < count ) && aBits; index++ )
+ {
+ const TInt mask = ( 1 << index );
+ if ( aBits & mask )
+ {
+ // Bit is set if corresponding method
+ // is wanted to be executed.
+
+ aBits &= ~mask;
+ TMethodL method = methodArray[ index ];
+ ( iAppUi.*method )(); // may leave
+ }
+ }
+ aBits = 0; // for loop executed successfully.
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::HandleVolumeChange
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::HandleVolumeChange(
+ TRemConCoreApiButtonAction aButtonAct )
+ {
+ __VTPRINTENTER( "VtUi.HandleVolumeChange" )
+ // Order of the events is as follows:
+ // Click - Immediately when key is pressed down
+ // Press - After 0.6 seconds
+ // Release - When key is released after 0.6 seconds
+ //
+ // Thus, the following sequences are possible from single keypress:
+ // <Click>
+ // <Click> <0.6 sec pause> <Press> <indefinite pause> <Release>
+
+ switch ( aButtonAct )
+ {
+ case ERemConCoreApiButtonPress:
+ __VTPRINT( DEBUG_GEN, "VtUi.HandleVolumeChange.ButtonPress" )
+ TRAP_IGNORE( iAppUi.AdjustVolumeL( iRCCAOperationId ) );
+ TRAP_IGNORE( iAppUi.RefreshVolumeL() );
+ TRAP_IGNORE( iAppUi.iInstance->VolumeKeyPressedL() );
+
+ iRemConVolumeRepeatTimer->Start(
+ KVtUiVolumeRepeatLongDelay,
+ KVtUiVolumeRepeatDelay,
+ TCallBack( DoHandleVolumeRepeat, this ) );
+
+ break;
+
+ case ERemConCoreApiButtonRelease:
+ __VTPRINT( DEBUG_GEN, "VtUi.HandleVolumeChange.ButtonRelease" )
+ iRCCAOperationId = ENop;
+ TRAP_IGNORE( iAppUi.iInstance->VolumeKeyPressedL() );
+ break;
+
+ case ERemConCoreApiButtonClick:
+ __VTPRINT( DEBUG_GEN, "VtUi.HandleVolumeChange.ButtonClick" )
+ TRAP_IGNORE( iAppUi.AdjustVolumeL( iRCCAOperationId ) );
+ TRAP_IGNORE( iAppUi.RefreshVolumeL() );
+ TRAP_IGNORE( iAppUi.iInstance->VolumeKeyPressedL() );
+ break;
+
+ default:
+ break;
+ }
+ __VTPRINTEXIT( "VtUi.HandleVolumeChange" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::HandleRemMuteChange
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::HandleRemMuteChange(
+ TRemConCoreApiButtonAction aButtonAct )
+ {
+ __VTPRINTENTER( "VtUi.EventObserver.HandleRemMuteChange" )
+ TBool AudioEn (EFalse );
+ AudioEn = iAppUi.iUiStates->AudioState().IsAudio();
+ if( AudioEn )
+ iAppUi.HandleCommandL( EVtUiCmdDisableAudio );
+ else
+ iAppUi.HandleCommandL( EVtUiCmdEnableAudio );
+ __VTPRINTEXIT( "VtUi.EventObserver.HandleRemMuteChange" )
+ }
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::DoHandleVolumeRepeat
+// -----------------------------------------------------------------------------
+//
+TInt CVtUiAppUi::CEventObserver::DoHandleVolumeRepeat( TAny* aAny )
+ {
+ __VTPRINTENTER( "VtUi.SvkRpt" )
+ CEventObserver* self = reinterpret_cast< CEventObserver* >( aAny );
+ TRAP_IGNORE( self->iAppUi.AdjustVolumeL( self->iRCCAOperationId ) );
+ TRAP_IGNORE( self->iAppUi.RefreshVolumeL() );
+ __VTPRINTEXIT( "VtUi.SvkRpt" )
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::RefreshVolumeL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::RefreshVolumeL()
+ {
+ __VTPRINTENTER( "VtUi.RefreshVolumeL" )
+ // Refresh volume
+ CVtUiVolume* volume = static_cast< CVtUiVolume* >(
+ iFeatureManager->GetFeatureById( EVtUiFeatureIdVolume ) );
+ if ( volume )
+ {
+ volume->RefreshL();
+ }
+ __VTPRINTEXIT( "VtUi.RefreshVolumeL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::AdjustVolumeL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::AdjustVolumeL( TRemConCoreApiOperationId aOperationId )
+ {
+ __VTPRINTENTER( "VtUi.AdjustVolumeL" )
+ __VTPRINT2( DEBUG_GEN,
+ "VtUi.AdjustVolumeL aOperationId = %d", aOperationId )
+ TInt command( KVtEngCommandNone );
+ switch ( aOperationId )
+ {
+ case ERemConCoreApiVolumeDown:
+ command = KVtEngDecreaseAudioVolume;
+ break;
+
+ case ERemConCoreApiVolumeUp:
+ command = KVtEngIncreaseAudioVolume;
+ break;
+
+ default:
+ break;
+ }
+
+ if ( command != KVtEngCommandNone )
+ {
+ ExecuteCmdL( command );
+ }
+ __VTPRINTEXIT( "VtUi.AdjustVolumeL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CEventObserver::MrccatoCommand
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CEventObserver::MrccatoCommand(
+ TRemConCoreApiOperationId aOperationId,
+ TRemConCoreApiButtonAction aButtonAct )
+ {
+ __VTPRINTENTER( "VtUi.MrccatoCommand" )
+ // Side volume keys will also dismiss zoom mode if zoom mode is active
+ if ( iAppUi.iUiStates->IsZoomModeOn() )
+ {
+ __VTPRINT( DEBUG_GEN, "VtUi.MrccatoCommand1" )
+ TRAP_IGNORE( iAppUi.SetZoomModeL( EFalse ));
+ }
+
+ iRemConVolumeRepeatTimer->Cancel();
+ iRCCAOperationId = aOperationId;
+ switch ( aOperationId )
+ {
+ case ERemConCoreApiVolumeUp:
+ // if volume in maximum value and volume up is pressed
+ // volume indicator must still be shown for a while if
+ // muted or call duration is shown in navipane
+ __VTPRINT( DEBUG_GEN, "VtUi.MrccatoCommand ERemConCoreApiVolumeUp" )
+ HandleVolumeChange( aButtonAct );
+ break;
+
+ case ERemConCoreApiVolumeDown:
+ // if volume in minimun value and volume down is pressed
+ // volume indicator must still be shown for a while if
+ // muted or call duration is shown in navipane
+ __VTPRINT( DEBUG_GEN, "VtUi.MrccatoCommand ERemConCoreApiVolumeDown" )
+ HandleVolumeChange( aButtonAct );
+ break;
+ case ERemConCoreApiMute:
+ __VTPRINT( DEBUG_GEN, "VtUi.MrccatoCommand ERemConCoreApiMute" )
+ HandleRemMuteChange( aButtonAct );
+ default:
+ // Other commands ignored.
+ break;
+ }
+ __VTPRINTEXIT( "VtUi.MrccatoCommand" )
+ }
+
+// Implementation of CVtUiAppUi::CVtUiAppUiMGVerifier
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CVtUiAppUiMGVerifier::NewLC
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CVtUiAppUiMGVerifier* CVtUiAppUi::CVtUiAppUiMGVerifier::NewLC(
+ CVtUiAppUi& aAppUi, CCoeEnv& aCoeEnv )
+ {
+ CVtUiAppUiMGVerifier* self = new ( ELeave )
+ CVtUiAppUiMGVerifier( aAppUi, aCoeEnv );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CVtUiAppUiMGVerifier::~CVtUiAppUiMGVerifier
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CVtUiAppUiMGVerifier::~CVtUiAppUiMGVerifier()
+ {
+ delete iManager;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CVtUiAppUiMGVerifier::VerifySelectionL
+// -----------------------------------------------------------------------------
+//
+TBool CVtUiAppUi::CVtUiAppUiMGVerifier::VerifySelectionL(
+ const MDesCArray* aSelectedFiles )
+ {
+ TBool isOk( EFalse );
+ if ( aSelectedFiles->MdcaCount() > 0 )
+ {
+ TVirtualPathPtr virtualPath(
+ aSelectedFiles->MdcaPoint( 0 ), KDefaultContentObject );
+
+ // not ptotected by default
+ TInt isProtected = 0;
+
+ TInt err = iManager->GetAttribute( EIsProtected,
+ isProtected, virtualPath );
+ if ( isProtected )
+ {
+ iAppUi.ShowDRMNotAllowedNoteL();
+ }
+ if ( err == KErrNone )
+ {
+ isOk = !isProtected;
+ }
+ }
+ return isOk;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CVtUiAppUiMGVerifier::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CVtUiAppUi::CVtUiAppUiMGVerifier::ConstructL()
+ {
+ iManager = CManager::NewL();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtUiAppUi::CVtUiAppUiMGVerifier::CVtUiAppUiMGVerifier
+// -----------------------------------------------------------------------------
+//
+CVtUiAppUi::CVtUiAppUiMGVerifier::CVtUiAppUiMGVerifier(
+ CVtUiAppUi& aAppUi, CCoeEnv& aCoeEnv )
+ : iAppUi( aAppUi ), iCoeEnv( &aCoeEnv )
+ {
+ }
+
+// End of File