diff -r 000000000000 -r a41df078684a kerneltest/e32test/examples/camera1/camera1.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/examples/camera1/camera1.h	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,304 @@
+// Copyright (c) 2005-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 "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:
+// in its implementation.
+// 
+//
+
+/**
+ @file The interface to an example camera device driver which uses Shared Chunks
+ @publishedPartner
+ @prototype 9.1
+*/
+
+#ifndef __CAMERA1_H__
+#define __CAMERA1_H__
+
+#include <e32cmn.h>
+#include <e32ver.h>
+#ifndef __KERNEL_MODE__
+#include <e32std.h>
+#endif
+
+/**
+User interface for 'Camera1'
+*/
+class RCamera1 : public RBusLogicalChannel
+	{
+public:
+	/**
+	Structure for holding driver capabilities information
+	(Just a version number in this example.)
+	*/
+	class TCaps
+		{
+	public:
+		TVersion iVersion;
+		};
+
+	/**
+	Structure for holding driver configuration data
+	*/
+	class TConfig
+		{
+	public:
+		TSize iImageSize;			/**< Size of image in pixels */
+		TInt iImageBytesPerPixel;	/**< Number of bytes used to represent a single pixel */
+		TInt iFrameRate;			/**< Speed to capture images at in frames per second*/
+		TInt iNumImageBuffers;		/**< Number of simultanious images the client wishes to process */
+		};
+	typedef TPckgBuf<TConfig> TConfigBuf;
+
+#ifndef __KERNEL_MODE__
+public:
+	TInt Open();
+	void Close();
+	TInt GetConfig(TConfigBuf& aConfig);
+	TInt SetConfig(const TConfigBuf& aConfig);
+	TInt StartCapture();
+	TInt EndCapture();
+	void CaptureImage(TRequestStatus& aStatus, TInt aReleaseImage=-1);
+	void CaptureImageCancel();
+	TInt ReleaseImage(TInt aReleaseImage);
+	TInt Duplicate(const RThread& aSrc,TOwnerType aType=EOwnerProcess);
+	inline RChunk ImageChunk() const;
+private:
+	RChunk iChunk;   /**< The chunk into which captured images will be placed */
+#endif
+
+public:
+	inline static const TDesC& Name();
+	inline static TVersion VersionRequired();
+
+private:
+	/**
+	Enumeration of Control messages.
+	*/
+	enum TControl
+		{
+		EGetConfig,
+		ESetConfig,
+		EStartCapture,
+		EEndCapture,
+		ECaptureImage,
+		EReleaseImage
+		};
+
+	/**
+	Enumeration of Request messages.
+	(None used in this example)
+	*/
+	enum TRequest
+		{
+		ENumRequests,
+		EAllRequests = (1<<ENumRequests)-1
+		};
+
+	// Kernel side LDD channel is a friend
+	friend class DCamera1Channel;
+	};
+
+/**
+  The driver's name
+
+  @return The name of the driver
+
+  @internalComponent
+*/
+inline const TDesC& RCamera1::Name()
+	{
+	_LIT(KCamera1Name,"CAMERA1");
+	return KCamera1Name;
+	}
+
+/**
+  The driver's version
+
+  @return The version number of the driver
+
+  @internalComponent
+*/
+inline TVersion RCamera1::VersionRequired()
+	{
+	const TInt KMajorVersionNumber=1;
+	const TInt KMinorVersionNumber=0;
+	const TInt KBuildVersionNumber=KE32BuildVersionNumber;
+	return TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
+	}
+
+/*
+  NOTE: The following methods would normally be exported from a seperate client DLL
+  but are included inline in this header file for convenience.
+*/
+
+#ifndef __KERNEL_MODE__
+
+/**
+  Open a logical channel to the driver
+
+  @return One of the system wide error codes.
+*/
+TInt RCamera1::Open()
+	{
+	return DoCreate(Name(),VersionRequired(),KNullUnit,NULL,NULL,EOwnerProcess);
+	}
+
+/**
+  Close a logical channel to the driver
+*/
+void RCamera1::Close()
+	{
+	iChunk.Close();
+	RBusLogicalChannel::Close();
+	}
+
+/**
+  Get the current configuration settings.
+
+  @param aConfig A structure which will be filled with the configuration settings.
+
+  @return KErrNone
+*/
+TInt RCamera1::GetConfig(TConfigBuf& aConfig)
+	{
+	return DoControl(EGetConfig,(TAny*)&aConfig);
+	}
+
+/**
+  Set the current configuration settings.
+
+  @param aConfig The new configuration settings to be used.
+
+  @return KErrInUse if image capturing is already in progress
+          KErrArgument if any configuration values are invalid.
+		  KErrNone otherwise
+
+  @post On success, iChunk will contain the handle of the chunk used to
+        contain captured images.
+*/
+TInt RCamera1::SetConfig(const TConfigBuf& aConfig)
+	{
+	iChunk.Close(); // The following call will give us a new handle
+	return iChunk.SetReturnedHandle(DoControl(ESetConfig,(TAny*)&aConfig));
+	}
+
+/**
+  Start the image capture process.
+
+  @return KErrNotReady if SetConfig() has not been previously called.
+          KErrNone otherwise.
+
+  @pre The driver must have been previousely initialised by a call to SetConfig()
+*/
+TInt RCamera1::StartCapture()
+	{
+	return DoControl(EStartCapture);
+	}
+
+/**
+  End the image capturing process.
+  Also performs CaptureImageCancel()
+*/
+TInt RCamera1::EndCapture()
+	{
+	return DoControl(EEndCapture);
+	}
+
+/**
+  Get the next available image and optionally release an already captured image.
+  Only one request may be pending at any time.
+
+  @param aStatus The request status signaled when an image is available (or on error).
+                 The result value is the offset within iChunk where the capture image resides;
+		         or set to one of the system wide error codes when an error occurs:
+				 KErrNotReady if StartCapture() hasn't been previousely called,
+				 KErrInUse if there is already a pending CaptureImage() request,
+				 KErrOverflow if the client already has all the images buffers.
+
+  @param aReleaseImage The chunk offset of an image which the client has finished processing.
+                       Set to -1 to indicate 'no image'
+
+  @pre Image capturing must have been started with StartCapture()
+*/
+void RCamera1::CaptureImage(TRequestStatus& aStatus,TInt aReleaseImage)
+	{
+	aStatus=KRequestPending;
+	DoControl(ECaptureImage,(TAny*)&aStatus,(TAny*)aReleaseImage);
+	}
+
+/**
+  Cancel a previous CaptureImage() request
+*/
+void RCamera1::CaptureImageCancel()
+	{
+	DoCancel(1<<ECaptureImage);
+	}
+
+/**
+  Release an already captured image.
+
+  This makes the images buffer available again for the driver to capture images into.
+
+  @param aReleaseImage The chunk offset of the image to be released.
+                       This is a value returned by a CaptureImage() request.
+*/
+TInt RCamera1::ReleaseImage(TInt aReleaseImage)
+	{
+	return DoControl(EReleaseImage,(TAny*)aReleaseImage);
+	}
+
+/**
+  Override of RHandleBase::Duplicate.
+  This takes care of also duplicating other resources owned by this object.
+  @param aSrc  A reference to the thread containing the handle which is to be 
+               duplicated for this thread.
+  @param aType An enumeration whose enumerators define the ownership of this 
+               handle. If not explicitly specified, EOwnerProcess is taken
+               as default.
+  @return KErrNone, if successful; otherwise, one of the other system wide error 
+          codes.
+  @see RHandleBase::Duplicate
+*/
+TInt RCamera1::Duplicate(const RThread& aSrc,TOwnerType aType)
+	{
+	// Duplicate handle to channel
+	TInt r=RHandleBase::Duplicate(aSrc,aType);
+	if(r==KErrNone && iChunk.Handle()!=KNullHandle)
+		{
+		// Duplicate handle to chunk
+		r = iChunk.Duplicate(aSrc,aType);
+		if(r!=KErrNone)
+			RHandleBase::Close(); // Undo channel open
+		}
+	if(r!=KErrNone)
+		iChunk.SetHandle(KNullHandle); // On error, clear chunk handle
+	return r;
+	}
+
+/**
+  Obtain the chunk into which captured images will be placed.
+  This chunk may change after calls to SetConfig().
+
+  @return The chunk
+
+  @pre The driver must have been configured using SetConfig()
+*/
+inline RChunk RCamera1::ImageChunk() const
+	{
+	return iChunk;
+	}
+
+#endif  // !__KERNEL_MODE__
+
+#endif
+