/*

* Copyright (c) 2004-2007 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:  Defines the CBtChannelBase class.

*

*/

#include <obex.h>

#include "crsbtdevice.h"

#include "cbtchannelbase.h"

#include "cbtsoapcodec.h"

#include "clog.h"

#include "tbtmapper.h"

#include "cbtdiscover.h"

#include "printmessagecodes.h"

#include "rsutils.h"

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::CBtChannelBase

//

//--------------------------------------------------------------------------------------------

CBtChannelBase::CBtChannelBase(MBtPCObserver& aObs):

	CActive(CActive::EPriorityStandard),

	iObs( aObs ),

	iState( EStateNone ),

	iJobId( KErrNotFound ),

	iChannel( NULL ),

	iSoapCodec( NULL ),

	iObexBufObject( NULL ),

	iObexNullObject( NULL ),

	iObexBody( NULL ),

	iDevice( NULL ),

	iWait( NULL ),

	iResponseError(KErrNone),

	iStop(EFalse)

{

	LOG("[CBtChannelBase::CBtChannelBase]\t");

	CActiveScheduler::Add(this);

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::~CBtChannelBase

//

//--------------------------------------------------------------------------------------------

CBtChannelBase::~CBtChannelBase()

{

	LOG("[CBtChannelBase::~CBtChannelBase]\t");

	if(iWait)

	{

		StopWaiting();

		delete iWait;

	}

	ClearConnection();

	if(iSoapCodec)

		delete iSoapCodec;

	if(iObexNullObject)

		delete iObexNullObject;

	if(iObexBufObject)

		delete iObexBufObject;

	if(iObexBody)

		delete iObexBody;

	if(iChannel)

	{

		delete iChannel;

		iChannel = NULL;

	}

	if (iPasswordQuery)

	{

		delete iPasswordQuery;

		iPasswordQuery = NULL;

	}

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::ConstructL

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::ConstructL()

{

	LOG("[CBtChannelBase::ConstructL]\t begin");

	iWait = new (ELeave) CActiveSchedulerWait;

	LOG("[CBtChannelBase::ConstructL]\t iSoapCodec");

	iSoapCodec = CBtSoapCodec::NewL();

	// Create obex objects here: do not NEVER delete them but in destructor

	iObexBody = CBufFlat::NewL(8);

	iObexBufObject = CObexBufObject::NewL(iObexBody);

	iObexNullObject = CObexNullObject::NewL();

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::SetDevice

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::SetJobId( TInt aId )

{

	iJobId = aId;

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::Device

//

//--------------------------------------------------------------------------------------------

TInt CBtChannelBase::JobId() const

{

	return iJobId;

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::SetDevice

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::SetDevice( CRsBtDevice& aDevice )

{

	iDevice = &aDevice;

	LOG1("[CBtChannelBase::SetDevice]\t iDevice %d", iDevice);

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::Device

//

//--------------------------------------------------------------------------------------------

const CRsBtDevice& CBtChannelBase::Device() const

{

	return *iDevice;

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::StartL

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::StartL( CRsBtDevice& aDevice )

{

	LOG1("[CBtChannelBase::StartL]\t state %d", iState);

	User::LeaveIfNull(&aDevice);

	Stop();

	iStop = EFalse;

	TBool btOn = RsUtils::IsBluetoothOn();

	LOG1("[CBtChannelBase::StartL]\t btOn: %d", btOn);

	if( !btOn )

		User::Leave( EObexConnectError );

	SetDevice( aDevice );

	iState = EStateNone;

	ConnectL();

	WaitL();

	LOG("[CBtChannelBase::StartL]\t out");

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::Stop

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::Stop()

{

	LOG("[CBtChannelBase::Stop]\t");

	iStop = ETrue;

	if( IsActive() )

	{

		Cancel();

	}

	else

		StopWaiting();

	ClearConnection();

	LOG("[CBtChannelBase::Stop]\t out");

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::DoCancel

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::DoCancel()

{

	LOG("[CBtChannelBase::DoCancel]\t");

	StopWaiting();

	LOG1("[CBtChannelBase::DoCancel]\t iChannel %d", iChannel);

	if(iChannel)

	{

		LOG1("[CBtChannelBase::DoCancel]\t iStatus.Int(): 0x%X", iStatus.Int());

		if(KRequestPending == iStatus.Int())

		{

			DeleteChannel();

		}

	}

	LOG1("[CBtChannelBase::DoCancel]\t out iStatus 0x%X", iStatus.Int());

}

//------------------------------

// InCalls

//------------------------------

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::IsConnected

//

//--------------------------------------------------------------------------------------------

TBool CBtChannelBase::IsConnected()

{

	TBool connected = EFalse;

	if(iChannel && iChannel->IsConnected())

	{

		connected = ETrue;

	}

	LOG2("[CBtChannelBase::IsConnected]\t iChannel: %d, connected: %d", iChannel, connected);

	return connected;

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::Disconnect

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::Disconnect()

{

	TBool conn = IsConnected();

	LOG1("[CBtChannelBase::Disconnect]\t IsConnected(): %d", conn);

	if( conn )

	{

		if(IsActive())

		{

			LOG("[CBtChannelBase::Disconnect]\t iChannel abort");

			iChannel->Abort();

		}

		else

		{

			LOG("[CBtChannelBase::Disconnect]\t iChannel disconnect");

			iState = EStateDisconnecting;

			iChannel->Disconnect(iStatus);

			Activate();

		}

		iStop = ETrue;

	}

	else

	{

		DeleteChannel();

		iState = EStateNone;

	}

	LOG1("[CBtChannelBase::Disconnect]\t out. iState: %d", iState);

	return;

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::FinishPrinting

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::FinishPrinting()

{

	LOG("[CBtChannelBase::FinishPrintingL]\t begin");

	// Already finishing

	if(EStateFinish == iState)

	{

		LOG("[CBtChannelBase::FinishPrintingL]\t already finishing");

		return;

	}

	iState = EStateDisconnecting;

	LOG1("[CBtChannelBase::FinishPrintingL]\t IsActive() %d", IsActive());

	if(IsActive())

	{

		//return: the iState causes disconnection printing when RunL called.

		return;

	}

	IsConnected();

		Disconnect();

	LOG("[CBtChannelBase::FinishPrintingL]\t end");

    return;

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::SendSoapRequestL

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::SendSoapRequestL(const TInt aRequest, const TInt aJobId)

{

	SendSoapRequestL(aRequest, iStatus, aJobId);

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::SendSoapRequestL

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::SendSoapRequestL(const TInt aRequest,

								  TRequestStatus& aStatus,

								  const TInt aJobId)

{

	LOG1("[CBtChannelBase::SendSoapRequestL]\t begin for %d", aRequest);

	User::LeaveIfNull(iChannel);

	User::LeaveIfNull(iObexBufObject); // panics if iObexBody == NULL

	/* Create soap from file */

	if(!iSoapCodec)

	{

		iSoapCodec = CBtSoapCodec::NewL();

	}

    TPtrC8 soap = iSoapCodec->CreateSoapL(aRequest, aJobId);

	LOG2("[CBtChannelBase::SendSoapRequestL]\t Soap created for %d. len: %d",aRequest, soap.Length());

	iObexBufObject->Reset();

	iObexBody->InsertL(0, soap);

	LOG1("[CBtChannelBase::SendSoapRequestL]\t data size %d", iObexBody->Size());

	iObexBufObject->SetTypeL(KBtMimeTypeSoap());

	LOG("[CBtChannelBase::SendSoapRequestL]\t Issuing get.");

	iChannel->Get(*iObexBufObject, aStatus);

	Activate();

	LOG("[CBtChannelBase::SendSoapRequestL]\t end");

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::GetSoapResponseL

//

//--------------------------------------------------------------------------------------------

TInt CBtChannelBase::GetSoapResponseL()

{

	LOG("[CBtChannelBase::GetSoapResponseL]\t");

	if( 0 >= iObexBody->Size() )

		User::Leave(KErrInvalidData);

	LOG("[CBtChannelBase::GetSoapResponseL]\t Data in obex body.");

	LOG1("[CBtChannelBase::GetSoapResponseL]\t iDevice: %d", iDevice);

	TInt action = EBtUnknownAction;

	//give obexbody to parser

	if(!iSoapCodec)

	{

		iSoapCodec = CBtSoapCodec::NewL();

	}

   	//read

	iSoapCodec->ReadSoapL(action, *iObexBody);

	LOG1("[CBtChannelBase::GetSoapResponseL]\t soap read. Action %d", action);

	// Reset object: data is stored in iSoapCodec.

	// NOTE: reset resets also iObexBody

	iObexBufObject->Reset();

	LOG("[CBtChannelBase::GetSoapResponseL]\t done");

	return action;

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::Activate

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::Activate()

{

	// If already active do not activate again

	LOG2("[CBtChannelBase::Activate]\t for %d, IsActive %d",iState, IsActive());

	if( IsActive() )

		return;

	SetActive();

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::CompleteRequest

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::CompleteRequest(TControlState aStateCompleted, TInt aError)

{

	LOG2("[CBtChannelBase::CompleteRequest]\t aStateCompleted %d, aError %d",aStateCompleted, aError);

	iState = aStateCompleted;

	LOG2("[CBtChannelBase::CompleteRequest]\t IsActive() %d, iStatus %d", IsActive(), iStatus.Int());

	if(IsActive() && KRequestPending == iStatus.Int())

	{

		TRequestStatus* statusPtr = &iStatus;

		User::RequestComplete(statusPtr, aError);

	}

	if(EStateNone != aStateCompleted)

	{

		Activate();

	}

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::StartWaiting

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::WaitL()

{

	if( !(iWait->IsStarted()) && KRequestPending == iStatus.Int())

	{

		LOG("[CBtChannelBase::WaitL]\t");

		iWait->Start();

		LOG2("[CBtChannelBase::WaitL]\t Continue, iStatus: %d at iState: %d", iStatus.Int(), iState);

		LOG1("[CBtChannelBase::WaitL]\t iStop: %d",iStop);

		if(KErrNone != iStatus.Int() && KRequestPending != iStatus.Int() && !iStop)

			User::Leave(iStatus.Int());

		LOG("[CBtChannelBase::WaitL]\t out");

	}

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::StopWaiting

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::StopWaiting()

{

	if( (iWait->IsStarted()) )

	{

		LOG("[CBtChannelBase::StopWaiting]\t");

		iWait->AsyncStop();

	}

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::ClearConnection

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::ClearConnection()

{

	LOG1("[CBtChannelBase::ClearConnection]\t iState %d", iState);

	Cancel();

	iObexBufObject->Reset();

	iObexNullObject->Reset();

	iDevice = NULL;

    if(iChannel)

    {

		LOG("[CBtChannelBase::ClearConnection]\t iChannel clear");

		//Sends the abort operation to receiver and completes request with KErrAbort

		Disconnect();	

    }

	LOG("[CBtChannelBase::ClearConnection]\t out");

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::DeleteChannel

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::DeleteChannel()

{

	LOG1("[CBtChannelBase::DeleteChannel]\t iChannel %d delete", iChannel);

    if(iChannel)

    {

		delete iChannel;

		iChannel = NULL;

    }

	iStop = EFalse;

	LOG1("[CBtChannelBase::DeleteChannel]\t iChannel %d out", iChannel);

}

//--------------------------------------------------------------------------------------------

//

// CBtChannelBase::GetUserPasswordL

//

//--------------------------------------------------------------------------------------------

void CBtChannelBase::GetUserPasswordL( const TDesC &aRealm )

{

    LOG("[CBtChannelBase::GetUserPasswordL begin]\t");

    iPasswordQuery = CBtPasswordQuery::NewL( *this );

    iPasswordQuery->StartActiveObjectL();