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

/**
 @file
 @internalComponent - Internal Symbian test code 
*/

#include "contentmgr.h"
#include <apmstd.h>
#include <mdaaudiosampleplayer.h>
#include <apparc.h>
#include <apgcli.h>

GLDEF_C TInt E32Dll(
					)
	{
	return(KErrNone);
	}

//
// class CTestPictureAudio
//

class CTestPictureAudio : public CPicture, public MMdaAudioPlayerCallback
	{
public:
	static CTestPictureAudio* NewL(RFs& aFs,const TDesC& aFileName);
	static CTestPictureAudio* NewL(RFs& aFs,const CStreamStore& aStore,TStreamId aStreamId);
	~CTestPictureAudio();
	//
	void PlayL();
private: // from CPicture
	void Draw(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,MGraphicsDeviceMap* aMap) const;
	void ExternalizeL(RWriteStream& aStream) const;
	void GetOriginalSizeInTwips(TSize& aSize) const;
private: // from MMdaAudioPlayerCallback
	void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration);
	void MapcPlayComplete(TInt aError);
private:
	CTestPictureAudio(RFs& aFs);
	void ConstructL(const TDesC& aFileName);
	void ConstructL(const CStreamStore& aStore,TStreamId aStreamId);
	void CommonConstructL();
	void RestoreL(const CStreamStore& aStore,TStreamId aStreamId);
	void StopPlay();
private:
	RFs& iFs;
	CFbsBitmap* iBitmap;
	CMdaAudioPlayerUtility* iSoundPlayer;
	HBufC8* iPlayBuf;
	TPtr8 iPtr;
	};

_LIT(KBitmapName,"\\system\\data\\contentmgr.mbm");

CTestPictureAudio* CTestPictureAudio::NewL(RFs& aFs,const TDesC& aFileName)
	{ // static
	CTestPictureAudio* self=new(ELeave) CTestPictureAudio(aFs);
	CleanupStack::PushL(self);
	self->ConstructL(aFileName);
	CleanupStack::Pop(); // self
	return self;
	}

CTestPictureAudio* CTestPictureAudio::NewL(RFs& aFs,const CStreamStore& aStore,TStreamId aStreamId)
	{ // static
	CTestPictureAudio* self=new(ELeave) CTestPictureAudio(aFs);
	CleanupStack::PushL(self);
	self->ConstructL(aStore,aStreamId);
	CleanupStack::Pop(); // self
	return self;
	}

CTestPictureAudio::~CTestPictureAudio()
	{
	StopPlay();
	delete iBitmap;
	delete iPlayBuf;
	}

void CTestPictureAudio::PlayL()
	{
	StopPlay();
	iSoundPlayer=CMdaAudioPlayerUtility::NewDesPlayerL(iPtr,*this);
	}

void CTestPictureAudio::Draw(CGraphicsContext& aGc,const TPoint& aTopLeft,const TRect& aClipRect,
												MGraphicsDeviceMap* /*aMap*/) const
	{
	TSize sizeInPixels=iBitmap->SizeInPixels();
	TRect originalRectInPixels(aTopLeft,sizeInPixels);
	aGc.SetClippingRect(aClipRect);
	aGc.DrawBitmap(originalRectInPixels,iBitmap);
	aGc.CancelClippingRect();
	}

void CTestPictureAudio::ExternalizeL(RWriteStream& aStream) const
	{
	aStream.WriteInt32L(iPtr.Length());
	aStream.WriteL(iPtr);
	}

void CTestPictureAudio::GetOriginalSizeInTwips(TSize& aSize) const
	{
	TSize sizeInPixels=iBitmap->SizeInPixels();
	TInt vert=iBitmap->VerticalPixelsToTwips(sizeInPixels.iHeight);
	TInt horiz=iBitmap->HorizontalPixelsToTwips(sizeInPixels.iWidth);
	aSize=TSize(horiz,vert);
	}

void CTestPictureAudio::MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& /*aDuration*/)
	{
	if (aError)
		{
		StopPlay();
		return;;
		}
	iSoundPlayer->Play();
	}

void CTestPictureAudio::MapcPlayComplete(TInt /*aError*/)
	{
	StopPlay();
	}

CTestPictureAudio::CTestPictureAudio(RFs& aFs)
	: iFs(aFs), iPtr(NULL,0)
	{}

LOCAL_C void GetFullPath(TDes& aPath)
	{
	TFileName dllName;
	Dll::FileName(dllName);
	TBuf<2> drive=dllName.Left(2);
	aPath.Insert(0,drive);
	}

void CTestPictureAudio::CommonConstructL()
	{
	TFileName bitmapFile=KBitmapName();
	GetFullPath(bitmapFile);
	iBitmap=new(ELeave) CFbsBitmap;
	User::LeaveIfError(iBitmap->Load(bitmapFile));
	}

void CTestPictureAudio::ConstructL(const TDesC& aFileName)
	{
	CommonConstructL(); // creates bitmap
	RFile file;
	User::LeaveIfError(file.Open(iFs,aFileName,EFileRead));
	CleanupClosePushL(file);
	TInt size;
	User::LeaveIfError(file.Size(size));
	iPlayBuf=HBufC8::NewL(size);
	TPtr8 ptr=iPlayBuf->Des();
	iPtr.Set(ptr);
	User::LeaveIfError(file.Read(iPtr));
	CleanupStack::PopAndDestroy(); // file.Close()
	}

void CTestPictureAudio::ConstructL(const CStreamStore& aStore,TStreamId aStreamId)
	{
	CommonConstructL(); // creates bitmap
	// following is a poor example.  There's no reason for us to waste time restoring the embedded
	// stream yet.  We could wait till its really needed but that requires more faffing with Store
	// than can be justified for some quick example code.
	RestoreL(aStore,aStreamId);
	}

void CTestPictureAudio::RestoreL(const CStreamStore& aStore,TStreamId aStreamId)
	{
	RStoreReadStream stream;
	stream.OpenLC(aStore,aStreamId);
	const TInt len=stream.ReadInt32L();
	iPlayBuf=HBufC8::NewL(len);
	TPtr8 ptr=iPlayBuf->Des();
	stream.ReadL(ptr,len);
	CleanupStack::PopAndDestroy(); // stream
	iPtr.Set(ptr);
	}

void CTestPictureAudio::StopPlay()
	{
	delete iSoundPlayer;
	iSoundPlayer=NULL;
	}

//
// class CTestAudioContent
//

class CTestAudioContent : public CBase
	{
public:
	CStreamStore* iHost;
	TFileName iSourceFile;
	};

//
// class CEikTestContentManager
//

_LIT8(KContentDataTypeAudio,"audio/*");
const TUid KTestContentType={5711};

EXPORT_C CEikTestContentManager* CEikTestContentManager::NewL(RFs& aFs)
	{ // static
	CEikTestContentManager* self=new(ELeave) CEikTestContentManager(aFs);
	return self;
	}

EXPORT_C CEikTestContentManager::~CEikTestContentManager()
	{
	}

EXPORT_C void CEikTestContentManager::GetPictureTypeFromDataL(TUid& aPictureType,CBase*& aData,
															  const TDesC& aFileName,const TDesC8& aSrcData) const
	{
	RApaLsSession ls;
	User::LeaveIfError(ls.Connect());
	CleanupClosePushL(ls);
	TDataRecognitionResult res;
	User::LeaveIfError(ls.RecognizeData(aFileName,aSrcData,res));
	CleanupStack::PopAndDestroy(); // ls
	//
	TUid type=KNullUid;
	if (res.iDataType.Des8().MatchF(KContentDataTypeAudio)==0)
		{
		CTestAudioContent* data=new(ELeave) CTestAudioContent;
		data->iSourceFile=aFileName;
		aData=data;
		type=KTestContentType;
		}
	aPictureType=type;
	}

TBool CEikTestContentManager::SupportsPictureType(TUid aPictureType) const
	{
	return (aPictureType==KTestContentType);
	}

const MPictureFactory* CEikTestContentManager::PictureFactory(TUid aPictureType) const
	{
	if (aPictureType==KTestContentType)
		{
		return this;
		}
	return NULL;
	}

TPictureHeader CEikTestContentManager::InsertL(TUid aPictureType,CBase* aData)
	{
	TPictureHeader header;
	if (aPictureType==KTestContentType)
		{
		CPicture* picture=CTestPictureAudio::NewL(iFs,static_cast<CTestAudioContent*>(aData)->iSourceFile);
		header.iPicture=picture;
		header.iPictureType=aPictureType;
		picture->GetOriginalSizeInTwips(header.iSize);
		}
	return header;
	}

void CEikTestContentManager::EditL(const TPictureHeader& aPictureHeader,TBool /*aReadOnly*/)
	{
	CTestPictureAudio* picture=static_cast<CTestPictureAudio*>(aPictureHeader.iPicture.AsPtr());
	picture->PlayL();
	}

void CEikTestContentManager::NewPictureL(TPictureHeader& aHeader,const CStreamStore& aDeferredPictureStore) const
	{
	if (aHeader.iPictureType!=KTestContentType)
		{
		User::Leave(KErrNotSupported);
		}
	TStreamId id=aHeader.iPicture.AsId();
	CTestPictureAudio* picture=CTestPictureAudio::NewL(iFs,aDeferredPictureStore,id);
	aHeader.iPicture=picture;
	}

CEikTestContentManager::CEikTestContentManager(RFs& aFs)
	: iFs(aFs)
	{}