FCL/sf/app/radio: comparison radioengine/engine/src/cradioengineimp.cpp

equal deleted inserted replaced

-:6bcf277166c1
+:451b2e1545b2
 #include <badesca.h>
 #include <tzlocalizer.h>
 // User includes
 #include "cradioenginelogger.h"
-#include "radiointernalpskeys.h"
 #include "radiointernalcrkeys.h"
 #include "cradioaudiorouter.h"
-#include "cradiopubsub.h"
 #include "cradioengineimp.h"
 #include "mradioengineobserver.h"
-#include "mradioscanobserver.h"
 #include "cradioregion.h"
 #include "cradiosettings.h"
 #include "mradioenginesettings.h"
 #include "mradiosettingssetter.h"
-#include "cradiorepositorymanager.h"
 #include "cradiordsreceiver.h"
 #include "cradiosystemeventcollector.h"
 #include "cradionetworkinfolistener.h"
 #include "radioengine.hrh"
+#include "cradioenginelogger.h"
-#include "../../group/buildflags.hrh"
-#ifdef __FEATURE_RDS_SIMULATOR
+// This has to be the last include.
-#   include "t_cradiordsreceiversimulator.h"
+#ifdef STUB_CONSTELLATION
-#endif
+#   include <RadioStubManager.h>
+#endif //STUB_CONSTELLATION
 // Constants
 /** The limit of volume steps that must not be divided */
 const TInt KRadioVolumeStepsDividinglimit = 20;
 CRadioEngineImp::CRadioEngineImp( CRadioAudioRouter* aAudioRouter )
 : CRadioEngine( aAudioRouter )
 , iAntennaAttached( ETrue )
 , iFreqEventReason( RadioEngine::ERadioFrequencyEventReasonUnknown )
 {
+LEVEL3( LOG_METHOD_AUTO );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 // to headset
 RadioEngine::TRadioAudioRoute route = iSystemEventCollector->IsHeadsetConnectedL() ?
 RadioEngine::ERadioHeadset : RadioEngine::ERadioSpeaker;
 User::LeaveIfError( iSettings->RadioSetter().SetAudioRoute( route ) );
-#ifdef __FEATURE_RDS_SIMULATOR
-iRdsReceiver = CRadioRdsReceiverSimulator::NewL( iSettings->EngineSettings() );
-#else
 iRdsReceiver = CRadioRdsReceiver::NewL( iSettings->EngineSettings() );
-#endif
 iNetworkInfoListener = CRadioNetworkInfoListener::NewL( iSettings->RadioSetter(), NULL );
 iRdsReceiver->AddObserverL( this );
 // Create timer that is used when polling for radio restart.
 //
 // ---------------------------------------------------------------------------
 //
 CRadioEngineImp::~CRadioEngineImp()
 {
-LOG( "CRadioEngineImp::~CRadioEngineImp -- Start" );
+LEVEL3( LOG_METHOD_AUTO );
 delete iNetworkInfoListener;
 PowerOff();
 {
 iSystemEventCollector->RemoveObserver( this );
 }
 delete iSystemEventCollector;
-delete iPubSub;
 if ( iSettings )
 {
 iSettings->RadioSetter().SetObserver( NULL );
 }
 delete iSettings;
-LOG( "CRadioEngineImp::~CRadioEngineImp -- End" );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::SetSystemEventCollector( CRadioSystemEventCollector* aCollector )
 {
+LEVEL3( LOG_METHOD_AUTO );
 iSystemEventCollector = aCollector;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::SetRadioSettings( CRadioSettings* aSettings )
 {
+LEVEL3( LOG_METHOD_AUTO );
 iSettings = aSettings;
 iSettings->RadioSetter().SetObserver( this );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-void CRadioEngineImp::SetRadioPubSub( CRadioPubSub* aPubSub )
-{
-iPubSub = aPubSub;
-}
-// ---------------------------------------------------------------------------
-//
-// ---------------------------------------------------------------------------
-//
 CRadioAudioRouter& CRadioEngineImp::AudioRouter() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 return *iAudioRouter;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 CRadioSystemEventCollector& CRadioEngineImp::SystemEventCollector() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 return *iSystemEventCollector;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 CRadioSettings& CRadioEngineImp::Settings() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 return *iSettings;
 }
 // ---------------------------------------------------------------------------
-//
-// ---------------------------------------------------------------------------
-//
-CRadioPubSub* CRadioEngineImp::PubSub() const
-{
-return iPubSub;
-}
-// ---------------------------------------------------------------------------
 // Determines radio region
 // ---------------------------------------------------------------------------
 //
 TRadioRegion CRadioEngineImp::DetermineRegion()
 {
+LEVEL3( LOG_METHOD_AUTO );
 TRadioRegion region = ERadioRegionNone;
 MRadioEngineSettings& engineSettings = iSettings->EngineSettings();
 if ( iSystemEventCollector->IsMobileNetworkCoverage() )
 {
 // ---------------------------------------------------------------------------
 // Initializes / reinitializes the radio. If this is not called
 // the radio is not functional
 // ---------------------------------------------------------------------------
 //
-void CRadioEngineImp::InitRadioL( TInt aRegionId, CRadioPubSub* aPubSub )
+void CRadioEngineImp::InitRadioL( TInt aRegionId )
 {
 LOG_METHOD_AUTO;
-LOG_FORMAT( "CRadioEngineImp::InitRadioL: Region: %d", aRegionId );
+LOG_FORMAT( "Region: %d", aRegionId );
 iRadioInitializationState = ERadioNotInitialized;
-iPubSub = aPubSub;
 iFreqEventReason = RadioEngine::ERadioFrequencyEventReasonUnknown;
 if ( iSettings->EngineSettings().RegionId() != aRegionId )
 {
 // Change only when necessary as it changes also the default tuned frequency
 //
 // ---------------------------------------------------------------------------
 //
 TBool CRadioEngineImp::RadioInitialized() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 return iRadioInitializationState == ERadioTunerControlGranted;
 }
 // ---------------------------------------------------------------------------
 // Sets the state for radio audio
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::EnableAudio( TBool aEnable, TBool aDelay )
 {
-LOG_FORMAT( "CRadioEngineImp::EnableAudio( %d )", aEnable );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aEnable %d ", aEnable );
 iRadioEnabled = aEnable;
 if ( aDelay )
 {
 SwitchPower( iRadioEnabled );
 }
 // Gets the state for radio audio.
 // ---------------------------------------------------------------------------
 //
 TBool CRadioEngineImp::RadioAudioEnabled() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 return iRadioEnabled;
 }
 // ---------------------------------------------------------------------------
 // Sets the state for audio overriding
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::SetAudioOverride( TBool aOverride )
 {
-LOG_FORMAT( "CRadioEngineImp::SetAudioOverride( %d )", aOverride );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aOverride %d ", aOverride ) );
 iOverrideAudioResources = aOverride;
 }
 // ---------------------------------------------------------------------------
 // Adds an observer for the radio state changes notifications.
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::AddObserverL( MRadioEngineObserver* aObserver )
 {
-LOG( "CRadioEngineImp::AddObserver" );
+LEVEL3( LOG_METHOD_AUTO );
 TInt index = iObservers.FindInAddressOrder( aObserver );
 if ( index == KErrNotFound )
 {
 iObservers.InsertInAddressOrderL( aObserver );
 }
 // Removes an observer from the list of obsevers
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::RemoveObserver( MRadioEngineObserver* aObserver )
 {
-LOG( "CRadioEngineImp::RemoveObserver" );
+LEVEL3( LOG_METHOD_AUTO );
 TInt index = iObservers.FindInAddressOrder( aObserver );
 if ( index >= 0 )
 {
 iObservers.Remove( index );
 //
 // ---------------------------------------------------------------------------
 //
 TFmRadioFrequencyRange CRadioEngineImp::TunerFrequencyRangeForRegionId( TInt aRegionId ) const
 {
+LEVEL3( LOG_METHOD_AUTO );
 TFmRadioFrequencyRange result = EFmRangeEuroAmerica;
 switch ( aRegionId )
 {
 case ERadioRegionDefault:
 {
 // Sets radio mode ERadioStereo or ERadioMono
 // ---------------------------------------------------------------------------
 void CRadioEngineImp::SetAudioMode( TInt aAudioMode )
 {
-LOG_FORMAT( "CRadioEngineImp::SetAudioMode: aAudioMode: %d", aAudioMode );
+LEVEL3( LOG_METHOD_AUTO );
+LOG_FORMAT( "aAudioMode: %d", aAudioMode );
 TInt err = KErrNone;
 if ( !RadioInitialized() )
 {
 TInt err = iSettings->RadioSetter().SetOutputMode( aAudioMode );
 NotifyRadioEvent( ERadioEventAudioMode, err );
 // Switches power on/off after a delay
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::SwitchPower( TBool aPowerOn )
 {
-LOG_FORMAT( "CRadioEngineImp::SwitchPower( %d )", aPowerOn );
+LEVEL3( LOG_METHOD_AUTO );
+LOG_FORMAT( "aPowerOn %d", aPowerOn );
 if ( RadioInitialized() )
 {
 if ( !aPowerOn || OkToPlay( iSettings->EngineSettings().TunedFrequency() ) )
 {
 iRadioTimer->Cancel();
 // Executes the power switch
 // ---------------------------------------------------------------------------
 //
 TInt CRadioEngineImp::StaticPowerOnCallback( TAny* aSelfPtr )
 {
-LOG( "CRadioEngineImp::StaticPowerOnCallback" );
+LEVEL3( LOG_METHOD_AUTO );
 CRadioEngineImp* self = reinterpret_cast<CRadioEngineImp*>( aSelfPtr );
 if ( self )
 {
 self->iRadioTimer->Cancel(); // prevents the further calls.
 // Executes the power switch
 // ---------------------------------------------------------------------------
 //
 TInt CRadioEngineImp::StaticPowerOffCallback( TAny* aSelfPtr )
 {
-LOG( "CRadioEngineImp::StaticPowerOffCallback" );
+LEVEL3( LOG_METHOD_AUTO );
 CRadioEngineImp* self = reinterpret_cast<CRadioEngineImp*>( aSelfPtr );
 if ( self )
 {
 self->iRadioTimer->Cancel(); // prevents the further calls.
 {
 SetAudioMode( iSettings->EngineSettings().OutputMode() );
 iPlayerUtility->SetVolumeRamp( TTimeIntervalMicroSeconds( MAKE_TINT64( 0, KRadioMillion ) ) );
 iPlayerUtility->SetVolume( TunerVolumeForUiVolume( iSettings->EngineSettings().Volume() ) );
-// If we are about to start scanning, mute the radio and set minimum frequency
+iPlayerUtility->Mute( iSettings->EngineSettings().IsVolMuted() );
-if ( iScanObserver )
+iTunerUtility->SetFrequency( iSettings->EngineSettings().TunedFrequency() );
-{
-iPlayerUtility->Mute( ETrue );
-iTunerUtility->SetFrequency( iSettings->EngineSettings().MinFrequency() );
-}
-else
-{
-iPlayerUtility->Mute( iSettings->EngineSettings().IsVolMuted() );
-iTunerUtility->SetFrequency( iSettings->EngineSettings().TunedFrequency() );
-}
 iFreqEventReason = RadioEngine::ERadioFrequencyEventReasonImplicit;
 TRAP_IGNORE( iAudioRouter->SetAudioRouteL(
 RadioEngine::TRadioAudioRoute( iSettings->EngineSettings().AudioRoute() ) ) )
 // Radio power off
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::PowerOff()
 {
-LOG( "CRadioEngineImp::PowerOff" );
+LOG_METHOD_AUTO;
 if ( iSettings->EngineSettings().IsPowerOn() )
 {
 if ( RadioInitialized() )
 {
 //
 // ---------------------------------------------------------------------------
 //
 TBool CRadioEngineImp::OkToPlay( TUint32 aFrequency ) const
 {
+LEVEL3( LOG_METHOD_AUTO );
 TBool audioResourcesAvailable = iSystemEventCollector->IsAudioResourcesAvailable();
 TBool okToPlay = iAntennaAttached &&
 !iFmTransmitterActive &&
 ( audioResourcesAvailable || iOverrideAudioResources ) &&
 #ifdef COMPILE_IN_IVALO
 && !iSystemEventCollector->IsCallActive();
 #else
 IsFrequencyValid( aFrequency );
 #endif //COMPILE_IN_IVALO
-LOG_FORMAT( "CRadioEngineImp::OkToPlay, returning %d ", okToPlay );
+LEVEL2( LOG_FORMAT( "returning okToPlay %d ", okToPlay ) );
 return okToPlay;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TBool CRadioEngineImp::IsFrequencyValid( TUint32 aFrequency ) const
 {
+LEVEL3( LOG_METHOD_AUTO );
 TBool ret( EFalse );
 if ( !aFrequency )
 {
 aFrequency = iSettings->EngineSettings().TunedFrequency();
 }
 }
 return ret;
 }
 // ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CRadioEngineImp::SetManualSeekMode( TBool aManualSeekActive )
+{
+iManualSeekMode = aManualSeekActive;
+if ( iManualSeekMode )
+{
+CancelSeek();
+iRdsReceiver->StopReceiver();
+}
+else
+{
+iRdsReceiver->StartReceiver();
+TInt frequency = 0;
+iTunerUtility->GetFrequency( frequency );
+HandleFrequencyEvent( frequency );
+}
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CRadioEngineImp::IsInManualSeekMode() const
+{
+return iManualSeekMode;
+}
+// ---------------------------------------------------------------------------
 // Radio tuning
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::SetFrequency( TUint32 aFrequency, RadioEngine::TRadioFrequencyEventReason aReason )
 {
-LOG_METHOD_AUTO;
+LEVEL3( LOG_METHOD_AUTO );
-LOG_FORMAT( "CRadioEngineImp::SetFrequency, freq: %u, Initialized: %d, Enabled: %d",
+LEVEL2( LOG_FORMAT( "freq: %u, Initialized: %d, Enabled: %d",
-aFrequency, RadioInitialized(), iRadioEnabled );
+aFrequency, RadioInitialized(), iRadioEnabled ) );
-iFrequencySetByRdsAf = EFalse;
 iFreqEventReason = aReason;
+if ( iManualSeekMode )
-TInt frequency = 0;
+{
-if ( iTunerUtility )
+iTunerUtility->SetFrequency( aFrequency );
-{
-iTunerUtility->GetFrequency( frequency );
-}
-CancelSeek();
-if ( aFrequency == frequency ) //radio has already the frequency to be set.
-{
-LOG( "CRadioEngineImp::SetFrequency: Already at the requested frequency" );
-HandleFrequencyEvent( aFrequency );
 }
 else
 {
-iRadioTimer->Cancel();
+iFrequencySetByRdsAf = EFalse;
-if ( RadioInitialized() && iRadioEnabled && OkToPlay( aFrequency ) )
-{
+TInt frequency = 0;
-LOG( "CRadioEngineImp::SetFrequency: Tuning to frequency" );
+if ( iTunerUtility )
-iTunerUtility->SetFrequency( aFrequency );
+{
+iTunerUtility->GetFrequency( frequency );
+}
+CancelSeek();
+if ( aFrequency == frequency ) //radio has already the frequency to be set.
+{
+LOG( "CRadioEngineImp::SetFrequency: Already at the requested frequency" );
+HandleFrequencyEvent( aFrequency );
 }
 else
 {
-HandleFrequencyEvent( aFrequency );
+iRadioTimer->Cancel();
-}
+if ( RadioInitialized() && iRadioEnabled && OkToPlay( aFrequency ) )
-}
+{
-}
+LOG( "CRadioEngineImp::SetFrequency: Tuning to frequency" );
+iTunerUtility->SetFrequency( aFrequency );
-// ---------------------------------------------------------------------------
+}
-// Radio tuning
+else
-// ---------------------------------------------------------------------------
+{
-//
+HandleFrequencyEvent( aFrequency );
-void CRadioEngineImp::SetFrequencyFast( TUint32 aFrequency,
+}
-RadioEngine::TRadioFrequencyEventReason /*aReason*/ )
+}
-{
+}
-if ( iSeekingState != RadioEngine::ERadioNotSeeking )
-{
-iSeekingState = RadioEngine::ERadioNotSeeking;
-iTunerUtility->CancelStationSeek();
-}
-iTunerUtility->SetFrequency( aFrequency );
-iSettings->RadioSetter().SetTunedFrequency( aFrequency );
-}
-// ---------------------------------------------------------------------------
-// Frequency stepping
-// ---------------------------------------------------------------------------
-//
-void CRadioEngineImp::StepToFrequency( RadioEngine::TRadioTuneDirection aDirection )
-{
-LOG( "CRadioEngineImp::StepToFrequency" );
-TUint32 freq = iSettings->EngineSettings().TunedFrequency();
-RadioEngine::TRadioFrequencyEventReason reason( RadioEngine::ERadioFrequencyEventReasonUnknown );
-if ( aDirection == RadioEngine::ERadioUp )
-{
-freq = freq + iSettings->EngineSettings().FrequencyStepSize();
-reason = RadioEngine::ERadioFrequencyEventReasonUp;
-}
-else
-{
-freq = freq - iSettings->EngineSettings().FrequencyStepSize();
-reason = RadioEngine::ERadioFrequencyEventReasonDown;
-}
-// Check overflow or underflow
-if ( IsFrequencyValid( freq ) )
-{
-if ( aDirection == RadioEngine::ERadioUp )
-{
-freq = iSettings->EngineSettings().MinFrequency();
-}
-else
-{
-freq = iSettings->EngineSettings().MaxFrequency();
-}
-}
-SetFrequency( freq, reason );
 }
 // ---------------------------------------------------------------------------
 // Radio seek
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::Seek( RadioEngine::TRadioTuneDirection aDirection )
 {
-LOG_FORMAT( "CRadioEngineImp::Seek-- Start direction:%d",aDirection );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aDirection: %d",aDirection );
 iFrequencySetByRdsAf = EFalse;
 // Check if audio playing parameters ( other than frequency ) are OK
 if ( iRadioEnabled &&
 }
 }
 else
 {
 NotifyRadioEvent( ERadioEventSeeking, KErrGeneral );
-StopScan( KErrGeneral );
 }
 }
 // ---------------------------------------------------------------------------
 // Cancels seek up/down request
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::CancelSeek()
 {
-LOG_FORMAT( "CRadioEngineImp::CancelSeek -- seeking state was:%d", iSeekingState );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "seeking state was:%d", iSeekingState );
-if ( !iScanObserver )
-{
+if ( iSeekingState != RadioEngine::ERadioNotSeeking )
-if ( iSeekingState != RadioEngine::ERadioNotSeeking )
+{
-{
+iSeekingState = RadioEngine::ERadioNotSeeking;
-iSeekingState = RadioEngine::ERadioNotSeeking;
+iTunerUtility->CancelStationSeek();
-iTunerUtility->CancelStationSeek();
+iFreqEventReason = RadioEngine::ERadioFrequencyEventReasonImplicit;
-iFreqEventReason = RadioEngine::ERadioFrequencyEventReasonImplicit;
+NotifyRadioEvent( ERadioEventSeeking, KErrCancel );
-NotifyRadioEvent( ERadioEventSeeking, KErrCancel );
+NotifyRadioEvent( ERadioEventFrequency, KErrNone ); // Notify the observers even if the frequency remains the same.
-NotifyRadioEvent( ERadioEventFrequency, KErrNone ); // Notify the observers even if the frequency remains the same.
-}
-}
-else
-{
-StopScan( KErrCancel );
 }
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 RadioEngine::TRadioSeeking CRadioEngineImp::Seeking() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 return iSeekingState;
 }
 // ---------------------------------------------------------------------------
-// Starts scanning all available stations from the minimum frequency
-// ---------------------------------------------------------------------------
-//
-void CRadioEngineImp::StartScan( MRadioScanObserver& aObserver )
-{
-LOG( "CRadioEngineImp::StartScan" );
-const TUint32 minFrequency = iSettings->EngineSettings().MinFrequency();
-if ( !iScanObserver && iRadioEnabled && RadioInitialized() && OkToPlay( minFrequency ) )
-{
-CancelSeek();
-iScanObserver = &aObserver;
-iPreviousMuteState = iSettings->EngineSettings().IsVolMuted();
-iPreviousScannedFrequency = 0;
-iPlayerUtility->Mute( ETrue );
-iTunerUtility->SetFrequency( minFrequency );
-Seek( RadioEngine::ERadioUp );
-}
-else
-{
-TInt error = iScanObserver ? KErrAlreadyExists : KErrNotReady;
-TRAP_IGNORE( aObserver.ScanCompletedEventL( error ) )
-}
-}
-// ---------------------------------------------------------------------------
-// Stops any scans currently in progress.
-// ---------------------------------------------------------------------------
-//
-void CRadioEngineImp::StopScan( TInt aError )
-{
-LOG_FORMAT( "CRadioEngineImp::StopScan, error: %d", aError );
-if ( iScanObserver )
-{
-if ( iSeekingState != RadioEngine::ERadioNotSeeking )
-{
-iSeekingState = RadioEngine::ERadioNotSeeking;
-if ( RadioInitialized() )
-{
-iTunerUtility->CancelStationSeek();
-}
-}
-iPreviousScannedFrequency = 0;
-MRadioScanObserver& observer = *iScanObserver;
-iScanObserver = NULL;
-NotifyRadioScanEvent( ERadioEventScanCompleted, observer, aError );
-if ( !OkToPlay( iSettings->EngineSettings().MinFrequency() ) )
-{
-// Try to reset the frequency as sometimes extra frequency event occurs after seeking
-iFreqEventReason = RadioEngine::ERadioFrequencyEventReasonImplicit;
-iTunerUtility->SetFrequency( iSettings->EngineSettings().TunedFrequency() );
-}
-if ( iPlayerUtility && OkToPlay( iSettings->EngineSettings().TunedFrequency() ) )
-{
-iPlayerUtility->Mute( iPreviousMuteState );
-}
-}
-}
-// ---------------------------------------------------------------------------
 // Sets volume level up/down one step.
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::AdjustVolume( RadioEngine::TRadioVolumeSetDirection aDirection )
 {
-LOG_FORMAT( "CRadioEngineImp::AdjustVolume( %d )", aDirection );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aDirection: %d ", aDirection );
 if ( iSettings->EngineSettings().IsPowerOn() )
 {
 TInt volume = iSettings->EngineSettings().Volume();
-LOG_FORMAT( "CRadioEngineImp::AdjustVolume volume = ( %d )", volume );
+LOG_FORMAT( "volume = ( %d )", volume );
 if ( aDirection == RadioEngine::ERadioDecVolume )
 {
 TInt min = iSettings->EngineSettings().DefaultMinVolumeLevel();
 if ( --volume < min )
 volume = max;
 }
 }
 else
 {
-LOG( "CRadioEngineImp::AdjustVolume - Unhandled case" );
+LOG( "Unhandled case" );
 }
 SetVolume( volume );
 }
 }
 // Sets audio volume level
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::SetVolume( TInt aVolume )
 {
-LOG_FORMAT( "CRadioEngineImp::SetVolume vol: %d", aVolume );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aVolume: %d", aVolume );
 if ( iSettings->EngineSettings().IsPowerOn() && RadioInitialized() )
 {
-LOG( "CRadioEngineImp::SetVolume: Setting volume to player utility" );
+LOG( "Setting volume to player utility" );
 if ( aVolume == 0 )
 {
 SetVolumeMuted( ETrue );
 }
 // ---------------------------------------------------------------------------
 // Set radio audio muted/unmuted
 // ---------------------------------------------------------------------------
 //
-void CRadioEngineImp::SetVolumeMuted( TBool aMuteState )
+void CRadioEngineImp::SetVolumeMuted( TBool aMuteState, TBool aUpdateSettings )
 {
 LOG_METHOD_AUTO;
 LOG_FORMAT( "MuteState = %d", aMuteState );
 if ( iSettings->EngineSettings().IsPowerOn() )
 {
 TInt err = KErrNone;
 if ( RadioInitialized() )
 {
 err = iPlayerUtility->Mute( aMuteState );
-iSettings->RadioSetter().SetVolMuted( aMuteState );
+}
-NotifyRadioEvent( ERadioEventMute, err );
-}
+if ( aUpdateSettings )
-else
 {
 err = iSettings->RadioSetter().SetVolMuted( aMuteState );
-NotifyRadioEvent( ERadioEventMute, err );
+}
-}
+NotifyRadioEvent( ERadioEventMute, err );
 }
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TBool CRadioEngineImp::IsAntennaAttached()
 {
-LOG_FORMAT( "CRadioEngineImp::IsAntennaAttached, returning %d", iAntennaAttached );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "returning iAntennaAttached: %d", iAntennaAttached ) );
 return iAntennaAttached;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TBool CRadioEngineImp::IsFmTransmitterActive() const
 {
-LOG_FORMAT( "CRadioEngineImp::IsFmTransmitterActive, returning %d", iFmTransmitterActive );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "returning iFmTransmitterActive: %d", iFmTransmitterActive ) );
 return iFmTransmitterActive;
 }
 // ---------------------------------------------------------------------------
 // This function is usable only in WINS emulator.
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::SetAntennaAttached( TBool aAntennaAttached )
 {
+LOG_METHOD_AUTO;
 #ifdef __WINS__
 MrftoAntennaStatusChange( aAntennaAttached );
 #endif
 }
 // is 20.
 // ---------------------------------------------------------------------------
 //
 TInt CRadioEngineImp::MaxVolumeLevel() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 TInt maxLevel = 0;
 #if defined __WINS__
 maxLevel = KRadioVolumeStepsOld;
 #else
 //
 // ---------------------------------------------------------------------------
 //
 TBool CRadioEngineImp::FrequencySetByRdsAf() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 return iFrequencySetByRdsAf;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 MRadioRdsReceiver& CRadioEngineImp::RdsReceiver()
 {
+LEVEL3( LOG_METHOD_AUTO );
 return *iRdsReceiver;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 TInt CRadioEngineImp::TunerVolumeForUiVolume( TInt aUiVolume )
 {
+LEVEL3( LOG_METHOD_AUTO );
 TInt vol = aUiVolume * KRadioVolumeStepsDivider;
 return vol;
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::NotifyRadioEvent( TInt aRadioEvent, TInt aErrorCode )
 {
+LEVEL3( LOG_METHOD_AUTO );
 TRAP_IGNORE( DoNotifyRadioEventL( aRadioEvent, aErrorCode ) )
 }
 // ---------------------------------------------------------------------------
 // Notifies all the registered observers of radio events
 // by sending notifications to observers.
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::DoNotifyRadioEventL( TInt aRadioEvent, TInt aErrorCode )
 {
+LOG_METHOD_AUTO;
 TInt count = iObservers.Count();
 for ( TInt i = 0; i<count; i++)
 {
 MRadioEngineObserver * observer = iObservers[i];
 observer->VolumeEventL( iSettings->EngineSettings().Volume(), aErrorCode );
 break;
 }
 case ERadioEventMute:
 {
-if ( !iScanObserver )
+observer->MuteEventL( iSettings->EngineSettings().IsVolMuted(), aErrorCode );
-{
-observer->MuteEventL( iSettings->EngineSettings().IsVolMuted(), aErrorCode );
-}
 break;
 }
 case ERadioEventAudioMode:
 {
 observer->AudioModeEventL( iSettings->EngineSettings().OutputMode(), aErrorCode );
 }
 }
 }
 // ---------------------------------------------------------------------------
-// Notifies the observer of a radio scan event.
-// ---------------------------------------------------------------------------
-//
-void CRadioEngineImp::NotifyRadioScanEvent( TRadioScanEvent aEvent,
-MRadioScanObserver& aObserver,
-TInt aError  )
-{
-TRAP_IGNORE( DoNotifyRadioScanEventL( aEvent, aObserver, aError ) )
-}
-// ---------------------------------------------------------------------------
-// Notifies the observer of a radio scan event.
-// ---------------------------------------------------------------------------
-//
-void CRadioEngineImp::DoNotifyRadioScanEventL( TRadioScanEvent aEvent,
-MRadioScanObserver& aObserver,
-TInt aError )
-{
-LOG_FORMAT( "CRadioEngineImp::DoNotifyRadioScanEventL, aEvent: %d, aError: %d", aEvent, aError );
-if ( aEvent == ERadioEventFrequencyScanned )
-{
-if ( aError == KErrNone )
-{
-aObserver.ScanFrequencyEventL( iPreviousScannedFrequency );
-}
-}
-else if ( aEvent == ERadioEventScanCompleted )
-{
-// KFmRadioErrTuning error means that no channels can be found anymore
-if ( aError == KFmRadioErrTuning )
-{
-aError = KErrNotFound;
-}
-aObserver.ScanCompletedEventL( aError );
-}
-}
-// ---------------------------------------------------------------------------
 // Handles some system events
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::HandleSystemEventL( TRadioSystemEventType aEventType )
 {
-LOG_FORMAT( "CRadioEngineImp::HandleSystemEventL, aEventType = %d", aEventType );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aEventType = %d", aEventType );
 switch ( aEventType )
 {
 case ERadioAudioResourcesAvailable:
 {
 }
 break;
 case ERadioCallActivated:
 {
-StopScan( KErrGeneral );
 CancelSeek();
 }
 break;
 case ERadioCallDeactivated:
 case ERadioHeadsetConnected:
 {
 // Explicitly set the audio routing to headset. Because system
 // forces the routing to headset anyway, and without our knowledge.
+MRadioSettingsSetter& setter = iSettings->RadioSetter();
+setter.SetAudioRoute( RadioEngine::ERadioHeadset );
 iAudioRouter->SetAudioRouteL( RadioEngine::ERadioHeadset );
 }
 break;
 case ERadioHeadsetDisconnected:
 {
 // Explicitly set the audio routing to speaker. Because system
 // forces the routing to speaker anyway, if radio stays on.
+MRadioSettingsSetter& setter = iSettings->RadioSetter();
+setter.SetAudioRoute( RadioEngine::ERadioSpeaker );
 iAudioRouter->SetAudioRouteL( RadioEngine::ERadioSpeaker );
 }
 break;
 default:
 {
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoRequestTunerControlComplete( TInt aError )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoRequestTunerControlComplete( %d )", aError );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aError: %d", aError );
 if ( aError == KErrNone || aError == KErrAlreadyExists ) // Tuner activated now or was already active
 {
 iRadioInitializationState = ERadioTunerControlGranted;
 TBool offlineAvailable( tunerCaps.iTunerFunctions &
 TFmTunerCapabilities::ETunerAvailableInOfflineMode );
 iTunerUtility->EnableTunerInOfflineMode( offlineAvailable );
-TBool rdsSupported = EFalse;
+if ( tunerCaps.iTunerFunctions & TFmTunerCapabilities::ETunerRdsSupport )
-TRAP_IGNORE( CRadioRepositoryManager::GetRepositoryValueL( KRadioCRUid, KRadioCRRdsSupport,
+{
-rdsSupported ) )
+TRAP_IGNORE( iRdsReceiver->InitL( *iRadioUtility ) )
-if ( tunerCaps.iTunerFunctions & TFmTunerCapabilities::ETunerRdsSupport &&
-rdsSupported )
-{
-TRAP_IGNORE( iRdsReceiver->InitL( *iRadioUtility, iPubSub ) )
 }
 iTunerUtility->SetFrequencyRange( TunerFrequencyRangeForRegionId(
 iSettings->EngineSettings().RegionId() ) );
 // To prevent false frequency changes
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoSetFrequencyRangeComplete( TInt aError )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoSetFrequencyRangeComplete( %d )", aError );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aError: %d", aError ) );
 if ( aError )
 {
 NotifyRadioEvent( ERadioEventRegion, aError );
 }
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoSetFrequencyComplete( TInt aError )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoSetFrequencyComplete: Err: %d", aError );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aError: %d", aError );
-if ( aError )
+if ( aError && !iManualSeekMode )
 {
 if ( aError == KErrNotReady )
 {
 iRadioInitializationState = ERadioUtilitiesConstructed;
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoStationSeekComplete( TInt aError, TInt aFrequency )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoStationSeekComplete() -- aError = %d, aFrequency = %d", aError, aFrequency );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aError = %d, aFrequency = %d", aError, aFrequency );
 // Seeking has ended, error code tells if it was successful
 if ( aError == KFmRadioErrAntennaNotConnected )
 {
 iAntennaAttached = EFalse;
 iRadioInitializationState = ERadioUtilitiesConstructed;
 }
 iSeekingState = RadioEngine::ERadioNotSeeking;
-NotifyRadioEvent( ERadioEventSeeking, aError );
+if ( aFrequency == 0 ) {
+NotifyRadioEvent( ERadioEventFrequency, aError );
+}
 //    if ( aError != KErrNone )
 //        {
 //        iFreqEventReason = RadioEngine::ERadioFrequencyEventReasonImplicit;
 //        NotifyRadioEvent( ERadioEventFrequency, KErrNone ); // Frequency change is not otherwise notified when seeking fails.
 //        if ( !iFrequencySetByRdsAf )
 //            {
 //            NotifyRadioEvent( ERadioEventFrequency, KErrNone );
 //            }
 //        }
-if ( iScanObserver )
-{
-if ( aError != KErrNone )
-{
-StopScan( aError );
-}
-else
-{
-if ( aFrequency > iSettings->EngineSettings().MinFrequency() && aFrequency > iPreviousScannedFrequency )
-{
-iPreviousScannedFrequency = aFrequency;
-NotifyRadioScanEvent( ERadioEventFrequencyScanned, *iScanObserver, KErrNone );
-Seek( RadioEngine::ERadioUp ); // Continue scanning.
-}
-else
-{
-if ( aFrequency == iSettings->EngineSettings().MinFrequency() )
-{
-iPreviousScannedFrequency = aFrequency;
-NotifyRadioScanEvent( ERadioEventFrequencyScanned, *iScanObserver, KErrNone );
-}
-StopScan( aError );
-}
-}
-}
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoFmTransmitterStatusChange( TBool aActive )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoFmTransmitterStatusChange( %d )", aActive );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aActive: %d", aActive );
 iFmTransmitterActive = aActive;
 if ( !iFmTransmitterActive )
 {
 SwitchPower( ETrue );
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoAntennaStatusChange( TBool aAttached )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoAntennaStatusChange( %d )", aAttached );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aAttached: %d", aAttached );
 iAntennaAttached = aAttached;
 if ( iAntennaAttached )
 {
 SwitchPower( ETrue );
 NotifyRadioEvent( ERadioEventAntenna );
-iPubSub->PublishAntennaState( ERadioPSRadioAntennaAttached );
 }
 else
 {
 NotifyRadioEvent( ERadioEventAntenna, KErrDisconnected );
-iPubSub->PublishAntennaState( ERadioPSRadioAntennaDetached );
+}
 }
-}
+// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
+//
-//
+// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
+//
-//
+void CRadioEngineImp::MrftoOfflineModeStatusChange( TBool DEBUGVAR3( aOfflineMode ) )
-void CRadioEngineImp::MrftoOfflineModeStatusChange( TBool DEBUGVAR( aOfflineMode ) )
+{
-{
+LEVEL3( LOG_METHOD_AUTO );
-LOG_FORMAT( "CRadioEngineImp::MrftoOfflineModeStatusChange( %d )", aOfflineMode );
+LEVEL3( LOG_FORMAT( "aOfflineMode: %d", aOfflineMode ) );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-void CRadioEngineImp::MrftoFrequencyRangeChange( TFmRadioFrequencyRange DEBUGVAR( aBand ) )
+void CRadioEngineImp::MrftoFrequencyRangeChange( TFmRadioFrequencyRange DEBUGVAR3( aBand ) )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoFrequencyRangeChange( %d )", aBand );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aBand: %d", aBand ) );
 if ( RadioInitialized() )
 {
 iTunerUtility->SetFrequency( iSettings->EngineSettings().TunedFrequency() );
 iFreqEventReason = RadioEngine::ERadioFrequencyEventReasonImplicit;
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoFrequencyChange( TInt aNewFrequency )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoFrequencyChange aNewFrequency = %u", aNewFrequency );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aNewFrequency = %u", aNewFrequency ) );
 // There may be frequency changed events when radio is not initialized ( because
 // of SetFrequency or Seek returns with KErrNotReady ).
-if ( RadioInitialized() )
+if ( !iManualSeekMode && RadioInitialized() )
 {
 HandleFrequencyEvent( aNewFrequency );
 }
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoForcedMonoChange( TBool aForcedMono )
 {
-LOG_FORMAT( "CRadioEngineImp::MrftoForcedMonoChange -- aForcedMono = %d", aForcedMono );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aForcedMono = %d", aForcedMono ) );
 iSettings->RadioSetter().SetOutputMode( aForcedMono ? RadioEngine::ERadioMono : RadioEngine::ERadioStereo );
 NotifyRadioEvent( ERadioEventAudioMode );
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrftoSquelchChange( TBool /*aSquelch*/ )
 {
+LEVEL3( LOG_METHOD_AUTO );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrpoStateChange( TPlayerState aState, TInt aError )
 {
-LOG_FORMAT( "CRadioEngineImp::MrpoStateChange() -- aState = %d, aError = %d", aState, aError );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aState = %d, aError = %d", aState, aError ) );
 if ( aError == KFmRadioErrAntennaNotConnected )
 {
 iAntennaAttached = EFalse;
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrpoVolumeChange( TInt aVolume )
 {
-aVolume = aVolume / KRadioVolumeStepsDivider;
+LEVEL3( LOG_METHOD_AUTO );
-LOG_FORMAT( "CRadioEngineImp::MrpoVolumeChange() --  volume = %d", aVolume );
+	aVolume = aVolume / KRadioVolumeStepsDivider;
 if ( aVolume != iSettings->EngineSettings().Volume() )
 {
 iSettings->RadioSetter().SetVolume( aVolume );
 NotifyRadioEvent( ERadioEventVolume );
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrpoMuteChange( TBool aMute )
 {
+LEVEL3( LOG_METHOD_AUTO );
 TBool muted = iSettings->EngineSettings().IsVolMuted();
-if ( !iScanObserver && !aMute != !muted )
+if ( !aMute != !muted )
 {
 iSettings->RadioSetter().SetVolMuted( aMute );
 NotifyRadioEvent( ERadioEventMute );
 }
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::MrpoBalanceChange( TInt /*aLeftPercentage*/, TInt /*aRightPercentage*/ )
 {
+LEVEL3( LOG_METHOD_AUTO );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::RdsAfSearchSettingChangedL( TBool aEnabled )
 {
-LOG_FORMAT( "CRadioEngineImp::RdsAfSearchSettingChangedL( %d )", aEnabled );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aEnabled: %d", aEnabled ) );
 iRdsReceiver->SetAutomaticSwitchingL( aEnabled );
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-void CRadioEngineImp::RegionSettingChangedL( TInt DEBUGVAR( aRegion ) )
+//TODO: Check if this can be removed. Radio doesn't currently support changing regions on the fly
-{
+void CRadioEngineImp::RegionSettingChangedL( TInt DEBUGVAR3( aRegion ) )
-LOG_FORMAT( "CRadioEngineImp::RegionSettingChangedL( %d )", aRegion );
+{
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aRegion: %d", aRegion ) );
 if ( RadioInitialized() )
 {
 iTunerUtility->SetFrequencyRange( TunerFrequencyRangeForRegionId( iSettings->EngineSettings().RegionId() ) );
 iTunerUtility->SetFrequency( iSettings->EngineSettings().TunedFrequency() );
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::RdsAfSearchBegin()
 {
-LOG( "CRadioEngineImp::RdsAfSearchBegin()" );
+LEVEL3( LOG_METHOD_AUTO );
 iFrequencySetByRdsAf = ETrue;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
-void CRadioEngineImp::RdsAfSearchEnd( TUint32 DEBUGVAR( aFrequency ), TInt aError )
+void CRadioEngineImp::RdsAfSearchEnd( TUint32 DEBUGVAR3( aFrequency ), TInt aError )
 {
-LOG_FORMAT( "CRadioEngineImp::RdsAfSearchEnd( %d, %d )", aFrequency, aError );
+LEVEL3( LOG_METHOD_AUTO );
+LEVEL3( LOG_FORMAT( "aFrequency: %d, aError: %d )", aFrequency, aError ) );
 if ( aError != KErrNone )
 {
 iFrequencySetByRdsAf = EFalse;
 }
 }
 // Tries to figure the region out based on current mobile network id
 // ---------------------------------------------------------------------------
 //
 TRadioRegion CRadioEngineImp::RegionFromMobileNetwork() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 TRadioRegion region = ERadioRegionNone;
 // Choose the frequency range according to country code
 MRadioEngineSettings& engineSettings = iSettings->EngineSettings();
-const TDesC& countryCode = engineSettings.CountryCode();
+TPtrC countryCode = engineSettings.CountryCode();
 const TInt regionCount = engineSettings.CountRegions();
 TBool matchFound = EFalse;
 for ( TInt i = 0; i < regionCount && !matchFound; ++i )
 {
 const RRadioCountryCodeArray& regionCountryCodes =
 // Tries to figure the region out based on timezone selection
 // ---------------------------------------------------------------------------
 //
 TRadioRegion CRadioEngineImp::RegionFromTimezone() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 TRadioRegion region = ERadioRegionNone;
 TRAP_IGNORE( region = DoRegionFromTimezoneL() );
 return region;
 }
 // We get the ownership so we must delete
 CTzLocalizedCity* city = timezoneLocalizer->GetFrequentlyUsedZoneCityL( CTzLocalizedTimeZone::ECurrentZone );
 const TUint8 cityId = city->GroupId();
 delete city;
 city = NULL;
-LOG_FORMAT( "CRadioEngineHandler::CurrentTimeZoneToRegionL group id: %d", cityId );
+LOG_FORMAT( "group id: %d", cityId );
 TRadioRegion region = ERadioRegionNone;
 const TInt cityGroupCount = cityGroups->Count();
 TBool found = EFalse;
 for ( TInt i = 0; i < cityGroupCount && !found; ++i )
 }
 CleanupStack::PopAndDestroy( cityGroups );
 CleanupStack::PopAndDestroy( timezoneLocalizer );
-LOG_ASSERT( found, LOG_FORMAT( "CRadioEngine::DoMapCurrentTimeZoneToRegionL. City not found: %d", cityId ) );
+LOG_ASSERT( found, LOG_FORMAT( "City not found: %d", cityId ) );
 return region;
 }
 // ---------------------------------------------------------------------------
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::HandleAudioRoutingEvent( RadioEngine::TRadioAudioRoute aDestination )
 {
-LOG_FORMAT( "CRadioEngineImp::HandleAudioRoutingL( %d )", aDestination );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aDestination: %d", aDestination );
 // Make modifications to volume ONLY if new audio source state
 // differs from settings. If they don't differ, this state
 // change is a part of the radio initialization.
 MRadioSettingsSetter& setter = iSettings->RadioSetter();
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::HandlePowerEvent( TBool aPowerOn, TInt aErrorCode )
 {
-LOG_FORMAT( "CRadioEngineImp::HandlePowerEvent( %d, %d )", aPowerOn, aErrorCode );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aPowerOn: %d, aErrorCode: %d )", aPowerOn, aErrorCode );
 const TBool powerState = iSettings->EngineSettings().IsPowerOn();
 if ( !powerState != !aPowerOn )
 {
 iSettings->RadioSetter().SetPowerOn( aPowerOn );
 }
 }
 if ( !iSettings->EngineSettings().IsPowerOn() )
 {
-StopScan( aErrorCode );
 CancelSeek();
 }
 // If we are seeking, power event starts seeking
 if ( iSeekingState != RadioEngine::ERadioNotSeeking && iSettings->EngineSettings().IsPowerOn() )
 {
 // Reset seeking state to enable seeking start
+LOG( "PowerOn event in seekingstate. Restart seeking" );
 RadioEngine::TRadioSeeking oldSeeking = iSeekingState;
 iSeekingState = RadioEngine::ERadioNotSeeking;
 Seek( oldSeeking == RadioEngine::ERadioSeekingUp ? RadioEngine::ERadioUp : RadioEngine::ERadioDown );
 }
-if ( !powerState != !aPowerOn )
+if ( !powerState != !aPowerOn || aErrorCode )
 {
 NotifyRadioEvent( ERadioEventPower, aErrorCode );
 }
 }
 //
 // ---------------------------------------------------------------------------
 //
 void CRadioEngineImp::HandleFrequencyEvent( TUint32 aFrequency, TInt aErrorCode )
 {
-LOG_FORMAT( "CRadioEngineImp::HandleFrequencyEvent( %d, %d )", aFrequency, aErrorCode );
+LOG_METHOD_AUTO;
+LOG_FORMAT( "aFrequency:  %d, aErrorCode: %d )", aFrequency, aErrorCode );
 if ( iSettings->EngineSettings().TunedFrequency() != aFrequency )
 {
 if ( iSettings->EngineSettings().IsPowerOn() )
 {
 // audio routing is not supported.
 // ---------------------------------------------------------------------------
 //
 TBool CRadioEngineImp::IsAudioRoutingPossible() const
 {
+LEVEL3( LOG_METHOD_AUTO );
 TBool headsetConnected = EFalse;
 TRAP_IGNORE( ( headsetConnected = iSystemEventCollector->IsHeadsetConnectedL() ) )
 TBool powerOn = iSettings->EngineSettings().IsPowerOn();

branch	GCC_SURGE
changeset 37	451b2e1545b2
parent 14	63aabac4416d
parent 32	189d20c34778