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

*/

#include <ecom/ecom.h>

#include <ecom/implementationproxy.h>

#include <f32file.h>

#include "mmcameraclientsession.h"

#include "mmdirectviewfinder.h"

#include <graphics/surfaceconfiguration.h>

#include "w32std.h"

/**

 * First-phase constructor

 */

CMMCameraClientSession::CMMCameraClientSession():iCameraObserver2(NULL),

									 iReserved(EFalse),

									 iPoweredUp(EFalse),

									 iPrepareCompleted(EFalse),

									 iCollaborativeClient(EFalse)

	{

	}

/**

 * NewL() factory function

 */

CMMCameraClientSession* CMMCameraClientSession::NewL()

	{

	FileDependencyUtil::CheckFileDependencyL();

	return new (ELeave) CMMCameraClientSession;

	}

/**

 * Destructor

 */

CMMCameraClientSession::~CMMCameraClientSession()

	{

	delete iCameraPowerHandler;

	delete iCameraAccessHandler;

	iHashMap.Close();

	iCameraSession.Close();

	}

//

// from CCameraPlugin

//

/**

 * Derived from CCameraPlugin. Second Phase contruction

 *

 * @see CCameraPlugin

 */

void CMMCameraClientSession::Construct2L(MCameraObserver& /*aObserver*/, TInt /*aCameraIndex*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Derived from CCameraPlugin. Second Phase contruction for collaborative clients

 *

 * @see CCameraPlugin

 */

void CMMCameraClientSession::Construct2DupL(MCameraObserver& /*aObserver*/, TInt /*aCameraHandle*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Derived from CCameraPlugin. Second Phase contruction

 *

 * @see CCameraPlugin

 */

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

	{

	if (aCameraIndex > CamerasAvailable())

		{

		User::Leave(KErrNotSupported);

		}

	iCameraIndex = aCameraIndex;

	iPriority = aPriority;

	iCameraObserver2 = &aObserver;

	//initialize server

	//create session

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

	//open camera

	TOpenCamera openCam;

	openCam.iCameraIndex = iCameraIndex;

	openCam.iPriority = iPriority;

	openCam.iHandle = KECamHandleNotKnown;

	openCam.iMMCapability = ETrue;  //could be changed.

	openCam.iCollaborativeClient = EFalse;

	TOpenCameraPckg openCamBuf(openCam);

	User::LeaveIfError(iCameraSession.SendMessage(ECamOpenCamera, openCamBuf));

					// since this call is synchronous, providing reference to local

					//  varialbe is not a problem.

	iCameraAccessHandler = CMMCameraAccessHandler::NewL(this, CActive::EPriorityStandard);

	iCameraPowerHandler = CMMCameraPowerHandler::NewL(this, CActive::EPriorityStandard);

	}

/**

 * Derived from CCameraPlugin. Second Phase contruction for collaborative clients

 *

 * @see CCameraPlugin

 */

void CMMCameraClientSession::Construct2DupL(MCameraObserver2& /*aObserver*/, TInt /*aCameraHandle*/)

	{

	User::Leave(KErrNotSupported);	

	}

//

// from CCamera itself

//

/**

 * Retrieves information about the currectly reserved camera device

 *

 * @see CCamera::CameraInfo()

 */

void CMMCameraClientSession::CameraInfo(TCameraInfo& /*aInfo*/) const

	{ 

	return;

	}

/**

 * Reserves the camera

 *

 * @see CCamera::Reserve()

 */

void CMMCameraClientSession::Reserve()

	{

	iCameraAccessHandler->Reserve();

	}

/**

 * Relinquishes control of the camera device

 *

 * @see CCamera::Release()

 */

void CMMCameraClientSession::Release()

	{

	iCameraSession.SendMessage(ECamCameraAccessControl, ECameraRelease);

	iPoweredUp = EFalse;

	}

/**

 * Powers on the camera device

 *

 * @see CCamera::PowerOn()

 */

void CMMCameraClientSession::PowerOn()

	{

	iCameraPowerHandler->PowerOn();

	}

/**

 * Powers down the camera device

 *

 * @see CCamera::PowerOff()

 */

void CMMCameraClientSession::PowerOff()

	{	

	iCameraSession.SendMessage(ECamPowerCamera, ECameraPowerOff);

	iPoweredUp = EFalse;

	}

/**

 * Retrieves the handle of the currently reserved camera

 *

 * @see CCamera::Handle()

 */

TInt CMMCameraClientSession::Handle()

	{

	TCameraHandle handle;

	TCameraHandlePckg pckg(handle);

	iCameraSession.SendRxMessage(ECamCameraHandle, pckg);

	handle = pckg();

	return handle.iHandle;

	}

/**

 * Sets the optical zoom level

 *

 * @see CCamera::SetZoomFactorL()

 */

void CMMCameraClientSession::SetZoomFactorL(TInt aZoomFactor)

	{

	User::LeaveIfError(iCameraSession.SendMessage(ECamSetParameter, EZoomFactor, aZoomFactor));

	}

/**

 *  Retrieves current optical zoom level

 *

 * @see CCamera::ZoomFactor()

 */

TInt CMMCameraClientSession::ZoomFactor() const

	{

	TCameraZoom zoomFactor;

	TCameraZoomPckg pckg(zoomFactor);

	iCameraSession.SendRxMessage(ECamGetParameter, EZoomFactor, pckg);

	zoomFactor = pckg();

	return zoomFactor.iZoom;

	}

/**

 * Sets the digital zoom level

 *

 * @see CCamera::SetDigitalZoomFactorL()

 */

void CMMCameraClientSession::SetDigitalZoomFactorL(TInt aDigitalZoomFactor)

	{

	User::LeaveIfError(iCameraSession.SendMessage(ECamSetParameter, EDigitalZoomFactor, aDigitalZoomFactor));

	}

/**

 * Retrieves the current digital zoom level

 *

 * @see CCamera::DigitalZoomFactor()

 */

TInt CMMCameraClientSession::DigitalZoomFactor() const

	{

	TCameraDigitalZoom digitalZoomFactor;

	TCameraDigitalZoomPckg pckg(digitalZoomFactor);

	iCameraSession.SendRxMessage(ECamGetParameter, EDigitalZoomFactor, pckg);

	digitalZoomFactor = pckg();

	return digitalZoomFactor.iDigitalZoom;

	}

/**

 * Sets the contrast level

 *

 * @see CCamera::SetContrastL()

 */

void CMMCameraClientSession::SetContrastL(TInt aContrast)

	{

	User::LeaveIfError(iCameraSession.SendMessage(ECamSetParameter, EContrast, aContrast));

	}

/**

 * Retrieves the current contrast level

 *

 * @see CCamera::Contrast()

 */

TInt CMMCameraClientSession::Contrast() const

	{

	TCameraContrast contrast;

	TCameraContrastPckg pckg(contrast);

	iCameraSession.SendRxMessage(ECamGetParameter, EContrast, pckg);

	contrast = pckg();

	return contrast.iContrast;

	}

/**

 * Sets the brightness level

 *

 * @see CCamera::SetBrightnessL()

 */

void CMMCameraClientSession::SetBrightnessL(TInt aBrightness)

	{

	User::LeaveIfError(iCameraSession.SendMessage(ECamSetParameter, EBrightness, aBrightness));

	}

/**

 * Retrieves the current brightness level

 *

 * @see CCamera::Brigthness()

 */

TInt CMMCameraClientSession::Brightness() const

	{

	TCameraBrightness brightness;

	TCameraBrightnessPckg pckg(brightness);

	iCameraSession.SendRxMessage(ECamGetParameter, EBrightness, pckg);

	brightness = pckg();

	return brightness.iBrightness;

	}

/**

 * Sets the flash level

 *

 * @see CCamera::SetFlashL()

 */

void CMMCameraClientSession::SetFlashL(TFlash aFlash)

	{

	TCameraFlash flash;

	flash.iFlash = aFlash;

	TCameraFlashPckg pckg(flash);

	User::LeaveIfError(iCameraSession.SendMessage(ECamSetParameter, EFlash, pckg));

	}

/**

 * Retrieves the current flash level

 *

 * @see CCamera::Flash()

 */

CCamera::TFlash CMMCameraClientSession::Flash() const

	{

	TCameraFlash flash;

	TCameraFlashPckg pckg(flash);

	iCameraSession.SendRxMessage(ECamGetParameter, EFlash, pckg);

	flash = pckg();

	return flash.iFlash;

	}

/**

 * Sets the exposure level

 *

 * @see CCamera::SetExposureL()

 */

void CMMCameraClientSession::SetExposureL(TExposure aExposure)

	{

	TCameraExposure exposure;

	exposure.iExposure = aExposure;

	TCameraExposurePckg pckg(exposure);

	User::LeaveIfError(iCameraSession.SendMessage(ECamSetParameter, EExposure, pckg));

	}

/**

 * Retrieves the current exposure level

 *

 * @see CCamera::Exposure()

 */

CCamera::TExposure CMMCameraClientSession::Exposure() const

	{

	TCameraExposure exposure;

	TCameraExposurePckg pckg(exposure);

	iCameraSession.SendRxMessage(ECamGetParameter, EExposure, pckg);

	exposure = pckg();

	return exposure.iExposure;

	}

/**

 * Sets the white balance level

 *

 * @see CCamera::SetWhiteBalance()

 */

void CMMCameraClientSession::SetWhiteBalanceL(TWhiteBalance aWhiteBalance)

	{

	TCameraWhiteBalance whiteBalance;

	whiteBalance.iWhiteBalance = aWhiteBalance;

	TCameraWhiteBalancePckg pckg(whiteBalance);

	User::LeaveIfError(iCameraSession.SendMessage(ECamSetParameter, EWhiteBalance, pckg));

	}

/**

 * Retrieves the current white balance level

 *

 * @see CCamera::WhiteBalance()

 */

CCamera::TWhiteBalance CMMCameraClientSession::WhiteBalance() const

	{

	TCameraWhiteBalance whiteBalance;

	TCameraWhiteBalancePckg pckg(whiteBalance);

	iCameraSession.SendRxMessage(ECamGetParameter, EWhiteBalance, pckg);

	whiteBalance = pckg();

	return whiteBalance.iWhiteBalance;	

	}

/**

 * Starts client direct viewfinder.

 * Not supported in this implementation.

 * 

 * @see CCamera::StartViewFinderDirectL()

 */

void CMMCameraClientSession::StartViewFinderDirectL(RWsSession& /*aWs*/, CWsScreenDevice& /*aScreenDevice*/, RWindowBase& /*aWindow*/, TRect& /*aScreenRect*/)

	{

	User::Leave(KErrNotSupported);	

	}

/**

 * Starts client direct viewfinder.

 * Not supported in this implementation.

 * 

 * @see CCamera::StartViewFinderDirectL()

 */

void CMMCameraClientSession::StartViewFinderDirectL(RWsSession& /*aWs*/, CWsScreenDevice& /*aScreenDevice*/, RWindowBase& /*aWindow*/, TRect& /*aScreenRect*/, TRect& /*aClipRect*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Starts client viewfinder.

 * Not supported in this implementation.

 * 

 * @see CCamera::StartViewFinderBitmapsL()

 */

void CMMCameraClientSession::StartViewFinderBitmapsL(TSize& /*aSize*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Starts client viewfinder.

 * Not supported in this implementation.

 * 

 * @see CCamera::StartViewFinderBitmapsL()

 */

void CMMCameraClientSession::StartViewFinderBitmapsL(TSize& /*aSize*/, TRect& /*aClipRect*/)

	{

	User::Leave(KErrNotSupported);	

	}

/**

 * Starts client viewfinder.

 * Not supported in this implementation.

 * 

 * @see CCamera::StartViewFinderL()

 */

void CMMCameraClientSession::StartViewFinderL(CCamera::TFormat /*aImageFormat*/, TSize& /*aSize*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Starts client viewfinder.

 * Not supported in this implementation.

 * 

 * @see CCamera::StartViewFinderL()

 */

void CMMCameraClientSession::StartViewFinderL(CCamera::TFormat /*aImageFormat*/, TSize& /*aSize*/, TRect& /*aClipRect*/)

	{

	User::Leave(KErrNotSupported);	

	}

/**

 * Stops client viewfinder.

 * Not supported in this implementation.

 * 

 * @see CCamera::StopViewFinder()

 */

void CMMCameraClientSession::StopViewFinder()

	{

	return;

	}

/**

 * Queries if viewfinder is active.

 * Not supported in this implementation.

 * 

 * @see CCamera::ViewFinderActive()

 */

TBool CMMCameraClientSession::ViewFinderActive() const

	{

	return EFalse;

	}

/**

 * Turns on/off viewfinder mirrorring.

 * Not supported in this implementation.

 * 

 * @see CCamera::SetViewFinderMirrorL()

 */

void CMMCameraClientSession::SetViewFinderMirrorL(TBool /*aMirror*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Queries whether viewfinder mirrorring is on or off.

 * Not supported in this implementation.

 * 

 * @see CCamera::ViewFinderMirrorL()

 */

TBool CMMCameraClientSession::ViewFinderMirror() const

	{

	return EFalse;

	}

/**

 * Prepares image capture.

 * 

 * @see CCamera::PrepareImageCapture()

 */

void CMMCameraClientSession::PrepareImageCaptureL(CCamera::TFormat /*aImageFormat*/, TInt /*aSizeIndex*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Prepares image capture.

 * 

 * @see CCamera::PrepareImageCapture()

 */

void CMMCameraClientSession::PrepareImageCaptureL(CCamera::TFormat /*aImageFormat*/, TInt /*aSizeIndex*/, const TRect& /*aClipRect*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Captures image.

 * 

 * @see CCamera::CaptureImage()

 */

void CMMCameraClientSession::CaptureImage()

	{

	return;

	}

/**

 * Cancels any ongoing image capture.

 * 

 * @see CCamera::CaptureImage()

 */

void CMMCameraClientSession::CancelCaptureImage()

	{

	return;

	}

/**

 * Enumerates image capture sizes.

 * 

 * @see CCamera::EnumerateCaptureSizes()

 */

void CMMCameraClientSession::EnumerateCaptureSizes(TSize& /*aSize*/, TInt /*aSizeIndex*/, CCamera::TFormat /*aFormat*/) const

	{

	return;

	}

/**

 * Prepares video capture.

 * 

 * @see CCamera::PrepareVideoCaptureL()

 */

void CMMCameraClientSession::PrepareVideoCaptureL(CCamera::TFormat /*aFormat*/, TInt /*aSizeIndex*/, TInt /*aRateIndex*/, TInt /*aBuffersToUse*/, TInt /*aFramesPerBuffer*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Prepares video capture.

 * 

 * @see CCamera::PrepareVideoCaptureL()

 */

void CMMCameraClientSession::PrepareVideoCaptureL(CCamera::TFormat /*aFormat*/, TInt /*aSizeIndex*/, TInt /*aRateIndex*/, TInt /*aBuffersToUse*/, TInt /*aFramesPerBuffer*/, const TRect& /*aClipRect*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

 * Starts video capture.

 * 

 * @see CCamera::StartVideoCapture()

 */

void CMMCameraClientSession::StartVideoCapture()

	{

	return;

	}

/**

 * Stops video capture.

 * 

 * @see CCamera::StopVideoCapture()

 */

void CMMCameraClientSession::StopVideoCapture()

	{

	return;

	}

/**

 * Queries whether video capture is active.

 * 

 * @see CCamera::VideoCaptureActive()

 */

TBool CMMCameraClientSession::VideoCaptureActive() const

	{

	return EFalse;	

	}

/**

 * Enumerates video frame sizes.

 * 

 * @see CCamera::EnumerateVideoFrameSizes()

 */

void CMMCameraClientSession::EnumerateVideoFrameSizes(TSize& /*aSize*/, TInt /*aSizeIndex*/, CCamera::TFormat /*aFormat*/) const

	{

	return;

	}

/**

 * Enumerates video frame rates.

 * 

 * @see CCamera::EnumerateVideoFrameRates()

 */

void CMMCameraClientSession::EnumerateVideoFrameRates(TReal32& /*aRate*/, TInt /*aRateIndex*/, CCamera::TFormat /*aFormat*/, TInt /*aSizeIndex*/, TExposure /*aExposure*/) const

	{

	return;

	}

/**

 * Retrieve the frame size.

 * 

 * @see CCamera::GetFrameSize()

 */

void CMMCameraClientSession::GetFrameSize(TSize& /*aSize*/) const

	{

	return;	

	}

/**

 * Retrieve the frame rate.

 * 

 * @see CCamera::FrameRate()

 */

TReal32 CMMCameraClientSession::FrameRate() const

	{

	return static_cast<TReal32>(0);

	}

/**

 * Retrieve the number of buffers currently in use.

 * 

 * @see CCamera::BuffersInUse()

 */

TInt CMMCameraClientSession::BuffersInUse() const

	{

	return 0;

	}

/**

 * Retrieve the number of frames per buffer.

 * 

 * @see CCamera::FramesPerBuffer()

 */

TInt CMMCameraClientSession::FramesPerBuffer() const

	{

	return 0;	

	}

/**

 * Set the Jpeg quality.

 * 

 * @see CCamera::SetJpegQuality()

 */

void CMMCameraClientSession::SetJpegQuality(TInt /*aQuality*/)

	{

	return;

	}

/**

 * Retrieve the Jpeg quality.

 * 

 * @see CCamera::JpegQuality()

 */

TInt CMMCameraClientSession::JpegQuality() const

	{

	return 0;	

	}

/**

 * Retrieves a custom interface based on the id passed in by the client.

 * 

 * @see CCamera::CustomInterface()

 */

TAny* CMMCameraClientSession::CustomInterface(TUid aInterface)

	{

	switch (aInterface.iUid)

		{

		// The framework retrieves KECamMCameraV2DirectViewFinderUidValue followed by KECamMCameraBaseV2DirectViewFinderUidValue

		// We take care to initialise iDirectViewFinder in the first case and use it in the subsequent call

		case KECamMCameraV2DirectViewFinderUidValue:

			{

			ASSERT(!iDirectViewFinder);

			TRAPD(err, iDirectViewFinder = CMMDirectViewFinder::NewL(*this));

			if (err != KErrNone)

				{

				return NULL;

				}

			return static_cast<MCameraV2DirectViewFinder*>(iDirectViewFinder);

	        }

		case KECamMCameraBaseV2DirectViewFinderUidValue:

			{

			ASSERT(iDirectViewFinder);

			iVF = static_cast<MCameraViewFinder*>(iDirectViewFinder);

			//delete iDirectViewFinder;

			iDirectViewFinder = NULL;

			return iVF;

	        }

		default:

			{

			return NULL;

			}

		}

	}

//

// From CCameraInfoPlugin

//

CMMCameraClientSessionInfo* CMMCameraClientSessionInfo::NewL()

	{

	FileDependencyUtil::CheckFileDependencyL();

	return new (ELeave) CMMCameraClientSessionInfo;

	}

CMMCameraClientSessionInfo::~CMMCameraClientSessionInfo()

	{

	}

/**

 * Retrieves the number of cameras available.

 * 

 * @see CCameraInfoPlugin::CamerasAvailable()

 */

TInt CMMCameraClientSessionInfo::CamerasAvailable()

	{

	// One-off connection to the server

	RMMCameraSession cameraSession;

	TInt error = cameraSession.Connect();

	if (error != KErrNone)

		{

		return 0;

		}

	TCamerasAvailable info;

	TCamerasAvailablePckg pckg(info);

	error = cameraSession.SendMessage(ECamQueryCamerasAvailable, pckg);

	cameraSession.Close();

	if (error != KErrNone)

		{

		return 0;

		}

	info = pckg();

	return info.iCameraCount;

	}

CMMCameraClientSessionInfo::CMMCameraClientSessionInfo()

	{

	}

void FileDependencyUtil::CheckFileDependencyL()

	{	

	RFs fsSession;

  	RFile file;

    CleanupClosePushL(fsSession);

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

    TInt err = file.Open(fsSession, KMMCameraPluginName, EFileRead);

  	file.Close();

  	if(err != KErrNone)

  		{

	    User::LeaveIfError(KErrNotSupported);

  		}

  	CleanupStack::PopAndDestroy(&fsSession);

	}

//

// CLASS CMMCameraAccessHandler

//

CMMCameraAccessHandler::CMMCameraAccessHandler(CMMCameraClientSession* aPlugin, TInt aPriority): CActive(aPriority), 

																					   iPlugin(aPlugin)

	{

	}

CMMCameraAccessHandler* CMMCameraAccessHandler::NewL(CMMCameraClientSession* aPlugin, TInt aPriority)

	{

	CMMCameraAccessHandler* self = new (ELeave) CMMCameraAccessHandler(aPlugin, aPriority);

	CActiveScheduler::Add(self);

	return self;

	}

CMMCameraAccessHandler::~CMMCameraAccessHandler()

	{

	Cancel();

	}

void CMMCameraAccessHandler::Reserve()

	{

	if(!IsActive())

		{

		// Reserve the camera

		iPlugin->iCameraSession.ReceiveMessage(ECamCameraAccessControl, ECameraReservedNotification, iStatus);

		SetActive();

		}

	else

		{

		// Reserve has been called again before first call has completed so notify the client

		TECAMEvent ecamEvent(KUidECamEventReserveComplete, KErrInUse);

		iPlugin->iCameraObserver2->HandleEvent(ecamEvent);

		}

	}

void CMMCameraAccessHandler::RunL()

	{ 

	TInt ret = iStatus.Int();

	if(!iPlugin->iReserved)

		{

		if(KErrNone == ret)

			{

			iPlugin->iReserved = ETrue;

			if(!IsActive())

				{

				// Continue monitoring for overthrow messages should a higher priority client reserve the same camera index

				iPlugin->iCameraSession.ReceiveMessage(ECamCameraAccessControl, ECameraOverthrowNotification, iStatus);

				SetActive();

				}

			}

		// notify the client that reserve has completed, successfully or otherwise

		TECAMEvent ecamEvent(KUidECamEventReserveComplete, ret);	

		iPlugin->iCameraObserver2->HandleEvent(ecamEvent);

		}

	else

		{

		iPlugin->iReserved = EFalse;

		if (ret == KErrNone)

			{

			// Client has been overthrown by a second client with higher priority

			TECAMEvent ecamEvent(KUidECamEventCameraNoLongerReserved, ret);

			iPlugin->iCameraObserver2->HandleEvent(ecamEvent);		

			}

		}

	}

void CMMCameraAccessHandler::DoCancel()

	{

	if(!iPlugin->iReserved)

		{

		iPlugin->iCameraSession.SendMessage(ECamCameraAccessControl, ECameraCancelReservedNotification);

		// Notify client that ongoing reserve request was cancelled

		TECAMEvent ecamEvent(KUidECamEventReserveComplete, KErrCancel);

		iPlugin->iCameraObserver2->HandleEvent(ecamEvent);

		}

	else

		{

		iPlugin->iCameraSession.SendMessage(ECamCameraAccessControl, ECameraCancelOverthrowNotification);

		iPlugin->iReserved = EFalse;

		}

	}

//

//

// CLASS CMMCameraPowerHandler

//

CMMCameraPowerHandler::CMMCameraPowerHandler(CMMCameraClientSession* aPlugin, TInt aPriority): CActive(aPriority), 

																					 iPlugin(aPlugin)

	{

	}

CMMCameraPowerHandler* CMMCameraPowerHandler::NewL(CMMCameraClientSession* aPlugin, TInt aPriority)

	{

	CMMCameraPowerHandler* self = new (ELeave) CMMCameraPowerHandler(aPlugin, aPriority);

	CActiveScheduler::Add(self);

	return self;

	}

CMMCameraPowerHandler::~CMMCameraPowerHandler()

	{

	Cancel();

	}

void CMMCameraPowerHandler::PowerOn()

	{ 

	if(!IsActive())

		{

		iPlugin->iCameraSession.ReceiveMessage(ECamPowerCamera, ECameraPowerOnNotification, iStatus);

		SetActive();

		}

	else

		{

		// PowerOn has been called again before first call has completed so notify the client

		TECAMEvent ecamEvent(KUidECamEventPowerOnComplete, KErrAlreadyExists);	

		iPlugin->iCameraObserver2->HandleEvent(ecamEvent);	

		}

	}

void CMMCameraPowerHandler::RunL()

	{ 

	TInt ret = iStatus.Int();

	if(!iPlugin->iPoweredUp)

		{

		if (ret == KErrNone)

			{

			iPlugin->iPoweredUp = ETrue;

			}

		}

	TECAMEvent ecamEvent(KUidECamEventPowerOnComplete, ret);	

	iPlugin->iCameraObserver2->HandleEvent(ecamEvent);

	}

void CMMCameraPowerHandler::DoCancel()

	{

	if(!iPlugin->iPoweredUp)

		{

		iPlugin->iCameraSession.SendMessage(ECamPowerCamera, ECameraCancelPowerOnNotification);

		} 

	}

// __________________________________________________________________________

// Exported proxy for instantiation method resolution

// Define the interface UIDs

const TImplementationProxy ImplementationTable[] = 

	{

	IMPLEMENTATION_PROXY_ENTRY(KUidMMCameraClientSession, CMMCameraClientSession::NewL),

	IMPLEMENTATION_PROXY_ENTRY(KUidMMCameraClientSessionInfo, CMMCameraClientSessionInfo::NewL)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return ImplementationTable;

	}