/*

* Copyright (c) 2010 Kanrikogaku Kenkyusho, Ltd.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

* Kanrikogaku Kenkyusho, Ltd. - Initial contribution

*

* Contributors:

*

* Description:  Contains the CDirectPrintBody class definition.

*

*/

#include <bluetooth/hci/hcierrors.h>

#include "directprintbody.h"

#include "directprintrsimageparser.h"

#include "clog.h"

#include "directprintselectitem.h"

#include "directprintmessage.h"

CDirectPrintBody* CDirectPrintBody::NewL()

    {

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

    }

CDirectPrintBody::~CDirectPrintBody()

	{

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

	delete iClassLoader;

	iImageFileNames.ResetAndDestroy();

	delete iIdleDiscovery;

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

	}

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

	{

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

	iPrinterDiscoveryObserver = &aObserver;

	if( iCurrentProtocol )

		{

		iCurrentProtocol->CancelDiscovery( EFalse );

		}

	iCurrentProtocol = NULL;

	iClassLoader->Reset();

	iProtocolsRequested = aProtocols;

	iDiscoveryCancelled = EFalse;

	TryNextDiscovery();		

	LOG("CDirectPrintBody::StartDiscovery end");

	return KErrNone;

	}

void CDirectPrintBody::CancelDiscovery()

	{

	LOG("CDirectPrintBody::CancelDiscovery begin");

	iDiscoveryCancelled = ETrue;

	if( iCurrentProtocol )

		{

		iCurrentProtocol->CancelDiscovery();

		}

	LOG("CDirectPrintBody::CancelDiscovery end");

	}

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

	{

	LOG("CDirectPrintBody::CreatePrintJobL begin");

	iPrinterPrintEventObserver = &aObserver;

	iCurrentPrintJobProtocol = NULL;

	if( iCurrentProtocol )

		{		

		iCurrentProtocol->CancelDiscovery( EFalse );

		}

#ifdef __IMAGE_PRINT_BASE

	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;

			}

		}

#endif // __IMAGE_PRINT_BASE

	TInt DeviceID;

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

	if( !err )

		{

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

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

		}

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

	return err;

	}

void CDirectPrintBody::SubmitPrintJobL()

	{

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

	TInt err( KErrNone );

	if( !iCurrentPrintJobProtocol )

		{

		err = KErrInvalidSequence;

		}

	if( !err )

		{

		TInt invalidImages;

		err = ValidateImagesL( iImageFileNames, invalidImages );

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

		}

	User::LeaveIfError( err );

	iCurrentPrintJobProtocol->SubmitPrintJobL();

	LOG("CDirectPrintBody::SubmitPrintJobL end");

	}

TInt CDirectPrintBody::CancelPrintJob()

	{

	LOG("CDirectPrintBody::CancelPrintJob begin");

	TInt err( KErrNone );

	if( !iCurrentPrintJobProtocol )

		{

		err = KErrInvalidSequence;

		}

	if( !err )

		{

		err = iCurrentPrintJobProtocol->CancelPrintJob();

		}

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

	return err;

	}

TInt CDirectPrintBody::ContinuePrintJobL()

	{

	LOG("CDirectPrintBody::ContinuePrintJobL begin");

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->ContinuePrintJobL();

		}

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

	return err;

	}

TInt CDirectPrintBody::GetNumPrintPages()

	{

	LOG("CDirectPrintBody::GetNumPrintPages begin");

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->GetNumPrintPages();

		}

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

	return err;

	}

TInt CDirectPrintBody::GetJobStatus()

	{

	LOG("CDirectPrintBody::GetJobStatus begin");

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->GetPrintJobStatus();

		}

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

	return err;

	}

TInt CDirectPrintBody::GetPrinterStatus(TInt aPrinterID)

	{

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

	TInt DeviceID;

	MProtPrintingDevice* theProtToQuery = NULL;

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

	if( !err )

		{

		err = theProtToQuery->GetPrinterStatus( DeviceID );

		}

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

	return err;

	}

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

	{

	LOG1("CDirectPrintBody::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("CDirectPrintBody::GetPrinterCapabilityIDsL return: %d", err);

	return err;

	}

TInt CDirectPrintBody::GetPrinterCapabilityL(TInt aPrinterID, TInt aCapabilityID, TDirectPrintCapability& aCapability)

	{

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

	LOG1("CDirectPrintBody::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("CDirectPrintBody::GetPrinterCapabilityL return: %d", err);

	return err;

	}

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

	{

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

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

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

		}

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

	return err;

	}

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

	{

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

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

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

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

		}

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

	return err;

	}

TInt CDirectPrintBody::GetNumPreviewPages()

	{

	LOG("CDirectPrintBody::GetNumPreviewPages");

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->GetNumPreviewPages();

		}

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

	return err;

	}

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

	{

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

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

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

		}

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

	return err;

	}

TInt CDirectPrintBody::CreatePreviewImage(TInt aPageNumber)

	{

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

	TInt err( KErrInvalidSequence );

	if( iCurrentPrintJobProtocol )

		{

		err = iCurrentPrintJobProtocol->CreatePreviewImage(aPageNumber);

		}

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

	return err;

	}

TInt CDirectPrintBody::RemoveCachedPrinterL(TInt aPrinterID)

	{

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

	TInt DeviceID;

	MProtPrintingDevice* theProtToQuery = NULL;

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

	if( !err )

		{

		err = theProtToQuery->RemoveCachedDeviceL( DeviceID );

		}

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

	return err;

	}

TUint CDirectPrintBody::SupportedProtocols()

	{

	LOG("CDirectPrintBody::SupportedProtocols begin");

	TUint prots = iClassLoader->SupportedProtocols();

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

	return prots;

	}

void CDirectPrintBody::RegisterIdleObserver(MIdleObserver *aObserver)

	{

	LOG("CDirectPrintBody::RegisterIdleObserver begin");

	iPrinterIdleObserver = aObserver;

	LOG("CDirectPrintBody::RegisterIdleObserver end");

	}

// From MProtDiscoveryObserver.

void CDirectPrintBody::FoundDeviceL(TPrinter& aDeviceInfo)

	{

	LOG("CDirectPrintBody::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("CDirectPrintBody::FoundDeviceL end");	

	}

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

	{

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

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

	LOG1("CDirectPrintBody::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("CDirectPrintBody::DiscoveryStatusL doDiscovery: %d", doDiscovery);

				LOG1("CDirectPrintBody::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("CDirectPrintBody::DiscoveryStatusL end");

	}

void CDirectPrintBody::RemoveDeviceL(TPrinter& aDeviceInfo)

	{	

	LOG("CDirectPrintBody::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("CDirectPrintBody::RemoveDeviceL end");	

	}

// From MProtPrintEventObserver.

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

	{

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

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

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

	if( iPrinterPrintEventObserver )

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

	LOG("CDirectPrintBody::PrintJobProgressEvent end");

	}

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

	{

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

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

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->PrintJobErrorEvent(aErrorCode, aErrorStringCode);

	LOG("CDirectPrintBody::PrintJobErrorEvent end");

	}

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

	{

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

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

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->PrinterStatusEvent(aErrorCode, aErrorStringCode);

	LOG("CDirectPrintBody::PrinterStatusEvent end");

	}

void CDirectPrintBody::PreviewImageEvent(TInt aFsBitmapHandle)

	{

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

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->PreviewImageEvent(aFsBitmapHandle);

	LOG("CDirectPrintBody::PreviewImageEvent end");

	}

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

	{

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

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

	if( iPrinterPrintEventObserver )

		iPrinterPrintEventObserver->ShowMessageL(aMsgLine1Code, aMsgLine2Code);

	LOG("CDirectPrintBody::ShowMessageL end");

	}

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

	{

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

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

	TBool res( EFalse );

	if( iPrinterPrintEventObserver )

		{

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

		}

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

	return res;

	}

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

	{

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

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

	if( iPrinterPrintEventObserver )

		{

		return iPrinterPrintEventObserver->AskForInputL(aMsgLine1Code, aMsgLine2Code);

		}

	else

		{

		return KNullDesC;

		}

	}

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

	{

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

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

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

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

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

	if( iPrinterIdleObserver )

		{

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

		}

	if( aEvent.iEventType == EAsynchronousLeave )

		{

		// a protocol threw an async leave