--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ImagePrint/ImagePrintEngine/DeviceProtocols/upnpprotocolfw2/src/cupnpprintingdevice.cpp Thu Dec 17 08:45:53 2009 +0200
@@ -0,0 +1,1606 @@
+/*
+* 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;
+ iconsFileName.Append( KDC_RESOURCE_FILES_DIR );
+ iconsFileName.Append( KIconsFileName );
+ res = iFbsBitmap->Load( iconsFileName ,EMbmUpnpiconsIcon );
+
+ if( res == KErrNone )
+ aFsBitmapHandle = iFbsBitmap->Handle();
+ else
+ {
+ aFsBitmapHandle = 0;
+ delete iFbsBitmap;
+ iFbsBitmap = NULL;
+ }
+ }
+
+ return res;
+ }
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::CreatePreviewImage
+//
+//--------------------------------------------------------------------------------------------
+TInt CUPnPPrintingDevice::CreatePreviewImage(TInt /*aPageNumber*/)
+ {
+ return KErrNotSupported;
+ }
+
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::SetNumsOfCopiesL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::SetNumsOfCopiesL( const RArray<TInt>& aNumsOfCopies, TInt& aErr )
+{
+ if(iState != EUPnPJobReady)
+ aErr = KErrInvalidSequence;
+ else
+ aErr = iPrintingJob->SetNumsOfCopies(aNumsOfCopies);
+
+ return;
+}
+
+// ==========================================================================================
+// From MPCPObserver
+// ==========================================================================================
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::CreateJobResponse
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::CreateJobResponse( CUpnpAction* aAction, TInt aErrorCode )
+{
+ LOG1("[CUPnPPrintingDevice::CreateJobResponse]\t Error: %d", aErrorCode);
+
+ if(!aAction)
+ return;
+
+ if (iState == EUPnPCancelling || iPrintingJob->SessionId() != aAction->SessionId())
+ return;
+
+ if(KErrNone != aErrorCode)
+ {
+ FinishPrinting(EObexConnectError, aErrorCode);
+ return;
+ }
+
+ ResetTimer();
+ iPrintingJob->SetJobId(aAction->ArgumentValue(KJobId()));
+
+ iState = EUPnPPrintingStarted;
+
+ TBuf8<KMaxIdLength> id;
+ iPrintingJob->GetJobId(id);
+
+ LOG("[CUPnPPrintingDevice]\t ******");
+ LOG81("[CUPnPPrintingDevice]\t -Printing started with job id: * %S", &id);
+ LOG("[CUPnPPrintingDevice]\t ******");
+
+ // Printing started - restart timer
+ StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(StatusTimeoutCBL, this) );
+}
+
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::CancelJobResponse
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::CancelJobResponse( CUpnpAction* /*aAction*/, TInt aErrorCode )
+{
+ LOG1("[CUPnPPrintingDevice::CancelJobResponse]\t Error: %d", aErrorCode);
+
+ FinishPrinting(aErrorCode, KErrNone);
+ if (iPrintEventObserver && KErrNone == aErrorCode)
+ iPrintEventObserver->PrintJobProgressEvent(EDone, iPrintingJob->Progress(), ECancelling);
+}
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::GetPrinterAttributesResponse
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::GetPrinterAttributesResponse( CUpnpAction* aAction, TInt aErrorCode )
+{
+ LOG1("[CUPnPPrintingDevice::GetPrinterAttributesResponse]\t Error: %d", aErrorCode);
+
+ if(!aAction)
+ return;
+
+ if (KErrNone != aErrorCode)
+ {
+ FinishPrinting(KErrGeneral, aErrorCode);
+ return;
+ }
+
+ // Cancel and restart timer
+ // Read printer attributes from action and update job status
+ TUPnPState state = EStateUnknown;
+ TRAPD(err, state = iPrintingJob->UpdateJobState(aAction->ArgumentValue( KPrinterState() ),
+ aAction->ArgumentValue( KPrinterStateReasons() ),
+ aAction->ArgumentValue( KJobIdList() ),
+ aAction->ArgumentValue( KJobId() ),
+ aAction->ArgumentValue( KSheetsCompleted() ) ) );
+ if(KErrNone != err)
+ {
+ FinishPrinting(KErrGeneral, err);
+ return;
+ }
+
+ UpdatePrintingStatus(state);
+}
+
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::GetJobAttributesResponse
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::GetJobAttributesResponse( CUpnpAction* aAction, TInt aErrorCode )
+{
+ LOG1("[CUPnPPrintingDevice::GetJobAttributesResponse]\t Error: %d", aErrorCode);
+
+ if (KErrNone != aErrorCode)
+ {
+ LOG1("[CUPnPPrintingDevice:.GetJobAttributesResponse]\t - GetPrinterAttributesL with error: %d", aErrorCode);
+
+ TInt err = KErrNone;
+ CUpnpDevice* printer = GetPrinter();
+ if(!printer)
+ err = KErrNoMemory;
+ else
+ TRAP(err, iPrinterControl->GetPrinterAttributesL(printer));
+
+ if(KErrNone != err)
+ FinishPrinting(KErrGeneral, err);
+
+ return;
+ }
+
+ if(!aAction)
+ return;
+
+ LOG81("[CUPnPPrintingDevice::GetJobAttributesResponse]\t sheets: ", &(aAction->ArgumentValue( KSheetsCompleted() )));
+ LOG81("[CUPnPPrintingDevice::GetJobAttributesResponse]\t name: ", &(aAction->ArgumentValue( KJobName() )));
+ LOG81("[CUPnPPrintingDevice::GetJobAttributesResponse]\t origin: ", &(aAction->ArgumentValue( KUserName() )));
+ LOG81("[CUPnPPrintingDevice::GetJobAttributesResponse]\t id: ", &(aAction->ArgumentValue( KJobId() )));
+
+ TBuf8<KMaxIdLength> id;
+ iPrintingJob->GetJobId(id);
+
+ TUPnPState state = EStateUnknown;
+ state = iPrintingJob->JobMediaSheetsCompletedUpdated(id, aAction->ArgumentValue( KSheetsCompleted() ) );
+
+ UpdatePrintingStatus(state);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::GetMarginsResponse
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::GetMarginsResponse( CUpnpAction* /*aAction*/, TInt aErrorCode )
+{
+ LOG1("[CUPnPPrintingDevice::GetMarginsResponse]\t Error: %d", aErrorCode);
+ if (KErrNone != aErrorCode)
+ {
+ FinishPrinting(KErrGeneral, aErrorCode);
+ return;
+ }
+
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::GetMediaListResponse
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::GetMediaListResponse( CUpnpAction* /*aAction*/, TInt aErrorCode )
+{
+ LOG1("[CUPnPPrintingDevice::GetMediaListResponse]\t Error: %d", aErrorCode);
+ if (KErrNone != aErrorCode)
+ {
+ FinishPrinting(KErrGeneral, aErrorCode);
+ return;
+ }
+
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::StateUpdatedResponse
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::StateUpdatedResponse( const TDesC8& /*aPrinterState*/,
+ const TDesC8& /*aPrinterStateReasons*/,
+ const TDesC8& /*aJobIdList*/,
+ const TDesC8& /*aJobEndState*/,
+ const TDesC8& /*aJobMediaSheetsCompleted*/,
+ const TDesC8& /*aJobAbortState*/,
+ const TDesC8& /*aContentCompleteList*/ )
+{
+ LOG("[CUPnPPrintingDevice::StateUpdatedResponse]\t");
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::PrinterStateUpdated
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::PrinterStateUpdated( const TDesC8& aEvent )
+{
+ // no need to check the states: we're not printing
+ if(EUPnPPrintingStarted != iState && EUPnPPrinting != iState)
+ return;
+
+ LOG81("[CUPnPPrintingDevice::PrinterStateUpdated]\t:%S",&aEvent);
+ iStatusTimeout = EFalse;
+ TUPnPState state = iPrintingJob->PrinterStateUpdated(aEvent);
+ UpdatePrintingStatus(state);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::PrinterStateReasonsUpdated
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::PrinterStateReasonsUpdated( const TDesC8& aEvent )
+{
+ // no need to check the states: we're not printing
+ if(EUPnPPrintingStarted != iState && EUPnPPrinting != iState)
+ return;
+
+ LOG81("[CUPnPPrintingDevice::PrinterStateReasonsUpdated]\t: %S",&aEvent);
+ iStatusTimeout = EFalse;
+ TUPnPState state = iPrintingJob->PrinterStateReasonsUpdated(aEvent);
+ UpdatePrintingStatus(state);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::JobIdListUpdated
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::JobIdListUpdated( const TDesC8& aEvent )
+{
+ // no need to check the states: we're not printing
+ if(EUPnPPrintingStarted != iState && EUPnPPrinting != iState)
+ return;
+
+ LOG81("[CUPnPPrintingDevice::JobIdListUpdated]\t:%S",&aEvent);
+ iStatusTimeout = EFalse;
+ TUPnPState state = iPrintingJob->JobIdListUpdated(aEvent);
+ UpdatePrintingStatus(state);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::JobEndStateUpdated
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::JobEndStateUpdated( const TDesC8& aEvent )
+{
+ // no need to check the states: we're not printing
+ if(EUPnPPrintingStarted != iState && EUPnPPrinting != iState)
+ return;
+
+ LOG81("[CUPnPPrintingDevice::JobEndStateUpdated]\t:%S",&aEvent);
+
+ TUPnPState state = EStateUnknown;
+ TRAPD(err, state = iPrintingJob->JobEndStateUpdatedL(aEvent));
+ if(KErrNone != err)
+ {
+ LOG1("[CUPnPPrintingDevice::JobEndStateUpdated]\t leaving with error %d. Continue with timer.",err);
+ return;
+ }
+
+ iStatusTimeout = EFalse;
+ UpdatePrintingStatus(state);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::JobMediaSheetsCompletedUpdated
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::JobMediaSheetsCompletedUpdated( const TDesC8& aEvent )
+{
+ // no need to check the states: we're not printing
+ if(EUPnPPrintingStarted != iState && EUPnPPrinting != iState)
+ return;
+
+ LOG81("[CUPnPPrintingDevice::JobMediaSheetsCompletedUpdated]\t:%S",&aEvent);
+ iStatusTimeout = EFalse;
+ TUPnPState state = iPrintingJob->JobMediaSheetsCompletedUpdated(aEvent);
+ UpdatePrintingStatus(state);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::ContentCompleteListUpdated
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::ContentCompleteListUpdated( const TDesC8& aEvent )
+{
+ // no need to check the states: we're not printing
+ if(EUPnPPrintingStarted != iState && EUPnPPrinting != iState)
+ return;
+
+ LOG81("[CUPnPPrintingDevice::ContentCompleteListUpdated]\t:%S",&aEvent);
+ iStatusTimeout = EFalse;
+ TUPnPState state = iPrintingJob->ContentCompleteListUpdated(aEvent);
+ UpdatePrintingStatus(state);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::JobAbortStateUpdated
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::JobAbortStateUpdated( const TDesC8& aEvent )
+{
+ // no need to check the states: we're not printing
+ if(EUPnPPrintingStarted != iState && EUPnPPrinting != iState)
+ return;
+
+ LOG81("[CUPnPPrintingDevice::JobAbortStateUpdated]\t:%S",&aEvent);
+
+ TUPnPState state = EStateUnknown;
+ TRAPD(err, state = iPrintingJob->JobAbortStateUpdatedL(aEvent));
+ if(KErrNone != err)
+ {
+ LOG1("[CUPnPPrintingDevice::JobAbortStateUpdatedL]\t leaving with error %d. Continue with timer.",err);
+ return;
+ }
+
+ iStatusTimeout = EFalse;
+ UpdatePrintingStatus(state);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::DeviceDiscoveredL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::DeviceDiscoveredL( CUpnpDevice* aDevice )
+{
+
+ LOG("[CUPnPPrintingDevice::DeviceDiscovered]\t ");
+ TInt id;
+ TInt err = KErrNone;
+
+ if(!aDevice)
+ return;
+
+ //Trap this: the iDiscoveryObserver will othervise never know about error
+ TRAP(err, iPrinterContainer->AddPrinterL(*aDevice, id));
+
+ // Inform about error and leave
+ if(KErrNone != err && KErrAlreadyExists != err)
+ {
+ if(iDiscoveryObserver && iState == EUPnPDiscovery)
+ {
+ iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, err, 0);
+ }
+ User::Leave(err);
+ }
+
+ iPrintersFound = ETrue;
+ if (iState == EUPnPUninitialized)
+ {
+ iState = EUPnPReady;
+ }
+
+ if(iState == EUPnPDiscovery && iDiscoveryObserver && KErrAlreadyExists != err)
+ {
+
+ TInt index = iPrinterContainer->PrinterIndex(id);
+ TPrinter printer = iPrinterContainer->ToTPrinter(index);
+ iDiscoveryObserver->FoundDeviceL(printer);
+ }
+
+ if (iState == EUPnPSubmittingJob)
+ {
+ // Check if the discovered printer is the one we're trying to print with
+ if (iPrintingJob->PrinterId() == id)
+ {
+ // Stop submit timer and submit job
+ ResetTimer();
+ TRAP(err, SubmitJobToPcpL(*aDevice, id) );
+
+ // If error occured inform client - leaving not necessary here
+ if (err != KErrNone)
+ {
+ if (iPrintEventObserver)
+ {
+ iPrintEventObserver->PrintJobErrorEvent(EObexConnectError, err);
+ }
+ iState = EUPnPJobReady;
+ }
+ }
+ }
+ LOG("[CUPnPPrintingDevice::DeviceDiscovered]\t -out");
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::DeviceDisappeared
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::DeviceDisappeared( CUpnpDevice* aDevice )
+{
+ LOG("[CUPnPPrintingDevice]\t DeviceDisappeared");
+ if ( aDevice )
+ {
+ // Notify protocol client if we're in discovery state
+ if(iState == EUPnPDiscovery && iDiscoveryObserver)
+ {
+ TInt index = iPrinterContainer->PrinterIndex( *aDevice );
+ if (index >= 0)
+ {
+ LOG("[CUPnPPrintingDevice]\t informing observer");
+ TPrinter printer = iPrinterContainer->ToTPrinter(index);
+
+ // Notification needs to be trapped because this is not a leaving function
+ TRAP_IGNORE(iDiscoveryObserver->RemoveDeviceL(printer));
+
+ iPrinterContainer->RemovePrinter(index);
+ }
+ }
+ else
+ {
+ LOG("[CUPnPPrintingDevice]\t saving to disappeared list");
+ // Trapped because this is not a leaving function
+ TRAP_IGNORE(iPrinterContainer->PrinterDisappeared( *aDevice ));
+ }
+ }
+ if ( iPrinterContainer->PrinterCount() < 1 )
+ {
+ iPrintersFound = EFalse;
+ }
+}
+
+
+/////////////////////////
+// Protected.
+/////////////////////////
+
+
+/////////////////////////
+// Private.
+/////////////////////////
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::CUPnPPrintingDevice
+//
+//--------------------------------------------------------------------------------------------
+CUPnPPrintingDevice::CUPnPPrintingDevice()
+ {
+ iPrinterTimer = NULL;
+ iState = EUPnPUninitialized;
+ iPrintersFound = EFalse;
+ iTriedReadCacheAndFail = EFalse;
+ ResetTimer();
+ }
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::RestartControlPointL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::RestartControlPointL()
+ {
+ if (iPrinterControl)
+ {
+ delete iPrinterControl;
+ iPrinterControl = NULL;
+ }
+
+ iFriendlyName.Copy(KUPnPUserName());
+
+ CUpnpSettings *rep = CUpnpSettings::NewL( KCRUidUPnPStack );
+ CleanupStack::PushL(rep);
+ //Get Access Point from central repository
+ TInt iapId = -1;
+ User::LeaveIfError( rep->Get( CUpnpSettings::KUPnPStackIapId, iapId ));
+
+ //Check accessPoint and leave if not ok
+ if( iapId < 0 )
+ {
+ if(iDiscoveryObserver)
+ iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, KErrAbort, 0);
+ User::Leave( KErrAbort );
+ }
+
+ CleanupStack::PopAndDestroy(rep);
+
+
+ // Create printer control point - search starts right away
+ LOG("[CUPnPPrintingDevice]\t - Printer control point");
+ iPrinterControl = CPrinterControlPoint::NewL(*this);
+ }
+
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::SendPrinterListL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::SendPrinterListL(TBool aSync)
+{
+LOG("[CUPnPPrintingDevice]\t SendPrinterListL Begin");
+ TInt err = KErrNone;
+ if (aSync)
+ {
+ // Remove disappeared devices from array
+ iPrinterContainer->SyncPrinterArray();
+ }
+
+ if (iPrinterContainer->PrinterCount() < 1 && !iTriedReadCacheAndFail)
+ {
+ // Read printer cache
+ LOG("[CUPnPPrintingDevice]\t SendPrinterListL xxx trying read cache file");
+ TRAP(err, iPrinterContainer->ReadCacheL());
+ if(KErrNone != err)
+ {
+ LOG1("[CUPnPPrintingDevice]\t SendPrinterListL xxx some error file reading %d", err);
+ if(err == KErrNotFound)
+ {
+ iPrintersFound = EFalse;
+ iTriedReadCacheAndFail = ETrue;
+ }
+ else
+ User::Leave(err);
+ }
+ else
+ {
+ LOG("[CUPnPPrintingDevice]\t SendPrinterListL xxx cachefile readed");
+ iPrintersFound = EFalse;
+ }
+
+ if(aSync)
+ {
+ RestartControlPointL();
+ }
+ }
+
+ if (iPrinterContainer->PrinterCount() > 0 && iDiscoveryObserver)
+ {
+ for (TInt i=0; i< iPrinterContainer->PrinterCount(); i++)
+ {
+ TPrinter t = iPrinterContainer->ToTPrinter(i);
+ iDiscoveryObserver->FoundDeviceL( t );
+ }
+ }
+
+ if (!iPrintersFound)
+ {
+ // start timed search
+ StartTimer(KPrinterDiscoveryTimeout, KPrinterDiscoveryTimeout, TCallBack(DiscoveryTimeoutCBL, this) );
+ iState = EUPnPDiscovery;
+ iTriedReadCacheAndFail = EFalse;
+ }
+ else
+ {
+ iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, KErrNone, 0);
+ }
+ LOG("[CUPnPPrintingDevice]\t SendPrinterListL end");
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::DoDiscoveryTimeoutL
+//
+//--------------------------------------------------------------------------------------------
+TBool CUPnPPrintingDevice::DoDiscoveryTimeoutL(TBool aDoCallBack)
+{
+ LOG("[CUPnPPrintingDevice]\t DoDiscoveryTimeOut");
+
+ ResetTimer();
+ switch( iState )
+ {
+ case EUPnPCancellingDiscovery:
+ {
+ LOG("[CUPnPPrintingDevice]\t cancelling discovery");
+
+ if (iPrinterContainer->PrinterCount() > 0)
+ {
+ iPrintersFound = ETrue;
+ }
+
+ if (aDoCallBack && iDiscoveryObserver)
+ {
+ iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, KErrNone, 0);
+ }
+
+ }
+ break;
+ case EUPnPDiscovery:
+ {
+ LOG("[CUPnPPrintingDevice]\t discovery timeout");
+
+ // Notify about cached devices, which weren't discovered
+ RPointerArray<CUPPrinter> cachedPrinters;
+ CleanupClosePushL(cachedPrinters);
+ iPrinterContainer->GetDisappearedPrinters(cachedPrinters);
+ for (TInt i=0; i < cachedPrinters.Count(); i++)
+ {
+ TPrinter printer = cachedPrinters[i]->ToTPrinter();
+ iDiscoveryObserver->RemoveDeviceL(printer);
+ }
+
+ CleanupStack::PopAndDestroy(); //cachedPrinters
+
+ // Remove disappeared printers and cached printers, which weren't found printers from container
+ iPrinterContainer->SyncPrinterArray();
+
+ if (iPrinterContainer->PrinterCount() > 0)
+ {
+ iPrintersFound = ETrue;
+ }
+
+ // Notify client's observer
+ if (aDoCallBack && iDiscoveryObserver)
+ iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, KErrNone, 0);
+
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (!iPrintersFound)
+ {
+ LOG("[CUPnPPrintingDevice]\t no printers found");
+ iState = EUPnPUninitialized;
+ }
+ else
+ {
+ iState = EUPnPReady;
+ }
+
+ //Don't run this callback again
+ return EFalse;
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::DoStatusTimeoutL
+//
+//--------------------------------------------------------------------------------------------
+TBool CUPnPPrintingDevice::DoStatusTimeoutL()
+{
+ LOG("[CUPnPPrintingDevice]\t DoStatusTimeOut");
+
+ if (iState == EUPnPCancelling || iState == EUPnPSubmittingJob)
+ {
+ // Printer did not response to cancel or create job
+ LOG("[CUPnPPrintingDevice]\t - no response for cancel or create.");
+ FinishPrinting(KErrGeneral, EPbCheckPrinter);
+ return EFalse; // do not call again
+ }
+
+ if (iState == EUPnPPrinting || iState == EUPnPPrintingStarted)
+ {
+ --iPendingCount;
+
+ // No printing status notifications received
+ CUpnpDevice* printer = GetPrinter();
+ if (!printer || iStatusTimeout || 0 > iPendingCount)
+ {
+ // print error - cancel printing
+ LOG("[CUPnPPrintingDevice]\t - print error - cancel printing.");
+ LOG1("[CUPnPPrintingDevice]\t - iStatusTimeout: %d", iStatusTimeout);
+ LOG1("[CUPnPPrintingDevice]\t - iPendingCount: %d", iPendingCount);
+ ResetTimer();
+ if (iPrintEventObserver)
+ iPrintEventObserver->PrintJobErrorEvent(KErrTimedOut, EPbCheckPrinter);
+ DoCancelPrinting();
+ return EFalse; // do not call again
+ }
+
+ iStatusTimeout = ETrue;
+
+ LOG1("[CUPnPPrintingDevice]\t - GetPrinterAttributesL with iState: %d", iState);
+ iPrinterControl->GetPrinterAttributesL(printer);
+
+ /*LOG1("[CUPnPPrintingDevice]\t - GetJobAttributesL with iState: %d", iState);
+ TBuf8<KMaxIdLength> id;
+ iPrintingJob->GetJobId(id);
+ iPrinterControl->GetJobAttributesL(printer, id);*/
+ }
+
+ return ETrue; // call again
+}
+
+
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::InitJobL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::InitJobL(TInt aDeviceId, RPointerArray<TDesC>& aImages)
+{
+ LOG("[CUPnPPrintingDevice::InitJobL]\t");
+
+ // Check that device exists
+ CUPPrinter* printer = iPrinterContainer->Printer(aDeviceId);
+ if (!printer)
+ {
+ LOG("[CUPnPPrintingDevice]\t printer not found");
+ User::Leave(KErrArgument);
+ }
+
+ // Create job
+ if (iPrintingJob)
+ {
+ delete iPrintingJob;
+ iPrintingJob = NULL;
+ }
+
+ // Change format of file list
+ RArray<TFileName> imageList;
+ CleanupClosePushL(imageList);
+ for (TInt i=0; i < aImages.Count(); i++)
+ {
+ LOG81("[InitJobL]\t ", aImages[i]);
+ imageList.Append( *(aImages[i]) );
+ }
+
+ // Create job object
+ iPrintingJob = CUPPrintingJob::NewL(printer, imageList, iPrintFactory, iFriendlyName);
+ CleanupStack::PopAndDestroy(&imageList);
+
+ // Update state and return
+ iState = EUPnPJobReady;
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::StartPrintingL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::StartPrintingL()
+{
+ LOG("[CUPnPPrintingDevice::StartPrintingL]\t");
+ ResetTimer();
+
+ // Get pointer to correct CDevice
+ CUPPrinter* upPrinter = static_cast<CUPPrinter*>(User::LeaveIfNull(
+ iPrinterContainer->Printer(iPrintingJob->PrinterId())));
+
+ CUpnpDevice* printer = upPrinter->Device();
+
+ if (!printer)
+ {
+ LOG("[CUPnPPrintingDevice]\t -UPnP Printer pointer was NULL");
+
+ // Try to discover selected printer - start timer
+ StartTimer(KPrinterSubmitTimeout, KPrinterSubmitTimeout, TCallBack(SubmitTimeoutCBL, this) );
+ return;
+ }
+
+ // Send create job to PCP
+ SubmitJobToPcpL(*printer, iPrintingJob->PrinterId());
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::DoSubmitTimeoutL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::DoSubmitTimeoutL()
+{
+ LOG("[CUPnPPrintingDevice]\t CUPnPPrintingDevice::DoSubmitTimeoutL");
+
+ ResetTimer();
+
+ TRAPD(err, SubmitJobToPcpL(iPrintingJob->PrinterId()));
+
+ if( err != KErrNone)
+ {
+ if (iPrintEventObserver)
+ iPrintEventObserver->PrintJobErrorEvent(EObexConnectError, err);
+ iState = EUPnPJobReady;
+ }
+
+}
+
+
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::SubmitJobToPcpL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::SubmitJobToPcpL(TInt aDeviceID)
+{
+ LOG("[CUPnPPrintingDevice::SubmitJobToPcpL(TInt)]\t");
+
+ // Get pointer to correct CDevice
+ CUPPrinter* printer = NULL;
+
+ TInt printerIndex = iPrinterContainer->PrinterIndex(aDeviceID);
+ if (printerIndex >= 0)
+ {
+ printer =
+ static_cast<CUPPrinter*> (User::LeaveIfNull(iPrinterContainer->Printer(printerIndex)));
+ }
+
+ SubmitJobToPcpL(*(printer->Device()), aDeviceID);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::SubmitJobToPcpL
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::SubmitJobToPcpL(CUpnpDevice& aPrinter, TInt aPrinterID)
+{
+ LOG("[CUPnPPrintingDevice::SubmitJobToPcpL(CDevice&, TInt)]\t");
+
+ // Init settings
+ TPtrC8 userName;
+ iPrintingJob->GetUserName(userName);
+
+ // Get and convert xhtml file
+ TFileName8 fileName;
+
+ LOG("[CUPnPPrintingDevice::SubmitJobToPcpL]\t -before GetPrintFileL call");
+ iPrintingJob->GetPrintFileL(fileName);
+ LOG("[CUPnPPrintingDevice::SubmitJobToPcpL]\t -after GetPrintFile call");
+
+ User::LeaveIfNull(&aPrinter);
+
+ LOG("[CUPnPPrintingDevice::SubmitJobToPcpL]\t -before CreateJobL call");
+ TInt sessionId = iPrinterControl->CreateJobL(&aPrinter, fileName, userName, KUPnPOne(), KUPnPDeviceSetting(),
+ KUPnPDeviceSetting(), KUPnPDeviceSetting(), KUPnPDeviceSetting(), KUPnPDeviceSetting(), KUPnPDeviceSetting());
+ LOG("[CUPnPPrintingDevice::SubmitJobToPcpL]\t -after CreateJobL call");
+
+ iPrintingJob->SetSessionId(sessionId);
+ iPendingCount = KPendingLimit + iPrintingJob->ImageCount();
+
+ LOG1("[CUPnPPrintingDevice]\t -Printing started successfully - timer can expire %d times", iPendingCount);
+
+ //Add printer in cache if doesn't exist
+ iPrinterContainer->UpdateCacheL(aPrinterID);
+
+ StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(StatusTimeoutCBL, this) );
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::DoCancelPrintJob()
+//
+//--------------------------------------------------------------------------------------------
+TInt CUPnPPrintingDevice::DoCancelPrinting()
+{
+ LOG("[CUPnPPrintingDevice]\t DoCancelPrinting()");
+
+ if (iState == EUPnPPrintingStarted || iState == EUPnPPrinting || iState == EUPnPSubmittingJob)
+ {
+ // Cancel printer response timer first
+ LOG("[CUPnPPrintingDevice]\t -Canceling timer");
+ ResetTimer();
+
+ // Cancel current job
+ iState = EUPnPCancelling;
+ CUpnpDevice* printer = GetPrinter();
+ if (!printer)
+ {
+ LOG("[CUPnPPrintingDevice]\t Invalid printer");
+ return KErrArgument;
+ }
+
+ TInt err;
+ TBuf8<KMaxIdLength> id;
+ iPrintingJob->GetJobId(id);
+
+ if (id.Length() >= 1)
+ {
+ LOG81("[CUPnPPrintingDevice]\t Cancel with job id %S", &id);
+ TRAP(err, iPrinterControl->CancelJobL(printer, id))
+ }
+ else
+ {
+ LOG81("[CUPnPPrintingDevice]\t Cancel with session id %S", iPrintingJob->SessionId());
+ TRAP(err, iPrinterControl->CancelJobL(iPrintingJob->SessionId()) );
+ }
+
+ if(KErrNone != err)
+ {
+ LOG1("[CUPnPPrintingDevice]\t Cancel failed with error %d -> roughly finish printing ", err);
+ FinishPrinting(KErrGeneral, err);
+ return err;
+ }
+
+ // Start timer for cancel response
+ StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(StatusTimeoutCBL, this) );
+
+ return KErrNone;
+ }
+
+ if (iState == EUPnPJobReady)
+ {
+ return KErrNone;
+ }
+
+ return KErrInvalidSequence;
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::UpdatePrintingStatus()
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::UpdatePrintingStatus(TUPnPState aJobState)
+{
+ LOG1("[CUPnPPrintingDevice::UpdatePrintingStatus]\t - JobState: %d", aJobState);
+
+ /* Printer stopped */
+ if(EPrinterStateStopped == aJobState || EStatePending == aJobState)
+ {
+ iStatusTimeout = EFalse;
+ // Finish printing if reason found. Otherwise wait timer or new message
+ if(ENoMessage != iPrintingJob->JobState()->Reason())
+ {
+ LOG1("[CUPnPPrintingDevice]\t - state NOK -> Cancel with %d", iPrintingJob->JobStateReason());
+ if (iPrintEventObserver)
+ iPrintEventObserver->PrintJobErrorEvent(KErrGeneral, iPrintingJob->JobStateReason());
+ DoCancelPrinting();
+ }
+ return;
+ }
+
+ // Job aborted
+ if(EJobStateAborted == aJobState)
+ {
+ LOG("[CUPnPPrintingDevice]\t - EJobStateAborted -> Finish");
+ FinishPrinting(KErrGeneral, iPrintingJob->JobStateReason());
+ return;
+ }
+
+ if(EStateReady == aJobState)
+ {
+ // Printing finished for current job
+ LOG("[CUPnPPrintingDevice]\t - Printing finished");
+ iPrintEventObserver->PrintJobProgressEvent(EDone, iPrintingJob->Progress(), ENoMessage);
+
+ // FinishPrinting
+ FinishPrinting();
+ return;
+ }
+
+ iPrintEventObserver->PrintJobProgressEvent(EActive, iPrintingJob->Progress(), ENoMessage);
+ iStatusTimeout = EFalse;
+ LOG("[CUPnPPrintingDevice::UpdatePrintingStatus]\t - out");
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::FinishPrinting
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::FinishPrinting()
+{
+ LOG("[CUPnPPrintingDevice::FinishPrinting]\t ");
+
+ LOG("[CUPnPPrintingDevice]\t -Reset timer");
+ ResetTimer();
+
+ LOG("[CUPnPPrintingDevice]\t -Unshare");
+ iPrintingJob->UnShareImages();
+
+ LOG("[CUPnPPrintingDevice]\t -Init ids");
+ iPrintingJob->SetJobId(KNullDesC8());
+ iPrintingJob->SetSessionId(KErrNotFound);
+ iPendingCount = KPendingLimit;
+
+ LOG("[CUPnPPrintingDevice]\t -Update state");
+ if(NULL != GetPrinter())
+ iState = EUPnPJobReady;
+ else
+ iState = EUPnPReady;
+ LOG1("[CUPnPPrintingDevice]\t FinishPrinting: state=%d", iState);
+
+
+ // Inform control point
+ // No can do if this leaves -> ignore leave
+ TRAP_IGNORE(iPrinterControl->PrintingFinishedL(GetPrinter()));
+ LOG("[CUPnPPrintingDevice::FinishPrinting]\t -out");
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::FinishPrinting
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::FinishPrinting(TInt aErrorCode, TInt aErrorMessage)
+{
+ FinishPrinting();
+
+ if (iPrintEventObserver && KErrNone != aErrorCode)
+ iPrintEventObserver->PrintJobErrorEvent(aErrorCode, aErrorMessage);
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::GetPrinter
+//
+//--------------------------------------------------------------------------------------------
+CUpnpDevice* CUPnPPrintingDevice::GetPrinter()
+{
+ LOG("[CUPnPPrintingDevice::GetPrinter]");
+
+ if(iPrintingJob)
+ {
+ CUPPrinter* uaPrinter = iPrinterContainer->Printer(iPrintingJob->PrinterId());
+ if (uaPrinter)
+ {
+ return uaPrinter->Device();
+ }
+ }
+ return NULL;
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::ResetTimer
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::ResetTimer()
+{
+ LOG("[CUPnPPrintingDevice::ResetTimer]\t");
+
+ if(iPrinterTimer)
+ iPrinterTimer->Cancel();
+ iStatusTimeout = EFalse;
+}
+
+//--------------------------------------------------------------------------------------------
+//
+// CUPnPPrintingDevice::ResetTimer
+//
+//--------------------------------------------------------------------------------------------
+void CUPnPPrintingDevice::StartTimer(TTimeIntervalMicroSeconds32 aDelay,
+ TTimeIntervalMicroSeconds32 anInterval,
+ TCallBack aCallBack)
+{
+ LOG("[CUPnPPrintingDevice::StartTimer]\t");
+
+ ResetTimer();
+
+ iPrinterTimer->Start(aDelay, anInterval, aCallBack );
+
+}
+
+// End of File