/*

* Copyright (c) 2002-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 CPBPrintingDevice class definition.

*

*/

#include <e32std.h>

#include <pictbridge.h>

#include <s32file.h>

#include <f32file.h>

#include "cpbprintingdevice.h"

#include "printcapabilitycodes.h"

#include "printmessagecodes.h"

#include "imageprint.h"

#include "cpbconnect.h"

#include "clog.h"

//  CONSTANTS

namespace

	{

	const TInt KPBVersionMajor = 0;

	const TInt KPBVersionMinor = 0;

	const TInt KPBVersionBuild = 1;

	}

const TInt KConfigLength = 16;

const TInt KMaxRetry = 10;

_LIT( KConfigInfoFile, "config.DPS");

MProtPrintingDevice* CPBPrintingDevice::NewL()

	{

	return new (ELeave) CPBPrintingDevice();

	}

CPBPrintingDevice::CPBPrintingDevice() :

CActive( CActive::EPriorityStandard ), iState(EPBUninitialized), iDisconnectPrinter(EFalse)

	{

	CActiveScheduler::Add(this);

	}

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

	{

	LOG("CPBPrintingDevice::ConstructL begin");	

	iDpsEngine = CDpsEngine::GetEngineL();		

	iConnect = CPBConnect::NewL( *iDpsEngine, *this );

    iCongFileName = HBufC::NewL( iDpsEngine->DpsFolder().Length() + KConfigLength );

    TInt k = iDpsEngine->DpsFolder().Length() + KConfigLength;

    iCongFileName->Des().Copy( iDpsEngine->DpsFolder() );

    iCongFileName->Des().Append( KConfigInfoFile );

	iCancelRetry = 0;

    // for Cert software to indicate that printing state and idle state 

    iPrintingStateComplete = 0;

	iUserSelectedPaperSize = EDpsPaperSizeDefault;

	iNewJobOK = ETrue;

	LOG("CPBPrintingDevice::ConstructL end");

	}

CPBPrintingDevice::~CPBPrintingDevice()

	{

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

	Cancel();

	delete iConnect;

	delete iCongFileName;

	if ( iDpsEngine )

		{

		iDpsEngine->Delete();

		}

	REComSession::DestroyedImplementation( iDtor_ID_Key );

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

	}

TVersion CPBPrintingDevice::Version()

	{

	return TVersion(KPBVersionMajor, KPBVersionMinor, KPBVersionBuild);

	}

TUint CPBPrintingDevice::SupportedProtocols()

	{

	return KImagePrint_PrinterProtocol_PictBridge;

	}

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

	{		

	LOG1("CPBPrintingDevice::StartDiscoveryL aProtocol: %d", aProtocol);

	iDiscoveryObserver = &aObserver;

	if ( IsActive() )

		{

		LOG1("CPBPrintingDevice::StartDiscoveryL invalid state %d, cannot start discovery", iState);

		iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrInvalidSequence, 0 );

		return;

		}

	if ( !( aProtocol & KImagePrint_PrinterProtocol_PictBridge ) )

		{

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

		iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNotSupported, 0 );

		return;

		}

	if ( !iPrinterConnected )

		{

		LOG("CPBPrintingDevice::StartDiscoveryL no printer connected, ending discovery");

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

		return;

		}

	// clear capability map

	iCapToDps.Close();

    iConfigS.iReqParam.Reset();

    iDpsEngine->GetDpsConfigL( iConfigS.iReqParam );

    iDpsEngine->DoDpsRequestL( &iConfigS, iStatus );

	iState = EPBDiscovery;

    SetActive();

	LOG("CPBPrintingDevice::StartDiscoveryL setting state to Discovery");

	LOG("CPBPrintingDevice::StartDiscoveryL end");

	}

TInt CPBPrintingDevice::RemoveCachedDeviceL( TInt aDeviceID )

	{

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

  	return KErrInvalidData;

	}

void CPBPrintingDevice::CancelDiscovery( TBool aDoCallBack )

	{

  	LOG2("CPBPrintingDevice::CancelDiscovery aDoCallBack %d, iState %d", aDoCallBack, iState );  	

  	if ( iState == EPBDiscovery )

	  	{

	  	Cancel();

		if ( aDoCallBack && iDiscoveryObserver )

			{

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

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

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

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

			}

		iState = EPBUninitialized;

	  	}  	

	LOG("CPBPrintingDevice::CancelDiscovery end");

	}

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

	{

  	LOG2("CPBPrintingDevice::CreatePrintJobL begin, deviceid %d imagecount %d", aDeviceID, aImages.Count());

	iPrintEventObserver = &aObserver;		

	if ( aDeviceID != 0 )

		{

		LOG("CPBPrintingDevice::CreatePrintJobL invalid device");

		return KErrArgument;

		}

	if ( iState != EPBReady && iState != EPBJobReady )

		{

		LOG1("CPBPrintingDevice::CreatePrintJobL invalid state %d", iState);

		if(iDisconnectPrinter) // If printer is disconnected then return KErrDisconnected.

			return KErrDisconnected;

		else 

			return KErrInvalidSequence;

		}

    iStart.iReqParam.Reset();                                                                               

	// these must be appended in same order as PBJobSettingIndex

    TDpsArgsInt arg;    

    arg.iElement = EDpsArgPaperSize;

    arg.iContent = EDpsPaperSizeDefault;

    iStart.iReqParam.iJobConfig.Append(arg);

    arg.iElement = EDpsArgQuality;

    arg.iContent = EDpsPrintQualityDefault;

    iStart.iReqParam.iJobConfig.Append(arg);

    arg.iElement = EDpsArgLayout;

    arg.iContent = EDpsLayoutDefault;

    iStart.iReqParam.iJobConfig.Append(arg);

	for ( TInt i = 0; i < aImages.Count(); ++i )

		{

	    TDpsPrintInfo info;

	    info.Reset();

	    const TDesC& image = *aImages[i];

	    LOG1("CPBPrintingDevice::CreatePrintJobL image %S", &image);

	    info.iFile.Copy( image );

	    iStart.iReqParam.iPrintInfo.Append( info );

		}

	LOG("CPBPrintingDevice::CreatePrintJobL setting state to JobReady");

	iState = EPBJobReady;

	LOG("CPBPrintingDevice::CreatePrintJobL end");

	return KErrNone;

	}

void CPBPrintingDevice::SubmitPrintJobL()

	{

	LOG("CPBPrintingDevice::SubmitPrintJobL begin");

	// Checking that job is ready and printer has send aStatus.iRepParam.iNewJobOk

	// Check PrinterNotify function

	if ( iState == EPBJobReady && iNewJobOK )

		{

		iDpsEngine->DoDpsRequestL( &iStart, iStatus );

		iState = EPBSubmittingJob;

		SetActive();

		LOG("CPBPrintingDevice::SubmitPrintJobL setting state to SubmittingJob");

		}

	else

		{

		LOG1("CPBPrintingDevice::SubmitPrintJobL invalid state %d", iState);

		if( iDisconnectPrinter )

		    {

		    User::Leave( KErrDisconnected );

		    }

		else

		    {

		  	// Job or printer not ready, inform user

		  	if( iPrintEventObserver )

		  	    {

    		  	LOG("CPBPrintingDevice::SubmitPrintJobL sending EPbStatusErrorReasonHardwarePrinterBusy message to UI");

    		  	iPrintEventObserver->PrinterStatusEvent( EPbStatusErrorReasonHardwarePrinterBusy );

		  	    }

		    else

		        {

       			LOG1("CPBPrintingDevice::SubmitPrintJobL invalid state %d", iState);

       			User::Leave( KErrInvalidSequence );

		        }

		    }

		}

	LOG("CPBPrintingDevice::SubmitPrintJobL end");

	}

TInt CPBPrintingDevice::CancelPrintJob()

	{

	LOG("CPBPrintingDevice::CancelPrintJob begin");

    if( iCancelRetry > KMaxRetry )

        {

        return KErrInUse;

        }

	if ( iState == EPBSubmittingJob || iState == EPBPrinting || iState == EPBCancelling )

		{

        Cancel();

        iAbort.iReqParam.iAbortStyle = EDpsAbortStyleImmediately;

        TRAPD( err, iDpsEngine->DoDpsRequestL( &iAbort, iStatus ) );

        if ( err != KErrNone )

	        {

	        LOG1("CPBPrintingDevice::CancelPrintJob FATAL, DoDpsRequestL failed %d, setting state to Uninitialized", err);

	       	iState = EPBUninitialized;

	       	return KErrGeneral;

	        }        

        iState = EPBCancelling;

        SetActive();

        LOG("CPBPrintingDevice::CancelPrintJob setting state to Cancelling");

		}	

	else if ( iState == EPBJobReady )

		{

		LOG("CPBPrintingDevice::CancelPrintJob state is JobReady so doing nothing");

		return KErrNone;

		}

	else 

		{

		LOG1("CPBPrintingDevice::CancelPrintJob invalid state %d", iState);

		return KErrInvalidSequence;

		}

	LOG("CPBPrintingDevice::CancelPrintJob end");

	return KErrNone;

	}

TInt CPBPrintingDevice::ContinuePrintJobL()

	{

	LOG1("CPBPrintingDevice::ContinuePrintJobL returns with: %d", KErrNotSupported);

	return KErrNotSupported;

	}

TInt CPBPrintingDevice::GetNumPrintPages()

	{

	LOG("CPBPrintingDevice::GetNumPrintPages begin");

	if ( iState != EPBJobReady && iState != EPBSubmittingJob && iState != EPBPrinting )

		{

		LOG1("CPBPrintingDevice::GetNumPrintPages invalid state %d, returning 0", iState);

		return 0;

		}

	TInt imagesPerPage = 1;

	TDpsArgsInt& config = iStart.iReqParam.iJobConfig[EPBSettingLayout];

	switch ( config.iContent )

		{        

        case EDpsLayout2Up:

			imagesPerPage = 2;

        	break;        

        case EDpsLayout4Up:

			imagesPerPage = 4;

        	break;        

        case EDpsLayout6Up:

			imagesPerPage = 6;

        	break;        

        case EDpsLayout9Up:

			imagesPerPage = 9;

        	break;        	        			        		        						

		default:

			break;

		}

	TInt numPrintPages = (iStart.iReqParam.iPrintInfo.Count() + imagesPerPage - 1) / imagesPerPage;

	LOG1("CPBPrintingDevice::GetNumPrintPages end, result %d", numPrintPages);

	return numPrintPages;

	}

TInt CPBPrintingDevice::GetPrintJobStatus()

	{

	LOG1("CPBPrintingDevice::GetPrintJobStatus returns with: %d", KErrNotSupported);

	return KErrNotSupported;

	}

TInt CPBPrintingDevice::GetPrinterStatus(TInt /*aDeviceID*/)

	{

	LOG1("CPBPrintingDevice::GetPrinterStatus returns with: %d", KErrNotSupported);

	return KErrNotSupported;

	}

TInt CPBPrintingDevice::GetDeviceCapabilityIDsL(TInt aDeviceID, RArray<TInt>& aCapabilityIDs)

	{

	LOG1("CPBPrintingDevice::GetDeviceCapabilityIDsL begins with aDeviceID: %d", aDeviceID);

	if ( aDeviceID != 0 )

		{

		LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid device");

		return KErrArgument;

		}		

	if ( iState != EPBReady && iState != EPBJobReady )

		{

		LOG1("CPBPrintingDevice::GetDeviceCapabilityL invalid state %d", iState);

		return KErrInvalidSequence;

		}	

	aCapabilityIDs.Append( EPrintCapabLayout );

	aCapabilityIDs.Append( EPrintCapabQuality );

	aCapabilityIDs.Append( EPrintCapabPaperSize );

	LOG("CPBPrintingDevice::GetDeviceCapabilityIDsL end");

	return KErrNone;

	}

TInt CPBPrintingDevice::GetDeviceCapabilityL(TInt aDeviceID, TInt aCapabilityID, TPrintCapability& aCapability)

	{		

	LOG2("CPBPrintingDevice::GetDeviceCapabilityL begins with aDeviceID %d, aCapabilityID %d", aDeviceID, aCapabilityID);

	if ( aDeviceID != 0 )

		{

		LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid device");

		return KErrArgument;

		}		

	if ( iState != EPBReady && iState != EPBJobReady )

		{

		LOG1("CPBPrintingDevice::GetDeviceCapabilityL invalid state %d", iState);

		return KErrInvalidSequence;

		}	

	if ( aCapabilityID == EPrintCapabPaperSize )

		{

		// paper sizes

		iCap.iRepParam.Reset();

		iCap.iReqParam.iCap = EDpsArgPaperSizes;

		iDpsEngine->DoDpsRequestL(&iCap, iStatus);

		SetActive();

		iWait.Start();

		HandlePapersizesResponseL( aCapability );

		if ( !aCapability.iEnumCount )

			{

			LOG("CPBPrintingDevice::GetDeviceCapabilityL paper sizes not supported, set to default");

	    	aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeAuto;

	    	iCapToDps.InsertL( EPrintCapabPaperSizeAuto, EDpsPaperSizeDefault );

			}				    		

	    }

	else if ( aCapabilityID == EPrintCapabQuality )

		{

		// qualities

		LOG("CPBPrintingDevice::GetDeviceCapabilityL qualities");

		iCap.iRepParam.Reset();

		iCap.iReqParam.iCap = EDpsArgQualities;

		iDpsEngine->DoDpsRequestL( &iCap, iStatus );

		SetActive();

		iWait.Start();

		HandleQualitiesResponseL( aCapability );

		}

	else if ( aCapabilityID == EPrintCapabLayout )

		{			

		// layouts		

		LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts");

		iCap.iRepParam.Reset();

		iCap.iReqParam.iCap = EDpsArgLayouts;

		iCap.iReqParam.iAttribute = iUserSelectedPaperSize;

		LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts dodpsrequest");		

		iDpsEngine->DoDpsRequestL(&iCap, iStatus);

		SetActive();

		LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts wait");

		iWait.Start();

		HandleLayoutsResponseL( aCapability );

		}

	else

		{

		LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid capabilityID");

		return KErrArgument;

		}	    

	LOG1("CPBPrintingDevice::GetDeviceCapabilityL iCapToDps count %d", iCapToDps.Count());

	LOG("CPBPrintingDevice::GetDeviceCapabilityL end");

	return KErrNone;

	}

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

	{

	LOG1("CPBPrintingDevice::GetJobSetting begin, aCapabilityID %d", aCapabilityID);

	TInt err = KErrNone;		

	if ( iState != EPBJobReady )

		{

		LOG1("CPBPrintingDevice::GetJobSetting invalid state %d", iState);

		err = KErrInvalidSequence;

		}	

	else if ( aCapabilityID == EPrintCapabPaperSize )

		{

		err = GetPapersizeJobSetting( aValue );

	    }

	else if ( aCapabilityID == EPrintCapabQuality )

		{

		err = GetQualityJobSetting( aValue );

		}

	else if ( aCapabilityID == EPrintCapabLayout )

		{

		err = GetLayoutJobSetting( aValue );

		}

	else

		{

		LOG("CPBPrintingDevice::GetJobSetting invalid capabilityID");

		err = KErrArgument;

		}	    

	LOG2("CPBPrintingDevice::GetJobSetting end, return code %d value %d", err, aValue);

	return err;

	}

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

	{

	LOG2("CPBPrintingDevice::SetJobSettingL begin, aCapabilityID %d aValue %d", aCapabilityID, aValue);

	aAffectedCapability = aCapabilityID;

	RArray<TDpsArgsInt>& config = iStart.iReqParam.iJobConfig;

	TInt err = KErrNone;

	if ( iState != EPBJobReady )

		{

		LOG1("CPBPrintingDevice::SetJobSettingL invalid state %d", iState);

		err = KErrInvalidSequence;

		}

	else if ( aCapabilityID == EPrintCapabPaperSize )

		{

		TInt* dpsValue = iCapToDps.Find( aValue );

		if ( dpsValue )

		    {

			config[EPBSettingPaperSize].iContent = *dpsValue;

			// for CertSW: needs layouts for particular paper sizes

			iUserSelectedPaperSize = config[EPBSettingPaperSize].iContent;

		    }

		else

			{

			LOG("CPBPrintingDevice::SetJobSettingL invalid value");

			err = KErrInvalidData;

			}

	    }

	else if ( aCapabilityID == EPrintCapabQuality )

		{

		TInt* dpsValue = iCapToDps.Find( aValue );

		if ( dpsValue )

			{

			config[EPBSettingQuality].iContent = *dpsValue;

			}

		else

			{

			LOG("CPBPrintingDevice::SetJobSettingL invalid value");

			err = KErrInvalidData;

			}

		}

	else if ( aCapabilityID == EPrintCapabLayout )

		{

		TInt* dpsValue = iCapToDps.Find( aValue );

		if ( dpsValue )

			{