/*

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

*

*/

//  EXTERNAL INCLUDES

#include <e32std.h>

#include <barsc.h>

#include <btprotocol.rsg>

#include <fbs.h>

#include "cbtprintingdevice.h"

#include "printcapabilitycodes.h"

#include "printmessagecodes.h"

#include "rsutils.h"

#include "crsbtdevice.h"

#include "cbtdevicecontainer.h"

#include "clog.h"

#include "tbtmapper.h"

#include "crsbtdiscoverengine.h"

//  CONSTANTS

namespace

	{

	/// Bluetooth BPP/OPP Version Major.

	const static TInt KBtVersionMajor = 3;

	/// Bluetooth BPP/OPP Version Minor.

	const static TInt KBtVersionMinor = 0;

	/// Bluetooth BPP/OPP Version Build.

	const static TInt KBtVersionBuild = 1;

	}

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

//

// CBtPrintingDevice::NewL

//

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

MProtPrintingDevice* CBtPrintingDevice::NewL()

{

	return new (ELeave) CBtPrintingDevice();

}

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

//

// CBtPrintingDevice::CBtPrintingDevice

//

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

CBtPrintingDevice::CBtPrintingDevice() :

	CActive(CActive::EPriorityStandard),

	iState( ENone ),

	iPrintingJob( NULL ),

	iPrinterController( NULL ),

	iDeviceContainer( NULL ),

	iRequestedProtocols( 0 ),

	iPrintError( KErrNone ),

	iPrintErrorMsgCode( 0 ),

	iPendingCount(KPendingLimit),

	iPrinterTimer( NULL ),

	iProggress( 0 )

{

	iDiscoveryObserver = NULL;

	iPrintEventObserver = NULL;

	CActiveScheduler::Add(this);

}

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

//

// CBtPrintingDevice::ConstructL

//

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

void CBtPrintingDevice::ConstructL(const TDesC& /*aDLLPath*/)

{

	LOG("CBtPrintingDevice ****************************************************");

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

	iPrinterController 	= CBtPrinterController::NewL(*this);

	iDeviceContainer 	= CBtDeviceContainer::NewL();

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

	LOG("CBtPrintingDevice::ConstructL end");

}

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

//

// CBtPrintingDevice::~CBtPrintingDevice

//

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

CBtPrintingDevice::~CBtPrintingDevice()

{

	LOG("CBtPrintingDevice::~CBtPrintingDevice begin");

	Deactivate();

	if(iPrinterTimer)

	{

		if(iPrinterTimer->IsActive())

			iPrinterTimer->Cancel();

		delete iPrinterTimer;

	}

	if(iPrinterController)

	{

		iPrinterController->Stop();

		delete iPrinterController;

	}

	if(iPrintingJob)

		delete iPrintingJob;

	if(iDeviceContainer)

		delete iDeviceContainer;

	REComSession::DestroyedImplementation( iDtor_ID_Key );

	LOG("CBtPrintingDevice::~CBtPrintingDevice end");

}

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

//

// CBtPrintingDevice::RunL

//

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

void CBtPrintingDevice::RunL()

{

	LOG1("[CBtPrintingDevice::RunL]\t iStatus: %d", iStatus.Int());

	if(KErrNone != iStatus.Int())

	{

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

	}

	switch( iState )

	{

		case EFinish:

			FinishPrinting(iStatus.Int());

			break;

		case EGetJobAttributes:

			GetJobAttributesL();

			break;

		case EGetPrinterState:

			GetPrinterStateL();

			break;

		default:

			break;

	}

}

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

//

// CBtPrintingDevice::RunError

//

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

TInt CBtPrintingDevice::RunError(TInt aError)

{

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

	FinishPrinting(aError);

	return KErrNone;

}

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

//

// CBtPrintingDevice::DoCancel

//

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

void CBtPrintingDevice::DoCancel()

{

	LOG1("[CBtPrintingDevice::DoCancel]\t iStatus: %d", iStatus.Int());

	ResetTimer();

}

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

//

// CBtPrintingDevice::Deactivate

//

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

void CBtPrintingDevice::Deactivate()

{

	LOG2("[CBtPrintingDevice::Deactivate]\t iStatus: %d iState %d", iStatus.Int(), iState);

	ResetTimer();

	Cancel();

	iStatus = KErrNone;

}

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

//

// CBtPrintingDevice::Version

//

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

TVersion CBtPrintingDevice::Version()

{

	return TVersion(KBtVersionMajor, KBtVersionMinor, KBtVersionBuild);

}

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

//

// CBtPrintingDevice::SupportedProtocols

//

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

TUint CBtPrintingDevice::SupportedProtocols()

{

	return KImagePrint_PrinterProtocol_BPP |

		   KImagePrint_PrinterProtocol_OPP_Printer |

		   KImagePrint_PrinterProtocol_OPP_PC;

}

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

//

// CBtPrintingDevice::DiscoveryError

//

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

void CBtPrintingDevice::DiscoveryError(TInt aError)

{

	LOG1("[CBtPrintingDevice::DiscoveryError]\t aError: %d", aError);

	if(0 < iDeviceContainer->Count())

	{

		iState = EReady;

	}

	else

	{

		iState = ENone;

	}

  	iPrinterController->CancelDiscovery();

  	Deactivate();

	if( iDiscoveryObserver )

	{

		if(KErrNone == aError)// discovery finished, update not-found cached devices

			UpdateCacheList();

		//We're not interested if the call back leaves

		TRAP_IGNORE(iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, aError));

	}

	LOG("[CBtPrintingDevice::DiscoveryError]\t end");

}

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

//

// CBtPrintingDevice::StartDiscoveryL

//

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

void CBtPrintingDevice::StartDiscoveryL(MProtDiscoveryObserver& aObserver, TUint aProtocol)

{

	LOG1("[CBtPrintingDevice::StartDiscoveryL]\t aProtocol: %d", aProtocol);

	iDiscoveryObserver = &aObserver;

	// already discovering

	if(EDiscovering == iState)

		return;

	if((aProtocol & SupportedProtocols()))

	{

		iRequestedProtocols = aProtocol;

		iDeviceContainer->Reset();

		iPrinterController->Stop();

		// If GetUsedDevicesL fails, no can do. Just continue.

		LOG("[CBtPrintingDevice::StartDiscoveryL]\t Get used devices");

		TInt leave;

		TRAP(leave, GetUsedDevicesL() );

		LOG1("[CBtPrintingDevice::StartDiscoveryL]\t Get used devices leaves with %d", leave);

		LOG("[CBtPrintingDevice::StartDiscoveryL]\t Calling iPrinterController");

	  	iPrinterController->StartDiscoveryL(aProtocol);

		iState = EDiscovering;

	}

	else

	{

		LOG("CBtPrintingDevice::StartDiscoveryL NO protocol match, ending discovery...");

		if( iDiscoveryObserver )

		{

			//We're not interested if the call back leaves

			TRAP_IGNORE(iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, KErrNone));

		}

	}

	LOG("[CBtPrintingDevice::StartDiscoveryL]\t end");

}

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

//

// CBtPrintingDevice::RemoveCachedDeviceL

//

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

TInt CBtPrintingDevice::RemoveCachedDeviceL(TInt aDeviceID)

{

	LOG1("CBtPrintingDevice::RemoveCachedDeviceL aDeviceID: %d", aDeviceID);

	TInt err = KErrNone;

	CRsBtDevice* device = FindDevice(aDeviceID);

	if( device )

	{

		device->SetUsed(EFalse);

		iDeviceContainer->StoreL();

	}

	else

	{

		err = KErrInvalidData;

	}

	LOG1("CBtPrintingDevice::RemoveCachedDeviceL end with: %d", err);

	return err;

}

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

//

// CBtPrintingDevice::UpdateCacheListL

//

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

void CBtPrintingDevice::UpdateCacheList()

{

	LOG("[CBtPrintingDevice::UpdateCacheList]\t");

	for(TInt i = 0; i < iDeviceContainer->Count(); ++i)

	{

		CRsBtDevice* device = iDeviceContainer->At(i);

		if(device && !device->IsJustFound())

			DeviceDisappeared(*device);

	}

}

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

//

// CBtPrintingDevice::CancelDiscovery

//

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

void CBtPrintingDevice::CancelDiscovery(TBool aDoCallBack)

{

  	LOG1("[CBtPrintingDevice::CancelDiscovery]\t aDoCallBack: %d", aDoCallBack);

	if(0 < iDeviceContainer->Count())

	{

		iState = EReady;

	}

	else

	{

		iState = ENone;

	}

  	iPrinterController->CancelDiscovery();

  	Deactivate();

	if( aDoCallBack && iDiscoveryObserver )

	{

		//We're not interested if the call back leaves

		TRAP_IGNORE(iDiscoveryObserver->DiscoveryStatusL(EDiscoveryCancelling, KErrNone));

	}

	LOG("[CBtPrintingDevice::CancelDiscovery]\t end");

}

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

//

// CBtPrintingDevice::CreatePrintJobL

//

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

TInt CBtPrintingDevice::CreatePrintJobL(TInt aDeviceID, RPointerArray<TDesC>& aImages, MProtPrintEventObserver& aObserver)

{

	LOG("[CBtPrintingDevice::CreatePrintJobL]\t begin");

  	LOG2("[CBtPrintingDevice::CreatePrintJobL]\t aDeviceID: %d, aImages.Count(): %d", aDeviceID, aImages.Count());

	iPrintEventObserver = &aObserver;

	CRsBtDevice *printer = FindDevice( aDeviceID );

	if( printer == NULL )

	{

		LOG("CBtPrintingDevice::CreatePrintJobL no device found, returning error");

		return KErrInvalidData;

	}

	if(iPrintingJob && 

	  (CPrintJob::EStateSubmitted == iPrintingJob->JobState() ||

	   CPrintJob::EStateSending == iPrintingJob->JobState() ||

	   CPrintJob::EStatePrinting == iPrintingJob->JobState()) )

	{

		LOG("[CBtPrintingDevice::CreatePrintJobL]\t Printing job already");

		return KErrInvalidSequence;

	}

	iPendingCount = 0;

	GetCapabilities(*printer);

	InitJobL(printer, aImages);

	LOG("[CBtPrintingDevice::CreatePrintJobL]\t job created");

	iPrintingJob->UpdateJobState(CPrintJob::EStateCreated);

	LOG1("[CBtPrintingDevice::CreatePrintJobL]\t end - status: %d", iState);

	return KErrNone;

}

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

//

// CBtPrintingDevice::SubmitPrintJobL

//

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

void CBtPrintingDevice::SubmitPrintJobL()

{

	LOG("[CBtPrintingDevice::SubmitPrintJobL] begin");

	TInt err = KErrInvalidSequence;

	if( iPrintingJob && iPrintingJob->JobState() == CPrintJob::EStateCreated )

	{

		// We try to find the Device specified in our list.

		CRsBtDevice* device = static_cast<CRsBtDevice*>(User::LeaveIfNull(

				FindDevice(iPrintingJob->PrinterId())));

		LOG1("[CBtPrintingDevice::SubmitPrintJobL] iPrintingJob.iPrinterID: %d", iPrintingJob->PrinterId() );

		// save used bluetooth profile

		iUsedBtProfile = device->UsedProtocol();

		if( !(device->UsedProtocol() & SupportedProtocols()) )

		{

			LOG("[CBtPrintingDevice::SubmitPrintJobL]\t can't select a protocol");

			err = KErrInvalidData;

		}

		else

		{

			LOG1("[CBtPrintingDevice::SubmitPrintJobL]\t Submitting to printer \"%S\"", &(device->FriendlyName()));

			iState = EJobProgress;

			StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) );

			iPendingCount = 0;

			iProggress = 0;

			TRAP(err, iPrinterController->CreateJobL(*device, *iPrintingJob) );

			LOG1("[CBtPrintingDevice::SubmitPrintJobL]\t CreateJobL leaves with %d", err);

			if(KErrNone == err)

			{

				device->SetUsed(ETrue);

				iDeviceContainer->StoreL();

				if( iPrintingJob->JobState() != CPrintJob::EStateSending &&

					iPrintingJob->JobState() != CPrintJob::EStatePrinting )

				{

					iPrintingJob->UpdateJobState(CPrintJob::EStateSubmitted);

				}

			}

			else

			{

					CreateJobResponse(KErrNotFound, err);

			}

		}

	}

	else

		LOG("[CBtPrintingDevice::SubmitPrintJobL]\t ***Invalid Sequence***. Job state wrong or job not created");

	if(KErrNone != err)

	{

		LOG1("[CBtPrintingDevice::SubmitPrintJobL]\t return error %d", err);

		if (iPrintEventObserver)

			iPrintEventObserver->PrintJobErrorEvent(err);

		else

			User::Leave(err);

	}

	LOG("[CBtPrintingDevice::SubmitPrintJobL] end");

}

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

//

// CBtPrintingDevice::CancelPrintJob

//

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

TInt CBtPrintingDevice::CancelPrintJob()

{

	LOG("[CBtPrintingDevice::CancelPrintJob]\t begin");

	TInt retVal( KErrInvalidSequence );

	LOG1("[CBtPrintingDevice::CancelPrintJob]\t iPrintingJob: %d", iPrintingJob);

	if(iPrintingJob)

	{

        retVal = KErrNone;

		LOG1("[CBtPrintingDevice::CancelPrintJob]\t iPrintingJob->JobState(): %d", iPrintingJob->JobState());

		if(iPrintingJob->JobState() == CPrintJob::EStateCancel)

		{

			LOG("[CBtPrintingDevice::CancelPrintJob]\t Already cancelling. Return.");

			retVal = KErrCancel;

		}

		else if( iPrintingJob->JobState() == CPrintJob::EStateSubmitted || 

                 iPrintingJob->JobState() == CPrintJob::EStateSending || 

                 iPrintingJob->JobState() == CPrintJob::EStatePrinting )

		{

			// cancel job

			TInt leave; // for remove compiling errors

			TRAP(leave, CancelJobL());

			if( leave == KErrDisconnected )

			    {

			  	LOG("[CBtPrintingDevice::CancelPrintJob]\t calling OPPJobRollBack...");

			  	OPPJobRollBack();

				}

			LOG1("[CBtPrintingDevice::CancelPrintJob]\t CancelJobL() leaves with %d.", leave);

		}

		else

        {

			LOG1("[CBtPrintingDevice::CancelPrintJob]\t No print job, just cancel all (forced stop) if connections exist: %d", iPrinterController->IsConnected());

			FinishPrinting( KErrInvalidSequence );

		}

	}

	if( iPrintEventObserver )

	    {

		iPrintEventObserver->PrintJobProgressEvent( EDone, iPrinterController->GetPercentSent(), ECancelling );

        }