/*

* 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:  

*

*/

/**

 *  @file CBtJobChannel.h

 *	@brief	Defines the CBtJobChannel class.

 */

#include <obex.h>

#include "crsbtdevice.h"

#include "cbtjobchannel.h"

#include "cbtsoapcodec.h"

#include "clog.h"

#include "tbtmapper.h"

#include "cbtdiscover.h"

#include "printmessagecodes.h"

#include "cbtstatuschannel.h"

#include "rsutils.h"

#include "cbttimer.h"

#include "btprotocolconsts.h"

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

//

// CBtJobChannel::NewL

//

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

CBtJobChannel* CBtJobChannel::NewL(MBtPCObserver& aObs)

{

		CBtJobChannel *self = NewLC(aObs);

		CleanupStack::Pop(); // self

		return self;

}

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

//

// CBtJobChannel::NewLC

//

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

CBtJobChannel* CBtJobChannel::NewLC(MBtPCObserver& aObs)

{

		CBtJobChannel *self = new (ELeave) CBtJobChannel(aObs);

		CleanupStack::PushL(self);

		self->ConstructL();

		return self;

}

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

//

// CBtJobChannel::CBtJobChannel

//

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

CBtJobChannel::CBtJobChannel(MBtPCObserver& aObs):

	CBtChannelBase(aObs),

	iJobFile(KNullDesC8()),

	iJobFileNum(0),

	iImageCount(0),

	iFileObjectSize(0),

	iObexFileObject(NULL),

	iPercents(0),

	iTimer(NULL),

	iStatusChannel(NULL)

{

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

}

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

//

// CBtJobChannel::~CBtJobChannel

//

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

CBtJobChannel::~CBtJobChannel()

{

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

	Stop();

	// ignore leave: if cleaning fails, no can do.

	TRAP_IGNORE(CleanXhtmlDirL())

	if(iObexFileObject)

		delete iObexFileObject;

	if(iTimer)

		delete iTimer;

	if(iStatusChannel)

	{

		delete iStatusChannel;

		iStatusChannel = NULL;

	}

	// deleting iChannel here because review-x report error.

	if(iChannel)

	{

		delete iChannel;

		iChannel = NULL;

	}

	iImageList.Reset();

	iImageList.Close();

	if (iUpdateProgress)

		{

		delete iUpdateProgress;

		iUpdateProgress = NULL;

		}

	LOG("[CBtJobChannel::~CBtJobChannel]\t out");

}

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

//

// CBtJobChannel::ConstructL

//

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

void CBtJobChannel::ConstructL()

{

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

	CBtChannelBase::ConstructL();

	iObexFileObject = CObexFileObject::NewL();

	iStatusChannel = CBtStatusChannel::NewL(iObs);

	iState = EStateNone;

	iPercents = 0;

	iImageCount = 0;

	// Create periodic timer to update progress of printing. 

	iUpdateProgress = CPeriodic::NewL( CActive::EPriorityStandard );

}

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

//

// CBtJobChannel::RunL

//

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

void CBtJobChannel::RunL()

{

	LOG2("[CBtJobChannel::RunL]\t BEGIN iStatus %d at state %d", iStatus.Int(), iState);

	 //Finish if required

	if( EStateFinish == iState )

	{

		ClearConnection();

		return;

	}

	// leave if "not allowed" error

	DoLeaveL( iStatus.Int() );

	switch( iState )

	{ 

		case EStateConnecting:

			RemoveObexCmdTimeOut();

			iObexNullObject->Reset();

			LOG("[CBtJobChannel::RunL]\t EStateConnecting");

			StopWaiting();

			break;

        case EStateDisconnecting:

			StopWaiting();

			// Go to disconnection again in case it is not finished yet...

			Disconnect();

			break;

		case EStateGettingCapabilities:

			GetSoapResponseL();

			GetPrinterCapabilitiesResponseL();

			StopWaiting();

			iState = EStateNone;

			break;

		case EStateGettingPrinterState:

			GetSoapResponseL();

			GetPrinterStateResponseL();

			iState = EStateNone;

			break;

		case EStateCreatingJob:

		{

			GetSoapResponseL();

			TInt res = CreateJobResponseL();

			StopWaiting();

			// No reason to send doc in error case

			if(KErrNone == res)

			{

				LOG("[CBtJobChannel::RunL]\t CreateJobResponseL() returns %d");

				SendXhtmlDocumentL();

			}

		}

			break;

		case EStateCancellingJob:

			GetSoapResponseL();

			CancelJobResponseL();

			iDevice = NULL;

			iState = EStateNone;

			break;

		case EStateGettingJobAttributes:

			GetSoapResponseL();

			GetJobAttributesResponseL();

			iState = EStateNone;

			break;

		case EStateSendingXhtml:

			iState = EStateNone;

			iObexBufObject->Reset();

			iObs.GetEventResponse(iJobId, EBtStateSending, EBtStatePrinting, ENoMessage, iStatus.Int());

			break;

		case EStateSendingOPP:						

			SendOPPL();

			break;

		default:

			break;		

	}

	LOG("[CBtJobChannel::RunL]\t out");

}

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

//

// CBtJobChannel::RunError

//

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

TInt CBtJobChannel::RunError(TInt aError)

	{

	LOG1("[CBtJobChannel::RunError]\t state %d", iState);

	LOG2("[CBtJobChannel::RunError]\t error %d, iStatus %d", aError, iStatus.Int() );

	TInt id = KErrNotFound;

	StopWaiting();

	switch ( iState )

		{

		case EStateGettingPrinterState:

			if(iDevice)

				id = iDevice->DeviceId();

			iState = EStateFinish;

			iObs.GetPrinterStateResponse(EBtStateIdle, ENoMessage, aError, id);

			break;

		case EStateCreatingJob:

			iState = EStateFinish;

			iObs.CreateJobResponse(KErrNotFound, aError);

			break;

		case EStateCancellingJob:

			iState = EStateFinish;

			iObs.CancelJobResponse(aError);

			break;

		case EStateGettingJobAttributes:

			iState = EStateFinish;

			iObs.GetJobAttributesResponse(iJobId, KNullDesC8(), KNullDesC8(), KErrNotFound, KErrNotFound, aError);

			break;

		case EStateSendingXhtml:

		case EStateSendingOPP:

		default:

			iState = EStateFinish;

			iObs.GetEventResponse(KErrNotFound, KErrNotFound, KErrNotFound, KErrNotFound, aError);

			LOG("[CBtJobChannel::RunError]\t GetEventResponse sent" );

			break;

		}

	iResponseError = aError;

	return KErrNone; // othervise error returns to CActive: that's what we don't want.

	}

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

//

// CBtJobChannel::DoCancel

//

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

void CBtJobChannel::DoCancel()

{

	LOG2("[CBtJobChannel::DoCancel]\t at state %d, iStatus 0x%X", iState, iStatus.Int());

	StopWaiting();

	iState = EStateNone;

	CBtChannelBase::DoCancel();

	iStatusChannel->Cancel();

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

}

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

// InCalls

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

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

//

// CBtJobChannel::HandleTimeoutL

//

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

void CBtJobChannel::HandleTimeoutL()

{

	LOG1("[CBtJobChannel::HandleTimeoutL]\t at state %d", iState);

	if(EStateSendingOPP != iState)

		return;

	TInt state(EBtStateSending);

	if( 100 == iPercents )

	{

		state = EBtStateCompleted;

	}

	else if(iTimer)

		iTimer->Start(KSentPercentsDelay);

	iObs.GetEventResponse(iJobId, state, EBtStatePrinting, KErrNone, KErrNone);

}

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

//

// CBtJobChannel::GetPercentSent

//

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

TInt CBtJobChannel::GetPercentSent()

{

	LOG1("[CBtJobChannel::GetPercentSent]\t at state %d", iState);

	iPercents = 100;

	if(EStateSendingOPP == iState)

	{	

		// Store current bytes sent. 

		TReal32 bytesSent = iObexFileObject->BytesSent();

		TInt temp = iProgressOfFullImages - iFileObjectSize;

		iPercents = ( 100 * ( ( temp + bytesSent ) / iJobSize) );

		LOG2("[CBtJobChannel::GetPercentSent]\t iJobId %d, iImageCount: %d", iJobId, iImageCount);

		LOG2("[CBtJobChannel::GetPercentSent]\t BytesSent %d, iFileObjectSize %d", iObexFileObject->BytesSent(), iFileObjectSize);

	}

	LOG1("[CBtJobChannel::GetPercentSent]\t at state %d", iPercents);

	return iPercents;	

}

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

//

// CBtJobChannel::CreateJobL

//

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

void CBtJobChannel::CreateJobL(CPrintJob& aJob)

	{

	LOG("[CBtJobChannel::CreateJob]\t begin");

	if(!IsConnected())

		User::Leave( KErrDisconnected );

	Cancel();

	iProgressOfFullImages = 0;

	++iJobFileNum;

	iJobFile.Format(KXHTMLFileName8(), iJobFileNum);

	aJob.GetPrintFileL(iJobFile);

	iImageList.Reset();

	aJob.Images(iImageList);

	iJobSize = CalculateJobSizeL();

	iImageCount = iImageList.Count();

	LOG1("[CBtJobChannel::CreateJob]\t iImageList.Count(): %d", iImageList.Count());

	iJobId = KErrNotFound;

	iResponseError = KErrNone;

	LOG1("[CBtJobChannel::CreateJob]\t aDevice.UsedProtocol() %d", iDevice->UsedProtocol());

	if(KImagePrint_PrinterProtocol_BPP == iDevice->UsedProtocol())

		{

		iState = EStateCreatingJob;

		SendSoapRequestL(EBtCreateJob, iJobFileNum);

		// do asynchronously to indicate to start the object server

		WaitL();

	}

	else

	{

		iState = EStateSendingOPP;

		iJobId = 1;

		SendOPPL();

		Activate();

	}

	LOG1("[CBtJobChannel::CreateJob]\t Request sent. iResponseError: %d", iResponseError);

	if( KErrNone != iResponseError )

		{

		User::Leave( iResponseError );

		}

	LOG("[CBtJobChannel::CreateJob]\t out");

	}

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

//

// CBtJobChannel::GetCapabilitiesL

//

// Fully independent and synchronous method. Does not require any existing 

// connections and all connections will be deleted after execution.

//

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

void CBtJobChannel::GetCapabilitiesL(CRsBtDevice& aDevice)

{

	LOG("[CBtJobChannel::GetCapabilitiesL]\t");

	Cancel();

	if( KImagePrint_PrinterProtocol_BPP != aDevice.UsedProtocol() )

		User::Leave(KErrNotSupported);

	if( !RsUtils::IsBluetoothOn() )

		User::Leave(KErrCancel);

	CRsBtDevice* tmpDevice = iDevice;

	iDevice = &aDevice;

	TBool connected = IsConnected();

	iResponseError = KErrNone;

	ConnectL();

	WaitL();

	LOG1("[CBtJobChannel::GetCapabilitiesL]\t ConnectL done: %d", IsConnected());

	iState = EStateGettingCapabilities;

	SendSoapRequestL(EBtGetPrinterAttributes);

	LOG1("[CBtJobChannel::GetCapabilitiesL]\t SendSoapRequestL done: %d", IsConnected());

	WaitL();

	if(!connected)

	{

		ClearConnection();

	}

	iDevice = tmpDevice;

	tmpDevice = NULL;

	LOG("[CBtJobChannel::GetCapabilitiesL]\t OUT");

	User::LeaveIfError(iResponseError);

}

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

//

// CBtJobChannel::GetPrinterStateL

//

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

void CBtJobChannel::GetPrinterStateL()

{

	LOG1("[CBtJobChannel::GetPrinterStateL]\t begin for protocol %d", iDevice->UsedProtocol());

	if(KImagePrint_PrinterProtocol_BPP != iDevice->UsedProtocol())

	{

		iObs.GetPrinterStateResponse(EBtStatePrinting, ENoMessage, KErrNone, iDevice->DeviceId());

		return;

	}

	if(!IsConnected())

		User::Leave(KErrDisconnected);

	iStatusChannel->StartL(*iDevice);

	iStatusChannel->GetPrinterStateL();

}

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

//

// CBtJobChannel::GetJobAttributesL

//

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

void CBtJobChannel::GetJobAttributesL(TInt aJobId)

{

	LOG("[CBtJobChannel::GetJobAttributesL]\t begin");

	if(!iDevice)

	{

	    User::Leave(KErrDisconnected);   

	}

	LOG1("[CBtJobChannel::GetJobAttributesL]\t begin for protocol %d", iDevice->UsedProtocol());

	if(KImagePrint_PrinterProtocol_BPP != iDevice->UsedProtocol())

	{

		TInt state(EBtStateSending), completed(0);

		if(100 == iPercents)

		{

			state = EBtStateCompleted;

			completed = iImageCount;

		}

		iObs.GetJobAttributesResponse(state, KNullDesC8(), KNullDesC8(), completed, 0, KErrNone);

		return;

	}

	if(!IsConnected())

		User::Leave(KErrDisconnected);

	LOG("[CBtJobChannel::GetJobAttributesL]\t start status channel if required");

	if(!iStatusChannel->IsConnected())

		iStatusChannel->StartL(*iDevice);

	LOG1("[CBtJobChannel::GetJobAttributesL]\t iStatusChannel->GetJobAttributesL(%d)", iJobId);

	iStatusChannel->GetJobAttributesL(aJobId);

}

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

//

// CBtJobChannel::GetEventL

//

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

void CBtJobChannel::GetEventL(TInt aJobId)

{

	LOG("[CBtJobChannel::GetJobAttributesL]\t begin");

	if(KImagePrint_PrinterProtocol_BPP != iDevice->UsedProtocol())

	{

		TInt state(EBtStateSending);