diff -r 7d48bed6ce0c -r 987c9837762f satui/satapp/SATUISrc/CSatUiViewAppUi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/satui/satapp/SATUISrc/CSatUiViewAppUi.cpp Wed Sep 01 12:15:03 2010 +0100 @@ -0,0 +1,3563 @@ +/* +* Copyright (c) 2002-2010 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: +* Implements the application UI and the methods derived from +* MSatUiActionImplementer i.e. showing messages and asking input. +* +* +*/ + + +// INCLUDE FILES +#include +#include // for descriptor arrays +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include //DisplayText icon popupform +#include //CEikCaptionedControl +#include //CRichText +#include //CEikRichTextEditor +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "satui.hrh" +#include "CSatUiApplication.h" +#include "CSatUiViewAppUi.h" +#include "CSatUiView.h" +#include "CSatUiTextQueryDialog.h" +#include "CSatUiMessageQueryIcon.h" +#include "CSatUiWaitDialog.h" +#include "tflogger.h" + +#include +#include +#include +#include +#include +#include +#include // Used for FeatureManager +#include // For BT SAP connection state keys. +#include // Used for RProperty +#include + +#include +#include +#include +#include + +#include +#include + + +// CONSTANTS +const TInt KSatActiveProfileOffline = 5; // value from ProfileEngine +const TInt K32TIntMaxValue = 0x7FFFFFFF; +// From UI spec 60 sec delay user response. +const TInt KNoResponseFromUserDelay = 60; +const TInt KMicroSecondsInSecond = 1000000; +const TInt KClearScreenDelay = 3; +const TInt KMicroSecondsInTenthOfSecond = 100000; +const TInt K3Seconds = 3000000; + +// Maximum length for sound file. +const TInt KMaxSoundFileLength = 256; +// Audio sample is repeated indefinitely. +const TInt KSoundPlayerRepeatForever = KMdaRepeatForever; +// Used when dividing some values. Used only for preventing the use of magic +// numbers +const TInt KDivideByEight = 8; + +const TUint8 KGetInputStringMaxSize = 0xEF; + +_LIT( K3Spaces, " " ); // Used for empty title. +const TInt KEmptyTitleLength( 3 ); // Length of empty title. +_LIT( KSatEmptySpace, " " ); // Used for empty item. +_LIT( KSatEmptyDes, "" ); + +const TUint8 KKeyZero = 0x30; +const TUint8 KKeyNine = 0x39; +const TUint8 KHwAsterisk = 0x2a; // In hw scan code value for asterisk + +// The max volume value from settings. +// From TProfileToneSettings.h +const TInt KMaxVolumeFromProfile( 10 ); + +// ================= MEMBER FUNCTIONS ======================= + +// C++ default constructor can NOT contain any code, that +// might leave. +// +CSatUiViewAppUi::CSatUiViewAppUi(): + iHelp( EFalse ), + iSetUpMenuFirst( ETrue ), + iSelectItemFirst( ETrue ), + iPreviousForeground( EFalse ), + iViewLoopCounter( 0 ), + iDuration( TTimeIntervalMicroSeconds( static_cast( 0 ) ) ), + iReqWSBufferID( KErrNone ) + { + } + +// Symbian OS default constructor can leave. +void CSatUiViewAppUi::ConstructL() + { + TFLOGSTRING( "CSatUiViewAppUi::ConstructL() called" ) + BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible ); + + // Requests Window Server client buffer used by the application to + // be of at least the given size. + iReqWSBufferID = CAknEnv::Static()->RequestWsBuffer( KAknMaxWsBufferSize ); + TFLOGSTRING2( "iReqWSBufferID is %d", iReqWSBufferID ) + + if ( BTSAPActivatedL() ) + { + HBufC* sapText = + iCoeEnv->AllocReadResourceLC( R_QTN_OFFLINE_NOT_POSSIBLE_SAP ); + CAknInformationNote* note = new ( ELeave ) CAknInformationNote( ETrue ); + iForegroundControl = note; + note->ExecuteLD( *sapText ); + iForegroundControl = NULL; + CleanupStack::PopAndDestroy( sapText ); + Exit(); + } + + if ( ProfileState() == KSatActiveProfileOffline ) + { + ShowNotAvailableNoteL(); + Exit(); + } + + + if ( StatusPane()->PaneCapabilities( TUid::Uid( + EEikStatusPaneUidTitle ) ).IsPresent() ) + { + CAknTitlePane* titlePane = STATIC_CAST( CAknTitlePane*, + StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) ); + titlePane->SetTextL( KNullDesC ); + titlePane->DrawNow(); + } + + TFLOGSTRING( "CSatUiViewAppUi::ConstructL() exit" ) + } + +// Destructor. +CSatUiViewAppUi::~CSatUiViewAppUi() + { + TFLOGSTRING( "CSatUiViewAppUi::~CSatUiViewAppUi() called" ) + this->StopShowWaitNote(); + + delete iTitle; + delete iAppName; + delete iPlayer; + delete iTimer; + + TFLOGSTRING( "CSatUiViewAppUi::~CSatUiViewAppUi() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::CreateEmptyMenuL +// Creates empty menu. This is used in SIM originated commands. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::CreateEmptyMenuL() + { + TFLOGSTRING( "CSatUiViewAppUi::CreateEmptyMenuL() called" ) + + // Create the menu item array with no content. + CDesCArrayFlat* menuItems = new( ELeave ) CDesCArrayFlat( 1 ); + CleanupStack::PushL( menuItems ); + menuItems->Reset(); + menuItems->AppendL( KSatEmptySpace ); + + // Create the empty next action indicator array. + CArrayFixFlat* menuActions = + new( ELeave ) CArrayFixFlat( 1 ); + CleanupStack::PushL( menuActions ); + menuActions->Reset(); + + // Create empty title pane. + HBufC* satTitle = HBufC::NewLC( KEmptyTitleLength ); + satTitle->Des().Append( K3Spaces ); + + iSetUpMenuFirst = EFalse; + iSetUpMenuView = CSatUiView::NewL( ETrue, this, ETrue ); + iSetUpMenuView->SetItemsL( satTitle, + *menuItems, + menuActions, + EFalse ); + + // Hide list box. + iSetUpMenuView->MakeListBoxVisible( EFalse ); + + // Transfer ownership to CAknViewAppUi. + AddViewL( iSetUpMenuView ); + + iSetUpMenuView->SetAdapter( iAdapter ); + iActiveView = KSetUpMenuViewId; + + // satTitle, menuActions, menuItems + CleanupStack::PopAndDestroy( satTitle ); + CleanupStack::PopAndDestroy( menuActions ); + CleanupStack::PopAndDestroy( menuItems ); + TFLOGSTRING( "CSatUiViewAppUi::CreateEmptyMenuL() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::SetAdapter +// Sets the pointer to MSatUiAdapter object. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::SetAdapter( + MSatUiAdapter* aAdapter ) + { + iAdapter = aAdapter; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ShowWaitNoteL +// Displays the wait note. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ShowWaitNoteL() + { + TFLOGSTRING( "CSatUiViewAppUi::ShowWaitNoteL() called" ) + if ( !iWaitNote ) + { + iWaitNote = new(ELeave)CAknWaitDialog( + (REINTERPRET_CAST(CEikDialog**,&iWaitNote))); + iForegroundControl = iWaitNote; + iWaitNote->ExecuteLD( R_SATUI_WAIT_NOTE ); + // iForegroundControl won't be clear until the wait dialog + // closed. It will avoid we lose the chance to set focus for + // the wait dialog when the switch of foreground/background + // happened. + } + TFLOGSTRING( "CSatUiViewAppUi::ShowWaitNoteL() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ShowWaitNoteWithoutDelayL +// Displays the wait note without delay +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ShowWaitNoteWithoutDelayL() + { + TFLOGSTRING( "CSatUiViewAppUi::ShowWaitNoteWithoutDelayL() called" ) + if ( !iWaitNote ) + { + iWaitNote = new(ELeave)CAknWaitDialog( + (REINTERPRET_CAST(CEikDialog**,&iWaitNote)), ETrue ); + iForegroundControl = iWaitNote; + iWaitNote->ExecuteLD( R_SATUI_WAIT_NOTE ); + // iForegroundControl won't be clear until the wait dialog + // closed. It will avoid we lose the chance to set focus for + // the wait dialog when the switch of foreground/background + // happened. + } + TFLOGSTRING( "CSatUiViewAppUi::ShowWaitNoteWithoutDelayL() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::StopShowWaitNote +// Removes the wait note from the screen. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::StopShowWaitNote() + { + TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() called" ) + + if ( iNoteDialog ) + { + iForegroundControl = NULL; + + TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() Closing \ + NoteDialog" ) + delete iNoteDialog; + iNoteDialog = NULL; + } + + if ( iWaitNote ) + { + iForegroundControl = NULL; + + TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() Closing WaitNote" ) + // Process finished. The function was either ExecuteLD or RunLD. + // This function call stops the execution of these function and + // causes the deletion of object + TInt err(0); + TRAP( err, iWaitNote->ProcessFinishedL() ) + TFLOGSTRING2(" 2nd: iWaitNote: %x ", iWaitNote ) + TFLOGSTRING2( "TRAP: %d", err ) + // Delete the object just in case. Seems that above method does not + // delete the object in some cases. e.g in very fast execution + delete iWaitNote; + iWaitNote = NULL; + } + if ( iBipWaitNote ) + { + iForegroundControl = NULL; + + TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() Closing BIP note" ) + delete iBipWaitNote; + iBipWaitNote = NULL; + } + + if ( iPermanentNote ) + { + TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() \ + iPermanentNote cleared" ) + // If iPermanentNote exists until wait note is stopped, + // then dialog has been already removed. + iPermanentNote->ExitSleepingDialog(); + delete iPermanentNote; + iPermanentNote = NULL; + } + + TFLOGSTRING( "CSatUiViewAppUi::StopShowWaitNote() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::BTSAPActivatedL +// Check that if BT SAP connection activated. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TBool CSatUiViewAppUi::BTSAPActivatedL() + { + + TFLOGSTRING( "CSatUiViewAppUi::BTSAPActivated() called" ) + + TBool isActive( EFalse ); + FeatureManager::InitializeLibL(); + if ( FeatureManager::FeatureSupported( KFeatureIdBtSap ) ) + { + TFLOGSTRING( "BTSAP is supported by ME" ) + TInt status( EBTSapNotConnected ); + TInt err = RProperty::Get( KPSUidBluetoothSapConnectionState, + KBTSapConnectionState, + status ); + + if ( EBTSapNotConnected != status && !err ) + { + TFLOGSTRING( "BTSAP is connected" ) + isActive = ETrue; + } + else + { + TFLOGSTRING3( "BTSAP status %d and error %d", status, err ) + } + } + else + { + TFLOGSTRING( "BTSAP is not supported by ME" ) + } + + FeatureManager::UnInitializeLib(); + TFLOGSTRING( "CSatUiViewAppUi::BTSAPActivated() exit" ) + return isActive; + + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::CoeEnv +// Returns CoeEnv. +// (other items were commented in a header). +// --------------------------------------------------------- +// +CCoeEnv* CSatUiViewAppUi::CoeEnv() + { + return iCoeEnv; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::DisplayTextL +// Displays the text in a note. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::DisplayTextL( + const TDesC& aText, + const TDesC& aSimApplicationName, + CFbsBitmap* aIconBitmapDisplayText, + const TBool aSelfExplanatoryIcon, + const TBool aSustainedText, + const TTimeIntervalSeconds aDuration, + const TBool aWaitUserToClear ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL called" ) + StopShowWaitNote(); + + TSatUiResponse response( ESatSuccess ); + iHighPriorityEvent = EFalse; + + // Indication immediate response TLV for Display Text during MT call, + // if it is immediate response, close dialog, otherwise leave it alone. + iImmediateRsp = aSustainedText; + TFLOGSTRING2( "CSatUiViewAppUi::DisplayTextL immediate rsp: %d", + iImmediateRsp ) + + HBufC* header; + + if ( iHelp ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL iHelp ETrue" ) + header = StringLoader::LoadLC( + R_QTN_SAT_HELP_HEADER, iCoeEnv ); + iHelp = EFalse; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL iHelp EFalse" ) + TFLOGSTRING2( "CSatUiViewAppUi::DisplayTextL length of \ + aSimApplicationName: %d", aSimApplicationName.Length() ) + if ( aSimApplicationName.Length() > 0 ) + { + header = aSimApplicationName.AllocLC(); + } + else + { + //Reads a resource string with memory allocation + header = StringLoader::LoadLC( R_QTN_SAT_MESSAGE_HEADER, iCoeEnv ); + } + } + + // Remove NULL characters from title + RemoveNullCharacters( header ); + + if ( aIconBitmapDisplayText ) + { + //icon available use querydialog + iDisplayTextIconDialog = CAknPopupForm::NewL(); + } + + CUserActivityManager* activityManager = + CUserActivityManager::NewL( EPriorityNormal ); + + CleanupStack::PushL( activityManager ); + + // Duration handling: + // If duration is given use that value for timeout. + TTimeIntervalSeconds duration ( aDuration ); + + // If user is expected to clear shown dialog and + // duration is NOT given use 60s timeout. + if ( aWaitUserToClear && !aDuration.Int() ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL wait user to clear" ) + duration = TTimeIntervalSeconds( KNoResponseFromUserDelay ); + } + // If user is NOT expected to clear shown dialog and + // duration is NOT given use 3s timeout. + else if ( !aDuration.Int() ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL don't wait user \ + to clear" ) + duration = TTimeIntervalSeconds( KClearScreenDelay ); + } + + // If not sustained or Clear after delay requested start timer + if ( !aSustainedText || aDuration.Int() || !aWaitUserToClear ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL No sustained text" ) + TFLOGSTRING2( "CSatUiViewAppUi::DisplayTextL duration: %d", + duration.Int() ) + + // If duration is given start timer which doesn't + // care about user activity. + if ( aDuration.Int() ) + { + CreateCallBackTimerL( duration.Int() * KMicroSecondsInSecond, + DelayCallback ); + } + // Otherwise start timer which takes account user activity. + else + { + User::ResetInactivityTime(); + activityManager->Start( duration, + TCallBack( DispatchUserInactive, this ), 0 ); + } + } + + TInt userResponse; + + if ( aIconBitmapDisplayText ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL have IconBitmap" ) + // Prepare dialog with icon + iDisplayTextIconDialog->SetPopupFormType( EAknQuery ); + iDisplayTextIconDialog->PrepareLC( R_SATUI_MESSAGE_TEXT_ICON ); + iDisplayTextIconDialog->SetTitleL( *header ); + + // Get richtext control + CEikCaptionedControl* capControl = + iDisplayTextIconDialog->GetControlByControlType + ( EEikCtRichTextEditor ); + CCoeControl* coeControl = NULL; + if ( capControl ) + { + coeControl = capControl->iControl; + } + if ( !coeControl ) + { + User::Leave( KErrUnknown ); + } + CEikRichTextEditor* rtxtEditor = + reinterpret_cast( coeControl ); + + if ( !aSelfExplanatoryIcon ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL not \ + SelfExplanatoryIcon" ) + // Not selfexplanatory icon, add text + // Get font + const CFont* logicalFont = AknLayoutUtils::FontFromId( + EAknLogicalFontSecondaryFont ); + + // Extract font information + TFontSpec fontspec = logicalFont->FontSpecInTwips(); + TCharFormat charFormat( fontspec.iTypeface.iName, + fontspec.iHeight ); + + // Make the font to be anti-aliased + TFontStyle style; + style.SetBitmapType( EAntiAliasedGlyphBitmap ); + charFormat.iFontSpec.iFontStyle = style; + + // Set mask (which settings are set) + TCharFormatMask charFormatMask; + charFormatMask.SetAttrib( EAttColor ); + charFormatMask.SetAttrib( EAttFontTypeface ); + charFormatMask.SetAttrib( EAttFontHeight ); + + // Apply settings + rtxtEditor->RichText()->ApplyCharFormatL( + charFormat, charFormatMask, 0, 0 ); + + // One space between icon and text + rtxtEditor->RichText()->InsertL( 0, KSatEmptySpace ); + rtxtEditor->RichText()->InsertL( 1, aText ); + } + + // Count icon size in twips + CWsScreenDevice* device = CCoeEnv::Static()->ScreenDevice(); + TInt width = device->HorizontalPixelsToTwips( + aIconBitmapDisplayText->SizeInPixels().iWidth ); + TInt height = device->VerticalPixelsToTwips( + aIconBitmapDisplayText->SizeInPixels().iHeight ); + TSize twipsSize( width, height ); + + // Create picture + CSatUiMessageQueryIcon* picture = new( ELeave ) + CSatUiMessageQueryIcon( twipsSize, *aIconBitmapDisplayText ); + TPictureHeader pictureHeader; + pictureHeader.iPicture = TSwizzle( picture ); + //Insert picture + rtxtEditor->RichText()->InsertL( 0, pictureHeader ); + //Needed to show whole picture + _LIT( KString, "\f\f\f"); + rtxtEditor->RichText()->InsertL( rtxtEditor->Text()->DocumentLength(), + KString ); + + // Set MSK same as LSK without any text causing the icon drawing + iDisplayTextIconDialog->ButtonGroupContainer().SetCommandL( + CEikButtonGroupContainer::EMiddleSoftkeyPosition, EAknSoftkeyOk, + KSatEmptyDes ); + iForegroundControl = iDisplayTextIconDialog; + userResponse = iDisplayTextIconDialog->RunLD(); + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL don't have IconBitmap" ) + // Dialog without icon + iDisplayTextDialog = new (ELeave) CAknMessageQueryDialog(); + iDisplayTextDialog->PrepareLC( R_SATUI_MESSAGE ); + iDisplayTextDialog->SetMessageTextL( aText ); + iDisplayTextDialog->QueryHeading()->SetTextL( *header ); + + // Set MSK same as LSK without any text causing the icon drawing + iDisplayTextDialog->ButtonGroupContainer().SetCommandL( + CEikButtonGroupContainer::EMiddleSoftkeyPosition, EAknSoftkeyOk, + KSatEmptyDes ); + iForegroundControl = iDisplayTextDialog; + userResponse = iDisplayTextDialog->RunLD(); + } + iForegroundControl = NULL; + + CleanupStack::PopAndDestroy( activityManager ); + CleanupStack::PopAndDestroy( header ); // header,activityManager + // After duration call back timer is destroyed + DestroyCallBackTimer(); + + // If user is not expected to clear message used response is success + // in timeout case. + if ( userResponse + || ( iNoteClearedAfterDelay && !aWaitUserToClear ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL successful response" ) + response = ESatSuccess; + } + else if ( iNoResponseFromUserAfterDelay || + ( aWaitUserToClear && iHighPriorityEvent ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL no user response" ) + // User did not close the text, closed by the timer or MT call + response = ESatNoResponseFromUser; + } + else + { + if ( IsAppShutterRunning() ) + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL satsession \ + terminated by user " ) + response = ESatSessionTerminatedByUser; + iSessionTerminated = ETrue; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::DisplayTextL backward \ + requested by user " ) + response = ESatBackwardModeRequestedByUser; + } + } + + if ( iDisplayTextDialog ) + { + iDisplayTextDialog = NULL; + } + if ( iDisplayTextIconDialog ) + { + iDisplayTextIconDialog = NULL; + } + + iNoteClearedAfterDelay = EFalse; + iNoResponseFromUserAfterDelay = EFalse; + + ShowWaitNoteL(); + + TFLOGSTRING2( "CSatUiViewAppUi::DisplayTextL exit, return: %d", response ) + return response; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ClearScreen +// Displays yes/no confirmation query. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ClearScreen() + { + TFLOGSTRING( "CSatUiViewAppUi::ClearScreen() called" ) + + iNoteClearedAfterDelay = ETrue; + CloseDialogs(); + + TFLOGSTRING( "CSatUiViewAppUi::ClearScreen() exit" ) + } +// --------------------------------------------------------- +// CSatUiViewAppUi::GetYesNoL +// Displays yes/no confirmation query. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::GetYesNoL( + const TDesC& aText, + const TSatCharacterSet aCharacterSet, + TChar& aInkey, + const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatory, + TUint& aDuration, + const TBool aImmediateDigitResponse ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL called" ) + TSatUiResponse response( ESatSuccess ); + + StopShowWaitNote(); + + CUserActivityManager* activityManager = + CUserActivityManager::NewL( EPriorityNormal ); + CleanupStack::PushL( activityManager ); + + // Start time for duration + TTime startTime; + iImmediateDigitResponse = aImmediateDigitResponse; + + TFLOGSTRING2( "CSatUiViewAppUi::GetYesNoL duration in 1/10 sec: %d", + aDuration ) + + // If duration is given use that value for timeout. + // Start timer which doesn't care about user activity. + if ( aDuration ) + { + TInt duration ( 0 ); + + TTimeIntervalMicroSeconds max32Bit( + static_cast( K32TIntMaxValue ) ); + TTimeIntervalMicroSeconds durationInTenthOfSeconds( + static_cast( aDuration ) ); + TTimeIntervalMicroSeconds durationInus( + durationInTenthOfSeconds.Int64() * KMicroSecondsInTenthOfSecond ); + + if ( durationInus > max32Bit ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL durationInus bigger \ + than max32Bit" ) + // since timers can only handle 32-bit values, + // let's break the aDuration to smaller bits. + // we break it here to 8 bits to fit in 32-bit value + duration = durationInus.Int64() / KDivideByEight; + iTimerRepeatOn = ETrue; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL durationInus less \ + than max32Bit" ) + duration = durationInus.Int64(); + } + + CreateCallBackTimerL( duration, DelayCallback ); + startTime.HomeTime(); + } + // Otherwise start timer which takes account user activity. + else + { + User::ResetInactivityTime(); + activityManager->Start( + TTimeIntervalSeconds( KNoResponseFromUserDelay ), + TCallBack( DispatchUserInactive, this ), 0 ); + } + + TInt resource( 0 ); + + if ( aIconBitmap ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL iGetYesNoIconDialog" ) + + if ( ESatYesNo == aCharacterSet ) + { + resource = R_SATUI_CONFIRM_YES_NO_QUERY_WITH_ICON; + } + else + { + resource = R_SATUI_IMMEDIATE_DIGIT_NOTE_WITH_ICON; + } + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL iGetYesNoDialog" ) + + if ( ESatYesNo == aCharacterSet ) + { + resource = R_SATUI_CONFIRM_YES_NO_QUERY; + } + else + { + resource = R_SATUI_IMMEDIATE_DIGIT_QUERY; + } + } + + TInt userResponse = RunQueryDialogL( resource , aText, aIconBitmap, + aSelfExplanatory, EAknSoftkeyYes ); + + iImmediateDigitResponse = EFalse; + + // set received immediate digit response + aInkey = iKey; + iKey = 0; + + if ( aDuration ) + { + TTime endTime; + endTime.HomeTime(); + TTimeIntervalMicroSeconds timeDifference( 0 ); + timeDifference = endTime.MicroSecondsFrom( startTime ); + aDuration = timeDifference.Int64() / KMicroSecondsInTenthOfSecond; + + // After duration call back timer is destroyed + DestroyCallBackTimer(); + } + + CleanupStack::PopAndDestroy( activityManager ); + + // Timeout + if ( iNoResponseFromUserAfterDelay ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL no response from user" ) + response = ESatNoResponseFromUser; + } + // Cancel is pressed if immediate digit response without Yes/No + else if ( !userResponse && ESatYesNo != aCharacterSet && !aInkey ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL backward request by user" ) + response = ESatBackwardModeRequestedByUser; + } + // Yes button is used + else if ( userResponse && !aInkey) + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL button used" ) + aInkey = 1; + } + // No button is used + else if ( !aInkey ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetYesNoL no button used" ) + aInkey = 0; + } + + iNoResponseFromUserAfterDelay = EFalse; + + ShowWaitNoteL(); + + TFLOGSTRING2( "CSatUiViewAppUi::GetYesNoL exit, return: %d", response ) + return response; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::GetInputL +// Displays data query. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::GetInputL( + const TDesC& aText, + const TSatCharacterSet aCharacterSet, + TDes& aInput, + const TInt aMinLength, + const TInt aMaxLength, + const TBool aHideInput, + const TBool aGetInkey, + const CFbsBitmap* aIconBitmapGetInput, + const TBool aSelfExplanatory, + TUint& aDuration ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL called" ) + StopShowWaitNote(); + + TSatUiResponse response( ESatSuccess ); + + TPtrC textPtr( aText ); + + TInt minLength( 0 ); + TInt maxLength( 1 ); + + TFLOGSTRING2( "CSatUiViewAppUi::GetInputL aMinLength %d", aMinLength ) + TFLOGSTRING2( "CSatUiViewAppUi::GetInputL aMaxLength %d", aMaxLength ) + //lint -e{961} else block not needed, minLength initialized. + if ( aMinLength <= KGetInputStringMaxSize && aMinLength > 0 ) + { + minLength = aMinLength; + } + else if ( aMinLength > KGetInputStringMaxSize ) + { + minLength = KGetInputStringMaxSize; + } + + //lint -e{961} else block not needed, maxLength initialized. + if ( aMaxLength < minLength ) + { + maxLength = minLength; + } + else if ( aMaxLength <= KGetInputStringMaxSize && aMaxLength > 1 ) + { + maxLength = aMaxLength; + } + else if ( aMaxLength > KGetInputStringMaxSize ) + { + maxLength = KGetInputStringMaxSize; + } + + HBufC* input = HBufC::NewLC( KGetInputStringMaxSize ); + TPtr inputPtr(input->Des()); + + HBufC* textHolder = NULL; + + TFLOGSTRING2( "CSatUiViewAppUi::GetInputL aInput.Length %d",\ + aInput.Length() ) + + if ( ( aInput.Length() >= minLength ) + && ( aInput.Length() <= maxLength ) ) + { + inputPtr = aInput; + } + + TInt userResponse; + + CUserActivityManager* activityManager = + CUserActivityManager::NewL( EPriorityNormal ); + + CleanupStack::PushL( activityManager ); + + // Start time for timer + TTime startTime; + + // If duration is given use that value for timeout. + // Start timer which doesn't care about user activity. + if ( aDuration && aGetInkey ) + { + TFLOGSTRING2( "CSatUiViewAppUi::GetInputL duration in 1/10 sec: %d", + aDuration ) + + TInt duration ( 0 ); + + TTimeIntervalMicroSeconds max32Bit( + static_cast( K32TIntMaxValue ) ); + TTimeIntervalMicroSeconds durationInTenthOfSeconds( + static_cast( aDuration ) ); + TTimeIntervalMicroSeconds durationInus( + durationInTenthOfSeconds.Int64() * KMicroSecondsInTenthOfSecond ); + + if ( durationInus > max32Bit ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL durationInus bigger \ + than max32Bit" ) + // since timers can only handle 32-bit values, + // let's break the aDuration to smaller bits. + // we break it here to 8 bits to fit in 32-bit value + duration = durationInus.Int64() / KDivideByEight; + iTimerRepeatOn = ETrue; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL durationInus less \ + than max32Bit" ) + duration = durationInus.Int64(); + } + + CreateCallBackTimerL( duration, DelayCallback ); + startTime.HomeTime(); + } + // Otherwise start timer which takes account user activity. + else + { + User::ResetInactivityTime(); + activityManager->Start( + TTimeIntervalSeconds( KNoResponseFromUserDelay ), + TCallBack( DispatchUserInactive, this ), 0 ); + } + + CEikImage* image = new(ELeave) CEikImage; + CleanupStack::PushL( image ); + + if ( aIconBitmapGetInput ) + { + image->SetBitmap( aIconBitmapGetInput ); + + // Create mask for icon bitmap + CFbsBitmap* mask = new(ELeave) CFbsBitmap; + + TSize size = aIconBitmapGetInput->SizeInPixels(); + CleanupStack::PushL( mask ); + MakeGetInputBitmapMask( mask, size ); + + image->SetMask( mask ); + CleanupStack::Pop( mask ); + } + + TInt resource( 0 ); + TInt textResource( 0 ); + // Query dialog + iGetInputDialog = new (ELeave) CSatUiTextQueryDialog( inputPtr, + CAknQueryDialog::ENoTone, minLength, maxLength ); + iForegroundControl = iGetInputDialog; + + if ( aCharacterSet == ESatDigitOnly ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL ESatDigitOnly" ) + if ( aText.Length() == 0 ) + { + if ( aGetInkey ) + { + textResource = R_TEXT_SIMATK_ENTER_NBR; + } + else + { + textResource = R_TEXT_SIMATK_ENTER_NBR_STRING; + } + } + + // Hidden digit as input + if ( aHideInput ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL Hidden digit" ) + if ( aIconBitmapGetInput ) + { + resource = R_SATUI_HIDDEN_NUMBER_QUERY_WITH_LABEL_AND_ICON; + } + else + { + resource = R_SATUI_HIDDEN_NUMBER_QUERY_WITHOUT_LABEL; + } + } + // Normal number query + else + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL normal digit" ) + if ( aIconBitmapGetInput ) + { + resource = R_SATUI_NUMBER_QUERY_WITH_LABEL_AND_ICON; + } + else + { + resource = R_SATUI_NUMBER_QUERY_WITHOUT_LABEL; + } + } + } + + else // ESatCharSmsDefaultAlphabet or ESatCharUcs2Alphabet + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL ESatCharSmsDefaultAlphabet \ + or ESatCharUcs2Alphabet" ) + if ( aText.Length() == 0 ) + { + if ( aGetInkey ) + { + textResource = R_TEXT_SIMATK_ENTER_CHAR; + } + else + { + textResource = R_TEXT_SIMATK_ENTER_CHAR_STRING; + } + } + + if ( !aGetInkey ) + { + iGetInputDialog->SetPredictiveTextInputPermitted( ETrue ); + } + + iGetInputDialog->SetMaxLength( maxLength ); + + if ( aIconBitmapGetInput ) + { + resource = R_SATUI_TEXT_QUERY_WITH_LABEL_AND_ICON; + } + else + { + resource = R_SATUI_TEXT_QUERY_WITHOUT_LABEL; + } + } + + // Read default text if sim doesn't provide text to dialog + if ( aText.Length() == 0 ) + { + // Reads a resource string with memory allocation + // and pushes the string onto the cleanup stack. + textHolder = StringLoader::LoadLC( textResource, iCoeEnv); + textPtr.Set( *textHolder ); + } + + // Icon is used and command is get input + if ( aIconBitmapGetInput ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL icon is used" ) + iGetInputDialog->PrepareLC( resource ); + if ( !aSelfExplanatory ) + { + // Icon is not self-explanatory, show also text + iGetInputDialog->SetPromptL( textPtr ); + } + // Add icon to query + iGetInputDialog->QueryHeading()->SetHeaderImageL( image ); + // Set MSK same as LSK without any text causing the icon drawing + iGetInputDialog->ButtonGroupContainer().SetCommandL( + CEikButtonGroupContainer::EMiddleSoftkeyPosition, EAknSoftkeyOk, + KSatEmptyDes ); + userResponse = iGetInputDialog->RunLD(); + TFLOGSTRING2( "CSatUiViewAppUi::GetInputL userResponse is: %d", + userResponse ) + } + // No icon in use + else + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL icon isn't used" ) + iGetInputDialog->PrepareLC( resource ); + iGetInputDialog->SetPromptL( textPtr ); + // Set MSK same as LSK without any text causing the icon drawing + iGetInputDialog->ButtonGroupContainer().SetCommandL( + CEikButtonGroupContainer::EMiddleSoftkeyPosition, EAknSoftkeyOk, + KSatEmptyDes ); + userResponse = iGetInputDialog->RunLD(); + TFLOGSTRING2( "CSatUiViewAppUi::GetInputL userResponse is: %d", + userResponse ) + } + iForegroundControl = NULL; + + if ( textHolder ) + { + CleanupStack::PopAndDestroy( textHolder ); + } + + if ( aDuration && aGetInkey ) + { + TTime endTime; + endTime.HomeTime(); + TTimeIntervalMicroSeconds timeDifference( 0 ); + timeDifference = endTime.MicroSecondsFrom( startTime ); + aDuration = timeDifference.Int64() / KMicroSecondsInTenthOfSecond; + + // After duration call back timer is destroyed + DestroyCallBackTimer(); + } + + CleanupStack::PopAndDestroy( image ); + CleanupStack::PopAndDestroy( activityManager ); // image, activityManager + iGetInputDialog = NULL; + + if ( iNoResponseFromUserAfterDelay ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL no response from user" ) + response = ESatNoResponseFromUser; + } + else if ( userResponse ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL successful response" ) + if ( inputPtr.Length() ) + { + aInput.Copy( inputPtr ); + } + response = ESatSuccess; + } + else + { + if ( IsAppShutterRunning() ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL satsession \ + terminated by user " ) + response = ESatSessionTerminatedByUser; + iSessionTerminated = ETrue; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::GetInputL backward \ + requested by user " ) + response = ESatBackwardModeRequestedByUser; + } + } + + iNoResponseFromUserAfterDelay = EFalse; + + CleanupStack::PopAndDestroy( input ); // input + + ShowWaitNoteL(); + + TFLOGSTRING2( "CSatUiViewAppUi::GetInputL exit, return: %d", response ) + return response; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::SetUpMenuL +// Sets the parameters for SetUpMenu view and calls the method +// from the CSatUiView class. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::SetUpMenuL( + const TDesC& aText, + const MDesCArray& aMenuItems, + const CArrayFixFlat* aMenuItemNextActions, + const CFbsBitmap* aIconBitmap, + const CAknIconArray* aItemsIconArray, + const TBool aSelfExplanatoryItems, + const TBool aHelpIsAvailable ) + { + TFLOGSTRING( "CSatUiViewAppUi::SetUpMenuL called" ) + StopShowWaitNote(); + TSatUiResponse response( ESatSuccess ); + + delete iTitle; + iTitle = NULL; + + delete iAppName; + iAppName = NULL; + + TFLOGSTRING2( "CSatUiViewAppUi::SetUpMenuL length of aText %d", \ + aText.Length() ) + if ( aText.Length() > 0 ) + { + iTitle = aText.AllocL(); + iAppName = aText.AllocL(); + } + else + { + //Reads a resource string with memory allocation + iTitle = StringLoader::LoadL( R_QTN_SAT_TITLE, iCoeEnv ); + } + + if ( iSetUpMenuFirst ) + { + iSetUpMenuFirst = EFalse; + iSetUpMenuView = CSatUiView::NewL( ETrue, this, EFalse ); + + // transfer ownership to CAknViewAppUi: + AddViewL( iSetUpMenuView ); + + iSetUpMenuView->SetAdapter( iAdapter ); + } + + // Make list box visible. + iSetUpMenuView->MakeListBoxVisible( ETrue ); + + //set contextpane icon and item icons + iSetUpMenuView->SetIconL( aIconBitmap ); + iSetUpMenuView->SetItemsIconL( aItemsIconArray, aSelfExplanatoryItems ); + iSetUpMenuView->SetTitle( iTitle ); + + response = iSetUpMenuView->SetUpMenuL( iTitle, aMenuItems, + aMenuItemNextActions, aHelpIsAvailable ); + + iActiveView = KSetUpMenuViewId; + + // Reset counter for detecting possible loop in HandleForegroundEventL. + iViewLoopCounter = 0; + + TFLOGSTRING2( "CSatUiViewAppUi::SetUpMenuL exit, return: %d", response ) + return response; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::HandleForegroundEventL +// Called when satui is brought to foreground or put into +// background +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::HandleForegroundEventL( TBool aForeground ) + { + TFLOGSTRING2( "CSatUiViewAppUi::HandleForegroundEventL called \ + value %d", aForeground ) + + iForeground = aForeground; + + // Check whether it is only need to display a dialog. + if ( iForeground && ( iForegroundControl || iCcNote ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleForegroundEventL \ + need to display a dialog" ) + if ( iForegroundControl && ForegroundAlive() ) + { + iForegroundControl->SetFocus( ETrue, EDrawNow ); + } + } + // Check is it allowed to activate local view. + // Removes possibility of view activation loop for example when + // launching Browser. + else if ( ViewActivationAllowed( aForeground, iActiveView ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleForegroundEventL \ + activate local view allowed" ) + TVwsViewId viewId; + GetActiveViewId( viewId ); + TFLOGSTRING2( "CSatUiViewAppUi::HandleForegroundEventL called \ + appUid %x", viewId.iAppUid ) + TFLOGSTRING2( "CSatUiViewAppUi::HandleForegroundEventL called \ + viewUid %x", viewId.iViewUid ) + + if( ( KUidSATUI != viewId.iAppUid ) || + ( ( KUidSATUI == viewId.iAppUid ) + && ( viewId.iViewUid != iActiveView ) ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleForegroundEventL \ + activate local view executing" ) + if ( KSetUpMenuViewId == iActiveView ) + { + ActivateLocalViewL( KSetUpMenuViewId ); + } + else + { + ActivateLocalViewL( KSelectItemViewId ); + } + } + + } + // Forwards event to the base class. + CAknViewAppUi::HandleForegroundEventL( aForeground ); + TFLOGSTRING( "CSatUiViewAppUi::HandleForegroundEventL exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ViewActivationAllowed +// Sets the parameters for SelectItem view and calls the method +// from the CSatUiView class. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TBool CSatUiViewAppUi::ViewActivationAllowed( const TBool aForeground, + const TUid aActiveView ) + { + + TFLOGSTRING( "CSatUiViewAppUi::ViewActivationAllowed called" ) + TBool activationAllowed( EFalse ); + // Value for detecting view activation loop. + const TInt certainViewLoopCount( 6 ); + + // Check for foreground event, background event, + // foreground event, background event, ... sequence. + if ( aForeground ^ iPreviousForeground ) + { + TFLOGSTRING( "CSatUiViewAppUi::ViewActivationAllowed \ + check foreground event" ) + iViewLoopCounter++; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::ViewActivationAllowed \ + no foreground event" ) + iViewLoopCounter = 0; + } + + // Store information is application in foreground or + // in background for next evaluation round. + iPreviousForeground = aForeground; + + // Check that there is no loop. + if ( aForeground && aActiveView.iUid ) + { + if ( iViewLoopCounter < certainViewLoopCount ) + { + TFLOGSTRING( "CSatUiViewAppUi::ViewActivationAllowed \ + there are loops" ) + activationAllowed = ETrue; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::ViewActivationAllowed \ + no loop" ) + // Counter is reset in case of foreground event + // because of background event does not draw anything. + iViewLoopCounter = 0; + } + + } + + if ( iDisplayTextDialog || iDisplayTextIconDialog ) + { + activationAllowed = EFalse; + } + + TFLOGSTRING2( "CSatUiViewAppUi::ViewActivationAllowed exit, return: %d",\ + activationAllowed ) + return activationAllowed; + + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::SelectItemL +// Sets the parameters for SelectItem view and calls the method +// from the CSatUiView class. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::SelectItemL( + const TDesC& aText, + const MDesCArray& aMenuItems, + const CArrayFixFlat* aMenuItemNextActions, + const TInt aDefaultItem, + TUint8& aSelection, + const CFbsBitmap* aIconBitmap, + const CAknIconArray* aItemsIconArray, + const TBool aSelfExplanatoryItems, + const TBool aHelpIsAvailable ) + { + TFLOGSTRING( "CSatUiViewAppUi::SelectItemL called" ) + StopShowWaitNote(); + + TSatUiResponse response( ESatSuccess ); + + delete iTitle; + iTitle = NULL; + + TFLOGSTRING2( "CSatUiViewAppUi::SelectItemL length of aText %d", + aText.Length() ) + if ( aText.Length() > 0 ) + { + iTitle = aText.AllocL(); + } + else if ( iAppName ) + { + TFLOGSTRING( "CSatUiViewAppUi::SelectItemL there is appname" ) + iTitle = iAppName->AllocL(); + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::SelectItemL read appname" ) + //Reads a resource string with memory allocation + iTitle = StringLoader::LoadL( R_QTN_SAT_TITLE, iCoeEnv ); + } + + if ( iSelectItemFirst ) + { + iSelectItemFirst = EFalse; + iSelectItemView = CSatUiView::NewL( EFalse, this, EFalse ); + + // transfer ownership to CAknViewAppUi: + AddViewL( iSelectItemView ); + } + + iSelectItemPending = ETrue; + iActiveView = KSelectItemViewId; + + //set contextpane icon and item icons + iSelectItemView->SetIconL( aIconBitmap ); + iSelectItemView->SetItemsIconL( aItemsIconArray, aSelfExplanatoryItems ); + response = iSelectItemView->SelectItemL( iTitle, aMenuItems, + aMenuItemNextActions, aDefaultItem, aSelection, aHelpIsAvailable ); + + iSelectItemPending = EFalse; + + if ( iEndKeyPressed ) + { + response = ESatSessionTerminatedByUser; + } + + if ( response != ESatSessionTerminatedByUser ) + { + ShowWaitNoteL(); + } + + TFLOGSTRING2( "CSatUiViewAppUi::SelectItemL exit, return: %d", response ) + return response; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::MatoPrepareComplete +// Indicates success or failure. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::MatoPrepareComplete(TInt aError) + { + TFLOGSTRING( "CSatUiViewAppUi::MatoPrepareComplete called" ) + TFLOGSTRING2( "CSatUiViewAppUi::MatoPrepareComplete error %i", aError ) + if ( KErrNone == aError ) + { + iPlayToneError = ESatSuccess; + + TTimeIntervalMicroSeconds zero( static_cast( 0 ) ); + + iPlayer->SetPriority( KAudioPriorityLowLevel, + STATIC_CAST( TMdaPriorityPreference, KAudioPrefConfirmation ) ); + + iPlayer->SetRepeats( KMdaAudioToneRepeatForever, zero ); + + iPlayer->Play(); + } + else + { + iPlayToneError = ESatFailure; + } + TFLOGSTRING( "CSatUiViewAppUi::MatoPrepareComplete exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::MatoPlayComplete +// Indicates success or failure. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::MatoPlayComplete( TInt aError ) + { + TFLOGSTRING( "CSatUiViewAppUi::MatoPlayComplete calling" ) + if ( KErrNone == aError && iPlayer ) + { + TFLOGSTRING( "CSatUiViewAppUi::MatoPlayComplete play" ) + iPlayer->Play(); + } + else if ( iWait && iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::MatoPlayComplete stop playing" ) + // Stops playing if error. + iWait->AsyncStop(); + } + TFLOGSTRING2( "CSatUiViewAppUi::MatoPlayComplete exit, error %i", aError ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::PlayStandardToneL +// Plays Standard Tone. If needed displays the text in a note +// while playing. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::PlayStandardToneL( + const TDesC& aText, + const TDesC8& aSequence, + TTimeIntervalMicroSeconds aDuration, + const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatory ) + { + TFLOGSTRING( "CSatUiViewAppUi::PlayStandardToneL called" ) + StopShowWaitNote(); + // Delete timer just in case e.g. if DisplayText was on the screen + DestroyCallBackTimer(); + + iPermanentNote = NULL; + iTimerRepeatOn = EFalse; + + TFLOGSTRING2( "CSatUiViewAppUi::PlayStandardToneL length of aText %i", \ + aText.Length() ) + if (aText.Length() != 0) + { + iPermanentNote = new (ELeave) CAknStaticNoteDialog(); + iPermanentNote->PrepareLC( R_SATUI_PERMANENT_NOTE ); + + if ( ( !aSelfExplanatory ) || ( !aIconBitmap ) ) + { + // Set text + iPermanentNote->SetTextL( aText ); + } + + if ( aIconBitmap ) + { + //Set image + TFLOGSTRING( "CSatUiViewAppUi::PlayStandardToneL SetImage" ) + // Get scalable bitmap if available. + CEikImage* image = new ( ELeave ) CEikImage(); + CleanupStack::PushL( image ); + image->SetBitmap( aIconBitmap ); + iPermanentNote->SetImageL( image ); + CleanupStack::Pop( image ); + } + + iForegroundControl = iPermanentNote; + iPermanentNote->RunLD(); + iPermanentNote->DrawNow(); + iCoeEnv->WsSession().Flush(); + } + + iPlayer = CMdaAudioToneUtility::NewL(*this); + + TInt volume( iPlayer->MaxVolume() ); + iPlayer->SetVolume( volume ); + TFLOGSTRING2( "CSatUiViewAppUi::PlayStandardToneL SetVolume %d", + volume ) + + iPlayer->PrepareToPlayDesSequence( aSequence ); + + TTimeIntervalMicroSeconds max32Bit( + static_cast( K32TIntMaxValue ) ); + + if ( aDuration > max32Bit ) + { + // since timers can only handle 32-bit values, + // let's break the aDuration to smaller bits. + // we break it here to 8 bits to fit in 32-bit value + aDuration = aDuration.Int64() / KDivideByEight; + iTimerRepeatOn = ETrue; + } + + CreateCallBackTimerL( I64INT( aDuration.Int64() ), DelayCallback ); + + if ( !iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::PlayStandardToneL starting iWait" ) + iWait->Start(); + TFLOGSTRING( "CSatUiViewAppUi::PlayStandardToneL strarting done" ) + } + + iPlayer->CancelPlay(); + + DestroyCallBackTimer(); + + delete iPlayer; + iPlayer = NULL; + + if ( iPermanentNote ) + { + iPermanentNote->ExitSleepingDialog(); + delete iPermanentNote; + iPermanentNote = NULL; + } + iForegroundControl = NULL; + + if ( !iEndKeyPressed ) + { + ShowWaitNoteL(); + } + + //get warning and game tones setting from active profile + GetProfileParamsL(); + + if( ( EFalse == iWarningAndPlayTones ) && + ( ESatSuccess == iPlayToneError ) ) + { + iPlayToneError = ESatSuccessToneNotPlayed; + } + + TFLOGSTRING2( "CSatUiViewAppUi::PlayStandardToneL exit,return: %d", \ + iPlayToneError ) + return iPlayToneError; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ConfirmSendL +// Displays a query to get confirmation for Send SMS, +// Send SS or Send USSD command. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::ConfirmSendL( + const TDesC& /* aText */, + TBool& aActionAccepted, + TInt aType) + { + TFLOGSTRING2( "CSatUiViewAppUi::ConfirmSendL called, aType: %d", \ + aType ) + HBufC* textHolder = NULL; + + switch ( aType ) + { + case ESatUiConfirmSendSms: + textHolder = StringLoader::LoadLC( R_TEXT_SIMATK_SEND_SMS, + iCoeEnv ); + break; + case ESatUiConfirmSendSs: + case ESatUiConfirmSendUssd: //the same string for SS and USSD + textHolder = StringLoader::LoadLC( R_TEXT_SIMATK_SEND_SS, + iCoeEnv ); + break; + default: + return ESatFailure; + } + + TInt userResponse = RunQueryDialogL( R_SATUI_CONFIRM_SEND_CANCEL_QUERY, + *textHolder, NULL, EFalse, ESatUiSoftkeySend ); + + TFLOGSTRING2( "CSatUiViewAppUi::ConfirmSendL userResponse: %d", \ + userResponse ) + if ( userResponse ) + { + aActionAccepted = ETrue; + } + else + { + aActionAccepted = EFalse; + } + + if ( textHolder ) + { + CleanupStack::PopAndDestroy( textHolder ); //textHolder + } + + TFLOGSTRING( "CSatUiViewAppUi::ConfirmSendL return ESatSuccess" ) + return ESatSuccess; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ShowSmsWaitNoteL +// Displays a wait note to indicate SMS sending. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ShowSmsWaitNoteL( const TDesC& aText, + const CFbsBitmap* aIconBitmapSendSM, + const TBool aSelfExplanatoryIcon ) + { + + TFLOGSTRING( "CSatUiViewAppUi::ShowSmsWaitNoteL called" ) + + iWaitNoteInUse = ETrue; + + TFLOGSTRING2( "CSatUiViewAppUi::ShowSmsWaitNoteL iWaitNote: %d", \ + iWaitNote ) + if ( NULL == iWaitNote ) + { + iWaitNote = new(ELeave) CAknWaitDialog( + ( REINTERPRET_CAST( CEikDialog**, &iWaitNote ) ), ETrue ); + iWaitNote->PrepareLC( R_SATUI_SMS_WAIT_NOTE ); + + if ( ( aText.Length() > 0 ) && ( !aSelfExplanatoryIcon || + !aIconBitmapSendSM ) ) + { + //Set text + TFLOGSTRING( "CSatUiViewAppUi::ShowSmsWaitNoteL SetText" ) + iWaitNote->SetTextL( aText ); + } + + if ( aIconBitmapSendSM ) + { + //Set image + TFLOGSTRING( "CSatUiViewAppUi::ShowSmsWaitNoteL SetImage" ) + CEikImage* image = new ( ELeave ) CEikImage(); + CleanupStack::PushL( image ); + image->SetBitmap( aIconBitmapSendSM ); + iWaitNote->SetImageL( image ); + CleanupStack::Pop( image ); + } + + iForegroundControl = iWaitNote; + iWaitNote->RunLD(); + // iForegroundControl won't be clear until the wait dialog + // closed. It will avoid we lose the chance to set focus for + // the wait dialog when the switch of foreground/background + // happened. + } + + TFLOGSTRING( "CSatUiViewAppUi::ShowSmsWaitNoteL exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ShowSsWaitNoteL +// Displays a wait note to indicate SS sending. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ShowSsWaitNoteL( const TDesC& aText, + const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatoryIcon ) + { + TFLOGSTRING( "CSatUiViewAppUi::ShowSsWaitNoteL called" ) + + iWaitNoteInUse = ETrue; + + TFLOGSTRING2( "CSatUiViewAppUi::ShowSsWaitNoteL iWaitNote: %d", \ + iWaitNote ) + if ( !iWaitNote ) + { + iWaitNote = new ( ELeave ) CSatUiWaitDialog( + ( REINTERPRET_CAST ( CEikDialog**,&iWaitNote ) ), + *iAdapter, ETrue ); + iForegroundControl = iWaitNote; + + TFLOGSTRING2( "CSatUiViewAppUi::ShowSsWaitNoteL length of aText: %d",\ + aText.Length() ) + // if there is an alpha id + if ( aText.Length() > 0 ) + { + // if there is not an icon or it's not self explanatory + if ( ( !aSelfExplanatoryIcon ) || ( !aIconBitmap ) ) + { + iWaitNote->SetTextL( aText ); + } + + if ( aIconBitmap ) + { + //Set image + TFLOGSTRING( "CSatUiViewAppUi::ShowSsWaitNoteL SetImage" ) + CEikImage* image = new ( ELeave ) CEikImage(); + CleanupStack::PushL( image ); + image->SetBitmap( aIconBitmap ); + iWaitNote->SetImageL( image ); + CleanupStack::Pop( image ); + } + + iWaitNote->ExecuteLD( R_SATUI_SS_WAIT_NOTE ); + } + else + { + iWaitNote->ExecuteLD( R_SATUI_REQUESTING_WAIT_NOTE ); + } + // iForegroundControl won't be clear until the wait dialog + // closed. It will avoid we lose the chance to set focus for + // the wait dialog when the switch of foreground/background + // happened. + } + TFLOGSTRING( "CSatUiViewAppUi::ShowSsWaitNoteL exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ShowDtmfWaitNoteL +// Shows a wait note while DTMF are being sent. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::ShowDtmfWaitNoteL( const TDesC& aText, + const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatoryIcon ) + { + TFLOGSTRING( "CSatUiViewAppUi::ShowDtmfWaitNoteL called" ) + TSatUiResponse response(ESatFailure); + + iWaitNoteInUse = ETrue; + + TFLOGSTRING2( "CSatUiViewAppUi::ShowDtmfWaitNoteL iWaitNote: %d", \ + iWaitNote ) + if ( !iWaitNote ) + { + iWaitNote = new ( ELeave ) CSatUiWaitDialog( + (REINTERPRET_CAST( CEikDialog**,&iWaitNote ) ), *iAdapter, ETrue ); + + if ( ( aText.Length() > 0 ) && + ( ( !aSelfExplanatoryIcon ) || ( !aIconBitmap ) ) ) + { + iWaitNote->SetTextL( aText ); + } + + if ( aIconBitmap ) + { + //Set image + TFLOGSTRING( "CSatUiViewAppUi::ShowDtmfWaitNoteL SetImage" ) + CEikImage* image = new ( ELeave ) CEikImage(); + CleanupStack::PushL( image ); + image->SetBitmap( aIconBitmap ); + iWaitNote->SetImageL( image ); + CleanupStack::Pop( image ); + } + + iForegroundControl = iWaitNote; + iWaitNote->ExecuteLD( R_SATUI_DTMF_WAIT_NOTE ); + // iForegroundControl won't be clear until the wait dialog + // closed. It will avoid we lose the chance to set focus for + // the wait dialog when the switch of foreground/background + // happened. + response = ESatSuccess; + } + TFLOGSTRING2( "CSatUiViewAppUi::ShowDtmfWaitNoteL exit, return: %d",\ + response ) + return response; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ConfirmRefreshL +// Displays a query to get confirmation Refresh command. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::ConfirmRefreshL(TBool& aActionAccepted) + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmRefreshL called" ) + StopShowWaitNote(); + + TSatUiResponse response( ESatSuccess ); + + HBufC* textHolder = NULL; + + textHolder = StringLoader::LoadLC( R_QTN_SAT_QUERY_ALLOW_RESET, + iCoeEnv ); + + TInt userResponse = RunQueryDialogL( R_SATUI_CONFIRM_OK_CANCEL_QUERY, + *textHolder, NULL, EFalse, EAknSoftkeyOk ); + + TFLOGSTRING2( "CSatUiViewAppUi::ConfirmRefreshL userResponse: %d", \ + userResponse ) + if ( userResponse ) + { + aActionAccepted = ETrue; + } + else + { + aActionAccepted = EFalse; + } + + if ( textHolder ) + { + CleanupStack::PopAndDestroy( textHolder ); //textHolder + } + + ShowWaitNoteL(); + + TFLOGSTRING2( "CSatUiViewAppUi::ConfirmRefreshL exit, return: %d",\ + response ) + return response; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::CallControlL +// Displays info about call control to user +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::CallControlL( + const TDesC& aText, + const TSatAlphaIdStatus aAlphaIdStatus ) + { + TFLOGSTRING( "CSatUiViewAppUi::CallControlL called" ) + + if ( !iCcNote ) + { + iCcNote = CAknGlobalNote::NewL(); + } + iCcNote->SetTone( CAknNoteDialog::ENoTone ); + + if ( ESatAlphaIdNotNull == aAlphaIdStatus ) + { + TFLOGSTRING( "CSatUiViewAppUi::CallControlL AlphaIdNotNull" ) + + // The note will be disabled by the phone UI when the call is + // in connecting status. But call controll case is an exception, So we + // use RAknKeyLock to enable soft notifications. + RAknKeyLock keyLock; + TInt errorCode = keyLock.Connect(); + TFLOGSTRING2( "CSatUiViewAppUi::CallControlL connect error %d", \ + errorCode ) + if ( KErrNone == errorCode ) + { + keyLock.EnableSoftNotifications( ETrue ); + } + keyLock.Close(); + + iCcNote->SetSoftkeys( R_AVKON_SOFTKEYS_OK_EMPTY ); + iCcNoteId = iCcNote->ShowNoteL( + EAknGlobalInformationNote, aText ); + CreateCallBackTimerL( K3Seconds, CloseCallControlNoteL ); + if ( iWait && !iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::CallControlL iWait starting" ) + iWait->Start(); + } + DestroyCallBackTimer(); + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::CallControlL AlphaId Null" ) + iCcNote->ShowNoteL( EAknGlobalInformationNote, aText ); + } + + if ( iCcNote ) + { + delete iCcNote; + iCcNote = NULL; + } + TFLOGSTRING( "CSatUiViewAppUi::CallControlL exit" ) + + return ESatSuccess; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::MoSmControlL +// Displays info about Mo SM control to user +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::MoSmControlL( + const TDesC& aText, + const TSatAlphaIdStatus aAlphaIdStatus ) + { + TFLOGSTRING( "CSatUiViewAppUi::MoSmControlL called" ) + if ( ESatAlphaIdNotNull == aAlphaIdStatus ) + { + TFLOGSTRING( "CSatUiViewAppUi::MoSmControlL AlphaIdNotNull" ) + CAknNoteDialog* dialog = new (ELeave) CAknNoteDialog( + REINTERPRET_CAST( CEikDialog**,&dialog ), + CAknNoteDialog::ENoTone, + CAknNoteDialog::ELongTimeout ); + + dialog->PrepareLC( R_SATUI_MOSM_CONTROL_NOTE ); + + dialog->SetTextL( aText ); + + iForegroundControl = dialog; + dialog->RunLD(); + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::MoSmControlL AlphaId Null" ) + CAknNoteDialog* dialog = new (ELeave) CAknNoteDialog( + REINTERPRET_CAST( CEikDialog**,&dialog ), + CAknNoteDialog::ENoTone, + CAknNoteDialog::ELongTimeout ); + + dialog->PrepareLC( R_SATUI_INFORMATION_NOTE ); + + dialog->SetTextL( aText ); + + iForegroundControl = dialog; + dialog->RunLD(); + } + iForegroundControl = NULL; + TFLOGSTRING( "CSatUiViewAppUi::MoSmControlL exit" ) + return ESatSuccess; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ConfirmLaunchBrowserL +// Displays a query to get confirmation for Launch Browser +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ConfirmLaunchBrowserL( + const TDesC& aText, + TBool& aActionAccepted, + const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatory ) + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmLaunchBrowserL called" ) + + TInt resource( 0 ); + + if ( aIconBitmap ) + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmLaunchBrowserL icon" ) + resource = R_SATUI_CONFIRM_OK_CANCEL_QUERY_WITH_ICON; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmLaunchBrowserL no icon" ) + resource = R_SATUI_CONFIRM_OK_CANCEL_QUERY; + } + + TInt userResponse = RunQueryDialogL( resource, aText, aIconBitmap, + aSelfExplanatory, EAknSoftkeyOk ); + + TFLOGSTRING2( "CSatUiViewAppUi::ConfirmLaunchBrowserL userResponse %d",\ + userResponse ) + if ( userResponse ) + { + aActionAccepted = ETrue; + } + else + { + aActionAccepted = EFalse; + } + + TFLOGSTRING( "CSatUiViewAppUi::ConfirmLaunchBrowserL exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::HandleCommandL +// Called by CSatUiView::HandleCommandL. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::HandleCommandL( + TInt aCommand ) + { + TFLOGSTRING2( "CSatUiViewAppUi::HandleCommandL called, aCommand: %d",\ + aCommand ) + switch ( aCommand ) + { + case EEikCmdExit: + { + HandleExitCommandL(); + break; + } + case EAknCmdHelp: + { + //Show Series 60 Help + HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), + AppHelpContextL() ); + break; + } + default: + break; + } + TFLOGSTRING( "CSatUiViewAppUi::HandleCommandL exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::HandleExitCommandL +// Handling of the exit softkey. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::HandleExitCommandL() + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL called" ) + + if ( iBipWaitNote ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL iBipWaitNote" ) + SetCommandPending( EFalse ); + } + + if ( iWait ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL iWait " ) + if ( iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL \ + iWait->AsyncStop()" ) + iWait->AsyncStop(); + } + } + + CloseDialogs(); + + if ( iEndKeyPressed ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL endkeypressed" ) + // Inform SAT Server that end key has been pressed + iAdapter->SessionTerminated( EEndKeyUsed ); + } + + if ( !iCommandPending ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL !iCommandPending" ) + + if ( iPlayer && EMdaAudioToneUtilityPlaying == iPlayer->State() ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL cancel playtone") + iPlayer->CancelPlay(); + } + + if ( iAudioPlayer ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL cancel \ + userselected tone" ) + iAudioPlayer->Stop(); + delete iAudioPlayer; + iAudioPlayer = NULL; + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL\ + iAudioPlayer deleted" ) + } + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL exiting AppUI ") + Exit(); + } + if ( iWaitNoteInUse ) + { + iCommandPending = EFalse; + } + if ( iSelectItemPending && !iEndKeyPressed ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL SelectItem pending" ) + iSessionTerminated = ETrue; + iSelectItemView->HandleCommandL( ESatUiCmdExit ); + } + + TFLOGSTRING( "CSatUiViewAppUi::HandleExitCommandL exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::HandleWsEventL +// Handling of the window server events. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::HandleWsEventL( + const TWsEvent& aEvent, + CCoeControl* aDestination ) + { + switch ( aEvent.Type() ) + { + // This is End key closing event. If this window server event is + // received, by default application will be closed unless it is + // the system application. + case KAknUidValueEndKeyCloseEvent: + { + // Performs the same behaviour as when Exit softkey is pressed. + TFLOGSTRING( "CSatUiViewAppUi::HandleWsEventL End key pressed" ) + iEndKeyPressed = ETrue; + HandleExitCommandL(); + break; + } + case EEventPointer: + { + TFLOGSTRING( "CSatUiViewAppUi::HandleWsEventL EEventPointer" ) + const TPointerEvent& pointer = *( aEvent.Pointer() ); + const TPointerEvent::TType pointerType = pointer.iType; + + if ( ( TPointerEvent::EButton1Down == pointerType ) || + ( TPointerEvent::EButton2Down == pointerType ) || + ( TPointerEvent::EButton3Down == pointerType ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleWsEventL EEventPointer\ + handle the event" ) + // Check if we need to end play tone + StopPlayToneL(); + } + break; + } + case EEventKeyDown: + { + // Handles other user key presses + TFLOGSTRING( "CSatUiViewAppUi::HandleWsEventL EEventKeyDown" ) + // Check if we need to end play tone + StopPlayToneL(); + if ( iImmediateDigitResponse ) + { + HandleImmediateDigitResponse( aEvent.Key()->iScanCode ); + } + break; + } + + default: + break; + } + // Forwards event to the base class. + CAknViewAppUi::HandleWsEventL( aEvent, aDestination ); + PriorityVerifyAndClose( aEvent ); + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::HelpStatus +// Help support status +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::HelpStatus( TBool aStatus ) + { + TFLOGSTRING( "CSatUiViewAppUi::HelpStatus calling" ) + iHelp = aStatus; + TFLOGSTRING( "CSatUiViewAppUi::HelpStatus exiting" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::DelayCallback +// Delay Callback function. Completes after predefined +// time has passed +// (other items were commented in a header). +// --------------------------------------------------------- +// +TInt CSatUiViewAppUi::DelayCallback( TAny* aPtr ) + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback calling" ) + if ( ((CSatUiViewAppUi* )aPtr)->iTimerRepeatOn ) + { + if ( ((CSatUiViewAppUi* )aPtr)->iTimerRepeatCount++ == KDivideByEight ) + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback -- 1" ) + if ( ((CSatUiViewAppUi* )aPtr)->iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback -- 2" ) + ((CSatUiViewAppUi* )aPtr)->iWait->AsyncStop(); + } + if ( ( ( CSatUiViewAppUi* ) aPtr )->iGetInputDialog || + ( ( CSatUiViewAppUi* ) aPtr )->iQueryDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback -- 3" ) + ( ( CSatUiViewAppUi* ) aPtr )-> + iNoResponseFromUserAfterDelay = ETrue; + ( ( CSatUiViewAppUi* ) aPtr )->CloseDialogs(); + } + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback -- 4" ) + return ( ETrue ); + } + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback -- 5" ) + if ( ((CSatUiViewAppUi* )aPtr)->iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback -- 6" ) + ((CSatUiViewAppUi* )aPtr)->iWait->AsyncStop(); + } + } + + // Close DisplayText dialog if clearing after delay is requested + if ( ((CSatUiViewAppUi* )aPtr)->iDisplayTextDialog || + ((CSatUiViewAppUi* )aPtr)->iDisplayTextIconDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback -- 7" ) + ( ( CSatUiViewAppUi* ) aPtr )->iNoResponseFromUserAfterDelay = ETrue; + ( ( CSatUiViewAppUi* ) aPtr )->ClearScreen(); + } + else if ( ( ( CSatUiViewAppUi* ) aPtr )->iGetInputDialog || + ( ( CSatUiViewAppUi* ) aPtr )->iQueryDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback -- 8" ) + ( ( CSatUiViewAppUi* ) aPtr )->iNoResponseFromUserAfterDelay = ETrue; + ( ( CSatUiViewAppUi* ) aPtr )->CloseDialogs(); + } + + TFLOGSTRING( "CSatUiViewAppUi::DelayCallback exiting" ) + return ( EFalse ); + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::CreateCallBackTimerLC +// Creates a callback timer +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::CreateCallBackTimerL( const TInt aDelay, + TInt (*aFunction)(TAny* aPtr) ) + { + TFLOGSTRING( "CSatUiViewAppUi::CreateCallBackTimerLC called" ) + iTimerRepeatCount = 0; + iTimer = CPeriodic::NewL( CActive::EPriorityStandard ); + + if ( iTimerRepeatOn ) + { + TFLOGSTRING( "CSatUiViewAppUi::CreateCallBackTimerLC repeating" ) + iTimer->Start( aDelay, aDelay, + TCallBack( aFunction, this ) ); + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::CreateCallBackTimerLC \ + no repeating" ) + iTimer->Start( aDelay, KMicroSecondsInSecond, + TCallBack( aFunction, this ) ); + } + + TFLOGSTRING( "CSatUiViewAppUi::CreateCallBackTimerLC exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::DestroyCallBackTimer +// Destroys the callback timer +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::DestroyCallBackTimer( ) + { + TFLOGSTRING( "CSatUiViewAppUi::DestroyCallBackTimer() called" ) + delete iTimer; + iTimer = NULL; + iTimerRepeatOn = EFalse; + TFLOGSTRING( "CSatUiViewAppUi::DestroyCallBackTimer() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ProcessCommandParametersL +// Takes care of external launching. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TBool CSatUiViewAppUi::ProcessCommandParametersL( + TApaCommand aCommand, + TFileName& aDocumentName, + const TDesC8& aTail ) + { + TFLOGSTRING2( "CSatUiViewAppUi::ProcessCommandParametersL called,\ + aCommand: %d", aCommand ) + // TApaCommand is 0 for SIM originated opening and 2 for user originated + // opening. Empty view is only needed for SIM originated opening. + if ( EApaCommandOpen == aCommand ) + { + // Creates empty view for commands without view. + CreateEmptyMenuL(); + } + + TFLOGSTRING( "CSatUiViewAppUi::ProcessCommandParametersL exit" ) + return CAknViewAppUi::ProcessCommandParametersL( aCommand, aDocumentName, + aTail ); + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::DispatchUserInactive +// Called when user has been inactive for a pre-defined time period +// (other items were commented in a header). +// --------------------------------------------------------- +// +TInt CSatUiViewAppUi::DispatchUserInactive( TAny* aPtr ) + { + TFLOGSTRING( "CSatUiViewAppUi::DispatchUserInactive calling" ) + ((CSatUiViewAppUi* )aPtr)->iNoResponseFromUserAfterDelay = ETrue; + + //lint -e{961} else block not needed. + if ( ( ( CSatUiViewAppUi* ) aPtr )->iDisplayTextDialog || + ( ( CSatUiViewAppUi* ) aPtr )->iDisplayTextIconDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::DispatchUserInactive clear screen" ) + ( ( CSatUiViewAppUi* ) aPtr )->ClearScreen(); + } + else if ( ( ( CSatUiViewAppUi* ) aPtr )->iQueryDialog || + ( (CSatUiViewAppUi* ) aPtr )->iGetInputDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::DispatchUserInactive close dialog" ) + ( ( CSatUiViewAppUi* ) aPtr )->CloseDialogs(); + } + + TFLOGSTRING( "CSatUiViewAppUi::DispatchUserInactive exiting" ) + return (EFalse); + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::MakeGetInputBitmapMask +// Make a mask for get input icon +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::MakeGetInputBitmapMask( CFbsBitmap* aMask, + TSize aSize ) const + { + TFLOGSTRING( "CSatUiViewAppUi::MakeGetInputBitmapMask calling" ) + TInt width = aSize.iWidth; + TInt height = aSize.iHeight; + aMask->Create( TSize( width, height ), EColor16M ); + + TBitmapUtil bitmap1Util( aMask ); + // Begin manipulation with bitmap1Util, setting initial pixel to 0,0 + bitmap1Util.Begin( TPoint( 0,0 ) ); + + // Make mask which covers whole icon + for ( TInt y = 0; y < height; y++ ) + { + for ( TInt x = 0; x < width; x++ ) + { + bitmap1Util.SetPos( TPoint( x, y ) ); + bitmap1Util.SetPixel( 0x0000ff ); + } + } + bitmap1Util.End(); + TFLOGSTRING( "CSatUiViewAppUi::MakeGetInputBitmapMask exiting" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::DispatchTimer +// Dispatch iWait to action implementer. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::DispatchTimer( CActiveSchedulerWait& aWait ) + { + TFLOGSTRING( "CSatUiViewAppUi::DispatchTimer calling" ) + iWait = &aWait; + TFLOGSTRING( "CSatUiViewAppUi::DispatchTimer exiting" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::GetEndKey +// Get a flag which is indicating if end key is pressed. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TBool CSatUiViewAppUi::GetEndKey() + { + TFLOGSTRING( "CSatUiViewAppUi::GetEndKey calling-exiting" ) + return iEndKeyPressed; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::SetEndKey +// Set a flag which is indicating if end key is pressed. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::SetEndKey( TBool aValue ) + { + TFLOGSTRING2( "CSatUiViewAppUi::SetEndKey calling, aValue:%d", aValue ) + iEndKeyPressed = aValue; + TFLOGSTRING( "CSatUiViewAppUi::SetEndKey exiting" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::SetCommandPending +// Set a flag which is indicating proactive command is pending. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::SetCommandPending( TBool aValue ) + { + TFLOGSTRING2( "CSatUiViewAppUi::SetCommandPending calling, aValue:%d", \ + aValue ) + iCommandPending = aValue; + if ( aValue ) + { + // Cancels a request to save RAM when higher than normal buffer size is + // no longer required. + CAknEnv::Static()->CancelWsBufferRequest( iReqWSBufferID ); + } + TFLOGSTRING( "CSatUiViewAppUi::SetCommandPending exiting" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::CloseDialogs +// Close all existing dialogs. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::CloseDialogs() + { + TFLOGSTRING( "CSatUiViewAppUi::CloseDialogs() called" ) + if ( iWaitNote || iBipWaitNote || iNoteDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::CloseDialogs() StopShowWaitNote" ) + StopShowWaitNote(); + } + if ( iDisplayTextDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::CloseDialogs() iDisplayTextDialog" ) + delete iDisplayTextDialog; + iDisplayTextDialog = NULL; + iImmediateRsp = EFalse; + } + if ( iDisplayTextIconDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::CloseDialogs() iDisplayTextIconDialog" ) + delete iDisplayTextIconDialog; + iDisplayTextIconDialog = NULL; + iImmediateRsp = EFalse; + } + if ( iGetInputDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::CloseDialogs() iGetInputDialog" ) + TRAP_IGNORE( iGetInputDialog->DismissQueryL() ) + iGetInputDialog = NULL; + } + if ( iQueryDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::CloseDialogs() iQueryDialog" ) + delete iQueryDialog; + iQueryDialog = NULL; + } + if ( iPermanentNote ) + { + TFLOGSTRING( "CSatUiViewAppUi::CloseDialogs() iPermanentNote" ) + // CAknNoteDialog has already performed deletion when user action. + iPermanentNote = NULL; + } + TFLOGSTRING( "CSatUiViewAppUi::CloseDialogs() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::MapcInitComplete +// Plays the tone. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::MapcInitComplete( TInt aError, + const TTimeIntervalMicroSeconds& /*aDuration*/ ) + { + TFLOGSTRING( "CSatUiViewAppUi::MapcInitComplete called" ) + // Audio player is initialised, so if there is no error, we can start + // playing the tone. + if( KErrNone == aError ) + { + const TInt volume( Max( 0, Min( iVolume, + iAudioPlayer->MaxVolume() ) ) ); + TFLOGSTRING2( "CSatUiViewAppUi::\ + MapcInitComplete SetVolume %i", volume ) + // Set volume according Settings. + iAudioPlayer->SetVolume( volume ); + iAudioPlayer->Play(); + TFLOGSTRING( "CSatUiViewAppUi::MapcInitComplete Play" ) + } + else + { + // Otherwise, we delete the initialised audio player. + if ( iAudioPlayer ) + { + TFLOGSTRING( "CSatUiViewAppUi::MapcInitComplete iAudioPlayer \ + true" ) + delete iAudioPlayer; + iAudioPlayer = NULL; + } + + // Remove also the note for play tone + if ( iPermanentNote ) + { + TFLOGSTRING( "CSatUiViewAppUi::MapcInitComplete iPermanentNote \ + true" ) + iPermanentNote->ExitSleepingDialog(); + delete iPermanentNote; + iPermanentNote = NULL; + } + + // If there was a duration for play tone, stop waiting + if ( iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::MapcInitComplete stop iWait" ) + iWait->AsyncStop(); + } + + TFLOGSTRING2( "CSatUiViewAppUi::MapcInitComplete Error %i", aError ) + } + + TFLOGSTRING( "CSatUiViewAppUi::MapcInitComplete exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::MapcPlayComplete +// Deletes audio player after playing is completed. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::MapcPlayComplete( TInt aError ) + { + TFLOGSTRING( "CSatUiViewAppUi::MapcPlayComplete called" ) + + // When playing is completed, deleting the audio player. + if ( iAudioPlayer ) + { + TFLOGSTRING( "CSatUiViewAppUi::MapcPlayComplete delete iAudioPlayer" ) + delete iAudioPlayer; + iAudioPlayer = NULL; + } + // Remove note after play has completed. + if ( iPermanentNote ) + { + TFLOGSTRING( "CSatUiViewAppUi::MapcPlayComplete ExitSleepingDialog" ) + iPermanentNote->ExitSleepingDialog(); + delete iPermanentNote; + iPermanentNote = NULL; + } + // Show wait note only for samples that have duration, otherwise there is + // chance that wait note is not stopped. + if ( TTimeIntervalMicroSeconds( static_cast( 0 ) ) != iDuration ) + { + // It does not affect for tone playing if wait note + // is not able to show. + TFLOGSTRING( "CSatUiViewAppUi::MapcPlayComplete ShowWaitNoteL" ) + TRAP_IGNORE( ShowWaitNoteL() ) + } + + TFLOGSTRING2( "CSatUiViewAppUi::MapcPlayComplete exit, error:%i", aError ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::PlayUserSelectedToneL +// Plays user selected tone from active Profile. +// If needed displays the text in a note while playing. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::PlayUserSelectedToneL( + const TDesC& aText, + TTimeIntervalMicroSeconds aDuration, + TSatTone aTone, + const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatory ) + { + TFLOGSTRING( "CSatUiViewAppUi::PlayUserSelectedToneL called" ) + StopShowWaitNote(); + // Delete timer just in case e.g. if DisplayText was on the screen + DestroyCallBackTimer(); + + iPermanentNote = NULL; + iDuration = aDuration; + + TFLOGSTRING2( "CSatUiViewAppUi::PlayUserSelectedToneL length of aText \ + %d", aText.Length() ) + if ( 0 != aText.Length() ) + { + iPermanentNote = new (ELeave) CAknStaticNoteDialog(); + iPermanentNote->PrepareLC( R_SATUI_PERMANENT_NOTE ); + + if ( ( !aSelfExplanatory ) || ( !aIconBitmap ) ) + { + // Set text + iPermanentNote->SetTextL( aText ); + } + + if ( aIconBitmap ) + { + //Set image + TFLOGSTRING( "CSatUiViewAppUi::PlayUserSelectedToneL SetImage" ) + CEikImage* image = new ( ELeave ) CEikImage(); + CleanupStack::PushL( image ); + image->SetBitmap( aIconBitmap ); + iPermanentNote->SetImageL( image ); + CleanupStack::Pop( image ); + } + + iPermanentNote->SetTimeout( CAknNoteDialog::ENoTimeout ); + iForegroundControl = iPermanentNote; + iPermanentNote->RunLD(); + } + + // If several messages/calls arrive during a small amount of time and if the + // message received or incoming call tone is already being played we do not + // restart it. + if ( iAudioPlayer ) + { + TFLOGSTRING( "CSatUiViewAppUi::\ + PlayUserSelectedToneL Error - already played" ) + return ESatFailure; + } + + // This defines name for the current message alert or incoming call tone. + TBuf soundFileName; + GetProfileParamsL( aTone, &soundFileName ); + // This defines the behaviour to be adopted by an + // audio client if a higher priority client takes over the device. + TInt mdaPriority( KAudioPrefIncomingCall ); + // This is used to resolve conflicts when more than one client tries to + // access the same sound output device simultaneously. + TInt audioPriority( KAudioPriorityPhoneCall ); + + TFLOGSTRING2( "CSatUiViewAppUi::PlayUserSelectedToneL\ + Volume is %i ", iVolume ) + + // Creates the audio player. + iAudioPlayer = CMdaAudioPlayerUtility::NewFilePlayerL( + soundFileName, + *this, + audioPriority, + ( TMdaPriorityPreference ) mdaPriority ); + + if ( TTimeIntervalMicroSeconds( static_cast( 0 ) ) != aDuration ) + { + TFLOGSTRING( "CSatUiViewAppUi::PlayUserSelectedToneL duration not 0" ) + TTimeIntervalMicroSeconds max32Bit( + static_cast( K32TIntMaxValue ) ); + if ( aDuration > max32Bit ) + { + // Timers can only handle 32-bit values + // and 64-bit value is received. + // Let's break the aDuration to smaller bits. + // Divided here by 8 to fit in 32-bit maxvalue. + // Loops 8 times in DelayCallback to play tone + // right duration. + aDuration = aDuration.Int64() / KDivideByEight; + iTimerRepeatOn = ETrue; + } + iAudioPlayer->SetRepeats( KSoundPlayerRepeatForever, + TTimeIntervalMicroSeconds( + static_cast( 0 ) ) ); + CreateCallBackTimerL( I64INT( aDuration.Int64() ), DelayCallback ); + + if ( !iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::PlayUserSelectedToneL\ + starting iWait" ) + iWait->Start(); + TFLOGSTRING( "CSatUiViewAppUi::PlayUserSelectedToneL\ + strarting done" ) + } + + // Sample is played in forever loop for the duration. + // After duration call back timers are destroyed + DestroyCallBackTimer(); + // If player exists, stop playing and delete player. MapcPlayComplete + // is not called because CallBackTimer stops the playing. + if ( iAudioPlayer ) + { + iAudioPlayer->Stop(); + delete iAudioPlayer; + iAudioPlayer = NULL; + TFLOGSTRING( "CSatUiViewAppUi::PlayUserSelectedToneL\ + iAudioPlayer deleted" ) + } + // Remove note after play has completed. + if ( iPermanentNote ) + { + iPermanentNote->ExitSleepingDialog(); + delete iPermanentNote; + iPermanentNote = NULL; + } + iForegroundControl = NULL; + + if ( !iEndKeyPressed ) + { + ShowWaitNoteL(); + } + + } + else + { + // If duration is zero then tone is played only once. + // Playing duration is same as duration of the sample. + iAudioPlayer->SetRepeats( + 0, TTimeIntervalMicroSeconds( static_cast( 0 ) ) ); + TFLOGSTRING( "CSatUiViewAppUi::PlayUserSelectedToneL SetRepeats 0" ) + } + + TFLOGSTRING( "CSatUiViewAppUi::PlayUserSelectedToneL exit" ) + if( EFalse == iWarningAndPlayTones ) + { + return ESatSuccessToneNotPlayed; + } + + return ESatSuccess; + } + + +// --------------------------------------------------------- +// CSatUiViewAppUi::ConfirmOpenChannelL +// Displays a query to get confirmation for Open Channel command. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TSatUiResponse CSatUiViewAppUi::ConfirmOpenChannelL( + const TDesC& aText, + TBool& aActionAccepted, + const CFbsBitmap* aIconBitmapOpenChannel, + const TBool aSelfExplanatory ) + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmOpenChannelL called" ) + + TSatUiResponse response( ESatSuccess ); + TInt resource( 0 ); + TPtrC textPtr( aText ); + HBufC* textHolder = NULL; + + if ( aIconBitmapOpenChannel ) + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmOpenChannelL have icon" ) + resource = R_SATUI_CONFIRM_OK_CANCEL_QUERY_WITH_ICON; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmOpenChannelL no icon" ) + resource = R_SATUI_CONFIRM_OK_CANCEL_QUERY; + + TFLOGSTRING2( "CSatUiViewAppUi::ConfirmOpenChannelL length of \ + aText %d", aText.Length() ) + if ( 0 == aText.Length() ) + { + textHolder = StringLoader::LoadLC( R_QTN_SAT_CONF_OPEN_CHANNEL_BIP, + iCoeEnv ); + textPtr.Set( *textHolder ); + } + } + + TInt userResponse = RunQueryDialogL( resource, textPtr, + aIconBitmapOpenChannel, aSelfExplanatory, EAknSoftkeyOk ); + + if ( textHolder ) + { + CleanupStack::PopAndDestroy( textHolder ); + } + + if ( userResponse ) + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmOpenChannelL action accepted" ) + aActionAccepted = ETrue; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmOpenChannelL action not \ + accepted" ) + aActionAccepted = EFalse; + } + + + + ShowWaitNoteL(); + + TFLOGSTRING2( "CSatUiViewAppUi::ConfirmOpenChannelL exit,return: %d",\ + response ) + return response; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ShowBIPNoteL +// Displays the BIP note. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ShowBIPNoteL( TInt aCommand, const TDesC& aText, + const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatory ) + { + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL() called" ) + TFLOGSTRING2( "CSatUiViewAppUi::ShowBIPNoteL() aCommand: %d", aCommand ) + + iWaitNoteInUse = ETrue; + TBool showNote( EFalse ); + TInt resourceId( 0 ); + switch ( aCommand ) + { + case ESendDataIdentier: // fall through + case EReceiveDataIdentifier: + { + resourceId = R_SATUI_BIP_WAIT_NOTE; + showNote = ETrue; + break; + } + case ECloseChannelIdentifier: + { + HBufC* textHolder = StringLoader::LoadLC( + R_QTN_SAT_CONF_CLOSE_CHANNEL_BIP, iCoeEnv ); + + if ( !iNoteDialog ) + { + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL no NoteDialog" ) + iNoteDialog = new (ELeave) CAknNoteDialog( + REINTERPRET_CAST( CEikDialog**, &iNoteDialog ), + CAknNoteDialog::ENoTone, + CAknNoteDialog::EShortTimeout ); + + if ( aIconBitmap ) + { + iNoteDialog->PrepareLC( R_SATUI_CLOSE_CHANNEL_ICON_NOTE ); + //Set image + TFLOGSTRING( + "CSatUiViewAppUi::ShowBIPNoteL SetImage" ) + CEikImage* image = new ( ELeave ) CEikImage(); + CleanupStack::PushL( image ); + image->SetBitmap( aIconBitmap ); + iNoteDialog->SetImageL( image ); + CleanupStack::Pop( image ); + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL no Icon" ) + iNoteDialog->PrepareLC( R_SATUI_CLOSE_CHANNEL_NOTE ); + } + + // inform the user using received alpha id + if ( ( aText.Length() > 0 ) && + ( !aSelfExplanatory || !aIconBitmap ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL using \ + received alpha id" ) + iNoteDialog->SetTextL( aText ); + } + // inform the user using localized text + else if ( aText.Length() == 0 ) + { + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL using \ + localized text" ) + iNoteDialog->SetTextL( *textHolder ); + } + + iForegroundControl = iNoteDialog; + iNoteDialog->RunLD(); + // iForegroundControl won't be clear until the note dialog + // closed. It will avoid we lose the chance to set focus for + // the wait dialog when the switch of foreground/background + // happened. + } + + CleanupStack::PopAndDestroy( textHolder ); // textHolder + + showNote = EFalse; + break; + } + default: + { + showNote = EFalse; + break; + } + } + if ( showNote ) + { + + // First, stop normal wait note. + if ( iWaitNote ) + { + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL() Closing WaitNote" ) + TRAP_IGNORE( iWaitNote->ProcessFinishedL() ) + iWaitNote = NULL; + } + + if ( !iBipWaitNote ) + { + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL() no BipWaitNote" ) + iBipWaitNote = new ( ELeave ) CSatUiWaitDialog( + (REINTERPRET_CAST(CEikDialog**,&iBipWaitNote)), + *iAdapter, ETrue ); + + if ( ( aText.Length() > 0 ) && ( !aSelfExplanatory || + !aIconBitmap ) ) + { + iBipWaitNote->SetTextL( aText ); + } + + if ( aIconBitmap ) + { + //Set image + TFLOGSTRING( + "CSatUiViewAppUi::ShowBIPNoteL SetImage" ) + CEikImage* image = new ( ELeave ) CEikImage(); + CleanupStack::PushL( image ); + image->SetBitmap( aIconBitmap ); + iBipWaitNote->SetImageL( image ); + CleanupStack::Pop( image ); + } + + iForegroundControl = iBipWaitNote; + iBipWaitNote->ExecuteLD( resourceId ); + // iForegroundControl won't be clear until the BipWait dialog + // closed. It will avoid we lose the chance to set focus for + // the wait dialog when the switch of foreground/background + // happened. + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL() have BipWaitNote" ) + // BIP note already exists, update text if not with self + // explanatory icon + if ( ( aText.Length() > 0 ) && + ( !aSelfExplanatory || !aIconBitmap ) ) + { + iBipWaitNote->SetTextL( aText ); + } + else if ( aSelfExplanatory && aIconBitmap ) + { + const TDesC emptyText( KNullDesC ); + iBipWaitNote->SetTextL( emptyText ); + } + // BIP note already exists, update image + if ( aIconBitmap ) + { + //Set image + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL SetImage" ) + CEikImage* image = new ( ELeave ) CEikImage(); + CleanupStack::PushL( image ); + image->SetBitmap( aIconBitmap ); + iBipWaitNote->SetImageL( image ); + CleanupStack::Pop( image ); + } + } + } + TFLOGSTRING( "CSatUiViewAppUi::ShowBIPNoteL() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::RemoveNullCharacters +// Null characters are removed from text +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::RemoveNullCharacters( HBufC* aText ) + { + TFLOGSTRING( "CSatUiViewAppUi::RemoveNullCharacters calling" ) + TPtr titleptr = aText->Des(); + TInt nullLocation( 0 ); + while ( ( nullLocation = titleptr.Locate( NULL ) ) >= 0 ) + { + titleptr.Delete( nullLocation, 1 ); + } + TFLOGSTRING( "CSatUiViewAppUi::RemoveNullCharacters exiting" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ConfirmSetUpCallL +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ConfirmSetUpCallL( + const TDesC& aText, + const TDesC& aSimAppName, + TBool& aActionAccepted, + const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatory ) + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmSetUpCallL calling" ) + + aActionAccepted = EFalse; + TPtrC text( aText ); + HBufC* textHolder = NULL; + HBufC* titleHolder = NULL; + TInt resource( 0 ); + + if ( aIconBitmap ) + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmSetUpCallL have icon" ) + resource = R_SATUI_CONFIRM_CALL_CANCEL_QUERY_WITH_ICON; + + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::ConfirmSetUpCallL no icon" ) + resource = R_SATUI_CONFIRM_CALL_CANCEL_QUERY; + + TFLOGSTRING2( "CSatUiViewAppUi::ConfirmSetUpCallL length of aText, \ + %d", aText.Length() ) + if ( aText.Length() == 0 ) + { + + if ( aSimAppName.Length() > 0 ) + { + titleHolder = aSimAppName.AllocLC(); + } + else + { + titleHolder = StringLoader::LoadLC( R_QTN_SAT_QUERY_TITLE, + iCoeEnv ); + } + + textHolder = StringLoader::LoadLC( R_TEXT_CALL_SETUP_BY_SIMATK, + *titleHolder, iCoeEnv ); + + RemoveNullCharacters( textHolder ); + + text.Set(*textHolder); + } + } + + TInt userResponse = RunQueryDialogL( resource, text, aIconBitmap, + aSelfExplanatory, ESatUiSoftkeyCall ); + + if ( textHolder ) + { + CleanupStack::PopAndDestroy( textHolder ); //textHolder + } + + if ( titleHolder ) + { + CleanupStack::PopAndDestroy( titleHolder ); //titleHolder + } + + if ( userResponse ) + { + aActionAccepted = ETrue; + } + + TFLOGSTRING( "CSatUiViewAppUi::ConfirmSetUpCallL exiting" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ShowNotAvailableNoteL +// Show note indicating SAT is not available +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ShowNotAvailableNoteL() + { + TFLOGSTRING( "CSatUiViewAppUi::ShowNotAvailableNoteL() called" ) + CAknNoteDialog* noteDialog = new (ELeave) CAknNoteDialog( + REINTERPRET_CAST(CEikDialog**,¬eDialog), + CAknNoteDialog::ENoTone, + CAknNoteDialog::ELongTimeout ); + + HBufC* textHolder = StringLoader::LoadLC( R_QTN_SAT_SERVICES_NOT_AVAILABLE, + iCoeEnv ); + + noteDialog->PrepareLC( R_SATUI_INFORMATION_NOTE ); + noteDialog->SetTextL( *textHolder ); + iForegroundControl = noteDialog; + noteDialog->RunLD(); + iForegroundControl = NULL; + + CleanupStack::PopAndDestroy( textHolder ); + + TFLOGSTRING( "CSatUiViewAppUi::ShowNotAvailableNoteL() exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::RunQueryIconDialogL +// Make and run note dialog with an icon +// (other items were commented in a header). +// --------------------------------------------------------- +// +TInt CSatUiViewAppUi::RunQueryDialogL( + TInt aResourceId, const TDesC& aText, const CFbsBitmap* aIconBitmap, + const TBool aSelfExplanatory, TInt aMskCommand ) + { + TFLOGSTRING( "CSatUiViewAppUi::RunQueryDialogL called" ) + CEikImage* image = new(ELeave) CEikImage; + CleanupStack::PushL( image ); + iQueryDialog = CAknQueryDialog::NewL(); + iQueryDialog->PrepareLC( aResourceId ); + TInt userResponse( 0 ); + + if ( aIconBitmap ) + { + TFLOGSTRING( "CSatUiViewAppUi::RunQueryDialogL set icon" ) + image->SetBitmap( aIconBitmap ); + + // Create mask for icon bitmap + CFbsBitmap* mask = new(ELeave) CFbsBitmap; + TSize size = aIconBitmap->SizeInPixels(); + MakeGetInputBitmapMask( mask, size ); + image->SetMask( mask ); + // Add icon to query + iQueryDialog->QueryHeading()->SetHeaderImageL( image ); + } + + if ( !aSelfExplanatory || !aIconBitmap ) + { + TFLOGSTRING( "CSatUiViewAppUi::RunQueryDialogL set text" ) + TPtrC textPtr( aText ); + // Icon is not self-explanatory, show also text + iQueryDialog->SetPromptL( textPtr ); + } + + // Set MSK same as LSK without any text causing the icon drawing + iQueryDialog->ButtonGroupContainer().SetCommandL( + CEikButtonGroupContainer::EMiddleSoftkeyPosition, aMskCommand, + KSatEmptyDes ); + iForegroundControl = iQueryDialog; + userResponse = iQueryDialog->RunLD(); + iForegroundControl = NULL; + CleanupStack::PopAndDestroy( image ); // image + + iQueryDialog = NULL; + + TFLOGSTRING2( "CSatUiViewAppUi::RunQueryDialogL exit,return: %d", \ + userResponse ) + return userResponse; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::CloseSatUI +// Start SatUi closing process +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::CloseSatUI() + { + TFLOGSTRING( "CSatUiViewAppUi::CloseSatUI called" ) + + TRAP_IGNORE( HandleExitCommandL() ); + + if ( !IsAppShutterRunning() ) + { + TFLOGSTRING( "CSatUiViewAppUi::CloseSatUI RunAppShutter" ) + RunAppShutter(); + } + + TFLOGSTRING( "CSatUiViewAppUi::CloseSatUI exit" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::GetProfileParamsL +// Get and store settings from current profile +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::GetProfileParamsL( TSatTone aTone /*= ESatToneNotSet*/, + TDes* aToneName /*= NULL*/ ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetProfileParamsL calling" ) + + MProfile* profile = NULL; + MProfileEngine* engine = NULL; + + engine = CreateProfileEngineL(); + CleanupReleasePushL( *engine ); + + profile = engine->ActiveProfileLC(); + + const MProfileTones& tones = profile->ProfileTones(); + + // Takes a current warning and gametones setting. + const TProfileToneSettings& ts = tones.ToneSettings(); + iWarningAndPlayTones = ts.iWarningAndGameTones; + iVolume = ts.iRingingVolume; + TFLOGSTRING2( "CSatUiViewAppUi::GetProfileParamsL \ + iVolume before mapping %d", iVolume ) + + // Max volume from profile is KMaxVolumeFromProfile, Max volume from + // CMdaAudioToneUtility is different, maybe 10,000. So, + // rate = maxVolumeFromPlayer / KMaxVolumeFromProfile + // User may never hear the TONE, because volume is too small. + // iVolume times the rate make it can be heard. + + CMdaAudioToneUtility* toneUtl = CMdaAudioToneUtility::NewL( *this ); + TInt maxVolumeFromPlayer( toneUtl->MaxVolume() ); + iVolume *= maxVolumeFromPlayer / KMaxVolumeFromProfile; + delete toneUtl; + toneUtl = NULL; + TFLOGSTRING2( "CSatUiViewAppUi::GetProfileParamsL \ + iVolume after mapping %d", iVolume ) + + if ( ( ESatUserSelectedToneIncomingSms == aTone ) && ( aToneName ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetProfileParamsL message tone" ) + aToneName->Copy( tones.MessageAlertTone() ); + } + else if( aToneName ) + { + TFLOGSTRING( "CSatUiViewAppUi::GetProfileParamsL ring tone" ) + aToneName->Copy( tones.RingingTone1() ); + } + + CleanupStack::PopAndDestroy( 2 ); // engine, profile + + TFLOGSTRING( "CSatUiViewAppUi::GetProfileParamsL exits" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::HandleImmediateDigitResponse +// Check received key event. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::HandleImmediateDigitResponse( TInt aScanCode ) + { + TFLOGSTRING2( "CSatUiViewAppUi::HandleImmediateDigitResponse() code: %d", + aScanCode ) + TBool closeDialog( ETrue ); + + // If number button is pressed + if ( ( KKeyZero <= aScanCode ) && ( KKeyNine >= aScanCode ) ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleImmediateDigitResponse press \ + digit 0-9" ) + iKey = aScanCode; + } + else if ( EStdKeyNkpAsterisk == aScanCode || KHwAsterisk == aScanCode ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleImmediateDigitResponse press \ + *" ) + iKey = 0x2A; + } + else if ( EStdKeyHash == aScanCode ) + { + TFLOGSTRING( "CSatUiViewAppUi::HandleImmediateDigitResponse press \ + #" ) + iKey = 0x23; + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::HandleImmediateDigitResponse press \ + others" ) + closeDialog = EFalse; + iKey = 0x00; + } + + if( closeDialog ) + { + CloseDialogs(); + } + + TFLOGSTRING( "CSatUiViewAppUi::HandleImmediateDigitResponse exits" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::PriorityVerifyAndClose +// Handle closing display text in high priority events +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::PriorityVerifyAndClose( const TWsEvent& aEvent ) + { + TFLOGSTRING( "CSatUiViewAppUi::PriorityVerifyAndClose calling" ) + + if ( ( iDisplayTextDialog || iDisplayTextIconDialog ) && + ( EEventFocusLost == aEvent.Type() ) ) + { + // Open the WS server session. + RWsSession wsSession; + if ( KErrNone == wsSession.Connect() ) + { + TInt wgFocus( wsSession.GetFocusWindowGroup() ); + TInt wgPriority( + wsSession.GetWindowGroupOrdinalPriority( wgFocus ) ); + TFLOGSTRING2( + "CSatUiViewAppUi::PriorityVerifyAndClose priority=%d", + wgPriority ) + + // For some reason window group priority for call dialogs was 0 + // so those cases must be checked in addition + TInt callActiveState = EPSCTsyCallStateNone; + + // Get current call status from P&S + const TInt errCode( RProperty::Get( + KPSUidCtsyCallInformation, + KCTsyCallState, + callActiveState ) ); + + // Receiving MT or creating MO call + const TBool callIncoming( + ( EPSCTsyCallStateAlerting == callActiveState ) || + ( EPSCTsyCallStateRinging == callActiveState ) || + ( EPSCTsyCallStateDialling == callActiveState ) ); + TFLOGSTRING2( + "CSatUiViewAppUi::PriorityVerifyAndClose callActiveState=%d", + callActiveState ) + TFLOGSTRING2( + "CSatUiViewAppUi::PriorityVerifyAndClose iImmediateRsp=%d", + iImmediateRsp ) + + // If the new focus window group has high priority + // close dialog + if ( ( wgPriority > 0 && iForeground ) || + ( iImmediateRsp && callIncoming ) ) + { + iHighPriorityEvent = ETrue; + CloseDialogs(); + } + + wsSession.Close(); + } + } + + TFLOGSTRING( "CSatUiViewAppUi::PriorityVerifyAndClose exiting" ) + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::CloseCallControlNote +// Call back method, close the note in call control. +// (other items were commented in a header). +// --------------------------------------------------------- +// +TInt CSatUiViewAppUi::CloseCallControlNoteL( TAny* aPtr ) + { + TFLOGSTRING( "CSatUiViewAppUi::CloseCallControlNote calling" ) + + if ( !aPtr ) + { + return KErrArgument; + } + + CSatUiViewAppUi* pAppUi = + reinterpret_cast( aPtr ); + + TRAPD( err, pAppUi->iCcNote->CancelNoteL( pAppUi->iCcNoteId ) ); + if( KErrNone != err ) + { + return err; + } + + if ( pAppUi->iWait->IsStarted() ) + { + pAppUi->iWait->AsyncStop(); + } + delete pAppUi->iCcNote; + pAppUi->iCcNote = NULL; + + TFLOGSTRING( "CSatUiViewAppUi::CloseCallControlNote exiting" ) + + return 0; + } + +// --------------------------------------------------------- +// CSatUiViewAppUi::ShowSsErrorNoteL +// Show a Ss Error note. +// (other items were commented in a header). +// --------------------------------------------------------- +// +void CSatUiViewAppUi::ShowSsErrorNoteL() + { + TFLOGSTRING( "CSatUiViewAppUi::ShowSsErrorNoteL calling" ) + CAknNoteDialog* errorNote = new ( ELeave ) CAknNoteDialog( + REINTERPRET_CAST( CEikDialog**,&errorNote ), + CAknNoteDialog::ENoTone, + CAknNoteDialog::ELongTimeout ); + CleanupStack::PushL( errorNote ); + + HBufC* textHolder = StringLoader::LoadLC(R_TEXT_NOT_DONE, iCoeEnv ); + errorNote->SetTextL( *textHolder ); + CleanupStack::PopAndDestroy( textHolder ); + CleanupStack::Pop( errorNote ); + errorNote->ExecuteLD( R_SATUI_INFORMATION_NOTE ); + + TFLOGSTRING( "CSatUiViewAppUi::ShowSsErrorNoteL exiting" ) + } + +// ----------------------------------------------------------------------------- +// CSatUiViewAppUi::ProfileState +// Return current profile state +// ----------------------------------------------------------------------------- +// +TInt CSatUiViewAppUi::ProfileState() + { + TFLOGSTRING( "CSatUiViewAppUi::ProfileState called" ) + + TInt profileId( 0 ); + CRepository* cr ( NULL ); + + TRAPD( err, cr = CRepository::NewL( KCRUidProfileEngine ) ); + if ( ( KErrNone == err ) && cr ) + { + TFLOGSTRING( "CSatUiViewAppUi::ProfileState no err" ) + // Get the ID of the currently active profile: + cr->Get( KProEngActiveProfile, profileId ); + delete cr; + } + + else + { + TFLOGSTRING2( "CR failed: %i", err ) + } + + TFLOGSTRING2( "CSatUiViewAppUi::ProfileState exit value: %d", + profileId ) + + return profileId; + } +// ----------------------------------------------------------------------------- +// CSatUiViewAppUi::StopPlayToneL +// Stops playing play tone. Used when user terminates play tone +// ----------------------------------------------------------------------------- +// +void CSatUiViewAppUi::StopPlayToneL() + { + TFLOGSTRING( "CSatUiViewAppUi::StopPlayToneL called" ) + if ( iPlayer && iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::StopPlayToneL\ + iPlayer exists" ) + iPlayToneError = ESatSessionTerminatedByUser; + iWait->AsyncStop(); + } + if ( iAudioPlayer ) + { + TFLOGSTRING( "StopPlayToneL iAudioPlayer exists" ) + if ( iWait->IsStarted() ) + { + TFLOGSTRING( "CSatUiViewAppUi::StopPlayToneL\ + iWait started" ) + // Remove note when play has been interrupted. + if ( iPermanentNote ) + { + iPermanentNote->ExitSleepingDialog(); + delete iPermanentNote; + iPermanentNote = NULL; + } + iPlayToneError = ESatSessionTerminatedByUser; + iWait->AsyncStop(); + } + else + { + TFLOGSTRING( "CSatUiViewAppUi::StopPlayToneL\ + iWait not started" ) + iAudioPlayer->Stop(); + // When playing is stopped, deleting the audio player. + // MapcPlayComplete is not called because user stops + // the playing. + if ( iAudioPlayer ) + { + delete iAudioPlayer; + iAudioPlayer = NULL; + TFLOGSTRING( "CSatUiViewAppUi::StopPlayToneL\ + iAudioPlayer deleted" ) + + // Remove note after play has completed. + if ( iPermanentNote ) + { + TFLOGSTRING( "CSatUiViewAppUi::StopPlayToneL\ + iPermanentNote true" ) + iPermanentNote->ExitSleepingDialog(); + delete iPermanentNote; + iPermanentNote = NULL; + } + + // Show wait note only for samples that have + // duration, otherwise there is chance that wait + // note is not stopped. + if ( TTimeIntervalMicroSeconds( + static_cast( 0 ) ) != iDuration ) + { + ShowWaitNoteL(); + } + } + } + } + TFLOGSTRING( "CSatUiViewAppUi::StopPlayToneL exiting" ) + } + +// ----------------------------------------------------------------------------- +// CSatUiViewAppUi::ForegroundAlive +// Check if foreground control is alive when HandleForegroundEventL is called. +// ----------------------------------------------------------------------------- +// +TBool CSatUiViewAppUi::ForegroundAlive() const + { + TFLOGSTRING( "CSatUiViewAppUi::ForegroundAlive called" ) + + // Only if value of iForegroundControl equals to one of the following 8 + // pointers, the alive value will be set to true. This will check if + // the foreground control is alive. + TBool alive = + iForegroundControl == static_cast( iWaitNote ) + || iForegroundControl == static_cast( + iDisplayTextIconDialog ) + || iForegroundControl == static_cast( + iDisplayTextDialog ) + || iForegroundControl == static_cast( iGetInputDialog ) + || iForegroundControl == static_cast( iPermanentNote ) + || iForegroundControl == static_cast( iNoteDialog ) + || iForegroundControl == static_cast( iBipWaitNote ) + || iForegroundControl == static_cast( iQueryDialog ); + + TFLOGSTRING2( "CSatUiViewAppUi::ForegroundAlive exiting alive=%d", alive ) + + return alive; + } + +// End of File