/*
* 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 );
// Re-layout the remote video
iDownlinkWindow->LayoutRemoteVideo();
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" )
// delay mute cmd received during layout change
if ( aCommand == EAknSoftkeyOptions )
{
if ( iLayoutChg )
{
iDelayedCmd = EAknSoftkeyOptions;
__VTPRINTEXIT( "VtUi.ProcessCommandL mute delayed due to LayoutChange" )
return;
}
}
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();
MVtEngMedia& media = Model().Media();
if ( VtUiUtility::GetFreezeState( media ) )
{
TBool isViewFinderInContextPane = IsViewFinderInContextPane();
iUiStates->SetViewFindersInitialPlaceContextPane( isViewFinderInContextPane );
}
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 && wb->State() == MVtUiFeature::EActive )
{
__VTPRINT( DEBUG_GEN, "CVtUiWhiteBalance::DoDeactivateL" );
wb->DoDeactivateL ();
}
if ( ct && 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 && wb->IsPendingCmd() )
wb->HandlePendingCmdL();
if( ct && 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);
if( iDelayedCmd == EAknSoftkeyOptions )
{
ProcessCommandL( iDelayedCmd );
}
else
{
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