/*

* 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 CPrinterControlPoint class

*

*/

#include <f32file.h>

#include <in_sock.h>

#include <upnpservice.h>

#include <upnpdevice.h>

#include <upnpaction.h>

#include <upnphttpmessagefactory.h>

#include "cuplogger.h"

#include "cprintercontrolpoint.h"

#include "mpcpobserver.h"

// CONSTANTS

#define KMaxCancelReqs 100

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

// CPrinterControlPoint::NewL

// Two-phased constructor

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

//

EXPORT_C CPrinterControlPoint* CPrinterControlPoint::NewL(MPCPObserver& aPCPObserver)

{

	LOG("[CPrinterControlPoint] \tCPrinterControlPoint::NewL");

	CPrinterControlPoint* self = new (ELeave) CPrinterControlPoint( aPCPObserver);

	CleanupStack::PushL( self );

	self -> ConstructL( );

	CleanupStack::Pop( self );

	return self;

}

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

// CPrinterControlPoint::CPrinterControlPoint

// C++ default constructor

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

//

CPrinterControlPoint::CPrinterControlPoint( MPCPObserver& aPCPObserver)

	: CUpnpControlPoint(), iPCPObserver( aPCPObserver )

{

}

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

// CPrinterControlPoint::ConstructL

// Two-phased constructor

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

//

void CPrinterControlPoint::ConstructL()

{

	LOG("[CPrinterControlPoint] \tCPrinterControlPoint::ConstructL");

	_LIT8( KPrinter, "Printer:1" );

	// Base class ConstructL

	CUpnpControlPoint::ConstructL( KPrinter());

	// Share Xhtml folder (create if necessary)

	RFs fsSession;

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

	CleanupClosePushL( fsSession );

	TInt err = fsSession.MkDirAll( KUPnPXhtmlPath() );

	if (err != KErrNone && err != KErrAlreadyExists)

	{

		User::Leave(err);

	}

	CleanupStack::PopAndDestroy(&fsSession);

	iJobStateEvents = NULL;

	// Start printer search

	TPtrC8 device_ptr;

	device_ptr.Set( KPrinterDevice );

	SearchL( device_ptr );

}

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

// CPrinterControlPoint::~CPrinterControlPoint

// C++ default destructor

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

//

EXPORT_C CPrinterControlPoint::~CPrinterControlPoint()

{

	LOG("[CPrinterControlPoint] \tCPrinterControlPoint::~CPrinterControlPoint()");

    iCancelledJobSIDs.Close();   

    if(iJobStateEvents)

	{

		delete iJobStateEvents;

	}

}

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

// CPrinterControlPoint::CreateJobL

// Create printer job

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

//

EXPORT_C TInt CPrinterControlPoint::CreateJobL( CUpnpDevice* aPrinter, const TDesC8& aPrintFile,

                                  const TDesC8& aUserName, const TDesC8& aCopies, const TDesC8& aSides,

                                  const TDesC8& aNumberUp, const TDesC8& aOrientationRequest, const TDesC8& aMediaSize,

                                  const TDesC8& aMediaType, const TDesC8& aPrintQuality, TBool aPrintBasic )

{

	LOG("[CPrinterControlPoint] \tCPrinterControlPoint::CreateJobL");

	if(!aPrinter)

	{

		User::Leave(KErrArgument);

	}

	if(iJobStateEvents)

	{

		iJobStateEvents->InitL();

	}

	else

	{

		iJobStateEvents = CJobStateEvents::NewL();

	}

    // Set printer as authorized device

   	//  - remove the previous printer address from allowed list

  	//  - add the current printer address to allowed list

	TBuf8<20> logStr;

	CUpnpHttpMessage::AddrOutput(aPrinter->Address(), logStr);

	LOG81("[CPrinterControlPoint::CreateJobL]/t Printer address: %S", &logStr);

   	// Check services

	TPrintService serviceType;

	CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );

	if (serviceType == EServiceNone)

	{

		User::Leave(KErrNotSupported);

	}

   	if (aPrintBasic)

   	{

   		// Force to use PrintBasic:1

   		serviceType = EPrintBasic;

   	}

	// PrintBasic:1 or PrintEnhanced:1 supported

	SubscribeL( service );

	CUpnpAction* action;

   	// Create action according to service type

   	if (serviceType == EPrintEnhanced)

   	{

   		LOG("[CPrinterControlPoint] \t -PrintEnhanced:1 - CreateJobV2");

    	action = service->CreateActionLC( KCreateJobV2 );

   	}

   	else // serviceType == EPrintBasic

   	{ 

   		LOG("[CPrinterControlPoint] \t -PrintBasic:1 - CreateJob");

		  action = service->CreateActionLC( KCreateJob() );

  	}

	User::LeaveIfNull(action);

	// Common arguments for both action types

	User::LeaveIfError(action -> SetArgumentL( KJobName, aPrintFile ));

	User::LeaveIfError(action -> SetArgumentL( KUserName,  aUserName));

	User::LeaveIfError(action -> SetArgumentL( KDocFormat, KUPnPDocFormat() ));

	User::LeaveIfError(action -> SetArgumentL( KCopies, aCopies ));

	User::LeaveIfError(action -> SetArgumentL( KSides, aSides ));

	User::LeaveIfError(action -> SetArgumentL( KNumberUp, aNumberUp ));

	User::LeaveIfError(action -> SetArgumentL( KOrientationRequest, aOrientationRequest ));

	User::LeaveIfError(action -> SetArgumentL( KSize, aMediaSize ));

	User::LeaveIfError(action -> SetArgumentL( KType, aMediaType ));

	User::LeaveIfError(action -> SetArgumentL( KQuality, aPrintQuality ));

	if (serviceType == EPrintEnhanced)

	{

		// Fill in the rest arguments

		User::LeaveIfError(action->SetArgumentL( KCriticalAttributes, KNullDesC8() ));

	}

	// Send action

	SendL( action );

	// return session id

	TInt sessionId = action->SessionId();

   	CleanupStack::Pop(); // action

    return sessionId;

}

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

// CPrinterControlPoint::PrintingFinishedL

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

//

EXPORT_C void CPrinterControlPoint::PrintingFinishedL( CUpnpDevice* aPrinter )

{

	LOG("[CPrinterControlPoint::PrintingFinishedL] \t");

	// Check services

	TPrintService serviceType;

	CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );

	if (serviceType == EServiceNone)

	{

		User::Leave(KErrNotSupported);

	}

	// Service is PrintBasic:1 or PrintEnhanced:1 - Unsubscribe

	UnsubscribeL(service);

	LOG("[CPrinterControlPoint::PrintingFinishedL] \t - unsubscribed... ...deleting event");

	// init job state events

	if ( iJobStateEvents )

		{

		iJobStateEvents->InitL();

		}

    // Remove last printer address from allowed list

	LOG("[CPrinterControlPoint::PrintingFinishedL] \t - out");

}

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

// CPrinterControlPoint::CancelJobL

// Cancel printer job

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

//

EXPORT_C void CPrinterControlPoint::CancelJobL( CUpnpDevice* aPrinter,

    const TDesC8& aJobId )

{

	LOG81("[CPrinterControlPoint] \tCPrinterControlPoint::CancelJobL %S", &aJobId);

	// Check services

	TPrintService serviceType;

	CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );

	if (serviceType == EServiceNone)

	{

		User::Leave(KErrNotSupported);

	}

	// Service is PrintBasic:1 or PrintEnhanced:1

	DoCancelJobL(*service, aJobId);

}

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

// CPrinterControlPoint::CancelJobL

// Cancel printer job by session id

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

//

EXPORT_C void CPrinterControlPoint::CancelJobL( const TInt aSessionId )

{

	LOG1("[CPrinterControlPoint::CancelJobL] \t by session id %d", aSessionId);

	// Add id to cancelled jobs - nothing else to do at this point

	// Actual cancelling is done when a message with this session id and job id is received from printer

	iCancelledJobSIDs.AppendL(aSessionId);

	// If number of pending cancel request exceeds KMaxCancelReqs delete the oldest request

	if (iCancelledJobSIDs.Count() > KMaxCancelReqs)

	{

		iCancelledJobSIDs.Remove(0);

	}

}

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

// CPrinterControlPoint::GetPrinterAttributesL

//

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

//

EXPORT_C void CPrinterControlPoint::GetPrinterAttributesL( CUpnpDevice* aPrinter )

{

	LOG("[CPrinterControlPoint::GetPrinterAttributesL]");

	// Check services

	TPrintService serviceType;

	CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );

	if (serviceType == EServiceNone)

	{

		User::Leave(KErrNotSupported);

	}

	if( serviceType == EPrintBasic )

   	{

		CUpnpAction* action = service -> CreateActionLC( KGetPrinterAttr );

		User::LeaveIfNull(action);

		SendL( action );

		CleanupStack::Pop();	// action

   	}

	if( serviceType == EPrintEnhanced )

   	{

		CUpnpAction* action = service -> CreateActionLC( KGetPrinterAttrV2 );

		User::LeaveIfNull(action);

		SendL( action );

		CleanupStack::Pop();	// action

   	}

}

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

// CPrinterControlPoint::GetMarginsL

//

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

//

EXPORT_C void CPrinterControlPoint::GetMarginsL( CUpnpDevice* aPrinter, const TDesC8& aMediaSize, const TDesC8& aMediaType )

{

	LOG("[CPrinterControlPoint::GetMarginsL]");

	// Check services

	TPrintService serviceType;

	CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );

	if( serviceType == EPrintEnhanced )

   	{

		CUpnpAction* action = service -> CreateActionLC( KGetMargins );

		User::LeaveIfNull(action);

		User::LeaveIfError(action -> SetArgumentL( KSize, aMediaSize ));

		User::LeaveIfError(action -> SetArgumentL( KType,  aMediaType));

		SendL( action );

		CleanupStack::Pop();	// action

   	}

   	else

   	{

		User::Leave(KErrNotSupported);

   	}

}

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

// CPrinterControlPoint::GetMarginsL

//

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

//

EXPORT_C void CPrinterControlPoint::GetMediaListL( CUpnpDevice* aPrinter, const TDesC8& aMediaSize, const TDesC8& aMediaType )

{

	LOG("[CPrinterControlPoint::GetMediaListL]");

	// Check services

	TPrintService serviceType;

	CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );

	if( serviceType == EPrintEnhanced )

   	{

		CUpnpAction* action = service -> CreateActionLC( KGetMediaList );

		User::LeaveIfNull(action);

		User::LeaveIfError(action -> SetArgumentL( KSize, aMediaSize ));

		User::LeaveIfError(action -> SetArgumentL( KType,  aMediaType));

		SendL( action );

		CleanupStack::Pop();	// action

   	}

   	else

   	{

		User::Leave(KErrNotSupported);

   	}

}

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

// CPrinterControlPoint::GetJobAttributesL

//

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

//

EXPORT_C void CPrinterControlPoint::GetJobAttributesL( CUpnpDevice* aPrinter,

    const TDesC8& aJobId )

{

	LOG("[CPrinterControlPoint::GetJobAttributesL]");

	// Check services

	TPrintService serviceType;

	CUpnpService* service = GetServiceFromDevice( aPrinter, serviceType );

	if (serviceType == EServiceNone)

	{

		User::Leave(KErrNotSupported);

	}

	CUpnpAction* action = service -> CreateActionLC( KGetJobAttr );

	User::LeaveIfNull(action);

	User::LeaveIfError(action -> SetArgumentL( KJobId, aJobId ));

	SendL( action );

	CleanupStack::Pop();	// action

}

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

// CPrinterControlPoint::StateUpdatedL

// From ControlPoint

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

//

EXPORT_C void CPrinterControlPoint::StateUpdatedL( CUpnpService* aService )

{

	// Seven evented state variables (see PrintEnhanced:1 and PrintBasic:1 specification for details):

	// PrinterState, PrinterStateReasons, JobIdList, JobEndState,

	// JobMediaSheetsConpleted, JobAbortState and ContentCompleteList

	// JobEndState == JobId,JobName,JobOriginatingUser,

	// JobMediaSheetsConpleted,job-completion-state

	LOG("[CPrinterControlPoint::StateUpdatedL]");

	User::LeaveIfNull(aService);

	JobStateLog(aService);

	CUpnpStateVariable* prntState = aService->StateVariable( KPrinterState() );

	CUpnpStateVariable* prntStateReasons = aService->StateVariable( KPrinterStateReasons() );

	CUpnpStateVariable* jobIdList = aService->StateVariable( KJobIdList() );

	CUpnpStateVariable* jobEndState = aService->StateVariable( KJobEndState() );

	CUpnpStateVariable* sheets = aService->StateVariable( KSheetsCompleted() );

	// The next ones are supported only in PrintEnhanced:1

	CUpnpStateVariable* jobAbortState = aService->StateVariable( KJobAbortState() );

	CUpnpStateVariable* contentCompList = aService->StateVariable( KContentCompleteList() );

	if ( iJobStateEvents )

		{	

	    if( prntState )

			{

				TPtrC8 ptr = RemoveTags( prntState->Value());

		        if(iJobStateEvents->ChangedEventL(ptr, CJobStateEvents::EPrinterState))

		        	iPCPObserver.PrinterStateUpdated( ptr );

			}		    

		    if ( prntStateReasons )

			    {

					TPtrC8 ptr = RemoveTags( prntStateReasons->Value());

			        if(iJobStateEvents->ChangedEventL(ptr, CJobStateEvents::EPrinterStateReasons))

			        	iPCPObserver.PrinterStateReasonsUpdated( ptr );

			    }

		    if ( jobIdList )

			    {

					TPtrC8 ptr = RemoveTags( jobIdList->Value());

			        if(iJobStateEvents->ChangedEventL( ptr, CJobStateEvents::EJobIdList))

			        	iPCPObserver.JobIdListUpdated( ptr );

			    }

		    if ( jobEndState )

			    {

					TPtrC8 ptr = RemoveTags( jobEndState->Value());

			        if(iJobStateEvents->ChangedEventL( ptr, CJobStateEvents::EJobEndState))

			        	iPCPObserver.JobEndStateUpdated( ptr );

			    }

		    if ( sheets )

			    {

					TPtrC8 ptr = RemoveTags( sheets->Value());

			        if(iJobStateEvents->ChangedEventL(ptr, CJobStateEvents::EJobMediaSheetsCompleted))

			        	iPCPObserver.JobMediaSheetsCompletedUpdated( ptr );

			    }

		    if ( jobAbortState )

			    {

					TPtrC8 ptr = RemoveTags( jobAbortState->Value());

			        if(iJobStateEvents->ChangedEventL(ptr, CJobStateEvents::EContentCompleteList))

			        	iPCPObserver.JobAbortStateUpdated( ptr );

			    }

		    if ( contentCompList )

			    {

					TPtrC8 ptr = RemoveTags( contentCompList->Value());

			        if(iJobStateEvents->ChangedEventL( ptr, CJobStateEvents::EJobAbortState))

			        	iPCPObserver.ContentCompleteListUpdated( ptr );

			    }

		}

}

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

// CPrinterControlPoint::DeviceDiscoveredL

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

//

EXPORT_C void CPrinterControlPoint::DeviceDiscoveredL( CUpnpDevice* aDevice)

{

	LOG("[CPrinterControlPoint::DeviceDiscoveredL]");

	iPCPObserver.DeviceDiscoveredL( aDevice );

}

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

// CPrinterControlPoint::DeviceDisappearedL

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

//

EXPORT_C void CPrinterControlPoint::DeviceDisappearedL( CUpnpDevice* aDevice )

{

	LOG("[CPrinterControlPoint::DeviceDisappearedL]");

	iPCPObserver.DeviceDisappeared( aDevice );

}

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

// CPrinterControlPoint::ActionResponseReceivedL

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

//

EXPORT_C void CPrinterControlPoint::ActionResponseReceivedL( CUpnpAction* aAction )

{

	User::LeaveIfNull(aAction);

	LOG8S("[CPrinterControlPoint::ActionResponseReceivedL]\t - action: ", aAction->Name());