diff -r cce62ebc198e -r 93c594350b9a fmradio/fmradioengine/src/fmradioengine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fmradio/fmradioengine/src/fmradioengine.cpp Wed Sep 01 12:30:32 2010 +0100 @@ -0,0 +1,1968 @@ +/* +* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: The class implements the core functionality of the Radio Engine +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include +#include + +#include "fmradioengine.h" +#include "fmradioenginestatechangecallback.h" +#include "debug.h" +#include "fmradioengineradiosettings.h" +#include "fmradioengineradiostatehandler.h" +#include "fmradioenginecentralrepositoryhandler.h" +#include "fmradioenginecrkeys.h" +#include "fmradiosystemeventdetector.h" +#include "fmradiomobilenetworkinfolistener.h" +#include "fmradiopubsub.h" +#include "fmradiordsreceiver.h" +#include "fmradiordsreceiversimulator.h" +#include "fmradioaccessoryconnection.h" + +#ifndef __ACCESSORY_FW +#include "fmradioenginedosserverobserver.h" +#endif + +// CONSTANTS + +const TInt KFMRadioNumberOfVolumeSteps = 20; + +// ============================ MEMBER FUNCTIONS =============================== +// ---------------------------------------------------- +// CRadioEngine::CRadioEngine +// Default class constructor. +// ---------------------------------------------------- +// +CRadioEngine::CRadioEngine( + MRadioEngineStateChangeCallback& aCallback) + : + iCurrentRadioState( EStateRadioOff ), + iCallback( aCallback ), + iTempFrequency( KDefaultRadioFrequency ), + iTunePresetRequested( EFalse ), + iInitializeRadioRequestExists( EFalse ), + iTunerControl( EStateRadioTunerControlUninitialized ) + { + } + +// ---------------------------------------------------- +// CRadioEngine::ConstructL +// Second phase class constructor. +// ---------------------------------------------------- +// +void CRadioEngine::ConstructL() + { + FTRACE(FPrint(_L("CRadioEngine::ConstructL()"))); + + InitializeResourceLoadingL(); + + iRadioSettings = new ( ELeave ) TRadioSettings; + + iCentralRepositoryHandler = CCentralRepositoryHandler::NewL( *iRadioSettings ); + +#ifdef __WINS__ + // NetworkInfoListener takes care of listening to the network id and country code. + iNetworkInfoListener = CFMRadioMobileNetworkInfoListener::NewL( *this ); +#endif + + // for monitoring network availability + iSystemEventDetector = CFMRadioSystemEventDetector::NewL( *this ); + + // create an instance of Radio Utility factory and indicate + // FM Radio is a primary client + iRadioUtility = CRadioUtility::NewL( ETrue ); + + // Get a tuner utility + iFmTunerUtility = &iRadioUtility->RadioFmTunerUtilityL( *this ); + iFmTunerUtility->EnableTunerInOfflineMode( ETrue ); + + // Get a player utility + iPlayerUtility = &iRadioUtility->RadioPlayerUtilityL( *this ); + + TInt maxVolume = 0; + iPlayerUtility->GetMaxVolume( maxVolume ); + FTRACE(FPrint(_L("CRadioEngine::ConstructL() maxVolume %d"), maxVolume ) ); + // calculate multiplier for scaling the UI volume to the value used by DevSound + iUiVolumeFactor = ( static_cast ( maxVolume ) / KFMRadioNumberOfVolumeSteps ); + + + // Get a preset utility + iPresetUtility = CRadioFmPresetUtility::NewL( *this ); + +#ifdef __WINS__ + iRdsReceiver = CFMRadioRdsReceiverSimulator::NewL( *iRadioSettings ); + static_cast ( iRdsReceiver )->SetRadioEngineForRadioFmTunerSimulation( this ); +#else + iRdsReceiver = CFMRadioRdsReceiver::NewL( *iRadioSettings ); +#endif + + iRdsReceiver->AddObserver( this ); + + iStateHandler = CRadioStateHandler::NewL( this ); + +#ifndef __ACCESSORY_FW + iDosServerObserver = CDosServerObserver::NewL( this, iRadioSettings ); +#else +#ifndef __WINS + TRAP_IGNORE( iAudioOutput = CAudioOutput::NewL( *iPlayerUtility ) ); +#endif +#endif + + iTopFrequency = 0; + iBottomFrequency = 0; + + if ( iSystemEventDetector->IsCallActive() ) + { + // Pre-empted due to phone call + iInCall = ETrue; + } + // accessory observer + iHeadsetObserver = CFMRadioAccessoryConnection::NewL(); + iHeadsetObserver->SetObserver( this ); + // Set audio output to current setting + if ( iHeadsetObserver->WiredHeadsetConnected() ) + { + SetAudioOutput( EFMRadioOutputHeadset ); + } + else + { + SetAudioOutput( EFMRadioOutputIHF ); + } + // Assume headset is connected, we'll be notified later if it's not. + iRadioSettings->SetHeadsetConnected(); + + + // Create P&S interface. + iPubSub = CFMRadioPubSub::NewL(); + + // Publish antenna status as connected, we'll be notified later if it's not. + iPubSub->PublishAntennaStatusL( EFMRadioPSHeadsetConnected ); + + iPubSub->PublishFrequencyDecimalCountL( + TFMRadioPSFrequencyDecimalCount( iRadioSettings->DecimalCount() ) ); + + FTRACE(FPrint(_L("CRadioEngine::ConstructL() End "))); + } + +// ---------------------------------------------------- +// CRadioEngine::NewL +// Two-phased class constructor. +// ---------------------------------------------------- +// +EXPORT_C CRadioEngine* CRadioEngine::NewL( + MRadioEngineStateChangeCallback& aCallback ) + { + CRadioEngine* self = new (ELeave) CRadioEngine( aCallback ); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +// ---------------------------------------------------- +// CRadioEngine::~CRadioEngine +// Destructor of CRadioEngine class. +// ---------------------------------------------------- +//// +EXPORT_C CRadioEngine::~CRadioEngine() + { + FTRACE(FPrint(_L("CRadioEngine::~CRadioEngine()"))); + if ( iCentralRepositoryHandler) + { + iCentralRepositoryHandler->SaveEngineSettings(); + delete iCentralRepositoryHandler; + } + + delete iPubSub; + delete iHeadsetObserver; + + RadioOff(); + + delete iNetworkInfoListener; + delete iSystemEventDetector; + delete iPresetUtility; + delete iRadioSettings; + delete iStateHandler; + + if ( iAudioOutput ) + { + TRAP_IGNORE(iAudioOutput->SetAudioOutputL(CAudioOutput::EPrivate)); + delete iAudioOutput; + } + + if ( iRdsReceiver ) + { + iRdsReceiver->RemoveObserver( this ); + } + + delete iRdsReceiver; + + if ( iFmTunerUtility ) + { + iFmTunerUtility->Close(); + } + + if ( iPlayerUtility ) + { + iPlayerUtility->Close(); + } + + delete iRadioUtility; + + #ifndef __ACCESSORY_FW + if (iDosServerObserver) + { + iDosServerObserver->SetAudioRouting(EFMRadioOutputHeadset); + delete iDosServerObserver; + } + #endif + + if ( iFMRadioEngineResourceOffset > 0 ) + { + CCoeEnv::Static()->DeleteResourceFile( iFMRadioEngineResourceOffset ); + } + } + +// ---------------------------------------------------- +// CRadioEngine::InitializeRadio +// Set radio settings to their default values. +// Returns: None +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::InitializeRadio() + { + FTRACE(FPrint(_L("CRadioEngine::InitializeRadio()"))); + iInitializeRadioRequestExists = ETrue; + Tune( iRadioSettings->Frequency() ); +#ifdef __WINS__ + // MrftoRequestTunerControlComplete never completes in WINS, so initialize RdsReceiver here + TRAP_IGNORE( iRdsReceiver->InitL( *iRadioUtility, iPubSub ) ); +#endif + } + +// ---------------------------------------------------- +// CRadioEngine::RadioOn +// Start the radio. +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::RadioOn() + { + FTRACE(FPrint(_L("CRadioEngine::RadioOn()"))); + if ( !iRadioSettings->IsRadioOn() ) + { + FTRACE(FPrint(_L("CRadioEngine::RadioOn() - Turning Radio on, calling play"))); + iRadioSettings->SetRadioOn(); + iPlayerUtility->Play(); + + if ( iPubSub ) + { + TRAP_IGNORE( iPubSub->PublishStateL( ETrue ) ); + } + } + } + +// ---------------------------------------------------- +// CRadioEngine::RadioOff +// Stops the radio. +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::RadioOff() + { + FTRACE(FPrint(_L("CRadioEngine::RadioOff()"))); + if ( iStateHandler ) + { + iStateHandler->Cancel(); + } + + iCurrentRadioState = EStateRadioOff; + + if( iFmTunerUtility && + iRadioSettings && + iRadioSettings->RadioMode() == ERadioTunerMode ) + { + CancelScan(); + } + + if ( iPlayerUtility && + iPlayerUtility->PlayerState() == ERadioPlayerPlaying ) + { + iPlayerUtility->Stop(); + } + + if ( iPubSub ) + { + TRAP_IGNORE( iPubSub->PublishStateL( EFalse ) ); + } + } + +// ---------------------------------------------------- +// CRadioEngine::IsRadioOn +// Returns the radio status. +// ---------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::IsRadioOn() + { + return iRadioSettings->IsRadioOn(); + } + +// ---------------------------------------------------- +// CRadioEngine::IsOfflineProfileL +// Checks if offine profile is current active profile +// Returns: true/false +// ---------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::IsOfflineProfileL() + { + return iCentralRepositoryHandler->IsOfflineProfileActiveL(); + } + +// ---------------------------------------------------- +// CRadioEngine::Tune +// Tune to the specified frequency +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::Tune( TInt aFrequency, TRadioMode aRadioMode ) + { + FTRACE(FPrint(_L("CRadioEngine::Tune()"))); + iTempFrequency = aFrequency; + + iRadioSettings->SetRadioMode( aRadioMode ); + if ( iTunerControl == EStateRadioTunerControlOn && iRadioSettings->IsHeadsetConnected() ) + { + iFmTunerUtility->SetFrequency( aFrequency ); + } + else + { + StoreAndPublishFrequency( aFrequency ); + } + if ( iPubSub ) + { + TRAP_IGNORE + ( + iPubSub->PublishFrequencyL( aFrequency ); + if( aRadioMode == ERadioTunerMode ) + { + iPubSub->PublishChannelNameL( KNullDesC ); + iPubSub->PublishChannelL( KErrNotFound ); + } + ) + } + } + +// ---------------------------------------------------- +// CRadioEngine::SetTunerModeOn +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetTunerModeOn() + { + FTRACE(FPrint(_L("CRadioEngine::SetTunerModeOn()"))); + + iRadioSettings->SetRadioMode( ERadioTunerMode ); + + if ( iPubSub ) + { + TRAP_IGNORE + ( + iPubSub->PublishChannelNameL( KNullDesC ); + iPubSub->PublishChannelL( KErrNotFound ); + ) + } + } + +// ---------------------------------------------------- +// CRadioEngine::ScanUp +// Scan up to the next available frequency +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::ScanUp() + { + iRadioSettings->SetRadioMode(ERadioTunerMode); + iFmTunerUtility->StationSeek( ETrue ); + TRAP_IGNORE + ( + iTuningState = EFMRadioPSTuningStarted; + iPubSub->PublishTuningStateL( iTuningState ); + iPubSub->PublishChannelNameL( KNullDesC ); + iPubSub->PublishChannelL( KErrNotFound ); + ) + } + +// ---------------------------------------------------- +// CRadioEngine::ScanDown +// Scan down to the last available frequency +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::ScanDown() + { + iRadioSettings->SetRadioMode(ERadioTunerMode); + iFmTunerUtility->StationSeek( EFalse ); + TRAP_IGNORE + ( + iTuningState = EFMRadioPSTuningStarted; + iPubSub->PublishTuningStateL( iTuningState ); + iPubSub->PublishChannelNameL( KNullDesC ); + iPubSub->PublishChannelL( KErrNotFound ); + ) + } + +// ---------------------------------------------------- +// CRadioEngine::CancelScan +// Cancel previously requested scan, and return to the +// already tuned frequency +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::CancelScan() + { + if( iFmTunerUtility ) + { + iFmTunerUtility->CancelStationSeek(); + iTuningState = EFMRadioPSTuningUninitialized; + TRAP_IGNORE(iPubSub->PublishTuningStateL( iTuningState )); + } + } + +// ---------------------------------------------------- +// CRadioEngine::IsHeadsetConnected +// Check whether the headset is currently connected +// Returns: true/false +// ---------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::IsHeadsetConnected() const + { + return iRadioSettings->IsHeadsetConnected(); + } + +// ---------------------------------------------------- +// CRadioEngine::IsFlightmodeEnabled +// Check whether flight mode is currently enabled +// Returns: true/false +// ---------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::IsFlightModeEnabled() const + { + return iRadioSettings->IsFlightModeEnabled(); + } + +// ---------------------------------------------------- +// CRadioEngine::SetMuteOn +// Sets the audio mute state +// Returns: None +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetMuteOn( + TBool aMuteOn) // a flag indicating if set mute on + { + FTRACE(FPrint(_L("CRadioEngine::SetMuteOn()"))); + TInt error = KErrNone; + if ( IsMuteOn() && (!aMuteOn) ) + { + error = iPlayerUtility->Mute( EFalse ); + if( !error ) + { + FTRACE(FPrint(_L("CRadioEngine::SetMuteOn() setting mute off"))); + iRadioSettings->SetMuteOff(); + TRAP_IGNORE(iPubSub->PublishRadioMuteStateL(EFalse)); + } + } + else if ( !IsMuteOn() && aMuteOn ) + { + error = iPlayerUtility->Mute( ETrue ); + if( !error ) + { + FTRACE(FPrint(_L("CRadioEngine::SetMuteOn() setting mute on"))); + iRadioSettings->SetMuteOn(); + TRAP_IGNORE(iPubSub->PublishRadioMuteStateL(ETrue)); + } + } + iStateHandler->Callback( MRadioEngineStateChangeCallback::EFMRadioEventSetMuteState, error ); + } + + +// ---------------------------------------------------- +// CRadioEngine::IsMuteOn +// Gets the audio mute state +// Returns: true/false +// ---------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::IsMuteOn() const + { + return iRadioSettings->IsMuteOn(); + } + +// ---------------------------------------------------- +// CRadioEngine::GetPresetIndex +// Retrieve the currently selected channel +// Returns: the preset channel index +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::GetPresetIndex() const + { + return iRadioSettings->CurrentPreset(); + } + + +// ---------------------------------------------------- +// CRadioEngine::SetPresetFrequency +// Update the channel located at the index to use the frequency specified. +// Returns: None +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetPresetNameFrequencyL( + TInt aIndex, // preset channel index + const TStationName& aStationName, + TInt aFrequency) // preset channel frequency + { + iPresetUtility->SetPresetL(aIndex, aStationName, aFrequency); + if( aIndex == iRadioSettings->CurrentPreset() ) + { + iPubSub->PublishChannelNameL( aStationName ); + if( aFrequency == 0 ) + { + // Current preset was deleted + iPubSub->PublishChannelL( KErrNotFound ); + } + } + iPubSub->PublishChannelDataChangedL( aIndex ); + } + +// ---------------------------------------------------- +// CRadioEngine::GetPresetFrequency +// Retrieve the channel frequency at the index specified +// Returns: tmpFrequency: preset frequency +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::GetPresetFrequencyL( + TInt aIndex) const // preset channel index + { + TInt tmpFrequency = KDefaultRadioFrequency; + TStationName tmpStationName; + + iPresetUtility->GetPresetL( aIndex, tmpStationName, tmpFrequency ); + + FTRACE(FPrint(_L("CRadioEngine::GetPresetFrequencyL() aIndex %d"), aIndex)); + FTRACE(FPrint(_L("CRadioEngine::GetPresetFrequencyL() Freq %d"), tmpFrequency)); + FTRACE(FPrint(_L("CRadioEngine::GetPresetFrequencyL() Name %S"), &tmpStationName)); + return tmpFrequency; + } + +// ---------------------------------------------------- +// CRadioEngine::GetPresetName +// Retrieve the channel name at the index specified +// Returns: tmpStationName: the channel name +// ---------------------------------------------------- +// +EXPORT_C CRadioEngine::TStationName& CRadioEngine::GetPresetNameL( TInt aIndex ) + { + TInt tmpFrequency; + + iPresetUtility->GetPresetL(aIndex, iStationName, tmpFrequency); + FTRACE(FPrint(_L("CRadioEngine::GetPresetFrequencyL() Freq %d"),tmpFrequency)); + FTRACE(FPrint(_L("CRadioEngine::GetPresetFrequencyL() Name %S"),&iStationName)); + return iStationName; + } + +// ---------------------------------------------------- +// CRadioEngine::GetPresetNameAndFrequencyL +// get preset name frequency from the preset utility +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::GetPresetNameAndFrequencyL( TInt aIndex, TDes& aName, TInt& aFrequency ) + { + TInt tmpFrequency; + TStationName tmpStationName; + + iPresetUtility->GetPresetL( aIndex, tmpStationName, tmpFrequency ); + + aFrequency = tmpFrequency; + aName = tmpStationName; + } + +// ---------------------------------------------------- +// CRadioEngine::GetTunedFrequency +// Retrieves the current frequency. +// Returns: channel frequency +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::GetTunedFrequency() const + { + return iRadioSettings->Frequency(); + } + +// ---------------------------------------------------- +// CRadioEngine::SetVolume +// Sets the volume level of the FM radio +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetVolume( + TInt aVolume ) + { + FTRACE(FPrint(_L("CRadioEngine::SetVolume( %d )"), aVolume )); + + if ( aVolume < 0 ) + { + aVolume = 0; + } + else if ( aVolume > KFMRadioNumberOfVolumeSteps ) + { + aVolume = KFMRadioNumberOfVolumeSteps; + } + + TInt playerVolume = ( iUiVolumeFactor * aVolume ); + + FTRACE(FPrint(_L("CRadioEngine::SetVolume() playerVolume %d"), playerVolume )); + + TInt error = iPlayerUtility->SetVolume( playerVolume ); + + if ( !error ) + { + if ( iRadioSettings->AudioOutput() == EFMRadioOutputHeadset ) + { + iRadioSettings->SetHeadsetVolume( aVolume ); + iCentralRepositoryHandler->SaveHeadsetVolumeSetting(); + } + else + { + iRadioSettings->SetSpeakerVolume( aVolume ); + iCentralRepositoryHandler->SaveSpeakerVolumeSetting(); + } + } + else + { + iStateHandler->Callback( MRadioEngineStateChangeCallback::EFMRadioEventVolumeUpdated, error ); + } + } + +// ---------------------------------------------------- +// CRadioEngine::GetRadioMode +// Retrieves the current radio mode (tuner or preset). +// Returns: radio mode +// ---------------------------------------------------- +// +EXPORT_C CRadioEngine::TRadioMode CRadioEngine::GetRadioMode() const + { + return iRadioSettings->RadioMode(); + } + +// ---------------------------------------------------- +// CRadioEngine::GetVolume +// Gets the volumelevel. +// Returns: volume +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::GetVolume() const + { + if ( iRadioSettings->AudioOutput() == EFMRadioOutputHeadset ) + { + return iRadioSettings->HeadsetVolume(); + } + else + { + return iRadioSettings->SpeakerVolume(); + } + } + +// ---------------------------------------------------- +// CRadioEngine::GetMaxVolume +// Gets the max volumelevel. +// Returns: max volume +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::GetMaxVolume() const + { + TInt maxVolume; + iPlayerUtility->GetMaxVolume( maxVolume ); + return maxVolume; + } + +// ---------------------------------------------------- +// CRadioEngine::GetAudioMode +// Gets the current audio mode. +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::GetAudioMode() const + { + return iRadioSettings->AudioMode(); + } + +// ---------------------------------------------------- +// CRadioEngine::SetAudioMode +// Set the radio's audio mode (stereo or mono) +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetAudioMode( const TFMRadioAudioMode aAudioMode ) + { + FTRACE(FPrint(_L("CRadioEngine::SetAudioMode"))); + TBool forcedMono = EFalse; + TInt res = KErrNone; + TFMRadioAudioMode audioMode = iRadioSettings->AudioMode(); + if (audioMode != aAudioMode) + { + if ( aAudioMode == EFMRadioMono ) + { + forcedMono = ETrue; + } + res = iFmTunerUtility->ForceMonoReception( forcedMono ); + if ( res ) + { + iRadioSettings->SetAudioMode( aAudioMode ); + } + } + iStateHandler->Callback( MRadioEngineStateChangeCallback::EFMRadioEventSetAudioMode, res ); + } + +// ---------------------------------------------------- +// CRadioEngine::GetAudioOutput +// Retrieve the current audio output +// Returns: audio output +// ---------------------------------------------------- +// +EXPORT_C CRadioEngine::TFMRadioAudioOutput CRadioEngine::GetAudioOutput() const + { + return iRadioSettings->AudioOutput(); + } + +// ---------------------------------------------------- +// CRadioEngine::SetAudioOutput +// Sets the audio Output +// Returns: None +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetAudioOutput( const TFMRadioAudioOutput aAudioOutput ) + { + FTRACE(FPrint(_L("CRadioEngine::SetAudioOutput() Output = %d"), aAudioOutput)); + TInt tempError = KErrNone; + // use mute here to avoid any audio peaks during output change + SetMuteOn( ETrue ); + +#ifndef __ACCESSORY_FW + + tempError = iDosServerObserver->SetAudioRouting(aAudioOutput); + FTRACE(FPrint(_L("CRadioEngine::SetAudioOutput() tempError = %d"), tempError)); + +#else + + CAudioOutput::TAudioOutputPreference outputPreference = CAudioOutput::EPrivate; + + if ( EFMRadioOutputHeadset == aAudioOutput ) + { + FTRACE(FPrint(_L("CRadioEngine::SetAudioOutput() Headset is set to Output"))); + outputPreference = CAudioOutput::EPrivate; + } + else if ( EFMRadioOutputIHF == aAudioOutput ) + { + FTRACE(FPrint(_L("CRadioEngine::SetAudioOutput() IHF is set to Output"))); + + outputPreference = CAudioOutput::EPublic; + } + +#ifndef __WINS + if ( iAudioOutput ) + { + TRAP( tempError, iAudioOutput->SetAudioOutputL( outputPreference ) ); + } +#endif + +#endif + + if ( KErrNone == tempError ) + { + if ( !iHeadsetObserver->WiredHeadsetConnected() ) + { + iRadioSettings->SetAudioOutput( EFMRadioOutputIHF ); + } + else + { + iRadioSettings->SetAudioOutput( aAudioOutput ); + } + } + + iStateHandler->Callback( MRadioEngineStateChangeCallback::EFMRadioEventSetAudioOutput, tempError ); + } + +// ---------------------------------------------------- +// CRadioEngine::SetRdsAfSearchEnable +// Sets the rds af search enabled +// Returns: None +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetRdsAfSearchEnable( TBool aEnabled ) + { + TRAP_IGNORE( iRdsReceiver->SetAutomaticSwitchingL( aEnabled ) ); + aEnabled ? iRadioSettings->SetRdsAfSearchEnabled() : iRadioSettings->SetRdsAfSearchDisabled(); + } + +// ---------------------------------------------------- +// CRadioEngine::RadioSettings +// ---------------------------------------------------- +// +EXPORT_C TRadioSettings& CRadioEngine::RadioSettings( ) + { + return *iRadioSettings; + } + +// ---------------------------------------------------- +// CRadioEngine::TunePreset +// Tunes to the chosen channel. +// Returns: None +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::TunePresetL( TInt aIndex ) + { + FTRACE(FPrint(_L("CRadioEngine::TunePresetL()"))); + iRadioSettings->SetCurrentPreset( aIndex ); + TInt tmpFrequency = 0;// changed back to zero + TStationName name; + + iPresetUtility->GetPresetL( aIndex, name, tmpFrequency ); + // Should not tune if the radio is not on. + if ( iRadioSettings->IsRadioOn()) + { + FTRACE(FPrint(_L("CRadioEngine::TunePresetL() inside if"))); + iTunePresetRequested = ETrue; + iTempFrequency = tmpFrequency; + Tune(tmpFrequency, ERadioPresetMode); + } + else + { + StoreAndPublishFrequency( tmpFrequency ); + } + iPubSub->PublishChannelNameL( name ); + iPubSub->PublishChannelL( aIndex ); + iRadioSettings->SetRadioMode(ERadioPresetMode); + FTRACE(FPrint(_L("CRadioEngine::TunePresetL() end %d"),tmpFrequency)); + } + +// ---------------------------------------------------- +// CRadioEngine::5 +// Return min and max freq for the specified range (band) +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::GetFrequencyBandRange( + TInt& aBottomFrequency, + TInt& aTopFrequency) + { + TBool err = KErrNone; + + aBottomFrequency = iCentralRepositoryHandler->MinFrequency() * KFMRadioFreqMultiplier; + aTopFrequency = iCentralRepositoryHandler->MaxFrequency() * KFMRadioFreqMultiplier; + + return err; + } + +// ---------------------------------------------------- +// CRadioEngine::IsInCall +// ---------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::IsInCall() const + { + return iInCall; + } + +// --------------------------------------------------------- +// CRadioEngine::FrequencySetByRdsAf +// --------------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::FrequencySetByRdsAf() const + { + return iFrequencySetByRdsAf; + } + +// --------------------------------------------------------- +// CRadioEngine::RdsReceiver +// --------------------------------------------------------- +// +EXPORT_C CFMRadioRdsReceiverBase& CRadioEngine::RdsReceiver() + { + return *iRdsReceiver; + } + +// ---------------------------------------------------- +// CRadioEngine::HandleFlightModeEnabled +// Switches the engine into flight mode, and notifies the UI of +// the change in status. +// ---------------------------------------------------- +// +void CRadioEngine::HandleFlightModeEnabled() + { + FTRACE(FPrint(_L("CRadioEngine::HandleFlightModeEnabled()"))); + iRadioSettings->SetFlightMode(ETrue); + HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventFlightModeEnabled, KErrNone); + } + +// ---------------------------------------------------- +// CRadioEngine::HandleFlightModeDisabled +// Switches the engine out of flight mode, and notifies the UI of +// the change in status +// ---------------------------------------------------- +// +void CRadioEngine::HandleFlightModeDisabled() + { + FTRACE(FPrint(_L("CRadioEngine::HandleFlightModeDisabled()"))); + iRadioSettings->SetFlightMode(EFalse); + HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventFlightModeDisabled, KErrNone); + } + + +// ---------------------------------------------------- +// CRadioEngine::HandleCallback +// Calls the User Interface callback function, indicating the event code and +// error code. +// ---------------------------------------------------- +// +void CRadioEngine::HandleCallback(TInt aEventCode, TInt aCode ) + { + FTRACE(FPrint(_L("CRadioEngine::HandleCallback(aEventCode %d, aCode %d "), aEventCode, aCode ) ); + iCallback.HandleRadioEngineCallBack((MRadioEngineStateChangeCallback::TFMRadioNotifyEvent)aEventCode, aCode); + } + +// ---------------------------------------------------- +// CRadioEngine::HandleHeadsetButtonPress +// Notifies UI that the headset button has been pressed +// ---------------------------------------------------- +// +void CRadioEngine::HandleHeadsetButtonPress() + { + FTRACE(FPrint(_L("CRadioEngine::HandleHeadsetButtonPress()"))); + iStateHandler->Callback(MRadioEngineStateChangeCallback::EFMRadioEventButtonPressed, KErrNone); + } + +// ---------------------------------------------------- +// CRadioEngine::HeadsetAccessoryConnectedCallbackL +// ---------------------------------------------------- +// +void CRadioEngine::HeadsetAccessoryConnectedCallbackL() + { + FTRACE(FPrint(_L("CRadioEngine::HeadsetAccessoryConnectedCallbackL"))); + // forward volume changes to headset + SetAudioOutput( EFMRadioOutputHeadset ); + } + +// ---------------------------------------------------- +// CRadioEngine::HeadsetAccessoryDisconnectedCallbackL +// ---------------------------------------------------- +// +void CRadioEngine::HeadsetAccessoryDisconnectedCallbackL() + { + FTRACE(FPrint(_L("CRadioEngine::HeadsetAccessoryDisconnectedCallbackL"))); + // forward volume changes to speakers + SetAudioOutput( EFMRadioOutputIHF ); + } + +// ---------------------------------------------------- +// CRadioEngine::MrftoRequestTunerControlComplete +// ---------------------------------------------------- +// +void CRadioEngine::MrftoRequestTunerControlComplete( TInt aError ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoRequestTunerControlComplete() - Error = %d"), aError)); + + if ( aError == KErrNone ) + { + iTunerControl = EStateRadioTunerControlOn; + // Headset must be connected + iRadioSettings->SetHeadsetConnected(); + iFmTunerUtility->GetCapabilities( iTunerCaps ); + if( iTunerCaps.iTunerFunctions & TFmTunerCapabilities::ETunerRdsSupport ) + { + TRAP_IGNORE( iRdsReceiver->InitL( *iRadioUtility, iPubSub ) ) + } + + TFmRadioFrequencyRange japanFreqRange = EFmRangeJapan; + if ( TunerFrequencyRangeForRegionId( RegionId() ) == japanFreqRange ) + { + // region is Japan so we need to change the freq range from the default + iFmTunerUtility->SetFrequencyRange( japanFreqRange ); + } + else + { + // allready on correct freq range + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTunerReady, KErrNone ); + } + + } + else if ( aError == KFmRadioErrAntennaNotConnected ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoRequestTunerControlComplete() - KFmRadioErrAntennaNotConnected"))); + iTunerControl = EStateRadioTunerControlOff; + iRadioSettings->SetHeadsetDisconnected(); + HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventHeadsetDisconnected, KErrNone ); + } + else if ( aError == KErrAlreadyExists ) + { + iTunerControl = EStateRadioTunerControlOn; + // Headset must be connected + iRadioSettings->SetHeadsetConnected(); + iFmTunerUtility->GetCapabilities( iTunerCaps ); + TInt frequency; + iFmTunerUtility->GetFrequency( frequency ); + StoreAndPublishFrequency( frequency ); + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTune, KErrNone ); + } + else if ( aError == KFmRadioErrFmTransmitterActive ) + { + iTunerControl = EStateRadioTunerControlOff; + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventFMTransmitterOn, KErrNone ); + } + else if ( aError == KFmRadioErrOfflineMode ) + { + iTunerControl = EStateRadioTunerControlOff; + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventFlightModeEnabled, KErrNone ); + } + else + { + iTunerControl = EStateRadioTunerControlOff; + } + } + +// ---------------------------------------------------- +// CRadioEngine::MrftoSetFrequencyRangeComplete +// +// ---------------------------------------------------- +// +void CRadioEngine::MrftoSetFrequencyRangeComplete( TInt aError ) + { + if ( aError == KErrNone ) + { + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTunerReady, KErrNone ); + } + + FTRACE(FPrint(_L("CRadioEngine::MrftoSetFrequencyRangeComplete() - error = %d"), aError)); + } + +// ---------------------------------------------------- +// CRadioEngine::MrftoSetFrequencyComplete +// ---------------------------------------------------- +// +void CRadioEngine::MrftoSetFrequencyComplete( TInt aError ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoSetFrequencyComplete() - aError = %d"), aError)); + + if ( !aError ) + { + iRdsReceiver->ClearRdsInformation(); + StoreAndPublishFrequency( iTempFrequency ); + if ( iTunePresetRequested ) + { + iCentralRepositoryHandler->SaveEngineSettings(); + iTunePresetRequested = EFalse; + } + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTune, aError ); + + if ( iInitializeRadioRequestExists ) + { + iInitializeRadioRequestExists = EFalse; + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventFMRadioInitialized, KErrNone ); + } + } + else + { + iInitializeRadioRequestExists = EFalse; + + FTRACE(FPrint(_L("CRadioEngine::MrftoSetFrequencyComplete() - Sending event to UI"))); + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTune, aError ); + } + } + +// ---------------------------------------------------- +// CRadioEngine::MrftoStationSeekComplete +// +// ---------------------------------------------------- +// +void CRadioEngine::MrftoStationSeekComplete( + TInt aError, + TInt aFrequency ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoStationSeekComplete() - Frequency = %d"), aFrequency)); + FTRACE(FPrint(_L("CRadioEngine::MrftoStationSeekComplete() - error = %d"), aError)); + + if ( !aError ) + { + StoreAndPublishFrequency( aFrequency ); + + iRdsReceiver->ClearRdsInformation(); + StoreAndPublishFrequency( aFrequency ); + if ( iTunePresetRequested ) + { + iCentralRepositoryHandler->SaveEngineSettings(); + iTunePresetRequested = EFalse; + } + iTuningState = EFMRadioPSTuningUninitialized; + // Process the callback first because it might change the tuning state and we must avoid switching it back and forth + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTune, aError ); + TRAP_IGNORE(iPubSub->PublishTuningStateL( iTuningState )); + + if ( iInitializeRadioRequestExists ) + { + iInitializeRadioRequestExists = EFalse; + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventFMRadioInitialized, KErrNone ); + } + } + else + { + iInitializeRadioRequestExists = EFalse; + if ( aError == KFmRadioErrAntennaNotConnected ) + { + iRadioSettings->SetHeadsetDisconnected(); + } + FTRACE(FPrint(_L("CRadioEngine::MrftoStationSeekComplete() - Sending event to UI"))); + iTuningState = EFMRadioPSTuningUninitialized; + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTune, aError ); + TRAP_IGNORE(iPubSub->PublishTuningStateL( iTuningState )); + } + } + + +// ---------------------------------------------------- +// CRadioEngine::MrftoFmTransmitterStatusChange +// The FM tuner is turned off when FM transmitter is on. +// ---------------------------------------------------- +// +void CRadioEngine::MrftoFmTransmitterStatusChange( + TBool aActive ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoFmTransmitterStatusChange() - Active = %d"), aActive)); + if ( aActive ) + { + // loses tuner control + iTunerControl = EStateRadioTunerControlOff; + } + } + + +// ---------------------------------------------------- +// CRadioEngine::MrftoAntennaStatusChange +// Called when antenna status changes. +// ---------------------------------------------------- +// +void CRadioEngine::MrftoAntennaStatusChange( + TBool aAttached ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoAntennaStatusChange() - Antenna Status = %d"), aAttached)); + if ( aAttached ) + { + if ( iTunerControl == EStateRadioTunerControlOff ) + { + iFmTunerUtility->RequestTunerControl(); + } + iRadioSettings->SetHeadsetConnected(); + TRAP_IGNORE( iPubSub->PublishAntennaStatusL( EFMRadioPSHeadsetConnected ) ); + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventHeadsetReconnected, KErrNone ); + } + else + { + iRadioSettings->SetHeadsetDisconnected(); + TRAP_IGNORE( iPubSub->PublishAntennaStatusL( EFMRadioPSHeadsetDisconnected ) ); + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventHeadsetDisconnected, KErrNone ); + } + } + + +// ---------------------------------------------------- +// CRadioEngine::FlightModeChanged +// Called when offline mode status changes +// ---------------------------------------------------- +// +void CRadioEngine::MrftoOfflineModeStatusChange( TBool aOfflineMode ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoOfflineModeStatusChange() - Offline Mode = %d"), aOfflineMode)); + + if ( aOfflineMode ) + { + HandleFlightModeEnabled(); + } + else + { + if ( iTunerControl == EStateRadioTunerControlOff ) + { + iFmTunerUtility->RequestTunerControl(); + } + HandleFlightModeDisabled(); + } + } + +// ---------------------------------------------------- +// CRadioEngine::MrftoFrequencyRangeChange +// +// ---------------------------------------------------- +// +void CRadioEngine::MrftoFrequencyRangeChange( + TFmRadioFrequencyRange FDEBUGVAR( aNewRange ) ) + { + FTRACE( FPrint(_L("CRadioEngine::MrftoFrequencyRangeChange() - Band = %d"), aNewRange ) ); + } + + // ---------------------------------------------------- +// CRadioEngine::MrftoFrequencyChange +// Called when the tuned frequency changes +// ---------------------------------------------------- +// +void CRadioEngine::MrftoFrequencyChange( + TInt aNewFrequency ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoFrequencyChange() - New Frequency = %d"), aNewFrequency)); + + if ( iRadioSettings->Frequency() != aNewFrequency ) + { + iRdsReceiver->ClearRdsInformation(); + StoreAndPublishFrequency( aNewFrequency ); + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventTune, KErrNone ); + } + } + +// ---------------------------------------------------- +// CRadioEngine::MTsoForcedMonoChanged +// Called when a client enables/disabled forced mono reception +// ---------------------------------------------------- +// +void CRadioEngine::MrftoForcedMonoChange( + TBool aForcedMono ) + { + FTRACE(FPrint(_L("CRadioEngine::MrftoForcedMonoChange() - Forced Mono = %d"), aForcedMono)); + if ( aForcedMono ) + { + iRadioSettings->SetAudioMode( EFMRadioMono ); + } + else + { + iRadioSettings->SetAudioMode( EFMRadioStereo ); + } + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventSetAudioMode, KErrNone ); + } + +// ---------------------------------------------------- +// CRadioEngine::MrftoSquelchChange +// +// error code. +// ---------------------------------------------------- +// +void CRadioEngine::MrftoSquelchChange( + TBool /*aSquelch*/ ) + { + } + + +// ---------------------------------------------------- +// CRadioEngine::MrpoStateChange This is Tuner State +// Called when the state of the tuner changes +// ---------------------------------------------------- +// +void CRadioEngine::MrpoStateChange( + TPlayerState aState, + TInt aError ) + { + FTRACE(FPrint(_L("CRadioEngine::MrpoStateChange() - State Change = %d, Error = %d"), aState, aError)); + + if ( !aError ) + { + if ( aState == ERadioPlayerPlaying ) + { + iRadioSettings->SetRadioOn(); + iCurrentRadioState = EStateRadioOn; + FTRACE(FPrint(_L("CRadioEngine::MrpoStateChange() Resource Available Error = %d"), aError )); + iRdsReceiver->StartReceiver(); + HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventRadioOn, KErrNone); + } + else + { + iRdsReceiver->StopReceiver(); + iRadioSettings->SetRadioOff(); + iCurrentRadioState = EStateRadioOff; + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventRadioOff, KErrNone ); + } + } + else + { + if ( aState == ERadioPlayerIdle && iRadioSettings->IsRadioOn() ) + { + MRadioEngineStateChangeCallback::TFMRadioNotifyEvent ret = + MRadioEngineStateChangeCallback::EFMRadioEventAudioResourcePaused; + iCurrentRadioState = EStateRadioOff; + iRdsReceiver->StopReceiver(); + iRadioSettings->SetRadioOff(); + if ( ( aError == KErrDied ) || + ( aError == KErrAccessDenied ) || + ( aError == KErrNotReady ) || + ( aError == KErrInUse ) ) + { + // check call status + if ( iSystemEventDetector->IsCallActive() ) + { + FTRACE(FPrint(_L("CRadioEngine::MrpoStateChange() EFMRadioEventCallStarted") ) ); + iInCall = ETrue; + ret = MRadioEngineStateChangeCallback::EFMRadioEventCallStarted; + } + } + else if ( aError == KErrHardwareNotAvailable ) // Radio is interrupted by FM Transmitter activation. + { + ret = MRadioEngineStateChangeCallback::EFMRadioEventFMTransmitterOn; + } + HandleCallback( ret, aError ); + } + } + if( iRadioSettings->IsRadioOn() ) + { + TRAP_IGNORE( iPubSub->PublishStateL( ETrue ) ) + } + else + { + TRAP_IGNORE + ( + iTuningState = EFMRadioPSTuningUninitialized; + iPubSub->PublishTuningStateL( iTuningState ); + iPubSub->PublishStateL( EFalse ); + ) + } + } + +// ---------------------------------------------------- +// CRadioEngine::MrpoVolumeChange +// +// ---------------------------------------------------- +// +void CRadioEngine::MrpoVolumeChange( TInt FDEBUGVAR( aVolume ) ) + { + FTRACE(FPrint(_L("CRadioEngine::MrpoVolumeChange() - Volume = %d"), aVolume) ); + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventVolumeUpdated, KErrNone ); + } + +// ---------------------------------------------------- +// CRadioEngine::MrpoMuteChange +// +// ---------------------------------------------------- +// +void CRadioEngine::MrpoMuteChange( TBool aMute ) + { + FTRACE(FPrint(_L("CRadioEngine::MrpoMuteChange() - Mute = %d"), aMute)); + + if ( aMute && !iRadioSettings->IsMuteOn() ) + { + iRadioSettings->SetMuteOn(); + HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventSetMuteState, KErrNone); + } + else if ( !aMute && iRadioSettings->IsMuteOn() ) + { + iRadioSettings->SetMuteOff(); + HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventSetMuteState, KErrNone); + } + } + +// ---------------------------------------------------- +// CRadioEngine::MrpoBalanceChange +// +// ---------------------------------------------------- +// +void CRadioEngine::MrpoBalanceChange( + TInt /*aLeftPercentage*/, + TInt /*aRightPercentage*/ ) + { + // Not supported. + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::MrpeoPresetChanged +// Observer for Presets +// ----------------------------------------------------------------------------- +void CRadioEngine::MrpeoPresetChanged( + TPresetChangeEvent /*aChange*/, + TInt /*aIndex*/ ) + { + + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::NetworkUpCallbackL +// callback notifies when networks comes up +// ----------------------------------------------------------------------------- +// +void CRadioEngine::NetworkUpCallbackL() + { +#ifndef __WINS__ + + if ( !iNetworkInfoListener ) + { + // NetworkInfoListener takes care of listening to the network id and country code. + iNetworkInfoListener = CFMRadioMobileNetworkInfoListener::NewL( *this ); + } +#endif + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::NetworkDownCallbackL +// callback notifies when network goes down +// ----------------------------------------------------------------------------- +// +void CRadioEngine::NetworkDownCallbackL() + { + // No implementation needed + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::NetworkIdChanged +// Used for notifying that the network id has changed +// ----------------------------------------------------------------------------- +// +void CRadioEngine::NetworkIdChanged() + { + // No implementation needed + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::AudioResourcesAvailableL +// This callback notifies when audio resources become available. +// ----------------------------------------------------------------------------- +// +void CRadioEngine::AudioResourcesAvailableL() + { + FTRACE( FPrint( _L("CRadioEngine::AudioResourcesAvailableL()" ) ) ); + // if iPubSub exists, then the ConstructL has been successfully completed + if ( iPubSub && !iInCall && iTunerControl == EStateRadioTunerControlOn ) + { + HandleCallback(MRadioEngineStateChangeCallback::EFMRadioEventAudioResourceAvailable, KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::AudioAutoResumeForbiddenL +// This callback notifies when audio auto resuming is forbidden. +// ----------------------------------------------------------------------------- +// +void CRadioEngine::AudioAutoResumeForbiddenL() + { + FTRACE( FPrint( _L("CRadioEngine::AudioAutoResumeForbiddenL()" ) ) ); + if ( iPubSub ) // if iPubSub exists, then the ConstructL has been successfully completed + { + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventAudioResourceLost, KErrNone ); + } + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::CallActivatedCallbackL +// This callback notifies when call becomes active. +// ----------------------------------------------------------------------------- +// +void CRadioEngine::CallActivatedCallbackL() + { + FTRACE( FPrint( _L("CRadioEngine::CallActivatedCallbackL()" ) ) ); + iInCall = ETrue; + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::CallDeactivatedCallbackL +// This callback notifies when call becomes deactive. +// ----------------------------------------------------------------------------- +// +void CRadioEngine::CallDeactivatedCallbackL() + { + FTRACE( FPrint( _L("CRadioEngine::CallDeactivatedCallbackL()" ) ) ); + iInCall = EFalse; + if ( iPubSub ) // if iPubSub exists, then the ConstructL has been successfully completed + { + HandleCallback( MRadioEngineStateChangeCallback::EFMRadioEventCallEnded, KErrNone ); + } + } + +// --------------------------------------------------------- +// CRadioEngine::RdsDataProgrammeService +// --------------------------------------------------------- +// +void CRadioEngine::RdsDataProgrammeService( const TDesC& /*aProgramService*/ ) + { + } + +// --------------------------------------------------------- +// CRadioEngine::RdsDataPsNameIsStatic +// --------------------------------------------------------- +// +void CRadioEngine::RdsDataPsNameIsStatic( TBool /*aStatic*/ ) + { + } + +// --------------------------------------------------------- +// CRadioEngine::RdsDataRadioText +// --------------------------------------------------------- +// +void CRadioEngine::RdsDataRadioText( const TDesC& /*aRadioText*/ ) + { + } + +// --------------------------------------------------------- +// CRadioEngine::RdsDataRadioTextPlus +// --------------------------------------------------------- +// +void CRadioEngine::RdsDataRadioTextPlus( const TInt /*aRTPlusClass*/, const TDesC& /*aRadioText*/ ) + { + } + +// --------------------------------------------------------- +// CRadioEngine::RdsAfSearchBegin +// --------------------------------------------------------- +// +void CRadioEngine::RdsAfSearchBegin() + { + iFrequencySetByRdsAf = ETrue; + } + +// --------------------------------------------------------- +// CRadioEngine::RdsAfSearchEnd +// --------------------------------------------------------- +// +void CRadioEngine::RdsAfSearchEnd( TUint32 /*aFrequency*/, TInt aError ) + { + if( aError != KErrNone ) + { + iFrequencySetByRdsAf = EFalse; + } + } + +// --------------------------------------------------------- +// CRadioEngine::RdsAfSearchStateChange +// --------------------------------------------------------- +// +void CRadioEngine::RdsAfSearchStateChange( TBool /*aEnabled*/ ) + { + } + +// --------------------------------------------------------- +// CRadioEngine::RdsAvailable +// --------------------------------------------------------- +// +void CRadioEngine::RdsAvailable( TBool /*aAvailable*/ ) + { + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::InitializeResourceLoadingL +// add resource file information +// ----------------------------------------------------------------------------- +// +void CRadioEngine::InitializeResourceLoadingL() + { + CCoeEnv* coeEnv = CCoeEnv::Static(); + RFs fs( coeEnv->FsSession() ); + TFileName fileName; + TFileName baseResource; + TFindFile finder( fs ); + TLanguage language( ELangNone ); + + TParsePtrC parse( KFMRadioEngineResourceFile ); + _LIT( resourceFileWildExt, ".r*" ); + + // Make sure to find all resource files, not only .rsc files as it may be so + // that there is only .r01, .r02, etc. files available + fileName.Copy( parse.Name() ); + fileName.Append( resourceFileWildExt ); + + // TFindFile applies search order that is from + // drive Y to A, then Z + CDir* entries = NULL; + TInt err = finder.FindWildByDir( fileName , KDC_RESOURCE_FILES_DIR, entries ); + delete entries; + entries = NULL; + TBool found = EFalse; + while ( !found && err == KErrNone ) + { + // Found file + fileName.Zero(); + TParsePtrC foundPath( finder.File() ); + fileName.Copy( foundPath.DriveAndPath() ); + fileName.Append( KFMRadioEngineResourceFile ); + BaflUtils::NearestLanguageFile( fs, fileName, language ); + if ( language != ELangNone && BaflUtils::FileExists( fs, fileName ) ) + { + found = ETrue; + iFMRadioEngineResourceOffset = coeEnv->AddResourceFileL( fileName ); + } + else + { + if ( language == ELangNone && + !baseResource.Compare( KNullDesC ) && + BaflUtils::FileExists( fs, fileName ) ) + { + baseResource.Copy( fileName ); + } + err = finder.FindWild( entries ); + delete entries; + entries = NULL; + } + } + + if ( !found && baseResource.Compare( KNullDesC ) ) + { + // If we found *.rsc then better to use that than nothing + if ( BaflUtils::FileExists( fs, baseResource ) ) + { + iFMRadioEngineResourceOffset = coeEnv->AddResourceFileL( baseResource ); + } + } + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::TunerFrequencyRangeForRegionId +// convert FMRadio region info to tuner utility frequency range +// ----------------------------------------------------------------------------- +// +TFmRadioFrequencyRange CRadioEngine::TunerFrequencyRangeForRegionId( const TInt aRegionId ) const + { + FTRACE( FPrint( _L("CRadioEngine::TunerFrequencyRangeForRegionId(TInt aRegionID = %d)"), aRegionId ) ); + TFmRadioFrequencyRange result = EFmRangeEuroAmerica; + switch( aRegionId ) + { + case EFMRadioRegionDefault: + { + result = EFmRangeEuroAmerica; + break; + } + case EFMRadioRegionJapan: + { + result = EFmRangeJapan; + break; + } + case EFMRadioRegionAmerica: + { + result = EFmRangeEuroAmerica; + break; + } + default: + break; + } + return result; + } + +// ----------------------------------------------------------------------------- +// CRadioEngine::GetRegionL +// determine current region +// ----------------------------------------------------------------------------- +// +EXPORT_C TFMRadioRegionSetting CRadioEngine::GetRegionL() const + { + FTRACE( FPrint( _L("CRadioEngine::GetRegionL()" ) ) ); + TInt regionCount = iCentralRepositoryHandler->CountRegions(); + TFMRadioRegionSetting reg = EFMRadioRegionNone; + + if ( iSystemEventDetector->IsNetworkCoverage() ) + { + TBool countryCodeMatch( EFalse ); + // Choose the frequency range according to country code + const TDesC& countryCode = + iNetworkInfoListener->CountryCode(); + for ( TInt i = 0 ; i < regionCount ; i++ ) + { + const RFMRadioCountryCodeArray& regionCountryCodes = + iCentralRepositoryHandler->Region( i ).CountryCodes(); + + for ( TInt j = 0 ; j < regionCountryCodes.Count() ; j++ ) + { + if ( countryCode == *regionCountryCodes[j] ) + { + // We have a match + countryCodeMatch = ETrue; + reg = iCentralRepositoryHandler->Region(i).Id(); + } + } + } + if ( !countryCodeMatch ) + { + // All regions have been searched and no direct match found, + // use default one + reg = EFMRadioRegionDefault; + } + } + else + { + if ( iCentralRepositoryHandler->RegionId() != EFMRadioRegionNone ) + { + reg = static_cast( + iCentralRepositoryHandler->RegionId() ); + } + } + return reg; + } + +// ---------------------------------------------------- +// CRadioEngine::FillListWithRegionDataL +// fill given list with fmradio regions +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::FillListWithRegionDataL( CDesC16Array& aArray ) const + { + TInt regionCount = iCentralRepositoryHandler->CountRegions(); + + for ( TInt i = 0 ; i < regionCount ; i++ ) + { + aArray.AppendL( iCentralRepositoryHandler->Region( i ).Name() ); + } + } + +// ---------------------------------------------------- +// CRadioEngine::RegionIdAtIndex +// return region from the array of supported regions +// ---------------------------------------------------- +// +EXPORT_C TFMRadioRegionSetting CRadioEngine::RegionIdAtIndex( const TInt aIndex ) const + { + return iCentralRepositoryHandler->Region( aIndex ).Id(); + } + +// ---------------------------------------------------- +// CRadioEngine::RegionId +// Return current region Id. +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::RegionId() const + { + return iCentralRepositoryHandler->RegionId(); + } + +// ---------------------------------------------------- +// CRadioEngine::SetRegionIdL +// Change the the current region Id. +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetRegionIdL( TInt aRegionId ) const + { + if ( iCentralRepositoryHandler->RegionId() != aRegionId ) + { + // Change only when necessary as it changes also the default tuned frequency + //iSetters.SetRegionIdL( aRegionId ); + iCentralRepositoryHandler->SetRegionIdL( aRegionId ); + iPubSub->PublishFrequencyDecimalCountL( + TFMRadioPSFrequencyDecimalCount( iRadioSettings->DecimalCount() ) ); + } + } + +// ---------------------------------------------------- +// CRadioEngine::RequestTunerControl +// request tuner control from RadioFmTunerUtility +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::RequestTunerControl() const + { + FTRACE( FPrint( _L("CRadioEngine::RequestTunerControl()")) ); + if ( iTunerControl == EStateRadioTunerControlUninitialized ) + { + // first request for tuner control. + iFmTunerUtility->RequestTunerControl(); + } + } + +// ---------------------------------------------------- +// CRadioEngine::DecimalCount +// return decimal count for current region MHz information +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::DecimalCount() const + { + return iCentralRepositoryHandler->DecimalCount(); + } + +// ---------------------------------------------------- +// CRadioEngine::FrequencyStepSize +// return step size for tuning. +// ---------------------------------------------------- +// +EXPORT_C TUint32 CRadioEngine::FrequencyStepSize() const + { + return iRadioSettings->FrequencyStepSize(); + } + +// ---------------------------------------------------- +// CRadioEngine::PubSubL +// Returns a reference to P&S interface +// ---------------------------------------------------- +// +EXPORT_C CFMRadioPubSub& CRadioEngine::PubSubL() const + { + User::LeaveIfNull( iPubSub ); + return *iPubSub; + } + +// ---------------------------------------------------- +// CRadioEngine::StartupCount +// increases startup count by one and returns amount of app startups. +// ---------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::UpdatedStartupCount() const + { + FTRACE( FPrint( _L("CRadioEngine::UpdatedStartupCount()" ) ) ); + iCentralRepositoryHandler->IncreaseStartupCount(); + return iRadioSettings->StartupCount(); + } + +// ---------------------------------------------------- +// CRadioEngine::CancelScanLocalStationsScan +// Cancel seek and notify UI +// ---------------------------------------------------- +// +EXPORT_C void CRadioEngine::CancelScanLocalStationsScan() + { + FTRACE( FPrint( _L("CRadioEngine::CancelScanLocalStationsScan()" ) ) ); + CancelScan(); + TInt error = KErrNone; + iStateHandler->Callback( MRadioEngineStateChangeCallback::EFMRadioEventScanLocalStationsCanceled, error ); + } + +// --------------------------------------------------------------------------- +// CRadioEngine::IsAudioRoutingPossible +// Routing is not possible when headset is not available or radio is off +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::IsAudioRoutingPossible() const + { + FTRACE( FPrint( _L("CRadioEngine::IsAudioRoutingPossible()" ) ) ); + TBool isAudioRoutingPossible = EFalse; + + TBool headsetConnected = iHeadsetObserver->WiredHeadsetConnected(); + TBool radioOn = iRadioSettings->IsRadioOn(); + + if ( headsetConnected && radioOn ) + { + isAudioRoutingPossible = ETrue; + } + + return isAudioRoutingPossible; + } + +// --------------------------------------------------------------------------- +// CRadioEngine::MusicStoreNoteDisplayed +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CRadioEngine::MusicStoreNoteDisplayed() + { + return iCentralRepositoryHandler->MusicStoreNoteDisplayed(); + } + +// --------------------------------------------------------------------------- +// CRadioEngine::SetMusicStoreNoteDisplayed +// --------------------------------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetMusicStoreNoteDisplayed() + { + iCentralRepositoryHandler->SetMusicStoreNoteDisplayed(); + } + +// --------------------------------------------------------------------------- +// CRadioEngine::MusicStoreNoteDisplayed +// --------------------------------------------------------------------------- +// +EXPORT_C TFMRadioRTPlusLevel CRadioEngine::GetRTPlusSupportLevel() + { + TInt value = iCentralRepositoryHandler->GetRTPlusSupportLevel(); + + //do not return the value directly - make sure we return a valid value + if ( value == EFMRadioAllInteractions ) + { + return EFMRadioAllInteractions; + } + return EFMRadioMusicStoreOnly; + } + +// --------------------------------------------------------------------------- +// CRadioEngine::SetCurrentPresetIndex +// sets current preset index if the preset database changes +// --------------------------------------------------------------------------- +// +EXPORT_C void CRadioEngine::SetCurrentPresetIndex( const TInt aIndex ) + { + TInt maxNumberOfPresets; + iPresetUtility->GetMaxNumberOfPresets( maxNumberOfPresets ); + + if ( ( aIndex >= KErrNotFound ) && ( aIndex < maxNumberOfPresets ) ) + { + iRadioSettings->SetCurrentPreset( aIndex ); + if ( aIndex >= 0 ) + { + // publish current preset + TRAP_IGNORE + ( + TInt frequency = 0; + TStationName name; + iPresetUtility->GetPresetL( aIndex, name, frequency ); + iPubSub->PublishChannelNameL( name ); + iPubSub->PublishChannelL( aIndex ); + ) + } + } + } + +// --------------------------------------------------------------------------- +// CRadioEngine::StoreAndPublishFrequency +// Updates the frequency into settings and P&S +// --------------------------------------------------------------------------- +// +void CRadioEngine::StoreAndPublishFrequency( TInt aFrequency ) + { + iRadioSettings->SetFrequency( aFrequency ); + TRAP_IGNORE( iPubSub->PublishFrequencyL( aFrequency ); ) + } + +// --------------------------------------------------------------------------- +// CRadioEngine::PresetUrlL +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CRadioEngine::PresetUrlL( TInt aIndex, TDes& aUrl ) + { + FTRACE( FPrint( _L("CRadioEngine::PresetUrlL( Index %d, url: %S)"), aIndex, &aUrl ) ); + TInt err = KErrNone; + TFmPresetUrl presetUrl; + + if ( presetUrl.MaxLength() <= aUrl.MaxLength() ) + { + iPresetUtility->GetPresetUrlL( aIndex, presetUrl ); + aUrl.Copy( presetUrl ); + if ( !aUrl.Length() ) + { + err = KErrNotFound; + } + } + else + { + err = KErrOverflow; + } + return err; + } + +// --------------------------------------------------------------------------- +// CRadioEngine::DeletePresetL +// Delete preset. With index -1 all preset are reseted +// --------------------------------------------------------------------------- +// +EXPORT_C void CRadioEngine::DeletePresetL( TInt aIndex ) + { + FTRACE( FPrint( _L("CRadioEngine::DeletePresetL( i: %d )"), aIndex ) ); + iPresetUtility->DeletePresetL( aIndex ); + } + +// --------------------------------------------------------------------------- +// CRadioEngine::SaveUrlToCurrentPresetL +// --------------------------------------------------------------------------- +// +EXPORT_C void CRadioEngine::SaveUrlToPresetL( TInt aIndex, const TDesC& aUrl ) + { + FTRACE( FPrint( _L("CRadioEngine::SaveUrlToCurrentPresetL( i: %d Url: %S)"), aIndex, &aUrl ) ); + TFmPresetUrl presetUrl; + if ( aUrl.Length() <= presetUrl.MaxLength() ) + { + presetUrl.Copy( aUrl ); + iPresetUtility->SetPresetUrlL( aIndex, presetUrl ); + } + } + +// End of file