fmradio/fmradioengine/src/fmradioengine.cpp
author Simon Howkins <simonh@symbian.org>
Mon, 15 Nov 2010 17:46:43 +0000
branchRCL_3
changeset 63 c80bbe28af4f
parent 46 93c594350b9a
permissions -rw-r--r--
Adjusted to avoid exports, etc, from a top-level bld.inf

/*
* 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 <AudioOutput.h>
#include <AccMonitor.h>
#include <bautils.h>
#include <coemain.h>
#include <data_caging_path_literals.hrh>

#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<TReal> ( maxVolume ) / KFMRadioNumberOfVolumeSteps );
    
    
    // Get a preset utility
    iPresetUtility = CRadioFmPresetUtility::NewL( *this );
    
#ifdef __WINS__
    iRdsReceiver = CFMRadioRdsReceiverSimulator::NewL( *iRadioSettings );
    static_cast<CFMRadioRdsReceiverSimulator*> ( 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<TFMRadioRegionSetting>( 
                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