diff -r 000000000000 -r 40261b775718 mmplugins/cameraplugins/source/mmcameraclientplugin/mmcameraclientsession/src/mmcameraclientsession.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmplugins/cameraplugins/source/mmcameraclientplugin/mmcameraclientsession/src/mmcameraclientsession.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,951 @@
+// 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;
+	}