// Copyright (c) 1997-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 <obexusbtransportinfo.h>

#include "usbconn.h"

#include <obex/transport/obexconnector.h>

#include "logger.h"

#include "obexusbfaults.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, "USB");

#endif

#ifdef _DEBUG

_LIT(KPanicCat, "ObexUsbHandler");

#endif

//

/**

CObexUsbActiveWriter factory function

@param	aTransport	Reference to a CObexUsbTransportController object. Required for a call to the CObexUsbActiveReader

@param	aOwner		Reference to a MObexTransportNotify object

@param	aUsb		Reference to a RDevUsbcClient object

@param	aInfo		Reference to a TObexConnectionInfo object

@param  aPacketSize The size of packets used on the underlying link, dependent on High Speed mode.

@return Ownership of a new CObexUsbActiveWriter.

*/

CObexUsbActiveWriter* CObexUsbActiveWriter::NewL(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb,

										   TObexConnectionInfo& aInfo, TInt aPacketSize)

	{

	CObexUsbActiveWriter* self = new(ELeave) CObexUsbActiveWriter(aOwner, aUsb, aInfo, aPacketSize);

	CleanupStack::PushL(self);

	self->BaseConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

CObexUsbActiveWriter constructor

@param	aTransport	Reference to a CObexUsbTransportController object. Required for a call to the CObexUsbActiveReader

@param	aOwner		Reference to a MObexTransportNotify object

@param	aUsb		Reference to a RDevUsbcClient object

@param	aInfo		Reference to a TObexConnectionInfo object

@param  aPacketSize The size of packets used on the underlying link, dependent on High Speed mode.

*/

CObexUsbActiveWriter::CObexUsbActiveWriter(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb,

										   TObexConnectionInfo& aInfo, TInt aPacketSize)

: CObexWriterBase(EPriorityHigh, aOwner, aInfo),

 iUsb(aUsb), iPacketSize(aPacketSize)

	{

	}

/**

CObexUsbActiveWriter destructor.

*/

CObexUsbActiveWriter::~CObexUsbActiveWriter()

	{

	LOG_FUNC

	Cancel();

	}

/**

Start actual transfer.  May be called several times by CObexActiveRW::RunL.

Queues a write on USB endpoint.

*/

void CObexUsbActiveWriter::DoTransfer()

	{

	LOG_FUNC

	LOG1(_L("CObexUsbActiveWriter::DoTransfer [Length=%d]"),iLocation.Length());

	iLocation.SetMax();

	iUsb.Write(iStatus, KTransmitEndpoint, iLocation, iLocation.Length(), ETrue);

	SetActive();

	}

/**

Cancels an outstanding write.

*/

void CObexUsbActiveWriter::DoCancel()

	{

	LOG_FUNC

	//Only cancel the write if there's more than 1 packet left to write.

	//This restriction is imposed to prevent the SUCCESS response being

	//cancelled when an ObexServer is handling a disconnect and bringing 

	//the transport down.

	if(Remaining() > iPacketSize)

		{

		iUsb.WriteCancel(KTransmitEndpoint);

		}		

	}

//

/**

CObexUsbActiveReader factory function

@param	aOwner		Reference to a MObexTransportNotify object

@param	aUsb		Reference to a RDevUsbcClient object

@param	aInfo		Reference to a TObexConnectionInfo object

@return Ownership of a new CObexUsbActiveWriter.

*/

CObexUsbActiveReader* CObexUsbActiveReader::NewL(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb,

										   TObexConnectionInfo& aInfo)

	{

	CObexUsbActiveReader* self = new(ELeave) CObexUsbActiveReader(aOwner, aUsb, aInfo);

	CleanupStack::PushL(self);

	self->BaseConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

CObexUsbActiveReader constructor

@param	aOwner		Reference to a MObexTransportNotify object

@param	aUsb		Reference to a RDevUsbcClient object

@param	aInfo		Reference to a TObexConnectionInfo object

*/

CObexUsbActiveReader::CObexUsbActiveReader(MObexTransportNotify& aOwner, RDevUsbcClient& aUsb,

										   TObexConnectionInfo& aInfo)

: CObexReaderBase(EPriorityStandard, aOwner, aInfo), iUsb(aUsb)

	{

	}

/**

CObexUsbActiveReader destructor.

*/

CObexUsbActiveReader::~CObexUsbActiveReader()

	{

	LOG_FUNC

	Cancel();

	}

/**

Start actual transfer.  May be called several times by CObexActiveRW::RunL.

Queues a read on USB endpoint.

*/

void CObexUsbActiveReader::DoTransfer()

	{

	LOG_FUNC

	LOG1(_L("CObexUsbActiveReader::DoTransfer [maxLength=%d]"),iLocation.MaxLength());

	iUsb.ReadUntilShort(iStatus, KReceiveEndpoint, iLocation);

	SetActive();

	}

/**

Cancels an outstanding read,

 */

void CObexUsbActiveReader::DoCancel()

	{

	FLOG(_L("CObexUsbActiveReader::DoCancel"));

	iUsb.ReadCancel(KReceiveEndpoint);

	}

/**

Return the maximum packet size

@return TInt the maximum packet size for this transport

*/

TInt CObexUsbActiveReader::GetMaxPacketSize()

	{

	LOG_FUNC

	return GetObexPacketDataLimit();

	}

/**

Returns a initial packet size when the packet size of iPacket is not know.  This is used

when determining the remaining bytes to be read.  

@return TInt the initial packet size

*/

TInt CObexUsbActiveReader::GetInitialPacketSize ()

	{

	LOG_FUNC

	return GetObexPacketBufferSize();

	}

//

/**

CObexUsbConnector constructor.

*/

CObexUsbConnector::CObexUsbConnector(MObexTransportNotify& aObserver, TObexUsbTransportInfo& aUsbTransportInfo)

 :	CObexConnector(aObserver), 

	iObexTransportInfo(aUsbTransportInfo), 

	iMode(EDefaultClient)

	{

	LOG_FUNC

	// Note iObexTransportInfo reference is only kept so that it can be used in the ConstructL

	// It may not be safe to use this variables outside of the construction phases

	}

/*

Returns an instance of CObexUsbConnector

@param	aController  	Reference to a MObexTransportNotify object (the CObexUsbTransportController that owns this)

@param	aTransportInfo 	Reference to a TObexUsbTransportInfo object containing the transport information

@return	A pointer to a CObexUsbConnector object

*/

CObexUsbConnector* CObexUsbConnector::NewL(MObexTransportNotify& aController, TObexUsbTransportInfo& aTransportInfo)

	{

	CObexUsbConnector* self = new(ELeave) CObexUsbConnector(aController, aTransportInfo);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return(self);

	}

/**

Second phase construction.

*/

void CObexUsbConnector::ConstructL()

	{

	LOG_FUNC

	OpenUsbL(0);

	FLOG(_L("USB opened"));

	iHandler  = CObexUsbHandler::NewL(iObexTransportInfo, *this, iUsb);

	iCallback = new(ELeave) CAsyncCallBack(EPriorityHigh);

	iStaller = CObexUsbStaller::NewL(iUsb, *this);

	iHandler->Start();

	BaseConstructL();

	}

/**

CObexUsbConnector destructor. Releases endpoint and closes USB object if we have an open connection.

*/

CObexUsbConnector::~CObexUsbConnector()

	{

	LOG_FUNC

	delete iCallback;

	delete iHandler;

	delete iStaller;

	if (iUsb.Handle())

		{	

		iUsb.Close();

		}

	}

/**

Attempt to open a client-type connection.

This will succeed if the USB host has already opened a connection to us

*/

void CObexUsbConnector::ConnectL()

	{

	LOG_FUNC

	if (iMode == EServer)

		{

		// Already performed a server-type connect, so can't act as a

		// client as well.

		FLOG(_L(" -- In server mode, give up"));

		LEAVEIFERRORL(KErrNotSupported);		

		}

	FLOG(_L(" -- Not in server mode"));

	iMode = EClient;

	if (iTransportLinkAvailable)

		{

		FLOG(_L(" -- Link available, set a callback"));

		TCallBack callback(LinkUp, this);

		iCallback->Set(callback);

		iCallback->CallBack();

		iConnectRequested = ETrue;

		}

	else

		{

		FLOG(_L(" -- No link available, set a callback"));

		TCallBack callback(NoDevice, this);

		iCallback->Set(callback);

		iCallback->CallBack();

		}

	}

/*

@param	aConn	A pointer to a connector object. Will be cast to CObexUsbConnector

@return	KErrNone

*/

TInt CObexUsbConnector::LinkUp(TAny* aConn)

	{

	FLOG(_L("CObexUsbConnector::LinkUp"));

	reinterpret_cast<CObexUsbConnector*>(aConn)->SignalUp();

	return KErrNone;

	}

/*

@param	aConn	A pointer to a connector object. Will be cast to CObexUsbConnector

@return	KErrNone

*/

TInt CObexUsbConnector::NoDevice(TAny* aConn)

	{

	FLOG(_L("CObexUsbConnector::NoDevice"));

	reinterpret_cast<CObexUsbConnector*>(aConn)->SignalDown(KErrIrObexClientPeerDoesNotHaveObex);

	return KErrNone;

	}

/**

Cancel an active connection attempt.  This is unlikely to succeed, as a client

connection over USB will complete almost immediately.

*/

void CObexUsbConnector::CancelConnect()

	{

	LOG_FUNC

	if (iMode == EClient)

		{

		iCallback->Cancel();

		}

	iConnectRequested = EFalse;

	}

/**

Start listening for a connection to us.

*/

void CObexUsbConnector::AcceptL()

	{

	LOG_FUNC

	if (iMode == EClient)

		{

		// Already carried out a client side connection.  Therefore we

		// can't be a server as well.

		FLOG(_L(" -- In client mode, give up"));

		LEAVEIFERRORL(KErrNotSupported);		

		}

	FLOG(_L(" -- Not in client mode"));

	iMode = EServer;

	if (iTransportLinkAvailable)

		{

		FLOG(_L(" -- Transport link currently available, set a callback"));

		TCallBack callback(LinkUp, this);

		iCallback->Set(callback);

		iCallback->CallBack();

		}

	else

		{

		FLOG(_L(" -- No link available, wait for one"));

		iWaitingForLink = ETrue;

		}

	}

/**

Stop listening for connections.

*/

void CObexUsbConnector::CancelAccept()

	{

	LOG_FUNC

	if (iMode == EServer)

		{

		iWaitingForLink = EFalse;

		iCallback->Cancel();

		}

	}

/**

Called to indicate transport layer has come up.

*/

void CObexUsbConnector::TransportUp()

	{

	LOG_FUNC

	SetTransportPacketSize();

	iTransportLinkAvailable = ETrue;

	if ((iMode == EServer) && (iWaitingForLink))

		{

		FLOG(_L(" -- Signalling link available"));

		iWaitingForLink = EFalse;

		SignalUp();

		}

	}

/**

Called to indicate transport layer has gone down.

@param	aErr 	Any error code associated with disconnection. Defaults to KErrDisconnected.

*/

void CObexUsbConnector::TransportDown(TInt aErr)

	{

	LOG_FUNC

	ResetTransportPacketSize();

	iStaller->Cancel();

	iTransportLinkAvailable = EFalse;

	if (iMode == EServer)

		{

		FLOG(_L(" -- In server mode, signal link down"));

		SignalDown(aErr);

		}

	else

		{

		FLOG(_L(" -- In client mode"));

		// Client or default client state

		if (iConnectRequested)

			{

			FLOG(_L(" -- Outstanding client connection. Signal link down"));

			iConnectRequested = EFalse;

			SignalDown(aErr);

			}

		}

	}

/**

Signals to the transport controller that the transport is up

*/

void CObexUsbConnector::SignalUp()

	{

	LOG_FUNC

	// Indicate transport now up

	TObexConnectionInfo sockinfo;

	sockinfo.iMaxRecvSize = 0;	// set these to zero as we can't find them out

	sockinfo.iMaxSendSize = 0;	// and they are not used

	sockinfo.iSocketType = TObexConnectionInfo::EUsbStream;

	Observer().TransportUp(sockinfo);

	}

/**

Signals (with an error code) to the transport controller that the transport has gone down 

*/

void CObexUsbConnector::SignalDown(TInt aErr)

	{

	FLOG(_L("CObexUsbConnector::SignalDown"));

	Observer().Error(aErr);

	}

/**

The Obex server running over USB is not able to bring the transport

down itself. It will only delete the transport object when an error

has occurred (such as the link being brought down) and hence the

transport is no longer valid.

@return	ETrue

*/

TBool CObexUsbConnector::BringTransportDown()

{

	// This cancel function needs to be called here because it

	// doesn't get called anywhere else. Bluetooth and IrDA rely

	// on the socket shutdown to cancel the accept.

	CancelAccept();

	return ETrue;

}

/**

Return the transport layer object for use by USB transport objects

@return Pointer to the USB transport layer object

*/

RDevUsbcClient* CObexUsbConnector::TransportObject()

	{

	return &iUsb;