diff -r 08cc4cc059d4 -r 59ea2209bb67 ImagePrint/ImagePrintEngine/DeviceProtocols/upnpprotocolfw2/src/cupnpprintingdevice.cpp --- a/ImagePrint/ImagePrintEngine/DeviceProtocols/upnpprotocolfw2/src/cupnpprintingdevice.cpp Fri Jun 11 16:24:10 2010 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1614 +0,0 @@ -/* -* 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