/*

* Copyright (c) 2005 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:  Contains implementation of the TRadioSettings class, which holds 

*                       the RadioEngine settings.

*

*/

//  INCLUDES

#include "fmradioengine.h"

#include "fmradioengineradiosettings.h"

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

// ----------------------------------------------------

// TRadioSettings::TRadioSettings

// Default class constructor.

// ----------------------------------------------------

//

TRadioSettings::TRadioSettings():

                    iFMRadioHeadsetVolume( KDefaultRadioVolume ),

                    iFMRadioSpeakerVolume( KDefaultRadioVolume ),

                    iCurrentPreset( 0 ),

                    iFrequency( KDefaultRadioFrequency ),

                    iMaxFrequency( 0 ),

                    iMinFrequency( 0 ),

                    iFrequencyStepSize( 0 ),

                    iDecimalCount( 0 ),

                    iAudioMode( CRadioEngine::EFMRadioStereo ),

                    iAudioOutput(CRadioEngine::EFMRadioOutputHeadset ),

                    iMuteOn(EFalse),

                    iRadioOn( EFalse),

                    iRadioMode( CRadioEngine::ERadioPresetMode ),

                    iIsHeadsetConnected( EFalse ),

                    iFlightModeEnabled( EFalse ),

                    iStartupCount( 0 ),

                    iRdsAfSearchEnabled( EFalse ),

                    iJapanRegionAllowed( ETrue )

    {

    }

// ----------------------------------------------------

// TRadioSettings::Volume

// retrieve current headset volume level

// Returns: iFMRadioHeadsetVolume: headset volume

// ----------------------------------------------------

//

TInt TRadioSettings::HeadsetVolume() const

    {

    return iFMRadioHeadsetVolume;

    }

// ----------------------------------------------------

// TRadioSettings::SpeakerVolume

// retrieve current speaker volume level

// Returns: iFMRadioSpeakerVolume: speaker volume

// ----------------------------------------------------

//

TInt TRadioSettings::SpeakerVolume() const

    {

    return iFMRadioSpeakerVolume;

    }

// ----------------------------------------------------

// TRadioSettings::CurrentPreset

// retrieve currently selected channel

// Returns: iCurrentPreset: current preset index number

// ----------------------------------------------------

//

TInt TRadioSettings::CurrentPreset() const

    {

    	return iCurrentPreset;

    }

// ----------------------------------------------------

// TRadioSettings::Frequency

// retrieve current frequency

// Returns: iFrequency: current frequency

// ----------------------------------------------------

//

TInt TRadioSettings::Frequency() const

    {

    return iFrequency;

    }

// ----------------------------------------------------

// TRadioSettings::MaxFrequency

// retrieve max frequency

// ----------------------------------------------------

//

TUint32 TRadioSettings::MaxFrequency() const

    {

    return iMaxFrequency;

    }

// ----------------------------------------------------

// TRadioSettings::MinFrequency

// retrieve min frequency

// ----------------------------------------------------

//

TUint32 TRadioSettings::MinFrequency() const

    {

    return iMinFrequency;

    }

// ----------------------------------------------------

// TRadioSettings::FrequencyStepSize

// return step size for tuning

// ----------------------------------------------------

//

TUint32 TRadioSettings::FrequencyStepSize() const

    {

    return iFrequencyStepSize;

    }

// ----------------------------------------------------

// TRadioSettings::DecimalCount

// Returns decimal count for current region MHz information 

// ----------------------------------------------------

//

TInt TRadioSettings::DecimalCount() const

    {

    return iDecimalCount;

    }	

// ----------------------------------------------------

// TRadioSettings::AudioMode

// retrieve current audio mode (stereo or mono)

// Returns: iAudioMode: current mode

// ----------------------------------------------------

//

CRadioEngine::TFMRadioAudioMode TRadioSettings::AudioMode() const

    {

    return iAudioMode;

    }

// ----------------------------------------------------

// TRadioSettings::AudioOutput

// retrieve current audio output (headset/ihf)

// Returns: iAudioOutput: current audio output

// ----------------------------------------------------

//

CRadioEngine::TFMRadioAudioOutput TRadioSettings::AudioOutput() const

    {

    return iAudioOutput;

    }

// ----------------------------------------------------

// TRadioSettings::IsMuteOn

// retrieve current mute state (on/off)

// Returns: iMuteOn: mute flag

// ----------------------------------------------------

//

TBool TRadioSettings::IsMuteOn() const

    {

    return iMuteOn;

    }

// ----------------------------------------------------

// TRadioSettings::IsRadioOn

// retrieve current radio on state (on/off)

// Returns: iRadioOn: a flag indicating radio on/off

// ----------------------------------------------------

//

TBool TRadioSettings::IsRadioOn() const

    {

    return iRadioOn;

    }

// ----------------------------------------------------

// TRadioSettings::RadioMode

// retrieve the current radio mode (preset or direct frequency)

// Returns: iRadioMode: a flag indicating radio mode

// ----------------------------------------------------

//

CRadioEngine::TRadioMode TRadioSettings::RadioMode() const

    {

    return iRadioMode;

    }

// ----------------------------------------------------

// TRadioSettings::IsHeadsetConnected

// retrieve the current headset mode (connected or disconnected)

// Returns: iIsHeadsetConnected: a flag indicating if headset is connected

// ----------------------------------------------------

//

TBool TRadioSettings::IsHeadsetConnected() const

    {

    return iIsHeadsetConnected;

    }

// ----------------------------------------------------

// TRadioSettings::IsFlightModeEnabled

// retrieve the current flight mode status (on/off)

// Returns: iFlightModeEnabled: a flag indicating if flight mode is enabled

// ----------------------------------------------------

//

TBool TRadioSettings::IsFlightModeEnabled() const

    {

    return iFlightModeEnabled;

    }

// ----------------------------------------------------

// TRadioSettings::IsRdsAfSearchEnabled

// ----------------------------------------------------

//

EXPORT_C TBool TRadioSettings::IsRdsAfSearchEnabled()

	{

	return iRdsAfSearchEnabled;

	}

// ----------------------------------------------------

// TRadioSettings::SetHeadsetVolume

// set the current fm radio headset volume

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetHeadsetVolume(

    const TInt aVolume) // the new volume

    {

    iFMRadioHeadsetVolume = aVolume;

    }

// ----------------------------------------------------

// TRadioSettings::SetSpeakerVolume

// set the current fm radio speaker volume

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetSpeakerVolume(

    const TInt aVolume)  // new volume

	  {

	  iFMRadioSpeakerVolume = aVolume;

	  }

// ----------------------------------------------------

// TRadioSettings::SetCurrentPreset

// set the current preset

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetCurrentPreset(

    const TInt aChannel) //new channel to be set

    {

    	iCurrentPreset = aChannel;

    }

// ----------------------------------------------------

// TRadioSettings::SetFrequency

// set the current frequency

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetFrequency(

    const TInt aFrequency) // new frequency

    {

    	iFrequency = aFrequency;

    //	if (iFrequency < 87500000 || iFrequency > 108000000)

    //		iFrequency = 87500000;

    }

// ----------------------------------------------------

// TRadioSettings::SetMaxFrequency

// set the max frequency

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetMaxFrequency( const TUint32 aMaxFrequency )

	{

	iMaxFrequency = aMaxFrequency;

	}

// ----------------------------------------------------

// TRadioSettings::SetMinFrequency

// set min frequency

// Returns: none

// ----------------------------------------------------

//

 void TRadioSettings::SetMinFrequency( const TUint32 aMinFrequency )

	{

	iMinFrequency = aMinFrequency;

	}

 // ----------------------------------------------------

 // TRadioSettings::SetFrequencyStepSize

 // set step size for manual tuning.

 // Returns: none

 // ----------------------------------------------------

 //

 void TRadioSettings::SetFrequencyStepSize( const TUint32 aFrequencyStepSize )

	{

	iFrequencyStepSize = aFrequencyStepSize;

	}

 // ----------------------------------------------------

 // TRadioSettings::SetDecimalCount

 // Set decimal count for current region MHz information 

 // Returns: none

 // ----------------------------------------------------

 //

 void TRadioSettings::SetDecimalCount( const TInt aDecimalCount )

	{

	iDecimalCount = aDecimalCount;

	}	

// ----------------------------------------------------

// TRadioSettings::SetAudioMode

// set the current audio mode

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetAudioMode(

    const CRadioEngine::TFMRadioAudioMode aAudioMode) // new audio mode

    {

    iAudioMode = aAudioMode;

    }

// ----------------------------------------------------

// TRadioSettings::SetAudioOutput

// set the current audio output

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetAudioOutput(

    const CRadioEngine::TFMRadioAudioOutput aAudioOutput) // new audio output

    {

    iAudioOutput = aAudioOutput;

    }

// ----------------------------------------------------

// TRadioSettings::SetMuteOn

// set mute state to on

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetMuteOn()

    {

    iMuteOn = ETrue;

    }

// ----------------------------------------------------

// TRadioSettings::SetMuteOff

// set mute state to off

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetMuteOff()

    {

    iMuteOn = EFalse;

    }

// ----------------------------------------------------

// TRadioSettings::SetRadioOn

// set radio state to "on"

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetRadioOn()

    {

    iRadioOn = ETrue;

    }

// ----------------------------------------------------

// TRadioSettings::SetRadioOff

// set radio state to "off"

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetRadioOff()

    {

    iRadioOn = EFalse;

    }

// ----------------------------------------------------

// TRadioSettings::SetRadioMode

// set radio mode

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetRadioMode(

    const CRadioEngine::TRadioMode aRadioMode) // new radio mode

    {

    iRadioMode = aRadioMode;

    }

// ----------------------------------------------------

// TRadioSettings::SetHeadsetConnected

// set headset connected

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetHeadsetConnected()

    {

    iIsHeadsetConnected = ETrue;

    }

// ----------------------------------------------------

// TRadioSettings::SetHeadsetDisconnected

// set headset disconnected

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetHeadsetDisconnected()

    {

    iIsHeadsetConnected = EFalse;

    }

// ----------------------------------------------------

// TRadioSettings::SetFlightMode

// set flightmode status

// Returns: none

// ----------------------------------------------------

//

void TRadioSettings::SetFlightMode( 

    TBool aEnabled) // indicating enable/disable

    {

    iFlightModeEnabled = aEnabled;

    }

// ----------------------------------------------------

// TRadioSettings::SetStartupCount

// set startup count

// ----------------------------------------------------

//	

void TRadioSettings::SetStartupCount( const TInt aStartupCount )

	{

	iStartupCount = aStartupCount;	

	}

// ----------------------------------------------------

// TRadioSettings::StartupCount

// return startup count

// ----------------------------------------------------

//	

TInt TRadioSettings::StartupCount() const

	{

	return iStartupCount;

	}

// ----------------------------------------------------

// TRadioSettings::SetRdsAfSearchEnabled

// ----------------------------------------------------

//

void  TRadioSettings::SetRdsAfSearchEnabled()

	{

	iRdsAfSearchEnabled = ETrue;

	}

// ----------------------------------------------------

// TRadioSettings::SetRdsAfSearchDisabled

// ----------------------------------------------------

//

void  TRadioSettings::SetRdsAfSearchDisabled()

	{

	iRdsAfSearchEnabled = EFalse;

	}

// ----------------------------------------------------

// TRadioSettings::SetJapanRegionAllowed

// ----------------------------------------------------

//

void  TRadioSettings::SetJapanRegionAllowed( const TBool aAllowed )

	{

	iJapanRegionAllowed = aAllowed;

	}	

// ----------------------------------------------------

// TRadioSettings::IsJapanRegionAllowed

// ----------------------------------------------------

//

TBool TRadioSettings::IsJapanRegionAllowed() const

	{

	return iJapanRegionAllowed;	

	}	

// end of file