/*

* 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:	

*			Contains implementation of the CAdaptation class.

*			Which holds RadioServer Console Test.

*

*/

// INCLUDE FILES

#include 	<e32svr.h>

// CONSTANTS

const TInt KReqTunerOn				= 1;

const TInt KReqTunerOff				= 2;

const TInt KReqSetFrequencyRange	= 3;

const TInt KReqSetFrequency			= 4;

const TInt KReqStationSeek			= 5;

const TInt KReqAudioMode			= 6;

const TInt KReqSetAudioMode			= 7;

const TInt KReqMaxSignalStrength	= 8;

const TInt KReqSignalStrength		= 9;

const TInt KReqSquelch				= 10;

const TInt KReqSetSquelch			= 11;

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

const TInt KReqStationSeekByPTY		= 12;

const TInt KReqStationSeekByTA		= 13;

const TInt KReqStationSeekByTP		= 14;

const TInt KReqGetFreqByPTY			= 15;

const TInt KReqGetFreqByTA			= 16;

const TInt KReqGetPSByPTY			= 17;

const TInt KReqGetPSByTA			= 18;

const TInt KEuroAmericaMin	=  87500000;

const TInt KEuroAmericaMax	= 108000000;

const TInt KJapanMin		=  76000000;

const TInt KJapanMax		=  90000000;

/*

KCBI 	 90.9	PTY = KRdsPtyReligion

KLTY 	 94.9	PTY = KRdsPtyReligion

KVIL	103.7	PTY = KRdsPtyLightClassical

KHKS	106.1	PTY = KRdsPtyRockMusic

*/

const TInt KFrequency1	=	 90900000;	// TA, TP

const TInt KFrequency2	=	 94900000;	// Alternate Frequency of KFrequency1

const TInt KFrequency3	=	103700000;

const TInt KFrequency4	=	106100000;	// TP

// DATA TYPES

struct TRadioMessageRequestData

	{

	TSglQueLink iLink;

	TInt iRequest;

	TInt iError;

	};

// ============================= LOCAL FUNCTIONS ===============================

/**

*  Class CTuner

*  @lib FMRadioTunerControlStub.lib

*  @since Series 60 3.0

*/

class CTuner : public CTimer

    {

	public:

		static CTuner* NewL( MFMRadioTunerControlObserver& aObserver )

			{

			CTuner* self = new( ELeave ) CTuner(aObserver);

			CleanupStack::PushL( self );

		    self->ConstructL();

		    CleanupStack::Pop();

		    return self;

			};

		virtual ~CTuner()

			{

			iFreqList.Close();

			iPsList.Close();

			iRTplusTags.Close();

			if ( IsActive() )

				{

				Cancel();

				}

			TRadioMessageRequestData* data;

			while ( !iRequestQue.IsEmpty() )

				{

				data = iRequestQue.First();

				iRequestQue.Remove(*data);

				delete data;

				}

			};

		void CompleteRequest( TInt aRequest, TInt aError )

			{

			TRadioMessageRequestData *data = new (ELeave) TRadioMessageRequestData;

			data->iRequest = aRequest;

			data->iError = aError;

			// Add it to the queue

			iRequestQue.AddLast(*data);

			if ( !IsActive() )

				{

				After(500000);	// 0.5 sec by default

				}

			};

		void Reset()

			{

			iTunerOn = EFalse;

			iRange = EFMRadioFrequencyEuroAmerica;

			iFrequency = KEuroAmericaMin;

			iSigStrength = 0;

			iMode = EFMRadioAudioStereo;

			iSquelch = ETrue;

			ResetRds();

			};

		void ResetRds()

			{

			iNotifyOn = EFalse;

			iRdsSignal = EFalse;

			iRdsData = 0;

			iAutoSwitch = EFalse;

			iFreqList.Reset();

			iPsList.Reset();

			iPi = 0;

			iPty = KRdsPtyNone;

			iPs = _L8("");

			iRt = _L8("");

			iRTplusTags.Reset();

			// Hardcoded to 2007/11/10 7:35

			iCt.Set(2007,ENovember,10,7,35,0,0);

			};

		void SendRdsData()

			{

			// Make sure we are still in RDS channel

			if ( !iRdsSignal || !iNotifyOn )

				{

				return;

				}

			if( iRdsData & ERdsProgrammeIdentification )

				{

				iRdsObserver->RdsDataPI(iPi);

				}

			if( iRdsData & ERdsProgrammeType )

				{

				iRdsObserver->RdsDataPTY(iPty);

				}

			if( iRdsData & ERdsProgrammeService )

				{

				iRdsObserver->RdsDataPS(iPs);

				}

			if( iRdsData & ERdsRadioText )

				{

				iRdsObserver->RdsDataRT(iRt, iRTplusTags);

				}

			if( iRdsData & ERdsClockTime )

				{

				iRdsObserver->RdsDataCT(iCt);

				}

			};

		void SendRdsAf(TBool aBegin)

			{

			if (aBegin)

				{

				iRdsObserver->RdsSearchBeginAF();

				}

			else

				{

				iFrequency = KFrequency2;

				iSigStrength = 2;

				iPs = _L8("KLTY");

				iRdsObserver->RdsSearchEndAF(iError, iFrequency);

				}

			};

    private:

		void DoCancel()

			{};

		void RunL()

			{

			TRadioMessageRequestData* data;

			data = iRequestQue.First();

			iRequestQue.Remove(*data);

			iRequest = data->iRequest;

			iError = data->iError;

			delete data;

			switch (iRequest)

				{

				case KReqTunerOn:

					iObserver->TunerOnComplete(iError);

					break;

				case KReqTunerOff:

					iObserver->TunerOffComplete(iError);

					break;

				case KReqSetFrequencyRange:

					iObserver->SetFrequencyRangeComplete(iError);

					break;

				case KReqSetFrequency:

					iObserver->SetFrequencyComplete(iError);

					break;

				case KReqStationSeek:

					iObserver->StationSeekComplete(iError, iFrequency);

					break;

				case KReqAudioMode:

					iObserver->AudioModeComplete(iError, iMode);

					break;

				case KReqSetAudioMode:

					iObserver->SetAudioModeComplete(iError);

					break;

				case KReqMaxSignalStrength:

					iObserver->MaxSignalStrengthComplete(iError, 15);

					break;

				case KReqSignalStrength:

					iObserver->SignalStrengthComplete(iError, iSigStrength);

					break;

				case KReqSquelch:

					iObserver->SquelchComplete(iError, iSquelch);

					break;

				case KReqSetSquelch:

					iObserver->SetSquelchComplete(iError);

					break;

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

//		RDS

				case KReqStationSeekByPTY:

					iRdsObserver->StationSeekByPTYComplete(iError, iFrequency);

					break;

				case KReqStationSeekByTA:

					iRdsObserver->StationSeekByTAComplete(iError, iFrequency);

					break;

				case KReqStationSeekByTP:

					iRdsObserver->StationSeekByTPComplete(iError, iFrequency);

					break;

				case KReqGetFreqByPTY:

					iRdsObserver->GetFreqByPTYComplete(iError, iFreqList);

					break;

				case KReqGetFreqByTA:

					iRdsObserver->GetFreqByTAComplete(iError, iFreqList);

					break;

				case KReqGetPSByPTY:

					iRdsObserver->GetPSByPTYComplete(iError, iPsList);

					break;

				case KReqGetPSByTA:

					iRdsObserver->GetPSByTAComplete(iError, iPsList);

					break;

//		RDS

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

				default:

					break;

				}

			// Process the next item in the queue if any

			if ( !iRequestQue.IsEmpty() )

				{

				// there is at least one element in the linked list

				After(100000);	// 0.1 sec by default

				}

			};

    private:

        CTuner( MFMRadioTunerControlObserver& aObserver )

        	:	CTimer(EPriorityStandard),

        		iObserver(&aObserver),

        		iRdsObserver(NULL),

        		iRequestQue(_FOFF( TRadioMessageRequestData, iLink ))

        	{};

        void ConstructL()

        	{

        	CTimer::ConstructL();

			CActiveScheduler::Add(this);

			Reset();

			};

    private:    // Data

    	// Tuner observer

    	MFMRadioTunerControlObserver* iObserver;

		// Rds observer

		MRdsControlObserver* iRdsObserver;

		// Request queue

		TSglQue<TRadioMessageRequestData> iRequestQue;

    	// Outstanding request

    	TInt iRequest;

    	TInt iError;

		// Tuner data

    	TBool iTunerOn;

    	TFMRadioFrequencyRange iRange;

		TInt iFrequency;

		TInt iSigStrength;

		TFMRadioAudioMode iMode;

		TBool iSquelch;

		// RDS data

    	TBool iNotifyOn;

		TBool iRdsSignal;

		TUint32 iRdsData;

		TBool iAutoSwitch;

		RArray<TInt> iFreqList;

		RArray<TRdsPSName> iPsList;

		TInt iPi;

		TRdsProgrammeType iPty;

		TRdsPSName iPs;

		TRdsRadioText iRt;

		RArray<TRdsRTplusTag> iRTplusTags;

		TDateTime iCt;

	private:    // Friend classes

		friend class CAdaptation;

		friend class CRdsGenerator;

	};

/**

*  Class CRdsGenerator

*  @lib FMRadioTunerControlStub.lib

*  @since Series 60 3.2

*/

class CRdsGenerator : public CTimer

    {

	public:

		static CRdsGenerator* NewL(CTuner& aTuner)

			{

			CRdsGenerator* self = new( ELeave ) CRdsGenerator(aTuner);

			CleanupStack::PushL( self );

		    self->ConstructL();

		    CleanupStack::Pop();

		    return self;

			};

		virtual ~CRdsGenerator()

			{

			if ( IsActive() )

				{

				Cancel();

				}

			};

		void Start()

			{

			if ( IsActive() )

				{

				Cancel();

				}

			After(1000000);	// 1 sec

			};

    private:

		void DoCancel()

			{};

		void RunL()

			{

			iTuner->SendRdsData();

			};

    private:

        CRdsGenerator( CTuner& aTuner )

        	:	CTimer(EPriorityStandard),

        		iTuner(&aTuner)

        	{};

        void ConstructL()

        	{

        	CTimer::ConstructL();

			CActiveScheduler::Add(this);

			};

    private:    // Data

    	// Tuner

    	CTuner* iTuner;

	};

/**

*  Class CAfSwitcher

*  @lib FMRadioTunerControlStub.lib

*  @since Series 60 3.2

*/

class CAfSwitcher : public CTimer

    {

	public:

		static CAfSwitcher* NewL(CTuner& aTuner)

			{

			CAfSwitcher* self = new( ELeave ) CAfSwitcher(aTuner);

			CleanupStack::PushL( self );

		    self->ConstructL();

		    CleanupStack::Pop();

		    return self;

			};

		virtual ~CAfSwitcher()

			{

			if ( IsActive() )

				{

				Cancel();

				}

			};

		void Start()

			{

			if ( IsActive() )

				{

				Cancel();

				}

			iBegin = ETrue;

			After(3000000);	// 3 sec

			};

    private:

		void DoCancel()

			{};

		void RunL()

			{

			iTuner->SendRdsAf(iBegin);

			if (iBegin)

				{

				iBegin = EFalse;

				After(2000000);	// 2 sec

				}

			};

    private:

        CAfSwitcher( CTuner& aTuner )

        	:	CTimer(EPriorityStandard),

        		iTuner(&aTuner),

        		iBegin(EFalse)

        	{};

        void ConstructL()

        	{

        	CTimer::ConstructL();

			CActiveScheduler::Add(this);

			};

    private:    // Data

    	// Tuner

    	CTuner* iTuner;

    	TBool iBegin;

	};

EXPORT_C CFMRadioTunerControl* CFMRadioTunerControl::NewL(

	MFMRadioTunerControlObserver& aObserver )

	{

	return CAdaptation::NewL(aObserver);

	}

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

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

// CAdaptation::CAdaptation

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

// might leave.

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

//

CAdaptation::CAdaptation()

	:	iTuner(NULL),

		iRds(NULL),

		iRdsAf(NULL)

    {

    }

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

// CAdaptation::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAdaptation::ConstructL(

	MFMRadioTunerControlObserver& aObserver )

    {

	iTuner = CTuner::NewL(aObserver);

	iRds = CRdsGenerator::NewL(*iTuner);

	iRdsAf = CAfSwitcher::NewL(*iTuner);

    }

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

// CAdaptation::NewL

// Two-phased constructor.

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

//

CAdaptation* CAdaptation::NewL(

	MFMRadioTunerControlObserver& aObserver )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL(aObserver);

    CleanupStack::Pop();

    return self;

    }

// Destructor

CAdaptation::~CAdaptation()

    {

	delete iRdsAf;

	delete iRds;

	delete iTuner;

    }

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

//

void CAdaptation::TunerOn(

	TFMRadioFrequencyRange aRange,

	TInt aFrequency )

	{

	if ( ValidFrequency(aRange, aFrequency) )

		{

		iTuner->iTunerOn = ETrue;

		iTuner->iRange = aRange;