--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/satui/satapp/SATUISrc/CSatUiActionPerformer.cpp Wed Sep 01 12:15:03 2010 +0100
@@ -0,0 +1,1837 @@
+/*
+* Copyright (c) 2002-2007 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: This class handles the communication between server and
+* user interface
+*
+*/
+
+
+// INCLUDE FILES
+#include <aknenv.h>
+#include <StringLoader.h>
+#include <SatUi.rsg>
+#include <e32test.h>
+
+#include <msatuiadapter.h>
+
+#include <AknIconArray.h> //for itemsicon
+#include <gulicon.h> //for itemsicon
+#include <aknlayout.cdl.h> //for TAknWindowLineLayout
+#include <aknlayoutscalable_avkon.cdl.h> //for scalable layouts
+#include <AknUtils.h>
+#include <AknIconUtils.h>
+#include <aknnotedialog.h>
+
+#include "CSatUiActionPerformer.h"
+#include "MSatUiActionImplementer.h"
+#include "csatuiiconhandler.h"
+#include "tflogger.h"
+
+#include "satui.hrh"
+
+#include <ProfileEngineSDKCRKeys.h>
+#include <centralrepository.h>
+#include <cenrepnotifyhandler.h>
+
+// General Settings Cen Rep Keys.
+#include <settingsinternalcrkeys.h>
+
+// CONSTANTS
+
+const TInt KSatActiveProfileOffline = 5; // value from ProfileEngine
+
+// PlayTone durations
+const TInt64 KSatDur170ms = 170000; // 170ms
+const TInt64 KSatDur200ms = 200000; // 200ms
+const TInt64 KSatDur250ms = 250000; // 250ms
+const TInt64 KSatDur1200ms = 1200000; // 1200ms
+
+// play tone tones
+_LIT8( KNetToneSeqNetBusy, "\x00\x11\x05\x4E\x30\x40\x30\x07\x0B" );
+
+_LIT8( KNetToneSeqNetCallWaiting, "\x00\x11\x05\x4E\x14\x40\x3C\x4E\x14\
+\x40\x64\x40\x64\x40\x64\x4E\x14\x40\x3C\x4E\x14\x40\x64\x40\x64\x40\x64\
+\x07\x0B" );
+
+_LIT8( KNetToneSeqNetCongestion, "\x00\x11\x05\x4E\x14\x40\x14\x07\x0B" );
+
+_LIT8( KNetToneSeqNetSpecialInformation, "\x00\x11\x05\x4F\x21\x50\
+\x21\x51\x21\x40\x64\x07\x0B" );
+
+_LIT8( KNetToneSeqDial,"\x00\x11\x05\x4E\xFE\x4E\xFE\x4E\xFE\x4E\xFE\x4E\xFE\
+\x4E\xFE\x4E\xFE\x4E\xFE\x07\x0B");
+
+_LIT8( KNetToneSeqRingGoing, "\x00\x11\x05\x4E\x64\x05\x04\x40\x64\06\x07\x0B" );
+
+// General Beep is set for forever duration. Instead of AVKON definition 170ms.
+_LIT8( KGeneralBeep, "\x00\x11\x0A\x76\x00\x0B" );
+_LIT8( KErrorTone, "\x00\x11\x0A\x6C\x19\x0B" );
+_LIT8( KRadioPathNotAvailable, "\x00\x11\x0A\x05\x03\x4E\x14\x40\x14\x06\x0B" );
+_LIT8( KRadioPathAck, "\x00\x11\x0A\x02\xFC\x0A\x80\x4E\x14\x0A\x7f\x0B" );
+
+// ================= MEMBER FUNCTIONS =======================
+
+// C++ default constructor can NOT contain any code, that
+// might leave.
+//
+CSatUiActionPerformer::CSatUiActionPerformer():
+ iRefresh( EFalse ),
+ iIconSupport( ETrue ),
+ iClearScreenEvent( EFalse )
+ {
+ }
+
+// Symbian OS default constructor can leave.
+void CSatUiActionPerformer::ConstructL()
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::ConstructL called" )
+
+ //Register to Server as subsession
+ //If Server is not up, this function call may take time
+ iSatSession.ConnectL();
+
+ iSat.RegisterL( iSatSession, this );
+ iAdapter = iSat.Adapter();
+ if ( !iAdapter )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ // create icon handler
+ iIconHandler = CSatUiIconHandler::NewL();
+
+ //Item icons
+ iItemIcons = new ( ELeave ) CAknIconArray( 1 );
+
+ TFLOGSTRING( "CSatUiActionPerformer::ConstructL exit" )
+ }
+
+// Two-phased constructor.
+CSatUiActionPerformer* CSatUiActionPerformer::NewL()
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::NewL() called" )
+ CSatUiActionPerformer* self = new ( ELeave ) CSatUiActionPerformer;
+
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ TFLOGSTRING( "CSatUiActionPerformer::NewL() exit" )
+ return self;
+ }
+
+// Destructor.
+CSatUiActionPerformer::~CSatUiActionPerformer()
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::~CSatUiActionPerformer() called" )
+
+ iSat.Close();
+ iSatSession.Close();
+
+ if ( iItemIcons )
+ {
+ iItemIcons->ResetAndDestroy();
+ delete iItemIcons;
+ }
+
+ // delete icon handler
+ delete iIconHandler;
+ iIconHandler = NULL;
+
+ iActionImplementer = NULL;
+ iAdapter = NULL;
+
+ TFLOGSTRING( "CSatUiActionPerformer::~CSatUiActionPerformer() exit" )
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::SetImplementer
+// Sets a pointer to CSatUiViewAppUi object.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+void CSatUiActionPerformer::SetImplementer(
+ MSatUiActionImplementer* aImplementer )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SetImplementer calling" )
+ iActionImplementer = aImplementer;
+ TFLOGSTRING( "CSatUiActionPerformer::SetImplementer exiting" )
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::Adapter
+// Returns a pointer to MSatUiAdapter provided by SatCli.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+MSatUiAdapter* CSatUiActionPerformer::Adapter()
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::Adapter calling-exiting" )
+ return iAdapter;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::DisplayTextL
+// Checks length of the text and calls method from
+// the CSatUiViewAppUi class if the length is OK.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TSatUiResponse CSatUiActionPerformer::DisplayTextL(
+ const TDesC& aText,
+ const TDesC& aSimApplicationName,
+ const TSatIconId& aIconId,
+ TBool& aRequestedIconDisplayed,
+ const TBool aSustainedText,
+ const TTimeIntervalSeconds aDuration,
+ const TBool aWaitUserToClear )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::DisplayText called" )
+ TSatUiResponse response( ESatFailure );
+ aRequestedIconDisplayed = ETrue;
+ TBool selfExplanatoryIcon( EFalse );
+
+ TInt textLength( aText.Length() );
+
+ if ( ( !textLength ) || ( textLength > RSat::KTextToDisplayMaxSize ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::DisplayText no text" )
+ aRequestedIconDisplayed = EFalse;
+ return response;
+ }
+
+ CFbsBitmap* iconBitmapDisplayText = NULL;
+ iActionImplementer->SetCommandPending( ETrue );
+
+ //if icon is available for command
+ if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||
+ ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&
+ ( iIconSupport ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::DisplayText have icon" )
+ iconBitmapDisplayText = FetchIcon( aIconId.iIdentifier,
+ EIconDisplayText );
+
+ if ( ESatSelfExplanatory == aIconId.iIconQualifier )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::DisplayText self \
+ explanatory icon" )
+ selfExplanatoryIcon = ETrue;
+ }
+ }
+
+ //icon not found not shown
+ if ( !iconBitmapDisplayText )
+ {
+ aRequestedIconDisplayed = EFalse;
+ }
+
+ iActionImplementer->DispatchTimer( iWait );
+
+ TRAPD( err,
+ response = iActionImplementer->DisplayTextL( aText, aSimApplicationName,
+ iconBitmapDisplayText, selfExplanatoryIcon,
+ aSustainedText, aDuration, aWaitUserToClear );
+ );
+
+ if ( err != KErrNone )
+ {
+ response = ESatFailure;
+ aRequestedIconDisplayed = EFalse;
+ }
+
+ if ( iActionImplementer->GetEndKey() )
+ {
+ response = ESatSessionTerminatedByUser;
+ iActionImplementer->SetEndKey( EFalse );
+ }
+
+ iActionImplementer->SetCommandPending( EFalse );
+
+ TFLOGSTRING2( "CSatUiActionPerformer::DisplayText exit, return: %d", \
+ response )
+ return response;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::GetInkeyL
+// Checks type of the input wanted and calls right method
+// from the CSatUiViewAppUi class.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TSatUiResponse CSatUiActionPerformer::GetInkeyL(
+ const TDesC& aText,
+ const TSatCharacterSet aCharacterSet,
+ TChar& aInput,
+ const TBool /*aHelpIsAvailable*/,
+ const TSatIconId& aIconId,
+ TBool& aRequestedIconDisplayed,
+ TUint& aDuration,
+ const TBool aImmediateDigitResponse )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetInkey called" )
+
+ TSatUiResponse response( ESatSuccess );
+ aRequestedIconDisplayed = EFalse;
+ TBuf<1> input;
+
+ if ( aInput.IsAssigned() )
+ {
+ input.Fill( aInput, 1 );
+ }
+
+ if ( ( aCharacterSet == ESatYesNo ) && ( aText.Length() == 0 ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetInkey return ESatFailure" )
+ return ESatFailure;
+ }
+
+ CFbsBitmap* iconBitmapGetInkey = NULL;
+ iActionImplementer->SetCommandPending( ETrue );
+
+ // If icon is available for command
+ if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||
+ ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&
+ ( iIconSupport ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetInkey have icon" )
+ TIconCommand iconCommand ( EIconGetInkey );
+
+ if ( ESatYesNo == aCharacterSet )
+ {
+ iconCommand = EIconGetYesNo;
+ }
+
+ iconBitmapGetInkey = FetchIcon( aIconId.iIdentifier,
+ iconCommand );
+ GetScalableBitmap( iconBitmapGetInkey, iconCommand,
+ aRequestedIconDisplayed );
+ }
+
+ TBool selfExplanatory( EFalse );
+
+ // Icon is self-explanatory
+ if ( ESatSelfExplanatory == aIconId.iIconQualifier )
+ {
+ selfExplanatory = ETrue;
+ }
+
+ iActionImplementer->DispatchTimer( iWait );
+
+ TRAPD( err,
+
+ if ( ESatYesNo == aCharacterSet || aImmediateDigitResponse )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetInkey digit response" )
+ response = iActionImplementer->GetYesNoL( aText, aCharacterSet,
+ aInput, iconBitmapGetInkey, selfExplanatory, aDuration,
+ aImmediateDigitResponse );
+ }
+ else //ESatCharSmsDefaultAlphabet, ESatCharUcs2Alphabet, ESatDigitOnly
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetInkey other conditions" )
+ response = iActionImplementer->GetInputL(
+ aText, aCharacterSet, input, 1, 1, EFalse, ETrue,
+ iconBitmapGetInkey, selfExplanatory, aDuration );
+
+ if ( ESatSuccess == response )
+ {
+ if ( input.Length() )
+ {
+ aInput = input[0];
+ }
+ }
+ }
+ );
+
+ if ( err != KErrNone )
+ {
+ response = ESatFailure;
+ }
+
+ if ( iActionImplementer->GetEndKey() )
+ {
+ response = ESatSessionTerminatedByUser;
+ iActionImplementer->SetEndKey( EFalse );
+ }
+ iActionImplementer->SetCommandPending( EFalse );
+
+ TFLOGSTRING2( "CSatUiActionPerformer::GetInkey exit, return: %d", \
+ response )
+ return response;
+ }
+
+// --------------------------------------------------------
+// CSatUiActionPerformer::GetInputL
+// Checks type of the input wanted and whether it should be
+// hidden and calls right method from the CSatUiViewAppUi class.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TSatUiResponse CSatUiActionPerformer::GetInputL(
+ const TDesC& aText,
+ const TSatCharacterSet aCharacterSet,
+ TDes& aInput,
+ const TInt aMinLength,
+ const TInt aMaxLength,
+ const TBool aHideInput,
+ const TBool /*aHelpIsAvailable*/,
+ const TSatIconId& aIconId,
+ TBool& aRequestedIconDisplayed )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetInput called" )
+ TSatUiResponse response( ESatSuccess );
+ aRequestedIconDisplayed = EFalse;
+
+ if ( ( ( aCharacterSet == ESatCharSmsDefaultAlphabet ) ||
+ ( aCharacterSet == ESatCharUcs2Alphabet ) ) &&
+ ( aHideInput ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetInput return ESatFailure" )
+ return ESatFailure;
+ }
+
+ CFbsBitmap* iconBitmapGetInput = NULL;
+ iActionImplementer->SetCommandPending( ETrue );
+
+ // If icon is available for command
+ if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||
+ ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&
+ ( iIconSupport ) )
+ {
+ iconBitmapGetInput = FetchIcon( aIconId.iIdentifier, EIconGetInput );
+ GetScalableBitmap( iconBitmapGetInput, EIconGetInput,
+ aRequestedIconDisplayed );
+ }
+
+ TBool selfExplanatory( EFalse );
+
+ // Icon is self-explanatory
+ if ( ESatSelfExplanatory == aIconId.iIconQualifier )
+ {
+ selfExplanatory = ETrue;
+ }
+
+ iActionImplementer->DispatchTimer( iWait );
+
+ TUint duration ( 0 );
+ TRAPD( err,
+ response = iActionImplementer->GetInputL(
+ aText, aCharacterSet, aInput, aMinLength, aMaxLength,
+ aHideInput, EFalse, iconBitmapGetInput, selfExplanatory,
+ duration );
+ );
+
+ if ( err != KErrNone )
+ {
+ TFLOGSTRING2( "CSatUiActionPerformer::GetInput err:%d", err )
+ response = ESatFailure;
+ aRequestedIconDisplayed = EFalse;
+ }
+
+ if ( iActionImplementer->GetEndKey() )
+ {
+ response = ESatSessionTerminatedByUser;
+ iActionImplementer->SetEndKey( EFalse );
+ }
+ iActionImplementer->SetCommandPending( EFalse );
+
+ TFLOGSTRING2( "CSatUiActionPerformer::GetInput response:%d", response )
+ TFLOGSTRING2( "CSatUiActionPerformer::GetInput aRequestedIconDisplayed:%d",
+ aRequestedIconDisplayed )
+ TFLOGSTRING( "CSatUiActionPerformer::GetInput exit" )
+ return response;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::SetUpMenuL
+// Calls the method from the CSatUiViewAppUi class to show
+// a SetUpMenu view.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TSatUiResponse CSatUiActionPerformer::SetUpMenuL(
+ const TDesC& aText,
+ const MDesCArray& aMenuItems,
+ const CArrayFixFlat<TSatAction>* aMenuItemNextActions,
+ const TBool aHelpIsAvailable,
+ const TSatIconId& aIconId,
+ const CArrayFixFlat<TInt>* aMenuIcons,
+ const enum TSatIconQualifier aIconListQualifier,
+ const enum TSatSelectionPreference /*aSelectionPreference*/ )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SetUpMenu called" )
+ TSatUiResponse response( ESatSuccess );
+ TBool selfExplanatoryItems( EFalse );
+ CFbsBitmap* iconTitleBitmap = NULL;
+ iActionImplementer->SetCommandPending( ETrue );
+
+ if ( !aMenuItems.MdcaCount() ||
+ ( KSatActiveProfileOffline ==
+ iActionImplementer->ProfileState() ) )
+ {
+ iActionImplementer->SetCommandPending( EFalse );
+ iActionImplementer->ShowNotAvailableNoteL();
+ iActionImplementer->CloseSatUI();
+ return response;
+ }
+
+ //if contextpane icon available for command
+ if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||
+ ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&
+ ( iIconSupport ) )
+ {
+ iconTitleBitmap = FetchIcon( aIconId.iIdentifier,
+ EIconSetUpMenuContext );
+ GetScalableBitmap( iconTitleBitmap, EIconSetUpMenuContext );
+ }
+
+ iItemIcons->ResetAndDestroy();
+ TInt iconCount( 0 );
+
+ if ( aMenuIcons )
+ {
+ iconCount = aMenuIcons->Count();
+ }
+
+ //if icons are available for item list
+ if ( ( aMenuItems.MdcaCount() == iconCount ) &&
+ ( ( aIconListQualifier == ESatSelfExplanatory ) ||
+ ( aIconListQualifier == ESatNotSelfExplanatory ) ) &&
+ ( iIconSupport ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SetUpMenu have icon" )
+ if ( aIconListQualifier == ESatSelfExplanatory )
+ {
+ selfExplanatoryItems = ETrue;
+ }
+
+ TBool continueLoop( ETrue );
+ TInt count( 0 );
+ for ( count = 0; ( count < iconCount ) && continueLoop; count++ )
+ {
+ CGulIcon* gulIcon = CGulIcon::NewLC();
+ TUint8 itemIconId( STATIC_CAST( TUint8,
+ aMenuIcons->operator[]( count ) ) );
+ CFbsBitmap* iconItemBitmap = NULL;
+ iconItemBitmap = FetchIcon( itemIconId, EIconSetUpMenuItems );
+
+ if ( !iconItemBitmap &&
+ ( aIconListQualifier == ESatSelfExplanatory ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SetUpMenu \
+ SelfExplanatory " )
+ CleanupStack::PopAndDestroy( gulIcon ); // gulIcon
+ iItemIcons->ResetAndDestroy();
+ continueLoop = EFalse;
+ }
+ else
+ {
+ if ( !iconItemBitmap &&
+ ( aIconListQualifier == ESatNotSelfExplanatory ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SetUpMenu \
+ not SelfExplanatory " )
+ iconItemBitmap = new( ELeave )CFbsBitmap();
+ }
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SetUpMenu \
+ other conditions " )
+ GetScalableBitmap( iconItemBitmap, EIconSetUpMenuItems );
+ }
+
+ gulIcon->SetBitmap( iconItemBitmap );
+ iItemIcons->AppendL( gulIcon );
+ CleanupStack::Pop( gulIcon );
+ }
+ }
+ TFLOGSTRING2( "CSatUiActionPerformer::SetUpMenu count: %d", count )
+ }
+
+ TRAPD( err,
+ response = iActionImplementer->SetUpMenuL(
+ aText, aMenuItems, aMenuItemNextActions, iconTitleBitmap,
+ iItemIcons, selfExplanatoryItems, aHelpIsAvailable );
+ );
+
+ if ( KErrNone != err )
+ {
+ response = ESatFailure;
+ }
+
+ if ( iActionImplementer->GetEndKey() )
+ {
+ response = ESatSessionTerminatedByUser;
+ iActionImplementer->SetEndKey( EFalse );
+ }
+
+ iActionImplementer->SetCommandPending( EFalse );
+ TFLOGSTRING2( "CSatUiActionPerformer::SetUpMenu exit, \
+ return:%i", response )
+ return response;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::SelectItemL
+// Calls the method from the CSatUiViewAppUi class to show
+// a SelectItem view.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TSatUiResponse CSatUiActionPerformer::SelectItemL(
+ const TDesC& aText,
+ const MDesCArray& aMenuItems,
+ const CArrayFixFlat<TSatAction>* aMenuItemNextActions,
+ const TInt aDefaultItem,
+ TUint8& aSelection,
+ const TBool aHelpIsAvailable,
+ const TSatIconId& aIconId,
+ const CArrayFixFlat<TInt>* aMenuIcons,
+ const enum TSatIconQualifier aIconListQualifier,
+ TBool& aRequestedIconDisplayed,
+ const enum TSatSelectionPreference /*aSelectionPreference*/ )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SelectItem called" )
+ TSatUiResponse response( ESatSuccess );
+ aRequestedIconDisplayed = ETrue;
+ TBool selfExplanatoryItems( EFalse );
+
+ CFbsBitmap* iconTitleBitmap = NULL;
+ iActionImplementer->SetCommandPending( ETrue );
+
+ //if contextpane icon available for command
+ if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||
+ ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&
+ ( iIconSupport ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SelectItem icon available" )
+ iconTitleBitmap = FetchIcon( aIconId.iIdentifier,
+ EIconSetUpMenuContext );
+ GetScalableBitmap( iconTitleBitmap, EIconSetUpMenuContext,
+ aRequestedIconDisplayed );
+ }
+
+ iItemIcons->ResetAndDestroy();
+
+ TInt iconCount( 0 );
+
+ if ( aMenuIcons )
+ {
+ iconCount = aMenuIcons->Count();
+ }
+
+ TFLOGSTRING2( "CSatUiActionPerformer::SelectItem iconCount:%d", iconCount )
+
+ //if icons are available for item list
+ if ( ( aMenuItems.MdcaCount() == iconCount ) &&
+ ( ( aIconListQualifier == ESatSelfExplanatory ) ||
+ ( aIconListQualifier == ESatNotSelfExplanatory ) ) &&
+ ( iIconSupport ) )
+ {
+ TFLOGSTRING(
+ "CSatUiActionPerformer::SelectItem icon available for item list" )
+
+ if ( aIconListQualifier == ESatSelfExplanatory )
+ {
+ selfExplanatoryItems = ETrue;
+ }
+
+ TBool continueLoop( ETrue );
+ TInt count( 0 );
+ for ( count = 0; ( count < iconCount ) && continueLoop; count++ )
+ {
+ CGulIcon* gulIcon = CGulIcon::NewLC();
+ TUint8 itemIconId = STATIC_CAST( TUint8,
+ aMenuIcons->operator[]( count ) );
+ CFbsBitmap* iconItemBitmap = NULL;
+ iconItemBitmap = FetchIcon( itemIconId, EIconSetUpMenuItems );
+
+ // when icon can't be received and is set to self explanatory, we
+ // iqnore all icons and show only text
+ if ( !iconItemBitmap &&
+ ( aIconListQualifier == ESatSelfExplanatory ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SelectItem \
+ SelfExplanatory " )
+ CleanupStack::PopAndDestroy( gulIcon ); // gulIcon
+ iItemIcons->ResetAndDestroy();
+ continueLoop = EFalse;
+ aRequestedIconDisplayed = EFalse;
+ }
+ else
+ {
+ // when icon can't be received and is set to not self
+ // explanatory, we replace it with empty icon
+ if ( !iconItemBitmap &&
+ ( aIconListQualifier == ESatNotSelfExplanatory ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SelectItem \
+ not SelfExplanatory " )
+ iconItemBitmap = new( ELeave )CFbsBitmap();
+ aRequestedIconDisplayed = EFalse;
+ }
+ // when icon was able to receive, we scale it
+ // if every prior icon is correctly received
+ else if ( aRequestedIconDisplayed )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SelectItem \
+ receive icon " )
+ GetScalableBitmap( iconItemBitmap, EIconSetUpMenuItems,
+ aRequestedIconDisplayed );
+ }
+ // if aRequestIconDisplayed is false, at least one prior icon
+ // fetch had problems and thus we must report that by not
+ // updating aRequestedIconDisplayed
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::SelectItem \
+ aRequestIconDisplayed false " )
+ GetScalableBitmap( iconItemBitmap, EIconSetUpMenuItems );
+ }
+
+ gulIcon->SetBitmap( iconItemBitmap );
+ iItemIcons->AppendL( gulIcon );
+ CleanupStack::Pop( gulIcon );
+ }
+ }
+ TFLOGSTRING2( "CSatUiActionPerformer::SelectItem count: %d", count )
+ }
+
+ TRAPD( err,
+ response = iActionImplementer->SelectItemL( aText, aMenuItems,
+ aMenuItemNextActions, aDefaultItem, aSelection, iconTitleBitmap,
+ iItemIcons, selfExplanatoryItems, aHelpIsAvailable );
+ );
+
+ if ( err != KErrNone )
+ {
+ response = ESatFailure;
+ aRequestedIconDisplayed = EFalse;
+ }
+
+ if ( iActionImplementer->GetEndKey() )
+ {
+ response = ESatSessionTerminatedByUser;
+ iActionImplementer->SetEndKey( EFalse );
+ }
+
+ iActionImplementer->SetCommandPending( EFalse );
+
+ TFLOGSTRING2( "CSatUiActionPerformer::SelectItem response:%d", response )
+ TFLOGSTRING( "CSatUiActionPerformer::SelectItem exit" )
+ return response;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::PlayTone
+// Checks type of the tone wanted and calls right method
+// from the CSatUiViewAppUi class.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TSatUiResponse CSatUiActionPerformer::PlayTone(
+ const TDesC& aText,
+ const TSatTone aTone,
+ const TTimeIntervalMicroSeconds aDuration,
+ const TSatIconId& aIconId,
+ TBool& aRequestedIconDisplayed )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone called" )
+ TFLOGSTRING2( "CSatUiActionPerformer::PlayTone tone is %i", aTone )
+
+ aRequestedIconDisplayed = EFalse;
+
+ iSequence.Zero();
+ TTimeIntervalMicroSeconds duration( aDuration.Int64() );
+ iActionImplementer->SetCommandPending( ETrue );
+ // This is used to determine zero length duration.
+ const TTimeIntervalMicroSeconds zeroDuration( static_cast<TInt64>( 0 ) );
+
+ CFbsBitmap* iconBitmap = NULL;
+ // If icon is available for command
+ if ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||
+ ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&
+ ( iIconSupport ) )
+ {
+ iconBitmap = FetchIcon( aIconId.iIdentifier, EIconPlayTone );
+ GetScalableBitmap( iconBitmap, EIconPlayTone,
+ aRequestedIconDisplayed );
+ }
+
+ TBool selfExplanatory( EFalse );
+
+ // Icon is self-explanatory
+ if ( ESatSelfExplanatory == aIconId.iIconQualifier )
+ {
+ selfExplanatory = ETrue;
+ }
+
+ // Check if the current Profile is Meeting
+ TInt errCR( KErrNone );
+ TInt profileId( 0 );
+
+ CRepository* repository = NULL;
+ TSatTone tone = aTone;
+
+ // Which UID to monitor.
+ TRAP( errCR, repository = CRepository::NewL( KCRUidProfileEngine ) );
+
+ if ( !errCR && repository )
+ {
+ errCR = repository->StartTransaction(
+ CRepository::EReadWriteTransaction );
+ errCR = repository->Get( KProEngActiveProfile, profileId );
+ }
+
+ delete repository;
+
+ TFLOGSTRING2( "CSatUiActionPerformer::PlayTone(): err = %d", errCR )
+
+ TFLOGSTRING2( "SCSatUiActionPerformer::PlayTone() profileId: %d",
+ profileId )
+
+ switch ( tone )
+ {
+ case ESatGeneralBeep:
+ case ESatPositiveTone:
+ case ESatToneNotSet:
+ if ( zeroDuration == duration )
+ {
+ duration = KSatDur170ms; // 170ms
+ }
+ iSequence.Copy( KGeneralBeep );
+ break;
+ case ESatNegativeTone:
+ if ( zeroDuration == duration )
+ {
+ duration = KSatDur250ms; // 250ms
+ }
+ iSequence.Copy( KErrorTone );
+ break;
+ case ESatRadioPathNotAvailableCallDropped:
+ if ( zeroDuration == duration )
+ {
+ duration = KSatDur1200ms; // 1200ms
+ }
+ iSequence.Copy( KRadioPathNotAvailable );
+ break;
+ case ESatRadioPathAcknowledge:
+ if ( zeroDuration == duration )
+ {
+ duration = KSatDur200ms; // 200ms
+ }
+ iSequence.Copy( KRadioPathAck );
+ break;
+ case ESatDialTone:
+ {
+ if ( zeroDuration == duration )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone() ESatDialTone" )
+ return ESatCmdDataNotUnderstood;
+ }
+ else
+ {
+ iSequence.Copy( KNetToneSeqDial );
+ }
+ }
+ break;
+ case ESatCalledSubscriberBusy:
+ {
+ if ( zeroDuration == duration )
+ {
+ return ESatCmdDataNotUnderstood;
+ }
+ else
+ {
+ iSequence.Copy( KNetToneSeqNetBusy );
+ }
+ }
+ break;
+ case ESatCongestion:
+ {
+ if ( zeroDuration == duration )
+ {
+ return ESatCmdDataNotUnderstood;
+ }
+ else
+ {
+ iSequence.Copy( KNetToneSeqNetCongestion );
+ }
+ }
+ break;
+ case ESatErrorSpecialInfo:
+ {
+ if ( zeroDuration == duration )
+ {
+ return ESatCmdDataNotUnderstood;
+ }
+ else
+ {
+ iSequence.Copy( KNetToneSeqNetSpecialInformation );
+ }
+ }
+ break;
+ case ESatCallWaitingTone:
+ {
+ if ( zeroDuration == duration )
+ {
+ return ESatCmdDataNotUnderstood;
+ }
+ else
+ {
+ iSequence.Copy( KNetToneSeqNetCallWaiting );
+ }
+ }
+ break;
+ case ESatRingingTone:
+ {
+ if ( zeroDuration == duration )
+ {
+ return ESatCmdDataNotUnderstood;
+ }
+ else
+ {
+ iSequence.Copy( KNetToneSeqRingGoing );
+ }
+ }
+ break;
+ case ESatUserSelectedToneIncomingSpeech:
+ case ESatUserSelectedToneIncomingSms:
+ {
+ // These are handled later.
+ }
+ break;
+ default:
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone Default" )
+ return ESatCmdDataNotUnderstood;
+ }
+
+ TSatUiResponse response( ESatFailure );
+
+ iActionImplementer->DispatchTimer( iWait );
+
+ // ESatSClearScreenEvent doesn't occur,clear displaytext on screen.
+ if ( EFalse == iClearScreenEvent )
+ {
+ // Clear displaytext on the screen.
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone clear screen" )
+ iActionImplementer->ClearScreen();
+ }
+
+ if ( 0 != iSequence.Length() )
+ {
+ TFLOGSTRING2( "CSatUiActionPerformer::PlayTone duration microseconds %d",
+ aDuration.Int64() )
+ TRAPD( err,
+ response = iActionImplementer->PlayStandardToneL(
+ aText,
+ iSequence,
+ duration,
+ iconBitmap,
+ selfExplanatory );
+ );
+
+ if ( KErrNone != err )
+ {
+ response = ESatFailure;
+ TFLOGSTRING2( "CSatUiActionPerformer::PlayTone error %i", err )
+ }
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone StandardTone exit" )
+ }
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone length of sequence \
+ is zero" )
+
+ TRAPD( err,
+ response = iActionImplementer->PlayUserSelectedToneL(
+ aText,
+ aDuration.Int64(),
+ tone,
+ iconBitmap,
+ selfExplanatory );
+ );
+
+ if ( KErrNone != err )
+ {
+ response = ESatFailure;
+ TFLOGSTRING2( "CSatUiActionPerformer::PlayTone error %i", err )
+ }
+
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone UserSelectedTone exit" )
+ }
+
+ if ( iActionImplementer->GetEndKey() )
+ {
+ response = ESatSessionTerminatedByUser;
+ iActionImplementer->SetEndKey( EFalse );
+ }
+
+ iActionImplementer->SetCommandPending( EFalse );
+
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone iClearScreenEvent false" )
+ iClearScreenEvent = EFalse;
+
+ TFLOGSTRING2( "CSatUiActionPerformer::PlayTone response: %d", response )
+ TFLOGSTRING( "CSatUiActionPerformer::PlayTone exit" )
+ return response;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::ConfirmCommand
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+void CSatUiActionPerformer::ConfirmCommand(
+ const TSatSQueryCommand aCommandId,
+ const TSatAlphaIdStatus aAlphaIdStatus,
+ const TDesC& aText,
+ const TDesC& aAdditionalText,
+ TBool& aActionAccepted,
+ const TSatIconId& aIconId,
+ TBool& aRequestedIconDisplayed,
+ TBool& aTerminatedByUser )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::ConfirmCommand calling" )
+ aRequestedIconDisplayed = EFalse;
+ TInt error( KErrNone );
+ TBool selfExplanatory( EFalse );
+
+ // Icon is self-explanatory
+ if ( ESatSelfExplanatory == aIconId.iIconQualifier )
+ {
+ selfExplanatory = ETrue;
+ }
+
+ aActionAccepted = ETrue;
+
+ iActionImplementer->SetCommandPending( ETrue );
+
+ iActionImplementer->StopShowWaitNote();
+
+ CFbsBitmap* iconBitmap = NULL;
+ // If icon is available for command
+ if ( ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||
+ ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&
+ ( ( ESatOpenChannelQuery == aCommandId ) ||
+ ( ESatSLaunchBrowserQuery == aCommandId ) ||
+ ( ESatSSetUpCallQuery == aCommandId ) ) ) &&
+ ( iIconSupport ) )
+ {
+ iconBitmap = FetchIcon( aIconId.iIdentifier,
+ EIconConfirmCommand );
+ GetScalableBitmap( iconBitmap, EIconConfirmCommand,
+ aRequestedIconDisplayed );
+ }
+ TFLOGSTRING2( "CSatUiActionPerformer::ConfirmCommand aCommandId: %d",
+ aCommandId )
+ // Check quering command
+ switch ( aCommandId )
+ {
+ case ESatOpenChannelQuery:
+ {
+ TFLOGSTRING( " Quering OpenChannel" )
+ TRAP( error, iActionImplementer->ConfirmOpenChannelL(
+ aText, aActionAccepted, iconBitmap, selfExplanatory ) );
+ break;
+ }
+
+ case ESatSRefreshQuery:
+ {
+ TFLOGSTRING( " Quering Refresh" )
+ TRAP(
+ error, iActionImplementer->ConfirmRefreshL( aActionAccepted );
+ );
+ break;
+ }
+
+ case ESatSLaunchBrowserQuery:
+ {
+ TFLOGSTRING( " Quering LaunchBrowser" )
+ HBufC* textHolder = NULL;
+
+ TRAP( error,
+ if ( ESatAlphaIdNull != aAlphaIdStatus )
+ {
+ TFLOGSTRING( " CSatUiActionPerformer::ConfirmCommand AlphaId \
+ isn't null" )
+ if ( ESatAlphaIdNotProvided == aAlphaIdStatus )
+ {
+ TFLOGSTRING( " CSatUiActionPerformer::ConfirmCommand \
+ AlphaId not provided" )
+ textHolder = StringLoader::LoadLC(
+ R_QTN_SAT_CONF_LAUNCH_BROW,
+ iActionImplementer->CoeEnv() );
+ }
+ else
+ {
+ TFLOGSTRING( " CSatUiActionPerformer::ConfirmCommand \
+ AlphaId provided" )
+ textHolder = HBufC::NewLC( aText.Length() );
+ TPtr ptr = textHolder->Des();
+ ptr.Append( aText );
+ }
+
+ iActionImplementer->ConfirmLaunchBrowserL( *textHolder,
+ aActionAccepted, iconBitmap, selfExplanatory );
+ // Clean textHolder
+ CleanupStack::PopAndDestroy( textHolder );
+ }
+
+ ); // TRAP
+ break;
+ }
+
+ case ESatSSendSmQuery:
+ {
+ TFLOGSTRING( " Quering SendSm" )
+ TRAP( error, iActionImplementer->ConfirmSendL( aText,
+ aActionAccepted, ESatUiConfirmSendSms ) );
+ break;
+ }
+
+ case ESatSSendSsQuery:
+ {
+ TFLOGSTRING( " Quering SendSs" )
+ TRAP( error, iActionImplementer->ConfirmSendL( aText,
+ aActionAccepted, ESatUiConfirmSendSs ) );
+ break;
+ }
+
+ case ESatSSendUssdQuery:
+ {
+ TFLOGSTRING( " Quering SendUssd" )
+ TRAP( error, iActionImplementer->ConfirmSendL( aText,
+ aActionAccepted, ESatUiConfirmSendUssd ) );
+ break;
+ }
+
+ case ESatSSetUpCallQuery:
+ {
+ TFLOGSTRING( " Quering SetUpCall" )
+ TRAP( error, iActionImplementer->ConfirmSetUpCallL(
+ aText, aAdditionalText, aActionAccepted, iconBitmap,
+ selfExplanatory ) );
+ break;
+ }
+
+ default:
+ {
+ TFLOGSTRING( " Unknown quering command" )
+ aActionAccepted = EFalse;
+ }
+ }
+
+ if ( KErrNone != error )
+ {
+ TFLOGSTRING2( "CSatUiActionPerformer::ConfirmCommand error:%d", error )
+ aActionAccepted = EFalse;
+ }
+ else if ( iActionImplementer->GetEndKey() )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::ConfirmCommand press endkey" )
+ aTerminatedByUser = ETrue;
+ aActionAccepted = EFalse;
+ iActionImplementer->SetEndKey( EFalse );
+ }
+ else
+ {
+ // Meaningless else
+ }
+
+ iActionImplementer->SetCommandPending( EFalse );
+ TFLOGSTRING( "CSatUiActionPerformer::ConfirmCommand exiting" )
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::Notification
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TSatUiResponse CSatUiActionPerformer::Notification(
+ const TSatSNotifyCommand aCommandId,
+ const TSatAlphaIdStatus aAlphaIdStatus,
+ const TDesC& aText,
+ const TSatIconId& aIconId,
+ TBool& aRequestedIconDisplayed,
+ const TSatControlResult aControlResult )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::Notification calling" )
+ TSatUiResponse response = ESatSuccess;
+ TInt error( KErrNone );
+ aRequestedIconDisplayed = EFalse;
+ iActionImplementer->SetCommandPending( ETrue );
+
+ HBufC* textHolder = NULL;
+
+ // In case where command id is SendDtmf and alphaID is not provided,
+ // DTMF string to be sent is shown in dialog along with default text.
+ if ( ( ESatSSendDtmfNotify == aCommandId ) &&
+ ( ESatAlphaIdNotProvided == aAlphaIdStatus ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::Notification SendDtmf" )
+ TRAP( error,
+ TInt resource = DefaultAlphaIdL( aCommandId, aControlResult );
+ // Now that resource is defined, get default text
+ textHolder = StringLoader::LoadL(
+ resource, aText )
+ );
+ }
+ // Get default text, if alpha not provided or it is NULL
+ else if ( aText.Length() == 0 && ESatAlphaIdNotNull != aAlphaIdStatus )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::Notification alpha is null" )
+ TRAP( error,
+ TInt resource = DefaultAlphaIdL( aCommandId, aControlResult );
+ // Now that resource is defined, get default text
+ textHolder = StringLoader::LoadL(
+ resource, iActionImplementer->CoeEnv() )
+ );
+ }
+ // else use given text
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::Notification alpha is provided" )
+ TRAP( error,
+ textHolder = HBufC::NewL( aText.Length() );
+ TPtr ptr = textHolder->Des();
+ ptr.Copy( aText );
+ );
+ }
+
+ if ( !textHolder )
+ {
+ TRAP( error, textHolder = HBufC::NewL( 0 ) );
+ }
+
+ // No need to add textHolder into CleanupStack, since this is
+ // not a leaving function
+
+ if ( ( KErrNone == error || KErrArgument == error ) && textHolder )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::Notification none error " )
+ CFbsBitmap* iconBitmap = NULL;
+ TBool selfExplanatoryIcon( EFalse );
+ // Fetch icon
+ // Icons not supported for sending and receiving data
+ if ( ( ( ( ESatSelfExplanatory == aIconId.iIconQualifier ) ||
+ ( ESatNotSelfExplanatory == aIconId.iIconQualifier ) ) &&
+ ( ( ESatSSendDataNotify != aCommandId ) &&
+ ( ESatSReceiveDataNotify != aCommandId ) ) ) &&
+ ( iIconSupport ) )
+ {
+ iconBitmap = FetchIcon( aIconId.iIdentifier,
+ EIconNotification );
+ GetScalableBitmap( iconBitmap, EIconNotification,
+ aRequestedIconDisplayed );
+ }
+
+ if ( ESatSelfExplanatory == aIconId.iIconQualifier )
+ {
+ selfExplanatoryIcon = ETrue;
+ }
+
+ // Check notifying command
+ switch ( aCommandId )
+ {
+ case ESatSSendDataNotify:
+ {
+ TFLOGSTRING( " Notifying SendData" )
+ TRAP( error,
+ iActionImplementer->ShowBIPNoteL(
+ ESendDataIdentier, *textHolder, iconBitmap,
+ selfExplanatoryIcon )
+ );
+ break;
+ }
+ case ESatSReceiveDataNotify:
+ {
+ TFLOGSTRING( " Notifying ReceiveData" )
+ TRAP( error,
+ iActionImplementer->ShowBIPNoteL(
+ EReceiveDataIdentifier, *textHolder, iconBitmap,
+ selfExplanatoryIcon )
+ );
+ break;
+ }
+ case ESatSCloseChannelNotify:
+ {
+ TFLOGSTRING( " Notifying CloseChannel" )
+ iActionImplementer->StopShowWaitNote();
+ TRAP( error,
+ iActionImplementer->ShowBIPNoteL(
+ ECloseChannelIdentifier, *textHolder, iconBitmap,
+ selfExplanatoryIcon )
+ );
+ break;
+ }
+ case ESatSMoSmControlNotify:
+ {
+ TFLOGSTRING( " Notifying MoSmControl" )
+ TRAP( error,
+ iActionImplementer->MoSmControlL(
+ *textHolder, aAlphaIdStatus )
+ );
+ iActionImplementer->SetCommandPending( EFalse );
+ break;
+ }
+ case ESatSCallControlNotify:
+ {
+ TFLOGSTRING( " Notifying CallControl" )
+ iActionImplementer->DispatchTimer( iWait );
+ TRAP( error,
+ iActionImplementer->CallControlL(
+ *textHolder, aAlphaIdStatus )
+ );
+ iActionImplementer->SetCommandPending( EFalse );
+ break;
+ }
+ case ESatSSendUssdNotify: // fall through
+ case ESatSSendSsNotify:
+ {
+ TFLOGSTRING( " Notifying SendSs / SendUssd" )
+ iActionImplementer->StopShowWaitNote();
+ TRAP( error,
+ if ( ( ESatAlphaIdNotNull == aAlphaIdStatus ) ||
+ ( ESatAlphaIdNotProvided == aAlphaIdStatus ) )
+ {
+ iActionImplementer->ShowSsWaitNoteL( *textHolder,
+ iconBitmap, selfExplanatoryIcon );
+ }
+ else
+ {
+ iActionImplementer->ShowWaitNoteWithoutDelayL();
+ }
+ );
+ break;
+ }
+ case ESatSSendDtmfNotify:
+ {
+ TFLOGSTRING( " Notifying SendDtmf" )
+ iActionImplementer->StopShowWaitNote();
+ TRAP( error, response = iActionImplementer->ShowDtmfWaitNoteL(
+ *textHolder, iconBitmap, selfExplanatoryIcon ) );
+ break;
+ }
+ case ESatSSendSmsNotify:
+ {
+ TFLOGSTRING( " Notifying SendSms" )
+ iActionImplementer->StopShowWaitNote();
+
+ if ( KErrNone == error )
+ {
+ // Show Sms wait note
+ TRAP( error,
+ iActionImplementer->ShowSmsWaitNoteL( *textHolder,
+ iconBitmap, selfExplanatoryIcon ) );
+ }
+
+ break;
+ }
+ default:
+ {
+ TFLOGSTRING( " Unkown notification" )
+ response = ESatFailure;
+ break;
+ }
+ }
+ }
+
+ delete textHolder;
+ textHolder = NULL;
+
+ if ( KErrNone != error )
+ {
+ TFLOGSTRING2( "CSatUiActionPerformer::Notification error:%d", error )
+ response = ESatFailure;
+ }
+ else if ( iActionImplementer->GetEndKey() )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::Notification terminated by user" )
+ response = ESatSessionTerminatedByUser;
+ iActionImplementer->SetEndKey( EFalse );
+ }
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::Notification success" )
+ response = ESatSuccess;
+ }
+
+
+ TFLOGSTRING2( "CSatUiActionPerformer::Notification exiting, return: %d", \
+ response )
+ return response;
+ }
+
+// -----------------------------------------------------------------------------
+// CSatUiActionPerformer::EventNotification
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CSatUiActionPerformer::EventNotification(
+ const TSatSEvent aEventId,
+ const TSatSEventStatus /*aEventStatus*/,
+ const TInt /*aError*/ )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::EventNotification calling" )
+
+ iActionImplementer->SetCommandPending( EFalse );
+ switch ( aEventId )
+ {
+ case ESatSSmEndEvent:
+ {
+ TFLOGSTRING( " SmsEnd event" )
+ iActionImplementer->StopShowWaitNote();
+ break;
+ }
+ case ESatSClearScreenEvent:
+ {
+ TFLOGSTRING( " ClearScreen event" )
+ iClearScreenEvent = ETrue;
+ iActionImplementer->ClearScreen();
+ break;
+ }
+ case ESatSsEndEvent:
+ {
+ TFLOGSTRING( " Ss end event" )
+ iActionImplementer->StopShowWaitNote();
+ break;
+ }
+ case ESatSsErrorEvent:
+ {
+ TFLOGSTRING( " Notifying Ss error" )
+ // If error occurred (and Alpha ID provided), notify user
+ TRAPD( err, iActionImplementer->ShowSsErrorNoteL() )
+
+ if ( err )
+ {
+ TFLOGSTRING( " Error Note could not be created!" )
+ }
+ break;
+ }
+ case ESatSDtmfEndEvent:
+ {
+ TFLOGSTRING( " DTMF End event" )
+ iActionImplementer->StopShowWaitNote();
+ break;
+ }
+ case ESatSCloseSatUiAppEvent:
+ {
+ TFLOGSTRING( " Close UI event" )
+ // Handle this similar way when End key is used
+ if ( KSatActiveProfileOffline ==
+ iActionImplementer->ProfileState() )
+ {
+ iActionImplementer->SetEndKey( ETrue );
+ TRAP_IGNORE( iActionImplementer->ShowNotAvailableNoteL() )
+ }
+ iActionImplementer->CloseSatUI();
+ break;
+ }
+ default:
+ {
+ TFLOGSTRING2( " Unknown event occured: %i", aEventId )
+ break;
+ }
+ }
+
+ TFLOGSTRING( "CSatUiActionPerformer::EventNotification exiting" )
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::DefaultAlphaIdL
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TInt CSatUiActionPerformer::DefaultAlphaIdL(
+ const TSatSNotifyCommand aCommandId,
+ const TSatControlResult aControlResult ) const
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::DefaultAlphaIdL calling" )
+ TInt resource( 0 );
+
+ switch ( aCommandId )
+ {
+ case ESatSSendDataNotify: // SendData
+ {
+ TFLOGSTRING( " SendData default" )
+ resource = R_QTN_SAT_CONF_SEND_DATA_BIP;
+ break;
+ }
+
+ case ESatSReceiveDataNotify: // ReceiveData
+ {
+ TFLOGSTRING( " ReceiveData default" )
+ resource = R_QTN_SAT_CONF_RECEIVE_DATA_BIP;
+ break;
+ }
+
+ case ESatSCloseChannelNotify: // CloseChannel
+ {
+ TFLOGSTRING( " CloseChannel default" )
+ resource = R_QTN_SAT_CONF_CLOSE_CHANNEL_BIP;
+ break;
+ }
+
+ case ESatSMoSmControlNotify: // MoSmControl
+ {
+ if ( ESatNotAllowed == aControlResult )
+ {
+ TFLOGSTRING( " MoSmcontrol Not allowed default" )
+ resource = R_QTN_SAT_MOSM_NOT_ALLOWED;
+ }
+ else if ( ESatAllowedWithModifications == aControlResult )
+ {
+ TFLOGSTRING( " MoSmcontrol Modified default" )
+ resource = R_QTN_SAT_MOSM_MODIFIED;
+ }
+ else
+ {
+ TFLOGSTRING( " MoSmcontrol No default" )
+ resource = 0; // Allowed, default alpha -> no info
+ }
+ break;
+ }
+
+ case ESatSCallControlNotify: // CallControl
+ {
+ if ( ESatNotAllowed == aControlResult )
+ {
+ TFLOGSTRING( " CallControl Not allowed default" )
+ resource = R_QTN_SAT_CC_NOT_ALLOWED;
+ }
+ else if ( ESatAllowedWithModifications == aControlResult )
+ {
+ TFLOGSTRING( " CallControl Modified default" )
+ resource = R_QTN_SAT_CC_MODIFIED;
+ }
+ else
+ {
+ TFLOGSTRING( " CallControl No default" )
+ resource = 0; // Allowed, default alpha -> no info
+ }
+ break;
+ }
+
+ case ESatSSendSmsNotify: // SendSm
+ {
+ TFLOGSTRING( " SendSms default" )
+ resource = R_QTN_SAT_SENDING_SMS;
+ break;
+ }
+
+ case ESatSSendDtmfNotify: // SendDtmf
+ {
+ TFLOGSTRING( " SendDTMF default" )
+ resource = R_QTN_SAT_NOTE_SENDING_DTMF_TEMPLATE;
+ break;
+ }
+
+ default:
+ {
+ TFLOGSTRING2( " Unknown command id: %i", aCommandId )
+ User::Leave( KErrArgument );
+ }
+ }
+
+ TFLOGSTRING2( "CSatUiActionPerformer::DefaultAlphaIdL exiting, resource: \
+ %d", resource )
+ return resource;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::FetchIcon
+// Fetch the icon information.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+CFbsBitmap* CSatUiActionPerformer::FetchIcon( const TUint8 aIconId,
+ const enum TIconCommand aIconCommand )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::FetchIcon called" )
+ CFbsBitmap* iconBitmap = NULL;
+
+ TSize layoutSize( 0, 0 );
+
+ // Set icon max size according the command
+ if ( GetPopUpWindowIconSize( layoutSize, aIconCommand ) )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::FetchIcon max size" )
+ TRAPD( err, iconBitmap = iIconHandler->FetchIconL( iSatSession,
+ aIconId, layoutSize.iWidth, layoutSize.iHeight, iIconSupport ) );
+
+ if ( err != KErrNone )
+ {
+ #if defined _DEBUG
+ _LIT( KFetchIcon, "CSatUiActionPerformer::FetchIcon" );
+ User::Panic( KFetchIcon, err );
+ #endif
+ }
+ }
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::FetchIcon not supported" )
+ }
+
+ TFLOGSTRING( "CSatUiActionPerformer::FetchIcon exit" )
+ return iconBitmap;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::GetPopUpWindowIconSize
+// Get size for the icon in popup window.
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+TBool CSatUiActionPerformer::GetPopUpWindowIconSize( TSize& aSize,
+ const TIconCommand aIconCommand )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetPopUpWindowIconSize called" )
+
+ TRect rect( TSize( 0, 0 ) );
+ TBool supported( ETrue );
+ TAknLayoutRect opLogoLayout;
+
+ TFLOGSTRING2( "CSatUiActionPerformer::GetPopUpWindowIconSize, \
+ aIconCommand: %i", aIconCommand )
+ // depending on the command, get correct layout and
+ // Calculate rectangle based on LAF specification.
+ switch ( aIconCommand )
+ {
+ case EIconSetUpMenuContext:
+ {
+ opLogoLayout.LayoutRect( rect,
+ AknLayoutScalable_Avkon::context_pane_g1().LayoutLine() );
+ break;
+ }
+ case EIconSetUpMenuItems:
+ {
+ opLogoLayout.LayoutRect( rect,
+ AknLayout::List_pane_elements__single_graphic__Line_1() );
+ break;
+ }
+ case EIconDisplayText:
+ {
+ // layout borrowed from video
+ opLogoLayout.LayoutRect( rect, AknLayoutScalable_Avkon::
+ popup_query_sat_info_window( 0 ).LayoutLine() );
+ break;
+ }
+ case EIconPlayTone:
+ {
+ opLogoLayout.LayoutRect( rect, AknLayoutScalable_Avkon::
+ popup_note_window_g1( 0 ).LayoutLine() );
+ break;
+ }
+ case EIconConfirmCommand: // fall through
+ case EIconGetInput: // fall through
+ case EIconGetYesNo: // fall through
+ case EIconGetInkey:
+ {
+ opLogoLayout.LayoutRect( rect, AknLayout::Icon( 0 ) );
+ break;
+ }
+ case EIconNotification:
+ {
+ opLogoLayout.LayoutRect( rect, AknLayout::
+ Wait_or_progress_note_pop_up_window_elements_Line_1() );
+ break;
+ }
+ default:
+ {
+ TFLOGSTRING(
+ "CSatUiActionPerformer::GetPopUpWindowIconSize not supported" )
+ supported = EFalse;
+ break;
+ }
+ }
+
+ aSize = opLogoLayout.Rect().Size();
+
+ // Layout for title icon gives incorrect width
+ // but since it is square height can be set to width
+ if ( EIconSetUpMenuContext == aIconCommand )
+ {
+ aSize.iWidth = aSize.iHeight;
+ }
+
+ TFLOGSTRING3( "CSatUiActionPerformer::GetPopUpWindowIconSize %dx%d exit",
+ aSize.iWidth, aSize.iHeight )
+ return supported;
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::GetScalableBitmap
+// Creates scalable bitmap
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+void CSatUiActionPerformer::GetScalableBitmapL(
+ CFbsBitmap*& aBitMapToConvert,
+ const TIconCommand aIconCommand )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap called" )
+ TSize layoutSize( 0, 0 );
+ CFbsBitmap* bitmap = NULL;
+
+ // If scalable icon is supported in current layout then
+ // makes the scalable icon.
+ if ( GetPopUpWindowIconSize( layoutSize, aIconCommand ) )
+ {
+ bitmap = new ( ELeave ) CFbsBitmap;
+ CleanupStack::PushL( bitmap );
+ // CAknIcon takes ownership of bitmaps.
+ CFbsBitmap* dupMain = new ( ELeave ) CFbsBitmap;
+ CleanupStack::PushL( dupMain );
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap duplicate original" )
+ User::LeaveIfError(
+ dupMain->Duplicate( aBitMapToConvert->Handle() ) );
+
+ CAknIcon* bitmapIcon = CAknIcon::NewL();
+ // Mask is not set because skins are not used.
+ // Ownership is transferred.
+ bitmapIcon->SetBitmap( dupMain );
+ CleanupStack::Pop( dupMain );
+ CleanupStack::PushL( bitmapIcon );
+ CAknIcon* scalableIcon = AknIconUtils::CreateIconL( bitmapIcon );
+ CleanupStack::Pop( bitmapIcon );
+ CleanupStack::PushL( scalableIcon );
+
+ // fetch the size of icon
+ TSize iconSize = dupMain->SizeInPixels();
+
+ // At first we assume that width is scaled to layout maximum and
+ // thus height is set so that the ratio of the image remains correct
+
+ TInt newHeight =
+ ( layoutSize.iWidth * iconSize.iHeight ) / iconSize.iWidth;
+
+ // If the new height is larger than the height of the layout
+ // we scale height to maximum and set the width so that the ratio of
+ // the image remains correct
+ if ( newHeight > layoutSize.iHeight )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap \
+ larger than layout height" )
+ layoutSize.iWidth =
+ ( layoutSize.iHeight * iconSize.iWidth ) / iconSize.iHeight;
+ }
+ // If the new height is smaller or the same as the height of the
+ // layout, the image is scaled according to it
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap \
+ smaller than layout height" )
+ layoutSize.iHeight = newHeight;
+ }
+
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap resize scaled icon" )
+ AknIconUtils::SetSize( scalableIcon->Bitmap(), layoutSize );
+
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap duplicate scaled" )
+ User::LeaveIfError( bitmap->Duplicate(
+ scalableIcon->Bitmap()->Handle() ) );
+
+ CleanupStack::PopAndDestroy( scalableIcon );
+
+ // Uses scaled icon if scalable bitmap is supported.
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap Show Scaled" )
+ delete aBitMapToConvert;
+ aBitMapToConvert = bitmap;
+ CleanupStack::Pop( bitmap );
+ }
+
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap exit" )
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::GetScalableBitmap
+// Handles scalable bitmap
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+void CSatUiActionPerformer::GetScalableBitmap(
+ CFbsBitmap*& aBitMapToConvert,
+ const TIconCommand aIconCommand,
+ TBool& aRequestedIconDisplayed )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap called" )
+
+ if ( aBitMapToConvert )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap bitmap \
+ to convert" )
+ // Scale icon
+ TRAPD( err, GetScalableBitmapL( aBitMapToConvert, aIconCommand ); );
+
+ if ( KErrNoMemory == err )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap memory \
+ low" )
+ // Memory low, command is done without icon
+ delete aBitMapToConvert;
+ aBitMapToConvert = NULL;
+ aRequestedIconDisplayed = EFalse;
+ }
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap have \
+ memory" )
+ aRequestedIconDisplayed = ETrue;
+ }
+ }
+ else
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap no bitmap" )
+ // Icon not received
+ aRequestedIconDisplayed = EFalse;
+ }
+
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap exit" )
+ }
+
+// ---------------------------------------------------------
+// CSatUiActionPerformer::GetScalableBitmap
+// Handles scalable bitmap
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+void CSatUiActionPerformer::GetScalableBitmap(
+ CFbsBitmap*& aBitMapToConvert,
+ const TIconCommand aIconCommand )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap called" )
+
+ if ( aBitMapToConvert )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap bitmap \
+ to convert" )
+ // Scale icon
+ TRAPD( err, GetScalableBitmapL( aBitMapToConvert, aIconCommand ); );
+
+ if ( KErrNoMemory == err )
+ {
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap memory \
+ low" )
+ // Memory low, command is done without icon
+ delete aBitMapToConvert;
+ aBitMapToConvert = NULL;
+ }
+ }
+
+ TFLOGSTRING( "CSatUiActionPerformer::GetScalableBitmap exit" )
+ }
+
+// End of File