// 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 "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

 @internalTechnology

*/

#include <bluetooth/logger.h>

#include <es_sock.h>

#include <bluetoothav.h>

#include "avctpbody.h"

#include "avctpreceiver.h"

#include "avctpsender.h"

#include "avctpremotedevices.h"

#include "avctpserviceutils.h"

#include "avctpcommon.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVCTP_SERVICES);

#endif

using namespace SymbianAvctp;

/***********************************************************************************/

// Construction / Destruction Methods

/**

Two phase constructor of CAvctpBody. 

@param aNotify the client to notify of AVCTP events

@param aPid the profile id that the client wishes to use

@internalComponent

*/

CAvctpBody* CAvctpBody::NewL(MAvctpEventNotify& aNotify, TPid aPid, MAvctpChannel*& aPrimaryChannel)

	{

	LOG_STATIC_FUNC

	CAvctpBody* self = CAvctpBody::NewLC(aNotify, aPid, aPrimaryChannel);

	CleanupStack::Pop(self);

	return self;	

	}

/**

Two phase constructor of CAvctpBody which leaves newly created object on cleanupstack

@param aNotify the client to notify of AVCTP events

@param aPid the profile id that the client wishes to use

@internalComponent

*/

CAvctpBody* CAvctpBody::NewLC(MAvctpEventNotify& aNotify, TPid aPid, MAvctpChannel*& aPrimaryChannel)

	{

	LOG_STATIC_FUNC

	CAvctpBody* self = new(ELeave) CAvctpBody(aNotify, aPid);

	CleanupStack::PushL(self);

	self->ConstructL(aPrimaryChannel);

	return self;

	}

void CAvctpBody::ConstructL(MAvctpChannel*& aPrimaryChannel)

	{

	CONNECT_LOGGER

	LOG_FUNC // must be after tls is created

	aPrimaryChannel = NULL;

	// Create proxy objects

	iPrimaryChannelProxy = new(ELeave) TPrimaryChannelProxy(*this);

	iSecondaryChannelProxy = new(ELeave) TSecondaryChannelProxy(*this);

	// Start establishing AVCTP services

	User::LeaveIfError(iSocketServ.Connect());

	User::LeaveIfError(iSocketServ.ShareAuto());

	User::LeaveIfError(iAvctpPrimaryDataSocket.Open(iSocketServ, KBTAddrFamily, KSockDatagram, KAVCTP));

	// bind that socket so that the protocol knows what channel it represents

	TAvctpSockAddr addr;

	addr.SetPid(iPid);

	addr.SetChannel(KAvctpPrimaryChannel);

	User::LeaveIfError(iAvctpPrimaryDataSocket.Bind(addr));

	iPrimaryChannelSender = CAvctpSender::NewL(iNotify, iAvctpPrimaryDataSocket, iPid);

	iPrimaryChannelReceiver = CAvctpReceiver::NewL(iNotify, iAvctpPrimaryDataSocket, iPid);

	// Needs to be called after the iAvctpControlSocket.Open call

	iRemoteDevices = CAvctpRemoteDevices::NewL(iNotify, iSocketServ, iPid);

	// Finally we are done so assign channel interface

	aPrimaryChannel = static_cast<MAvctpChannel*>(iPrimaryChannelProxy);

	}

/**

c'tor

@internalComponent

*/

CAvctpBody::CAvctpBody(MAvctpEventNotify& aNotify, TPid aPid):

 	iNotify(aNotify), 

	iPid(aPid)

	{

	LOG_FUNC // okay to be before tls created cause it's not created by the time this function returns

	LOG2(_L("aNotify: 0x%08x, aPid: %d"), &aNotify, aPid)

	}

/**

d'tor

@internalComponent

*/

CAvctpBody::~CAvctpBody()

	{

	LOG_FUNC

	delete iPrimaryChannelSender;

	delete iPrimaryChannelReceiver;

	delete iSecondaryChannelSender;

	delete iSecondaryChannelReceiver;

	delete iRemoteDevices;

	iAvctpSecondaryDataSocket.Close();

	iAvctpPrimaryDataSocket.Close();

	iSocketServ.Close();

	delete iSecondaryChannelProxy;

	delete iPrimaryChannelProxy;

	CLOSE_LOGGER

	}

/***********************************************************************************/

// Methods to support RAvctp

void CAvctpBody::Close(RAvctp::TCloseType aImmediacy)

	{

	LOG_FUNC

	TRequestStatus status;

	if(iAvctpSecondaryDataSocket.SubSessionHandle())

		{

		iAvctpSecondaryDataSocket.Shutdown(aImmediacy == RAvctp::ENormal ? RSocket::ENormal : RSocket::EImmediate, status);

		User::WaitForRequest(status);

		}

	iAvctpPrimaryDataSocket.Shutdown(aImmediacy == RAvctp::ENormal ? RSocket::ENormal : RSocket::EImmediate, status);

	User::WaitForRequest(status);

	delete this;

	}

void CAvctpBody::CloseGracefully()

	{

	LOG_FUNC

	iNotify.MaenErrorNotify(TBTDevAddr(0), KErrNotSupported);

	}

/**

Function from the AVCTP spec to request a channel connection to a remote

entity.

@return KErrArgument if a NULL TBTDevAddr is provided as an argument or

		 another system wide error code  

@internalComponent

*/	

TInt CAvctpBody::PrimaryChannelAttachRequest(const TBTDevAddr& aBTDevice)

 	{

	LOG_FUNC

#ifdef _DEBUG

	TBuf<12> addr;

	aBTDevice.GetReadable(addr);

	LOG1(_L("to BT Device %S"), &addr);

#endif

	return !IsNullAddress(aBTDevice) ? iRemoteDevices->PrimaryChannelAttachRequest(aBTDevice) : KErrArgument;

 	}

TBool CAvctpBody::IsAttached(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	return iRemoteDevices->IsAttached(aBTDevice);

	}

/**

Function from the AVCTP spec to explicitly request disconnection of an existing

channel.

@param aBTDevice The remote device to disconnect

@return KErrArgument if a NULL TBTDevAddr is provided as an argument or

		 another system wide error code

@internalComponent

*/

TInt CAvctpBody::PrimaryChannelDetachRequest(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

#ifdef _DEBUG

	TBuf<12> addr;

	aBTDevice.GetReadable(addr);

	LOG1(_L("to BT Device %S"), &addr);

#endif

	return !IsNullAddress(aBTDevice) ? iRemoteDevices->PrimaryChannelDetachRequest(aBTDevice) : KErrArgument;

	}

/**

Sends AVCTP message

The Pid to send the message to was given when the client opened the RAvctp object

used to send this message.

@pre must be connected to remote

@param aBTDevice device address to which to send message

@param aTransactionLabel transaction label

@param aType the message type, i.e. Command or Response

@param aMessageInformation the contents of the message to send

@return KErrInUse if the sender AO is active or

		 KErrInvalidTransactionLabel if the transaction label was invalid or

		 KErrArgument if a NULL TBTDevAddr is provided as an argument or

		 another system wide error code

@internalComponent

*/

TInt CAvctpBody::SendMessage(const TBTDevAddr& aBTDevice, 

							 TTransactionLabel aTransactionLabel,

							 TMessageType aType,

							 const TDesC8& aMessageInformation,

							 TBool aIsSecondChannel)

	{

	LOG_FUNC

#ifdef _DEBUG

	TBuf<12> addr;

	aBTDevice.GetReadable(addr);

	LOG1(_L("to BT Device %S"), &addr);

#endif

	LOG2(_L("aTransactionLabel: %d, aType: %d"), aTransactionLabel, aType)

	TInt ret = KErrNone;

	if (IsNullAddress(aBTDevice))

		{

		ret = KErrArgument;

		}

	else if(IsValidTransactionLabel(aTransactionLabel))

		{

		__ASSERT_ALWAYS(aType == ECommand || aType == EResponse, Panic(EAvctpInvalidMessageType));

		CAvctpSender& sender(aIsSecondChannel ? *iSecondaryChannelSender : *iPrimaryChannelSender);

		ret = sender.SendMessage(aBTDevice, aTransactionLabel, aType, aMessageInformation);

		}

	else

		{

		ret = KErrInvalidTransactionLabel;

		}

	return ret;

	}

void CAvctpBody::PrimaryChannelCancelAttach(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

#ifdef _DEBUG

	TBuf<12> addr;

	aBTDevice.GetReadable(addr);

	LOG1(_L("to BT Device %S"), &addr);

#endif

	__ASSERT_DEBUG(!IsNullAddress(aBTDevice), Panic(EAvctpNullBTDevAddr));

	iRemoteDevices->PrimaryChannelCancelAttach(aBTDevice);

	}

void CAvctpBody::PrimaryChannelCancelSend()

	{

	LOG_FUNC

	iPrimaryChannelSender->Cancel();

	}

void CAvctpBody::SecondaryChannelCancelSend()

	{

	LOG_FUNC

	iSecondaryChannelSender->Cancel();

	}

TInt CAvctpBody::InstallSecondaryChannel(MAvctpEventNotify& aSecondChannelObserver, MAvctpChannel*& aSecondaryChannel)

	{

	LOG_FUNC

	TRAPD(err, DoInstallSecondaryChannelL(aSecondChannelObserver, aSecondaryChannel));

	return err;

	}

void CAvctpBody::DoInstallSecondaryChannelL(MAvctpEventNotify& aSecondChannelObserver, MAvctpChannel*& aSecondaryChannel)

	{

	LOG_FUNC

	LEAVEIFERRORL(iAvctpSecondaryDataSocket.Open(iSocketServ, KBTAddrFamily, KSockDatagram, KAVCTP));

	// bind that socket so that the protocol knows what channel it represents

	TAvctpSockAddr addr;

	addr.SetChannel(KAvctpSecondaryChannel);

	addr.SetPid(iPid);

	User::LeaveIfError(iAvctpSecondaryDataSocket.Bind(addr));

	iSecondaryChannelNotify = &aSecondChannelObserver;

	__ASSERT_DEBUG(!iSecondaryChannelSender, Panic(EAvctpSenderAlreadyAllocated));

	iSecondaryChannelSender = CAvctpSender::NewL(*iSecondaryChannelNotify, iAvctpSecondaryDataSocket, iPid);

	__ASSERT_DEBUG(!iSecondaryChannelReceiver, Panic(EAvctpReceiverAlreadyAllocated));

	iSecondaryChannelReceiver = CAvctpReceiver::NewL(*iSecondaryChannelNotify, iAvctpSecondaryDataSocket, iPid);

	iRemoteDevices->SetSecondaryChannelNotifyL(&aSecondChannelObserver);

	// finally set the interface

	aSecondaryChannel = static_cast<MAvctpChannel*>(iSecondaryChannelProxy);

	}

void CAvctpBody::UninstallSecondaryChannel(RAvctp::TCloseType aImmediacy)

	{

	LOG_FUNC

	TRequestStatus status;

	iAvctpSecondaryDataSocket.Shutdown(aImmediacy == RAvctp::ENormal ? RSocket::ENormal : RSocket::EImmediate, status);

	User::WaitForRequest(status);

	delete iSecondaryChannelSender;

	iSecondaryChannelSender = NULL;

	delete iSecondaryChannelReceiver;

	iSecondaryChannelReceiver = NULL;

	iSecondaryChannelNotify = NULL;

	iAvctpSecondaryDataSocket.Close();

	TRAPD(err, iRemoteDevices->SetSecondaryChannelNotifyL(NULL));

	__ASSERT_DEBUG(err == KErrNone, Panic(EAvctpUnexpectedLeave));

	(void)(err == KErrNone);	// to avoid "variable not used" warning in release mode

	}

TInt CAvctpBody::SecondaryChannelAttachRequest(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

#ifdef _DEBUG

	TBuf<12> addr;

	aBTDevice.GetReadable(addr);

	LOG1(_L("to BT Device %S"), &addr);

#endif

	return !IsNullAddress(aBTDevice) ? iRemoteDevices->SecondaryChannelAttachRequest(aBTDevice) : KErrArgument;

	}

TInt CAvctpBody::SecondaryChannelDetachRequest(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

#ifdef _DEBUG

	TBuf<12> addr;

	aBTDevice.GetReadable(addr);

	LOG1(_L("to BT Device %S"), &addr);

#endif

	return !IsNullAddress(aBTDevice) ? iRemoteDevices->SecondaryChannelDetachRequest(aBTDevice) : KErrArgument;

	}

void CAvctpBody::SecondaryChannelCancelAttach(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

#ifdef _DEBUG

	TBuf<12> addr;

	aBTDevice.GetReadable(addr);

	LOG1(_L("to BT Device %S"), &addr);

#endif

	__ASSERT_DEBUG(!IsNullAddress(aBTDevice), Panic(EAvctpNullBTDevAddr));

	iRemoteDevices->SecondaryChannelCancelAttach(aBTDevice);

	}

//

// Channel Proxies

//

TPrimaryChannelProxy::TPrimaryChannelProxy(CAvctpBody& aBody)

	: iBody(aBody)

	{

	}

TInt TPrimaryChannelProxy::MacAttachRequest(const TBTDevAddr& aBTDevice)

	{

	return iBody.PrimaryChannelAttachRequest(aBTDevice);

	}

TBool TPrimaryChannelProxy::MacIsAttached(const TBTDevAddr& aBTDevice)

	{

	return iBody.IsAttached(aBTDevice);

	}

void TPrimaryChannelProxy::MacCancelAttach(const TBTDevAddr& aBTDevice)

	{

	iBody.PrimaryChannelCancelAttach(aBTDevice);

	}

TInt TPrimaryChannelProxy::MacDetachRequest(const TBTDevAddr& aBTDevice)

	{

	return iBody.PrimaryChannelDetachRequest(aBTDevice);

	}

TInt TPrimaryChannelProxy::MacSendMessage(const TBTDevAddr& aBTDevice, 

					SymbianAvctp::TTransactionLabel aTransactionLabel,

					SymbianAvctp::TMessageType aType,

					const TDesC8& aMessageInformation)

	{

	return iBody.SendMessage(aBTDevice, aTransactionLabel, aType, aMessageInformation, EFalse);

	}

void TPrimaryChannelProxy::MacCancelSend()

	{

	iBody.PrimaryChannelCancelSend();

	}

TSecondaryChannelProxy::TSecondaryChannelProxy(CAvctpBody& aBody)

	: iBody(aBody)

	{

	}

TInt TSecondaryChannelProxy::MacAttachRequest(const TBTDevAddr& aBTDevice)

	{

	return iBody.SecondaryChannelAttachRequest(aBTDevice);

	}

TBool TSecondaryChannelProxy::MacIsAttached(const TBTDevAddr& aBTDevice)

	{

	return iBody.IsAttached(aBTDevice);

	}

void TSecondaryChannelProxy::MacCancelAttach(const TBTDevAddr& aBTDevice)

	{

	iBody.SecondaryChannelCancelAttach(aBTDevice);

	}

TInt TSecondaryChannelProxy::MacDetachRequest(const TBTDevAddr& aBTDevice)

	{

	return iBody.SecondaryChannelDetachRequest(aBTDevice);

	}

TInt TSecondaryChannelProxy::MacSendMessage(const TBTDevAddr& aBTDevice, 

					SymbianAvctp::TTransactionLabel aTransactionLabel,

					SymbianAvctp::TMessageType aType,

					const TDesC8& aMessageInformation)

	{

	return iBody.SendMessage(aBTDevice, aTransactionLabel, aType, aMessageInformation, ETrue);

	}

void TSecondaryChannelProxy::MacCancelSend()

	{

	iBody.SecondaryChannelCancelSend();

	}