/*

* 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

*

*/

#include <bautils.h>

#include <utf.h>

#include <mmfpaniccodes.h>

#include "AudioPdPlayUtility.h"

#include "AudioPdProperties.h"

#include "progressivedownloadsourceuids.hrh"

#include <AudioPreference.h>

//void Panic(TInt aPanicCode);

const TUid KUidProgressiveDlSource	= {KProgressiveDownloadSourceUid};

void Panic(TInt aPanicCode)

	{

	_LIT(KProgressiveDownloadUtility, "ProgressiveDownloadUtility");

	User::Panic(KProgressiveDownloadUtility, aPanicCode);

	}

CAudioPdPlayUtility* CAudioPdPlayUtility::NewL(MAudioPdPlayUtilityCallback& aCallback)

	{

    CAudioPdPlayUtility* self = new(ELeave) CAudioPdPlayUtility();

	CleanupStack::PushL(self);

 	self->iProperties = CAudioPdProperties::NewL(aCallback);

	CleanupStack::Pop(self);

	return self;

	}

CAudioPdPlayUtility::~CAudioPdPlayUtility()

	{

	delete iProperties;

	}

CAudioPdPlayUtility::CAudioPdPlayUtility()

	{

	}

void CAudioPdPlayUtility::ConstructL()

	{

	}

//For Download Status

void CAudioPdPlayUtility::HandleDownloadEventL(TUint aTransactionID,

                                               TBrCtlDownloadEvent aEvent,

                                               TUint aValue)

	{

    iProperties->HandleDownloadEventL(aTransactionID,aEvent,aValue);

	}

void CAudioPdPlayUtility::Play()

	{

    iProperties->Play();

	}

void CAudioPdPlayUtility::Stop()

	{

    iProperties->Stop();

	}

TInt CAudioPdPlayUtility::Pause()

	{

    return iProperties->Pause();

	}

void CAudioPdPlayUtility::SetVolume(TInt aVolume)

	{

    iProperties->SetVolume(aVolume);

	}

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

	{

    iProperties->SetRepeats(aRepeatNumberOfTimes,aTrailingSilence);

	}

void CAudioPdPlayUtility::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)

	{

    iProperties->SetVolumeRamp(aRampDuration);

	}

const TTimeIntervalMicroSeconds& CAudioPdPlayUtility::Duration()

	{

	return iProperties->Duration();

	}

TInt CAudioPdPlayUtility:: MaxVolume()

	{

	return iProperties->MaxVolume();

	}

void CAudioPdPlayUtility::Close()

	{

    iProperties->Close();

	}

TInt CAudioPdPlayUtility::GetPosition(TTimeIntervalMicroSeconds& aPosition)

	{

    return iProperties->GetPosition(aPosition);

	}

void CAudioPdPlayUtility::SetPosition(const TTimeIntervalMicroSeconds& aPosition)

	{

    iProperties->SetPosition(aPosition);

	}

TInt CAudioPdPlayUtility::SetPriority(TInt aPriority, TMdaPriorityPreference aPref)

	{

    return iProperties->SetPriority(aPriority,aPref);

	}

TInt CAudioPdPlayUtility::GetVolume(TInt& aVolume)

	{

    return iProperties->GetVolume(aVolume);

	}

TInt CAudioPdPlayUtility::GetNumberOfMetaDataEntries(TInt& aNumEntries)

	{

    return iProperties->GetNumberOfMetaDataEntries(aNumEntries);

	}

CMMFMetaDataEntry* CAudioPdPlayUtility::GetMetaDataEntryL(TInt aMetaDataIndex)

	{

	return iProperties->GetMetaDataEntryL(aMetaDataIndex);

	}

TInt CAudioPdPlayUtility::SetPlayWindow(const TTimeIntervalMicroSeconds& aStart,

								const TTimeIntervalMicroSeconds& aEnd)

	{

    return iProperties->SetPlayWindow(aStart,aEnd);

	}

TInt CAudioPdPlayUtility::ClearPlayWindow()

	{

    return iProperties->ClearPlayWindow();

	}

TInt CAudioPdPlayUtility::SetBalance(TInt aBalance)

	{

    return iProperties->SetBalance(aBalance);

	}

TInt CAudioPdPlayUtility::GetBalance(TInt& aBalance)

	{

    return iProperties->GetBalance(aBalance);

	}

TInt CAudioPdPlayUtility::GetBitRate(TUint& aBitRate)

	{

    return iProperties->GetBitRate(aBitRate);

	}

void CAudioPdPlayUtility::RegisterForAudioLoadingNotification(MAudioLoadingObserver& aCallback)

	{

    iProperties->RegisterForAudioLoadingNotification(aCallback);

	}

void CAudioPdPlayUtility::GetAudioLoadingProgressL(TInt& aPercentageProgress)

	{

    iProperties->GetAudioLoadingProgressL(aPercentageProgress);

	}

const CMMFControllerImplementationInformation& CAudioPdPlayUtility::ControllerImplementationInformationL()

	{

	return iProperties->ControllerImplementationInformationL();

	}

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

	{

    return iProperties->CustomCommandSync(aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom);

	}

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

	{

    return iProperties->CustomCommandSync(aDestination, aFunction, aDataTo1, aDataTo2);

	}

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

	{

	iProperties->CustomCommandAsync(aDestination, aFunction, aDataTo1, aDataTo2, aDataFrom, aStatus);

	}

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

	{

	iProperties->CustomCommandAsync(aDestination, aFunction, aDataTo1, aDataTo2, aStatus);

	}

void CAudioPdPlayUtility::OpenFileL(const TDesC& aFileName)

	{

	iProperties->OpenFileL(aFileName);

	}

void CAudioPdPlayUtility::OpenFileL(const RFile& aFile)

	{

	RFile& file = const_cast<RFile&>(aFile);

	iProperties->OpenFileL(file);

	}

void CAudioPdPlayUtility::OpenFileL(const TMMSource& aSource)

	{

	iProperties->OpenFileL(aSource);

	}

void CAudioPdPlayUtility::DlCompleteOpenFileL(const TDesC& aFileName)

	{

	iProperties->DlCompleteOpenFileL(aFileName);

	}

TInt CAudioPdPlayUtility::GetFilePosition(TInt& aFilePosition)

	{

	return iProperties->GetFilePosition(aFilePosition);

	}

TInt CAudioPdPlayUtility::SetFileSize(TInt aFileSize)

	{

	return iProperties->SetFileSize(aFileSize);

	}

TInt CAudioPdPlayUtility::SetBytesDownloaded(TInt aBytesDownloaded, TBool aDownloadComplete)

	{

	return iProperties->SetBytesDownloaded(aBytesDownloaded,aDownloadComplete);

	}

MMMFDRMCustomCommand* CAudioPdPlayUtility::GetDRMCustomCommand()

	{

	//ASSERT(iProperties);

	return iProperties->GetDRMCustomCommand();

	}

TInt CAudioPdPlayUtility::CheckAudioPlayerState()

	{

	return iProperties->CheckAudioPlayerState();

	}

//===============================================================

// CAudioPdProperties implementation begins

//

//===============================================================

CAudioPdProperties* CAudioPdProperties::NewL(MAudioPdPlayUtilityCallback& aCallback)

	{

	CAudioPdProperties* self = new(ELeave) CAudioPdProperties(aCallback);

	CleanupStack::PushL(self);

	self->ConstructL(aCallback);

	CleanupStack::Pop(self);

	return self;

	}

CAudioPdProperties* CAudioPdProperties::NewLC(MAudioPdPlayUtilityCallback& /*aCallback*/)

	{

	return NULL;

	}

CAudioPdProperties::~CAudioPdProperties()

	{

	delete iControllerImplementationInformation;

	delete iAsyncCallBack;

	delete iRepeatTrailingSilenceTimer;

	delete iFindAndOpenController;

	delete iControllerEventMonitor;

	iMediaIds.Close();

	iController.Close();

	}

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

	iCallback(aCallback),

	iAudioPlayDeviceCommands(iController),

	iAudioPlayControllerCommands(iController),

	iDRMCustomCommands(iController)

	{

	iState = EStopped;

	iPrioritySettings.iPriority = KAudioPriorityRealOnePlayer;//80

	iPrioritySettings.iPref =(TMdaPriorityPreference) KAudioPrefRealOneLocalPlayback;// 0x01420001;

	iPlayStart = TTimeIntervalMicroSeconds(0);

	iPlayEnd = TTimeIntervalMicroSeconds(0);

	iPlayWindowSet = ENone;

    iSourceHandle =  NULL;

	}

void CAudioPdProperties::ConstructL(MAudioPdPlayUtilityCallback& /*aCallback*/)

	{

	iControllerEventMonitor = CMMFControllerEventMonitor::NewL(*this, iController);

	iRepeatTrailingSilenceTimer = CRepeatTrailingSilenceTimer::NewL(*this);

	iAsyncCallBack = CMMFMdaAudioPlayerCallBack::NewL(iCallback);

	User::LeaveIfError(iMediaIds.Append(KUidMediaTypeAudio));

	iFindAndOpenController = CMMFFindAndOpenController::NewL(*this);

	iFindAndOpenController->Configure(iMediaIds[0], iPrioritySettings);

	iFindAndOpenController->ConfigureController(iController, *iControllerEventMonitor, CMMFFindAndOpenController::EPlayback);

	}

void CAudioPdProperties::MfaocComplete(

		TInt& aError,

		RMMFController* /*aController*/,

		TUid aControllerUid,

		TMMFMessageDestination* aSourceHandle,

		TMMFMessageDestination* /*aSinkHandle*/)

	{

	iSourceHandle = aSourceHandle;

	if (aError == KErrNone)

		{

		iControllerUid = aControllerUid;

		// Get the clip duration

		iDuration = TTimeIntervalMicroSeconds(0);

		aError = iController.GetDuration(iDuration);

		// If an error occurred in any of the above, close the controller.

		if (aError != KErrNone)

			{

			iControllerEventMonitor->Cancel();

			iController.Close();

			}

		}

	iAsyncCallBack->InitComplete(aError, iDuration);

	}

void CAudioPdProperties::HandleDownloadEventL(TUint aTransactionID,

                                              TBrCtlDownloadEvent aEvent,

                                              TUint aValue)

	{

	iCallback.HandleDownloadEventL(aTransactionID,aEvent,aValue);

	}

void CAudioPdProperties::OpenFileL(const TDesC& aFileName)

	{

	TMMFileSource filesource(aFileName, ContentAccess::KDefaultContentObject, ContentAccess::EPlay);

	OpenFileL(filesource);

	}

void CAudioPdProperties::OpenFileL(const RFile& aFile)

	{

	RFile& file = const_cast<RFile&>(aFile);

	TMMFileHandleSource filesource(file, KNullDesC, ContentAccess::EPlay);

	OpenFileL(filesource);

	}

void CAudioPdProperties::OpenFileL(const TMMSource& aSource)

	{

	// If iAsyncCallBack is already active, we're still in the process of notifying the client

	// that a previous request to Open...(...) has completed.

	if (iAsyncCallBack->IsActive())

		User::Leave(KErrNotReady);

	if (aSource.SourceType()==KUidMMFileHandleSource)

		{

		RFile& fileHandle = static_cast<const TMMFileHandleSource&>(aSource).Handle();

	    iFindAndOpenController->ConfigureSourceSink(

	       CMMFFindAndOpenController::TSourceSink(KUidProgressiveDlSource,fileHandle),

		   CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput));

		}

	if (aSource.SourceType()==KUidMMFileSource)

		{

		const TDesC& fileName = static_cast<const TMMFileSource&>(aSource).Name();

	    iFindAndOpenController->ConfigureSourceSink(

	       CMMFFindAndOpenController::TSourceSink(KUidProgressiveDlSource,

	       CMMFFindAndOpenController::GetConfigFile(fileName)),

		   CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput));

		}

	iFindAndOpenController->OpenByFileSource(aSource);

	}

void CAudioPdProperties::DlCompleteOpenFileL(const TDesC& aFileName)

	{

	if (iAsyncCallBack->IsActive())

		User::Leave(KErrNotReady);

	Close();

	TMMFileSource filesource(aFileName, ContentAccess::KDefaultContentObject, ContentAccess::EPlay);

	iFindAndOpenController->ConfigureSourceSink(

			TMMFileSource(aFileName, filesource.UniqueId(), filesource.Intent(), filesource.IsUIEnabled()),

			CMMFFindAndOpenController::TSourceSink(KUidMmfAudioOutput));

	iFindAndOpenController->OpenByFileSource(filesource);

	}

void CAudioPdProperties::Play()

	{

	// if we're already playing, call the client's callback with KErrNotReady.

	// This is what the controller would do if we allowed the Play()

	// to propagate down. Need to do it here too (for consistency)

	// in case we're in a trailing silence period.

    if (iState == EPlaying)

		{

		iAsyncCallBack->PlayComplete(KErrNotReady);

		return;

		}

	// cancel the repeat timer in case the client has called Play()

	// without waiting for the previous play to complete

	iRepeatTrailingSilenceTimer->Cancel();

	// Reset played count

	iNumberOfTimesPlayed = 0;

	DoPlay();

	}

void CAudioPdProperties::DoPlay()

	{

#if defined(__AUDIO_PROFILING)

	RDebug::ProfileStart(4);

#endif  // defined(__AUDIO_PROFILING)

    TInt err = KErrNone;

    if (iState != EPaused)

        {

		err = iController.Prime();

#if defined(__AUDIO_PROFILING)

	RDebug::ProfileEnd(4);

#endif  // defined(__AUDIO_PROFILING)

		// make sure we don't set the position outside the play window -

		// but allow it to remain unchanged if it's within the window

		if (iPlayWindowSet == ESet &&

			(iPosition < iPlayStart || iPosition >= iPlayEnd))

			iPosition = iPlayStart;

		if (err==KErrNone)

			err = iController.SetPosition(iPosition);

        }

	if (err==KErrNone)

		{

		if (iPlayWindowSet == ESet)

			err = iAudioPlayControllerCommands.SetPlaybackWindow(iPlayStart, iPlayEnd);

		else if (iPlayWindowSet == EClear)

			{

			err = iAudioPlayControllerCommands.DeletePlaybackWindow();

			iPlayWindowSet = ENone;	// assume window will stay cleared

			}

		}

	if (err==KErrNone)

		{

#if defined(__AUDIO_PROFILING)

		RDebug::ProfileStart(5);

#endif  // defined(__AUDIO_PROFILING)

		err = iController.Play();

#if defined(__AUDIO_PROFILING)

		RDebug::ProfileEnd(5);

#endif  // defined(__AUDIO_PROFILING)

		}

	if (err!=KErrNone)

		iAsyncCallBack->PlayComplete(err);

	else

		{

		iState = EPlaying;

		iCallback.Playing();

		}

	}

void CAudioPdProperties::Stop()

	{

	if (iState==EPlaying || iState==EPaused)

		{

		// cancel the repeat timer in case the client has called Stop()

		// during the trailing silence period

		iRepeatTrailingSilenceTimer->Cancel();

		iController.Stop();

		iPosition = iPlayStart;

		iState = EStopped;

		}

	}

TInt CAudioPdProperties::Pause()

	{

    TInt err = KErrNone;

	if (iState==EPlaying)

		{

		err = iController.Pause();

		if (!err || err==KErrNotReady)

			err = iController.GetPosition(iPosition);

		iState = EPaused;

		iCallback.Paused();

		}

	return err;

	}

void CAudioPdProperties::SetVolume(TInt aVolume)

	{

	TInt err = iAudioPlayDeviceCommands.SetVolume(aVolume);

	__ASSERT_ALWAYS(err==KErrNone, Panic(EMMFMediaClientBadArgument));

	}

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

	{

	iNumberOfTimesToRepeat = aRepeatNumberOfTimes;

	iTrailingSilence = aTrailingSilence;

	}

void CAudioPdProperties::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)

	{

	iAudioPlayDeviceCommands.SetVolumeRamp(aRampDuration);

	}

const TTimeIntervalMicroSeconds& CAudioPdProperties::Duration()

	{

	TInt err = iController.GetDuration(iDuration);

	if (err)

		{