/*

* Copyright (c) 2003-2010 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:

*

*/

#include <e32uid.h>

#include <usbman.h>

#include <usb.h>

#include <e32base.h>

#ifdef __USBMAN_NO_PROCESSES__

#include <e32math.h>

#endif

static TInt StartServer()

//

// Start the server process or thread

//

	{

	const TUidType serverUid(KNullUid, KNullUid, KUsbmanSvrUid);

#ifdef __USBMAN_NO_PROCESSES__

	//

	// In EKA1 WINS the server is a DLL, the exported entrypoint returns a TInt

	// which represents the real entry-point for the server thread

	//

	RLibrary lib;

	TInt err = lib.Load(KUsbmanImg, serverUid);

	if (err != KErrNone)

		{

		return err;

		}

	TLibraryFunction ordinal1 = lib.Lookup(1);

	TThreadFunction serverFunc = reinterpret_cast<TThreadFunction>(ordinal1());

	//

	// To deal with the unique thread (+semaphore!) naming in EPOC, and that we may

	// be trying to restart a server that has just exited we attempt to create a

	// unique thread name for the server.

	// This uses Math::Random() to generate a 32-bit random number for the name

	//

	TName name(KUsbServerName);

	name.AppendNum(Math::Random(),EHex);

	RThread server;

	err = server.Create (

		name,

		serverFunc,

		KUsbmanStackSize,

		NULL,

		&lib,

		NULL,

		KUsbmanMinHeapSize,

		KUsbmanMaxHeapSize,

		EOwnerProcess

	);

	lib.Close();	// if successful, server thread has handle to library now

#else

	//

	// EPOC and EKA2 is easy, we just create a new server process. Simultaneous

	// launching of two such processes should be detected when the second one

	// attempts to create the server object, failing with KErrAlreadyExists.

	//

	RProcess server;

	TInt err = server.Create(KUsbmanImg, KNullDesC, serverUid);

#endif //__USBMAN_NO_PROCESSES__

	if (err != KErrNone)

		{

		return err;

		}

	TRequestStatus stat;

	server.Rendezvous(stat);

	if (stat!=KRequestPending)

		server.Kill(0);		// abort startup

	else

		server.Resume();	// logon OK - start the server

	User::WaitForRequest(stat);		// wait for start or death

	// we can't use the 'exit reason' if the server panicked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone

	err = (server.ExitType() == EExitPanic) ? KErrServerTerminated : stat.Int();

	server.Close();

	return err;

	}

EXPORT_C RUsb::RUsb() 

	: iDeviceStatePkg(0), iServiceStatePkg(0), iMessagePkg(0), 

	  iHostPkg(TDeviceEventInformation())

	{

	}

EXPORT_C RUsb::~RUsb()

	{

	}

EXPORT_C TVersion RUsb::Version() const

	{

	return(TVersion(KUsbSrvMajorVersionNumber,KUsbSrvMinorVersionNumber,KUsbSrvBuildVersionNumber));

	}

EXPORT_C TInt RUsb::Connect()

	{

	TInt retry = 2;

	FOREVER

		{

		// Create the session to UsbSrv with 10 asynchronous message slots

		TInt err = CreateSession(KUsbServerName, Version(), 10);

		if ((err != KErrNotFound) && (err != KErrServerTerminated))

			{

			return err;

			}

		if (--retry == 0)

			{

			return err;

			}

		err = StartServer();

		if ((err != KErrNone) && (err != KErrAlreadyExists))

			{

			return err;

			}

		}

	}

EXPORT_C void RUsb::Start(TRequestStatus& aStatus)

	{

	SendReceive(EUsbStart, aStatus);

	}

EXPORT_C void RUsb::StartCancel()

	{

	SendReceive(EUsbStartCancel);

	}

EXPORT_C void RUsb::Stop()

	{

	SendReceive(EUsbStop);

	}

EXPORT_C void RUsb::Stop(TRequestStatus& aStatus)

	{

	SendReceive(EUsbStop, aStatus);

	}

EXPORT_C void RUsb::StopCancel()

	{

	SendReceive(EUsbStopCancel);

	}

EXPORT_C TInt RUsb::GetServiceState(TUsbServiceState& aState)

	{

	TPckg<TUint32> pkg(aState);

	TInt ret=SendReceive(EUsbGetCurrentState, TIpcArgs(&pkg));

	aState=(TUsbServiceState)pkg();

	return ret;

	}

EXPORT_C TInt RUsb::GetCurrentState(TUsbServiceState& aState)

	{

	return GetServiceState(aState);

	}

EXPORT_C void RUsb::ServiceStateNotification(TUsbServiceState& aState,

	TRequestStatus& aStatus)

	{

	iServiceStatePkg.Set((TUint8*)&aState, sizeof(TUint32), sizeof(TUint32));

	SendReceive(EUsbRegisterServiceObserver, TIpcArgs(&iServiceStatePkg), aStatus);

	}

EXPORT_C void RUsb::ServiceStateNotificationCancel()

	{

	SendReceive(EUsbCancelServiceObserver);

	}

EXPORT_C TInt RUsb::GetDeviceState(TUsbDeviceState& aState)

	{

	TPckg<TUint32> pkg(aState);

	TInt ret=SendReceive(EUsbGetCurrentDeviceState, TIpcArgs(&pkg));

	aState=(TUsbDeviceState)pkg();

	return ret;

	}

EXPORT_C void RUsb::DeviceStateNotification(TUint aEventMask, TUsbDeviceState& aState,

											TRequestStatus& aStatus)

	{

	iDeviceStatePkg.Set((TUint8*)&aState, sizeof(TUint32), sizeof(TUint32));

	SendReceive(EUsbRegisterObserver, TIpcArgs(aEventMask, &iDeviceStatePkg), aStatus);

	}

EXPORT_C void RUsb::DeviceStateNotificationCancel()

	{

	SendReceive(EUsbCancelObserver);

	}

EXPORT_C void RUsb::StateNotification(TUint aEventMask, TUsbDeviceState& aState, TRequestStatus& aStatus)

	{

	DeviceStateNotification(aEventMask, aState, aStatus);

	}

EXPORT_C void RUsb::StateNotificationCancel()

	{

	DeviceStateNotificationCancel();

	}

EXPORT_C void RUsb::TryStart(TInt aPersonalityId, TRequestStatus& aStatus)

	{

	TIpcArgs ipcArgs(aPersonalityId);

	SendReceive(EUsbTryStart, ipcArgs, aStatus);

	}

EXPORT_C void RUsb::TryStop(TRequestStatus& aStatus)

	{

	SendReceive(EUsbTryStop, aStatus);

	}

EXPORT_C TInt RUsb::CancelInterest(TUsbReqType aMessageId)

	{

	TInt messageId;

	switch (aMessageId)

		{

	case EStart:

		messageId = EUsbStart;

		break;

	case EStop:

		messageId = EUsbStop;

		break;

	case ETryStart:

		messageId = EUsbTryStart;

		break;

	case ETryStop:

		messageId = EUsbTryStop;

		break;

	default:

		return KErrNotSupported;

		}

	TIpcArgs ipcArgs(messageId);

	return SendReceive(EUsbCancelInterest, ipcArgs);

	}

EXPORT_C TInt RUsb::GetDescription(TInt aPersonalityId, HBufC*& aLocalizedPersonalityDescriptor)

	{

	TInt ret = KErrNone;

	// caller is responsible for freeing up memory allocatd for aLocalizedPersonalityDescriptor

	TRAP(ret, aLocalizedPersonalityDescriptor = HBufC::NewL(KUsbStringDescStringMaxSize));

	if (ret == KErrNone)

		{

		TPtr ptr = aLocalizedPersonalityDescriptor->Des();

		TIpcArgs ipcArgs(0, &ptr);

		ipcArgs.Set(0, aPersonalityId);

		ret = SendReceive(EUsbGetDescription, ipcArgs);

		}

	else

		{

		// just in case caller tries to free the memory before checking the return code

		aLocalizedPersonalityDescriptor = NULL;

		}

	return ret;	

	}

EXPORT_C TInt RUsb::GetCurrentPersonalityId(TInt& aPersonalityId)

	{

	TPckg<TInt> pkg0(aPersonalityId);

	TInt ret = SendReceive(EUsbGetCurrentPersonalityId, TIpcArgs(&pkg0));

	aPersonalityId = static_cast<TInt>(pkg0());

	return ret;	

	}

EXPORT_C TInt RUsb::GetSupportedClasses(TInt aPersonalityId, RArray<TUid>& aClassUids)

	{

	TInt ret = KErrNone;

	HBufC8* buf = NULL;

	// +1 for the actual count of personality ids

	TRAP(ret, buf = HBufC8::NewL((KUsbMaxSupportedClasses + 1)*sizeof (TInt32)));

	if (ret != KErrNone)

		{

		return ret;

		}

	TPtr8 ptr8 = buf->Des();

	ret = SendReceive(EUsbGetSupportedClasses, TIpcArgs(aPersonalityId, &ptr8));

	if (ret == KErrNone)

		{

		const TInt32* recvedIds = reinterpret_cast<const TInt32*>(buf->Ptr());

		if (!recvedIds)

			{

			delete buf;

			return KErrCorrupt;

			}

		TInt arraySize = *recvedIds++;

		// Copy received supported class ids to aClassUids

		for (TInt i = 0; i < arraySize; i++)

			{

			if (recvedIds)

				{

				ret = aClassUids.Append(TUid::Uid(*recvedIds++));

				if(ret!=KErrNone)

					{

					//Remove all the ids appended so far (assume the last append failed, because

					//the only reason to fail is if the array couldn't grow to accommodate another

					//element).

					//It would be easier to just reset the array, but we never specified that

					//aClassUids should be an empty array, nor did we specify that this method

					//might empty the array. To maintain exisiting behaviour we should return

					//aClassUids to the state it was in when this method was called.

					TInt last = aClassUids.Count() - 1;

					while(i>0)

						{

						aClassUids.Remove(last);

						i--;

						last--;

						}	

					break;

					}

				}

			else

				{

				ret = KErrCorrupt;

				break;

				}

			}

		}

	delete buf;

	return ret;

	}

EXPORT_C TInt RUsb::ClassSupported(TInt aPersonalityId, TUid aClassUid, TBool& aSupported)

	{

	TPckg<TInt32>  	pkg2(aSupported);

	TIpcArgs ipcArgs(aPersonalityId, aClassUid.iUid, &pkg2);

	TInt ret = SendReceive(EUsbClassSupported, ipcArgs);

	if (ret == KErrNone)

		{

		aSupported = static_cast<TBool>(pkg2());		

		}

	return ret;

	}

EXPORT_C TInt RUsb::GetPersonalityIds(RArray<TInt>& aPersonalityIds)

	{

	TInt ret = KErrNone;

	HBufC8* buf = NULL;

	// +1 for the actual count of personality ids

	TRAP(ret, buf = HBufC8::NewL((KUsbMaxSupportedPersonalities + 1)*sizeof (TInt)));

	if (ret != KErrNone)

		{

		return ret;

		}

	TPtr8 ptr8 = buf->Des();

	ret = SendReceive(EUsbGetPersonalityIds, TIpcArgs(&ptr8));

	if (ret == KErrNone)

		{

		const TInt* recvedIds = reinterpret_cast<const TInt*>(buf->Ptr());

		if (!recvedIds)

			{

			delete buf;

			return KErrCorrupt;

			}

		TInt arraySize = *recvedIds++;

		// Copy received personality ids to aPersonalityIds

		for (TInt i = 0; i < arraySize; i++)

			{

			if (recvedIds)

				{		

				ret = aPersonalityIds.Append(*recvedIds++);

				if(ret!=KErrNone)

					{

					//Remove all the ids appended so far (assume the last append failed, because

					//the only reason to fail is if the array couldn't grow to accommodate another

					//element).

					//It would be easier to just reset the array, but we never specified that

					//aPersonalityIds should be an empty array, nor did we specify that this method

					//might empty the array. To maintain exisiting behaviour we should return

					//aPersonalityIds to the state it was in when this method was called.

					TInt last = aPersonalityIds.Count() - 1;

					while(i>0)

						{

						aPersonalityIds.Remove(last);

						i--;

						last--;

						}	

					break;

					}

				}

			else

				{

				ret = KErrCorrupt;

				break;

				}

			}

		}

	delete buf;

	return ret;

	}

EXPORT_C TInt RUsb::__DbgMarkHeap()

	{

#ifdef _DEBUG

    return SendReceive(EUsbDbgMarkHeap);

#else

    return KErrNone;