/*

* 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 "EMCPdPlayUtility.h"

#include "EMCPdProperties.h"

#include "MProgressiveDownloadUtility.h"

#include <apgcli.h>

#include <AudioPreference.h>

#include <SCCustomInterfaceUIDs.h>

#include <drmagents.h>

#include <DRMConfigIntfc.h>

#include <content.h>

#include <data.h>

#include <MetaDataFieldContainer.h>

#include <MetaDataUtility.h>

#include <mmfmeta.h>

_LIT8(KWMAMimeType,"audio/x-ms-wma");

using namespace ContentAccess;

using namespace DRM;

#ifdef _DEBUG

#define DEBPRN1(str)        RDebug::Print(str);

#define DEBPRN2(str, val1)   RDebug::Print(str, val1);

#define DEBPRN3(str, val1, val2)   RDebug::Print(str, val1, val2);

#define DEBPRN4(str, val1, val2, val3)   RDebug::Print(str, val1, val2, val3);

#define DEBPRN5(str, val1, val2, val3, val4)   RDebug::Print(str, val1, val2, val3, val4);

#else

#define DEBPRN1(str)

#define DEBPRN2(str, val1)

#define DEBPRN3(str, val1, val2)

#define DEBPRN4(str, val1, val2, val3)

#define DEBPRN5(str, val1, val2, val3, val4)

#endif // _DEBUG

const TInt KNumberOfBuffers = 10;

//const TUid KUidProgressiveDlSource	= {KProgressiveDownloadSourceUid};

const TInt KBufferingAmount = 40960;

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::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()

	{

    if(iMimeType)

        {

        delete iMimeType;

        iMimeType = NULL;

        }

    if(iBufferEmptiedEventAO->IsActive())

        {

        iBufferEmptiedEventAO->Cancel();

        }

    delete iBufferEmptiedEventAO;

    iFactory->DeleteStreamControl(iStreamControl);

    while(iBuffers.Count())

        {

        MDataBuffer* temp = iBuffers[0];

        iBuffers.Remove(0);

        iFactory->DeleteDataBuffer(temp);

        }

    if(iMDataBufferSource)

        {

        MSourceControl* objPtr = iMDataBufferSource;

        iFactory->DeleteSourceControl(objPtr);

        iMDataBufferSource = NULL;

        }

    MSinkControl* objPtr1 = iMAudioSink;

    iFactory->DeleteSinkControl(objPtr1);

	if(iMVolumeControl)

		{

		MEffectControl* effectObj = iMVolumeControl;

		iFactory->DeleteEffectControl(effectObj);

		iMVolumeControl = NULL;

		}

    if(iFileName)

        {

        delete iFileName;

        iFileName = NULL;

        }

    if (iMetaDataEntries.Count())

    	{

        iMetaDataEntries.ResetAndDestroy();

		iMetaDataEntries.Close();

		}

    delete iFile;

    iFile = NULL;

    iFs.Close();

    iBuffers.ResetAndDestroy();

    iBuffers.Close();

    iAvailable.Close();

 	delete iFactory;

	delete iControllerImplementationInformation;

	delete iAsyncCallBack;

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

	iBuffering = EFalse;

	iControllerPtr = NULL;

	iStopCalled = EFalse;

	iFileName = NULL;

	}

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

	{

	iAsyncCallBack = CMMFMdaAudioPlayerCallBack::NewL(iCallback);

    iBufferEmptiedEventAO = CBufferEmptiedEventAO::NewL(*this);

    iMimeType = HBufC8::NewL(20);

    TInt status = CMultimediaFactory::CreateFactory( iFactory );

    TInt err = iFactory->CreateStreamControl( KStreamControl, iStreamControl );

    User::LeaveIfError(err);

    iStreamControl->AddObserver( *this );

    MSinkControl* tempSinkCtrl(NULL);

    err = iFactory->CreateSinkControl( KMMFAudioOutputSinkControl, tempSinkCtrl );

    User::LeaveIfError(err);

	iMAudioSink = tempSinkCtrl;

    iStreamControl->AddSink( *iMAudioSink );

    MSourceControl* tempCtrl(NULL);

    err = iFactory->CreateSourceControl( KDataBufferSourceControl, tempCtrl );

    User::LeaveIfError(err);

    CreateAudioBuffersL();

    iMDataBufferSource = static_cast<MDataBufferSource*>(tempCtrl);

    iMDataBufferSource->AddObserver( *this );

	//Create Volume Control

	MEffectControl* effectCtrl(NULL);

	err = iFactory->CreateEffectControl( KVolumeEffectControl, effectCtrl );

	User::LeaveIfError(err);

	iMVolumeControl = static_cast<MVolumeControl*>(effectCtrl);

	err = iStreamControl->AddEffect( *iMVolumeControl );

	}

void CAudioPdProperties::HandleDownloadEventL(TUint aTransactionID,

                                              TBrCtlDownloadEvent aEvent,

                                              TUint aValue)

	{

	iCallback.HandleDownloadEventL(aTransactionID,aEvent,aValue);

	}

void CAudioPdProperties::CreateAudioBuffersL()

    {

    MDataBuffer* buffer;

    iBuffers.ResetAndDestroy();

    iAvailable.Reset();

    for (int i = 0; i < KNumberOfBuffers; i++ )

        {

        iFactory->CreateDataBuffer(KDataBufferSourceControl,4096,buffer);

        User::LeaveIfError(iBuffers.Append(buffer));

        buffer = NULL;

        iAvailable.AppendL(ETrue);

        }

    }

void CAudioPdProperties::DetermineFNMimeType(const TDesC& aFileName, TDes8& aMimeType)

    {

    RApaLsSession ls;

    TInt err;

    err=ls.Connect();

    TDataRecognitionResult result;

    err = ls.RecognizeData(aFileName,KNullDesC8(),result);

    if(!err && (result.iConfidence >= CApaDataRecognizerType::EProbable))

        {

        aMimeType.Copy(result.iDataType.Des8());

        }

    ls.Close();

    }

void CAudioPdProperties::DetermineFHMimeType(const RFile& aFile, TDes8& aMimeType)

    {

    RApaLsSession ls;

    TInt err;

    err=ls.Connect();

    TDataRecognitionResult result;

    err = ls.RecognizeData(aFile,result);

    if(!err && (result.iConfidence >= CApaDataRecognizerType::EProbable))

        {

        aMimeType.Copy(result.iDataType.Des8());

        }

    ls.Close();

    }

void CAudioPdProperties::OpenFileL(const TDesC& aFileName)

	{

    TBuf8<20> mimeType;

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

    if(iFileName)

        {

        delete iFileName;

        iFileName = NULL;

        }

    iFileName = HBufC::NewL(aFileName.Length());

    TPtr des = iFileName->Des();

    des.Copy(aFileName);

	TInt err = ExtractDRMRestrictionsL();

	User::LeaveIfError(err);

    if(!isProtected)

        {

        DetermineFNMimeType(aFileName,mimeType);

        iMimeType->Des().Copy(mimeType);

        }

    if(iMimeType->Des().Length())

        {

        DEBPRN1(_L("CAudioPdProperties::OpenFileL() Before iFile Open "));

    	iFile =  CContentFile::NewL(iFs,aFileName, KNullDesC, EFileShareAny,EFalse);

        DEBPRN2(_L("CAudioPdProperties::OpenFileL() After iFile Open Error[%d]"),err);

        iStreamControl->AddSource(*iMDataBufferSource);

    	MDataBuffer* dataBuffer = NULL;

    	err = iMDataBufferSource->Open(*iMimeType,*dataBuffer);

    	User::LeaveIfError(err);

        SetPriority(iPrioritySettings.iPriority,(TMdaPriorityPreference)iPrioritySettings.iPref);

    	iStreamControl->Open();

        }

    else

        {

        User::Leave(KErrNotSupported);

        }

	}

void CAudioPdProperties::OpenFileL(const RFile& aFile)

	{

    TBuf8<20> mimeType;

    iFileHandle = aFile;

	TInt err = ExtractDRMRestrictionsL();

	User::LeaveIfError(err);

    if(!isProtected)

        {

        DetermineFHMimeType(iFileHandle,mimeType);

        iMimeType->Des().Copy(mimeType);

        }

    iFile =  CContentFile::NewL(iFileHandle, KNullDesC ,EFalse);

    if(iMimeType->Des().Length())

        {

        MDataBuffer* dataBuffer = NULL;

    	TInt err = iMDataBufferSource->Open(*iMimeType,*dataBuffer);

    	User::LeaveIfError(err);

        SetPriority(iPrioritySettings.iPriority,(TMdaPriorityPreference)iPrioritySettings.iPref);

    	iStreamControl->Open();

        }

    else

        {

        User::Leave(KErrNotSupported);

        }

	}

void CAudioPdProperties::DlCompleteOpenFileL(const TDesC& aFileName)

	{

	OpenFileL(aFileName);

	}