/*

* 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 CBtStatusChannel class.

*

*/

#include <obex.h>

#include "crsbtdevice.h"

#include "cbtstatuschannel.h"

#include "cbtsoapcodec.h"

#include "clog.h"

#include "tbtmapper.h"

#include "cbtdiscover.h"

#include "printmessagecodes.h"

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

//

// CBtStatusChannel::NewL

//

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

CBtStatusChannel* CBtStatusChannel::NewL(MBtPCObserver& aObs)

{

		CBtStatusChannel *self = NewLC(aObs);

		CleanupStack::Pop();	// self

		return self;

}

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

//

// CBtStatusChannel::NewLC

//

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

CBtStatusChannel* CBtStatusChannel::NewLC(MBtPCObserver& aObs)

{

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

		CleanupStack::PushL(self);

		self->ConstructL();

		return self;

}

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

//

// CBtStatusChannel::CBtStatusChannel

//

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

CBtStatusChannel::CBtStatusChannel(MBtPCObserver& aObs):

	CBtChannelBase( aObs )

{

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

}

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

//

// CBtStatusChannel::~CBtStatusChannel

//

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

CBtStatusChannel::~CBtStatusChannel()

{

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

	Cancel();

	ClearConnection();

	// iChannel have to delete here or otherwise Review-x report critical error.

	if(iChannel)

	{

		delete iChannel;

		iChannel = NULL;

	}

}

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

//

// CBtStatusChannel::ConstructL

//

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

void CBtStatusChannel::ConstructL()

{

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

	CBtChannelBase::ConstructL();

	LOG("[CBtStatusChannel::ConstructL]\t end");

}

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

//

// CBtStatusChannel::RunL

//

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

void CBtStatusChannel::RunL()

{

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

	 //Finish if required

	if( EStateFinish == iState )

	{

		Disconnect();

		return;

	}

	DoLeaveL( iStatus.Int() );

	switch( iState )

	{

		case EStateConnecting:

			iObexNullObject->Reset();

			StopWaiting();

			break;

        case EStateDisconnecting:

			Disconnect();

			StopWaiting();

            break;

		case EStateGettingPrinterState:

			GetSoapResponseL();

			GetPrinterStateResponseL();

			iState = EStateNone;

			break;

		case EStateCancellingJob:

			GetSoapResponseL();

			CancelJobResponseL();

			iDevice = NULL;

			iState = EStateNone;

			break;

		case EStateGettingJobAttributes:

			GetSoapResponseL();

			GetJobAttributesResponseL();

			break;

		case EStateNone:

			User::Leave( KErrCancel );

			break;

		case EStateGetEvent:

			iState = EStateGettingEvent;

			SendSoapRequestL(EBtGetEvent, iJobId);

			WaitL();

			break;

		case EStateGettingEvent:

			GetSoapResponseL();

			GetEventResponseL();

			StopWaiting();

			break;

		default:

			break;

	}

}

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

//

// CBtStatusChannel::RunError

//

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

TInt CBtStatusChannel::RunError(TInt aError)

{

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

	LOG2("[CBtStatusChannel::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 EStateCancellingJob:

			iState = EStateFinish;

			iObs.CancelJobResponse(aError);

			break;

		case EStateGettingJobAttributes:

			iState = EStateFinish;

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

			break;

		case EStateGetEvent:

		case EStateGettingEvent:

			iObs.GetEventResponse(iJobId, EBtStateUnknown, EBtStateIdle, KErrNone, aError);

			break;

		default:

			iState = EStateFinish;

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

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

			break;

	}

	iResponseError = aError;

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

}

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

//

// CBtStatusChannel::DoCancel

//

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

void CBtStatusChannel::DoCancel()

{

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

	StopWaiting();

	iState = EStateNone;

	CBtChannelBase::DoCancel();

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

}

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

// InCalls

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

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

//

// CBtStatusChannel::GetPrinterAttributesL

//

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

TInt CBtStatusChannel::GetPrinterStateL()

{

	LOG("[CBtStatusChannel::GetPrinterStateL]\t begin");

	if(iStop)

		return KErrNone;

	if(!IsConnected())

		User::Leave(KErrDisconnected);

	Cancel();

	iState = EStateGettingPrinterState;

	SendSoapRequestL(EBtGetPrinterState);

	return KErrNone;

}

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

//

// CBtStatusChannel::GetJobAttributesL

//

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

TInt CBtStatusChannel::GetJobAttributesL(TInt aJobId)

{

	LOG1("[CBtStatusChannel::GetJobAttributesL]\t begin with id %d", aJobId);

	if(iStop)

		return KErrNone;

	if(!IsConnected())

		User::Leave(KErrDisconnected);

	if( KErrNotFound == aJobId)

		User::Leave(KErrInvalidData);

	LOG1("[CBtStatusChannel::GetJobAttributesL]\t wait connection? %d", iStatus.Int());

	WaitL();

	iJobId = aJobId;

	LOG1("[CBtStatusChannel::GetJobAttributesL]\t iJobId %d", iJobId);

	iState = EStateGettingJobAttributes;

	SendSoapRequestL(EBtGetJobAttributes, iJobId);

	return KErrNone;

}

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

//

// CBtStatusChannel::GetEventL

//

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

void CBtStatusChannel::GetEventL(TInt aJobId)

{

	LOG("[CBtStatusChannel::GetEvent]\t begin");

	if(iStop)

		return;

	if(!IsConnected())

		User::Leave(KErrDisconnected);

	if( 0 > aJobId)

		User::Leave(KErrInvalidData);

	if(EStateGetEvent == iState || EStateGettingEvent == iState)

		return;

	Cancel();

	iJobId = aJobId;

	iState = EStateGetEvent;

	Activate();

}

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

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

// Responses

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

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

//

// CBtStatusChannel::GetPrinterStateResponseL

//

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

void CBtStatusChannel::GetPrinterStateResponseL()

{

	LOG("[CBtStatusChannel::GetPrinterStateResponseL]\t");

	User::LeaveIfNull(iSoapCodec);

	iState = EStateNone;

	TInt state = EBtStateUnknown;

	TInt reasons = EPbCheckPrinter;

	TInt opStatus = KErrGeneral;

	iSoapCodec->GetPrinterStateResponseL(state, reasons, opStatus);

	TInt id = KErrNotFound;

	if(iDevice)

		id = iDevice->DeviceId();

	iObs.GetPrinterStateResponse(state, reasons, opStatus, id);

}

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

//

// CBtStatusChannel::GetJobAttributesResponseL

//

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

void CBtStatusChannel::GetJobAttributesResponseL()

{

	LOG("[CBtStatusChannel::GetJobAttributesResponseL]\t");

	User::LeaveIfNull(iSoapCodec);

	iState = EStateNone;

	TInt  jobState = EBtStateUnknown; 

	TBtAttrString8 jobName(KNullDesC8());

	TBtAttrString8 originator(KNullDesC8());

	TInt sheetsCompleted = KErrNotFound; 

	TInt pendingJobs = KErrNotFound;

	TInt opStatus = KErrNotSupported;

	iSoapCodec->GetJobAttributesResponseL(iJobId, jobState, jobName, originator, 

											sheetsCompleted, pendingJobs, opStatus);

	iObs.GetJobAttributesResponse(jobState, jobName, originator, 

									sheetsCompleted, pendingJobs, opStatus);

}

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

//

// CBtStatusChannel::CancelJobResponseL

//

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

void CBtStatusChannel::CancelJobResponseL()

{

	LOG("[CBtStatusChannel::CancelJobResponseL]\t");

	User::LeaveIfNull(iSoapCodec);

	iState = EStateNone;

	TInt err = KErrNotFound;

	iSoapCodec->CancelJobResponseL(iJobId, err);

	LOG1("[CBtStatusChannel::CancelJobResponseL]\t err %d", err);

	iObs.CancelJobResponse(err);

}

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

//

// CBtStatusChannel::GetEventResponseL

//

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

void CBtStatusChannel::GetEventResponseL()

{

	LOG("[CBtStatusChannel::GetEventResponseL]\t");

	User::LeaveIfNull(iSoapCodec);

	iState = EStateNone;

	TInt jobState, printerState, stateReasons, operationStatus;

	iSoapCodec->GetEventResponseL(iJobId, jobState, printerState, stateReasons, operationStatus);

	iObs.GetEventResponse(iJobId, jobState, printerState, stateReasons, operationStatus);

}

///////////////////////////////

// Private

///////////////////////////////

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

//

// CBtStatusChannel::ConnectL

//

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

void CBtStatusChannel::ConnectL()

{

	LOG2("[CBtStatusChannel::ConnectL]\t isConnected: %d, iDevice %d", IsConnected(), iDevice);

	User::LeaveIfNull(iDevice);

	LOG1("[CBtStatusChannel::ConnectedL]\t aDevice.UsedProtocols(): %d", iDevice->UsedProtocol());

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

	   	User::Leave(KErrNotSupported);

    if(IsConnected())

    {

		LOG1("[CBtStatusChannel::ConnectL]\t isConnected: %d", IsConnected());

    	return;

    }

	if(iChannel)

	{

		delete iChannel;

		iChannel = NULL;

	}

    TObexBluetoothProtocolInfo protocolInfo;

    protocolInfo.iTransport.Copy( KRFCOMMDesC );

    protocolInfo.iAddr.SetBTAddr(iDevice->BDAddr() );//Address of server bt device

   	protocolInfo.iAddr.SetPort(iDevice->STSPort() );//Service channel of server rfcomm

	TUUID uuid(KBTSDPPrintingStatus);

	iObexNullObject->Reset();

	iObexNullObject->SetTargetL(uuid.Des());

    // create channel

    iChannel = CObexClient::NewL( protocolInfo );

	iChannel->SetCallBack(*this);

	iChannel->Connect(*iObexNullObject, iStatus);

	iState = EStateConnecting;

	Activate();

}

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

//

// CBtStatusChannel::DoLeaveL

//

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

void CBtStatusChannel::DoLeaveL(TInt aError)

{

	LOG2("[CBtStatusChannel::DoLeaveL]\t aError %d at state %d", aError, iState); 

	if(KErrNone == aError)

		return;

	if(EStateDisconnecting == iState)

		return;

	if(KErrCancel == aError)

		return;

	if(KErrCompletion == aError)

		return;

	LOG("[CBtStatusChannel::DoLeaveL]\t Leave"); 

	User::Leave(aError);

}

//  End of File