diff -r 159fc2f68139 -r d59c248c9d36 ImagePrint/ImagePrintEngine/DeviceProtocols/upnpprotocolfw2/src/cupnpprintingdevice.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ImagePrint/ImagePrintEngine/DeviceProtocols/upnpprotocolfw2/src/cupnpprintingdevice.cpp Wed Sep 01 12:30:38 2010 +0100 @@ -0,0 +1,1614 @@ +/* +* 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 +#include +#include +#include +#include +#include + +#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(aWho); + return cbTarget->DoDiscoveryTimeoutL(ETrue); + } + + +//-------------------------------------------------------------------------------------------- +// +// CUPnPPrintingDevice::StatusTimeoutCBL +// +//-------------------------------------------------------------------------------------------- +TBool CUPnPPrintingDevice::StatusTimeoutCBL(TAny *aWho) + { + CUPnPPrintingDevice *cbTarget = static_cast(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(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& 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& 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& 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 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 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 if(iDiscoveryObserver) + { + iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, KErrNone, 0); + } + else + { + User::LeaveIfNull(iDiscoveryObserver); + } + 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 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 id; + iPrintingJob->GetJobId(id); + iPrinterControl->GetJobAttributesL(printer, id);*/ + } + + return ETrue; // call again +} + + + +//-------------------------------------------------------------------------------------------- +// +// CUPnPPrintingDevice::InitJobL +// +//-------------------------------------------------------------------------------------------- +void CUPnPPrintingDevice::InitJobL(TInt aDeviceId, RPointerArray& 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 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(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 (User::LeaveIfNull(iPrinterContainer->Printer(printerIndex))); + SubmitJobToPcpL(*(printer->Device()), aDeviceID); + } + else + { + User::LeaveIfNull(printer); + } + +} + +//-------------------------------------------------------------------------------------------- +// +// 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 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