/*

* 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:  mmftsplay test component

*

*/

#include "SimpleSoundPlayer.h"

#include <AudioPreference.h>

const TInt CSimpleSoundPlayer::KPlayerActionPlay = 1;

const TInt CSimpleSoundPlayer::KPlayerActionPause = 2;

const TInt CSimpleSoundPlayer::KPlayerActionStopPlayFile = 3;

const TInt CSimpleSoundPlayer::KPlayerActionReportPosition = 4;

const TInt CSimpleSoundPlayer::KPlayerActionReportDuration = 5;

const TInt CSimpleSoundPlayer::KPlayerActionStopPlayDes = 6;

const TInt CSimpleSoundPlayer::KPlayerActionReportVolume = 7;

const TInt CSimpleSoundPlayer::KPlayerActionStopPlayUrl = 8;

const TInt CSimpleSoundPlayer::KPlayerActionStopPlayFileHandler = 9;

const TInt CSimpleSoundPlayer::KPlayerActionReportDuration_Para = 10;

const TInt CSimpleSoundPlayer::KPlayerActionPauseResume = 11;

CSimpleSoundPlayer::CSimpleSoundPlayer(CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

			: iConsole(aConsole) , iImmediate(aImmediate) , iLogger(aLogger) , iSoundOpen(EFalse),

				iFinalError(KErrNone)

	{

	iSupervisor =0 ;

	iEventTarget=0;

	iParameters =0;

	iPlayerId =0 ;

	playVolume = false;

	metaInfo = false;

	playWindow = false;

	clearWindow = false;

	setBalance = false;

	iDontPlayAudioClip = false;  // Binh

	iIsLoopPlayEnabled = EFalse;

	}

void CSimpleSoundPlayer::ConstructUrlL(const TDesC &aUrl, TInt aIapId, const TDesC8 &aMime)

	{

	iMdaPlayer=CMdaAudioPlayerUtility::NewL(*this);

	//KUseDefaultIap

	iMdaPlayer->OpenUrlL(aUrl, aIapId, aMime );

	iSoundOpen=ETrue;

	_LIT(KPlayerCreated, "SoundPlayerCreated");

	iConsole.Printf(100, KPlayerCreated, KPlayerCreated);

	}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewUrlL(const TDesC &aUrl, TInt aIapId, const TDesC8 &aMime, CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

	{

    CSimpleSoundPlayer* self = NewUrlLC(aUrl, aIapId, aMime, aConsole, aLogger, aImmediate);

	CleanupStack::Pop(self);

    return self;

	}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewUrlLC(const TDesC &aUrl, TInt aIapId, const TDesC8 &aMime, CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

	{

    CSimpleSoundPlayer* self = new (ELeave) CSimpleSoundPlayer(aConsole, aLogger, aImmediate);

    CleanupStack::PushL(self);

    self->ConstructUrlL(aUrl, aIapId, aMime);

    return self;

	}

void CSimpleSoundPlayer::ConstructL(const TDesC8 &aDescriptor)

	{

	// Create a file audio player utility instance

	iMdaPlayer=CMdaAudioPlayerUtility::NewL(*this);		//Por Pasos

	iMdaPlayer->OpenDesL(aDescriptor);

	iSoundOpen=ETrue;

	_LIT(KPlayerCreated, "SoundPlayerCreated");

	iConsole.Printf(100, KPlayerCreated, KPlayerCreated);

	}

void CSimpleSoundPlayer::ConstructL(TBool aUseSharedHeap)

{

		iMdaPlayer=CMdaAudioPlayerUtility::NewL(*this, EMdaPriorityNormal,

	    EMdaPriorityPreferenceTimeAndQuality);

    	_LIT(KRootDir,"\\");

 	 	_LIT(KTestMP3File,"10s_smooth.mp3");

		TBuf8<60> buf2;

		RFs iFs2;

		User::LeaveIfError(iFs2.Connect());

	    TFindFile fileFind2(iFs2);

		TRAPD(err2,fileFind2.FindByDir(KTestMP3File,KRootDir));

		buf2.Copy((TDesC&) fileFind2.File());

		TBuf8<60> buf3;

		RFs iFs3;

		User::LeaveIfError(iFs3.Connect());

 	    TFindFile fileFind3(iFs3);

		TRAPD(err3,fileFind3.FindByDir(KTestMP3File,KRootDir));

		buf3.Copy((TDesC&) fileFind3.File());

        iMdaPlayer_1=CMdaAudioPlayerUtility::NewFilePlayerL(KTestMP3File, *this, EMdaPriorityNormal,

	    EMdaPriorityPreferenceTimeAndQuality);

	    iMdaPlayer_2=CMdaAudioPlayerUtility::NewDesPlayerL(buf2, *this);	// creación inmediata

		iMdaPlayer_3=CMdaAudioPlayerUtility::NewDesPlayerReadOnlyL(buf3, *this);

  	    iFs2.Close();

 	    iFs3.Close();

 	    iLogger.Log(_L("Trying to stop player") );

		iMdaPlayer_1->Stop();

		iLogger.Log(_L("Trying to close player") );

		iMdaPlayer_1->Close();

		iLogger.Log(_L("  Player stopped") );

    	delete iMdaPlayer_1;

    	iMdaPlayer_1 = NULL;

   		iLogger.Log(_L("Trying to stop player") );

		iMdaPlayer_2->Stop();

		iLogger.Log(_L("Trying to close player") );

		iMdaPlayer_2->Close();

		iLogger.Log(_L("  Player stopped") );

    	delete iMdaPlayer_2;

    	iMdaPlayer_2 = NULL;

    	iLogger.Log(_L("Trying to stop player") );

		iMdaPlayer_3->Stop();

		iLogger.Log(_L("Trying to close player") );

		iMdaPlayer_3->Close();

		iLogger.Log(_L("  Player stopped") );

    	delete iMdaPlayer_3;

    	iMdaPlayer_3 = NULL;

}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewLC(CTestModuleIf &aConsole, CStifLogger &iLogger,

                                                    TBool aUseSharedHeap)

{

    CSimpleSoundPlayer* self = new (ELeave) CSimpleSoundPlayer(aConsole, iLogger);

    CleanupStack::PushL(self);

    self->ConstructL(aUseSharedHeap);

    return self;

}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewL(CTestModuleIf &aConsole, CStifLogger &iLogger,

                                                    TBool aUseSharedHeap)

{

    RDebug::Print(_L("CSimpleSoundPlayer::NewL:"));

    CSimpleSoundPlayer* self = NewLC(aConsole, iLogger, aUseSharedHeap);

	CleanupStack::Pop(self);

    return self;

}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewL(const TDesC8 &aDescriptor, CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

	{

    CSimpleSoundPlayer* self = NewLC(aDescriptor, aConsole, aLogger, aImmediate);

	CleanupStack::Pop(self);

    return self;

	}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewLC(const TDesC8 &aDescriptor, CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

	{

    CSimpleSoundPlayer* self = new (ELeave) CSimpleSoundPlayer(aConsole, aLogger, aImmediate);

    CleanupStack::PushL(self);

    self->ConstructL(aDescriptor);

    return self;

	}

void CSimpleSoundPlayer::ConstructL(const TFileName &aFile)

	{

	iMdaPlayer=CMdaAudioPlayerUtility::NewL(*this);		//Instantiation by steps

	// Create a file audio player utility instance

	//iMdaPlayer_1=CMdaAudioPlayerUtility::NewFilePlayerL(aFile, *this);	//For inmediate instantiation

	iMdaPlayer->UseSharedHeap();  // Ensures that any subsequent calls to OpenXYZ() will create controllers that share a heap.

	iMdaPlayer->OpenFileL(aFile);

	iSoundOpen=ETrue;

	_LIT(KPlayerCreated, "SoundPlayerCreated");

	iConsole.Printf(100, KPlayerCreated, KPlayerCreated);

    iAudioOutput=NULL;

	}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewLC(const TFileName &aFile, CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

	{

    CSimpleSoundPlayer* self = new (ELeave) CSimpleSoundPlayer(aConsole, aLogger, aImmediate);

    CleanupStack::PushL(self);

    self->ConstructL(aFile);

    return self;

	}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewL(const TFileName &aFile, CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

	{

    CSimpleSoundPlayer* self = NewLC(aFile, aConsole, aLogger, aImmediate);

	CleanupStack::Pop(self);

    return self;

	}

void CSimpleSoundPlayer::ConstructL(const RFile &aFile)

	{

	// Create a file audio player utility instance

	//iMdaPlayer=CMdaAudioPlayerUtility::NewFilePlayerL(aFile, *this);	//For inmediate instantiation

	iMdaPlayer=CMdaAudioPlayerUtility::NewL(*this);		//Instantiation by steps

	iMdaPlayer->OpenFileL(aFile);

	iSoundOpen=ETrue;

	_LIT(KPlayerCreated, "SoundPlayerCreated");

	iConsole.Printf(100, KPlayerCreated, KPlayerCreated);

	}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewLC(const RFile &aFile, CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

	{

    CSimpleSoundPlayer* self = new (ELeave) CSimpleSoundPlayer(aConsole, aLogger, aImmediate);

    CleanupStack::PushL(self);

    self->ConstructL(aFile);

    return self;

	}

CSimpleSoundPlayer* CSimpleSoundPlayer::NewL(const RFile &aFile, CTestModuleIf &aConsole, CStifLogger &aLogger, TBool aImmediate)

	{

    CSimpleSoundPlayer* self = NewLC(aFile, aConsole, aLogger, aImmediate);

	CleanupStack::Pop(self);

    return self;

	}

TInt CSimpleSoundPlayer::OpenL(const TFileName &aFileName , const TBool &aImmediate=ETrue)

	{

	iImmediate = aImmediate;

	Stop();

	iLogger.Log(_L("Stop before opening file"));

	iLogger.Log(_L("Closed, opening [%S]") , &aFileName);

	iMdaPlayer->OpenFileL(aFileName);

	iSoundOpen=ETrue;

	iLogger.Log(_L("Opened"));

	return KErrNone;

	}

TInt CSimpleSoundPlayer::OpenFileHandlerL(const TFileName &aFileName , const TBool &aImmediate=ETrue)

	{

	iImmediate = aImmediate;

	Stop();

	iLogger.Log(_L("Stop before opening file"));

	iLogger.Log(_L("Closed, opening [%S]") , &aFileName);

	RFs aFs;

	RFile aFileHandler;

	User::LeaveIfError(aFs.Connect());

	User::LeaveIfError(aFileHandler.Open( aFs, aFileName, EFileRead));

	iMdaPlayer->OpenFileL(aFileHandler);

	aFileHandler.Close();

	aFs.Close();

	iSoundOpen=ETrue;

	iLogger.Log(_L("Opened"));

	return KErrNone;

	}

TInt CSimpleSoundPlayer::OpenUrlL(const TDesC &aUrl, TInt aIapId, const TDesC8 &aMime)

	{

	iLogger.Log(_L("Opening url [%S] with IapId [%s]") , &aUrl , aIapId );

	iLogger.Log(_L8("   and MIME Type [%S]") , &aMime);

	iMdaPlayer->OpenUrlL(aUrl, aIapId, aMime);

	return ETrue;

	}

TInt CSimpleSoundPlayer::OpenDesL(const TDesC8 &aSoundDes , const TBool &aImmediate)

	{

	iImmediate = aImmediate;

	Stop();

	iLogger.Log(_L("Stop before opening descriptor"));

	iLogger.Log(_L("Closed, opening second descriptor of length (%d)") , aSoundDes.Length() );

	iMdaPlayer->OpenDesL(aSoundDes);

	iSoundOpen=ETrue;

	iLogger.Log(_L("Opened"));

	////iAutoClose = ETrue;	///K

	return KErrNone;

	}

TInt CSimpleSoundPlayer::Play()

	{

	if(iState==EReady || iState==EPaused)

		{

		iState=EPlaying;

		iLastPlayTime.HomeTime();

		iLastStopTime.HomeTime();

		iMdaPlayer->Play();

		iLogger.Log(_L("Requested Play"));

		}

	else

		{

		iLogger.Log(_L("Requested Play, Not Ready to play"));

		iImmediate = true;

		}

	return KErrNone;

	}

TInt CSimpleSoundPlayer::Stop(const TBool &aAlsoClose)

	{

	iLogger.Log(_L("Requested Stop,,,,,"));

	iMdaPlayer->Stop();

	iLogger.Log(_L("Requested Stop,,,,, successful"));

	iLastStopTime.HomeTime();

	if (aAlsoClose)

		{

		iLogger.Log(_L("iMdaPlayer->Close()" ));

		iMdaPlayer->Close();

		iLogger.Log(_L("iMdaPlayer->Close() successful" ));

		iSoundOpen=EFalse;

		iState = ENotReady;

		}

	else

		{

		if (iState==EPlaying || iState==EPaused) {iState = EReady;}

		}

	return KErrNone;

	}

TInt CSimpleSoundPlayer::Pause()

	{

	iLogger.Log(_L("Requested Pause"));

	iState=EPaused;

	// Resume is not supported in Devsound adaptation on HW ... this will crash the phone for WAV.

#ifdef __WINS__

	iMdaPlayer->WillResumePlay();

#endif

	iMdaPlayer->Pause();

	return KErrNone;

	}

TInt CSimpleSoundPlayer::PauseResume()

	{

	iLogger.Log(_L("Requested Pause"));

	iState=EPaused;

    // Resume is not supported in Devsound adaptation on HW ... this will crash the phone for WAV.

#ifdef __WINS__

	iMdaPlayer->WillResumePlay();

#endif

	iMdaPlayer->Pause();

	return KErrNone;

	}

void CSimpleSoundPlayer::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds &/*aDuration*/)

	{

	iLogger.Log(_L("MapcInitComplete"));

	if (iImmediate)

		{

		if (aError == KErrNone)

			{

			_LIT(KGonnaPlay, "MapcInitComplete, GoingToPlay");

			_LIT(KGoing, "Going to");

			_LIT(KDone, "Done Started Playing");

			iConsole.Printf(100, KGonnaPlay, KGoing);

			if (playVolume)

			{

		//	TInt VolumeHigh;

			iLogger.Log(_L("SetVolume") );

			TInt maxVolume = iMdaPlayer->MaxVolume();

			iLogger.Log(_L("MaxVolume is %d"), maxVolume );

			iMdaPlayer->SetVolume(maxVolume);

			iLogger.Log(_L("SetVolume(iMdaPlayer->MaxVolume())  max=(%d)"),  iMdaPlayer->MaxVolume() );

			}

			if (metaInfo)

			{

				TInt NumMetaDatas;

				TInt MetaDataError = iMdaPlayer->GetNumberOfMetaDataEntries(NumMetaDatas);

				if ( MetaDataError )

				{	//Error getting meta data info

					Exit(MetaDataError);

				}

				else

				{	//No error yet

					TInt currMetaDataIndex;

					for ( currMetaDataIndex=0 ; currMetaDataIndex < NumMetaDatas ; currMetaDataIndex++)

					{

						CMMFMetaDataEntry *currMetaData = iMdaPlayer->GetMetaDataEntryL(currMetaDataIndex);

						// check for jpeg image

						if (currMetaData->Name() == _L("attachedpicture"))

							iLogger.Log(_L("MetaData[%d]: Name: [%S], Value: [image]") , currMetaDataIndex , &(currMetaData->Name()) );

						else

							iLogger.Log(_L("MetaData[%d]: Name: [%S], Value: [%S]") , currMetaDataIndex , &(currMetaData->Name()) , &(currMetaData->Value()) );

						delete currMetaData;

					}

				}

			}

			if (playWindow)

			{

				iLogger.Log(_L("SetPlayWindow, start=[%d]"),startPosition.Int64());

				iLogger.Log(_L("SetPlayWindow, end=[%d]"), endPosition.Int64() );

				TInt pwErr = iMdaPlayer->SetPlayWindow(startPosition, endPosition);

				iLogger.Log(_L("SetPlayWindow err=[%d]"), pwErr);

				if (clearWindow)

				{

					iLogger.Log(_L("ClearPlayWindow"));

					iMdaPlayer->ClearPlayWindow();

				}

			}

			if (setBalance)

			{

				SetBalance(aBalance);

			}

			// Binh

            if (iDontPlayAudioClip)

            {

                iState = EReady;

                Exit(aError);

            }

            else

                {

			iState = EPlaying;

			iLastPlayTime.HomeTime();

			iLastStopTime.HomeTime();

                if (! playWindow)

                   {

                    iLogger.Log(_L("Position before Play (%d)"), I64INT(iPosition.Int64())/1000000);

			iMdaPlayer->SetPosition(iPosition);

                   }

			iMdaPlayer->Play();

			iLogger.Log(_L("Play() was called"));

			iConsole.Printf(100, KGonnaPlay, KDone);

                }

			}

		else

			{

			iLogger.Log(_L("InitError (%d)"), aError);

			iState = ENotReady;

			Exit(aError);

			}

		}

	else

		{

		iLogger.Log(_L("InitComplete, error(%d)") , aError);

		iState = aError ? ENotReady : EReady;

		if (aError)

			{

			Exit(aError);

			}

		//added

		else

		    {

		    CActiveScheduler::Stop();

		    }

		}

	}

void CSimpleSoundPlayer::MapcPlayComplete(TInt aError)

	{

	iLastStopTime.HomeTime();

	iLogger.Log(_L("MapcPlayComplete, error (%d)") , aError);

	_LIT(KGonnaPlay, "MapcPlayComplete, GoingToPlay");

	_LIT(KGoing, "Going to");

	iConsole.Printf(100, KGonnaPlay, KGoing);

	iState = aError ? ENotReady : EReady;