/*

* 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:  Contains the CImagePrintBody class definition.

*

*/

#include <bluetooth/hci/hcierrors.h>

#include "cimageprintbody.h"

#include "crsimageparser.h"

#include "clog.h"

CImagePrintBody* CImagePrintBody::NewL()

    {

	CImagePrintBody* self = new (ELeave) CImagePrintBody();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

    }

CImagePrintBody::~CImagePrintBody()

	{

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

	delete iClassLoader;

	iImageFileNames.ResetAndDestroy();

	delete iIdleDiscovery;

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

	}

TInt CImagePrintBody::StartDiscovery(MPrinterDiscoveryObserver& aObserver, TUint aProtocols)

	{

	LOG1("CImagePrintBody::StartDiscovery aProtocols: %d", aProtocols);

	iPrinterDiscoveryObserver = &aObserver;

	if( iCurrentProtocol )

		{

		iCurrentProtocol->CancelDiscovery( EFalse );

		}

	iCurrentProtocol = NULL;

	iClassLoader->Reset();

	iProtocolsRequested = aProtocols;

	iDiscoveryCancelled = EFalse;

	TryNextDiscovery();		

	LOG("CImagePrintBody::StartDiscovery end");

	return KErrNone;

	}

void CImagePrintBody::CancelDiscovery()

	{

	LOG("CImagePrintBody::CancelDiscovery begin");

	iDiscoveryCancelled = ETrue;

	if( iCurrentProtocol )

		{

		iCurrentProtocol->CancelDiscovery();

		}

	LOG("CImagePrintBody::CancelDiscovery end");		

	}

TInt CImagePrintBody::CreatePrintJobL(TInt aPrinterID, RPointerArray<TDesC>& aImages, MPrintEventObserver& aObserver)

	{

	LOG("CImagePrintBody::CreatePrintJobL begin");		

	iPrinterPrintEventObserver = &aObserver;

	iCurrentPrintJobProtocol = NULL;

	if( iCurrentProtocol )

		{		

		iCurrentProtocol->CancelDiscovery( EFalse );

		}

	TInt DeviceID;

	TInt err = FindInternalDeviceReference( aPrinterID, DeviceID, iCurrentPrintJobProtocol );

	if( !err )

		{

		TInt count = aImages.Count();				

		if( count )

			{

			iImageFileNames.ResetAndDestroy();

			for( TInt i = 0; i < count; ++i )

				{

				HBufC* fileName = aImages[i]->AllocLC();

				iImageFileNames.AppendL( fileName );

				CleanupStack::Pop(); // fileName

				}

			ActiveScheduler().SetCurrentProtocol( iCurrentPrintJobProtocol->SupportedProtocols() );

			err = iCurrentPrintJobProtocol->CreatePrintJobL( DeviceID, aImages, *this );	

			}

		else

			{

			err = KErrInvalidData;

			}

		}

	LOG1("CImagePrintBody::CreatePrintJobL return: %d", err);	

	return err;

	}

void CImagePrintBody::SubmitPrintJobL()

	{	

	LOG1("CImagePrintBody::SubmitPrintJobL iCurrentPrintJobProtocol: %d", iCurrentPrintJobProtocol);

	TInt err( KErrNone );

	if( !iCurrentPrintJobProtocol )

		{

		err = KErrInvalidSequence;		

		}		

	if( !err )		

		{

		TInt invalidImages;

		err = ValidateImagesL( iImageFileNames, invalidImages );

		LOG1("CImagePrintBody::SubmitPrintJobL ValidateImagesL returns: %d", err);	

		}

	User::LeaveIfError( err );		

	iCurrentPrintJobProtocol->SubmitPrintJobL();

	LOG("CImagePrintBody::SubmitPrintJobL end");

	}

TInt CImagePrintBody::CancelPrintJob()

	{

	LOG("CImagePrintBody::CancelPrintJob begin");

	TInt err( KErrNone );		

	if( !iCurrentPrintJobProtocol )

		{

		err = KErrInvalidSequence;

		}

	if( !err )

		{

		err = iCurrentPrintJobProtocol->CancelPrintJob();	

		}		

	LOG1("CImagePrintBody::CancelPrintJob return: %d", err);		

	return err;

	}

TInt CImagePrintBody::ContinuePrintJobL()

	{

	LOG("CImagePrintBody::ContinuePrintJobL begin");

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->ContinuePrintJobL();

		}	

	LOG1("CImagePrintBody::ContinuePrintJobL return: %d", err);

	return err;

	}

TInt CImagePrintBody::GetNumPrintPages()

	{

	LOG("CImagePrintBody::GetNumPrintPages begin");

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->GetNumPrintPages();

		}

	LOG1("CImagePrintBody::GetNumPrintPages return: %d", err);

	return err;

	}

TInt CImagePrintBody::GetJobStatus()

	{

	LOG("CImagePrintBody::GetJobStatus begin");

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->GetPrintJobStatus();

		}

	LOG1("CImagePrintBody::GetJobStatus return: %d", err);

	return err;

	}

TInt CImagePrintBody::GetPrinterStatus(TInt aPrinterID)

	{

	LOG1("CImagePrintBody::GetPrinterStatus aPrinterID: %d", aPrinterID);

	TInt DeviceID;

	MProtPrintingDevice* theProtToQuery = NULL;

	TInt err = FindInternalDeviceReference( aPrinterID, DeviceID, theProtToQuery );

	if( !err )

		{

		err = theProtToQuery->GetPrinterStatus( DeviceID );

		}

	LOG1("CImagePrintBody::GetPrinterStatus return: %d", err);

	return err;

	}

TInt CImagePrintBody::GetPrinterCapabilityIDsL(TInt aPrinterID, RArray<TInt>& aCapabilityIDs)

	{

	LOG1("CImagePrintBody::GetPrinterCapabilityIDsL aPrinterID: %d", aPrinterID);		

	TInt DeviceID;

	MProtPrintingDevice* theProtToQuery = NULL;

	TInt err = FindInternalDeviceReference( aPrinterID, DeviceID, theProtToQuery );

	if( !err )

		{

		err = theProtToQuery->GetDeviceCapabilityIDsL( DeviceID, aCapabilityIDs );

		}

	else if( err == KErrNotFound )

		{

		err = KErrInvalidData;

		}

	LOG1("CImagePrintBody::GetPrinterCapabilityIDsL return: %d", err);

	return err;

	}

TInt CImagePrintBody::GetPrinterCapabilityL(TInt aPrinterID, TInt aCapabilityID, TPrintCapability& aCapability)

	{

	LOG1("CImagePrintBody::GetPrinterCapabilityL aPrinterID: %d", aPrinterID);

	LOG1("CImagePrintBody::GetPrinterCapabilityL aCapabilityID: %d", aCapabilityID);

	TInt DeviceID;

	MProtPrintingDevice* theProtToQuery = NULL;

	TInt err = FindInternalDeviceReference( aPrinterID, DeviceID, theProtToQuery );

	if( !err )

		{

		err = theProtToQuery->GetDeviceCapabilityL( DeviceID, aCapabilityID, aCapability );

		}

	else if( err == KErrNotFound )

		{

		err = KErrInvalidData;

		}

	LOG1("CImagePrintBody::GetPrinterCapabilityL return: %d", err);	

	return err;

	}

TInt CImagePrintBody::GetJobSetting(TInt aCapabilityID, TInt& aValue)

	{

	LOG1("CImagePrintBody::GetJobSetting aCapabilityID: %d", aCapabilityID);

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->GetJobSetting( aCapabilityID, aValue );

		}

	LOG1("CImagePrintBody::GetJobSetting return: %d", err);

	return err;

	}

TInt CImagePrintBody::SetJobSettingL(TInt aCapabilityID, TInt aValue, TInt& aAffectedCapability)

	{

	LOG1("CImagePrintBody::SetJobSettingL aCapabilityID: %d", aCapabilityID);

	LOG1("CImagePrintBody::SetJobSettingL aValue: %d", aValue);

	TInt err( KErrInvalidSequence );		

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->SetJobSettingL( aCapabilityID, aValue, aAffectedCapability );

		}

	LOG1("CImagePrintBody::SetJobSettingL return: %d", err);

	return err;		

	}

TInt CImagePrintBody::GetNumPreviewPages()

	{

	LOG("CImagePrintBody::GetNumPreviewPages");

	TInt err( KErrInvalidSequence );		

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->GetNumPreviewPages();

		}

	LOG1("CImagePrintBody::GetNumPreviewPages return: %d", err);

	return err;	

	}

TInt CImagePrintBody::GetJobTemplateIconL( TInt aTemplateID, TInt& aFbsBitmapHandle )

	{

	LOG1("CImagePrintBody::GetJobTemplateIconL aTemplateID: %d", aTemplateID);

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->GetJobTemplateIconL( aTemplateID, aFbsBitmapHandle );

		}

	LOG1("CImagePrintBody::GetJobTemplateIconL return: %d", err);

	return err;

	}

TInt CImagePrintBody::CreatePreviewImage(TInt aPageNumber)

	{

	LOG1("CImagePrintBody::CreatePreviewImage aPageNumber: %d", aPageNumber);

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->CreatePreviewImage(aPageNumber);

		}

	LOG1("CImagePrintBody::CreatePreviewImage return: %d", err);

	return err;

	}

TInt CImagePrintBody::RemoveCachedPrinterL(TInt aPrinterID)

	{

	LOG1("CImagePrintBody::RemoveCachedPrinterL aPrinterID: %d", aPrinterID);

	TInt DeviceID;

	MProtPrintingDevice* theProtToQuery = NULL;

	TInt err = FindInternalDeviceReference( aPrinterID, DeviceID, theProtToQuery );

	if( !err )

		{

		err = theProtToQuery->RemoveCachedDeviceL( DeviceID );

		}

	LOG1("CImagePrintBody::RemoveCachedPrinterL return: %d", err);

	return err;

	}

TUint CImagePrintBody::SupportedProtocols()

	{

	LOG("CImagePrintBody::SupportedProtocols begin");

	TUint prots = iClassLoader->SupportedProtocols();

	LOG1("CImagePrintBody::SupportedProtocols return: %d", prots);

	return prots;

	}

void CImagePrintBody::RegisterIdleObserver(MIdleObserver *aObserver)

	{

	LOG("CImagePrintBody::RegisterIdleObserver begin");

	iPrinterIdleObserver = aObserver;

	LOG("CImagePrintBody::RegisterIdleObserver end");

	}

// From MProtDiscoveryObserver.

void CImagePrintBody::FoundDeviceL(TPrinter& aDeviceInfo)

	{

	LOG("CImagePrintBody::FoundDeviceL begin");		

	if( iPrinterDiscoveryObserver )

		{	

		//Check that device id is valid, there can't be any bits in the protocol field (higher bits)

		if( !( PROTOCOL_ID_FIELD_MASK & aDeviceInfo.iPrinterID ) )			

			{

			// Get the protocol index number

			TInt protocolIndex = iClassLoader->GetProtocolIndex();		

			// Left shift this number so that it occupies the higher X bits (the PROTOCOL_ID_BIT_COUNT highest bits)

			protocolIndex <<= sizeof(TInt)*8 - PROTOCOL_ID_BIT_COUNT;

			// Add the protocol index number to the device id

			aDeviceInfo.iPrinterID |= protocolIndex;

			// Forward the FoundPrinterL callback to the observer

			iPrinterDiscoveryObserver->FoundPrinterL( aDeviceInfo );			

			}

		}

	LOG("CImagePrintBody::FoundDeviceL end");	

	}

void CImagePrintBody::DiscoveryStatusL( TInt aStatus, TInt aErrorCode, TInt aErrorStringCode )

	{

	LOG1("CImagePrintBody::DiscoveryStatusL aStatus: %d", aStatus);

	LOG1("CImagePrintBody::DiscoveryStatusL aErrorCode: %d", aErrorCode);

	LOG1("CImagePrintBody::DiscoveryStatusL aErrorStringCode: %d", aErrorStringCode);

	if( iPrinterDiscoveryObserver )

		{

		switch( aStatus )

			{

			case EDiscoveryFinished: // Done with 1 protocol.

			{

				// When Bluetooth discovery is finished, but Bluetooth is not enabled pass error code to UI. 

				if ( aErrorCode == ENoConnection )

					{

					iPrinterDiscoveryObserver->DiscoveryStatusL( aStatus, aErrorCode, aErrorStringCode );

					}

				iCurrentProtocol = NULL;

				TUint doDiscovery = iProtocolsRequested & iClassLoader->SupportedProtocols();

				LOG1("CImagePrintBody::DiscoveryStatusL doDiscovery: %d", doDiscovery);

				LOG1("CImagePrintBody::DiscoveryStatusL iDiscoveryCancelled: %d", iDiscoveryCancelled);

				if( ( !doDiscovery && aErrorCode == KErrCancel ) || iDiscoveryCancelled )

					{

					iPrinterDiscoveryObserver->DiscoveryStatusL( aStatus, aErrorCode, aErrorStringCode );

					}

				else

					{

					TryNextDiscovery();

					}

			}

				break;

			default: // Discovering, Cancelling.

				iCurrentProtocol = NULL;

				iPrinterDiscoveryObserver->DiscoveryStatusL( aStatus, aErrorCode, aErrorStringCode );

			break;

			}

		}

	LOG("CImagePrintBody::DiscoveryStatusL end");

	}

void CImagePrintBody::RemoveDeviceL(TPrinter& aDeviceInfo)

	{	

	LOG("CImagePrintBody::RemoveDeviceL begin");

	if( iPrinterDiscoveryObserver )

		{

		if (PROTOCOL_ID_FIELD_MASK & aDeviceInfo.iPrinterID)

			{	//Invalid id, reject printer

			}

		else

			{	// Get the protocol index number

			TInt protocolIndex = iClassLoader->GetProtocolIndex();

			// Left shift this number so that it occupies the higher X bits (the PROTOCOL_ID_BIT_COUNT highest bits)

			protocolIndex <<= sizeof(TInt)*8 - PROTOCOL_ID_BIT_COUNT;

			// Add the protocol index number to the device id

			aDeviceInfo.iPrinterID |= protocolIndex;

			// Forward the RemovePrinterL callback to the observer

			iPrinterDiscoveryObserver->RemovePrinterL( aDeviceInfo );			

			}

		}

	LOG("CImagePrintBody::RemoveDeviceL end");	

	}

// From MProtPrintEventObserver.

void CImagePrintBody::PrintJobProgressEvent(TInt aStatus, TInt aPercent, TInt aJobStateCode)

	{

	LOG1("CImagePrintBody::PrintJobProgressEvent aStatus: %d", aStatus);

	LOG1("CImagePrintBody::PrintJobProgressEvent aPercent: %d", aPercent);

	LOG1("CImagePrintBody::PrintJobProgressEvent aJobStateCode: %d", aJobStateCode);

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->PrintJobProgressEvent(aStatus, aPercent, aJobStateCode);

	LOG("CImagePrintBody::PrintJobProgressEvent end");

	}

void CImagePrintBody::PrintJobErrorEvent(TInt aErrorCode, TInt aErrorStringCode)

	{

	LOG1("CImagePrintBody::PrintJobErrorEvent aErrorCode: %d", aErrorCode);

	LOG1("CImagePrintBody::PrintJobErrorEvent aErrorStringCode: %d", aErrorStringCode);

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->PrintJobErrorEvent(aErrorCode, aErrorStringCode);

	LOG("CImagePrintBody::PrintJobErrorEvent end");

	}

void CImagePrintBody::PrinterStatusEvent(TInt aErrorCode, TInt aErrorStringCode)

	{

	LOG1("CImagePrintBody::PrinterStatusEvent aErrorCode: %d", aErrorCode);

	LOG1("CImagePrintBody::PrinterStatusEvent aErrorStringCode: %d", aErrorStringCode);

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->PrinterStatusEvent(aErrorCode, aErrorStringCode);

	LOG("CImagePrintBody::PrinterStatusEvent end");

	}

void CImagePrintBody::PreviewImageEvent(TInt aFsBitmapHandle)

	{

	LOG1("CImagePrintBody::PreviewImageEvent aFsBitmapHandle: %d", aFsBitmapHandle);

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->PreviewImageEvent(aFsBitmapHandle);

	LOG("CImagePrintBody::PreviewImageEvent end");

	}

void CImagePrintBody::ShowMessageL(TInt aMsgLine1Code, TInt aMsgLine2Code)

	{

	LOG1("CImagePrintBody::ShowMessageL aMsgLine1Code: %d", aMsgLine1Code);

	LOG1("CImagePrintBody::ShowMessageL aMsgLine2Code: %d", aMsgLine2Code);

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->ShowMessageL(aMsgLine1Code, aMsgLine2Code);

	LOG("CImagePrintBody::ShowMessageL end");

	}

TBool CImagePrintBody::AskYesNoQuestionL(TInt aMsgLine1Code, TInt aMsgLine2Code)

	{

	LOG1("CImagePrintBody::AskYesNoQuestionL aMsgLine1Code: %d", aMsgLine1Code);

	LOG1("CImagePrintBody::AskYesNoQuestionL aMsgLine2Code: %d", aMsgLine2Code);

	TBool res( EFalse );

	if( iPrinterPrintEventObserver )

		{

		res = iPrinterPrintEventObserver->AskYesNoQuestionL(aMsgLine1Code, aMsgLine2Code);	

		}

	LOG1("CImagePrintBody::AskYesNoQuestionL return: %d", res);	

	return res;

	}

const TDesC& CImagePrintBody::AskForInputL(TInt aMsgLine1Code, TInt aMsgLine2Code)

	{

	LOG1("CImagePrintBody::ShowMessageL aMsgLine1Code: %d", aMsgLine1Code);

	LOG1("CImagePrintBody::ShowMessageL aMsgLine2Code: %d", aMsgLine2Code);

	if( iPrinterPrintEventObserver )

		{

		return iPrinterPrintEventObserver->AskForInputL(aMsgLine1Code, aMsgLine2Code);	

		}

	else

		{

		return KNullDesC;	

		}				

	}

void CImagePrintBody::StatusEvent(const TEvent& aEvent, TInt aError, TInt aMsgCode)

	{

	LOG1("CImagePrintBody::StatusEvent aError: %d", aError);

	LOG1("CImagePrintBody::StatusEvent aMsgCode: %d", aMsgCode);

	LOG1("CImagePrintBody::StatusEvent aEvent.iProtocol: %d", aEvent.iProtocol);

	LOG1("CImagePrintBody::StatusEvent aEvent.iSeverity: %d", aEvent.iSeverity);

	LOG1("CImagePrintBody::StatusEvent aEvent.iEventType: %d", aEvent.iEventType);

	if( iPrinterIdleObserver )

		{

		iPrinterIdleObserver->StatusEvent( aEvent, aError, aMsgCode );

		}

	if( aEvent.iEventType == EAsynchronousLeave )

		{

		// a protocol threw an async leave

		// we continue with other protocols

		TUint doDiscovery = iProtocolsRequested & iClassLoader->SupportedProtocols();

		if( doDiscovery ) TryNextDiscovery();					

		}

	LOG("CImagePrintBody::StatusEvent end");

	}

CImagePrintBody::CImagePrintBody() :

							iCurrentProtocol( NULL ),

							iCurrentPrintJobProtocol( NULL ) 

	{

	LOG("CImagePrintBody::CImagePrintBody begin");