/*

* Copyright (c) 2010 ISB.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Symbian Foundation License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

*

* Initial Contributors:

* ISB - Initial contribution

*

* Contributors:

*

* Description:

*

*/

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <ecamuids.hrh>

#include <ecam.h>

#include "ecamwebcameraplugin.h"

#include "ecamwebcamerapluginuids.hrh"

#include "ecamwebcamerabuffer.h"

#include "ecamwebcameraadvset.h"

#include "ecamwebcameraactive.h"

#include "ecamwebcameravfactive.h"

_LIT(KCameraDriverPddName, "webcamera.pdd");

_LIT(KCameraDriverLddName, "ewebcamera.ldd");

const TInt KCaptureWidth     = 640;					// Capture image width

const TInt KCaptureHeight    = 480;					// Capture image height

const TInt KCaptureLineBytes = KCaptureWidth * 3;	// bytes of one line

//

// CWebCamera class

//

CWebCamera::CWebCamera():

	iCaptureBufPtr(NULL, 0)

	{

	iInfo.iHardwareVersion.iMajor = 0;

	iInfo.iHardwareVersion.iMinor = 0;

	iInfo.iHardwareVersion.iBuild = 0;

	iInfo.iSoftwareVersion.iMajor = 0;

	iInfo.iSoftwareVersion.iMinor = 0;

	iInfo.iSoftwareVersion.iBuild = 0;

	iInfo.iOrientation = TCameraInfo::EOrientationOutwards;

	iInfo.iOptionsSupported = 0;

	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderDirectSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderBitmapsSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EImageCaptureSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EVideoCaptureSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EContrastSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EBrightnessSupported;

	iInfo.iOptionsSupported |= TCameraInfo::EViewFinderClippingSupported;

	iInfo.iFlashModesSupported 			= 0; // Bitfield of TFlash values

	iInfo.iExposureModesSupported		= 0; // Bitfield of TExposure values

	iInfo.iWhiteBalanceModesSupported	= 0; // Bitfield of TWhiteBalance values

	iInfo.iMinZoom = KMinTestCameraZoom;

	// KMinTestCameraZoom is zero or negative

	// note the algorithm for creating of zoom factor

	iInfo.iMinZoomFactor = TReal32(1)/TReal32(1 << -KMinTestCameraZoom);

	iInfo.iMaxZoom = KMaxTestCameraZoom;

	iInfo.iMaxZoomFactor = 1 << KMaxTestCameraZoom;

	iInfo.iMaxDigitalZoom = KMaxTestCameraDigitalZoom;

	iInfo.iMaxDigitalZoomFactor = KMaxTestCameraDigitalZoomFactor;

	iInfo.iImageFormatsSupported = 0;

	iInfo.iImageFormatsSupported |= EFormatExif;

	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor4K;

	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor64K;

	iInfo.iImageFormatsSupported |= EFormatFbsBitmapColor16M;

	iInfo.iVideoFrameFormatsSupported = 0;

	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor4K;

	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor64K;

	iInfo.iVideoFrameFormatsSupported |= EFormatFbsBitmapColor16M;

	iInfo.iMaxFramesPerBufferSupported = 1;

	iInfo.iMaxBuffersSupported = 2;

	}

CWebCamera::~CWebCamera()

	{

	delete iCaptureBuf;

	delete iAdvSettingsImpl;

	delete iVfActive;

	delete iActive;

	delete iCaptureBitmap;

	iChunk.Close();

	iImageSizes.Close();

	iDriver.Close();

	}

CWebCamera* CWebCamera::NewL()

	{

	CWebCamera* self = new(ELeave) CWebCamera;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CWebCamera::ConstructL()

	{

	// Open drivers.

	TInt err;

	err = User::LoadPhysicalDevice(KCameraDriverPddName);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

	err = User::LoadLogicalDevice(KCameraDriverLddName);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

	iDriver.Open();

	iActive = CWebCameraActive::NewL(this, iDriver);

	iVfActive = CWebCameraVfActive::NewL(this, iDriver);

	User::LeaveIfError(iImageSizes.Append(TSize(640, 480)));	// VGA

	User::LeaveIfError(iImageSizes.Append(TSize(160, 120)));	// QQVGA

	iInfo.iNumImageSizesSupported = iImageSizes.Count();

	// Open chunk

	err = iDriver.OpenSharedChunks(iChunk, iChunkInfo);

	if (err != KErrNone)

		{

		User::Leave(err);

		}

	iChuckBase=iChunk.Base();

	}

/** 

from CCameraPlugin

A call to one of the factory functions firstly loads the plugin, followed by a

call to this function to complete construction.

Creates an object representing a camera.

@param  aObserver

        Reference to class derived from MCameraObserver2 designed to receive

        notification of asynchronous event completion.

@param	aCameraIndex

        Index from 0 to CamerasAvailable()-1 inclusive specifying the

        camera device to use.

@return Pointer to a fully constructed CCamera object. Ownership is passed

        to the caller.

@leave  May leave with KErrNoMemory or KErrNotSupported if aCameraIndex is

        out of range.	

*/

void CWebCamera::Construct2L(MCameraObserver& aObserver,TInt aCameraIndex)

	{

	iObserver = &aObserver;

	iCameraIndex = aCameraIndex;

	}

/** 

from CCameraPlugin

A call to one of the factory functions firstly loads the plugin, followed by a

call to this function to complete construction.

Duplicates the original camera object for use by, for example, multimedia systems.

May leave with KErrNoMemory or KErrNotFound if aCameraHandle is not valid.

@param  aObserver 					Reference to an observer.

@param  aCameraHandle Handle of an existing camera object.

@return Duplicate of the original camera object. 

*/

void CWebCamera::Construct2DupL(MCameraObserver& aObserver,TInt aCameraHandle)

	{

	iObserver = &aObserver;

	iCameraHandle = aCameraHandle;

	}

 /** 

from CCameraPlugin

 A call to one of the factory functions firstly loads the plugin, followed by a

call to this function to complete construction.

Creates an object representing a camera.

@param  aObserver

        Reference to class derived from MCameraObserver2 designed to receive

        notification of asynchronous event completion.

@param	aCameraIndex

        Index from 0 to CamerasAvailable()-1 inclusive specifying the

        camera device to use.

@param	aPriority

        Value from -100 to 100 indicating relative priority of client to

        use camera.

@return Pointer to a fully constructed CCamera object. Ownership is passed

        to the caller.

@leave  May leave with KErrNoMemory or KErrNotSupported if aCameraIndex is

        out of range.

*/

void CWebCamera::Construct2L(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority)

	{

	iObserver2 = &aObserver;

	iCameraIndex = aCameraIndex;

	iPriority = aPriority;

	}

/** 

from CCameraPlugin

Duplicates the original camera object for use by, for example, multimedia systems.

@leave  KErrNoMemory if out of memory.

@leave  KErrNotFound if aCameraHandle is not valid.	   

@leave  KErrPermissionDenied if the application does not have

        the UserEnvironment capability.

@param  aObserver

        Reference to an observer.

@param  aCameraHandle Handle of an existing camera object.

@return Duplicate of the original camera object. 

@capability	UserEnvironment

			An application that creates a CCamera object must have

			the UserEnvironment capability.

@note   Applications using this method to create camera object may not receive enums/uids added in future(after being baselined). 

		To receive them, they should rather use New2L() or NewDuplicate2L(), in which case, they should prepare 

		themselves to receive unrecognised values.

*/

void CWebCamera::Construct2DupL(MCameraObserver2& aObserver,TInt aCameraHandle)

	{

	iObserver2 = &aObserver;

	iCameraHandle = aCameraHandle;

	}

//

// virtual functions

//

/**

from CCamera		Gets information about the camera device.

@param  aInfo 		On return, information about the camera device. See TCameraInfo. 

*/

void CWebCamera::CameraInfo(TCameraInfo& aInfo) const

	{

	aInfo = iInfo;

	}

/** 

from CCamera

Asynchronous function that performs any required initialisation and reserves

the camera for exclusive use.

Calls MCameraObserver:: ReserveComplete() when complete. 

*/

void CWebCamera::Reserve()

	{

	iActive->Reserve();

	}

/** 

from CCamera

De-initialises the camera, allowing it to be used by other clients. 

*/

void CWebCamera::Release()

	{

	StopViewFinder();

	iReserved = EFalse;

	}

/** 

from CCamera

Asynchronous method to switch on camera power.

User must have successfully called Reserve() prior to calling this function.

Calls MCameraObserver::PowerOnComplete() when power on is complete. 

*/

void CWebCamera::PowerOn()

	{

	iActive->PowerOn();

	}

/** 

from CCamera

Synchronous function for switching off camera power. 

*/

void CWebCamera::PowerOff()

	{

	StopViewFinder();

	iPowerOn = EFalse;

	}

/**

from CCamera

Gets the device-unique handle of this camera object.

@return  The device-unique handle of this camera object. 

*/

TInt CWebCamera::Handle()

	{

	return 0;

	}

/** 

from CCamera

Sets the zoom factor.

This must be in the range of TCameraInfo::iMinZoom to TCameraInfo::iMaxZoom

inclusive. May leave with KErrNotSupported if the specified zoom factor is

out of range.

@param aZoomFactor 

       Required zoom factor.

*/

void CWebCamera::SetZoomFactorL(TInt /*aZoomFactor = 0*/)

	{

	}

/** 

from CCamera

Gets the currently set zoom factor.

@return  The currently set zoom factor.

*/

TInt CWebCamera::ZoomFactor() const

	{

	return 0;

	}

/** 

from CCamera

Sets the digital zoom factor.

This must be in the range of 0 to TCameraInfo::iMaxDigitalZoom inclusive.

May leave with KErrNotSupported if the zoom factor is out of range.

@param  aDigitalZoomFactor

        The required digital zoom factor. 

*/

void CWebCamera::SetDigitalZoomFactorL(TInt /*aDigitalZoomFactor = 0*/)

	{

	}

/** 

from CCamera

Gets the currently set digital zoom factor.

@return  The currently set digital zoom factor. 

*/

TInt CWebCamera::DigitalZoomFactor() const

	{

	return 0;

	}

/**

from CCamera

Sets the contrast adjustment of the device.

This must be in the range of -100 to +100 or EContrastAuto. May leave with

KErrNotSupported if the specified contrast value is out of range.

@param  aContrast 

        Required contrast value. See TCameraInfo::iContrastSupported 

*/

void CWebCamera::SetContrastL(TInt /*aContrast*/)

	{

	}

/** 

from CCamera

Gets the currently set contrast value.

@return  The currently set contrast value.

*/

TInt CWebCamera::Contrast() const

	{

	return 0;

	}

/** 

from CCamera

Sets the brightness adjustment of the device.

No effect if this is not supported, see TCameraInfo::iBrightnessSupported.

This must be in the range of -100 to +100 or EBrightnessAuto. May leave

with KErrNotSupported if the brightness adjustment is out of range.

@param  aBrightness

        The required brightness adjustment. 

*/

void CWebCamera::SetBrightnessL(TInt /*aBrightness*/)

	{

	}

/** 

from CCamera

Gets the currently set brightness adjustment value.

@return  The currently set brightness adjustment value. 

*/

TInt CWebCamera::Brightness() const

	{

	return 0;

	}

/** 

from CCamera

Sets the flash mode.

No effect if this is not supported, see TCameraInfo::iFlashModesSupported.

May leave with KErrNotSupported if the specified flash mode is invalid.

@param  aFlash

        The required flash mode. 

*/

void CWebCamera::SetFlashL(TFlash /*aFlash = EFlashNone*/)

	{

	}

/** 

from CCamera

Gets the currently set flash mode.

@return  The currently set flash mode. 

@note	if CCamera::New2L() or CCamera::NewDuplicate2L() is not used to create CCamera object, it is assumed that 

application is not prepared to receive extra added enum values (unrecognised). So, any extra enum value(unrecognised)

(set in the ECAM implementation because of sharing clients) should not be returned from the ECAM implementation.

To receive extra added enum values, application should rather use CCamera::New2L() or CCamera::NewDuplicate2L() 

to create camera object. ECAM implementation, after verifying this,(by checking version no.) may send new values, if set.

In this case, application is assumed to be prepared to receive unrecognised enum values.

@see CCamera::CCameraAdvancedSettings::FlashMode()	

*/

CCamera::TFlash CWebCamera::Flash() const

	{

	return EFlashNone;

	}

/** 

from CCamera

Sets the exposure adjustment of the device.

No effect if this is not supported, see CameraInfo::iExposureModesSupported.

May leave with KErrNotSupported if the specified exposure adjustment is invalid.

@param  aExposure

        The required exposure adjustment. 

*/

void CWebCamera::SetExposureL(TExposure /*aExposure = EExposureAuto*/)

	{

	}

/** 

from CCamera

Gets the currently set exposure setting value.

@return  The currently set exposure setting value. 

*/

CCamera::TExposure CWebCamera::Exposure() const

	{

	return EExposureAuto;

	}