/*

* 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 CDPOFPrintingDevice class definition.

*

*/

#include <e32std.h>

#include <barsc.h>

#include <dpof.rsg>

#include <bautils.h>

#include "cdpofprintingdevice.h"

#include "cconfirmationquery.h"

#include "cprintercapabilities.h"

#include "cprinterelement.h"

#include "imgprintkonst.h"

#include "tsetting.h"

#include "rsutils.h"

#include "printcapabilitycodes.h"

#include "printmessagecodes.h"

#include "imageprint.h"

#include "clog.h"

#include "cprintjob.h"

//  CONSTANTS

namespace

	{

	/// DPOF Version Major.

	const TInt KDPOFVersionMajor = 0;

	/// DPOF Version Minor.

	const TInt KDPOFVersionMinor = 0;

	/// DPOF Version Build.

	const TInt KDPOFVersionBuild = 1;

	_LIT( KResourceFileName, "imageprintdata\\protocols\\dpof.rsc" );

	const TInt KMmcPrinterId = 1;

	_LIT( KMmcPrinterName, "Memory Card" );

	}

MProtPrintingDevice* CDPOFPrintingDevice::NewL()

	{

	return new (ELeave) CDPOFPrintingDevice();

	}

CDPOFPrintingDevice::CDPOFPrintingDevice() : CActive( CActive::EPriorityStandard ),

											iPrintError( KErrNone ),

											iPrintErrorMsgCode( 0 )

	{

	CActiveScheduler::Add(this);

	}

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

	{

	LOG("CDPOFPrintingDevice::ConstructL begin");

	iCancelledByUser = EFalse;

	iPrintJob = new (ELeave) CPrintJob();

	iMappingArray.AppendL(TMapping(1,EPrintCapabLayout1UpMedium));

	iMappingArray.AppendL(TMapping(2,EPrintCapabLayout2Up));

	iMappingArray.AppendL(TMapping(4,EPrintCapabLayout4Up));

	iMappingArray.AppendL(TMapping(6,EPrintCapabLayout6Up));

	iMappingArray.AppendL(TMapping(9,EPrintCapabLayout9Up));

	iMappingArray.AppendL(TMapping(12,EPrintCapabLayout12Up));

	iMappingArray.AppendL(TMapping(16,EPrintCapabLayout16Up));

	RFs fs;

	User::LeaveIfError( fs.Connect() );

	CleanupClosePushL( fs );

	// Loading nearest Loc File.

	TFileName resourceFileName;

	resourceFileName.Append( KDC_RESOURCE_FILES_DIR );

	resourceFileName.Append( KResourceFileName );

	BaflUtils::NearestLanguageFile( fs, resourceFileName );

	RResourceFile resourceFile;

	resourceFile.OpenL( fs, resourceFileName );

	CleanupClosePushL( resourceFile );

	iCapabilities = LoadCapabilityL( resourceFile, DPOF_CAPABILITIES );

	CleanupStack::PopAndDestroy( 2 ); // resourceFile, fs

	iDPOF = CRsDpofEngine::NewL( *this );

	SetMMCPrinterL();

	LOG("CDPOFPrintingDevice::ConstructL end");

	}

void CDPOFPrintingDevice::SetMMCPrinterL()

	{

	LOG("CDPOFPrintingDevice::SetMMCPrinterL begin");

    // New implementation

	LOG("CDPOFPrintingDevice::SetMMCPrinterL calling iDPOF->SetMMCPathL ...");

	iDPOF->SetMMCPathL();

	if( iDPOF->HasMmc() )

		{

		CPrinterElement* printElem = CPrinterElement::NewLC();

		printElem->iPrinter.iDisplayName = KMmcPrinterName;

		printElem->iPrinter.iPrinterID = KMmcPrinterId;

		printElem->iPrinter.iProperties = TPrinter::SupportsPreview;

		printElem->iPrinter.iProtocol = KImagePrint_PrinterProtocol_DPOF;

		printElem->iTransport = DPOFTrans;

		printElem->iPrinterClass = EDefault;

		printElem->iPrinterCapabilities = CPrinterCapabilities::NewL( iCapabilities, printElem->iPrinterClass );

		User::LeaveIfError( iDeviceList.Append( printElem ) );

		CleanupStack::Pop( printElem );

		printElem = NULL;

		}

	LOG("CDPOFPrintingDevice::SetMMCPrinterL end");

	}

CDPOFPrintingDevice::~CDPOFPrintingDevice()

	{

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

	Cancel();

	delete iDPOF;

	delete iCapabilities;

	iDeviceList.ResetAndDestroy();

	iDeviceList.Close();	

	iMappingArray.Close();

	delete iPrintJob;

	iReadyRequests.Close();	

	REComSession::DestroyedImplementation( iDtor_ID_Key );

	if (iConfirmationQuery)

	{

		delete iConfirmationQuery;

		iConfirmationQuery = NULL;

	}

	if (iPQ)

	{

		delete iPQ;

		iPQ = NULL;

	}

	if (iQuestion)

		{

		delete iQuestion;

		iQuestion = NULL;

		}

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

	}

TVersion CDPOFPrintingDevice::Version()

	{

	return TVersion(KDPOFVersionMajor, KDPOFVersionMinor, KDPOFVersionBuild);

	}

TUint CDPOFPrintingDevice::SupportedProtocols()

	{

	return KImagePrint_PrinterProtocol_DPOF;

	}

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

	{

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

	iDiscoveryObserver = &aObserver;

	Cancel();

	if( aProtocol & KImagePrint_PrinterProtocol_DPOF )

		{

		LOG("CDPOFPrintingDevice::StartDiscoveryL protocol match, starting discovery...");

		iDPOF->StartDiscovery( iStatus );

		if( !IsActive() ) SetActive();

		}

	else

		{

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

		AddReadyRequestAndSetActive( EDiscoveryDone );		

		}	

	LOG("CDPOFPrintingDevice::StartDiscoveryL end");

	}

TInt CDPOFPrintingDevice::RemoveCachedDeviceL( TInt aDeviceID )

	{

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

  	CPrinterElement* targetPrinter = FindDeviceL( aDeviceID );

  	LOG1("CDPOFPrintingDevice::RemoveCachedDeviceL targetPrinter address: %d", (TInt)targetPrinter);

  	return ( targetPrinter ) ? KErrNone : KErrInvalidData;

	}

void CDPOFPrintingDevice::CancelDiscovery( TBool aDoCallBack )

	{

  	LOG1("CDPOFPrintingDevice::CancelDiscovery aDoCallBack: %d", aDoCallBack);

	if( aDoCallBack )

		{				

		AddReadyRequestAndSetActive( ECancelDiscovery );

		}

	LOG("CDPOFPrintingDevice::CancelDiscovery end");

	}

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

	{

  	LOG1("CDPOFPrintingDevice::CreatePrintJobL aDeviceID: %d", aDeviceID);

  	LOG1("CDPOFPrintingDevice::CreatePrintJobL aImages.Count(): %d", aImages.Count());

	iPrintEventObserver = &aObserver;

	iPrintJob->iState = PJSNone;  // Reset value until Job is fully setup in case of a leave.

	CPrinterElement *TargetPrinter = FindDeviceL( aDeviceID );

	if( TargetPrinter == NULL )

		{

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

		return KErrInvalidData;

		}

	iPrintJob->iTransport = DPOFTrans;

	iPrintJob->iPrinterID = aDeviceID;

	TInt NumImages = aImages.Count();

	iPrintJob->iImages.ResetAndDestroy();

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

		{

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

		User::LeaveIfError( iPrintJob->iImages.Append( Image ) );

		CleanupStack::Pop(Image);

		}

	LOG("CDPOFPrintingDevice::CreatePrintJobL image names copied");

	// Now we can access the capabilities and fill in the printer settings.

	RArray<TInt> CapabilityIDs;

	CleanupClosePushL( CapabilityIDs );

	GetDeviceCapabilityIDsL( aDeviceID, CapabilityIDs );

	LOG1("CDPOFPrintingDevice::CreatePrintJobL capability ids count: %d", CapabilityIDs.Count());

	iPrintJob->iSettings.Reset();

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

		{

		TPrintCapability capability;

		GetDeviceCapabilityL(aDeviceID, CapabilityIDs[i], capability);

		TInt nCurrentValue;

		TBool bHasValue = TargetPrinter->iPrinterCapabilities->GetCurrentValue(CapabilityIDs[i], nCurrentValue);

		TSetting Setting;

		Setting.iCapabilityID = capability.iCapabilityID;

		if (bHasValue)

			Setting.iValue = nCurrentValue;

		else

			Setting.iValue = capability.iDefaultValue;

		User::LeaveIfError(iPrintJob->iSettings.Append(Setting));

		}

	LOG("CDPOFPrintingDevice::CreatePrintJobL capabilities copied");

	CleanupStack::PopAndDestroy(); // CapabilityIDs

	iPrintJob->iState = PJSCreated;

	LOG("CDPOFPrintingDevice::CreatePrintJobL end");

	return KErrNone;

	}

void CDPOFPrintingDevice::SubmitPrintJobL()

	{

	LOG("CDPOFPrintingDevice::SubmitPrintJobL begin");

    if( iDPOF->AutoPrintFileExists() ) 

        {

        ShowConfirmationQueryL(); 

        }

    else 

    	{

    	OverwriteExistingJobL ();    	

    	}    

		LOG("CDPOFPrintingDevice::SubmitPrintJobL end");

	    }

void CDPOFPrintingDevice::ShowConfirmationQueryL() 

    {

    LOG("CDPOFPrintingDevice::ShowConfirmationQueryL begin");

  	RFs fs;

	User::LeaveIfError( fs.Connect() );

	CleanupClosePushL( fs );

	TFileName resourceFileName;

	resourceFileName.Append ( KDC_RESOURCE_FILES_DIR );

	resourceFileName.Append ( KResourceFileName );

	BaflUtils::NearestLanguageFile( fs, resourceFileName );

	RResourceFile resFile;

	resFile.OpenL( fs, resourceFileName );

	CleanupClosePushL( resFile );

	HBufC8 *resBuffer = resFile.AllocReadLC( R_QTN_PRINT_DPOF_CONFIRMATION_DIALOG );

	TResourceReader reader;

	reader.SetBuffer( resBuffer );

	TPtrC ptrQuestion = reader.ReadTPtrC();

	iQuestion = ptrQuestion.AllocL();

	CleanupStack::PopAndDestroy( 3 ); // resBuffer, resFile, fs

	iPQ = CAknGlobalConfirmationQuery::NewL();

    iConfirmationQuery = CConfirmationQuery::NewL( *this );

    iConfirmationQuery->StartWaitingAnswer( );        

    iPQ->ShowConfirmationQueryL( iConfirmationQuery->iStatus, *iQuestion, R_AVKON_SOFTKEYS_YES_NO );

    LOG("CDPOFPrintingDevice::ShowConfirmationQueryL end");

    }

TInt CDPOFPrintingDevice::CancelPrintJob()

	{

	LOG1("CDPOFPrintingDevice::CancelPrintJob begin with job state: %d", iPrintJob->iState);

	TInt retVal(KErrNone);

	if( iPrintJob->iState == PJSSubmitted )

		{

		LOG("CDPOFPrintingDevice::CancelPrintJob calling iDPOF->Stop()");

		iDPOF->Stop();				

		iPrintJob->iState = PJSCreated;

		AddReadyRequestAndSetActive( EPrintJobDone );

		}

	else

		{

		retVal = KErrInvalidSequence;

		}

	LOG1("CDPOFPrintingDevice::CancelPrintJob end with code: %d", retVal);

	return retVal;

	}

TInt CDPOFPrintingDevice::ContinuePrintJobL()

	{

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

	return KErrNotSupported;

	}

TInt CDPOFPrintingDevice::GetNumPrintPages()

	{

	LOG1("CDPOFPrintingDevice::GetNumPrintPages begin with job state: %d", iPrintJob->iState);

	if( iPrintJob->iState == PJSNone )

		{

		LOG("CDPOFPrintingDevice::GetNumPrintPages job state == PJSNone, ending with 0");

		return 0;

		}

	TInt ImagesPerPage = 1;

	TInt NumPrintPages;

	TInt NumImages = iPrintJob->iImages.Count();

	// Get Num images per page from the mapping table.

	TSetting Setting;

	FindSetting(EPrintCapabLayout, Setting);

	for (TInt j = 0; j < iMappingArray.Count(); j++)

		{

		if (iMappingArray[j].iCode == Setting.iValue)

			{

			ImagesPerPage = iMappingArray[j].iImagesPerPage;

			break;

			}

		}

	if( ImagesPerPage == 0 ) // Stickers, Uses only one image, and populates a single page

		NumPrintPages = 1;

	else

		NumPrintPages = (NumImages + ImagesPerPage - 1) / ImagesPerPage;

	LOG1("CDPOFPrintingDevice::GetNumPrintPages returns: %d", NumPrintPages);

	return NumPrintPages;

	}

TInt CDPOFPrintingDevice::GetPrintJobStatus()

	{

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

	return KErrNotSupported;

	}

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

	{

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

	return KErrNotSupported;

	}

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

	{

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

	TInt err(KErrNone);

	aCapabilityIDs.Reset();

	CPrinterElement* TargetPrinter = FindDeviceL(aDeviceID);

	if( TargetPrinter )

		{

		TargetPrinter->iPrinterCapabilities->GetIDs(aCapabilityIDs);

		}

	else

		{

		err = KErrInvalidData;

		}

	LOG1("CDPOFPrintingDevice::GetDeviceCapabilityIDsL ends with err: %d", err);

	return err;

	}

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

	{

	LOG1("CDPOFPrintingDevice::GetDeviceCapabilityL begins with aDeviceID: %d", aDeviceID);

	LOG1("CDPOFPrintingDevice::GetDeviceCapabilityL begins with aCapabilityID: %d", aCapabilityID);

	TInt err(KErrNone);

	CPrinterElement* TargetPrinter = FindDeviceL(aDeviceID);

	if( TargetPrinter )

		{

		TargetPrinter->iPrinterCapabilities->GetCapability(aCapabilityID, aCapability);

		}

	else

		{

		err = KErrInvalidData;

		}

	LOG1("CDPOFPrintingDevice::GetDeviceCapabilityL ends with err: %d", err);

	return err;

	}

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

	{

	LOG1("CDPOFPrintingDevice::GetJobSetting begins with aCapabilityID: %d", aCapabilityID);

	TInt err(KErrNone);

	if( iPrintJob->iState == PJSNone )

		{

		err = KErrInvalidSequence;

		}

	else

		{

		TSetting Setting;

		if( FindSetting(aCapabilityID, Setting) )

			{

			aValue = Setting.iValue;

			}

		else

			{

			err = KErrInvalidData;

			}

		}

	LOG1("CDPOFPrintingDevice::GetJobSetting ends with err: %d", err);

	return err;

	}

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

	{

	LOG1("CDPOFPrintingDevice::SetJobSettingL begins with aCapabilityID: %d", aCapabilityID);

	LOG1("CDPOFPrintingDevice::SetJobSettingL begins with aValue: %d", aValue);

	LOG1("CDPOFPrintingDevice::SetJobSettingL begins with aAffectedCapability: %d", aAffectedCapability);

	if( iPrintJob->iState == PJSNone )

		{

		LOG("CDPOFPrintingDevice::SetJobSettingL job state == PJSNone");

		LOG1("CDPOFPrintingDevice::SetJobSettingL ends with: %d", KErrInvalidSequence);

		return KErrInvalidSequence;

		}

	aAffectedCapability = 0;

	TSetting Setting;

	if( FindSetting(aCapabilityID, Setting) == EFalse )

		{

		LOG("CDPOFPrintingDevice::SetJobSettingL FindSetting == EFalse");

		LOG1("CDPOFPrintingDevice::SetJobSettingL ends with: %d", KErrInvalidData);

		return KErrInvalidData;

		}

	// Get the Target printer and capability

	TPrintCapability TargetCapability;

	CPrinterElement* TargetPrinter = FindDeviceL( iPrintJob->iPrinterID );

	if( TargetPrinter == NULL )

		{

		LOG("CDPOFPrintingDevice::SetJobSettingL TargetPrinter == NULL");

		LOG1("CDPOFPrintingDevice::SetJobSettingL ends with: %d", KErrInvalidData);

		return KErrInvalidData;

		}

	TargetPrinter->iPrinterCapabilities->GetCapability(aCapabilityID, TargetCapability);

	// Check Validity against the target capability ranges

	if ((TargetCapability.iType == TPrintCapability::Int) ||

		(TargetCapability.iType == TPrintCapability::Float))

		{

		if (((aValue < TargetCapability.iLow) && (TargetCapability.iLow != -1)) ||

			((aValue > TargetCapability.iHigh) && (TargetCapability.iHigh != -1)))

			{

			LOG("CDPOFPrintingDevice::SetJobSettingL capability ranges error");

			LOG1("CDPOFPrintingDevice::SetJobSettingL ends with: %d", KErrInvalidData);

			return KErrInvalidData;

			}

		}

	else // enum

		{

		TBool Valid = EFalse;

		for (TInt i = 0; i < TargetCapability.iEnumCount; i++)

			{

			if (aValue == TargetCapability.iEnumCodes[i])

				{

					Valid = ETrue;

					break;

				}

			}

		if (!Valid)

			{

			LOG("CDPOFPrintingDevice::SetJobSettingL !Valid");

			LOG1("CDPOFPrintingDevice::SetJobSettingL ends with: %d", KErrInvalidData);

			return KErrInvalidData;

			}

		}

	for (TInt i = 0; i < iPrintJob->iSettings.Count(); i++)

		{

		if (aCapabilityID == iPrintJob->iSettings[i].iCapabilityID)