1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  FM Radio App UI implementation

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 

    20 #include <featmgr.h>

    21 #if defined  __SERIES60_HELP || defined FF_S60_HELPS_IN_USE

    22 #include <hlplch.h>

    23 #include "radio.hlp.hrh"

    24 #endif

    25 #include <akntoolbar.h>

    26 #include <StringLoader.h>

    27 #include <eikmenup.h>

    28 #include <avkon.hrh>

    29 #include <aknlistquerydialog.h> 

    30 #include <AknQueryDialog.h>

    31 #include <AknGlobalNote.h>

    32 #include <fmradio.rsg>

    33 #include <fmradiocommandlineparams.h>

    34 #include <alf/alfenv.h>

    35 #include <AknVolumePopup.h>

    36 #include <fmradiointernalpskeys.h>

    37 #include <fmradiouids.h> 

    38 #include <iaupdate.h>

    39 #include <iaupdateparameters.h>

    40 #include <iaupdateresult.h>

    41 #include <e32property.h>

    42 #include <apgwgnam.h>

    43 #include <centralrepository.h>

    44 #include <settingsinternalcrkeys.h>

    45 #include <activeidle2domainpskeys.h>

    46 #include <akntoolbarextension.h>

    47 

    48 #include "fmradiobacksteppingservicewrapper.h"

    49 #include "fmradiodocument.h"

    50 #include "fmradioengine.h"

    51 #include "fmradiovariant.hrh"

    52 #include "fmradiomainview.h"

    53 #include "fmradiochannellistview.h"

    54 #include "fmradiocontroleventobserverimpl.h"

    55 #include "fmradioscanlocalstationsview.h"

    56 #include "fmradio.hrh"

    57 #include "fmradioengine.hrh"

    58 #include "fmradioappui.h"

    59 #include "fmradiordsreceiver.h"

    60 #include "fmradioapp.h"

    61 #include "fmradiopubsub.h"

    62 #include "debug.h"

    63 

    64 // Application Uid for Active Idle app

    65 #ifdef __ACTIVE_IDLE

    66 const TUid KFMRadioUidIdleApp = { 0x101FD64C };

    67 #else

    68 const TUid KFMRadioUidIdleApp = KPSUidActiveIdle2; // use this one instead because the "aisystemuids.hrh" is not export

    69 #endif

    70 // CONSTANTS 

    71 

    72 // ---------------------------------------------------------------------------------

    73 // CFMInformationNote::CFMInformationNote

    74 // ---------------------------------------------------------------------------------

    75 CFMInformationNote::CFMInformationNote( MInformationNoteInterface& aObserver ) :

    76     CAknInformationNote ( EFalse ),

    77     iDialogObserver( aObserver )

    78     {

    79     

    80     }

    81 // ---------------------------------------------------------------------------------

    82 // CFMInformationNote::~CFMInformationNote

    83 // ---------------------------------------------------------------------------------

    84 //

    85 CFMInformationNote::~CFMInformationNote()

    86     {

    87     iDialogObserver.DialogTerminated();

    88     }

    89 // ================= MEMBER FUNCTIONS =======================

    90 

    91 // ---------------------------------------------------------------------------------

    92 // C++ default constructor can NOT contain any code, that

    93 // might leave.

    94 // ---------------------------------------------------------------------------------

    95 //

    96 CFMRadioAppUi::CFMRadioAppUi() :

    97     iStartUp( ETrue ),

    98     iStartupWizardHandled( EFalse ),

    99     iStartupWizardRunning( EFalse ),

   100     iTuneFromWizardActivated( EFalse ),

   101     iInfoNoteOn( EFalse ),

   102     iPendingViewId( KNullUid ),

   103     iRegionChanged( EFalse )

   104     {

   105     }

   106 

   107 // ---------------------------------------------------------------------------------

   108 // CFMRadioAppUi::ConstructL

   109 // 2nd phase constructor. Instanciates all member objects

   110 // ---------------------------------------------------------------------------------

   111 //

   112 void CFMRadioAppUi::ConstructL()

   113     {

   114     FTRACE( FPrint( _L("CFMRadioAppUi::ConstructL()") ) );

   115     

   116     BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

   117     

   118     FeatureManager::InitializeLibL();

   119     iFeatureManagerInitialized = ETrue;

   120 

   121     // initialise local variation key with all features disabled.

   122     iFMRadioVariationFlags = 0;

   123     iAudioResourceAvailable = ETrue;

   124     iAlreadyClean = EFalse;

   125 

   126     iRadioEngine = CRadioEngine::NewL( *this ); // Construct a radio engine object

   127     

   128     // Fill channels array from engine

   129     GetChannelsArrayL();

   130     

   131     if ( iRadioEngine->IsInCall() ) 

   132         {

   133         iCurrentRadioState = EFMRadioStateOffForPhoneCall;

   134         }

   135     

   136     iBsWrapper = CFMRadioBackSteppingServiceWrapper::NewL( TUid::Uid( KUidFMRadioApplication ) );

   137     AddViewActivationObserverL( iBsWrapper );    

   138 

   139     iMainView = CFMRadioMainView::NewL( iRadioEngine, *iAlfEnv, *this  );

   140     AddViewL( iMainView );      // transfer ownership to CAknViewAppUi

   141     iChannelListView = CFMRadioChannelListView::NewL( iRadioEngine, *this );

   142     AddViewL( iChannelListView );     // transfer ownership to CAknViewAppUi

   143     iScanLocalStationsView = CFMRadioScanLocalStationsView::NewL( *iRadioEngine, *this );

   144     AddViewL( iScanLocalStationsView ); // transfer ownership to CAknViewAppUi

   145     }

   146 

   147 // ---------------------------------------------------------------------------

   148 // CFMRadioAppUi::SecondaryConstructL()

   149 // All leaving function calls are made here, so that nothing is left on the stack if the ConstructL leaves

   150 // The reason for this behaviour is that the UI framework doesn't handle leaves from the AppUi correctly.

   151 // ---------------------------------------------------------------------------

   152 //

   153 void CFMRadioAppUi::SecondaryConstructL()

   154     {

   155     FTRACE( FPrint( _L("CFMRadioAppUi::SecondaryConstructL()") ) );

   156     

   157     iLayoutChangeObserver = iMainView;

   158 

   159     iRadioEngine->PubSubL().PublishPresetCountL( iChannels.Count() );

   160     

   161     // Create vertical volume popup for speaker and headset

   162     iIhfVolumePopupControl = CAknVolumePopup::NewL( NULL, ETrue );

   163     iIhfVolumePopupControl->SetRange( KFMRadioMinVolumeLevel, KFMRadioMaxVolumeLevel );

   164     iIhfVolumePopupControl->SetStepSize( KFMRadioVolumeStepSize );

   165     // Set observer for control events

   166     iIhfVolumePopupControl->SetObserver( this );

   167     

   168     iHeadsetVolumePopupControl = CAknVolumePopup::NewL( NULL, ETrue );

   169     iHeadsetVolumePopupControl->SetRange( KFMRadioMinVolumeLevel, KFMRadioMaxVolumeLevel );

   170     iHeadsetVolumePopupControl->SetStepSize( KFMRadioVolumeStepSize );

   171     iHeadsetVolumePopupControl->SetObserver( this );

   172     

   173     iActiveVolumePopupControl = iHeadsetVolumePopupControl; //initialize it to Headset

   174 

   175     // Create and set our observer for control events.

   176     iControlEventObserver = CFMRadioControlEventObserverImpl::NewL( *this );

   177     iRadioEngine->PubSubL().SetControlEventObserver( iControlEventObserver );

   178 

   179     // For monitoring side volume key events

   180     iSvkEvents = CFMRadioSvkEvents::NewL(*this);

   181 

   182     iRadioEngine->PubSubL().PublishApplicationRunningStateL( EFMRadioPSApplicationRunning );

   183 

   184     UpdateLandscapeInformation();	

   185 

   186     // Create alfred environment

   187     iAlfEnv = CAlfEnv::NewL();

   188 

   189     // Create alfred display

   190     TRect rect;

   191     AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, rect);	

   192     if( !IsLandscapeOrientation() )

   193         {

   194         TRect toolBarRect = iMainView->Toolbar()->Rect();

   195         rect.SetHeight( rect.Height() - toolBarRect.Height() );	

   196         }

   197     iAlfEnv->NewDisplayL( rect, CAlfEnv::ENewDisplayAsCoeControl );

   198     }

   199 

   200 // ---------------------------------------------------------------------------

   201 // CFMRadioAppUi::HandleTunerReadyCallback

   202 // Tuner is initialized and ready.

   203 // ---------------------------------------------------------------------------

   204 //

   205 void CFMRadioAppUi::HandleTunerReadyCallback()

   206     {

   207     iRadioEngine->InitializeRadio();

   208     }

   209 

   210 // ---------------------------------------------------------------------------

   211 // CFMRadioAppUi::~CFMRadioAppUi

   212 // Destructor

   213 // Frees reserved resources

   214 // ---------------------------------------------------------------------------

   215 //

   216 CFMRadioAppUi::~CFMRadioAppUi()

   217     {

   218     if ( iRadioEngine )

   219         {

   220         TRAP_IGNORE(

   221             iRadioEngine->PubSubL().PublishApplicationRunningStateL( EFMRadioPSApplicationClosing ) )

   222         }

   223 

   224     FTRACE( FPrint( _L("CFMRadioAppUi::~CFMRadioAppUi()") ) );

   225     if ( iAlreadyClean == EFalse )

   226         {

   227         Cleanup();

   228         }

   229 

   230     if ( iFeatureManagerInitialized )

   231         {

   232         FeatureManager::UnInitializeLib();

   233         }

   234     }

   235 

   236 // ---------------------------------------------------------------------------

   237 // CFMRadioAppUi::Cleanup()

   238 // Perform object cleanup. This would normally be performed in the destructor,

   239 // but since it can also be called from SecondaryConstructL it was moved into

   240 // a seperate function.

   241 // ---------------------------------------------------------------------------

   242 //

   243 void CFMRadioAppUi::Cleanup()

   244     {

   245     FTRACE( FPrint( _L("CFMRadioAppUi::Cleanup()") ) );

   246 

   247     delete iIhfVolumePopupControl;

   248     iIhfVolumePopupControl = NULL;

   249     delete iHeadsetVolumePopupControl;

   250     iHeadsetVolumePopupControl = NULL;

   251 

   252     if (iRadioEngine)

   253         {

   254         delete iRadioEngine;

   255         iRadioEngine = NULL;

   256         }

   257     if (iSvkEvents)

   258         {

   259         delete iSvkEvents;

   260         }

   261     if (iGlobalOfflineQuery)

   262         {

   263         delete iGlobalOfflineQuery;

   264         }

   265     if (iLocalActivateOfflineQuery)

   266         {

   267         delete iLocalActivateOfflineQuery;

   268         }

   269     if (iLocalContinueOfflineQuery)

   270         {

   271         delete iLocalContinueOfflineQuery;

   272         }

   273     delete iControlEventObserver;

   274     delete iAlfEnv;

   275     

   276     iAlreadyClean = ETrue;

   277     

   278     if ( iConnectHeadsetGlobalNote )

   279         {

   280         delete iConnectHeadsetGlobalNote;

   281         iConnectHeadsetGlobalNote = NULL;

   282         }

   283     if ( iConnectHeadsetQuery )

   284         {

   285         delete iConnectHeadsetQuery;

   286         iConnectHeadsetQuery = NULL;

   287         }

   288 

   289      iChannels.ResetAndDestroy();

   290      iChannels.Close();

   291         

   292     if ( iUpdate )

   293         {

   294         delete iUpdate;

   295         iUpdate = NULL;

   296         }

   297     if ( iParameters )

   298         {

   299         delete iParameters;

   300         iParameters = NULL;

   301         }

   302     if ( iSettingsRepository )

   303         {

   304         delete iSettingsRepository;

   305         iSettingsRepository = NULL;

   306         }

   307     if ( iBsWrapper )

   308         {

   309         RemoveViewActivationObserver( iBsWrapper );

   310         }

   311     delete iBsWrapper;

   312     iBsWrapper = NULL;

   313     

   314     delete iStartupForegroundCallback;

   315     iStartupForegroundCallback = NULL;

   316     }

   317 

   318 // ---------------------------------------------------------------------------

   319 // CFMRadioAppUi::HandleCommandL

   320 // Interprets view's menu-,softkey and other commands and acts

   321 // accordingly by calling the appropriate command handler

   322 // function for further action.

   323 // ---------------------------------------------------------------------------

   324 //

   325 void CFMRadioAppUi::HandleCommandL( TInt aCommand )

   326     {

   327     FTRACE( FPrint( _L("CFMRadioAppUi::HandleCommandL state=%d command=%d "), iCurrentRadioState, aCommand) );

   328     if ( iCurrentRadioState == EFMRadioStateOn )

   329         {

   330         switch ( aCommand )

   331             {

   332             case EFMRadioCmdChannelList:

   333                 ActivateLocalViewL( iChannelListView->Id() );

   334                 break;

   335             case EFMRadioCmdSeekUp:

   336                 ScanUpL();

   337                 break;

   338             case EFMRadioCmdSeekDown:

   339                 ScanDownL();

   340                 break;

   341             case EFMRadioCmdSaveChannel:

   342                 SaveChannelToLastIntoListL();

   343                 break;

   344             case EFMRadioCmdScanLocalStations:

   345                 ActivateLocalViewL( iScanLocalStationsView->Id() );

   346                 break;

   347             case EFMRadioCmdScanLocalStationsScan:

   348                 // continue scanning

   349                 StartLocalStationsSeekL();

   350                 break;

   351             case EFMRadioCmdListenCh:

   352                 if ( iChannels.Count() > 0 )

   353                     {

   354                     PlayChannel( iChannelListView->CurrentlySelectedChannel() );

   355                     }

   356                 break;

   357             case EFMRadioCmdRename:

   358                 RenameCurrentChannelL();

   359                 break;

   360             case EFMRadioCmdActivateIhf:

   361                 SetAudioOutput( CRadioEngine::EFMRadioOutputIHF );

   362                 break;

   363             case EFMRadioCmdDeactivateIhf:

   364                 SetAudioOutput( CRadioEngine::EFMRadioOutputHeadset );

   365                 break;

   366             case EFMRadioCmdEnableRdsAfSearch:

   367                 iRadioEngine->SetRdsAfSearchEnable( ETrue );

   368                 break;

   369             case EFMRadioCmdDisableRdsAfSearch:

   370                 iRadioEngine->SetRdsAfSearchEnable( EFalse );

   371                 break;

   372             case EFMRadioCmdUpdateVolume:

   373                 UpdateVolume( EDirectionNone );

   374                 break;

   375             case EFMRadioCmdNextChannel:

   376                 {

   377                 TInt channelCount = iChannels.Count();

   378                 if ( channelCount >= 1 )

   379                     {

   380                     iMainView->SetStationChangeType( EFMRadioStationChangeNext );

   381                     PlayChannel( iChannelListView->NextChannel() );

   382                     }

   383                 else

   384                     {

   385                     if ( AknLayoutUtils::PenEnabled() )

   386                         {

   387                         DisplayInformationNoteL( R_QTN_FMRADIO_USE_LONG_TAP );

   388                         }

   389                     }

   390                 break;

   391                 }

   392             case EFMRadioCmdPrevChannel:

   393                 {

   394                 TInt channelCount = iChannels.Count();

   395                 if ( channelCount >= 1 )

   396                     {

   397                     iMainView->SetStationChangeType( EFMRadioStationChangePrevious );

   398                     PlayChannel( iChannelListView->PreviousChannel() );

   399                     }

   400                 else

   401                     {

   402                     if ( AknLayoutUtils::PenEnabled() )

   403                         {

   404                         DisplayInformationNoteL( R_QTN_FMRADIO_USE_LONG_TAP );

   405                         }

   406                     }

   407                 break;

   408             	}

   409             case EFMRadioCmdMuteOn:

   410             	iRadioEngine->SetMuteOn( ETrue );

   411             	break;

   412             case EFMRadioCmdMuteOff:

   413             	iRadioEngine->SetMuteOn( EFalse );

   414             	break;

   415             case EFMRadioCmdMute:

   416             	HandleMuteCommand();

   417             	break;	

   418             case EAknCmdHelp:

   419             case EFMRadioCmdHelp:

   420                 {

   421 #if defined __SERIES60_HELP || defined FF_S60_HELPS_IN_USE

   422                 if ( ActiveView() == KFMRadioMainViewId )

   423                     {

   424                     HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), GetCurrentHelpContextL() );

   425                     }

   426                 else

   427                     {

   428                     CArrayFix<TCoeHelpContext>* buf = CCoeAppUi::AppHelpContextL();

   429                     HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), buf );

   430                     }

   431 #endif

   432                 }

   433                 break;

   434             default:

   435                 break;

   436             }

   437         }

   438     else if ( iCurrentRadioState == EFMRadioStateBusySeek ||

   439              iCurrentRadioState == EFMRadioStateBusyScanLocalStations )

   440         {

   441         switch ( aCommand )

   442             {

   443             case EFMRadioCmdStopTuning:

   444             case EAknSoftkeyCancel:

   445                 CancelSeek();

   446                 break;

   447             default:

   448                 break;

   449             }

   450         }

   451     switch ( aCommand )

   452         {

   453         case EFMRadioCmdScanLocalStationsViewActive:

   454             iLayoutChangeObserver = iScanLocalStationsView;

   455             break;

   456         case EFMRadioCmdChannelListViewActive:

   457             iLayoutChangeObserver = iChannelListView;

   458             break;

   459         case EFMRadioCmdMainViewActive:

   460             iLayoutChangeObserver = iMainView;

   461             break;

   462         case EAknSoftkeyExit:

   463         case EEikCmdExit:

   464         case EAknCmdExit:

   465             Exit();

   466             break;

   467         default:

   468             break;

   469         }

   470     }

   471 

   472 // ---------------------------------------------------------------------------

   473 // CFMRadioAppUi::ActiveView

   474 // ---------------------------------------------------------------------------

   475 //

   476 TUid CFMRadioAppUi::ActiveView() const

   477     {

   478     return iView ? iView->Id() : KNullUid;

   479     }

   480 

   481 // ---------------------------------------------------------------------------

   482 // CFMRadioAppUi::RadioEngine

   483 // ---------------------------------------------------------------------------

   484 //

   485 CRadioEngine* CFMRadioAppUi::RadioEngine()

   486     {

   487     return iRadioEngine;

   488     }

   489 

   490 // ---------------------------------------------------------------------------

   491 // CFMRadioAppUi::Document

   492 // ---------------------------------------------------------------------------

   493 //

   494 CFMRadioDocument* CFMRadioAppUi::Document() const

   495     {

   496     return static_cast<CFMRadioDocument*>( CEikAppUi::Document() );

   497     }

   498 

   499 // ---------------------------------------------------------------------------

   500 // CFMRadioAppUi::BackSteppingWrapper

   501 // ---------------------------------------------------------------------------

   502 //

   503 CFMRadioBackSteppingServiceWrapper& CFMRadioAppUi::BackSteppingWrapper() const

   504     {

   505     return *iBsWrapper;

   506     }

   507 

   508 // ---------------------------------------------------------------------------

   509 // CFMRadioAppUi::TurnRadioOn

   510 // Turn the fm radio hardware on

   511 // ---------------------------------------------------------------------------

   512 //

   513 void CFMRadioAppUi::TurnRadioOn()

   514     {

   515     FTRACE(FPrint(_L("CFMRadioAppUi::TurnRadioOn()")));

   516     if ( !iRadioEngine->IsRadioOn() )

   517         {

   518         // Force the mute state only if it wasn't already forced

   519         if ( iMuteStatusBeforeRadioInit == EFMUninitialized )

   520             {

   521             if ( iRadioEngine->IsMuteOn() )

   522                 {

   523                 FTRACE(FPrint(_L("CFMRadioAppUi::iMuteStatusBeforeRadioInit = ETrue;()")));

   524                 iMuteStatusBeforeRadioInit = EFMMuted;	

   525                 }

   526             else

   527                 {

   528                 FTRACE(FPrint(_L("CFMRadioAppUi::iMuteStatusBeforeRadioInit = EFalse;()")));

   529                 iMuteStatusBeforeRadioInit = EFMUnmuted;

   530                 }

   531             }

   532         iCurrentRadioState = EFMRadioStateBusyRadioOn;

   533         // use mute here so we have no audio until tune event

   534         iRadioEngine->SetMuteOn( ETrue );

   535         iRadioEngine->RadioOn();

   536         }

   537     }

   538 

   539 // ---------------------------------------------------------------------------

   540 // CFMRadioAppUi::PlayChannel

   541 // Tune the radio hardware to the frequency saved at the specified channel

   542 // ---------------------------------------------------------------------------

   543 //

   544 void CFMRadioAppUi::PlayChannel( TInt aIndex )

   545     {

   546     FTRACE( FPrint( _L("CFMRadioAppUi::PlayChannel(%d)"), aIndex ) );

   547     if ( aIndex >= KMinNumberOfChannelListItems &&

   548          aIndex < KMaxNumberOfChannelListItems )

   549         {

   550         // Activate the channel by index

   551         TRAP_IGNORE( iRadioEngine->TunePresetL( aIndex ) )

   552         iMainView->PrepareViewForChannelChange();

   553 

   554         // Update channel list

   555         iChannelListView->SetNowPlayingChannel( aIndex );

   556         iChannelListView->SetLastListenedChannel( aIndex );

   557         }

   558     }

   559 

   560 // ---------------------------------------------------------------------------

   561 // CFMRadioAppUi::EraseCurrentChannelL

   562 // Delete channel from the channel list

   563 // ---------------------------------------------------------------------------

   564 //

   565 TBool CFMRadioAppUi::EraseChannelL( TInt aIndex )

   566     {

   567     FTRACE( FPrint( _L("CFMRadioAppUi::EraseCurrentChannelL()") ) );

   568 

   569     TBool accepted = ConfirmChannelListDeleteL( aIndex );

   570     

   571     if ( accepted )

   572         {        

   573         UpdateChannelsL( EDeleteChannel, aIndex, 0 ); 

   574         UpdateChannelsL( EStoreAllToRepository, 0, 0 );

   575         }

   576     return accepted;

   577     }

   578 

   579 // ---------------------------------------------------------------------------

   580 // CFMRadioAppUi::RenameCurrentChannelL

   581 // Rename the currently selected channel

   582 // ---------------------------------------------------------------------------

   583 //

   584 void CFMRadioAppUi::RenameCurrentChannelL()

   585     {

   586     FTRACE( FPrint( _L("CFMRadioAppUi::RenameCurrentChannelL()") ) );

   587     

   588     TInt channelIndex = KErrNotFound;

   589     if ( ActiveView() == KFMRadioChannelListViewId )

   590         {

   591         channelIndex = iChannelListView->CurrentlySelectedChannel();

   592         }

   593     else

   594         {

   595         channelIndex = iRadioEngine->GetPresetIndex();

   596         }

   597     // Display the text query

   598     CRadioEngine::TStationName channelName = iChannels[ channelIndex ]->PresetName();

   599    

   600     CAknTextQueryDialog* dlg = new (ELeave) CAknTextQueryDialog( channelName, CAknQueryDialog::ENoTone );

   601     

   602     if ( dlg->ExecuteLD( R_FMRADIO_RENAME_QUERY ) )

   603         {

   604         FTRACE(FPrint(_L("CFMRadioAppUi::RenameCurrentChannelL()")));

   605         

   606         iChannels[channelIndex]->SetPresetNameL( channelName );

   607         

   608         iChannelListView->UpdateChannelListContentL( channelIndex,

   609                         iChannels[ channelIndex ]->PresetName(),

   610                         iChannels[ channelIndex ]->PresetFrequency() );

   611         

   612         UpdateChannelsL( EStoreIndexToRepository, channelIndex, 0 );

   613         

   614         iMainView->SetStationChangeType( EFMRadioStationChangeNone );

   615         // A channel can also be renamed from the main view

   616         iMainView->DisplayChannelL( channelIndex );

   617         // show default logo for a while

   618         // so that animation is stopped and it has the right channel name

   619         // after restart

   620         iMainView->ShowDefaultLogo();

   621         }

   622     }

   623 

   624 // ---------------------------------------------------------------------------

   625 // CFMRadioAppUi::SaveChannelToLastIntoListL

   626 // Display listbox menu to allow user to specify a channel

   627 // to save currently tuned frequency to.

   628 // ---------------------------------------------------------------------------

   629 //

   630 void CFMRadioAppUi::SaveChannelToLastIntoListL()

   631     {

   632     FTRACE( FPrint( _L("CFMRadioAppUi::SaveChannelToLastIntoListL()") ) );

   633     SaveChannelL( iChannels.Count() + 1 );

   634     }

   635 

   636 // ---------------------------------------------------------------------------

   637 // CFMRadioAppUi::SaveChannel

   638 // Save currently tuned frequency to the currently selected channel

   639 // ---------------------------------------------------------------------------

   640 //

   641 void CFMRadioAppUi::SaveChannelL( TInt aIndex )

   642     {

   643     FTRACE( FPrint( _L("CFMRadioAppUi::SaveChannelL(%d)"), aIndex ) );

   644 

   645     TBool continueWithSave = ETrue;

   646     // check if channel list is full

   647     if ( aIndex == KMaxNumberOfChannelListItems + 1 )

   648         {

   649         CAknQueryDialog* query = CAknQueryDialog::NewL();

   650         if ( query->ExecuteLD( R_FMRADIO_REPLACE_EXISTING_CHANNELS_QUERY ) )

   651             {

   652             UpdateChannelsL( ERemoveAllFromRepository, 0, 0  );

   653             }

   654         else

   655             {

   656             continueWithSave = EFalse;

   657             }

   658         }

   659 

   660     if ( continueWithSave )

   661         {

   662         CFMRadioRdsReceiverBase& receiver = iRadioEngine->RdsReceiver();

   663         CFMRadioRdsReceiverBase::TFMRadioProgrammeSeviceType type = 

   664                 receiver.ProgrammeServiceNameType();

   665         const TDesC& channelName = type == CFMRadioRdsReceiverBase::EFMRadioPSNameStatic ?

   666                 receiver.ProgrammeService() : KNullDesC;

   667         

   668         CFMRadioPreset* preset = CFMRadioPreset::NewL();

   669         CleanupStack::PushL( preset );

   670         preset->SetPresetNameL( channelName );

   671         preset->SetPresetFrequency( iRadioEngine->GetTunedFrequency() );

   672                 

   673         const TDesC& webUrl = receiver.RtPlusProgramUrl();

   674         if ( webUrl.Length() )

   675             {

   676             preset->SetPresetUrlL( webUrl );

   677             }        

   678         iChannels.AppendL( preset );

   679         CleanupStack::Pop( preset ); 

   680         

   681         UpdateChannelsL( EStoreAllToRepository, 0, 0 );

   682         

   683         iMainView->SetStationChangeType( EFMRadioStationChangeNone );

   684         PlayChannel( iChannels.Count() - 1 );

   685         }

   686     }

   687 

   688 // ---------------------------------------------------------------------------

   689 // CFMRadioAppUi::ConfirmChannelListDeleteL

   690 // Display confirmation dialog for channel deletion

   691 // ---------------------------------------------------------------------------

   692 //

   693 TBool CFMRadioAppUi::ConfirmChannelListDeleteL( TInt aIndex )

   694     {

   695     FTRACE( FPrint( _L("CFMRadioAppUi::ConfirmChannelListActionL( %d )"), aIndex ) );

   696     TInt accepted = EFalse; // Operation accepted or discarded

   697     TInt stringResourceId = 0; // Resource id of the prompt text

   698     TInt queryResourceId = R_FMRADIO_ERASE_CH_CONFIRMATION_QUERY;  // Resource id of the used query dialog

   699 

   700     RBuf channelData;

   701     channelData.CleanupClosePushL();

   702     

   703     if ( iChannels[ aIndex ]->PresetName().Length() )

   704         {

   705         stringResourceId = R_QTN_FMRADIO_QUERY_DELETE;

   706         channelData.CreateL( iChannels[ aIndex ]->PresetName() );

   707         }

   708     else

   709         {

   710         stringResourceId = R_QTN_FMRADIO_QUERY_DELETE_MHZ;

   711         TInt maxDecimalPlaces = iRadioEngine->DecimalCount();

   712         TInt channelfreq = iChannels[ aIndex ]->PresetFrequency();

   713         TReal realFrequency = static_cast<TReal>( channelfreq / static_cast<TReal>( KHzConversionFactor ));

   714         

   715         channelData.CreateL( KFrequencyMaxLength );

   716         

   717         TRealFormat format( KFrequencyMaxLength, maxDecimalPlaces );

   718         channelData.Num( realFrequency, format );

   719         AknTextUtils::LanguageSpecificNumberConversion( channelData );

   720         }

   721     // Excecute a confirmation query with string and query resource id

   722     HBufC* prompt = StringLoader::LoadLC( stringResourceId, channelData, iCoeEnv );

   723     CAknQueryDialog* queryDlg = CAknQueryDialog::NewL();

   724     accepted = queryDlg->ExecuteLD( queryResourceId, *prompt );

   725     CleanupStack::PopAndDestroy( prompt );

   726     CleanupStack::PopAndDestroy( &channelData );

   727     return accepted;

   728     }

   729 

   730 // ---------------------------------------------------------------------------

   731 // CFMRadioAppUi::ScanUpL

   732 // 

   733 // ---------------------------------------------------------------------------

   734 //

   735 void CFMRadioAppUi::ScanUpL()

   736     {

   737     FTRACE( FPrint( _L("CFMRadioAppUi::ScanUpL()") ) );

   738     // Frequency is always 0 when asking engine for automatical tuning. Frequency

   739     // parameter is then ignored by engine when automatical tuning (seek) is requested.

   740     iCurrentRadioState = EFMRadioStateBusySeek;

   741 

   742     if ( iMainView->IsForeground() )

   743         {

   744         iMainView->SetStationChangeType( EFMRadioStationChangeScanUp );

   745         iMainView->SeekL(); // Show seek wait note

   746         }

   747     iRadioEngine->ScanUp();

   748     }

   749 

   750 // ---------------------------------------------------------------------------

   751 // CFMRadioAppUi::ScanDownL

   752 // 

   753 // ---------------------------------------------------------------------------

   754 //

   755 void CFMRadioAppUi::ScanDownL()

   756     {

   757     FTRACE( FPrint( _L("CFMRadioAppUi::ScanDownL()") ) );

   758     // Frequency is always 0 when asking engine for automatical tuning. Frequency

   759     // parameter is then ignored by engine when automatical tuning (seek) is requested.

   760     iCurrentRadioState = EFMRadioStateBusySeek;

   761     

   762     if ( iMainView->IsForeground() )

   763         {

   764         iMainView->SetStationChangeType( EFMRadioStationChangeScanDown );

   765         iMainView->SeekL(); // Show seek wait note

   766         }

   767     iRadioEngine->ScanDown();

   768     }

   769 

   770 // ---------------------------------------------------------------------------

   771 // CFMRadioAppUi::TuneL

   772 // 

   773 // ---------------------------------------------------------------------------

   774 //

   775 void CFMRadioAppUi::TuneL( TInt aFrequency )

   776     {

   777     FTRACE( FPrint( _L("CFMRadioAppUi::TuneL(%d)"), aFrequency ) );

   778     // Frequency is always 0 when asking engine for automatical tuning. Frequency

   779     // parameter is then ignored by engine when automatical tuning (seek) is requested.

   780     iCurrentRadioState = EFMRadioStateBusySeek;

   781     if (iMainView->IsForeground())

   782         {

   783         iMainView->SeekL(); // Show seek wait note

   784         }

   785     iRadioEngine->Tune(aFrequency);

   786     }

   787 

   788 // ---------------------------------------------------------------------------

   789 // CFMRadioAppUi::UpdateVolume

   790 // Update the radio volume

   791 // ---------------------------------------------------------------------------

   792 //

   793 void CFMRadioAppUi::UpdateVolume( CFMRadioAppUi::TFMRadioDirections aDirection )

   794     {

   795     FTRACE( FPrint( _L("CFMRadioAppUi::UpdateVolume(%d)"), UpdateVolume ) );

   796 

   797     if ( !iRadioEngine->IsInCall() )

   798         {

   799         TInt volumeControlLevel = iRadioEngine->GetVolume();

   800 

   801         TInt newVol = 0;

   802         if ( aDirection == EDirectionDown )

   803             {

   804             TRAP_IGNORE( ShowVolumePopupL(); )

   805             newVol = volumeControlLevel - 1;

   806             

   807             if ( newVol > KFMRadioMinVolumeLevel )

   808                 {

   809                 iRadioEngine->SetVolume( newVol );

   810                 }

   811             else

   812                 {

   813                 iRadioEngine->SetMuteOn( ETrue );

   814                 iRadioEngine->SetVolume( newVol );

   815                 iActiveVolumePopupControl->SetValue( KFMRadioMinVolumeLevel );

   816                 }

   817             }

   818         else if ( aDirection == EDirectionUp )

   819             {

   820             TRAP_IGNORE( ShowVolumePopupL(); )

   821             if ( iRadioEngine->IsMuteOn() )

   822                 {

   823                 iRadioEngine->SetMuteOn( EFalse );

   824                 }

   825             newVol = volumeControlLevel + 1;

   826             

   827             if ( newVol <= KFMRadioMaxVolumeLevel )

   828                 {

   829                 iRadioEngine->SetVolume( newVol );

   830                 }

   831             else

   832                 {

   833                 iActiveVolumePopupControl->SetValue( KFMRadioMaxVolumeLevel );

   834                 }

   835             }

   836         else if ( aDirection == EDirectionNone )

   837             {

   838             //we just wish to update the UI's volume control

   839             HandleVolumeChangedCallback();

   840             }

   841         }

   842     }

   843 

   844 // ---------------------------------------------------------------------------

   845 // CFMRadioAppUi::SetAudioOutput

   846 // Set the audio output of the radio.

   847 // ---------------------------------------------------------------------------

   848 //

   849 void CFMRadioAppUi::SetAudioOutput(

   850     CRadioEngine::TFMRadioAudioOutput aAudioOutput )

   851     {

   852     iRadioEngine->SetAudioOutput( aAudioOutput );

   853     }

   854 

   855 // ---------------------------------------------------------------------------

   856 // CFMRadioAppUi::CancelSeek

   857 // Cancel outstanding seek request.

   858 // ---------------------------------------------------------------------------

   859 //

   860 void CFMRadioAppUi::CancelSeek()

   861     {

   862     FTRACE( FPrint( _L("CFMRadioAppUi::CancelSeek()") ) );

   863     if ( iCurrentRadioState == EFMRadioStateBusySeek )

   864         {

   865         iRadioEngine->CancelScan(); // Seek request to engine

   866         }

   867     HandleStopSeekCallback();

   868     }

   869 

   870 // ---------------------------------------------------------------------------

   871 // CFMRadioAppUi::DisplayErrorNoteL

   872 // Displays an error note with the text contained in the passed in reference

   873 // ---------------------------------------------------------------------------

   874 //

   875 void CFMRadioAppUi::DisplayErrorNoteL( TInt aErrorNote )

   876     {

   877     // Show headset missing note

   878     CAknErrorNote* errorNote = new ( ELeave ) CAknErrorNote( ETrue );

   879     HBufC* noteText = StringLoader::LoadLC( aErrorNote, iCoeEnv );

   880     errorNote->ExecuteLD( *noteText );

   881     CleanupStack::PopAndDestroy( noteText );

   882     }

   883 

   884 // ---------------------------------------------------------------------------

   885 // CFMRadioAppUi::DisplayInformationNoteL

   886 // Displays an information note

   887 // ---------------------------------------------------------------------------

   888 //

   889 void CFMRadioAppUi::DisplayInformationNoteL( TInt aInfoNote )

   890     {

   891     if ( !iInfoNoteOn && IsForeground() )

   892         {

   893         CFMInformationNote* infonote = new ( ELeave ) CFMInformationNote( *this );

   894         HBufC* noteText = StringLoader::LoadLC( aInfoNote, iCoeEnv );

   895         iInfoNoteOn = ETrue;

   896         infonote->ExecuteLD( *noteText );

   897         CleanupStack::PopAndDestroy( noteText );

   898         }

   899     }

   900 

   901 // ---------------------------------------------------------------------------

   902 // CFMRadioAppUi::ExitApplication

   903 // Shutdown the application.

   904 // ---------------------------------------------------------------------------

   905 //

   906 void CFMRadioAppUi::ExitApplication()

   907     {

   908     FTRACE( FPrint( _L("CFMRadioAppUi::ExitApplication() - Start") ) );

   909     //this method is called twice. First will trigger the RadioOff command

   910     if ( iCurrentRadioState == EFMRadioStateOff ||

   911          iCurrentRadioState == EFMRadioStateOffForPhoneCall ||

   912          iCurrentRadioState == EFMRadioStateOffBeforePhoneCall )

   913         {

   914         //once we receive a radio off complete event we finish shutting down.

   915         FTRACE( FPrint( _L("CFMRadioAppUi::ExitApplication() - calling exit") ) );

   916         Exit();

   917         }

   918     else

   919         {

   920         if ( iCurrentRadioState != EFMRadioStateExiting )

   921             {

   922             iCurrentRadioState = EFMRadioStateExiting;

   923             FTRACE( FPrint( _L("CFMRadioAppUi::ExitApplication() - turning off, and starting timer") ) );

   924             iRadioEngine->RadioOff(); // Shutdown radio

   925             }

   926         }

   927     }

   928 

   929 // ---------------------------------------------------------------------------

   930 // From class CCoeAppUi

   931 // CFMRadioAppUi::HandleForegroundEventL

   932 // Application has gone to foreground/background.

   933 // ---------------------------------------------------------------------------

   934 //

   935 void CFMRadioAppUi::HandleForegroundEventL( TBool aForeground )

   936     {

   937     FTRACE( FPrint( _L("CFMRadioAppUi::HandleForegroundEventL(%d)"), aForeground ) );

   938     CAknViewAppUi::HandleForegroundEventL( aForeground );

   939     

   940     if ( aForeground )

   941         {

   942         if ( iStartUp )

   943             {

   944             iStartUp = EFalse;

   945             // Rest of startup processing may show a waiting dialog. It cannot be 

   946             // done while processing a foreground event. So a call back is used.

   947             iStartupForegroundCallback = new( ELeave ) CAsyncCallBack( 

   948                 TCallBack( StaticStartupForegroundCallback, this ), CActive::EPriorityStandard );

   949             iStartupForegroundCallback->CallBack();

   950             }

   951         else

   952             {

   953             // Restores all resources that were released with a call to Release().

   954             // After this the Hitchcock user interface should be in the same state

   955             // in terms of resources as it was prior to the Release() call.

   956             iAlfEnv->RestoreL();

   957             

   958             // Check if offline profile is activated after/when playing e.g. music player.

   959             // In that case we didn't show the offline query as global, so we need

   960             // to show it now.

   961             if ( IsOfflineProfileActivatedWhenRadioAudioDisabled() )

   962                 {

   963                 // Do not re-show the offline query if user hasn't yet answered to it.

   964                 if ( !iShowingLocalOfflineContinueQuery )

   965                     {

   966                     iRadioEngine->RadioOff();

   967                     TInt res(0);

   968                     iShowingLocalOfflineContinueQuery = ETrue;

   969                                                                                     

   970                     iOfflineQueryDialogActivated = ETrue;

   971                     

   972                     if ( !iLocalContinueOfflineQuery )

   973                         {

   974                         iLocalContinueOfflineQuery = CAknQueryDialog::NewL();

   975                         }

   976                                         

   977                     res = iLocalContinueOfflineQuery->ExecuteLD( R_FMRADIO_CONTINUE_IN_OFFLINE_QUERY );

   978                     

   979                     iLocalContinueOfflineQuery = NULL;

   980                     iOfflineQueryDialogActivated = EFalse;

   981                     iShowingLocalOfflineContinueQuery = EFalse;

   982                                                             

   983                     if ( res )

   984                         {

   985                         iOfflineProfileActivatedWhenRadioAudioDisabled = EFalse;

   986                         iRadioEngine->RadioOn();

   987                         HandlePendingViewActivationL();

   988                         }

   989                     else

   990                         {

   991                         Exit();

   992                         }

   993                     }

   994                 }

   995             TryToResumeAudioL();

   996             }  

   997         }

   998     else 

   999         {

  1000         // Releases as many resources of the Hitchcock as possible. 

  1001         iAlfEnv->Release();

  1002         }

  1003     }

  1004 

  1005 // ---------------------------------------------------------------------------

  1006 // CFMRadioAppUi::HandleRadioEngineCallBack

  1007 // Notification from Radio Engine informing the UI when requests have

  1008 // completed or certain events have occured that needs to be handled.

  1009 // ---------------------------------------------------------------------------

  1010 //

  1011 void CFMRadioAppUi::HandleRadioEngineCallBack(

  1012     MRadioEngineStateChangeCallback::TFMRadioNotifyEvent aEventCode,

  1013     TInt aErrorCode )

  1014     {

  1015     FTRACE( FPrint( _L("CFMRadioAppUi::HandleRadioEngineCallBack - event %d error code: %d"), aEventCode, aErrorCode ) );

  1016     TInt err = KErrNone;

  1017     if ( aErrorCode == KErrNone )

  1018         {

  1019         switch ( aEventCode )

  1020             {

  1021             case EFMRadioEventTunerReady:

  1022                 HandleTunerReadyCallback();

  1023                 break;

  1024             case EFMRadioEventRadioOn:

  1025                 {

  1026                 iCurrentRadioState = EFMRadioStateOn;

  1027                 TRAPD( err, HandleStartupWizardL() );

  1028                 iStartupWizardHandled = ETrue;

  1029                 const TUid activeViewTuid = ActiveView();

  1030                 

  1031                 if ( activeViewTuid == KFMRadioChannelListViewId )

  1032                     {

  1033                     CAknToolbar* toolbar = iChannelListView->Toolbar();

  1034                     if ( toolbar )

  1035                         {

  1036                         iChannelListView->UpdateToolbar();

  1037                         toolbar->DrawDeferred();

  1038                         }

  1039                     }

  1040                 if( !IsStartupWizardRunning() || err != KErrNone )

  1041                     {

  1042                     //we use method because the behaviour we require is the same.

  1043                     if ( !iTuneFromWizardActivated && iMuteStatusBeforeRadioInit != EFMUninitialized )

  1044                         {

  1045                         TBool mute = EFalse; 

  1046                         if ( iMuteStatusBeforeRadioInit == EFMMuted )

  1047                             {

  1048                             mute = ETrue;

  1049                             }

  1050                         iRadioEngine->SetMuteOn( mute );

  1051                         iMuteStatusBeforeRadioInit = EFMUninitialized;

  1052                         }

  1053                     HandleStopSeekCallback(); 

  1054                     }

  1055                 }

  1056                 break;

  1057             case EFMRadioEventRadioOff:

  1058                 iCurrentRadioState = EFMRadioStateOff;

  1059                 

  1060                 if ( !iOfflineQueryDialogActivated )

  1061                     {

  1062                     ExitApplication();

  1063                     }

  1064                 

  1065                 break;

  1066             case EFMRadioEventFMRadioInitialized:

  1067                 TRAP( err, HandleInitializedCallbackL() );

  1068                 break;

  1069             case EFMRadioEventTune:

  1070                 if ( iTuneFromWizardActivated )

  1071                     {

  1072                     iTuneFromWizardActivated = EFalse;

  1073                     iRadioEngine->SetMuteOn( EFalse );

  1074                     iMuteStatusBeforeRadioInit = EFMUninitialized;

  1075                     }

  1076                 if ( IsStartupWizardHandled() )

  1077                     {

  1078                     HandleStopSeekCallback();

  1079                     }

  1080                 break;

  1081             case EFMRadioEventSetMuteState:

  1082                 HandleSetMuteStateCallback();

  1083                 break;

  1084             case EFMRadioEventVolumeUpdated:

  1085                 HandleVolumeChangedCallback();

  1086                 break;

  1087             case EFMRadioEventSetAudioOutput:

  1088                 HandleAudioOutputSetCallback();

  1089                 break;

  1090             case EFMRadioEventButtonPressed:

  1091                 iMainView->SetStationChangeType( EFMRadioStationChangeNext );

  1092                 PlayChannel( iChannelListView->NextChannel() );

  1093                 break;

  1094             case EFMRadioEventHeadsetDisconnected:

  1095                 HandleHeadsetDisconnectedCallback();

  1096                 break;

  1097             case EFMRadioEventHeadsetReconnected:

  1098                 HandleHeadsetReconnectedCallback();

  1099                 break;

  1100             case EFMRadioEventAudioResourceLost:

  1101             	iAudioLost = ETrue;

  1102                 TRAP( err, HandleAudioResourceNotAvailableL(aErrorCode) );

  1103                 break;

  1104             case EFMRadioEventAudioResourcePaused:

  1105                 TRAP( err, HandleAudioResourceNotAvailableL(aErrorCode) );

  1106                 break;                

  1107             case EFMRadioEventAudioResourceAvailable:

  1108                 TRAP( err, HandleAudioResourceAvailableL() );

  1109                 break;

  1110             case EFMRadioEventCallStarted:

  1111                 if ( iCurrentRadioState != EFMRadioStateOff && 

  1112                      iCurrentRadioState != EFMRadioStateOffBeforePhoneCall )

  1113                     {

  1114                     iCurrentRadioState = EFMRadioStateOffForPhoneCall;

  1115                     }

  1116                 else

  1117                     {

  1118                     iCurrentRadioState = EFMRadioStateOffBeforePhoneCall;

  1119                     }

  1120                 FadeViewsAndShowExit( ETrue );

  1121                 break;

  1122             case EFMRadioEventCallEnded:

  1123                 {

  1124                 if ( iAudioLost )

  1125                     {

  1126                     TRAP_IGNORE( TryToResumeAudioL() );

  1127                     iCurrentRadioState = EFMRadioStateOff;

  1128                     }

  1129                 else if ( iCurrentRadioState == EFMRadioStateOffForPhoneCall )

  1130                     {

  1131                     TurnRadioOn();

  1132                     }

  1133                 else

  1134                     {