diff -r 1a6714c53019 -r cce62ebc198e fmradio/fmradio/src/fmradioappui.cpp --- a/fmradio/fmradio/src/fmradioappui.cpp Thu Aug 19 09:55:21 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,2856 +0,0 @@ -/* -* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). -* All rights reserved. -* This component and the accompanying materials are made available -* under the terms of "Eclipse Public License v1.0" -* which accompanies this distribution, and is available -* at the URL "http://www.eclipse.org/legal/epl-v10.html". -* -* Initial Contributors: -* Nokia Corporation - initial contribution. -* -* Contributors: -* -* Description: FM Radio App UI implementation -* -*/ - -// INCLUDE FILES - -#include -#if defined __SERIES60_HELP || defined FF_S60_HELPS_IN_USE -#include -#include "radio.hlp.hrh" -#endif -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "fmradiobacksteppingservicewrapper.h" -#include "fmradiodocument.h" -#include "fmradioengine.h" -#include "fmradiovariant.hrh" -#include "fmradiomainview.h" -#include "fmradiochannellistview.h" -#include "fmradiocontroleventobserverimpl.h" -#include "fmradioscanlocalstationsview.h" -#include "fmradio.hrh" -#include "fmradioengine.hrh" -#include "fmradioappui.h" -#include "fmradiordsreceiver.h" -#include "fmradioapp.h" -#include "fmradiopubsub.h" -#include "debug.h" - -// Application Uid for Active Idle app -#ifdef __ACTIVE_IDLE -const TUid KFMRadioUidIdleApp = { 0x101FD64C }; -#else -const TUid KFMRadioUidIdleApp = KPSUidActiveIdle2; // use this one instead because the "aisystemuids.hrh" is not export -#endif -// CONSTANTS - -// --------------------------------------------------------------------------------- -// CFMInformationNote::CFMInformationNote -// --------------------------------------------------------------------------------- -CFMInformationNote::CFMInformationNote( MInformationNoteInterface& aObserver ) : - CAknInformationNote ( EFalse ), - iDialogObserver( aObserver ) - { - - } -// --------------------------------------------------------------------------------- -// CFMInformationNote::~CFMInformationNote -// --------------------------------------------------------------------------------- -// -CFMInformationNote::~CFMInformationNote() - { - iDialogObserver.DialogTerminated(); - } -// ================= MEMBER FUNCTIONS ======================= - -// --------------------------------------------------------------------------------- -// C++ default constructor can NOT contain any code, that -// might leave. -// --------------------------------------------------------------------------------- -// -CFMRadioAppUi::CFMRadioAppUi() : - iStartUp( ETrue ), - iStartupWizardHandled( EFalse ), - iStartupWizardRunning( EFalse ), - iTuneFromWizardActivated( EFalse ), - iInfoNoteOn( EFalse ), - iPendingViewId( KNullUid ), - iRegionChanged( EFalse ) - { - } - -// --------------------------------------------------------------------------------- -// CFMRadioAppUi::ConstructL -// 2nd phase constructor. Instanciates all member objects -// --------------------------------------------------------------------------------- -// -void CFMRadioAppUi::ConstructL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::ConstructL()") ) ); - - BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible ); - - FeatureManager::InitializeLibL(); - iFeatureManagerInitialized = ETrue; - - // initialise local variation key with all features disabled. - iFMRadioVariationFlags = 0; - iAudioResourceAvailable = ETrue; - iAlreadyClean = EFalse; - - iRadioEngine = CRadioEngine::NewL( *this ); // Construct a radio engine object - - // Fill channels array from engine - GetChannelsArrayL(); - - if ( iRadioEngine->IsInCall() ) - { - iCurrentRadioState = EFMRadioStateOffForPhoneCall; - } - - iBsWrapper = CFMRadioBackSteppingServiceWrapper::NewL( TUid::Uid( KUidFMRadioApplication ) ); - AddViewActivationObserverL( iBsWrapper ); - - iMainView = CFMRadioMainView::NewL( iRadioEngine, *iAlfEnv, *this ); - AddViewL( iMainView ); // transfer ownership to CAknViewAppUi - iChannelListView = CFMRadioChannelListView::NewL( iRadioEngine, *this ); - AddViewL( iChannelListView ); // transfer ownership to CAknViewAppUi - iScanLocalStationsView = CFMRadioScanLocalStationsView::NewL( *iRadioEngine, *this ); - AddViewL( iScanLocalStationsView ); // transfer ownership to CAknViewAppUi - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::SecondaryConstructL() -// All leaving function calls are made here, so that nothing is left on the stack if the ConstructL leaves -// The reason for this behaviour is that the UI framework doesn't handle leaves from the AppUi correctly. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::SecondaryConstructL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::SecondaryConstructL()") ) ); - - iLayoutChangeObserver = iMainView; - - iRadioEngine->PubSubL().PublishPresetCountL( iChannels.Count() ); - - // Create vertical volume popup for speaker and headset - iIhfVolumePopupControl = CAknVolumePopup::NewL( NULL, ETrue ); - iIhfVolumePopupControl->SetRange( KFMRadioMinVolumeLevel, KFMRadioMaxVolumeLevel ); - iIhfVolumePopupControl->SetStepSize( KFMRadioVolumeStepSize ); - // Set observer for control events - iIhfVolumePopupControl->SetObserver( this ); - - iHeadsetVolumePopupControl = CAknVolumePopup::NewL( NULL, ETrue ); - iHeadsetVolumePopupControl->SetRange( KFMRadioMinVolumeLevel, KFMRadioMaxVolumeLevel ); - iHeadsetVolumePopupControl->SetStepSize( KFMRadioVolumeStepSize ); - iHeadsetVolumePopupControl->SetObserver( this ); - - iActiveVolumePopupControl = iHeadsetVolumePopupControl; //initialize it to Headset - - // Create and set our observer for control events. - iControlEventObserver = CFMRadioControlEventObserverImpl::NewL( *this ); - iRadioEngine->PubSubL().SetControlEventObserver( iControlEventObserver ); - - // For monitoring side volume key events - iSvkEvents = CFMRadioSvkEvents::NewL(*this); - - iRadioEngine->PubSubL().PublishApplicationRunningStateL( EFMRadioPSApplicationRunning ); - - UpdateLandscapeInformation(); - - // Create alfred environment - iAlfEnv = CAlfEnv::NewL(); - - // Create alfred display - TRect rect; - AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, rect); - if( !IsLandscapeOrientation() ) - { - TRect toolBarRect = iMainView->Toolbar()->Rect(); - rect.SetHeight( rect.Height() - toolBarRect.Height() ); - } - iAlfEnv->NewDisplayL( rect, CAlfEnv::ENewDisplayAsCoeControl ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleTunerReadyCallback -// Tuner is initialized and ready. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleTunerReadyCallback() - { - iRadioEngine->InitializeRadio(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::~CFMRadioAppUi -// Destructor -// Frees reserved resources -// --------------------------------------------------------------------------- -// -CFMRadioAppUi::~CFMRadioAppUi() - { - if ( iRadioEngine ) - { - TRAP_IGNORE( - iRadioEngine->PubSubL().PublishApplicationRunningStateL( EFMRadioPSApplicationClosing ) ) - } - - FTRACE( FPrint( _L("CFMRadioAppUi::~CFMRadioAppUi()") ) ); - if ( iAlreadyClean == EFalse ) - { - Cleanup(); - } - - if ( iFeatureManagerInitialized ) - { - FeatureManager::UnInitializeLib(); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::Cleanup() -// Perform object cleanup. This would normally be performed in the destructor, -// but since it can also be called from SecondaryConstructL it was moved into -// a seperate function. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::Cleanup() - { - FTRACE( FPrint( _L("CFMRadioAppUi::Cleanup()") ) ); - - delete iIhfVolumePopupControl; - iIhfVolumePopupControl = NULL; - delete iHeadsetVolumePopupControl; - iHeadsetVolumePopupControl = NULL; - - if (iRadioEngine) - { - delete iRadioEngine; - iRadioEngine = NULL; - } - if (iSvkEvents) - { - delete iSvkEvents; - } - if (iGlobalOfflineQuery) - { - delete iGlobalOfflineQuery; - } - if (iLocalActivateOfflineQuery) - { - delete iLocalActivateOfflineQuery; - } - if (iLocalContinueOfflineQuery) - { - delete iLocalContinueOfflineQuery; - } - delete iControlEventObserver; - delete iAlfEnv; - - iAlreadyClean = ETrue; - - if ( iConnectHeadsetGlobalNote ) - { - delete iConnectHeadsetGlobalNote; - iConnectHeadsetGlobalNote = NULL; - } - if ( iConnectHeadsetQuery ) - { - delete iConnectHeadsetQuery; - iConnectHeadsetQuery = NULL; - } - - iChannels.ResetAndDestroy(); - iChannels.Close(); - - if ( iUpdate ) - { - delete iUpdate; - iUpdate = NULL; - } - if ( iParameters ) - { - delete iParameters; - iParameters = NULL; - } - if ( iSettingsRepository ) - { - delete iSettingsRepository; - iSettingsRepository = NULL; - } - if ( iBsWrapper ) - { - RemoveViewActivationObserver( iBsWrapper ); - } - delete iBsWrapper; - iBsWrapper = NULL; - - delete iStartupForegroundCallback; - iStartupForegroundCallback = NULL; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleCommandL -// Interprets view's menu-,softkey and other commands and acts -// accordingly by calling the appropriate command handler -// function for further action. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleCommandL( TInt aCommand ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleCommandL state=%d command=%d "), iCurrentRadioState, aCommand) ); - if ( iCurrentRadioState == EFMRadioStateOn ) - { - switch ( aCommand ) - { - case EFMRadioCmdChannelList: - ActivateLocalViewL( iChannelListView->Id() ); - break; - case EFMRadioCmdSeekUp: - ScanUpL(); - break; - case EFMRadioCmdSeekDown: - ScanDownL(); - break; - case EFMRadioCmdSaveChannel: - SaveChannelToLastIntoListL(); - break; - case EFMRadioCmdScanLocalStations: - ActivateLocalViewL( iScanLocalStationsView->Id() ); - break; - case EFMRadioCmdScanLocalStationsScan: - // continue scanning - StartLocalStationsSeekL(); - break; - case EFMRadioCmdListenCh: - if ( iChannels.Count() > 0 ) - { - PlayChannel( iChannelListView->CurrentlySelectedChannel() ); - } - break; - case EFMRadioCmdRename: - RenameCurrentChannelL(); - break; - case EFMRadioCmdActivateIhf: - SetAudioOutput( CRadioEngine::EFMRadioOutputIHF ); - break; - case EFMRadioCmdDeactivateIhf: - SetAudioOutput( CRadioEngine::EFMRadioOutputHeadset ); - break; - case EFMRadioCmdEnableRdsAfSearch: - iRadioEngine->SetRdsAfSearchEnable( ETrue ); - break; - case EFMRadioCmdDisableRdsAfSearch: - iRadioEngine->SetRdsAfSearchEnable( EFalse ); - break; - case EFMRadioCmdUpdateVolume: - UpdateVolume( EDirectionNone ); - break; - case EFMRadioCmdNextChannel: - { - TInt channelCount = iChannels.Count(); - if ( channelCount >= 1 ) - { - iMainView->SetStationChangeType( EFMRadioStationChangeNext ); - PlayChannel( iChannelListView->NextChannel() ); - } - else - { - if ( AknLayoutUtils::PenEnabled() ) - { - DisplayInformationNoteL( R_QTN_FMRADIO_USE_LONG_TAP ); - } - } - break; - } - case EFMRadioCmdPrevChannel: - { - TInt channelCount = iChannels.Count(); - if ( channelCount >= 1 ) - { - iMainView->SetStationChangeType( EFMRadioStationChangePrevious ); - PlayChannel( iChannelListView->PreviousChannel() ); - } - else - { - if ( AknLayoutUtils::PenEnabled() ) - { - DisplayInformationNoteL( R_QTN_FMRADIO_USE_LONG_TAP ); - } - } - break; - } - case EFMRadioCmdMuteOn: - iRadioEngine->SetMuteOn( ETrue ); - break; - case EFMRadioCmdMuteOff: - iRadioEngine->SetMuteOn( EFalse ); - break; - case EFMRadioCmdMute: - HandleMuteCommand(); - break; - case EAknCmdHelp: - case EFMRadioCmdHelp: - { -#if defined __SERIES60_HELP || defined FF_S60_HELPS_IN_USE - if ( ActiveView() == KFMRadioMainViewId ) - { - HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), GetCurrentHelpContextL() ); - } - else - { - CArrayFix* buf = CCoeAppUi::AppHelpContextL(); - HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), buf ); - } -#endif - } - break; - default: - break; - } - } - else if ( iCurrentRadioState == EFMRadioStateBusySeek || - iCurrentRadioState == EFMRadioStateBusyScanLocalStations ) - { - switch ( aCommand ) - { - case EFMRadioCmdStopTuning: - case EAknSoftkeyCancel: - CancelSeek(); - break; - default: - break; - } - } - switch ( aCommand ) - { - case EFMRadioCmdScanLocalStationsViewActive: - iLayoutChangeObserver = iScanLocalStationsView; - break; - case EFMRadioCmdChannelListViewActive: - iLayoutChangeObserver = iChannelListView; - break; - case EFMRadioCmdMainViewActive: - iLayoutChangeObserver = iMainView; - break; - case EAknSoftkeyExit: - case EEikCmdExit: - case EAknCmdExit: - Exit(); - break; - default: - break; - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ActiveView -// --------------------------------------------------------------------------- -// -TUid CFMRadioAppUi::ActiveView() const - { - return iView ? iView->Id() : KNullUid; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::RadioEngine -// --------------------------------------------------------------------------- -// -CRadioEngine* CFMRadioAppUi::RadioEngine() - { - return iRadioEngine; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::Document -// --------------------------------------------------------------------------- -// -CFMRadioDocument* CFMRadioAppUi::Document() const - { - return static_cast( CEikAppUi::Document() ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::BackSteppingWrapper -// --------------------------------------------------------------------------- -// -CFMRadioBackSteppingServiceWrapper& CFMRadioAppUi::BackSteppingWrapper() const - { - return *iBsWrapper; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::TurnRadioOn -// Turn the fm radio hardware on -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::TurnRadioOn() - { - FTRACE(FPrint(_L("CFMRadioAppUi::TurnRadioOn()"))); - if ( !iRadioEngine->IsRadioOn() ) - { - // Force the mute state only if it wasn't already forced - if ( iMuteStatusBeforeRadioInit == EFMUninitialized ) - { - if ( iRadioEngine->IsMuteOn() ) - { - FTRACE(FPrint(_L("CFMRadioAppUi::iMuteStatusBeforeRadioInit = ETrue;()"))); - iMuteStatusBeforeRadioInit = EFMMuted; - } - else - { - FTRACE(FPrint(_L("CFMRadioAppUi::iMuteStatusBeforeRadioInit = EFalse;()"))); - iMuteStatusBeforeRadioInit = EFMUnmuted; - } - } - iCurrentRadioState = EFMRadioStateBusyRadioOn; - // use mute here so we have no audio until tune event - iRadioEngine->SetMuteOn( ETrue ); - iRadioEngine->RadioOn(); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::PlayChannel -// Tune the radio hardware to the frequency saved at the specified channel -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::PlayChannel( TInt aIndex ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::PlayChannel(%d)"), aIndex ) ); - if ( aIndex >= KMinNumberOfChannelListItems && - aIndex < KMaxNumberOfChannelListItems ) - { - // Activate the channel by index - TRAP_IGNORE( iRadioEngine->TunePresetL( aIndex ) ) - iMainView->PrepareViewForChannelChange(); - - // Update channel list - iChannelListView->SetNowPlayingChannel( aIndex ); - iChannelListView->SetLastListenedChannel( aIndex ); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::EraseCurrentChannelL -// Delete channel from the channel list -// --------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::EraseChannelL( TInt aIndex ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::EraseCurrentChannelL()") ) ); - - TBool accepted = ConfirmChannelListDeleteL( aIndex ); - - if ( accepted ) - { - UpdateChannelsL( EDeleteChannel, aIndex, 0 ); - UpdateChannelsL( EStoreAllToRepository, 0, 0 ); - } - return accepted; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::RenameCurrentChannelL -// Rename the currently selected channel -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::RenameCurrentChannelL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::RenameCurrentChannelL()") ) ); - - TInt channelIndex = KErrNotFound; - if ( ActiveView() == KFMRadioChannelListViewId ) - { - channelIndex = iChannelListView->CurrentlySelectedChannel(); - } - else - { - channelIndex = iRadioEngine->GetPresetIndex(); - } - // Display the text query - CRadioEngine::TStationName channelName = iChannels[ channelIndex ]->PresetName(); - - CAknTextQueryDialog* dlg = new (ELeave) CAknTextQueryDialog( channelName, CAknQueryDialog::ENoTone ); - - if ( dlg->ExecuteLD( R_FMRADIO_RENAME_QUERY ) ) - { - FTRACE(FPrint(_L("CFMRadioAppUi::RenameCurrentChannelL()"))); - - iChannels[channelIndex]->SetPresetNameL( channelName ); - - iChannelListView->UpdateChannelListContentL( channelIndex, - iChannels[ channelIndex ]->PresetName(), - iChannels[ channelIndex ]->PresetFrequency() ); - - UpdateChannelsL( EStoreIndexToRepository, channelIndex, 0 ); - - iMainView->SetStationChangeType( EFMRadioStationChangeNone ); - // A channel can also be renamed from the main view - iMainView->DisplayChannelL( channelIndex ); - // show default logo for a while - // so that animation is stopped and it has the right channel name - // after restart - iMainView->ShowDefaultLogo(); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::SaveChannelToLastIntoListL -// Display listbox menu to allow user to specify a channel -// to save currently tuned frequency to. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::SaveChannelToLastIntoListL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::SaveChannelToLastIntoListL()") ) ); - SaveChannelL( iChannels.Count() + 1 ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::SaveChannel -// Save currently tuned frequency to the currently selected channel -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::SaveChannelL( TInt aIndex ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::SaveChannelL(%d)"), aIndex ) ); - - TBool continueWithSave = ETrue; - // check if channel list is full - if ( aIndex == KMaxNumberOfChannelListItems + 1 ) - { - CAknQueryDialog* query = CAknQueryDialog::NewL(); - if ( query->ExecuteLD( R_FMRADIO_REPLACE_EXISTING_CHANNELS_QUERY ) ) - { - UpdateChannelsL( ERemoveAllFromRepository, 0, 0 ); - } - else - { - continueWithSave = EFalse; - } - } - - if ( continueWithSave ) - { - CFMRadioRdsReceiverBase& receiver = iRadioEngine->RdsReceiver(); - CFMRadioRdsReceiverBase::TFMRadioProgrammeSeviceType type = - receiver.ProgrammeServiceNameType(); - const TDesC& channelName = type == CFMRadioRdsReceiverBase::EFMRadioPSNameStatic ? - receiver.ProgrammeService() : KNullDesC; - - CFMRadioPreset* preset = CFMRadioPreset::NewL(); - CleanupStack::PushL( preset ); - preset->SetPresetNameL( channelName ); - preset->SetPresetFrequency( iRadioEngine->GetTunedFrequency() ); - - const TDesC& webUrl = receiver.RtPlusProgramUrl(); - if ( webUrl.Length() ) - { - preset->SetPresetUrlL( webUrl ); - } - iChannels.AppendL( preset ); - CleanupStack::Pop( preset ); - - UpdateChannelsL( EStoreAllToRepository, 0, 0 ); - - iMainView->SetStationChangeType( EFMRadioStationChangeNone ); - PlayChannel( iChannels.Count() - 1 ); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ConfirmChannelListDeleteL -// Display confirmation dialog for channel deletion -// --------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::ConfirmChannelListDeleteL( TInt aIndex ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::ConfirmChannelListActionL( %d )"), aIndex ) ); - TInt accepted = EFalse; // Operation accepted or discarded - TInt stringResourceId = 0; // Resource id of the prompt text - TInt queryResourceId = R_FMRADIO_ERASE_CH_CONFIRMATION_QUERY; // Resource id of the used query dialog - - RBuf channelData; - channelData.CleanupClosePushL(); - - if ( iChannels[ aIndex ]->PresetName().Length() ) - { - stringResourceId = R_QTN_FMRADIO_QUERY_DELETE; - channelData.CreateL( iChannels[ aIndex ]->PresetName() ); - } - else - { - stringResourceId = R_QTN_FMRADIO_QUERY_DELETE_MHZ; - TInt maxDecimalPlaces = iRadioEngine->DecimalCount(); - TInt channelfreq = iChannels[ aIndex ]->PresetFrequency(); - TReal realFrequency = static_cast( channelfreq / static_cast( KHzConversionFactor )); - - channelData.CreateL( KFrequencyMaxLength ); - - TRealFormat format( KFrequencyMaxLength, maxDecimalPlaces ); - channelData.Num( realFrequency, format ); - AknTextUtils::LanguageSpecificNumberConversion( channelData ); - } - // Excecute a confirmation query with string and query resource id - HBufC* prompt = StringLoader::LoadLC( stringResourceId, channelData, iCoeEnv ); - CAknQueryDialog* queryDlg = CAknQueryDialog::NewL(); - accepted = queryDlg->ExecuteLD( queryResourceId, *prompt ); - CleanupStack::PopAndDestroy( prompt ); - CleanupStack::PopAndDestroy( &channelData ); - return accepted; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ScanUpL -// -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::ScanUpL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::ScanUpL()") ) ); - // Frequency is always 0 when asking engine for automatical tuning. Frequency - // parameter is then ignored by engine when automatical tuning (seek) is requested. - iCurrentRadioState = EFMRadioStateBusySeek; - - if ( iMainView->IsForeground() ) - { - iMainView->SetStationChangeType( EFMRadioStationChangeScanUp ); - iMainView->SeekL(); // Show seek wait note - } - iRadioEngine->ScanUp(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ScanDownL -// -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::ScanDownL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::ScanDownL()") ) ); - // Frequency is always 0 when asking engine for automatical tuning. Frequency - // parameter is then ignored by engine when automatical tuning (seek) is requested. - iCurrentRadioState = EFMRadioStateBusySeek; - - if ( iMainView->IsForeground() ) - { - iMainView->SetStationChangeType( EFMRadioStationChangeScanDown ); - iMainView->SeekL(); // Show seek wait note - } - iRadioEngine->ScanDown(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::TuneL -// -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::TuneL( TInt aFrequency ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::TuneL(%d)"), aFrequency ) ); - // Frequency is always 0 when asking engine for automatical tuning. Frequency - // parameter is then ignored by engine when automatical tuning (seek) is requested. - iCurrentRadioState = EFMRadioStateBusySeek; - if (iMainView->IsForeground()) - { - iMainView->SeekL(); // Show seek wait note - } - iRadioEngine->Tune(aFrequency); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::UpdateVolume -// Update the radio volume -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::UpdateVolume( CFMRadioAppUi::TFMRadioDirections aDirection ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::UpdateVolume(%d)"), UpdateVolume ) ); - - if ( !iRadioEngine->IsInCall() ) - { - TInt volumeControlLevel = iRadioEngine->GetVolume(); - - TInt newVol = 0; - if ( aDirection == EDirectionDown ) - { - TRAP_IGNORE( ShowVolumePopupL(); ) - newVol = volumeControlLevel - 1; - - if ( newVol > KFMRadioMinVolumeLevel ) - { - iRadioEngine->SetVolume( newVol ); - } - else - { - iRadioEngine->SetMuteOn( ETrue ); - iRadioEngine->SetVolume( newVol ); - iActiveVolumePopupControl->SetValue( KFMRadioMinVolumeLevel ); - } - } - else if ( aDirection == EDirectionUp ) - { - TRAP_IGNORE( ShowVolumePopupL(); ) - if ( iRadioEngine->IsMuteOn() ) - { - iRadioEngine->SetMuteOn( EFalse ); - } - newVol = volumeControlLevel + 1; - - if ( newVol <= KFMRadioMaxVolumeLevel ) - { - iRadioEngine->SetVolume( newVol ); - } - else - { - iActiveVolumePopupControl->SetValue( KFMRadioMaxVolumeLevel ); - } - } - else if ( aDirection == EDirectionNone ) - { - //we just wish to update the UI's volume control - HandleVolumeChangedCallback(); - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::SetAudioOutput -// Set the audio output of the radio. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::SetAudioOutput( - CRadioEngine::TFMRadioAudioOutput aAudioOutput ) - { - iRadioEngine->SetAudioOutput( aAudioOutput ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::CancelSeek -// Cancel outstanding seek request. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::CancelSeek() - { - FTRACE( FPrint( _L("CFMRadioAppUi::CancelSeek()") ) ); - if ( iCurrentRadioState == EFMRadioStateBusySeek ) - { - iRadioEngine->CancelScan(); // Seek request to engine - } - HandleStopSeekCallback(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::DisplayErrorNoteL -// Displays an error note with the text contained in the passed in reference -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::DisplayErrorNoteL( TInt aErrorNote ) - { - // Show headset missing note - CAknErrorNote* errorNote = new ( ELeave ) CAknErrorNote( ETrue ); - HBufC* noteText = StringLoader::LoadLC( aErrorNote, iCoeEnv ); - errorNote->ExecuteLD( *noteText ); - CleanupStack::PopAndDestroy( noteText ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::DisplayInformationNoteL -// Displays an information note -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::DisplayInformationNoteL( TInt aInfoNote ) - { - if ( !iInfoNoteOn && IsForeground() ) - { - CFMInformationNote* infonote = new ( ELeave ) CFMInformationNote( *this ); - HBufC* noteText = StringLoader::LoadLC( aInfoNote, iCoeEnv ); - iInfoNoteOn = ETrue; - infonote->ExecuteLD( *noteText ); - CleanupStack::PopAndDestroy( noteText ); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ExitApplication -// Shutdown the application. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::ExitApplication() - { - FTRACE( FPrint( _L("CFMRadioAppUi::ExitApplication() - Start") ) ); - //this method is called twice. First will trigger the RadioOff command - if ( iCurrentRadioState == EFMRadioStateOff || - iCurrentRadioState == EFMRadioStateOffForPhoneCall || - iCurrentRadioState == EFMRadioStateOffBeforePhoneCall ) - { - //once we receive a radio off complete event we finish shutting down. - FTRACE( FPrint( _L("CFMRadioAppUi::ExitApplication() - calling exit") ) ); - Exit(); - } - else - { - if ( iCurrentRadioState != EFMRadioStateExiting ) - { - iCurrentRadioState = EFMRadioStateExiting; - FTRACE( FPrint( _L("CFMRadioAppUi::ExitApplication() - turning off, and starting timer") ) ); - iRadioEngine->RadioOff(); // Shutdown radio - } - } - } - -// --------------------------------------------------------------------------- -// From class CCoeAppUi -// CFMRadioAppUi::HandleForegroundEventL -// Application has gone to foreground/background. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleForegroundEventL( TBool aForeground ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleForegroundEventL(%d)"), aForeground ) ); - CAknViewAppUi::HandleForegroundEventL( aForeground ); - - if ( aForeground ) - { - if ( iStartUp ) - { - iStartUp = EFalse; - // Rest of startup processing may show a waiting dialog. It cannot be - // done while processing a foreground event. So a call back is used. - iStartupForegroundCallback = new( ELeave ) CAsyncCallBack( - TCallBack( StaticStartupForegroundCallback, this ), CActive::EPriorityStandard ); - iStartupForegroundCallback->CallBack(); - } - else - { - // Restores all resources that were released with a call to Release(). - // After this the Hitchcock user interface should be in the same state - // in terms of resources as it was prior to the Release() call. - iAlfEnv->RestoreL(); - - // Check if offline profile is activated after/when playing e.g. music player. - // In that case we didn't show the offline query as global, so we need - // to show it now. - if ( IsOfflineProfileActivatedWhenRadioAudioDisabled() ) - { - // Do not re-show the offline query if user hasn't yet answered to it. - if ( !iShowingLocalOfflineContinueQuery ) - { - iRadioEngine->RadioOff(); - TInt res(0); - iShowingLocalOfflineContinueQuery = ETrue; - - iOfflineQueryDialogActivated = ETrue; - - if ( !iLocalContinueOfflineQuery ) - { - iLocalContinueOfflineQuery = CAknQueryDialog::NewL(); - } - - res = iLocalContinueOfflineQuery->ExecuteLD( R_FMRADIO_CONTINUE_IN_OFFLINE_QUERY ); - - iLocalContinueOfflineQuery = NULL; - iOfflineQueryDialogActivated = EFalse; - iShowingLocalOfflineContinueQuery = EFalse; - - if ( res ) - { - iOfflineProfileActivatedWhenRadioAudioDisabled = EFalse; - iRadioEngine->RadioOn(); - HandlePendingViewActivationL(); - } - else - { - Exit(); - } - } - } - TryToResumeAudioL(); - } - } - else - { - // Releases as many resources of the Hitchcock as possible. - iAlfEnv->Release(); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleRadioEngineCallBack -// Notification from Radio Engine informing the UI when requests have -// completed or certain events have occured that needs to be handled. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleRadioEngineCallBack( - MRadioEngineStateChangeCallback::TFMRadioNotifyEvent aEventCode, - TInt aErrorCode ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleRadioEngineCallBack - event %d error code: %d"), aEventCode, aErrorCode ) ); - TInt err = KErrNone; - if ( aErrorCode == KErrNone ) - { - switch ( aEventCode ) - { - case EFMRadioEventTunerReady: - HandleTunerReadyCallback(); - break; - case EFMRadioEventRadioOn: - { - iCurrentRadioState = EFMRadioStateOn; - TRAPD( err, HandleStartupWizardL() ); - iStartupWizardHandled = ETrue; - const TUid activeViewTuid = ActiveView(); - - if ( activeViewTuid == KFMRadioChannelListViewId ) - { - CAknToolbar* toolbar = iChannelListView->Toolbar(); - if ( toolbar ) - { - iChannelListView->UpdateToolbar(); - toolbar->DrawDeferred(); - } - } - if( !IsStartupWizardRunning() || err != KErrNone ) - { - //we use method because the behaviour we require is the same. - if ( !iTuneFromWizardActivated && iMuteStatusBeforeRadioInit != EFMUninitialized ) - { - TBool mute = EFalse; - if ( iMuteStatusBeforeRadioInit == EFMMuted ) - { - mute = ETrue; - } - iRadioEngine->SetMuteOn( mute ); - iMuteStatusBeforeRadioInit = EFMUninitialized; - } - HandleStopSeekCallback(); - } - } - break; - case EFMRadioEventRadioOff: - iCurrentRadioState = EFMRadioStateOff; - - if ( !iOfflineQueryDialogActivated ) - { - ExitApplication(); - } - - break; - case EFMRadioEventFMRadioInitialized: - TRAP( err, HandleInitializedCallbackL() ); - break; - case EFMRadioEventTune: - if ( iTuneFromWizardActivated ) - { - iTuneFromWizardActivated = EFalse; - iRadioEngine->SetMuteOn( EFalse ); - iMuteStatusBeforeRadioInit = EFMUninitialized; - } - if ( IsStartupWizardHandled() ) - { - HandleStopSeekCallback(); - } - break; - case EFMRadioEventSetMuteState: - HandleSetMuteStateCallback(); - break; - case EFMRadioEventVolumeUpdated: - HandleVolumeChangedCallback(); - break; - case EFMRadioEventSetAudioOutput: - HandleAudioOutputSetCallback(); - break; - case EFMRadioEventButtonPressed: - iMainView->SetStationChangeType( EFMRadioStationChangeNext ); - PlayChannel( iChannelListView->NextChannel() ); - break; - case EFMRadioEventHeadsetDisconnected: - HandleHeadsetDisconnectedCallback(); - break; - case EFMRadioEventHeadsetReconnected: - HandleHeadsetReconnectedCallback(); - break; - case EFMRadioEventAudioResourceLost: - iAudioLost = ETrue; - TRAP( err, HandleAudioResourceNotAvailableL(aErrorCode) ); - break; - case EFMRadioEventAudioResourcePaused: - TRAP( err, HandleAudioResourceNotAvailableL(aErrorCode) ); - break; - case EFMRadioEventAudioResourceAvailable: - TRAP( err, HandleAudioResourceAvailableL() ); - break; - case EFMRadioEventCallStarted: - if ( iCurrentRadioState != EFMRadioStateOff && - iCurrentRadioState != EFMRadioStateOffBeforePhoneCall ) - { - iCurrentRadioState = EFMRadioStateOffForPhoneCall; - } - else - { - iCurrentRadioState = EFMRadioStateOffBeforePhoneCall; - } - FadeViewsAndShowExit( ETrue ); - break; - case EFMRadioEventCallEnded: - { - if ( iAudioLost ) - { - TRAP_IGNORE( TryToResumeAudioL() ); - iCurrentRadioState = EFMRadioStateOff; - } - else if ( iCurrentRadioState == EFMRadioStateOffForPhoneCall ) - { - TurnRadioOn(); - } - else - { - // Do nothing. - } - FadeViewsAndShowExit( EFalse ); - break; - } - case EFMRadioEventStandbyMode: - ExitApplication(); - break; - case EFMRadioEventFlightModeEnabled: - TRAP( err, HandleFlightModeEnabledCallbackL() ); - break; - case EFMRadioEventFlightModeDisabled: - HandleFlightModeDisabledCallback(); - break; - case EFMRadioEventFMTransmitterOn: - TRAP_IGNORE( HandleFMTransmitterOnCallbackL() ); - break; - case EFMRadioEventFreqRangeChanged: - HandleFreqRangeChangedCallback(); - break; - case EFMRadioEventScanLocalStationsCanceled: - { - HandleStopSeekCallback(); - SetStartupWizardRunning( EFalse ); - break; - } - default: - break; - } - } - else - { - switch ( aEventCode ) - { - case EFMRadioEventAudioResourceLost: - iAudioLost = ETrue; - TRAP( err, HandleAudioResourceNotAvailableL( aErrorCode ) ); - break; - case EFMRadioEventAudioResourcePaused: - TRAP( err, HandleAudioResourceNotAvailableL( aErrorCode ) ); - break; - case EFMRadioEventTune: - if ( iTuneFromWizardActivated ) - { - iTuneFromWizardActivated = EFalse; - iRadioEngine->SetMuteOn( EFalse ); - iMuteStatusBeforeRadioInit = EFMUninitialized; - } - - if ( aErrorCode == KFmRadioErrAntennaNotConnected ) - { - iScanLocalStationsView->SetScanCanceled(EFMRadioCancelScanByHeadsetDisconnect); - } - - HandleStopSeekCallback(); - break; - case EFMRadioEventCallStarted: - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleRadioEngineCallBack() error -> EFMRadioEventCallStarted ") ) ); - if ( iCurrentRadioState != EFMRadioStateOff && - iCurrentRadioState != EFMRadioStateOffBeforePhoneCall ) - { - iCurrentRadioState = EFMRadioStateOffForPhoneCall; - } - else - { - iCurrentRadioState = EFMRadioStateOffBeforePhoneCall; - } - FadeViewsAndShowExit( ETrue ); - break; - } - default: - FTRACE( FPrint( _L("CFMRadioAppUi::HandleRadioEngineCallBack() failed to process event.") ) ); - break; - } - } - FTRACE( FPrint( _L("END CFMRadioAppUi::HandleRadioEngineCallBack()") ) ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleVolumeChangedCallback -// Processes "volume changed" callback -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleVolumeChangedCallback() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleVolumeChangedCallback() Start") ) ); - if ( !iRadioEngine->IsMuteOn() ) - { - TInt newVolume = iRadioEngine->GetVolume(); // current volume - FTRACE( FPrint( _L("CFMRadioAppUi::HandleVolumeChangedCallback() - volume now %d "), newVolume ) ); - iActiveVolumePopupControl->SetValue( newVolume ); - } - else - { - iActiveVolumePopupControl->SetValue( KFMRadioMinVolumeLevel ); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleInitializedCallbackL -// The initialization of the radio is completed, the radio can be turned on if -// not in call. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleInitializedCallbackL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleInitializedCallbackL() Start") ) ); - if( iCurrentRadioState != EFMRadioStateOffForPhoneCall && - iCurrentRadioState != EFMRadioStateOffBeforePhoneCall ) - { - TurnRadioOn(); - if ( iRadioEngine->GetAudioOutput() == CRadioEngine::EFMRadioOutputIHF ) - { - iActiveVolumePopupControl = iIhfVolumePopupControl; - } - else - { - iActiveVolumePopupControl = iHeadsetVolumePopupControl; - } - HandleVolumeChangedCallback(); - } - } -// --------------------------------------------------------------------------- -// CFMRadioAppUi::FadeViewsAndShowExit -// fade and show exit for all views -// --------------------------------------------------------------------------- -// - -void CFMRadioAppUi::FadeViewsAndShowExit( TBool aState ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::FadeViewsAndShowExit( Tbool %d )"), aState ) ); - iMainView->FadeAndShowExit( aState ); - iChannelListView->FadeAndShowExit( aState ); - iScanLocalStationsView->FadeAndShowExit( aState ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleAudioResourceAvailableL -// When audio resource is available, we would resume the radio. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleAudioResourceAvailableL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleAudioResourceAvailableL") ) ); - - iAudioResourceAvailable = ETrue; - - if ( !IsOfflineProfileActivatedWhenRadioAudioDisabled() && - !( iGlobalOfflineQuery && iGlobalOfflineQuery->IsActive() ) ) - { - if ( ( ( iFMRadioVariationFlags & KFMRadioInternalAntennaSupported) || - iRadioEngine->IsHeadsetConnected() ) && !iAudioLost && !iRadioEngine->IsInCall() ) - { - TurnRadioOn(); - } - else if ( iAudioLost && - iRadioEngine->IsHeadsetConnected() ) - { - TryToResumeAudioL(); - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleAudioResourceNotAvailableL -// Handles the cases when the radio is interrupted due to: -// 1. Call setup/in progress -// 2. Higher priority audio -// --------------------------------------------------------------------------- - -void CFMRadioAppUi::HandleAudioResourceNotAvailableL( TInt FDEBUGVAR(aError) ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleAudioResourceNotAvailableL() error code: %d"), - aError ) ); - - SetStartupWizardRunning( EFalse ); - iAudioResourceAvailable = EFalse; - - if ( iCurrentRadioState != EFMRadioStateOffForPhoneCall && - iCurrentRadioState != EFMRadioStateOffBeforePhoneCall ) - { - iCurrentRadioState = EFMRadioStateOff; - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleHeadsetDisconnectedCallback -// Take actions when the headset is disconnected. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleHeadsetDisconnectedCallback() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleHeadsetDisconnectedCallback" ) ) ); - - if ( iFMRadioVariationFlags & KFMRadioInternalAntennaSupported ) - { - SetAudioOutput( CRadioEngine::EFMRadioOutputIHF ); - } - else - { - // radio is already turned off, and if it was tuning it was canceled - iCurrentRadioState = EFMRadioStateOff; - TRAP_IGNORE( ShowConnectHeadsetDialogL() ); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleHeadsetReconnectedCallback -// Take actions when the headset is reconnected. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleHeadsetReconnectedCallback() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleHeadsetReconnectedCallback()") ) ); - if ( iConnectHeadsetQuery ) - { - delete iConnectHeadsetQuery; - iConnectHeadsetQuery = NULL; - } - - //compare bitmask to see if feature supported - if ( !(iFMRadioVariationFlags & KFMRadioInternalAntennaSupported) && - iCurrentRadioState != EFMRadioStateOffForPhoneCall && - iCurrentRadioState != EFMRadioStateOffBeforePhoneCall ) - { - if ( !iRadioEngine->IsRadioOn() && !iRadioEngine->IsInCall() ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleHeadsetReconnectedCallback() - Turn radio on") ) ); - TurnRadioOn(); - } - // active offline query controls radio on/off - else if ( iAudioLost ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleHeadsetReconnectedCallback() - Try to resume") ) ); - TRAP_IGNORE( TryToResumeAudioL() ); - } - else if ( ( iGlobalOfflineQuery && !iGlobalOfflineQuery->IsActive() ) || - !iGlobalOfflineQuery ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleHeadsetReconnectedCallback() - Offline query") ) ); - iRadioEngine->InitializeRadio(); - } - HandleVolumeChangedCallback(); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleManualTuneFailedCallback -// Processes "manual tune failed" callback -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleManualTuneFailedCallback() - { - HandleStopSeekCallback(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleVolumeUpdateFailedCallback -// Processes "volume update failed" callback -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleVolumeUpdateFailedCallback() - { - HandleVolumeChangedCallback(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleMuteCallback -// Processes "radio volume muted" callback -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleSetMuteStateCallback() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleSetMuteStateCallback()")) ); - HandleVolumeChangedCallback(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleStopSeekCallback -// Processes "seek operation completed" callback -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleStopSeekCallback() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleStopSeekCallback() state %d "), iCurrentRadioState) ); - - if ( iCurrentRadioState == EFMRadioStateBusyManualTune || - iCurrentRadioState == EFMRadioStateBusySeek || - iCurrentRadioState == EFMRadioStateBusyScanLocalStations ) - { - iCurrentRadioState = EFMRadioStateOn; // Update state - } - - const TUid activeViewTuid = ActiveView(); - - if ( activeViewTuid == KFMRadioMainViewId ) - { - TRAP_IGNORE( iMainView->StopSeekL() ) - } - else if ( activeViewTuid == KFMRadioChannelListViewId ) - { - TRAP_IGNORE( iChannelListView->StopSeekL() ) - } - else if ( activeViewTuid == KFMRadioScanLocalStationsViewId ) - { - TRAP_IGNORE( iScanLocalStationsView->StopSeekL() ) - } - else - { - // nop - } - FTRACE( FPrint( _L("end CFMRadioAppUi::HandleStopSeekCallback") ) ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleAudioOutputSetCallback -// Processes "set audio output completed" callback -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleAudioOutputSetCallback() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleAudioOutputSetCallback()")) ); - if ( iRadioEngine->GetAudioOutput() == CRadioEngine::EFMRadioOutputIHF ) - { - iActiveVolumePopupControl = iIhfVolumePopupControl; - } - else - { - iActiveVolumePopupControl = iHeadsetVolumePopupControl; - } - // restore volume for current output - TInt volumeLevel = iRadioEngine->GetVolume(); - iRadioEngine->SetVolume( volumeLevel ); - - if ( iCurrentRadioState != EFMRadioStateBusyScanLocalStations ) - { - iRadioEngine->SetMuteOn( EFalse ); - } - - TUid view = ActiveView(); - - if ( view == KFMRadioScanLocalStationsViewId ) - { - iScanLocalStationsView->UpdateToolbar(); - } - else if ( view == KFMRadioChannelListViewId ) - { - iChannelListView->UpdateToolbar(); - } - else if ( view == KFMRadioMainViewId ) - { - CAknView* mainView = View( KFMRadioMainViewId ); - if ( mainView ) - { - // force update for toolbar extension view - mainView->Toolbar()->ToolbarExtension()->SetShown( EFalse ); - } - } - else - { - // NOP - } - - // So the views can dynamically change the option menu - StopDisplayingMenuBar(); // force update for menu bar - // Force UI update - HandleVolumeChangedCallback(); - } - -// -------------------------------------------------------------------------------- -// CFMRadioAppUi::HandleWsEventL -// -------------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleWsEventL( const TWsEvent& aEvent, CCoeControl* aDestination ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleWsEventL - event %d "), aEvent.Type() ) ); - switch ( aEvent.Type() ) - { - case KAknUidValueEndKeyCloseEvent: - { - if ( IsForeground() ) - { - const TUid KPhoneAppUid = {0x100058B3}; // hardcoded value for phone app uid - TApaTaskList taskList( iEikonEnv->WsSession() ); - TApaTask phoneTask = taskList.FindApp( KPhoneAppUid ); - - if ( phoneTask.Exists() ) - { - // Bring phone to foreground - phoneTask.BringToForeground(); - } - else - { - // Phone app should always be there, but this is a backup - // plan, just set radio to background - TApaTask task( iEikonEnv->WsSession() ); - task.SetWgId( iEikonEnv->RootWin().Identifier() ); - task.SendToBackground(); - } - } - break; - } - case EEventFocusLost: - { - // being sent to background, cancel any seek expect local stations scan - if ( iCurrentRadioState == EFMRadioStateBusySeek ) - { - iRadioEngine->CancelScan(); - HandleStopSeekCallback(); - } - CAknViewAppUi::HandleWsEventL( aEvent, aDestination ); - break; - } - case EEventFocusGained: - // override default behavior of unfading the ui - // can be taken out when auto resume is implemented - CAknViewAppUi::HandleWsEventL(aEvent, aDestination); - if (iMainView) - { - iMainView->UpdateDisplayForFocusGained(); - } - if (iChannelListView) - { - iChannelListView->UpdateDisplayForFocusGained(); - } - if (iScanLocalStationsView) - { - iScanLocalStationsView->UpdateDisplayForFocusGained(); - } - break; - default: - CAknViewAppUi::HandleWsEventL(aEvent, aDestination); - break; - } - } - -// ---------------------------------------------------------------------------------------------------- -// CFMRadioAppUi::FMRadioSvkChangeVolumeL -// Handles the change in the Volume that is needed as per the Side Volume Key -// events. -// ---------------------------------------------------------------------------------------------------- -// -void CFMRadioAppUi::FMRadioSvkChangeVolumeL( TInt aVolumeChange ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::FMRadioSvkRemoveVolumeL() aVolumeChange : %d"), aVolumeChange ) ); - - TBool headsetConnected = iRadioEngine->IsHeadsetConnected(); - - if ( iCurrentRadioState != EFMRadioStateBusyScanLocalStations && IsStartupWizardHandled() && - headsetConnected ) - { - if ( aVolumeChange > 0 ) // up direction - { - UpdateVolume( EDirectionUp ); - } - else // down direction - { - UpdateVolume( EDirectionDown ); - } - } - } - -// ---------------------------------------------------------------------------------------------------- -// CFMRadioAppUi::FMRadioSvkRemoveVolumeL -// Handles the remove Volume option that is needed depending on the duration of the -// Side Volume Key press -// ---------------------------------------------------------------------------------------------------- -// -void CFMRadioAppUi::FMRadioSvkRemoveVolumeL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::FMRadioSvkRemoveVolumeL( )") ) ); - } - -// ---------------------------------------------------------------------------------------------------- -// CFMRadioAppUi::FMRadioHeadsetEvent -// Handles the Headset button pressed -// ---------------------------------------------------------------------------------------------------- - -void CFMRadioAppUi::FMRadioHeadsetEvent( TAccessoryEvent aEvent ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::FMRadioHeadsetEvent event: %d "), aEvent ) ); - switch ( aEvent ) - { - case EForward: - { - if ( ActiveView() == KFMRadioScanLocalStationsViewId && - iCurrentRadioState != EFMRadioStateBusyScanLocalStations ) - { - // change channels in scan local stations view - TRAP_IGNORE( iScanLocalStationsView->HandleScanListRemConEventL( aEvent ) ) - } - else - { - TRAP_IGNORE( HandleCommandL( EFMRadioCmdNextChannel ) ) - } - break; - } - case ERewind: - { - if ( ActiveView() == KFMRadioScanLocalStationsViewId && - iCurrentRadioState != EFMRadioStateBusyScanLocalStations ) - { - TRAP_IGNORE( iScanLocalStationsView->HandleScanListRemConEventL( aEvent ) ) - } - else - { - TRAP_IGNORE( HandleCommandL( EFMRadioCmdPrevChannel ) ) - } - break; - } - case EStop: - { - if ( iCurrentRadioState != EFMRadioStateBusyScanLocalStations && IsStartupWizardHandled() ) - { - iRadioEngine->SetMuteOn( ETrue ); - } - break; - } - case EPausePlay: - { - if ( iCurrentRadioState != EFMRadioStateBusyScanLocalStations && IsStartupWizardHandled() ) - { - HandleMuteCommand(); - } - break; - } - default: - break; - } - } - -// ---------------------------------------------------------------------------------------------------- -// CFMRadioAppUi::HandleResourceChangeL -// ---------------------------------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleResourceChangeL( TInt aType ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleResourceChangeL type: %d "), aType ) ); - CAknViewAppUi::HandleResourceChangeL( aType ); - - if ( aType == KEikDynamicLayoutVariantSwitch ) - { - UpdateLandscapeInformation(); - iLayoutChangeObserver->LayoutChangedL( aType ); - } - else if ( aType == KAknsMessageSkinChange ) - { - iLayoutChangeObserver->LayoutChangedL( aType ); - } - } - -// ---------------------------------------------------------------------------------------------------- -// Handles MCoeControl events -// ---------------------------------------------------------------------------------------------------- -void CFMRadioAppUi::HandleControlEventL( CCoeControl* aControl, TCoeEvent aEventType ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleControlEventL - aEventID = %d"), aEventType) ); - if ( (aEventType == EEventStateChanged) && - ( aControl == iActiveVolumePopupControl ) ) - { - TInt volumeControlLevel = iActiveVolumePopupControl->Value(); - - if ( iRadioEngine->IsMuteOn() && volumeControlLevel == 1 ) - { - // Volume has been muted and volume is changed from - // popup. Restore volume to the previous level. - volumeControlLevel = iRadioEngine->GetVolume(); - volumeControlLevel++; - if ( volumeControlLevel > KFMRadioMaxVolumeLevel ) - { - volumeControlLevel = KFMRadioMaxVolumeLevel; - } - iActiveVolumePopupControl->SetValue( volumeControlLevel ); - } - - // Set mute - if ( volumeControlLevel == KFMRadioMinVolumeLevel ) - { - // Mute status could change from toolbar, svk or pointer event - if ( !iRadioEngine->IsMuteOn() ) - { - iRadioEngine->SetMuteOn( ETrue ); - } - } - else - { - iRadioEngine->SetMuteOn( EFalse ); - } - - // Make sure volume level is in range - if ( volumeControlLevel < KFMRadioMinVolumeLevel ) - { - volumeControlLevel = KFMRadioMinVolumeLevel; - } - else if ( volumeControlLevel > KFMRadioMaxVolumeLevel ) - { - volumeControlLevel = KFMRadioMaxVolumeLevel; - } - - // Set volume. If volume is muted we dont want to set it to iRadioEngine - if ( !iRadioEngine->IsMuteOn() ) - { - iRadioEngine->SetVolume( volumeControlLevel ); - } - } - } - -// ---------------------------------------------------------------------------------------------------- -// DialogTerminated -// ---------------------------------------------------------------------------------------------------- -void CFMRadioAppUi::DialogTerminated() - { - iInfoNoteOn = EFalse; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::UpdateLandscapeInformation -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::UpdateLandscapeInformation() - { - TSize screenSize; - - AknLayoutUtils::LayoutMetricsSize( AknLayoutUtils::EScreen, screenSize ); - - // Is it portrait or landscape, compare height and width, since we can't - // be sure if EGraphicsOrientationNormal is portrait or landscape - if ( screenSize.iHeight < screenSize.iWidth ) - { - iLandscape = ETrue; - } - else - { - iLandscape = EFalse; - } - } -// --------------------------------------------------------------------------- -// CFMRadioAppUi::UpdateChannelsL -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::UpdateChannelsL( TMoveoperations aOperation, - TInt aIndex, TInt aMovedToNewIndex ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::UpdateChannelsL(%d, %d, %d)"), aOperation, aIndex, aMovedToNewIndex ) ); - - // Move channel operation moves channel from aIndex to aMovedToNewIndex value - if ( EMoveChannels == aOperation ) - { - CFMRadioPreset* channelInfo = iChannels[ aIndex ]; - iChannels.Remove( aIndex ); - CleanupStack::PushL( channelInfo ); - iChannels.InsertL( channelInfo, aMovedToNewIndex ); - CleanupStack::Pop( channelInfo); - } - // Delete channel deletes channel from list - else if ( EDeleteChannel == aOperation ) - { - const CFMRadioPreset* channelinfo = iChannels[ aIndex ]; - iChannels.Remove( aIndex ); - delete channelinfo; - - for ( TInt index = 0; index < iChannels.Count(); index++ ) - { - iRadioEngine->SetPresetNameFrequencyL( - index, - iChannels[ index ]->PresetName(), - iChannels[ index ]->PresetFrequency() ); - - iRadioEngine->SaveUrlToPresetL( index, iChannels[ index ]->PresetUrl() ); - } - iRadioEngine->DeletePresetL( iChannels.Count() ); - } - - // Store all channels to repository - else if ( EStoreAllToRepository == aOperation ) - { - for ( TInt index = 0; index < iChannels.Count(); index++ ) - { - iRadioEngine->SetPresetNameFrequencyL( - index, - iChannels[ index ]->PresetName(), - iChannels[ index ]->PresetFrequency() ); - - iRadioEngine->SaveUrlToPresetL( index, iChannels[ index ]->PresetUrl() ); - } - } - - // Store specified index to repository and same index - else if ( EStoreIndexToRepository == aOperation ) - { - iRadioEngine->SetPresetNameFrequencyL( - aIndex, - iChannels[ aIndex ]->PresetName(), - iChannels[ aIndex ]->PresetFrequency() ); - - iRadioEngine->SaveUrlToPresetL( aIndex, iChannels[ aIndex ]->PresetUrl() ); - } - else if ( ERemoveAllFromRepository == aOperation ) - { - iRadioEngine->DeletePresetL( -1 ); // reset all presets - iChannels.ResetAndDestroy(); - } - - iRadioEngine->PubSubL().PublishPresetCountL( iChannels.Count() ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::AddChannelToListL -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::AddChannelToListL( const TDesC& aChannelName, TInt aChannelFreq ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::AddChannelToListL(%S, %d)"), &aChannelName, aChannelFreq ) ); - CFMRadioPreset* preset = CFMRadioPreset::NewL(); - CleanupStack::PushL( preset ); - preset->SetPresetNameL( aChannelName ); - preset->SetPresetFrequency( aChannelFreq ); - iChannels.AppendL( preset ); - CleanupStack::Pop( preset ); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::IsLandscapeOrientation -// --------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::IsLandscapeOrientation() const - { - return iLandscape; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ChooseLayoutResource -// --------------------------------------------------------------------------- -// -TInt CFMRadioAppUi::ChooseLayoutResource( TInt aNormalPortraitRes, - TInt aMirroredPortraitRes, TInt aNormalLandscapeRes, - TInt aMirroredLandscapeRes ) const - { - TInt resId = 0; - - if ( IsLandscapeOrientation() ) - { - if ( AknLayoutUtils::LayoutMirrored() ) - { - resId = aMirroredLandscapeRes; - } - else - { - resId = aNormalLandscapeRes; - } - } - else - { - if ( AknLayoutUtils::LayoutMirrored() ) - { - resId = aMirroredPortraitRes; - } - else - { - resId = aNormalPortraitRes; - } - } - return resId; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::IsLayoutMirrored -// --------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::IsLayoutMirrored() const - { - return AknLayoutUtils::LayoutMirrored(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleFlightModeEnabledCallbackL -// Displays continue offline query. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleFlightModeEnabledCallbackL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleFlightModeEnabledCallbackL" ) ) ); - - // If off-line profile is activated when no other app - // (that would disable auto resume) is playing (or has played) - // audio, a global confirmation query is displayed. - if ( iAudioResourceAvailable ) - { - iRadioEngine->RadioOff(); - - if ( !iGlobalOfflineQuery ) - { - iGlobalOfflineQuery = CFMRadioGlobalConfirmationQuery::NewL( this ); - } - - HBufC* text = StringLoader::LoadLC( R_QTN_FMRADIO_QUERY_OFFLINE_USE, iCoeEnv ); - - iOfflineQueryDialogActivated = ETrue; - iGlobalOfflineQuery->ShowQueryL( *text, R_AVKON_SOFTKEYS_YES_NO, R_QGN_NOTE_QUERY_ANIM ); - - CleanupStack::PopAndDestroy( text ); - } - - // Do the next when offline query wasn't already on the screen. - // That could happen when user changes profiles without - // answering to the query. - else if (!iGlobalOfflineQuery || !iGlobalOfflineQuery->IsActive()) - { - iOfflineProfileActivatedWhenRadioAudioDisabled = ETrue; - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleFlightModeDisabledCallback -// Close query dialog. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleFlightModeDisabledCallback() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleFlightModeDisabledCallback" ) ) ); - iOfflineProfileActivatedWhenRadioAudioDisabled = EFalse; - - // Close continue offline query - if ( iLocalContinueOfflineQuery && iLocalContinueOfflineQuery->IsVisible() ) - { - TRAP_IGNORE( iLocalContinueOfflineQuery->DismissQueryL() ); - } - // Close activate offline query - if ( iLocalActivateOfflineQuery && iLocalActivateOfflineQuery->IsVisible() ) - { - TRAP_IGNORE( iLocalActivateOfflineQuery->DismissQueryL() ); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::StaticStartupForegroundCallback -// takes care of some delayed initialisation -// --------------------------------------------------------------------------- -// -TInt CFMRadioAppUi::StaticStartupForegroundCallback( TAny* aSelfPtr ) - { - CFMRadioAppUi* self = reinterpret_cast( aSelfPtr ); - if ( self ) - { - delete self->iStartupForegroundCallback; - self->iStartupForegroundCallback = NULL; - - TRAPD( err, self->HandleStartupForegroundEventL() ) - if ( err ) - { - // Shutdown the application - CEikonEnv* eikonEnv = CEikonEnv::Static(); - TApaTask task( eikonEnv->WsSession() ); - task.SetWgId( eikonEnv->RootWin().Identifier() ); - task.EndTask(); - } - } - - return KErrNone; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleStartupForegroundEventL -// Note that leaving from this fuction will cause exit of -// FM Radio (on purpose)! -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleStartupForegroundEventL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleStartupForegroundEventL" ) ) ); - HandleOfflineModeAtStartUpL(); - TFMRadioRegionSetting region = HandleRegionsAtStartUpL(); - iRadioEngine->SetRegionIdL( region ); - HandlePendingViewActivationL(); - iRadioEngine->RequestTunerControl(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleOfflineModeAtStartUpL -// Handles offline mode at startup. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleOfflineModeAtStartUpL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleOfflineModeAtStartUpL" ) ) ); - if ( iRadioEngine->IsOfflineProfileL() ) - { - iOfflineQueryDialogActivated = ETrue; - - if ( AknLayoutUtils::PenEnabled() ) - { - // We must hide toolbar, otherwise query dialog softkeys doesn't work - ShowToolbar( EFalse ); - } - - iLocalActivateOfflineQuery = CAknQueryDialog::NewL(); - TInt result = iLocalActivateOfflineQuery->ExecuteLD( R_FMRADIO_ACTIVATE_IN_OFFLINE_QUERY ); - iLocalActivateOfflineQuery = NULL; - - iOfflineQueryDialogActivated = EFalse; - - if ( result ) - { - if ( AknLayoutUtils::PenEnabled() ) - { - ShowToolbar( ETrue ); - } - } - else - { - Exit(); - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ShowToolbar -// Sets toolbar visibility. This function is used to hide toolbar component -// while query dialog is shown. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::ShowToolbar( TBool aVisible ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::ShowToolbar(%d)"), aVisible ) ); - if ( iLayoutChangeObserver == iMainView ) - { - iMainView->ShowToolbar( aVisible ); - } - else if ( iLayoutChangeObserver == iScanLocalStationsView ) - { - iScanLocalStationsView->ShowToolbar( aVisible ); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::IsOfflineProfileActivatedWhenRadioAudioDisabled -// --------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::IsOfflineProfileActivatedWhenRadioAudioDisabled() const - { - return iOfflineProfileActivatedWhenRadioAudioDisabled; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleFMTransmitterOnCallback -// Displays note about transmitter being activated and -// fade the UI. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleFMTransmitterOnCallbackL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleFMTransmitterOnCallbackL()") ) ); - iCurrentRadioState = EFMRadioStateOff; - - CAknGlobalNote* fmTransmitterGlobalNote = CAknGlobalNote::NewLC(); - - if ( IsStartupWizardHandled() ) - { - // Wizard is allready handled so this callback is not coming - // in startup phase - HBufC* closeAppText = StringLoader::LoadLC( R_QTN_FMRADIO_NOTE_FMTX_CLOSE_APPLICATION, iCoeEnv ); - fmTransmitterGlobalNote->ShowNoteL( EAknGlobalInformationNote, *closeAppText ); - CleanupStack::PopAndDestroy( closeAppText ); - } - else - { - HBufC* unableToStartText = StringLoader::LoadLC( R_QTN_FMRADIO_NOTE_FMTX_UNABLE_TO_START, iCoeEnv ); - fmTransmitterGlobalNote->ShowNoteL( EAknGlobalInformationNote, *unableToStartText ); - CleanupStack::PopAndDestroy( unableToStartText ); - } - CleanupStack::PopAndDestroy( fmTransmitterGlobalNote ); - // check if we have any dialogs open and close them manually - if ( IsDisplayingDialog() ) - { - TKeyEvent key; - key.iRepeats = 0; - key.iCode = EKeyEscape; - key.iModifiers = 0; - - iCoeEnv->SimulateKeyEventL( key, EEventKey ); - // in case there is still dialog on the screen - if ( IsDisplayingDialog() ) - { - iCoeEnv->SimulateKeyEventL( key, EEventKey ); - } - } - // Shutdown the application - TApaTask task( iCoeEnv->WsSession() ); - task.SetWgId( iCoeEnv->RootWin().Identifier() ); - task.EndTask(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleFreqRangeChangedCallback -// Frequency range changed. -// Current handling is to exit the application since -// the UI specification doesn't specify how this should -// be handled. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleFreqRangeChangedCallback() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleFreqRangeChangedCallback()") ) ); - iCurrentRadioState = EFMRadioStateOff; - Exit(); - } -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleMuteCommand -// Handles mute keypress from main view -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleMuteCommand() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleMuteCommand" ) ) ); - if ( iRadioEngine->IsMuteOn() ) - { - iRadioEngine->SetMuteOn( EFalse ); - } - else - { - iRadioEngine->SetMuteOn( ETrue ); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleRegionsAtStartUpL -// get region automatically from network or manually by user choice if network -// is not available -// --------------------------------------------------------------------------- -// -TFMRadioRegionSetting CFMRadioAppUi::HandleRegionsAtStartUpL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleRegionsAtStartUpL()")) ); - TFMRadioRegionSetting region = iRadioEngine->GetRegionL(); - - if ( region == EFMRadioRegionNone ) - { - ShowToolbar( EFalse ); - TInt index = 0; - - CDesCArraySeg* regionList = new( ELeave ) CDesCArraySeg( KDefaultRegionArrayGranularity ); - CleanupStack::PushL( regionList ); - - iRadioEngine->FillListWithRegionDataL( *regionList ); - - CAknListQueryDialog* dlg = new ( ELeave ) CAknListQueryDialog( &index ); - - dlg->PrepareLC( R_FMRADIO_SELECT_REGION_QUERY ); - CTextListBoxModel* model = - static_cast( dlg->ListControl() )->listbox()->Model(); - model->SetItemTextArray( regionList ); - model->SetOwnershipType( ELbmDoesNotOwnItemArray ); // Array won't be deleted here - - TInt ret = dlg->RunLD(); - CleanupStack::PopAndDestroy( regionList ); - - if ( ret != EAknSoftkeyExit ) - { - // We should have a proper region selected by user - region = iRadioEngine->RegionIdAtIndex( index ); - } - - if ( region == EFMRadioRegionNone ) - { - Exit();// This will eventually exit FMRadio. - } - else - { - HBufC* bandSetText = StringLoader::LoadLC( R_QTN_FMRADIO_CONF_FREQ_BAND_SET_MANUAL, iCoeEnv ); - CAknInformationNote* note = new( ELeave ) CAknInformationNote( ETrue ); - note->ExecuteLD( *bandSetText ); - CleanupStack::PopAndDestroy( bandSetText ); - if ( AknLayoutUtils::PenEnabled() ) - { - ShowToolbar( ETrue ); - } - } - } - else - { - // Region is known - if ( region != iRadioEngine->RegionId() ) - { - TInt previousRegion = iRadioEngine->RegionId(); - - if ( previousRegion != EFMRadioRegionNone ) - { - // Show note only if the region has changed from a concrete - // one to another concrete one. EFMRadioRegionNone is not - // a concrete one (first startup case) -- don't show note. - iRegionChanged = ETrue; - HBufC* bandSetText = StringLoader::LoadLC( R_QTN_FMRADIO_CONF_FREQ_BAND_SET_AUTOM, iCoeEnv ); - CAknInformationNote* note = new ( ELeave ) CAknInformationNote( ETrue ); - note->ExecuteLD( *bandSetText ); - CleanupStack::PopAndDestroy( bandSetText ); - } - } - } - return region; - } - -// --------------------------------------------------------------------------- -// From class MFMRadioGlobalConfirmationQueryObserver. Callback function -// that is called when global confirmation query is dismissed. -// CFMRadioAppUi::GlobalConfirmationQueryDismissedL -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::GlobalConfirmationQueryDismissedL(TInt aSoftKey) - { - FTRACE( FPrint( _L("CFMRadioAppUi::GlobalConfirmationQueryDismissedL()")) ); - iOfflineQueryDialogActivated = EFalse; - - if ( aSoftKey == EAknSoftkeyYes ) - { - iOfflineProfileActivatedWhenRadioAudioDisabled = EFalse; - iRadioEngine->RadioOn(); - HandlePendingViewActivationL(); - } - else - { - // Shutdown the application - TApaTask task( iCoeEnv->WsSession() ); - task.SetWgId( iCoeEnv->RootWin().Identifier() ); - task.EndTask(); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::NumberOfChannelsStored -// return number of channels saved to the presets -// --------------------------------------------------------------------------- -// -TInt CFMRadioAppUi::NumberOfChannelsStored() const - { - FTRACE( FPrint( _L("CFMRadioAppUi::NumberOfChannelsStored()")) ); - return iChannels.Count(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleStartupWizard -// Determine if "Scan all channels" in scan local stations view should be started. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleStartupWizardL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleStartupWizardL()")) ); - if ( !IsStartupWizardHandled() || iRegionChanged ) - { - // Call to iRadioEngine->UpdatedStartupCount() - // increases startup count by one and returns amount of app startups. - TInt startupCount = iRadioEngine->UpdatedStartupCount(); - if ( startupCount <= KMaxStartupTimesToAskSaveWizard && - NumberOfChannelsStored() == 0 ) - { - SetStartupWizardRunning( ETrue ); - ActivateLocalViewL( iScanLocalStationsView->Id() ); - } - else if ( iRegionChanged ) //force rescan - { - iRegionChanged = EFalse; - UpdateChannelsL( ERemoveAllFromRepository, 0, 0 ); - SetStartupWizardRunning( ETrue ); - ActivateLocalViewL( iScanLocalStationsView->Id() ); - } - else // check IAD update here - { - HandleIADUpdateCheckL(); - } - } - } - -// -------------------------------------------------------------------------- -// CFMRadioAppUi::IsStartupWizardRunning -// Return startup scanning wizard status. -// --------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::IsStartupWizardRunning() const - { - return iStartupWizardRunning; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::SetStartupWizardRunning -// Set startup scanning wizard status. -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::SetStartupWizardRunning( const TBool aRunningState ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::SetStartupWizardRunning() - state = %d"), aRunningState) ); - iStartupWizardRunning = aRunningState; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::StartLocalStationsSeekL -// Start local stations scan -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::StartLocalStationsSeekL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::StartLocalStationsSeekL()")) ); - iCurrentRadioState = EFMRadioStateBusyScanLocalStations; - iRadioEngine->ScanUp(); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::TryToResumeAudioL -// Show Audio Preempted query -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::TryToResumeAudioL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::TryToResumeAudioL" ) ) ); - TFMRadioRegionSetting region = iRadioEngine->GetRegionL(); - if ( iAudioLost && - IsForeground() && - !iOfflineQueryDialogActivated && - region != EFMRadioRegionNone ) - { - iAudioLost = EFalse; - TurnRadioOn(); - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ShowConnectHeadsetDialogL -// Show connect headset query with only exit softkey -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::ShowConnectHeadsetDialogL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::ShowConnectHeadsetDialogL" ) ) ); - if ( !iConnectHeadsetQuery && !iConnectHeadsetGlobalNote ) - { - HBufC* noteTxt = StringLoader::LoadLC( R_QTN_FMRADIO_ERROR_CON_HEADSET, iCoeEnv ); - - // if radio is in background, show also global note - if ( !IsForeground() ) - { - iConnectHeadsetGlobalNote = CAknGlobalNote::NewL(); - iConnectHeadsetGlobalNote->ShowNoteL( EAknGlobalInformationNote, *noteTxt ); - delete iConnectHeadsetGlobalNote; - iConnectHeadsetGlobalNote = NULL; - } - - iConnectHeadsetQuery = CAknQueryDialog::NewL( CAknQueryDialog::EErrorTone ); - TInt ret = iConnectHeadsetQuery->ExecuteLD( R_FMRADIO_CONNECT_HEADSET_NOTE, *noteTxt ); - - CleanupStack::PopAndDestroy( noteTxt ); - FTRACE( FPrint( _L("CFMRadioAppUi::ShowConnectHeadsetDialogL() return value from dialog: %d"), ret ) ); - if ( iConnectHeadsetQuery ) - { - iConnectHeadsetQuery = NULL; - if ( ret == EAknSoftkeyExit || ret == EAknSoftkeyOk ) - { - TApaTask task( iCoeEnv->WsSession() ); - task.SetWgId( iCoeEnv->RootWin().Identifier() ); - task.EndTask(); - } - else - { - HandlePendingViewActivationL(); - } - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ShowVolumePopupL -// Show currently active volume popup -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::ShowVolumePopupL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::ShowVolumePopupL" ) ) ); - if ( !iRadioEngine->IsInCall() ) - { - if ( iActiveVolumePopupControl ) - { - if ( IsForeground() || ( IsActiveIdleEnabled() && IsIdleAppForeground() ) ) - { - iActiveVolumePopupControl->ShowVolumePopupL(); - } - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::GetCurrentHelpContext -// get help context based on currently active view -// --------------------------------------------------------------------------- -// -CArrayFix* CFMRadioAppUi::GetCurrentHelpContextL() const - { - FTRACE( FPrint( _L("CFMRadioAppUi::GetCurrentHelpContextL" ) ) ); -#if defined __SERIES60_HELP || defined FF_S60_HELPS_IN_USE - // currently main container and manual tuning container are derived from CBase - // so lets create help array manually for them - CArrayFixFlat* helpArray = new( ELeave ) - CArrayFixFlat( 1 ); - CleanupStack::PushL( helpArray ); - helpArray->AppendL( TCoeHelpContext( TUid::Uid( KUidFMRadioApplication ), KFMRADIO_HLP_MAIN ) ); - CleanupStack::Pop( helpArray ); - return helpArray; -#else - return AppHelpContextL(); -#endif -} - -// --------------------------------------------------------------------------- -// CFMRadioChannelListView::GetChannelsArrayL -// Get channels array list from radio engine -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::GetChannelsArrayL() - { - FTRACE( FPrint( _L("CFMRadioChannelListView::GetChannelsArrayL Start") ) ); - - // Note: KMaxNumberOfChannelListItems can be setted to any supported max value - for ( TInt index = 0; index < KMaxNumberOfChannelListItems; index++ ) - { - TBuf chName; - TInt chFrequency; - - iRadioEngine->GetPresetNameAndFrequencyL( index, - chName, - chFrequency ); - - if ( chFrequency != KErrNotFound ) - { - FTRACE( FPrint( _L("CFMRadioChannelListView::ChannelInUse inside if") ) ); - CFMRadioPreset* preset = CFMRadioPreset::NewL(); - CleanupStack::PushL( preset ); - preset->SetPresetNameL( chName ); - preset->SetPresetFrequency( chFrequency ); - - RBuf url; - url.CleanupClosePushL(); - url.CreateL( KFMRadioWebLinkMaxLength ); - TInt err = iRadioEngine->PresetUrlL( index, url ); - if ( !err ) - { - preset->SetPresetUrlL( url ); - } - - iChannels.AppendL( preset ); - CleanupStack::PopAndDestroy( &url ); - CleanupStack::Pop( preset ); - } - } - } - -// --------------------------------------------------------------------------- -// From class CEikAppUi. -// Handles window server messages. -// --------------------------------------------------------------------------- -// -MCoeMessageObserver::TMessageResponse CFMRadioAppUi::HandleMessageL( - TUint32 aClientHandleOfTargetWindowGroup, TUid aMessageUid, - const TDesC8& aMessageParameters ) - { - FTRACE(FPrint(_L(" *** S60 FMRadio-- CFMRadioAppUi::HandleMessageL" ))); - - TMessageResponse resp = CAknViewAppUi::HandleMessageL( - aClientHandleOfTargetWindowGroup, aMessageUid, aMessageParameters ); - - if ( resp == EMessageNotHandled && aMessageUid == TUid::Uid( KUidFMRadioApplication ) ) - { - ProcessCommandTailL( aMessageParameters ); - resp = EMessageHandled; - } - - return resp; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ProcessCommandParametersL -// Processes the shell commands -// --------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::ProcessCommandParametersL( TApaCommand aCommand, - TFileName& aDocumentName, - const TDesC8& aTail ) - { - FTRACE(FPrint(_L("CFMRadioAppUi::ProcessCommandParametersL(%d, %S)" ), aCommand, &aTail )); - SecondaryConstructL(); - - TBool ret = CAknViewAppUi::ProcessCommandParametersL( aCommand, aDocumentName, aTail ); - ProcessCommandTailL( aTail ); - - return ret; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::ProcessCommandParametersL -// Processes the command tail in any situation -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::ProcessCommandTailL( const TDesC8& aTail ) - { - TLex8 tailLex( aTail ); - if ( tailLex.Peek() != 0 ) - { - TPtrC8 command = tailLex.NextToken(); - if ( command == KFMRadioCommandFrequency ) - { - // tune to frequency - TLex8 frequencyLex( tailLex.NextToken() ); - TInt32 frequency = 0; - TInt min = 0; - TInt max = 0; - iRadioEngine->GetFrequencyBandRange( min, max ); - TInt ret = frequencyLex.BoundedVal( frequency, max ); - if ( ret == KErrNone && frequency >= min ) - { - iRadioEngine->CancelScan(); - TuneL( frequency ); - } - } - else if ( command == KFMRadioCommandStationIndex ) - { - // tune to station index - TLex8 indexLex( tailLex.NextToken() ); - TInt32 index = 0; - TInt ret = indexLex.BoundedVal( index, iChannels.Count() - 1 ); - if ( ret == KErrNone && index >= 0 ) - { - iRadioEngine->CancelScan(); - PlayChannel( index ); - } - } - else if( command == KFMRadioCommandActivateView ) - { - TLex8 viewIdLex( tailLex.NextToken() ); - TInt viewId = 0; - TInt ret = viewIdLex.Val( viewId ); - if ( ret == KErrNone ) - { - TUid uid = TUid::Uid( viewId ); - CAknView* view = View( uid ); - // Currently this API supports only activating main view or channel list view - if ( view && ( uid == KFMRadioMainViewId || uid == KFMRadioChannelListViewId ) ) - { - if ( iStartUp ) - { - SetDefaultViewL( *view ); - } - else - { - TFMRadioRegionSetting region = iRadioEngine->GetRegionL(); - - if ( iOfflineQueryDialogActivated || - iConnectHeadsetQuery || - region == EFMRadioRegionNone ) - { - iPendingViewId = view->Id(); - } - else - { - iChannelListView->CancelMoveL(); - ActivateLocalViewL( view->Id() ); - } - TApaTask task( iCoeEnv->WsSession() ); - task.SetWgId( iCoeEnv->RootWin().Identifier() ); - task.BringToForeground(); - } - } - } - } - else - { - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::Channels -// Returns channels array -// --------------------------------------------------------------------------- -// -RPointerArray& CFMRadioAppUi::Channels() - { - return iChannels; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::HandleIADUpdateCheckL -// Initialize software update check using IAD api -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::HandleIADUpdateCheckL() - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleIADUpdateCheckL") ) ); - if ( FeatureManager::FeatureSupported( KFeatureIdIAUpdate ) ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::HandleIADUpdateCheckL - KFeatureIdIAUpdate supported") ) ); - TRAPD( err, iUpdate = CIAUpdate::NewL( *this ) ) - if ( err && err != KErrNotSupported ) - { - User::Leave( err ); - } - if ( !err ) - { - iParameters = CIAUpdateParameters::NewL(); - // Use SIS package UID - iParameters->SetUid( TUid::Uid( KUidFMRadioApplication ) ); - iUpdate->CheckUpdates( *iParameters ); - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::CheckUpdatesComplete -// from base class MIAUpdateObserver -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::CheckUpdatesComplete( TInt aErrorCode, TInt aAvailableUpdates ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::CheckUpdatesComplete(%d, %d)"), aErrorCode, aAvailableUpdates ) ); - if ( aErrorCode == KErrNone ) - { - if ( aAvailableUpdates > 0 ) - { - // There were some updates available. Let's ask if the user wants to update them. - iUpdate->UpdateQuery(); - } - else - { - // No updates available. CIAUpdate object could be deleted already now, since we are not - // going to call anything else from the API. This will also close down the IAUpdate server. - delete iUpdate; - iUpdate = NULL; - delete iParameters; - iParameters = NULL; - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::UpdateComplete -// from base class MIAUpdateObserver -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::UpdateComplete( TInt FDEBUGVAR( aErrorCode ), CIAUpdateResult* aResultDetails ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::UpdateComplete(%d)"), aErrorCode ) ); - // The update process that the user started from IAUpdate UI is now completed. - // If the client application itself was updated in the update process, this callback - // is never called, since the client is not running anymore. - - delete aResultDetails; // Ownership was transferred, so this must be deleted by the client - - // We do not need the client-server session anymore, let's delete the object to close the session - delete iUpdate; - iUpdate = NULL; - delete iParameters; - iParameters = NULL; - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::UpdateQueryComplete -// from base class MIAUpdateObserver -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::UpdateQueryComplete( TInt aErrorCode, TBool aUpdateNow ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::UpdateQueryComplete(%d, %d)"), aErrorCode, aUpdateNow ) ); - if ( aErrorCode == KErrNone ) - { - if ( aUpdateNow ) - { - // User choosed to update now, so let's launch the IAUpdate UI. - iUpdate->ShowUpdates( *iParameters ); - } - else - { - // The answer was 'Later'. CIAUpdate object could be deleted already now, since we are not - // going to call anything else from the API. This will also close down the IAUpdate server. - delete iUpdate; - iUpdate = NULL; - delete iParameters; - iParameters = NULL; - } - } - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::AutoTuneInMainView -// Set autotune true, if scan is interrupted -// --------------------------------------------------------------------------- -// -void CFMRadioAppUi::AutoTuneInMainView ( TBool /*aTune*/ ) - { - FTRACE( FPrint( _L("CFMRadioAppUi::AutoTuneInMainView()"))); - } - -// --------------------------------------------------------------------------- -// CFMRadioAppUi::IsStartupWizardHandled -// --------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::IsStartupWizardHandled() const - { - return iStartupWizardHandled; - } - -// ----------------------------------------------------------------------------- -// Check if Active Idle app is on foreground -// ----------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::IsIdleAppForeground() - { - FTRACE( FPrint( _L( "CFMRadioAppUi::IsIdleAppForeground" ) ) ); - TBool isIdleActive( EFalse ); - // Gets the window group id of the app in foreground - RWsSession& wsSession = iCoeEnv->Static()->WsSession(); - TInt windowGroupId = wsSession.GetFocusWindowGroup(); - if ( windowGroupId >= 0 ) - { - TRAP_IGNORE( - { - CApaWindowGroupName* wgName = CApaWindowGroupName::NewL( - wsSession, windowGroupId ); - - isIdleActive = ( wgName->AppUid() == KFMRadioUidIdleApp ); - delete wgName; - } ); - } - return isIdleActive; - } - -// ----------------------------------------------------------------------------- -// Check if Active Idle is enabled -// ----------------------------------------------------------------------------- -// -TBool CFMRadioAppUi::IsActiveIdleEnabled() - { - FTRACE( FPrint( _L( "CFMRadioAppUi::IsActiveIdleEnabled" ) ) ); - TBool res( EFalse ); - -#ifdef __ACTIVE_IDLE - if (! FeatureManager::FeatureSupported( KFeatureIdActiveIdle ) ) - return EFalse; -#endif - if ( !iSettingsRepository ) - { - TRAP_IGNORE( - { - iSettingsRepository = CRepository::NewL( - KCRUidPersonalizationSettings ); - } ); - } - - if ( iSettingsRepository ) - { - TInt value( 0 ); - TInt err( iSettingsRepository->Get( KSettingsActiveIdleState, value ) ); - if ( !err && value ) - { - res = ETrue; - } - } - return res; - } - -// --------------------------------------------------------- -// CFMRadioAppUi::MatchingChannel -// Return the index of the first channel that matches the -// frequency specified. -// --------------------------------------------------------- -// -TInt CFMRadioAppUi::MatchingChannelL( TInt aFrequency ) - { - TInt channelIndex = KErrNotFound; - TInt numberOfChannels = iChannels.Count(); - - for ( TInt i = 0; i < numberOfChannels; i++ ) - { - TInt presetFrequency = iChannels[ i ]->PresetFrequency(); - - if ( aFrequency == presetFrequency ) - { - channelIndex = i; - break; - } - } - FTRACE(FPrint(_L("CFMRadioAppUi::MatchingChannel i[%d] aFrequency[%d]"), channelIndex, aFrequency)); - return channelIndex; - } - -// --------------------------------------------------------- -// CFMRadioAppUi::HandlePendingViewActivationL -// Activates the view that is pending -// --------------------------------------------------------- -// -void CFMRadioAppUi::HandlePendingViewActivationL() - { - if ( iPendingViewId != TUid::Null() ) - { - ActivateLocalViewL( iPendingViewId ); - iPendingViewId == TUid::Null(); - } - } - -// --------------------------------------------------------- -// CFMRadioAppUi::ActiveVolumePopup -// --------------------------------------------------------- -// -CAknVolumePopup* CFMRadioAppUi::ActiveVolumePopup() const - { - return iActiveVolumePopupControl; - } - -// --------------------------------------------------------- -// CFMRadioAppUi::RadioState -// --------------------------------------------------------- -// -CFMRadioAppUi::TRadioState CFMRadioAppUi::RadioState() const - { - return iCurrentRadioState; - } - -// End of File