Create Logic device.

	DP("DECLARE_STANDARD_LDD()");

	return new DWebcameraLogicalDevice;

Constructor

	// Set version number for this device

	iVersion = RWebcameraDevice::VersionRequired();

	// Indicate that we work with a PDD

	iParseMask = KDeviceAllowPhysicalDevice;

Destructor

Second stage constructor for DDriver1Factory.

This must at least set a name for the driver object.

@return KErrNone if successful, otherwise one of the other system wide error codes.

Return the drivers capabilities.

Called in the response to an RDevice::GetCaps() request.

@param aDes User-side descriptor to write capabilities information into

	// Create a capabilities object

	caps.iVersion = iVersion;

	// Write it back to user memory

	Kern::InfoCopy(aDes, (TUint8*)&caps, sizeof(caps));

Called by the kernel's device driver framework to create a Logical Channel.

This is called in the context of the user thread (client) which requested the creation of a Logical Channel

(E.g. through a call to RBusLogicalChannel::DoCreate)

The thread is in a critical section.

@param aChannel Set to point to the created Logical Channel

@return KErrNone if successful, otherwise one of the other system wide error codes.

	if (!aChannel)

		{

		}

	DP("DWebcameraLogicalDevice::Create() end");

Constructor

	: iReceiveDataDfc(GetFlameDfc, this, 1)

	, iCaptureDfc(CaptureDfc, this, 1)

	// Get pointer to client threads DThread object

	iClient = &Kern::CurrentThread();

	// Open a reference on client thread so it's control block can't dissapear until

	// this driver has finished with it.

	iWebCameraState = RWebcameraDevice::EPowerOff;

Destructor

	// Cancel all processing that we may be doing

	DoCancel(RWebcameraDevice::EAllRequests);

	// Close sharedchunks

	CloseSharedChunks();

	// Close our reference on the client thread

	Kern::SafeClose((DObject*&)iClient, NULL);

	delete iConvert;

	// Buffer Free.

	Kern::Free(iHeaderPtr);

	Kern::Free(iDataPtr);

	Kern::Free(iBmpBuf);

Called when a user thread requests a handle to this channel.

	{

	// Make sure that only our client can get a handle

	if (aType != EOwnerThread || aThread != iClient)

		{

		return KErrAccessDenied;

		}

	return KErrNone;

	}

Second stage constructor called by the kernel's device driver framework.

This is called in the context of the user thread (client) which requested the creation of a Logical Channel

(E.g. through a call to RBusLogicalChannel::DoCreate)

The thread is in a critical section.

@param aUnit The unit argument supplied by the client

@param aInfo The info argument supplied by the client

@param aVer The version argument supplied by the client

@return KErrNone if successful, otherwise one of the other system wide error codes.

	if (!Kern::CurrentThreadHasCapability(ECapability_None, __PLATSEC_DIAGNOSTIC_STRING("Checked by Webcamera")))

		{

		return KErrPermissionDenied;

		}

	// Check version

	if (!Kern::QueryVersionSupported(RWebcameraDevice::VersionRequired(), aVer))

	// Setup LDD for receiving client messages

	//Associate DFCs with the same queue we set above to receive client messages on

	//Give PDD a pointer to this channel

	Pdd()->iLdd = this;	

	// Create shared chunk.

	TInt rtn = CreatSharedChunks();

	if (rtn)

Process a message for this logical channel.

This function is called in the context of a DFC thread.

@param aMessage	The message to process.

				The iValue member of this distinguishes the message type:

				iValue==ECloseMsg, channel close message

				iValue==KMaxTInt, a 'DoCancel' message

				iValue>=0, a 'DoControl' message with function number equal to iValue

				iValue<0, a 'DoRequest' message with function number equal to ~iValue

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	// Get message type

	TInt id = m.iValue;

	DP("id=%d",id);

	// Decode the message type and dispatch it to the relevent handler function...

	if (id == (TInt)ECloseMsg)

	if (m.Client() != iClient)

		m.Complete(KErrNone, ETrue);

		return;

		}

	if (id == KMaxTInt)

		{

		DoCancel(m.Int0());

		m.Complete(KErrNone, ETrue);

	if (id < 0)

		TRequestStatus* pS = (TRequestStatus*)m.Ptr0();

		TInt rtn = DoRequest(~id, pS, m.Ptr1(), aMsg);

			{

			Kern::RequestComplete(iClient, pS, rtn);

			}

		m.Complete(KErrNone, ETrue);

		TInt rtn = DoControl(id, m.Ptr0(), aMsg);

		m.Complete(rtn, ETrue);

Process synchronous 'control' requests

TInt DWebcameraLogicalChannel::DoControl(TInt aFunction, TAny* a1, TAny* /*a2*/)

	rtn = KErrNone;

//			rtn = SetConfig((const TDesC8*)a1);

			break;

		case RWebcameraDevice::EOpenSharedChunck:

			rtn=OpenSharedChunks((RWebcameraDevice::TChunkInfo*)a1);

			break;

		case RWebcameraDevice::EInitViewFinder:

			rtn = Pdd()->InitViewFinder();

			iDataPtr = Kern::Alloc(BUFSIZE);

			iBmpBuf = (TUint8*)Kern::Alloc(BITMAPBUFSIZE);

			break;

Process asynchronous requests.

											TAny* /*a2*/)

	iRequesting = ETrue;

	rtn = KErrNone;

	switch (aReqNo)

			iReceiving = ETrue;

			iWebCameraState = RWebcameraDevice::EStart;

			iReceiveDataDfc.Add();

			// Example Platform Security capability check which tests the

			// client for ECapability_None (which always passes)...

			if (iRequesting == EFalse)

				iReceiving = EFalse;

				Kern::RequestComplete(iClient,

									  iReceiveDataStatus,

									  iReceiveDataResult);

				}

			else

				{

				iReceiveDataDescriptor = (TInt*)a1;

				}

			break;

		case RWebcameraDevice::ECapture:

			iCaptureStatus = aStatus;

			iWebCameraState = RWebcameraDevice::ECapture;

			iCaptureDfc.Add();

			if (iRequesting == EFalse)

				{

				Kern::RequestComplete(iClient, iCaptureStatus, iCaptureResult);

		        iCaptureDescriptor=(TInt*)a1;

		case RWebcameraDevice::EPowerOn:

			if (iPowerOn == EFalse)

				iPowerOn = ETrue;

				iWebCameraState = RWebcameraDevice::EPowerOn;

				iHeaderPtr = Kern::Alloc(sizeof(TWebcameraUVC));

				rtn = Pdd()->PowerOn(iHeaderPtr);

				Kern::RequestComplete(iClient, aStatus, rtn);

				Kern::RequestComplete(iClient, aStatus, KErrAlreadyExists);

		case RWebcameraDevice::EPowerOff:

			Pdd()->Disconnect();

			iPowerOn = EFalse;

			iReceiving = EFalse;

			iReceiveDataDfc.Cancel();

			iCaptureDfc.Cancel();

			iWebCameraState = RWebcameraDevice::EPowerOff;

			Kern::RequestComplete(iClient, aStatus, rtn);

			break;

			rtn = KErrNotSupported;

			Kern::RequestComplete(iClient, aStatus, rtn);

Process cancelling of asynchronous requests.

	if (aMask & (1 << RWebcameraDevice::EStart))

		{

			iReceiving = EFalse;

			Kern::RequestComplete(iClient, iReceiveDataStatus, KErrCancel);

		}

	if (aMask&(1<<RWebcameraDevice::ECapture))

		{

			Kern::RequestComplete(iClient, iCaptureStatus, KErrCancel);

		}

Called by PDD from ISR to indicate that a ReceiveData operation has completed.

	{

	iSaveSize = iSize - aDataSize;

	// Queue DFC

	iWebCameraState = RWebcameraDevice::ETransferData;

	iReceiveDataDfc.Add();

	//set size of received data

	if (iSaveSize > 0)

		{

		iReceiveDataResult = KErrNone;

		}

	else

		{

		iReceiveDataResult = KErrUnknown; //TODO:define of error

		}

	}

void DWebcameraLogicalChannel::DoStartViewFinder()

	{

	TInt rtn = Pdd()->StartViewerFinder(iDataPtr, BUFSIZE);

	if (rtn != KErrNone)

		{

		DP("rtn=%d",rtn);

		iReceiving = EFalse;

		Kern::RequestComplete(iClient, iReceiveDataStatus, rtn);

		}

	}

/**

DFC Callback which gets triggered after the PDD has signalled that getting oneflame completed.

This just casts aPtr and calls DoGetOneFlameComplete().

*/

void DWebcameraLogicalChannel::GetFlameDfc(TAny* aPtr)

	{

	switch (((DWebcameraLogicalChannel*)aPtr)->iWebCameraState)

		{

	case RWebcameraDevice::EStart:

		((DWebcameraLogicalChannel*)aPtr)->DoStartViewFinder();

		break;

	case RWebcameraDevice::ETransferData:

		((DWebcameraLogicalChannel*)aPtr)->DoGetOneFlameComplete();

		break;

	default:

		break;

		}

	}

/**

DFC Callback

gets Capture image completed.

This just casts aPtr and calls DoCaptureComplete().

*/

void DWebcameraLogicalChannel::CaptureDfc(TAny* aPtr)

	{

	DP("DWebcameraLogicalChannel::CaptureDfc() start");

	((DWebcameraLogicalChannel*)aPtr)->DoCaptureComplete();

	DP("DWebcameraLogicalChannel::CaptureDfc() end");

	}

Called from a DFC after the PDD has signalled that getting oneflame completed.

	{

	if (!iConvert)

		{

		iConvert = new DWebCameraConvert((TWebcameraUVC*)iHeaderPtr);

		}

	iConvert->ConvertData((TUint8*)iDataPtr, iBmpBuf);

	kumemget((TAny*)(iChunkLinAddr), iBmpBuf, iSaveSize);

	TInt result = Kern::ThreadRawWrite(iClient, iReceiveDataDescriptor, &iSaveSize,sizeof(TInt), 0);

	// Finished with client descriptor, so NULL it to help detect coding errors

	iReceiveDataDescriptor = NULL;

	// Use result code from PDD if it was an error

	if(iReceiveDataResult != KErrNone)

		{

		result = iReceiveDataResult;

		}

	// Complete clients request

	Kern::RequestComplete(iClient, iReceiveDataStatus, result);

	}

Called from a DFC after the PDD has signalled that getting Capture image completed.

	{