/*

* Copyright (c) 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:  Progressive Download Utility

*

*/

#ifndef __EMCPDPROPERTIES_H__

#define __EMCPDPROPERTIES_H__

#include <e32std.h>

#include <e32base.h>

#include <f32file.h>

#include "MAudioPlayUtility.h"

#include "EMCPdPlayUtility.h"

#include "mmfclientutility.h"

#include <mmf/common/mmcaf.h>

#include <StreamControl.h>

#include <ControlObserver.h>

#include <Events.h>

#include <DataBufferSource.h>

#include <DataBuffer.h>

#include <MMControlFactory.h>

#include <SinkControl.h>

#include <MimeTypes.h>

#include <VolumeControl.h>

#include <StreamControlObserver.h>

#include <SourceControlObserver.h>

#include "BufferEmptiedEventAO.h"

#include "ContentFile.h"

using namespace multimedia;

using multimedia::MStreamControl;

using multimedia::MControlObserver;

using multimedia::MDataBufferSource;

using multimedia::MDataBuffer;

using multimedia::MControl;

using multimedia::CMultimediaFactory;

using multimedia::MSinkControl;

using multimedia::MVolumeControl;

using multimedia::MSourceControlObserver;

using multimedia::MStreamControlObserver;

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

		ECallbackPlaying,

		ECallbackPaused

		};

public:

	static CMMFMdaAudioPlayerCallBack* NewL(MAudioPdPlayUtilityCallback& aCallback);

	~CMMFMdaAudioPlayerCallBack();

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

	void PlayComplete(TInt aError);

	void PlayingCallback();

	void PausedCallback();

private:

	CMMFMdaAudioPlayerCallBack(MAudioPdPlayUtilityCallback& aCallback);

	void RunL();

	void DoCancel();

private:

	MAudioPdPlayUtilityCallback& iCallback;

	TInt iError;

	TTimeIntervalMicroSeconds iDuration;

	TCallbackState iState;

	};

/**

Concrete implementation of the CAudioPdPlayUtility API.

@see CAudioPdPlayUtility

*/

class CAudioPdProperties: public CBase,

                            public MControlObserver,

                            public MBufferEmptiedObserver,

                            public MMMFDRMCustomCommand

	{

public:

	enum TMMFAudioPlayerState

		{

		EStopped,

		EOpening,

		EPaused,

		EPlaying,

		EBuffering,

		EPrimed

		};

	static CAudioPdProperties* NewL(MAudioPdPlayUtilityCallback& aCallback);

	static CAudioPdProperties* NewLC(MAudioPdPlayUtilityCallback& aCallback);

	~CAudioPdProperties();

   //For Download Status

    void HandleDownloadEventL(TUint aTransactionID,

                              TBrCtlDownloadEvent aEvent,

                              TUint aValue);

	 //For Audio control

	void Play();

	void Stop();

	TInt Pause();

	void SetVolume(TInt aVolume);

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

	void SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration);

	const TTimeIntervalMicroSeconds& Duration();

	TInt MaxVolume();

	void Close();

	TInt GetPosition(TTimeIntervalMicroSeconds& aPosition);

	void SetPosition(const TTimeIntervalMicroSeconds& aPosition);

	TInt SetPriority(TInt aPriority, TMdaPriorityPreference 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 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();

	void OpenFileL(const TDesC& aFileName);

	void OpenFileL(const RFile& aFile);

    void DlCompleteOpenFileL(const TDesC& aFileName);

	TInt GetFilePosition(TInt& aFilePosition);

	TInt SetFileSize(TInt aFileSize);

	TInt SetBytesDownloaded(TInt aBytesDownloaded, TBool isDownloadComplete);

	TInt CheckAudioPlayerState();

    TInt DisableAutomaticIntent(TBool aDisableAutoIntent);

    TInt ExecuteIntent(ContentAccess::TIntent aIntent);

    TInt EvaluateIntent(ContentAccess::TIntent aIntent);

    TInt SetAgentProperty(ContentAccess::TAgentProperty aProperty, TInt aValue);

private:

    void Event( MControl* aControl, TUint aEventType, TAny* aEventObject );

    void BufferEmptiedBySource();

    void FillSourceBuffers();

    void CreateAudioBuffersL();

    void DetermineFNMimeType(const TDesC& aFileName, TDes8& aMimeType);

    void DetermineFHMimeType(const RFile& aFile, TDes8& aMimeType);

    TInt ReadFromFileAndWriteToStream(TInt aIndex)    ;

    TInt ExtractDRMRestrictionsL();

    TInt ReOpenCAF();

	CAudioPdProperties(/*MMdaAudioPlayerCallback*/MAudioPdPlayUtilityCallback& aCallback);

	void ConstructL(MAudioPdPlayUtilityCallback& aCallback);

private:

	//MAudioPdPlayUtilityCallback* iAudioPdPlayCallback;

	// last play window command

	enum TPlayWindowCommand

		{

		ENone,

		ESet,

		EClear

		};

	MAudioPdPlayUtilityCallback& iCallback;

	CMMFMdaAudioPlayerCallBack* iAsyncCallBack;

	MAudioLoadingObserver* iLoadingObserver;

	RMMFController iController;

	RMMFController* iControllerPtr;

	TMMFAudioPlayerState iState;

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

	TMMFPrioritySettings iPrioritySettings;

	TInt iNumberOfTimesPlayed;

	TInt iNumberOfTimesToRepeat;

	TTimeIntervalMicroSeconds iTrailingSilence;

	// Custom command handlers

	RMMFAudioPlayDeviceCustomCommands iAudioPlayDeviceCommands;

	RMMFAudioPlayControllerCustomCommands iAudioPlayControllerCommands;

	RMMFDRMCustomCommands iDRMCustomCommands;

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

    MStreamControl* iStreamControl;

    MDataBufferSource* iMDataBufferSource;

    MSinkControl* iMAudioSink;

    MVolumeControl* iMVolumeControl;

    RFs             iFs;

    CContentFile*    iFile;

    RFile               iFileHandle;

    RPointerArray<MDataBuffer> iBuffers;

    RArray<TInt> iAvailable;

    TBool        iIsEOFReached;

    TInt         iBytesReadFromFile;

    TInt         iFileSizeInBytes;

    CMultimediaFactory* iFactory;

    HBufC8* iMimeType;

    MStreamControl::TStreamState iStreamState;

    CBufferEmptiedEventAO* iBufferEmptiedEventAO;

    TInt iFileSize;

    TBool iBuffering;

    TInt iBytesDownloaded;

    TBool iStopCalled;

    HBufC* iFileName;

    TBool isProtected;

    TBool iDisableAutoIntent;

    TBool iMetaDataRead;

    // Metadata entries, if supported

    RPointerArray<CMMFMetaDataEntry> iMetaDataEntries;

    TBool iControllerLoaded;

    TBool iDownloadComplete;

	};

#endif