// 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;
	}