/*

* 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:  Declares CUPnPPrintingDevice class

*

*/

#include <upnpsettings.h>

#include <fbs.h>

#include <upnpitem.h>

#include <upnphttpmessage.h>

#include <upnphttpmessagefactory.h>

#include <upnpicons.mbg>

#include "cupnpprintingdevice.h"

#include "cuplogger.h"

#include "upconsts.h"

_LIT( KIconsFileName, "imageprintdata\\protocols\\upnpicons.mbm" );

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

//

// CUPnPPrintingDevice::NewL

//

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

MProtPrintingDevice* CUPnPPrintingDevice::NewL()

	{

		LOG("[CUPnPPrintingDevice]\t ConstructL");

		return new (ELeave) CUPnPPrintingDevice();

	}

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

//

// CUPnPPrintingDevice::ConstructL

//

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

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

	{

		LOG("[CUPnPPrintingDevice]\t ConstructL");

		iPrinterContainer 	= CUPPrinterContainer::NewL();

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

		iPrintFactory 	= CUPPrintFactory::NewL();

		LOG("[CUPnPPrintingDevice]\t Done.");

	}

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

//

// CUPnPPrintingDevice::~CUPnPPrintingDevice

//

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

CUPnPPrintingDevice::~CUPnPPrintingDevice()

	{

	  if (iPrinterTimer){

      iPrinterTimer->Cancel();

      delete iPrinterTimer;

    }

		if (iPrinterControl)

			delete iPrinterControl;

		if (iFbsBitmap)

			delete iFbsBitmap;

		if (iPrintingJob)

			delete iPrintingJob;

    if (iPrinterContainer)

		  delete iPrinterContainer;

    if (iPrintFactory)

      delete iPrintFactory;

    REComSession::DestroyedImplementation( iDtor_ID_Key );

	}

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

//

// CUPnPPrintingDevice::DiscoveryTimeoutCBL

//

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

TBool CUPnPPrintingDevice::DiscoveryTimeoutCBL(TAny *aWho)

	{

		CUPnPPrintingDevice *cbTarget = static_cast<CUPnPPrintingDevice*>(aWho);

		return cbTarget->DoDiscoveryTimeoutL(ETrue);

	}

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

//

// CUPnPPrintingDevice::StatusTimeoutCBL

//

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

TBool CUPnPPrintingDevice::StatusTimeoutCBL(TAny *aWho)

	{

		CUPnPPrintingDevice *cbTarget = static_cast<CUPnPPrintingDevice*>(aWho);

		TInt res = KErrNone;

		TInt err = KErrNone;

		TRAP(err, res = cbTarget->DoStatusTimeoutL());

		if(KErrNone != err)

		{

			cbTarget->FinishPrinting(KErrTimedOut, err);

			//Don't run the callback again

			res = EFalse;

		}

		return res;

	}

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

//

// CUPnPPrintingDevice::SubmitTimeoutCBL

//

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

TInt CUPnPPrintingDevice::SubmitTimeoutCBL(TAny *aWho)

	{

		CUPnPPrintingDevice *cbTarget = static_cast<CUPnPPrintingDevice*>(aWho);

		cbTarget->DoSubmitTimeoutL();

		return EFalse; // Don't run the callback again

	}

// ===============================

// From MProtPrintingDevice.

// ===============================

// General

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

//

// CUPnPPrintingDevice::Version

//

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

TVersion CUPnPPrintingDevice::Version()

	{

		LOG("[CUPnPPrintingDevice]\t Version");

		return TVersion(KVersionMajor, KVersionMinor, KVersionBuild);

	}

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

//

// CUPnPPrintingDevice::SupportedProtocols

//

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

TUint CUPnPPrintingDevice::SupportedProtocols()

	{

	return KImagePrint_PrinterProtocol_UPnP;

	}

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

//

// CUPnPPrintingDevice::RegisterIdleObserver

//

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

void CUPnPPrintingDevice::RegisterIdleObserver(MProtIdleObserver* /*aObserver*/)

{

}

// Discovery.

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

//

// CUPnPPrintingDevice::StartDiscoveryL

//

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

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

{

	LOG("[CUPnPPrintingDevice]\t StartDiscoveryL");

	iDiscoveryObserver = &aObserver;

	iPrintersFound = EFalse;

	TRAPD(err, StartDiscoveryInternalL(aProtocol))

	if(KErrNone != err)

	{

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

	}

	return;

}

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

//

// CUPnPPrintingDevice::StartDiscoveryL

//

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

void CUPnPPrintingDevice::StartDiscoveryInternalL(TUint aProtocol)

	{

		LOG("[CUPnPPrintingDevice]\t StartDiscoveryInternalL");

		if (!(aProtocol &  KImagePrint_PrinterProtocol_UPnP))

		{

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

			return;

		}

		switch ( iState )

		{

			case EUPnPDiscovery: // Already discovering

				break; 

			case EUPnPUninitialized:

			{

				LOG("[CUPnPPrintingDevice]\t starting discovery");				

				// (Re)start printer control point

				RestartControlPointL();

				// No devices available - return printers from cache and start timer

				SendPrinterListL(EFalse);				

			}

				break;

			case EUPnPJobReady:

			case EUPnPReady:

			{

				LOG("[CUPnPPrintingDevice]\t returning latest printer list");

				SendPrinterListL();

			}

				break;

			case EUPnPCancellingDiscovery:

			case EUPnPCancelling:

			case EUPnPPrintingStarted:

			case EUPnPPrinting:

			default:

			{

				LOG("[CUPnPPrintingDevice]\t cannot start discovery");

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

				break;

			}

		}

	}

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

//

// CUPnPPrintingDevice::RemoveCachedDeviceL

//

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

TInt CUPnPPrintingDevice::RemoveCachedDeviceL(TInt aDeviceID)

	{

		LOG("[CUPnPPrintingDevice::RemoveCachedDeviceL]");

		return iPrinterContainer->RemoveCachedDeviceL(aDeviceID);

	}

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

//

// CUPnPPrintingDevice::CancelDiscovery

//

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

void CUPnPPrintingDevice::CancelDiscovery(TBool aDoCallBack)

	{

		LOG("[CUPnPPrintingDevice]\t CancelDiscovery");

		if (iState == EUPnPDiscovery)

		{

			iState = EUPnPCancellingDiscovery;

			if (aDoCallBack && iDiscoveryObserver)

			{

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

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

			}

			// This needs to be trapped since this function is not named as leaving - no need to chekc the error value

			TRAP_IGNORE( DoDiscoveryTimeoutL( EFalse ) );

		}

	}

// Print

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

//

// CUPnPPrintingDevice::CreatePrintJobL

//

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

TInt CUPnPPrintingDevice::CreatePrintJobL(TInt aDeviceId, RPointerArray<TDesC>& aImages, MProtPrintEventObserver& aObserver)

	{

		LOG("[CUPnPPrintingDevice]\t CreatePrintJobL");

		iPrintEventObserver = &aObserver;

		switch ( iState )

		{

			case EUPnPReady:

			case EUPnPJobReady:

			{

				LOG("[CUPnPPrintingDevice]\t initializing job container");

				InitJobL(aDeviceId, aImages);

				return KErrNone;

			}

			case EUPnPCancelling:

			case EUPnPPrintingStarted:

			case EUPnPPrinting:

			case EUPnPCancellingDiscovery:

			case EUPnPUninitialized:

			default:

			{

				LOG("[CUPnPPrintingDevice]\t cannot create job");

				break;

			}

		}

		return KErrInvalidSequence;

	}

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

//

// CUPnPPrintingDevice::SubmitPrintJobL

//

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

void CUPnPPrintingDevice::SubmitPrintJobL()

	{

		LOG("[CUPnPPrintingDevice]\t SubmitPrintJobL");

		TInt err = KErrNone;

		switch ( iState )

		{

			case EUPnPPrintingStarted:

			case EUPnPPrinting:

				break; 	// Already printing

			case EUPnPJobReady:

			{

				LOG("[CUPnPPrintingDevice]\t submitting jobs");

				// Share jobs

				TRAP(err, iPrintingJob->ShareImagesL());

				if (err != KErrNone)

				{

					LOG1("[CUPnPPrintingDevice]\t -Sharing failed: %d", err);

					break;

				}

				LOG1("[CUPnPPrintingDevice::SubmitPrintJobL]\t start printing with state=%d", iState);

				iState = EUPnPSubmittingJob;

				TRAP(err, StartPrintingL());

				if (err != KErrNone)

					iState = EUPnPJobReady;

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

				LOG1("[CUPnPPrintingDevice::SubmitPrintJobL]\t state=%d", iState);

			}

				break;

			case EUPnPDiscovery:

			case EUPnPCancelling:

			case EUPnPCancellingDiscovery:

			case EUPnPUninitialized:

			case EUPnPReady:

			default:

			{

				LOG("[CUPnPPrintingDevice]\t Invalid sequence to submit job");

				err = KErrInvalidSequence;

			}

				break;

		}

		if(KErrNone != err)

		{

			if (iPrintEventObserver)

				iPrintEventObserver->PrintJobErrorEvent(EObexSendError, err);

			else

				User::Leave(err);

		}

	}

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

//

// CUPnPPrintingDevice::CancelPrintJob

//

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

TInt CUPnPPrintingDevice::CancelPrintJob()

	{

		LOG("[CUPnPPrintingDevice]\t CancelPrintJob");

		return DoCancelPrinting();

	}

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

//

// CUPnPPrintingDevice::ContinuePrintJobL

//

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

TInt CUPnPPrintingDevice::ContinuePrintJobL()

	{

		return KErrInvalidSequence;

	}

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

//

// CUPnPPrintingDevice::GetNumPrintPages

//

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

TInt CUPnPPrintingDevice::GetNumPrintPages()

{

	if( iPrintingJob )

		return iPrintingJob->Sheets();

	else

		return KErrInvalidSequence;

}

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

//

// CUPnPPrintingDevice::GetPrintJobStatus

//

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

TInt CUPnPPrintingDevice::GetPrintJobStatus()

	{

		if (iState == EUPnPPrinting)

			return KErrInvalidSequence;

		return KErrNone;

	}

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

//

// CUPnPPrintingDevice::GetPrinterStatus

//

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

TInt CUPnPPrintingDevice::GetPrinterStatus(TInt /*aDeviceId*/)

	{

		return KErrNone;

	}

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

//

// CUPnPPrintingDevice::GetDeviceCapabilityIDsL

//

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

TInt CUPnPPrintingDevice::GetDeviceCapabilityIDsL(TInt /*aDeviceID*/, RArray<TInt>& aCapabilityIDs)

	{

		LOG("[CUPnPPrintingDevice]\t GetDeviceCapabilityIDsL");

		if (iState == EUPnPUninitialized)

		{

			LOG("[CUPnPPrintingDevice]\t No devices discovered");

			return KErrInvalidSequence;

		}

		// Return supported settings from XHTML file factory

		iPrintFactory->GetCapabilityIDs(aCapabilityIDs);

		return KErrNone;

	}

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

//

// CUPnPPrintingDevice::GetDeviceCapabilityL

//

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

TInt CUPnPPrintingDevice::GetDeviceCapabilityL(TInt /*aDeviceID*/, TInt aCapabilityID, TPrintCapability& aCapability)

	{

		LOG("[CUPnPPrintingDevice]\t GetDeviceCapabilityL");

		if (iState == EUPnPUninitialized)

		{

			LOG("[CUPnPPrintingDevice]\t No devices discovered");

			return KErrInvalidSequence;

		}

		// Return value from XHTML-print file factory

		return iPrintFactory->GetCapability(aCapabilityID, aCapability);

	}

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

//

// CUPnPPrintingDevice::GetJobSetting

//

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

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

	{

		LOG("[CUPnPPrintingDevice]\t GetJobSetting");

		if (iState != EUPnPJobReady)

		{

			LOG("[CUPnPPrintingDevice]\t Invalid state");

			return KErrInvalidSequence;

		}

		return iPrintFactory->GetPrintSetting(aCapabilityID, aValue);

	}

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

//

// CUPnPPrintingDevice::SetJobSettingL

//

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

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

	{

		LOG("[CUPnPPrintingDevice]\t SetJobSettingL");

		if (iState != EUPnPJobReady)

		{

			LOG("[CUPnPPrintingDevice]\t Invalid state");

			return KErrInvalidSequence;

		}

		// Set setting in job container

		aAffectedCapability = aCapabilityID;

		return iPrintFactory->SetPrintSetting(aCapabilityID, aValue);

	}

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

//

// CUPnPPrintingDevice::GetNumPreviewPages

//

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

TInt CUPnPPrintingDevice::GetNumPreviewPages()

	{

		return KErrNotSupported;

	}

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

//

// CUPnPPrintingDevice::GetJobTemplateIconL

//

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

TInt CUPnPPrintingDevice::GetJobTemplateIconL(TInt /*aTemplateID*/, TInt& aFsBitmapHandle)

	{

		TInt res = KErrNone;

		if(iFbsBitmap)

			aFsBitmapHandle = iFbsBitmap->Handle();

		else

		{

			iFbsBitmap = new (ELeave) CFbsBitmap();

			TFileName iconsFileName;