/*

* Copyright (c) 2002 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:  MmfTsTone class member functions

*

*/

#include "TonePlayer.h"

#include "TemplateParameters.h"

#include "DTMFParameters.h"

const TInt CTonePlayer::KPlayerActionPlay = 1;

const TInt CTonePlayer::KPlayerActionReportVolume = 2;

const TInt CTonePlayer::KPlayerActionStop = 3;

const TInt CTonePlayer::KPlayerActionCancelPrepare = 4;

const TInt CTonePlayer::KPlayerActionPrepareFileSequence = 5;

const TInt CTonePlayer::KPlayerActionPrepareFixedSequence = 6;

const TInt CTonePlayer::KPlayerActionPrepareTone = 7;

const TInt CTonePlayer::KPlayerActionPrepareDualTone = 8;

const TInt CTonePlayer::KPlayerActionPrepareDTMFSequence = 9;

const TInt CTonePlayer::KPlayerActionPrepareDesSequence = 10;

const TInt CTonePlayer::KPlayerActionChangeVolumeToMax = 11;

const TInt CTonePlayer::KPlayerActionChangeVolumeToAvg = 12;

const TInt CTonePlayer::KPlayerActionChangeVolumeToZero = 13;

// Frequency and duration of the tone to be played

/*

CTonePlayer::CTonePlayer(CLogger *aLogger)

	:	iSupervisor(0), iId(0), iFinalError(KErrNone), iLogger(aLogger), 

		iLastPrepareError(KErrNone), iPrepareCalledCounter(0),

		iExitEventTarget(0), iExitEventParameters(0)

		//, iLastPlayTime(0), iLastStopTime(0)

	{

	iFreeToPlay=EFalse;

	}

*/

/*

CTonePlayer* CTonePlayer::NewL(CLogger *aLogger, TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration, TBool aPlayInmediately)

	{

	CTonePlayer* self = NewLC(aLogger, aFrequency, aDuration, aPlayInmediately);

	CleanupStack::Pop(self);

	return self;

	}

*/

/*

CTonePlayer* CTonePlayer::NewLC(CLogger *aLogger, TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration, TBool aPlayInmediately)

	{

	CTonePlayer* self = new(ELeave)CTonePlayer(aLogger);

	CleanupStack::PushL(self);

	self->ConstructL(aFrequency, aDuration, aPlayInmediately);

	return self;

	}

*/

void CTonePlayer::ConstructL(TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration, TBool aPlayInmediately)

	{

	iFrequency=aFrequency;

	iDuration=aDuration;

	iPlayInmediately=aPlayInmediately;

	iMdaAudioToneUtility = CMdaAudioToneUtility::NewL(*this);

	// Configure the audio tone utility to play a single tone

	if (iMdaAudioToneUtility)

		{

		iMdaAudioToneUtility->PrepareToPlayTone(iFrequency, TTimeIntervalMicroSeconds(iDuration));

       // const TUid KUidBassBoostEffect = {0x10203827};  

       // iMdaAudioToneUtility->CustomInterface(KUidBassBoostEffect);  

		}

	else

		{	//console->Printf(KNotPlayed);

		}

	///console->Printf(KPlayed);

	}

void CTonePlayer::ConstructL()

	{

	iFrequency=0;

	iDuration=0;

	iMdaAudioToneUtility = CMdaAudioToneUtility::NewL(*this);

	}

/*

CTonePlayer* CTonePlayer::NewL(CLogger *aLogger)

	{

	CTonePlayer *_self = NewLC(aLogger);

	CleanupStack::Pop(_self);

	return _self;

	}

*/

/*

CTonePlayer* CTonePlayer::NewLC(CLogger *aLogger)

	{

	CTonePlayer *_self = new(ELeave)CTonePlayer(aLogger);

	CleanupStack::PushL(_self);

	_self->ConstructL();

	return _self;

	}

*/

// ///////////////////////////////////////////////////

CTonePlayer::CTonePlayer(COutputPrinter *aOutputPrinter)

	:	iSupervisor(0), iId(0), iFinalError(KErrNone), 

		iLastPrepareError(KErrNone), iPrepareCalledCounter(0),

		iExitEventTarget(0), iExitEventParameters(0), iOutputPrinter(aOutputPrinter)

		//, iLastPlayTime(0), iLastStopTime(0)

	{

	iFreeToPlay=EFalse;

	}

CTonePlayer* CTonePlayer::NewL(COutputPrinter *aOutputPrinter, TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration, TBool aPlayInmediately)

	{

	CTonePlayer* self = NewLC(aOutputPrinter, aFrequency, aDuration, aPlayInmediately);

	CleanupStack::Pop(self);

	return self;

	}

CTonePlayer* CTonePlayer::NewLC(COutputPrinter *aOutputPrinter, TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration, TBool aPlayInmediately)

	{

	CTonePlayer* self = new(ELeave)CTonePlayer(aOutputPrinter);

	CleanupStack::PushL(self);

	self->ConstructL(aFrequency, aDuration, aPlayInmediately);

	return self;

	}

CTonePlayer* CTonePlayer::NewL(COutputPrinter *aOutputPrinter)

	{

	CTonePlayer *_self = NewLC(aOutputPrinter);

	CleanupStack::Pop(_self);

	return _self;

	}

CTonePlayer* CTonePlayer::NewLC(COutputPrinter *aOutputPrinter)

	{

	CTonePlayer *_self = new(ELeave)CTonePlayer(aOutputPrinter);

	CleanupStack::PushL(_self);

	_self->ConstructL();

	return _self;

	}

// ///////////////////////////////////////////////////

CTonePlayer::~CTonePlayer()

	{

	delete iMdaAudioToneUtility;    

	iMdaAudioToneUtility = NULL;

	}

void CTonePlayer::CancelPrepare()

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::CancelPrepare()"), iId);

	iMdaAudioToneUtility->CancelPrepare();

	}

TBool CTonePlayer::Play()

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::Play()"), iId);

	if(iFreeToPlay)

		{

		iFreeToPlay = EFalse;

		iOutputPrinter->Printf(_L("%d) CTonePlayer::Play(), Starting playback"), iId);

		iLastPlayTime.HomeTime();

		iLastStopTime.HomeTime();

		iMdaAudioToneUtility->Play();

		return ETrue;

		} 

	else

		{

		return EFalse;	

		}

	}

void CTonePlayer::Stop()

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::Stop()"), iId);

	iMdaAudioToneUtility->CancelPlay();

	iLastStopTime.HomeTime();

	Exit(KErrNone);

	}

void CTonePlayer::SetVolumeRamp(TTimeIntervalMicroSeconds aRamp) { iMdaAudioToneUtility->SetVolumeRamp(aRamp); }

void CTonePlayer::SetVolume(TInt aVolume) { iOutputPrinter->Printf(_L("%d) CTonePlayer::SetVolume()"), iId);

iMdaAudioToneUtility->SetVolume(aVolume); }

TInt CTonePlayer::GetVolume() { return iMdaAudioToneUtility->Volume(); }

TInt CTonePlayer::GetMaxVolume() { return iMdaAudioToneUtility->MaxVolume(); }

void CTonePlayer::SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds &aTrailingSilence)

	{

	iMdaAudioToneUtility->SetRepeats(aRepeatNumberOfTimes,aTrailingSilence);

	}

TInt CTonePlayer::GetFixedSequenceCount()

	{

	TInt Sequences = iMdaAudioToneUtility->FixedSequenceCount();

	iOutputPrinter->Printf(_L("%d) CTonePlayer::GetFixedSequenceCount(), Number of fixed sequences: (%d)") , iId, Sequences );

	return Sequences;

	}

const TDesC &CTonePlayer::GetFixedSequenceName(TInt aSequenceNumber)

	{

	const TDesC &Name = iMdaAudioToneUtility->FixedSequenceName(aSequenceNumber);

	iOutputPrinter->Printf(_L("%d) CTonePlayer::GetFixedSequenceName(%d), result: is %S") , iId, aSequenceNumber , &Name );

	return Name;

	}

void CTonePlayer::PrepareTone(TInt aFreq, const TTimeIntervalMicroSeconds &aToneDuration, TBool aPlayInmediately)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::PrepareTone(%d, %d, %d)") , iId, aFreq, aToneDuration, aPlayInmediately);

	iPlayInmediately=aPlayInmediately;

	iMdaAudioToneUtility->PrepareToPlayTone(aFreq, aToneDuration);

	}

void CTonePlayer::PrepareFixedSequence(TInt aSequenceNumber, TBool aPlayInmediately)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::PrepareFixedSequence(%d, %d)") , iId, aSequenceNumber, aPlayInmediately);

	iPlayInmediately=aPlayInmediately;

	iMdaAudioToneUtility->PrepareToPlayFixedSequence(aSequenceNumber);

	}

void CTonePlayer::PrepareFixedSequenceCustomInterface(TInt aSequenceNumber, TBool aPlayInmediately)  

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::PrepareFixedSequenceCustomInterface(%d, %d)") , iId, aSequenceNumber, aPlayInmediately);

	iPlayInmediately=aPlayInmediately;

    const TUid KUidBassBoostEffect = {0x10203827};  

    iMdaAudioToneUtility->CustomInterface(KUidBassBoostEffect);  

	iMdaAudioToneUtility->PrepareToPlayFixedSequence(aSequenceNumber);

	}	

void CTonePlayer::PrepareFileSequence(const TDesC &aFileName , TBool aPlayInmediately)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::PrepareFileSequence(%S, %d)") , iId, &aFileName, aPlayInmediately);

	iPlayInmediately=aPlayInmediately;

	iMdaAudioToneUtility->PrepareToPlayFileSequence(aFileName);

	//iMdaAudioToneUtility->PrepareToPlayDTMFString(aFileName);

	}

void CTonePlayer::PrepareRFileSequence(const TDesC &aFileName, TBool aPlayInmediately)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::PrepareRFileSequence(%S, %d)") , iId, &aFileName, aPlayInmediately);

	iPlayInmediately=aPlayInmediately;

	RFs	  RFsPtr;

	RFile rfile;

	if( RFsPtr.Connect() == KErrNone )

		{

		if( rfile.Open( RFsPtr, aFileName, EFileRead ) == KErrNone )

			{

			iMdaAudioToneUtility->PrepareToPlayFileSequence(rfile);

			}

		}

	rfile.Close();

	RFsPtr.Close();

	//iMdaAudioToneUtility->PrepareToPlayDTMFString(aFileName);

	}

void CTonePlayer::PrepareDTMFSequence(const TDesC &aSequence, TBool aPlayInmediately)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::PrepareDTMFSequence(%S, %d)") , iId, &aSequence, aPlayInmediately);

	iPlayInmediately=aPlayInmediately;

	iMdaAudioToneUtility->PrepareToPlayDTMFString(aSequence);

	}

void CTonePlayer::PrepareDesSequence(const TDesC8 &aSequence, TBool aPlayInmediately)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::PrepareDesSequence(sequence, %d)") , iId, aPlayInmediately);

	iPlayInmediately=aPlayInmediately;

	iMdaAudioToneUtility->PrepareToPlayDesSequence(aSequence);

	}

void CTonePlayer::PrepareDualTone(TInt aFreq1, TInt aFreq2, const TTimeIntervalMicroSeconds &aToneDuration, TBool aPlayInmediately)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::PrepareDualTone(%d, %d, %d, %d)") , iId, aFreq1, aFreq2, aToneDuration, aPlayInmediately);

	iPlayInmediately=aPlayInmediately;

	iMdaAudioToneUtility->PrepareToPlayDualTone(aFreq1, aFreq2, aToneDuration);

	}

void CTonePlayer::SetPriority(TInt aPriority, TMdaPriorityPreference aPref)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::SetPriority(%d, %d)") , iId, aPriority, aPref);

	iMdaAudioToneUtility->SetPriority(aPriority, aPref);

	}

void CTonePlayer::SetId(TInt aId) { iId = aId; }

TInt CTonePlayer::GetId() { return iId; }

TInt CTonePlayer::GetFinalError() { return iFinalError; }

TInt CTonePlayer::GetLastPrepareCompleteError() {return iLastPrepareError; }

TInt CTonePlayer::GetPrepareCompleteCallbackCount() {return iPrepareCalledCounter;}

void CTonePlayer::SetSupervisor(TObjectCountDown *aCounter)

	{

	iSupervisor = aCounter;

	iSupervisor->NotifyCreation();

	}

void CTonePlayer::SetExitCompleteTarget(MEventTarget *aTarget, CParameters *aParameters)

	{

	iExitEventTarget = aTarget;

	iExitEventParameters = aParameters;

	}

TTimeIntervalMicroSeconds CTonePlayer::GetPlayDuration() { return iLastStopTime.MicroSecondsFrom(iLastPlayTime); }

TTime CTonePlayer::GetPlayStartTime() { return iLastPlayTime; }

TTime CTonePlayer::GetPlayStopTime() { return iLastStopTime; }

TInt CTonePlayer::GetBalanceL()

	{

	TInt retVal = iMdaAudioToneUtility->GetBalanceL();

	return retVal;

	}

void CTonePlayer::SetBalanceL(TInt aBalance)

	{

	iMdaAudioToneUtility->SetBalanceL(aBalance);

	}

void CTonePlayer::SetDTMFLengths(TTimeIntervalMicroSeconds32 iToneOnLength, TTimeIntervalMicroSeconds32 iToneOffLength, TTimeIntervalMicroSeconds32 iPauseLength)

	{

	iMdaAudioToneUtility->SetDTMFLengths(iToneOnLength, iToneOffLength, iPauseLength);

	}

void CTonePlayer::Exit(TInt aExitCode)

	{

	iOutputPrinter->Printf(_L("%d) CTonePlayer::Exit(%d)"), iId, aExitCode);

	iFinalError = aExitCode;

	if (iSupervisor)

		{

		iSupervisor->NotifyDestruction();

		iSupervisor=0;

		}

	else

		{

		CActiveScheduler::Stop();

		}

	if (iExitEventTarget && iExitEventParameters)

		{

		iExitEventTarget->ExecuteL(iExitEventParameters) ;

		}

	}

TInt CTonePlayer::State()

    {

    return iMdaAudioToneUtility->State();

    }

// from MMdaAudioToneObserver

void CTonePlayer::MatoPrepareComplete(TInt aError)

	{

	iLastPrepareError=aError;

	iPrepareCalledCounter++;

	iOutputPrinter->Printf(_L("%d) CTonePlayer::MatoPrepareComplete, error (%d)"), iId, aError);

	if (aError)

		{

		Exit(aError);

		}

	else

		{

		iFreeToPlay = ETrue;

		if (iPlayInmediately) 

			{

			Play();

			}

		else

		    {

		   CActiveScheduler::Stop();

		    }

		}

	iFinalError=aError;

	}

// from MMdaAudioToneObserver

void CTonePlayer::MatoPlayComplete(TInt aError)

	{

	iLastStopTime.HomeTime();

	iOutputPrinter->Printf(_L("%d) CTonePlayer::MatoPlayComplete, error (%d)"), iId, aError);

	if (aError == KErrNotSupported) 

	{

		iFinalError = KErrNone;

		aError = KErrNone;

	}

	else

	{

		iFinalError=aError;

	}

	iFreeToPlay = ETrue;

	Exit(aError);

	}

// from MEventTarget

TInt CTonePlayer::ExecuteL(CParameters *aParams)

	{

	switch (aParams->iAction)

		{

		case KPlayerActionPlay:

			Play();

			break;

		case KPlayerActionReportVolume:

			iOutputPrinter->Printf(_L("%d) Retrieving volume: (%d)") , iId, GetVolume());

			return ETrue;

			break;

		case KPlayerActionStop:

			Stop();

			break;

		case KPlayerActionCancelPrepare:

			CancelPrepare();

			break;

		case KPlayerActionPrepareFileSequence:

			{

			CTemplateParameters<TFileName> *fn=static_cast< CTemplateParameters<TFileName>* >(aParams);

			PrepareFileSequence(fn->GetData());

			//(*fn).GetData();

			break;

			}

		case KPlayerActionPrepareFixedSequence:

			{

			CTemplateParameters<TInt> *fs=static_cast< CTemplateParameters<TInt>* >(aParams);

			PrepareFixedSequence(fs->GetData());

			break;

			}

		case KPlayerActionPrepareTone:

			{

			CTemplateParameters<TFixedArray<TInt64, 2> > *ToneData = static_cast< CTemplateParameters<TFixedArray<TInt64, 2> >* >(aParams);

			TFixedArray<TInt64, 2> params = ToneData->GetData();

			//PrepareTone( params[0].GetTInt() , params[1]);

			PrepareTone( I64INT(params[0]), params[1]);

			break;

			}

		case KPlayerActionPrepareDualTone:

			{

			CTemplateParameters<TFixedArray<TInt64, 4> > *ToneData = static_cast< CTemplateParameters<TFixedArray<TInt64, 4> >* >(aParams);

			TFixedArray<TInt64, 4> params = ToneData->GetData();

			PrepareDualTone( I64INT(params[0]), I64INT(params[1]), params[2],params[3]);

			break;

			}

		case KPlayerActionPrepareDTMFSequence:

			{

			//CTemplateParameters<TBufC<50> > *ToneData = static_cast< CTemplateParameters<TBufC<50> >* >(aParams);

			CDTMFParameters *params = static_cast<CDTMFParameters*>(aParams);

			PrepareDTMFSequence( *(params->GetDTMFString()) );

			SetDTMFLengths(params->GetToneDuration(), params->GetToneOffDuration(), params->GetPauseDuration() );

			break;

			}

        case KPlayerActionPrepareDesSequence:

            CTemplateParameters<HBufC8*> *params =

                    static_cast<CTemplateParameters<HBufC8*> *> (aParams);

            PrepareDesSequence(*(params->GetData()));

            break;

        case KPlayerActionChangeVolumeToMax:

            {

            SetVolume( GetMaxVolume());

            break;

            }

        case KPlayerActionChangeVolumeToAvg:

            {

            SetVolume(GetMaxVolume() / 2);

            break;

            }

        case KPlayerActionChangeVolumeToZero:

            {

            SetVolume(0);

            break;

            }

        }

	return EFalse;

	}