// Copyright (c) 2002-2009 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:

//

#ifndef MMFCLIENTAUDIOPLAY_H

#define MMFCLIENTAUDIOPLAY_H

#include <e32std.h>

#include <e32base.h>

#include <mdaaudiosampleplayer.h>

#include <mmf/common/mmfcontroller.h>

#include <mmf/server/mmffile.h>

#include <mmf/server/mmfdes.h>

#include <mmfcontrollerimplementationuids.hrh>

#include <mmf/common/mmfstandardcustomcommands.h>

#include <mmf/common/mmfdrmcustomcommands.h>

#include "mmfclientutility.h"

#include <mmf/common/mmfdurationinfocustomcommands.h>

static const TUid KUidMmfAudioController = {KMmfUidControllerAudio}; 

/**

Mixin class to allow notification that the timed silence has finished.

*/

class MRepeatTrailingSilenceTimerObs

	{

public:

	virtual void RepeatTrailingSilenceTimerComplete() = 0;

	};

/**

CTimer-based active object that waits the requested time before notifying its observer.

*/

class CRepeatTrailingSilenceTimer : public CTimer

	{

public:

	static CRepeatTrailingSilenceTimer* NewL(MRepeatTrailingSilenceTimerObs& aObs);

	void RunL();

private:

	CRepeatTrailingSilenceTimer(MRepeatTrailingSilenceTimerObs& aObs);

private:

	MRepeatTrailingSilenceTimerObs& iObs;

	};

/**

Active object utility class to allow the callback to be called asynchronously.

This should help prevent re-entrant code in clients of the mediaframework.

*/

class CMMFMdaAudioPlayerCallBack : public CActive

	{

public:

	enum TCallbackState {

		ECallbackInitComplete,

		ECallbackPlayComplete

		};

public:

	static CMMFMdaAudioPlayerCallBack* NewL(MMdaAudioPlayerCallback& aCallback);

	~CMMFMdaAudioPlayerCallBack();

	void InitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration);

	void PlayComplete(TInt aError);

private:

	CMMFMdaAudioPlayerCallBack(MMdaAudioPlayerCallback& aCallback);

	void RunL();

	void DoCancel();

private:

	MMdaAudioPlayerCallback& iCallback;

	TInt iError;

	TTimeIntervalMicroSeconds iDuration;

	TCallbackState iState;

	};

/**

Concrete implementation of the CMdaAudioPlayerUtility API.

@see CMdaAudioPlayerUtility

*/

class CMMFMdaAudioPlayerUtility;

NONSHARABLE_CLASS( CMMFMdaAudioPlayerUtility ): public CBase, 

								  				public MMMFControllerEventMonitorObserver,

								  				public MRepeatTrailingSilenceTimerObs,

								  				public MMMFFindAndOpenControllerObserver

	{

friend class CMdaAudioPlayerUtility;

// friends for Unit testing only

friend class CTestStepUnitMMFAudClient;

public:

	enum TMMFAudioPlayerState

		{

		EStopped,

		EOpening,

		EPaused,

		EPlaying		

		};

public:

	static CMMFMdaAudioPlayerUtility* NewFilePlayerL(const TDesC& aFileName, 

								MMdaAudioPlayerCallback& aCallback, 

								TInt aPriority = EMdaPriorityNormal, 

								TInt aPref = EMdaPriorityPreferenceTimeAndQuality,

								CMdaServer* aServer = NULL);

	static CMMFMdaAudioPlayerUtility* NewDesPlayerL(const TDesC8& aData, 

								MMdaAudioPlayerCallback& aCallback, 

								TInt aPriority = EMdaPriorityNormal, 

								TInt aPref = EMdaPriorityPreferenceTimeAndQuality,

								CMdaServer* aServer = NULL);

	static CMMFMdaAudioPlayerUtility* NewDesPlayerReadOnlyL(const TDesC8& aData, 

								MMdaAudioPlayerCallback& aCallback, 

								TInt aPriority = EMdaPriorityNormal, 

								TInt aPref = EMdaPriorityPreferenceTimeAndQuality,

								CMdaServer* aServer = NULL);

	static CMMFMdaAudioPlayerUtility* NewL(MMdaAudioPlayerCallback& aCallback,

								TInt aPriority = EMdaPriorityNormal,

								TInt aPref = EMdaPriorityPreferenceTimeAndQuality);

/**

	Destructor

*/

	~CMMFMdaAudioPlayerUtility();

	void UseSharedHeap();

	void OpenFileL(const TDesC& aFileName);

	void OpenFileL(const RFile& aFile);

	void OpenFileL(const TMMSource& aSource);

	void OpenDesL(const TDesC8& aDescriptor);

	void OpenUrlL(const TDesC& aUrl, TInt aIapId=KUseDefaultIap, const TDesC8& aMimeType = KNullDesC8);

	void Play();

	void Stop();

	TInt SetVolume(TInt aVolume);

	void SetRepeats(TInt aRepeatNumberOfTimes, const TTimeIntervalMicroSeconds& aTrailingSilence);

	void SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration);

	const TTimeIntervalMicroSeconds& Duration();

	TInt MaxVolume();

	// API Additions since version 7.0	

	TInt Pause();

	void Close();

	TInt GetPosition(TTimeIntervalMicroSeconds& aPosition);

	void SetPosition(const TTimeIntervalMicroSeconds& aPosition);

	TInt SetPriority(TInt aPriority, TInt aPref);

	TInt GetVolume(TInt& aVolume);

	TInt GetNumberOfMetaDataEntries(TInt& aNumEntries);

	CMMFMetaDataEntry* GetMetaDataEntryL(TInt aMetaDataIndex);

	TInt SetPlayWindow(const TTimeIntervalMicroSeconds& aStart,

								const TTimeIntervalMicroSeconds& aEnd);

	TInt ClearPlayWindow();

	TInt SetBalance(TInt aBalance = KMMFBalanceCenter);

	TInt GetBalance(TInt& aBalance);

	TInt GetBitRate(TUint& aBitRate);

	void RegisterForAudioLoadingNotification(MAudioLoadingObserver& aCallback);

	void GetAudioLoadingProgressL(TInt& aPercentageProgress);

	const CMMFControllerImplementationInformation& ControllerImplementationInformationL();

	TInt RegisterAudioResourceNotification(MMMFAudioResourceNotificationCallback& aCallback,TUid aNotificationEventUid,const TDesC8& aNotificationRegistrationData = KNullDesC8);

	TInt CancelRegisterAudioResourceNotification(TUid aNotificationEventId);

	TInt WillResumePlay();

	TInt CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom);

	TInt CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2);

	void CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus);

	void CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus);

	MMMFDRMCustomCommand* GetDRMCustomCommand();

	TInt SetThreadPriority(const TThreadPriority& aThreadPriority) const;

	TMMFDurationInfo Duration(TTimeIntervalMicroSeconds& aDuration);

	// from MMMFControllerEventMonitorObserver

	virtual void HandleEvent(const TMMFEvent& aEvent);

	// from MRepeatTrailingSilenceTimerObs

	virtual void RepeatTrailingSilenceTimerComplete();

	// from MMMFFindAndOpenControllerObserver 

	virtual void MfaocComplete(

		TInt& aError, 

		RMMFController* aController, 

		TUid aControllerUid, 

		TMMFMessageDestination* aSourceHandle, 

		TMMFMessageDestination* aSinkHandle);

protected:

	CMMFMdaAudioPlayerUtility(MMdaAudioPlayerCallback& aCallback, TInt aPriority, TInt aPref);

	void ConstructL();

	void DoPlay();

private:

	void PlaySilence();

private:

	// last play window command

	enum TPlayWindowCommand

		{

		ENone,

		ESet,

		EClear

		};

	MMdaAudioPlayerCallback& iCallback;

	CMMFMdaAudioPlayerCallBack* iAsyncCallBack;

	MAudioLoadingObserver* iLoadingObserver;

	MMMFAudioResourceNotificationCallback* iAudioResourceNotificationCallBack;

	RMMFController iController;

	CMMFControllerEventMonitor* iControllerEventMonitor;

	TMMFAudioPlayerState iState;

	TTimeIntervalMicroSeconds iDuration; // Needed because of api "Duration()" that returns a reference

	TMMFPrioritySettings iPrioritySettings;

	TInt iNumberOfTimesPlayed;

	TInt iNumberOfTimesToRepeat;

	TTimeIntervalMicroSeconds iTrailingSilence;

	TTimeIntervalMicroSeconds iTrailingSilenceLeftToPlay;	

	CRepeatTrailingSilenceTimer* iRepeatTrailingSilenceTimer;

	// Source and sink handle info

	TMMFMessageDestination iSourceHandle;

	TMMFMessageDestination iSinkHandle;

	// Custom command handlers

	RMMFAudioPlayDeviceCustomCommands iAudioPlayDeviceCommands;

	RMMFAudioPlayControllerCustomCommands iAudioPlayControllerCommands;

	RMMFResourceNotificationCustomCommands iNotificationRegistrationCommands;

	RMMFDRMCustomCommands iDRMCustomCommands;

	RMMFAudioPlayControllerSetRepeatsCustomCommands iAudioPlayControllerSetRepeatsCommands;

	// Current playback time so we can resume from where we were stopped

	TTimeIntervalMicroSeconds iPosition;

	// Play window start and end times and whether it has been set

	TTimeIntervalMicroSeconds iPlayStart;

	TTimeIntervalMicroSeconds iPlayEnd;

	TPlayWindowCommand iPlayWindowSet;

	RArray<TUid> iMediaIds;

	CMMFControllerImplementationInformation* iControllerImplementationInformation;

	TUid iControllerUid;

	// utility class to find and open a suitable controller asynchronously

	CMMFFindAndOpenController* iFindAndOpenController;

	TUid iEventHolder;

	TBuf8<256> iNotificationDataHolder;

	TBool iRepeatCancelled;

	}; 

#endif