// 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