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

// extendedfunctionality.cpp

// 

//

#include "extended_functionality.h"

#include "AdvancedSettings.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ecamcapturecontrolconst.h>

#include <ecamviewfinderdef.h>

#include "ecamdef.h"

#endif

//

//pre image capture control impl

CCamPreImageCaptureControl* CCamPreImageCaptureControl::NewL(CCamUnitTestPlugin& aOwner)

	{

	return new(ELeave) CCamPreImageCaptureControl(aOwner);

	}

CCamPreImageCaptureControl::CCamPreImageCaptureControl(CCamUnitTestPlugin& aOwner): iOwner(aOwner),

																					iPreImageCaptureControlObserver(NULL)

	{

	}

CCamPreImageCaptureControl::~CCamPreImageCaptureControl()

	{

	}

void CCamPreImageCaptureControl::Release()

	{	

	delete this;

	}

void CCamPreImageCaptureControl::SetPreImageCaptureControlObserver(MPreImageCaptureControlObserver& aPreImageCaptureControlObserver)

	{

	iPreImageCaptureControlObserver = &aPreImageCaptureControlObserver;

	}

void CCamPreImageCaptureControl::GetDirectSnapshotSupportInfoL(TUint& aDirectSnapshotSupportInfo) const

	{

	aDirectSnapshotSupportInfo = CCamera::CCameraPreImageCaptureControl::EDirectSnapshotSupported;

	}

void CCamPreImageCaptureControl::GetSupportedEmbeddedStillCaptureSettingsL(RArray<TUid>& aSupportedEmbeddedStillCaptureSettings) const

	{

	aSupportedEmbeddedStillCaptureSettings.Reset();

	}

void CCamPreImageCaptureControl::GetSupportedDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType& aSupportedDirectSavingType) const

	{

	aSupportedDirectSavingType = CCamera::CCameraPreImageCaptureControl::EDirectSavingNotUsed;

	}

void CCamPreImageCaptureControl::SetSequentialImageFilenameL(const TDesC8& /*aFilename*/, TInt /*aStartingSequenceNumber*/)

	{

	User::Leave(KErrNotSupported);

	}

void CCamPreImageCaptureControl::SetLowerResolutionSequentialImageFilenameL(const TDesC8& /*aLowerResolutionFilename*/, TInt /*aStartingSequenceNumber*/)

	{

	User::Leave(KErrNotSupported);

	}

void CCamPreImageCaptureControl::GetDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType& aDirectSavingType) const

	{

	aDirectSavingType = CCamera::CCameraPreImageCaptureControl::EDirectSavingNotUsed;	

	}

void CCamPreImageCaptureControl::SetDirectSavingTypeL(CCamera::CCameraPreImageCaptureControl::TDirectSavingType /*aDirectSavingType*/)

	{

	User::Leave(KErrNotSupported);

	}

void CCamPreImageCaptureControl::GetCaptureEventSupportInfoL(TUint& aSupportedDriveModes) const

	{

	aSupportedDriveModes = 0; 	

	}

void CCamPreImageCaptureControl::GetImageFormatsSupportedL(TUint& aImageFormatsSupported, const TSize& /*aSize*/) const

	{

	aImageFormatsSupported = CCamera::EFormatFbsBitmapColor16M;

	}

void CCamPreImageCaptureControl::GetPixelAspectsSupportedL(TUint& aPixelAspectsSupported, CCamera::TFormat /*aImageFormat*/, const TSize& /*aSize*/) const

	{

	aPixelAspectsSupported = CCamera::CCameraAdvancedSettings::EPixelAspect1To1;

	}

void CCamPreImageCaptureControl::PrepareImageCapture(const CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& 

								aPrepareImageParameters, MCaptureImageObserver& aCaptureImageObserver)

	{

	//perform any prepare operation at hardware level eg. memory allocation etc.

	CCamera::CCameraImageCapture* cameraImageCapture = NULL;

	TRAPD(err,CreateCaptureImageL(cameraImageCapture, aPrepareImageParameters, aCaptureImageObserver));

	PreImageCaptureControlObserver()->PrepareImageComplete(cameraImageCapture, err);

	}

void CCamPreImageCaptureControl::GetImageMaxMemorySizeSettingSupportInfoL(TBool& aIsImageMaxMemorySizeSettingSupported) const

	{

	aIsImageMaxMemorySizeSettingSupported = EFalse;

	}

void CCamPreImageCaptureControl::GetImageMaxMemorySizeL(TUint& /*aMemorySize*/) const

	{

	User::Leave(KErrNotSupported);

	}

void CCamPreImageCaptureControl::GetSupportedProcessingOptionsL(TUint& /*aSupportedProcessingOptions*/) const

	{

	User::Leave(KErrNotSupported);

	}

void CCamPreImageCaptureControl::CreateCaptureImageL(CCamera::CCameraImageCapture*& aCameraImageCapture, const CCamera::

		CCameraPreImageCaptureControl::TPrepareImageParameters& aPrepareImageParameters, MCaptureImageObserver& aCaptureImageObserver)

	{

	CCamera::CCameraImageCapture* cameraImageCapture = CCamera::CCameraImageCapture::CreateL(iOwner, aPrepareImageParameters, aCaptureImageObserver);

	aCameraImageCapture = cameraImageCapture;

	}

//

//image capture impl

CCamImageCapture* CCamImageCapture::NewL(CCamUnitTestPlugin& aOwner)

	{

	return new(ELeave) CCamImageCapture(aOwner);

	}

CCamImageCapture::CCamImageCapture(CCamUnitTestPlugin& aOwner) : iOwner(aOwner), 

																 iCaptureImageObserver(NULL), 

																 iSnapshotImpForImage(NULL),

																 iCamImgProcImpForImage(NULL),

																 iCameraImageCapture(NULL)

	{

	iArrayPostCaptureControlId.Reset();

	iArrayPostCaptureControlHandle.Reset();

	iArrayPostCaptureControlImpl.Reset();

	}

CCamImageCapture::~CCamImageCapture()

	{

	iArrayPostCaptureControlId.Close();

	iArrayPostCaptureControlHandle.Reset();

	iArrayPostCaptureControlImpl.Reset();

	iArrayPostCaptureControlHandle.Close();

	iArrayPostCaptureControlImpl.Close();

	}

void CCamImageCapture::Release(CCamera::CCameraImageCapture* /*aCameraImageCapture*/)

	{

	delete this;

	}

void CCamImageCapture::CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const

	{

	aImplFactoryPtr	= CHistogramFactoryForImage::NewL(const_cast<CCamImageCapture&>(*this));

	}

void CCamImageCapture::GetSnapshotImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const

	{

	aImplFactoryPtr = CSnapshotFactoryForImage::NewL(const_cast<CCamImageCapture&>(*this), iSnapshotImpForImage);

	}

void CCamImageCapture::GetImageProcessingImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const

	{

	aImplFactoryPtr = CImgProcFactoryForImage::NewL(const_cast<CCamImageCapture&>(*this), iCamImgProcImpForImage);

	}

void CCamImageCapture::SetCaptureImageObserver(MCaptureImageObserver& aCaptureImageObserver)

	{

	iCaptureImageObserver = &aCaptureImageObserver;

	}

void CCamImageCapture::GetPrepareImageParametersL(CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& aPrepareImageParameters) const

	{

	if(aPrepareImageParameters.Size() != sizeof(CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters) ||

		aPrepareImageParameters.Version() != KECamPrepareImageParametersCurrentVersion)

		{

		User::Leave(KErrNotSupported);

		}

	if(aPrepareImageParameters.iDriveModeAttributes.Size() != sizeof(CCamera::CCameraPreImageCaptureControl::TDriveModeDependentAttributes) ||

		aPrepareImageParameters.iDriveModeAttributes.Version() != KECamDriveModeDependentAttributesCurrentVersion)

		{

		User::Leave(KErrNotSupported);

		}

	aPrepareImageParameters = iPrepareImageParameters;

	}

void CCamImageCapture::SetPrepareImageParameters(const CCamera::CCameraPreImageCaptureControl::TPrepareImageParameters& aPrepareImageParameters)

	{

	iPrepareImageParameters = aPrepareImageParameters;

	}

TAny* CCamImageCapture::CreatePostImageCaptureControlImpl(TUid aInterface, TPostCaptureControlId aPostCaptureControlId)

	{

	TInt err=KErrNone;

	if(aInterface.iUid == KECamMCameraPostImageCaptureControlUidValue)

		{

		if(iArrayPostCaptureControlId.Find(aPostCaptureControlId) == KErrNotFound)

			{

			CCamPostImageCaptureControl* camPostImageCaptureControl = NULL;

			TRAP(err, camPostImageCaptureControl = CCamPostImageCaptureControl::NewL(const_cast<CCamImageCapture&>(*this)));

			if (err == KErrNone)

				{

				err = iArrayPostCaptureControlId.Append(aPostCaptureControlId);

				if(err == KErrNone)

					{

					err = iArrayPostCaptureControlImpl.Append(camPostImageCaptureControl);

					if(err != KErrNone)

						{

						iArrayPostCaptureControlId.Remove(iArrayPostCaptureControlId.Count()-1);

						delete camPostImageCaptureControl;

						return NULL;

						}

					else

						{

						return static_cast<MCameraPostImageCaptureControl*>(camPostImageCaptureControl);	

						}

					}

				else

					{

					delete camPostImageCaptureControl;

					return NULL;	

					}

				}

			else

				{

				return NULL;

				}

			}

		else

			{

			return NULL;

			}

		}

	else

		{

		return NULL;

		}	

	}

void CCamImageCapture::CaptureImage(CCamera::CCameraImageCapture* aCameraImageCapture)

	{

	TInt count = iArrayPostCaptureControlId.Count();

	while(count > 0)

		{

		iArrayPostCaptureControlId.Remove(count-1);

		iArrayPostCaptureControlImpl.Remove(count-1);

		delete iArrayPostCaptureControlHandle[count-1];

		iArrayPostCaptureControlHandle.Remove(count-1);

		count = iArrayPostCaptureControlId.Count();

		}

	iCameraImageCapture = aCameraImageCapture;

	//this will create Post Image capture control object. assume one such object is required. ( for demo purpose only)

	CCamera::CCameraPostImageCaptureControl* postImageCaptureControl = NULL;

	TRAPD(err,CreatePostImageCaptureControlL(postImageCaptureControl, 1));

	if(err == KErrNone)

		{

		err = iArrayPostCaptureControlHandle.Append(postImageCaptureControl);

		if(err != KErrNone)

			{

			iArrayPostCaptureControlId.Remove(iArrayPostCaptureControlId.Count()-1);

			iArrayPostCaptureControlImpl.Remove(iArrayPostCaptureControlImpl.Count()-1);

			delete postImageCaptureControl;

			}

		else

			{

			CaptureImageObserver()->IndividualImageControlHandle(*iCameraImageCapture, 1);

			}

		}

	CaptureImageObserver()->ImageCaptureComplete(*iCameraImageCapture, KErrNotSupported);

	}

void CCamImageCapture::CancelCaptureImage()

	{

	return;

	}

void CCamImageCapture::GetNumImagesExposedL(TUint& /*aNumImagesExposed*/) const

	{

	User::Leave(KErrNotSupported);

	}

void CCamImageCapture::GetNumTotalImagesL(TUint& aNumTotalImages) const

	{

	aNumTotalImages = 1;	

	}

void CCamImageCapture::GetPostCaptureControlHandleL(CCamera::CCameraPostImageCaptureControl*& aPostCaptureControlHandle, 

									TPostCaptureControlId aPostCaptureControlId) const

	{

	TInt index = iArrayPostCaptureControlId.Find(aPostCaptureControlId);

	User::LeaveIfError(index);

	aPostCaptureControlHandle = iArrayPostCaptureControlHandle[index];

	}

void CCamImageCapture::SetCaptureImagePriorityL(TECamImagePriority /*aCaptureImagePriority*/)

	{

	User::Leave(KErrNotSupported);

	}

void CCamImageCapture::GetCaptureImagePriorityL(TECamImagePriority& /*aCaptureImagePriority*/) const

	{

	User::Leave(KErrNotSupported);	

	}

void CCamImageCapture::PauseProcessing(TUint /*aProcessingType*/)

	{

	return;

	}

void CCamImageCapture::ResumeProcessingL(TUint /*aProcessingType*/)

	{

	User::Leave(KErrNotSupported);

	}

void CCamImageCapture::CreatePostImageCaptureControlL(CCamera::CCameraPostImageCaptureControl*& aPostCaptureControlHandle, 

						TPostCaptureControlId aPostCaptureControlId)

	{

	CCamera::CCameraPostImageCaptureControl* postImageCaptureControl = CCamera::CCameraPostImageCaptureControl::

					CreateL(iCameraImageCapture, aPostCaptureControlId);

	aPostCaptureControlHandle = postImageCaptureControl;

	}

//

//post image capture control impl

CCamPostImageCaptureControl* CCamPostImageCaptureControl::NewL(CCamImageCapture& aCamImageCaptureImpl)

	{

	return new(ELeave) CCamPostImageCaptureControl(aCamImageCaptureImpl);

	}

CCamPostImageCaptureControl::CCamPostImageCaptureControl(CCamImageCapture& aCamImageCaptureImpl) : 

													iCamImageCaptureImpl(aCamImageCaptureImpl)

	{

	}

CCamPostImageCaptureControl::~CCamPostImageCaptureControl()

	{

	}

void CCamPostImageCaptureControl::Release(TPostCaptureControlId aPostCaptureControlId)

	{

	//remove this id from the CCamImageCapture arrays

	TInt index = iCamImageCaptureImpl.iArrayPostCaptureControlId.Find(aPostCaptureControlId);

	if(index >=0 )

		{

		iCamImageCaptureImpl.iArrayPostCaptureControlId.Remove(index);

		iCamImageCaptureImpl.iArrayPostCaptureControlImpl.Remove(index);

		iCamImageCaptureImpl.iArrayPostCaptureControlHandle.Remove(index);

		}

	delete this;

	}

void CCamPostImageCaptureControl::GetImageSequenceNumberL(TUint& /*aSequenceNumber*/) const

	{

	User::Leave(KErrNotSupported);

	}

void CCamPostImageCaptureControl::CancelImage()

	{

	return;

	}

void CCamPostImageCaptureControl::SetImagePriorityL(TECamImagePriority /*aImagePriority*/)

	{

	User::Leave(KErrNotSupported);

	}

void CCamPostImageCaptureControl::GetImagePriorityL(TECamImagePriority& /*aImagePriority*/) const

	{

	User::Leave(KErrNotSupported);	

	}

void CCamPostImageCaptureControl::PauseProcessing(TUint /*aProcessingType*/)

	{

	return;

	}

void CCamPostImageCaptureControl::ResumeProcessingL(TUint /*aProcessingType*/)

	{

	User::Leave(KErrNotSupported);

	}

void CCamPostImageCaptureControl::GetImageBufferL(MCameraImageBuffer& /*aCameraImageBuffer*/) const

	{

	User::Leave(KErrNotSupported);		

	}

void CCamPostImageCaptureControl::GetImageStateL(CCamera::CCameraPostImageCaptureControl::TImageState& /*aImageState*/) const

	{

	User::Leave(KErrNotSupported);	

	}

void CCamPostImageCaptureControl::GetBufferStateL(CCamera::CCameraPostImageCaptureControl::TBufferState& /*aBufferState*/) const

	{

	User::Leave(KErrNotSupported);		

	}

//

//video capture control impl

CCamVideoCaptureControl* CCamVideoCaptureControl::NewL(CCamUnitTestPlugin& aOwner)

	{

	CCamVideoCaptureControl* self = new(ELeave) CCamVideoCaptureControl(aOwner);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CCamVideoCaptureControl::ConstructL()

	{

	User::LeaveIfError(RFbsSession::Connect());

	iBitmap = new(ELeave) CFbsBitmap;

	User::LeaveIfError(iBitmap->Create(TSize(320,240), EColor16M));

	}

CCamVideoCaptureControl::CCamVideoCaptureControl(CCamUnitTestPlugin& aOwner) : 

																iOwner(aOwner),

																iCaptureVideoObserver(NULL),

																iSnapshotImpForVideo(NULL)

	{

	}

CCamVideoCaptureControl::~CCamVideoCaptureControl()

	{

	delete iBitmap;

	RFbsSession::Disconnect();

	}

void CCamVideoCaptureControl::Release()

	{

	delete this;

	}

void CCamVideoCaptureControl::CreateHistogramImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const

	{

	aImplFactoryPtr	= CHistogramFactoryForVideo::NewL(const_cast<CCamVideoCaptureControl&>(*this));

	}

void CCamVideoCaptureControl::GetSnapshotImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const

	{

	aImplFactoryPtr = CSnapshotFactoryForVideo::NewL(const_cast<CCamVideoCaptureControl&>(*this), iSnapshotImpForVideo);

	}

void CCamVideoCaptureControl::GetImageProcessingImplFactoryL(MImplementationFactory*& aImplFactoryPtr) const

	{

	aImplFactoryPtr = NULL;

	User::Leave(KErrNotSupported);	

	}

void CCamVideoCaptureControl::SetCaptureVideoObserver(MCaptureVideoObserver& aCaptureVideoObserver)

	{

	iCaptureVideoObserver = &aCaptureVideoObserver;

	}

void CCamVideoCaptureControl::GetVideoFormatsSupportedL(TUint& aVideoFormatsSupported, const TSize& /*aSize*/) const

	{

	aVideoFormatsSupported = CCamera::EFormatFbsBitmapColor16M;	

	}

void CCamVideoCaptureControl::GetPixelAspectsSupportedL(TUint& aPixelAspectsSupported, CCamera::TFormat /*aVideoFormat*/, const TSize& /*aSize*/) const

	{

	aPixelAspectsSupported = CCamera::CCameraAdvancedSettings::EPixelAspect1To1;	

	}

void CCamVideoCaptureControl::GetEmbeddedStillCaptureSupportInfoL(TInt& aSupportedEmbeddedStillCaptureTypes) const

	{

	aSupportedEmbeddedStillCaptureTypes = CCamera::CCameraVideoCaptureControl::EEmbeddedStillCaptureNotSupported;

	}

void CCamVideoCaptureControl::PrepareVideoCapture(const CCamera::CCameraVideoCaptureControl::TPrepareVideoParameters& aPrepareVideoParameters)

	{

	if(((aPrepareVideoParameters.Size() != sizeof(CCamera::CCameraVideoCaptureControl::TPrepareVideoParameters)) ||

		aPrepareVideoParameters.Version() != KECamPrepareVideoParametersCurrentVersion))

		{

		iOwner.Notify(KUidECamEventVideoCaptureControlPrepareComplete, KErrNotSupported);

		}

	iPrepareVideoParameters = aPrepareVideoParameters;

	iOwner.Notify(KUidECamEventVideoCaptureControlPrepareComplete, KErrNone);

	}

void CCamVideoCaptureControl::GetRangeAffectedSettingsL(RArray<TUid>& aRangeAffectedSettings) const

	{

	aRangeAffectedSettings.Reset();	

	}

void CCamVideoCaptureControl::GetValueAffectedSettingsL(RArray<TUid>& aValueAffectedSettings) const

	{

	aValueAffectedSettings.Reset();	

	}

void CCamVideoCaptureControl::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const

	{

	aDisabledSettings.Reset();	

	}

void CCamVideoCaptureControl::ReleaseVideoResource()