/*

* Copyright (c) 2002-2004 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:  This class maintains all the current radio settings. It's also

*				 responsible for sending spontaneous events using Publish & Subscribe.

*

*/

// INCLUDE FILES

#include    "RadioServerSettings.h"

#include 	"RadioClientServer.h"

// CONSTANTS

_LIT_SECURITY_POLICY_PASS(KRadioServerReadPolicy);

_LIT_SECURITY_POLICY_C1(KRadioServerWritePolicy, ECapabilityWriteUserData);

const TInt KFMDefaultFreq 			= 87500000;	// 87.5 MHz

const TInt KJapaneseFMDefaultFreq 	= 76000000;	// 76.0 MHz

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

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

// CRadioServerSettings::CRadioServerSettings

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

// might leave.

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

//

CRadioServerSettings::CRadioServerSettings()

	:	iMonitorOn(EFalse),

		iRadioOn(EFalse),

		iAntennaAttached(ETrue),

		iOfflineMode(EFalse),

		iTransmitterActive(EFalse),

		iRange(ERsRangeFmEuroAmerica),

		iMinFreq(0),

		iMaxFreq(0),

		iFrequency(KFMDefaultFreq),

		iForceMonoEnabled(EFalse),

		iSquelchEnabled(ETrue),

		iVolume(0),

		iMute(EFalse),

		iBalanceLeft(KRadioServerBalanceMax),

		iBalanceRight(KRadioServerBalanceMax),

		iAutoSwitch(EFalse)

    {

    }

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

// CRadioServerSettings::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRadioServerSettings::ConstructL()

    {

	TInt err = RProperty::Define(KRadioServPsMonitorState, RProperty::EInt,

								 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsPlayerState, RProperty::EByteArray,

								 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

    err = RProperty::Define(ERadioServPsAntennaStatus, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsOfflineMode, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsTransmitterStatus, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

   	err = RProperty::Define(ERadioServPsFrequency, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

   	err = RProperty::Define(ERadioServPsFrequencyRange, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsForceMonoReception, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsSquelch, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsVolume, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsMuteStatus, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsBalance, RProperty::EByteArray,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsRdsSignalStatus, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsAutoSwitchStatus, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsProgrammeIdentification, RProperty::EInt,

							KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsProgrammeType, RProperty::EInt,

							 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsProgrammeService, RProperty::EText,

							 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsRadioText, RProperty::EText,

							 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

  err = RProperty::Define(ERadioServPsRadioTextPlusObjects, RProperty::EByteArray,

               KRadioServerReadPolicy, KRadioServerWritePolicy);

  if ( err != KErrAlreadyExists)

    {

    User::LeaveIfError(err);

    }

	err = RProperty::Define(ERadioServPsClockTime, RProperty::EByteArray,

							 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	err = RProperty::Define(ERadioServPsTrafficAnnouncementStatus, RProperty::EInt,

							 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

    err = RProperty::Define(ERadioServPsAfSearchBegin, RProperty::EInt,

							 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

    err = RProperty::Define(ERadioServPsAfSearchEnd, RProperty::EByteArray,

							 KRadioServerReadPolicy, KRadioServerWritePolicy);

	if ( err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	}

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

// CRadioServerSettings::NewL

// Two-phased constructor.

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

//

CRadioServerSettings* CRadioServerSettings::NewL()

    {

    CRadioServerSettings* self = new( ELeave ) CRadioServerSettings();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CRadioServerSettings::~CRadioServerSettings()

    {

	RProperty::Delete(KRadioServerPropertyCategory, KRadioServPsMonitorState);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsPlayerState);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsAntennaStatus);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsOfflineMode);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsTransmitterStatus);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsFrequency);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsFrequencyRange);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsForceMonoReception);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsSquelch);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsVolume);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsMuteStatus);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsBalance);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsRdsSignalStatus);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsAutoSwitchStatus);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsProgrammeIdentification);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsProgrammeType);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsProgrammeService);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsRadioText);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsRadioTextPlusObjects);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsClockTime);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsTrafficAnnouncementStatus);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsAfSearchBegin);

	RProperty::Delete(KRadioServerPropertyCategory, ERadioServPsAfSearchEnd);

    }

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

// CRadioServerSettings::SetRadioMonitorStatus

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

//

void CRadioServerSettings::SetRadioMonitorStatus(

	TBool aMonitorOn,

	TBool aPublish )

    {

    if ( iMonitorOn != aMonitorOn )

		{

		iMonitorOn = aMonitorOn;

		if ( aPublish)

			{

			RProperty::Set(KRadioServerPropertyCategory,

						   KRadioServPsMonitorState,

						   iMonitorOn);

			}

		}

    }

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

// CRadioServerSettings::SetRadioOn

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

//

void CRadioServerSettings::SetRadioOn(

	TBool aPublish )

    {

    if ( !iRadioOn )

		{

		iRadioOn = ETrue;

		if ( aPublish)

			{

			TPckgBuf<TRsSettingsData> data;

			data().iError = KErrNone;

			data().iData1 = ETrue;

			RProperty::Set(KRadioServerPropertyCategory,

						   ERadioServPsPlayerState,

						   data);

			}

		}

    }

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

// CRadioServerSettings::SetRadioOff

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

//

void CRadioServerSettings::SetRadioOff(

	TInt aError,

	TBool aPublish )

    {

    if ( iRadioOn )

		{

		iRadioOn = EFalse;

		if ( aPublish)

			{

			TPckgBuf<TRsSettingsData> data;

			data().iError = aError;

			data().iData1 = EFalse;

			RProperty::Set(KRadioServerPropertyCategory,

						   ERadioServPsPlayerState,

						   data);

			}

		}

    }

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

// CRadioServerSettings::IsRadioOn

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

//

TBool CRadioServerSettings::IsRadioOn() const

    {

	return iRadioOn;

    }

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

// CRadioServerSettings::SetAntennaStatus

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

//

void CRadioServerSettings::SetAntennaStatus(

	TBool aAttached,

	TBool aPublish )

    {

    if ( iAntennaAttached != aAttached )

		{

		iAntennaAttached = aAttached;

		if ( aPublish)

			{

			RProperty::Set(KRadioServerPropertyCategory,

		        	       ERadioServPsAntennaStatus,

		        	       iAntennaAttached);

			}

		}

    }

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

// CRadioServerSettings::IsAntennaAttached

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

//

TBool CRadioServerSettings::IsAntennaAttached() const

    {

	return iAntennaAttached;

    }

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

// CRadioServerSettings::SetOfflineModeStatus

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

//

void CRadioServerSettings::SetOfflineModeStatus(

	TBool aOfflineMode,

	TBool aPublish )

    {

    if ( iOfflineMode != aOfflineMode )

		{

		iOfflineMode = aOfflineMode;

		if ( aPublish)

			{

			RProperty::Set(KRadioServerPropertyCategory,

						   ERadioServPsOfflineMode,

						   iOfflineMode);

			}

		}

    }

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

// CRadioServerSettings::IsOfflineModeEnabled

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

//

TBool CRadioServerSettings::IsOfflineModeEnabled() const

    {

	return iOfflineMode;

    }

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

// CRadioServerSettings::SetTransmitterStatus

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

//

void CRadioServerSettings::SetTransmitterStatus(

	TBool aActive,

	TBool aPublish )

    {

    if ( iTransmitterActive != aActive )

		{

		iTransmitterActive = aActive;

		if ( aPublish)

			{

			RProperty::Set(KRadioServerPropertyCategory,

						   ERadioServPsTransmitterStatus,

						   iTransmitterActive);

			}

		}

    }

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

// CRadioServerSettings::IsTransmitterActive

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

//

TBool CRadioServerSettings::IsTransmitterActive() const

    {

	return iTransmitterActive;

    }

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

// CRadioServerSettings::SetFrequency

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

//

void CRadioServerSettings::SetFrequency(

	TInt aFrequency,

	TBool aPublish )

	{

    if ( iFrequency != aFrequency )

		{

    	iFrequency = aFrequency;

		if ( aPublish)

			{

			RProperty::Set(KRadioServerPropertyCategory,

						   ERadioServPsFrequency,

						   iFrequency);

			}

    	}

    }

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

// CRadioServerSettings::Frequency

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

//

TInt CRadioServerSettings::Frequency() const

    {

	return iFrequency;

    }

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

// CRadioServerSettings::SetFrequencyRange

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

//

void CRadioServerSettings::SetFrequencyRange(

	TRsFrequencyRange aRange,

	TInt aMinFreq,

	TInt aMaxFreq,

	TBool aPublish )

    {

	iMinFreq = aMinFreq;

	iMaxFreq = aMaxFreq;

    if( iRange != aRange )

    	{

    	iRange = aRange;

	    if ( aRange == ERsRangeFmEuroAmerica )

	    	{

			iFrequency = KFMDefaultFreq;

			}

		else if ( aRange == ERsRangeFmJapan )

			{

			iFrequency = KJapaneseFMDefaultFreq;

			}

		if ( aPublish)

			{

			RProperty::Set(KRadioServerPropertyCategory,

		              	   ERadioServPsFrequencyRange,

		                   iRange);

			}

    	}

    }

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

// CRadioServerSettings::FrequencyRange

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

//

TRsFrequencyRange CRadioServerSettings::FrequencyRange() const

    {

	return iRange;

    }

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

// CRadioServerSettings::GetFrequencyRange

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

//

TInt CRadioServerSettings::GetFrequencyRange(

	TRsFrequencyRange& aRange,

	TInt& aMinFreq,

	TInt& aMaxFreq ) const

	{

	TInt err = KErrNone;

	if ( iMinFreq != 0 )

		{

		aRange = iRange;

		aMinFreq = iMinFreq;

		aMaxFreq = iMaxFreq;

		}

	else

		{

		err = KErrNotFound;

		}

	return err;

	}

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

// CRadioServerSettings::SetForcedMonoStatus

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