// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

/**

 @file

 @publishedAll

 @released

*/

#ifndef ECAM_H

#define ECAM_H

#include <e32base.h>

#include <ecamuids.hrh>

#include <e32property.h>

class MFrameBuffer;

class RWsSession;

class CWsScreenDevice;

class RWindowBase;

class CFbsBitmap;

typedef TInt TPostCaptureControlId;

/** Specifies camera device information.

If either zoom or digital zoom are available then the appropriate entries

in this class will be set to indicate the range of values that they may take.

This should be implemented such that a setting of zero corresponds to no zoom,

and a step of one corresponds to the smallest increment available, in a linear

fashion.

There are also zoom factors that correspond to the actual zoom factor when

at minimum (non-digital only) and maximum zoom. Negative zoom values represent

macro functionality.

Image capture, if supported, is simply a case of transferring the current

image from the camera to the client via MCameraObserver::ImageReady(). The

camera class must set the iImageFormatsSupported bitfield to indicate the

formats available.

@publishedAll

@released

*/

class TCameraInfo

	{

public:

	/** Possible directions in which the camera may point.

	*/

	enum TCameraOrientation

		{

		/** Outward pointing camera for taking pictures.

		Camera is directed away from the user. */

		EOrientationOutwards,

		/** Inward pointing camera for conferencing.

		Camera is directed towards the user. */

		EOrientationInwards,

		/** Mobile camera capable of multiple orientations.

		Camera orientation may be changed by the user. */

		EOrientationMobile,

		/** Camera orientation is not known. */

		EOrientationUnknown

		};

	/** Various flags describing the features available for a particular implementation

	*/

	enum TOptions

		{

		/** View finder display direct-to-screen flag */

		EViewFinderDirectSupported		= 0x0001,

		/** View finder bitmap generation flag */

		EViewFinderBitmapsSupported		= 0x0002,

		/** Still image capture flag */

		EImageCaptureSupported			= 0x0004,

		/** Video capture flag */

		EVideoCaptureSupported			= 0x0008,

		/** View finder display mirroring flag */

		EViewFinderMirrorSupported		= 0x0010,

		/** Contrast setting flag */

		EContrastSupported				= 0x0020,

		/** Brightness setting flag */

		EBrightnessSupported			= 0x0040,

		/** View finder clipping flag */

		EViewFinderClippingSupported	= 0x0080,

		/** Still image capture clipping flag */

		EImageClippingSupported			= 0x0100,

		/** Video capture clipping flag */

		EVideoClippingSupported			= 0x0200

		};

public:

	/** Version number and name of camera hardware. */

	TVersion iHardwareVersion;

	/** Version number and name of camera software (device driver). */

	TVersion iSoftwareVersion;

	/** Orientation of this particular camera device. */

	TCameraOrientation iOrientation;

	/** Bitfield of TOptions available */

	TUint32 iOptionsSupported;

	/** The supported flash modes.

	This is a bitfield of CCamera::TFlash values. 

	If methods CCamera::New2L() or CCamera::NewDuplicate2L() are not used to create the CCamera object, it is assumed that the 

	application may not be able to cope with any future additions to the enum values. So, any unrecognised enum value passed 

    from the implementation should be filtered by ECAM Implementation.

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

    to create camera object. This is an indication to ECAM implementation. In this case, application is assumed 

    to be prepared to receive unrecognised enum values.

    @see CCamera::CCameraAdvancedSettings::SupportedFlashModes()

	*/

	TUint32 iFlashModesSupported;

	/** The supported exposure modes.

	This is a bitfield of CCamera::TExposure values. */

	TUint32 iExposureModesSupported;

	/** The supported white balance settings.

	This is a bitfield of of CCamera::TWhiteBalance values. 

	If methods CCamera::New2L() or CCamera::NewDuplicate2L() are not used to create the CCamera object, it is assumed that the 

	application may not be able to cope with any future additions to the enum values. So, any unrecognised enum value passed 

    from the implementation should be filtered by ECAM Implementation.

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

    to create camera object. This is an indication to ECAM implementation. In this case, application is assumed 

    to be prepared to receive unrecognised enum values.

    Refer to CCamera::CCameraAdvancedSettings::SupportedWhiteBalanceModes() implementation

    @see CCamera::CCameraAdvancedSettings::SupportedWhiteBalanceModes()

	*/

	TUint32 iWhiteBalanceModesSupported;

	/** Minimum zoom value allowed. 

	Must be negative, or zero if not supported.

	This is the minimum value that may be passed to CCamera::SetZoomFactorL(). */

	TInt iMinZoom;

	/** Maximum zoom value allowed. 

	Must be positive, or zero if not supported.

	This is the maximum value that may be passed to CCamera::SetZoomFactorL(). */

	TInt iMaxZoom;

	/** Maximum digital zoom value allowed. 

	Must be positive, or zero if not supported.

	This is the maximum value that may be passed to CCamera::SetDigitalZoomFactorL(). 

	Digital zoom factor is assumed to be a linear scale from 0 to iMaxDigitalZoom. */

	TInt iMaxDigitalZoom;

	/** Image size multiplier corresponding to minimum zoom value. 

	Must be between 0 and 1 inclusive. Both 0 and 1 indicate that macro functionality 

	is not supported. */

	TReal32 iMinZoomFactor;

	/** Image size multiplier corresponding to maximum zoom value. 

	May take the value 0, or values greater than or equal to 1. Both 0 and 1 indicate 

	that zoom functionality is not supported. */

	TReal32 iMaxZoomFactor;

	/** Image size multiplier corresponding to maximum digital zoom value. 

	Implementation recommendation is to use 'appropriate value' for maximum digital zoom which could cover only values 

	given by new digital zoom methods based on image format and capture mode.

	Must be greater than or equal to 1. */

	TReal32 iMaxDigitalZoomFactor;

	/** Count of still image capture sizes allowed.

	Number of different image sizes that CCamera::EnumerateCaptureSizes() will 

	support, based on the index passed in. Index must be between 0 and iNumImageSizesSupported-1. */

	TInt iNumImageSizesSupported;

	/** The supported still image formats.

	This is a bitfield of CCamera::TFormat values. */

	TUint32 iImageFormatsSupported;

	/** Count of video frame sizes allowed. 

	This is the number of different video frame sizes that CCamera::EnumerateVideoFrameSizes() 

	will support, based on the specified index. The index must be between 0 and 

	iNumVideoFrameSizesSupported-1. */

	TInt iNumVideoFrameSizesSupported;

	/** Count of video frame rates allowed.

	This is the number of different video frame rates that CCamera::EnumerateVideoFrameRates() 

	will support, based on the specified index. The index must be between 0 and 

	iNumVideoFrameRatesSupported-1. */

	TInt iNumVideoFrameRatesSupported;

	/** The supported video frame formats.

	This is a bitfield of video frame CCamera::TFormat values. 

	If methods CCamera::New2L() or CCamera::NewDuplicate2L() are not used to create the CCamera object, it is assumed that the 

	application may not be able to cope with any future additions to the enum values. So, any unrecognised enum value passed 

    from the implementation should be filtered by the ECAM implementation.

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

    to create the camera object. This is an indication to the ECAM implementation. In this case, the application is assumed 

    to be prepared to receive unrecognised enum values.	

	*/

	TUint32 iVideoFrameFormatsSupported;

	/** Maximum number of frames per buffer that may be requested. */

	TInt iMaxFramesPerBufferSupported;

	/** Maximum number of buffers allowed */

	TInt iMaxBuffersSupported;

	};

/** Mixin base class for camera clients.

An application must implement an MCameraObserver or MCameraObserver2 (recommended)

in order to use the camera API. This derived class is called when the camera is 

ready for use, an image has been captured or a buffer of video data is ready, including 

when errors occur.

Implementations of the camera API should use MCameraObserver::FrameBufferReady()

and MFrameBuffer::Release() to co-ordinate the mapping of any special memory

objects.

@publishedAll

@released

*/

class MCameraObserver

	{

public:

	/** Camera reservation is complete.

	Called asynchronously when CCamera::Reserve() completes.

	@param  aError

	        An error on failure and KErrNone on success.

	*/

	virtual void ReserveComplete(TInt aError)=0;

	/** Indicates camera power on is complete.

	Called on completion of CCamera:PowerOn().

	@param  aError

	        KErrNone on success, KErrInUse if the camera is in

	        use by another client or KErrNoMemory if insufficient system memory is available.

	*/

	virtual void PowerOnComplete(TInt aError)=0;

	/** Tests whether transfer of view finder data has completed.

	Called periodically in response to the use of CCamera::StartViewFinderBitmapsL().

	@param  aFrame

	        The view finder frame.

	*/

	virtual void ViewFinderFrameReady(CFbsBitmap& aFrame)=0;

	/** Transfers the current image from the camera to the client.

	Called asynchronously when CCamera::CaptureImage() completes.

	@param  aBitmap

	        On return, a pointer to an image held in CFbsBitmap form if

	        this was the format specified in CCamera::PrepareImageCaptureL().

	@param  aData

	        On return, a pointer to an HBufC8 if this was the format specified

	        in CCamera::PrepareImageCaptureL(). NULL if there was an error.

	@param  aError

	        KErrNone on success or an error code on failure.

	*/

	virtual void ImageReady(CFbsBitmap* aBitmap,HBufC8* aData,TInt aError)=0;

	/** Passes a filled frame buffer to the client.

	Called asynchronously, when a buffer has been filled with the required number

	of video frames by CCamera::StartVideoCapture().

	@param  aFrameBuffer

	        On return, a pointer to an MFrameBuffer if successful,

	        or NULL if not successful.

	@param  aError

	        KErrNone if successful, or an error code if not successful.

	*/

	virtual void FrameBufferReady(MFrameBuffer* aFrameBuffer,TInt aError)=0;

	};

/**

Class used for passing camera picture data between camera and client in the V2 observer.

Used for viewfinder, image capture and video capture.

The class offers APIs for the client to access the data as a descriptor, a bitmap

or a handle to a kernel chunk. Depending on the format previously requested by

the client, one or more of the API choices may be inappropriate e.g. an image will

not be avaiable as a bitmap in the FBS unless the client has specifically requested

it.

The buffer may contain multiple frames.

@publishedAll

@released

*/

class MCameraBuffer

	{

public:

	/** 

	Returns the number of frames of image data contained within the buffer. This

	would be 1 for a image capture, and match the requested count

	for video capture. For other methods in this class that take a aFrameIndex

	param, 0 <= aFrameIndex < NumFrames()

	@return The number of frames of image data in the buffer. 

	*/

	virtual TInt NumFrames()=0;

	/**

	Returns a pointer to a descriptor containing a frame of camera data. The format

	will have been previously specified by a CCamera class method.

	@param  aFrameIndex

	        The index of the required frame. For a still image this should be 0.

	@leave  KErrArgument if aIndex is out of range and 

	@leave  KErrNotSupported if the camera data is actually bitmaps in the FBS.

	@return A pointer to a descriptor containing a frame of image data.

	*/

	virtual TDesC8* DataL(TInt aFrameIndex)=0;

	/** 

	Returns a reference to a FBS bitmap containing a frame of image data.

	@param  aFrameIndex 

	        The index of the required frame. For a still image this should be 0.

	@leave  KErrArgument if aIndex is out of range and 

	@leave  KErrNotSupported if the picture data is not a FBS bitmap.

	@return A reference to a FBS bitmap containing a frame of picture data. 

	*/

	virtual CFbsBitmap& BitmapL(TInt aFrameIndex)=0;

	/** 

	Returns a handle for the chunk that contains the camera data.

	The RChunk is exposed so that it can potentially be shared between multiple

	processes.

	The ptr returned by DataL(aFrameIndex) is effectively derived from this

	RChunk (where both are supported simulataneously). The equivalent ptr would be:

	TPtrC8* ptr;

	ptr.Set(ChunkL().Base() + ChunkOffset(aFrameIndex), FrameSize(aFrameIndex));

	@leave  KErrNotSupported if the chunk is not available.

	@return A reference to a handle to the chunk that contains the buffer of picture data. 

	*/

	virtual RChunk& ChunkL()=0;

	/** 

	Returns the offset into the chunk that contains the frame specified by aFrameIndex.

	The client would add this offset to the ptr returned by ChunkL().Base() to

	get the address of the start of the frame data. 

	@param  aIndex 

	        The index of the required frame. For a still image this should be 0.

	@leave  KErrNotSupported if the chunk is not available 

	@leave  KErrArgument if aIndex is out of range.

	@return The offset into the chunk for the start of the frame. 

	*/

	virtual TInt ChunkOffsetL(TInt aFrameIndex)=0;

	/** 

	Returns the size of the data in bytes that comprises the frame specified by aIndex.

	@param  aFrameIndex 

	        The index of the required frame. For a still image this should be 0.

	@leave  KErrArgument 

			if aIndex is out of range.

	@return Returns the size of the data in bytes that comprises the frame. 

	*/

	virtual TInt FrameSize(TInt aFrameIndex)=0;

	/** 

	Releases the buffer. Once the client has processed

	the picture data it should use this method to signal to CCamera that the

	buffer can be re-used.

	*/

	virtual void Release()=0;

public:

	/** 

	Sequential frame number of the first frame in the buffer, counting from when

	CCamera::StartVideoCapture() was called and including frames dropped due to

	lack of buffers. Always zero for still images. May also be used by client viewfinders.

	*/

	TInt iIndexOfFirstFrameInBuffer;

	/** 

	Time elapsed from when CCamera::StartVideoCapture() was called until the first

	frame in the buffer was captured. Always zero for still images.

	*/

	TTimeIntervalMicroSeconds iElapsedTime;

	};

/**

This class is used to provide extra buffer informations through a custom interface.

@see MCameraImageBuffer

@publishedPartner

@prototype

*/

class MCameraBuffer2 : public MCameraBuffer

	{

public:

	/**

	Retrieves an array of uids which represents the class identifier used for buffer extension.

	@param aInterfaceUids

		   An array of uids which represents the class identifier.

	@return The error code.

	*/

	virtual TInt GetInterfaceUids(RArray<TUid>& aInterfaceUids) = 0;

	/**

	Gets a custom interface for extra buffer information. 

	@param aInterface

		   The Uid of the particular interface function required for buffer information.

	@param aPtrInterface

		   The client has to cast the custom interface pointer to the appropriate type.	

	@return The error code.

	*/

	virtual TInt CustomInterface(TUid aInterface, TAny*& aPtrInterface) = 0;

	};

/** 

	Uid used to identify the event that the request to Reserve() has completed

*/

static const TUid  KUidECamEventReserveComplete = {0x101F7D3B};

/** 

	Uid used to identify the event that the request to PowerOn() has completed

*/

static const TUid  KUidECamEventPowerOnComplete = {0x101F7D3C};

/** 

	Uid used to identify the event that the client has lost

	control of the camera

*/

static const TUid  KUidECamEventCameraNoLongerReserved = {0x101F7D3D};

/** 

Uid used to notify the client who made the new reserve request. 

Error value KErrECamHighPriorityReserveRequesterExists indicates another such reserve request is outstanding and

has higher priority than this one.

Error value KErrCancel indicates a new reserve requester with higher priority than the current requester has 

been made. That's why, this one got cancelled.

Any other error may also occur.

@see CCamera::CCameraAdvancedSettings::ReserveL(const TTimeIntervalMicroseconds32& aMaxTimeToWait, TBool aKickOut);

*/

static const TUid  KUidECamEventNewReserveComplete = {KUidECamEventNewReserveCompleteUidValue};

/**

@publishedAll

@released

General purpose class to describe an ECam event.

Contains a UID to define the actual event type, and an integer to define the event code.

*/

class TECAMEvent

	{

public:

	/**

	Constructor.

	@param  aEventType

	        A UID to define the type of event.

	@param  aErrorCode

	        The error code associated with the event.

	*/

	IMPORT_C TECAMEvent(TUid aEventType, TInt aErrorCode);

	/**

	Default constructor.

	Provided so this class can be packaged in a TPckgBuf<>.

	*/

	IMPORT_C TECAMEvent();

	/**

	A UID to define the event type.

	*/

	TUid iEventType;

	/**

	The error code associated with the event.

	*/

	TInt iErrorCode;

	};

/** 

Uid used to identify a particular version of TECAMEvent base class being used i.e. TECAMEvent2 . 

Useful for MCameraObserver2::HandleEvent implementation to detect the version of TECAMEvent base class.

*/

static const TUid  KUidECamEventClass2 = {KUidECamEventClass2UidValue};

/** 

event indicating setting of color entry in the color swap operation. This is a part of class CCamera::CCameraImageProcessing. 

This event should be packed in TECAMEvent2 class.

@note  TECAMEvent2::iParam represents color entry.

*/

static const TUid  KUidECamEventCIPSetColorSwapEntry 		   = {KUidECamEventCIPSetColorSwapEntryUidValue};

static const TUid  KUidECamEvent2CIPSetColorSwapEntry 		   = {KUidECamEventCIPSetColorSwapEntryUidValue};

/** 

event indicating removal of color entry in the color swap operation. This is a part of class CCamera::CCameraImageProcessing. 

This event should be packed in TECAMEvent2 class.

@note  TECAMEvent2::iParam represents color entry.

*/

static const TUid  KUidECamEventCIPRemoveColorSwapEntry 	   = {KUidECamEventCIPRemoveColorSwapEntryUidValue};

static const TUid  KUidECamEvent2CIPRemoveColorSwapEntry 	   = {KUidECamEventCIPRemoveColorSwapEntryUidValue};

/** 

event indicating setting of color entry in the color accent operation. This is a part of class CCamera::CCameraImageProcessing. 

This event should be packed in TECAMEvent2 class.

@note  TECAMEvent2::iParam represents color entry.

*/

static const TUid  KUidECamEventCIPSetColorAccentEntry 		   = {KUidECamEventCIPSetColorAccentEntryUidValue};

static const TUid  KUidECamEvent2CIPSetColorAccentEntry 	   = {KUidECamEventCIPSetColorAccentEntryUidValue};

/** 

event indicating removal of color entry in the color accent operation. This is a part of class CCamera::CCameraImageProcessing. 

This event should be packed in TECAMEvent2 class.

@note  TECAMEvent2::iParam represents color entry.

*/

static const TUid  KUidECamEventCIPRemoveColorAccentEntry 	   = {KUidECamEventCIPRemoveColorAccentEntryUidValue};

static const TUid  KUidECamEvent2CIPRemoveColorAccentEntry 	   = {KUidECamEventCIPRemoveColorAccentEntryUidValue};

/** 

event indicating issue of pre capture warnings. This is a part of class CCamera::CCameraAdvancedSettings. 

This event should be packed in TECAMEvent2 class.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::

NewDuplicate2L():-

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

@note  TECAMEvent2::iParam represents bit field describing all PreCaptureWarnings currently issued.

*/

static const TUid  KUidECamEventCameraSettingPreCaptureWarning 	= {KUidECamEventCameraSettingPreCaptureWarningUidValue};

static const TUid  KUidECamEvent2CameraSettingPreCaptureWarning = {KUidECamEventCameraSettingPreCaptureWarningUidValue};

/** 

Event indicating continuous zoom progess. This event is used for StartContinuousZoomL feature. This is a part of class 

CCamera::CCameraAdvancedSettings. This event should be packed in TECAMEvent2 class. 

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::

NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

Note: TECAMEvent2::iParam represents percentage continuous zoom completion.

@note  If zoom direction is EZoomDirectionWide, percentage completion will target minimum possible value as 100%.

@note  If zoom direction is EZoomDirectionTele, percentage completion will target maximum possible value as 100%.

@publishedPartner

@prototype

*/

static const TUid  KUidECamEvent2CameraSettingContinuousZoomPercentageCompletion  = {KUidECamEvent2CameraSettingContinuousZoomPercentageCompletionUidValue};

/**

Notifies that unrequested feature changes have occurred. The method GetIndirectFeatureChangesL() is called to

retrieve the list of unrequested feature changes. The unrequested feature changes are ECAM component wide.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

Note: TECAMEvent2::iParam represents the TInt used to obtain a uid which represents the requested feature change.

@publishedPartner

@prototype

*/

static const TUid KUidECamEvent2IndirectFeatureChange  = {KUidECamEvent2IndirectFeatureChangeUidValue};

/** 

Viewfinder fading effect has been set.

This event should be packed in TECAMEvent2 class.

Note: TECAMEvent2::iParam represents viewfinder handle.

@internalTechnology

*/

static const TUid KUidECamEvent2ViewFinderFadingEffect = {KUidECamEvent2ViewFinderFadingEffectUidValue};

/** 

Event indicating auto aperture is being used. 

This event should be packed in TECAMEvent2 class.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::

NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

Note: TECAMEvent2::iParam represents actual value of aperture being used if camera is capable of. Otherwise, KErrNotFound will be retrieved.

@internalTechnology

*/

static const TUid  KUidECamEvent2CameraSettingAutoAperture  = {KUidECamEvent2CameraSettingAutoApertureUidValue};

/** 

Event providing focussing feedback. The focussing feedback will be provided whenever the focussing state changes for the

selected spot combination. 

This event should be packed in TECAMEvent2 class.

Note: TECAMEvent2::iParam represents bitfield of chosen spots which are in focus.

Note: TECAMEvent2::iParam1 represents bitfield of chosen spots which are not in focus.

@internalTechnology

*/

static const TUid  KECamEvent2ImageCaptureControlFocussingInformation = {KECamEvent2ImageCaptureControlFocussingInformationUidValue};

/** 

Focussing spot combination. This event tells about completion of the setting operation for the spot combination.

This event should be packed in TECAMEvent2 class.

@note  static_cast<CCamera::CCameraAdvancedSettings::TFocusMode>(TECAMEvent2::iParam) represents the focus mode for 

	   which the spot combination has to be set for receiving focussing feedback.

@internalTechnology

*/

static const TUid KUidECamEvent2ImageCaptureControlSpotCombination = {KUidECamEvent2ImageCaptureControlSpotCombinationUidValue};

/** 

Viewfinder magnification has been set.

This event should be packed in TECAMEvent2 class.

Note: TECAMEvent2::iParam represents viewfinder handle.

@internalTechnology

*/

static const TUid KUidECamEvent2ViewFinderMagnification = {KUidECamEvent2ViewFinderMagnificationUidValue};

/**

Notifies the current camera reserver that the camera control will be forcefully overtaken by another requesting client 

after a specific time interval.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

@note   TTimeIntervalMicroSeconds32(TECAMEvent2::iParam) represents the maximum time to wait. 

		TECAMEvent2::iParam needs to be passed as argument in order to construct the TTimeIntervalMicroSeconds32 object.

Note: TECAMEvent2::iParam1 represents the priority of the requestor client to whom the camera control will be forcibly 

passed after a specific time interval.

@internalTechnology

*/

static const TUid KUidECamEvent2CameraRequestForcedTimedTakeOver = {KUidECamEvent2CameraRequestForcedTimedTakeOverUidValue};

/**

Notifies the current camera reserver that another client is requesting for camera control in a specific time interval.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

@note   TTimeIntervalMicroSeconds32(TECAMEvent2::iParam) represents the maximum requested time within which the current 

		reserver may release the camera if it wishes to do so.

		TECAMEvent2::iParam needs to be passed as argument in order to construct the TTimeIntervalMicroSeconds32 object.

Note: TECAMEvent2::iParam1 represents the priority of the requestor client to whom the camera control will be passed 

should the current reserver wish to do so.

@internalTechnology

*/

static const TUid KUidECamEvent2CameraRequestTimedTakeOver = {KUidECamEvent2CameraRequestTimedTakeOverUidValue};

/**

Notifies the manual gain setting completion for the particular channel.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

Note: TECAMEvent2::iParam represents the specific channel for which the manual gain value has been set.

@internalTechnology

*/

static const TUid KUidECamEvent2CameraSettingManualGain = {KUidECamEvent2CameraSettingManualGainUidValue};

/**

Retrieves the optimal focussing feedback while using manual focus. This will be issued as a result of setting operation

CCamera::CCameraAdvancedSettings::SetFocusDistance(TInt aDistance).

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

@note   If TECAMEvent2::iParam > 1, information is unavailable; if TECAMEvent2::iParam < 0, error case. 

		Otherwise, static_cast<TBool>(TECAMEvent2::iParam) retrieves whether optimal focussing has been achieved or not.

@internalTechnology

*/

static const TUid KUidECamEvent2CameraSettingFocusDistance = {KUidECamEvent2CameraSettingFocusDistanceUidValue};

/**

Instructs the client to change its priority in order to allow the legacy client to get hold of the camera. Client should

restore their priority when they receive the notification 'KUidECamEventCameraSettingRestoreClientPriority'.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

Note: TECAMEvent2::iParam represents the target priority to which the client should set itself using the method SetClientPriorityL()

@internalTechnology

*/

static const TUid KUidECamEvent2CameraSettingChangeClientPriority  = {KUidECamEvent2CameraSettingChangeClientPriorityUidValue};

/** 

Event indicating image enhancement setting has been applied. 

This event should be packed in TECAMEvent2 class.

Note: TECAMEvent2::iParam represents viewfinder handle.

@internalTechnology

*/

static const TUid KUidECamEvent2ViewFinderImageEnhancement = {KUidECamEvent2ViewFinderImageEnhancementUidValue};

/**

Provides the various available schemes for event filtering. This will inform how the listed uids have to be interpreted 

by the implementation for filtering the events.

@see  CCamera::CCameraAdvancedSettings::RegisterEventsL(TECAMEventFilterScheme aEventFilter, const RArray<TUid>& aEvents);

@see  CCamera::CCameraAdvancedSettings::GetRegisterEventsL(TECAMEventFilterScheme aEventFilter, RArray<TUid>& aEvents) const;

@internalTechnology

*/	

enum TECAMEventFilterScheme

	{

	/** Black listing will mean not to receive specific events */

	EECAMEventFilterSchemeBlackList, 

	/** White listing will mean to receive only specific events */

	EECAMEventFilterSchemeWhiteList

	};

/**

Special type of TECAMEvent class used to retrieve some extra information from particular events received

@publishedAll

@released

*/	

class TECAMEvent2 : public TECAMEvent

	{

public:

	IMPORT_C static TBool IsEventEncapsulationValid(const TECAMEvent& aECAMEvent);

	IMPORT_C TECAMEvent2(TUid aEventType, TInt aErrorCode, TInt aParam);

	IMPORT_C const TUid& EventClassUsed() const;

private:

	/** 

	Uid representing this version of TECAMEvent base class. Uid used is KUidECamEventClass2 

	*/

	TUid iEventClassUsed;

	/**

	Reserved for future

	TInt iReserved1; -> Made Public TInt iParam1

	*/

	/**

	Reserved for future	

	*/

	TInt iReserved2; 

public:

	/**

	iParam1 will be used to provide extra information if iParam is not sufficient.

	This signifies different things for different valid events.

	Future events may also use this class member variable.

	*/

	TInt iParam1;

	/**

	This signifies different things for different valid events.

	Future events may also use this class member variable.

	*/	

	TInt iParam;

	};

/** Mixin base class V2 for camera clients.

An application must implement an MCameraObserver2 (or MCameraObserver) in order to use the camera

API. This derived class is called when the camera is ready for use, an image

has been captured or a buffer of video data is ready, including when errors

occur.

@publishedAll

@released

*/

class MCameraObserver2

	{

public:

	/** 

	A camera event has completed.

	@note Implementations of MCameraObserver2 should ignore events which are not recognised and should not leave.

	@param  aEvent

	        A reference to a TECAMEvent. This can be completion of a call to Reserve() 

			or a call to PowerOn() or a notification that the client has lost control 

			of the camera.

			The event contains a uid identifying the event and an accompanying

			error code (KErrNone for the successful completion of a request).

			The error will be KErrNotReady for a request that was made out of the

			correct sequence.

			The error will be KErrAccessDenied for a Reserve() request that failed

			because a higher priority client already controls the camera.

	@note   This may internally call TECAMEvent2::IsEventEncapsulationValid(aEvent) and also for any other derived version of TECAMEvent 

			class to know whether correct version of TECAMEvent base class has been used. 

	*/

	virtual void HandleEvent(const TECAMEvent& aEvent)=0;

	/** 

	Notifies client of new view finder data. Called periodically in response to 

	the use of CCamera::StartViewFinderL().

	@param  aCameraBuffer

	        A reference to an MCameraBuffer if successful, or NULL if not successful.

	@param  aError

	        KErrNone if successful, or an error code if not successful.

	*/

	virtual void ViewFinderReady(MCameraBuffer& aCameraBuffer,TInt aError)=0;

	/** 

	Notifies the client of a new captured camera image. Called asynchronously 

	when CCamera::CaptureImage() completes.

	@param  aCameraBuffer

	        A reference to an MCameraBuffer if successful, or NULL if not successful.

	@param  aError

	        KErrNone if successful, or an error code if not successful.

	@note   If new image capture classes used, then this callback will not be used. Refer MCaptureImageObserver

	*/

	virtual void ImageBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)=0;

	/** 

	Notifies the client of new captured video. Called asynchronously and periodically

	after CCamera::StartVideoCapture() is called. The buffer has been filled with the 

	required number of video frames specified PrepareVideoCaptureL().

	@param  aCameraBuffer

	        A reference to an MCameraBuffer if successful, or NULL if not successful.

	@param  aError

	        KErrNone if successful, or an error code if not successful.

	*/

	virtual void VideoBufferReady(MCameraBuffer& aCameraBuffer,TInt aError)=0;

	};

/** Base class for camera devices.

Provides the interface that an application uses to control, and acquire images

from, the camera.

An application must supply an implementation of MCameraObserver2 (or MCameraObserver).

@publishedAll

@released

*/

class CCamera : public CBase

	{

	friend class CCameraPlugin;

public:

	class CCameraPresets;

	class CCameraAdvancedSettings;

	class CCameraImageProcessing;

	class CCameraHistogram;

	class CCameraV2Histogram;

	class CCameraOverlay;

	class CCameraSnapshot;

	class CCameraDirectViewFinder;

	class CCameraV2DirectViewFinder;

	class CCameraClientViewFinder;

	class CCameraPreImageCaptureControl;

	class CCameraImageCapture;

	class CCameraPostImageCaptureControl;

	class CCameraVideoCaptureControl;

    class CCameraDirectSnapshot;

public:

	/** Possible still image and video frame formats

	Formats are read from left to right, starting at the top of the image. YUV

	format is as defined by ITU-R BT.601-4. */

	enum TFormat

		{

		/** 8 bit greyscale values, 0=black, 255=white. */

		EFormatMonochrome			= 0x0001,

		/** Packed RGB triplets, 4 bits per pixel with red in the least significant bits

		and the 4 most significant bits unused. */

		EFormat16bitRGB444			= 0x0002,

		/** Packed RGB triplets, 5 bits per pixel for red and blue and 6 bits for green,

		with red in the least significant bits. */

		EFormat16BitRGB565			= 0x0004,

		/** Packed RGB triplets, 8 bits per pixel with red in the least significant bits

		and the 8 most significant bits unused. */

		EFormat32BitRGB888			= 0x0008,

		/** JFIF JPEG. */

		EFormatJpeg					= 0x0010,

		/** EXIF JPEG */

		EFormatExif					= 0x0020,

		/** CFbsBitmap object with display mode EColor4K. */

		EFormatFbsBitmapColor4K		= 0x0040,

		/** CFbsBitmap object with display mode EColor64K. */

		EFormatFbsBitmapColor64K	= 0x0080,

		/** CFbsBitmap object with display mode EColor16M. */

		EFormatFbsBitmapColor16M	= 0x0100,

		/** Implementation dependent. */

		EFormatUserDefined			= 0x0200,

		/** 4:2:0 format, 8 bits per sample, Y00Y01Y10Y11UV. */

		EFormatYUV420Interleaved	= 0x0400,

		/** 4:2:0 format, 8 bits per sample, Y00Y01Y02Y03...U0...V0... */

		EFormatYUV420Planar			= 0x0800,

		/** 4:2:2 format, 8 bits per sample, UY0VY1. */

		EFormatYUV422				= 0x1000,

		/** 4:2:2 format, 8 bits per sample, Y1VY0U. */

		EFormatYUV422Reversed		= 0x2000,

		/** 4:4:4 format, 8 bits per sample, Y00U00V00 Y01U01V01... */

		EFormatYUV444				= 0x4000,

		/** 4:2:0 format, 8 bits per sample, Y00Y01Y02Y03...U0V0... */

		EFormatYUV420SemiPlanar		= 0x8000,

		/** CFbsBitmap object with display mode EColor16MU. */

		EFormatFbsBitmapColor16MU 	= 0x00010000, 	

		/** Motion JPEG for video 

		@note This value is available only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L()

		@internalTechnology