// Copyright (c) 2007-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:
//

#include <bluetooth/eirpublisher.h>
#include <e32uid.h>
#include <e32base.h>
#include <bluetooth/eirclient.h>
#include <bluetooth/eirmanshared.h>
#include "eirmanclientlogger.h"


void Panic(TBTEirPublisherPanic aPanic)
	{
	User::Panic(KBTEirPublisherPanic, aPanic);
	}

EXPORT_C CEirPublisher* CEirPublisher::NewL(TEirTag aEirTag, MEirPublisherNotifier& aNotifier)
	{
	LOG1(_L8("CEirPublisher::NewL creating publisher with tag %d"), aEirTag);
	CEirPublisher* self = new(ELeave) CEirPublisher(aEirTag, aNotifier);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CEirPublisher::CEirPublisher(TEirTag aEirTag, MEirPublisherNotifier& aNotifier)
	: CActive(CActive::EPriorityStandard)
	, iEirTag(aEirTag)
	, iNotifier(aNotifier)
	, iPublishOutstanding(EFalse)
	, iRequiredBytes(0)
	{
	CActiveScheduler::Add(this);
	}

CEirPublisher::~CEirPublisher()
	{
	LOG_FUNC
	iEirMan.Close(); // this should handle everything!
	Cancel();
	delete iNotifierAo;
	}

void CEirPublisher::ConstructL()
	{
	LOG_FUNC
	iNotifierAo = new(ELeave) CEirPublisherNotifier(*this);
	iEirMan.Connect(iStatus);
	iState = EConnecting;
	SetActive();
	}

/**
Notify server the required bytes from this client for the Extended Inquiry Response packet.
@param aRequiredBytes for the required bytes from this client
*/
EXPORT_C void CEirPublisher::PublishData(TInt aRequiredBytes)
	{
	LOG_FUNC
	__ASSERT_DEBUG(iState != EInvalid, Panic(EUnexpectedPublisherState));
	if(iState == ENoConnection)
		{
		// If there is no connection to server currently, create one and indicate a request is outstanding.
		iEirMan.Connect(iStatus);
		iState = EConnecting;
		iPublishOutstanding = ETrue;
		iRequiredBytes = aRequiredBytes;
		SetActive();
		}
	else if(iState != EIdle)
		{
		iPublishOutstanding = ETrue;
		iRequiredBytes = aRequiredBytes;
		}
	else
		{
		iState = ENewData;
		iEirMan.NewData(aRequiredBytes, iStatus);
		SetActive();
		}
	}

/**
Send data and its type to server to update the Extended Inquiry Response packet.
@param aData for the data to be added into Extended Inquiry Response
@param aDataMode for the type of data from this client (partial or complete)
*/
EXPORT_C void CEirPublisher::SetData(const TDesC8& aData, TEirDataMode aDataMode)
	{
	LOG_FUNC
	// Make sure that client has an invitation to the party
	__ASSERT_ALWAYS(iState == EDataCallback, PANIC(KEirManCliPncCat, EEirManPanicSetDataUninvited));
	iState = ESettingData;
	iEirMan.SetData(aData, aDataMode, iStatus);
	SetActive();
	}

void CEirPublisher::RunL()
	{
	LOG_FUNC
	LEAVEIFERRORL(iStatus.Int());
	
	switch(iState)
		{
	case EConnecting:
		iEirMan.RegisterTag(iEirTag, iStatus);
		iState = ERegisterTag;
		SetActive();
		break;
	case ERegisterTag:
		iNotifierAo->Start();
		// Fall through...
	case ENewData:
		// Fall through...
	case ESettingData:
		if(iPublishOutstanding)
			{
			iPublishOutstanding = EFalse;
			iState = ENewData;
			iEirMan.NewData(iRequiredBytes, iStatus);
			SetActive();
			}
		else if(iCallbackOutstanding)
			{
			iCallbackOutstanding = EFalse;
			iState = EDataCallback;
			LOG1(_L8("CEirPublisher::RunL: About to call back client with bytes available: %d"), iAvailableBytes);
			iNotifier.MepnSpaceAvailable(iAvailableBytes);
			}
		else
			{
			iState = EIdle;
			}
		break;		
	default:
		// Unexpected
		__ASSERT_DEBUG(EFalse, Panic(EUnexpectedPublisherState));
		break;
		}
	}

void CEirPublisher::DoCancel()
	{
	LOG_FUNC
	iNotifierAo->Cancel();
	// Because of asynchronous shutdown - we close the session and tidy up
	// the active objects locally.
	__ASSERT_DEBUG(!iEirMan.Handle(), Panic(EInvalidEirManHandle)); 
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrCancel);
	iState = EInvalid;
	}

TInt CEirPublisher::RunError(TInt aError)
	{
	LOG_FUNC
	LOG1(_L8("CEirPublisher::RunError: %d"), aError);
	// report error to client
	iNotifier.MepnSetDataError(aError);
	if (iState == EConnecting)
		{
		// We have a problem on Connecting to server, set the state to No Connection
		iState = ENoConnection;
		}
	return KErrNone;
	}

void CEirPublisher::SpaceAvailable(TUint aSpace)
	{
	LOG_FUNC
	
	if (aSpace > KEirLengthTagLength)
		{
		iAvailableBytes = aSpace - KEirLengthTagLength;
		}
	else
		{
		iAvailableBytes = 0;
		}
	if(iState == EIdle)
		{
		iState = EDataCallback;
		LOG1(_L8("CEirPublisher::RunL: About to call back client with bytes available: %d"), iAvailableBytes);
		iNotifier.MepnSpaceAvailable(iAvailableBytes);
		}
	else
		{
		iCallbackOutstanding = ETrue;
		}
	}

void CEirPublisher::NotifierError(TInt aError)
	{
	static_cast<void>(RunError(aError));
	}

REirMan& CEirPublisher::EirMan()
	{
	LOG_FUNC
	return iEirMan;
	}



CEirPublisherNotifier::CEirPublisherNotifier(CEirPublisher& aPublisher)
	: CActive(EPriorityStandard)
	, iPublisher(aPublisher)
	{
	LOG_FUNC
	CActiveScheduler::Add(this);
	}

CEirPublisherNotifier::~CEirPublisherNotifier()
	{
	LOG_FUNC
	Cancel();
	}

void CEirPublisherNotifier::Start()
	{
	LOG_FUNC
	iPublisher.EirMan().SpaceAvailableNotification(iSpaceAvailable, iStatus);
	SetActive();
	}

void CEirPublisherNotifier::RunL()
	{
	LOG_FUNC
	LEAVEIFERRORL(iStatus.Int());
	TUint spaceAvailable = iSpaceAvailable;
	iPublisher.EirMan().SpaceAvailableNotification(iSpaceAvailable, iStatus);
	SetActive();
	iPublisher.SpaceAvailable(spaceAvailable);
	}

void CEirPublisherNotifier::DoCancel()
	{
	LOG_FUNC
	// Because of asynchronous shutdown - we close the session and tidy up
	// the active objects locally.
	__ASSERT_DEBUG(!(iPublisher.EirMan().Handle()), Panic(EInvalidEirManHandle)); 
	TRequestStatus* status = &iStatus;
	User::RequestComplete(status, KErrCancel);
	}

TInt CEirPublisherNotifier::RunError(TInt aError)
	{
	LOG_FUNC
	iPublisher.NotifierError(aError);
	return KErrNone;
	}