diff -r 159fc2f68139 -r d59c248c9d36 ImagePrint/ImagePrintEngine/DeviceProtocols/btprotocol/src/cbtprintingdevice.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ImagePrint/ImagePrintEngine/DeviceProtocols/btprotocol/src/cbtprintingdevice.cpp Wed Sep 01 12:30:38 2010 +0100 @@ -0,0 +1,1666 @@ +/* +* Copyright (c) 2004-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: +* +*/ + + +// EXTERNAL INCLUDES +#include +#include +#include +#include + +#include "cbtprintingdevice.h" +#include "printcapabilitycodes.h" +#include "printmessagecodes.h" +#include "rsutils.h" +#include "crsbtdevice.h" +#include "cbtdevicecontainer.h" +#include "clog.h" +#include "tbtmapper.h" +#include "crsbtdiscoverengine.h" + + +// CONSTANTS +namespace + { + /// Bluetooth BPP/OPP Version Major. + const static TInt KBtVersionMajor = 3; + /// Bluetooth BPP/OPP Version Minor. + const static TInt KBtVersionMinor = 0; + /// Bluetooth BPP/OPP Version Build. + const static TInt KBtVersionBuild = 1; + } + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::NewL +// +//-------------------------------------------------------------------------------------------- +MProtPrintingDevice* CBtPrintingDevice::NewL() +{ + return new (ELeave) CBtPrintingDevice(); +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CBtPrintingDevice +// +//-------------------------------------------------------------------------------------------- +CBtPrintingDevice::CBtPrintingDevice() : + CActive(CActive::EPriorityStandard), + iState( ENone ), + iPrintingJob( NULL ), + iPrinterController( NULL ), + iDeviceContainer( NULL ), + iRequestedProtocols( 0 ), + iPrintError( KErrNone ), + iPrintErrorMsgCode( 0 ), + iPendingCount(KPendingLimit), + iPrinterTimer( NULL ), + iProggress( 0 ) +{ + iDiscoveryObserver = NULL; + iPrintEventObserver = NULL; + CActiveScheduler::Add(this); +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::ConstructL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::ConstructL(const TDesC& /*aDLLPath*/) +{ + LOG("CBtPrintingDevice ****************************************************"); + LOG("[CBtPrintingDevice::ConstructL]\t begin"); + + iPrinterController = CBtPrinterController::NewL(*this); + iDeviceContainer = CBtDeviceContainer::NewL(); + iPrinterTimer = CPeriodic::NewL(CActive::EPriorityStandard); + LOG("CBtPrintingDevice::ConstructL end"); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::~CBtPrintingDevice +// +//-------------------------------------------------------------------------------------------- +CBtPrintingDevice::~CBtPrintingDevice() +{ + LOG("CBtPrintingDevice::~CBtPrintingDevice begin"); + + Deactivate(); + + if(iPrinterTimer) + { + if(iPrinterTimer->IsActive()) + iPrinterTimer->Cancel(); + delete iPrinterTimer; + } + + if(iPrinterController) + { + iPrinterController->Stop(); + delete iPrinterController; + } + + if(iPrintingJob) + delete iPrintingJob; + + if(iDeviceContainer) + delete iDeviceContainer; + + REComSession::DestroyedImplementation( iDtor_ID_Key ); + + LOG("CBtPrintingDevice::~CBtPrintingDevice end"); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::RunL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::RunL() +{ + LOG1("[CBtPrintingDevice::RunL]\t iStatus: %d", iStatus.Int()); + + if(KErrNone != iStatus.Int()) + { + User::Leave(iStatus.Int()); + } + + switch( iState ) + { + case EFinish: + FinishPrinting(iStatus.Int()); + break; + case EGetJobAttributes: + GetJobAttributesL(); + break; + case EGetPrinterState: + GetPrinterStateL(); + break; + default: + break; + } +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::RunError +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::RunError(TInt aError) +{ + LOG2("[CBtPrintingDevice::RunError]\t iStatus: %d, aError: %d", iStatus.Int(), aError); + + FinishPrinting(aError); + + return KErrNone; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::DoCancel +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::DoCancel() +{ + LOG1("[CBtPrintingDevice::DoCancel]\t iStatus: %d", iStatus.Int()); + ResetTimer(); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::Deactivate +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::Deactivate() +{ + LOG2("[CBtPrintingDevice::Deactivate]\t iStatus: %d iState %d", iStatus.Int(), iState); + ResetTimer(); + Cancel(); + iStatus = KErrNone; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::Version +// +//-------------------------------------------------------------------------------------------- +TVersion CBtPrintingDevice::Version() +{ + return TVersion(KBtVersionMajor, KBtVersionMinor, KBtVersionBuild); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::SupportedProtocols +// +//-------------------------------------------------------------------------------------------- +TUint CBtPrintingDevice::SupportedProtocols() +{ + return KImagePrint_PrinterProtocol_BPP | + KImagePrint_PrinterProtocol_OPP_Printer | + KImagePrint_PrinterProtocol_OPP_PC; +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::DiscoveryError +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::DiscoveryError(TInt aError) +{ + LOG1("[CBtPrintingDevice::DiscoveryError]\t aError: %d", aError); + if(0 < iDeviceContainer->Count()) + { + iState = EReady; + } + else + { + iState = ENone; + } + + iPrinterController->CancelDiscovery(); + Deactivate(); + + if( iDiscoveryObserver ) + { + if(KErrNone == aError)// discovery finished, update not-found cached devices + UpdateCacheList(); + + //We're not interested if the call back leaves + TRAP_IGNORE(iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, aError)); + } + + LOG("[CBtPrintingDevice::DiscoveryError]\t end"); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::StartDiscoveryL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::StartDiscoveryL(MProtDiscoveryObserver& aObserver, TUint aProtocol) +{ + LOG1("[CBtPrintingDevice::StartDiscoveryL]\t aProtocol: %d", aProtocol); + iDiscoveryObserver = &aObserver; + + // already discovering + if(EDiscovering == iState) + return; + + if((aProtocol & SupportedProtocols())) + { + iRequestedProtocols = aProtocol; + iDeviceContainer->Reset(); + iPrinterController->Stop(); + + // If GetUsedDevicesL fails, no can do. Just continue. + LOG("[CBtPrintingDevice::StartDiscoveryL]\t Get used devices"); + TInt leave; + TRAP(leave, GetUsedDevicesL() ); + LOG1("[CBtPrintingDevice::StartDiscoveryL]\t Get used devices leaves with %d", leave); + + LOG("[CBtPrintingDevice::StartDiscoveryL]\t Calling iPrinterController"); + iPrinterController->StartDiscoveryL(aProtocol); + + iState = EDiscovering; + } + else + { + LOG("CBtPrintingDevice::StartDiscoveryL NO protocol match, ending discovery..."); + if( iDiscoveryObserver ) + { + //We're not interested if the call back leaves + TRAP_IGNORE(iDiscoveryObserver->DiscoveryStatusL(EDiscoveryFinished, KErrNone)); + } + } + LOG("[CBtPrintingDevice::StartDiscoveryL]\t end"); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::RemoveCachedDeviceL +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::RemoveCachedDeviceL(TInt aDeviceID) +{ + LOG1("CBtPrintingDevice::RemoveCachedDeviceL aDeviceID: %d", aDeviceID); + + TInt err = KErrNone; + CRsBtDevice* device = FindDevice(aDeviceID); + if( device ) + { + device->SetUsed(EFalse); + iDeviceContainer->StoreL(); + } + else + { + err = KErrInvalidData; + } + + LOG1("CBtPrintingDevice::RemoveCachedDeviceL end with: %d", err); + return err; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::UpdateCacheListL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::UpdateCacheList() +{ + LOG("[CBtPrintingDevice::UpdateCacheList]\t"); + + for(TInt i = 0; i < iDeviceContainer->Count(); ++i) + { + CRsBtDevice* device = iDeviceContainer->At(i); + if(device && !device->IsJustFound()) + DeviceDisappeared(*device); + } +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CancelDiscovery +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::CancelDiscovery(TBool aDoCallBack) +{ + LOG1("[CBtPrintingDevice::CancelDiscovery]\t aDoCallBack: %d", aDoCallBack); + if(0 < iDeviceContainer->Count()) + { + iState = EReady; + } + else + { + iState = ENone; + } + iPrinterController->CancelDiscovery(); + Deactivate(); + + if( aDoCallBack && iDiscoveryObserver ) + { + //We're not interested if the call back leaves + TRAP_IGNORE(iDiscoveryObserver->DiscoveryStatusL(EDiscoveryCancelling, KErrNone)); + } + LOG("[CBtPrintingDevice::CancelDiscovery]\t end"); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CreatePrintJobL +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::CreatePrintJobL(TInt aDeviceID, RPointerArray& aImages, MProtPrintEventObserver& aObserver) +{ + LOG("[CBtPrintingDevice::CreatePrintJobL]\t begin"); + LOG2("[CBtPrintingDevice::CreatePrintJobL]\t aDeviceID: %d, aImages.Count(): %d", aDeviceID, aImages.Count()); + + iPrintEventObserver = &aObserver; + + CRsBtDevice *printer = FindDevice( aDeviceID ); + + if( printer == NULL ) + { + LOG("CBtPrintingDevice::CreatePrintJobL no device found, returning error"); + return KErrInvalidData; + } + if(iPrintingJob && + (CPrintJob::EStateSubmitted == iPrintingJob->JobState() || + CPrintJob::EStateSending == iPrintingJob->JobState() || + CPrintJob::EStatePrinting == iPrintingJob->JobState()) ) + { + LOG("[CBtPrintingDevice::CreatePrintJobL]\t Printing job already"); + return KErrInvalidSequence; + } + + iPendingCount = 0; + + GetCapabilities(*printer); + + InitJobL(printer, aImages); + + LOG("[CBtPrintingDevice::CreatePrintJobL]\t job created"); + + iPrintingJob->UpdateJobState(CPrintJob::EStateCreated); + + LOG1("[CBtPrintingDevice::CreatePrintJobL]\t end - status: %d", iState); + + return KErrNone; +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::SubmitPrintJobL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::SubmitPrintJobL() +{ + LOG("[CBtPrintingDevice::SubmitPrintJobL] begin"); + + TInt err = KErrInvalidSequence; + if( iPrintingJob && iPrintingJob->JobState() == CPrintJob::EStateCreated ) + { + // We try to find the Device specified in our list. + CRsBtDevice* device = static_cast(User::LeaveIfNull( + FindDevice(iPrintingJob->PrinterId()))); + + LOG1("[CBtPrintingDevice::SubmitPrintJobL] iPrintingJob.iPrinterID: %d", iPrintingJob->PrinterId() ); + // save used bluetooth profile + iUsedBtProfile = device->UsedProtocol(); + if( !(device->UsedProtocol() & SupportedProtocols()) ) + { + LOG("[CBtPrintingDevice::SubmitPrintJobL]\t can't select a protocol"); + err = KErrInvalidData; + } + else + { + LOG1("[CBtPrintingDevice::SubmitPrintJobL]\t Submitting to printer \"%S\"", &(device->FriendlyName())); + iState = EJobProgress; + + StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) ); + iPendingCount = 0; + iProggress = 0; + + TRAP(err, iPrinterController->CreateJobL(*device, *iPrintingJob) ); + LOG1("[CBtPrintingDevice::SubmitPrintJobL]\t CreateJobL leaves with %d", err); + if(KErrNone == err) + { + device->SetUsed(ETrue); + iDeviceContainer->StoreL(); + + if( iPrintingJob->JobState() != CPrintJob::EStateSending && + iPrintingJob->JobState() != CPrintJob::EStatePrinting ) + { + iPrintingJob->UpdateJobState(CPrintJob::EStateSubmitted); + } + + } + else + { + CreateJobResponse(KErrNotFound, err); + } + } + } + else + LOG("[CBtPrintingDevice::SubmitPrintJobL]\t ***Invalid Sequence***. Job state wrong or job not created"); + + if(KErrNone != err) + { + LOG1("[CBtPrintingDevice::SubmitPrintJobL]\t return error %d", err); + if (iPrintEventObserver) + iPrintEventObserver->PrintJobErrorEvent(err); + else + User::Leave(err); + } + LOG("[CBtPrintingDevice::SubmitPrintJobL] end"); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CancelPrintJob +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::CancelPrintJob() +{ + LOG("[CBtPrintingDevice::CancelPrintJob]\t begin"); + TInt retVal( KErrInvalidSequence ); + + LOG1("[CBtPrintingDevice::CancelPrintJob]\t iPrintingJob: %d", iPrintingJob); + + if(iPrintingJob) + { + retVal = KErrNone; + + LOG1("[CBtPrintingDevice::CancelPrintJob]\t iPrintingJob->JobState(): %d", iPrintingJob->JobState()); + if(iPrintingJob->JobState() == CPrintJob::EStateCancel) + { + LOG("[CBtPrintingDevice::CancelPrintJob]\t Already cancelling. Return."); + retVal = KErrCancel; + } + else if( iPrintingJob->JobState() == CPrintJob::EStateSubmitted || + iPrintingJob->JobState() == CPrintJob::EStateSending || + iPrintingJob->JobState() == CPrintJob::EStatePrinting ) + { + // cancel job + TInt leave; // for remove compiling errors + TRAP(leave, CancelJobL()); + if( leave == KErrDisconnected ) + { + LOG("[CBtPrintingDevice::CancelPrintJob]\t calling OPPJobRollBack..."); + OPPJobRollBack(); + } + LOG1("[CBtPrintingDevice::CancelPrintJob]\t CancelJobL() leaves with %d.", leave); + } + else + { + LOG1("[CBtPrintingDevice::CancelPrintJob]\t No print job, just cancel all (forced stop) if connections exist: %d", iPrinterController->IsConnected()); + FinishPrinting( KErrInvalidSequence ); + + } + } + + if( iPrintEventObserver ) + { + iPrintEventObserver->PrintJobProgressEvent( EDone, iPrinterController->GetPercentSent(), ECancelling ); + } + + LOG1("CBtPrintingDevice::CancelPrintJob end with: %d", retVal); + return retVal; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::OPPJobRollBack +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::OPPJobRollBack() +{ + LOG("[CBtPrintingDevice::OPPJobRollBack ]\t begin"); + + Cancel(); + TInt err = KErrNone; + iState = EFinish; + TRequestStatus* tmpStatus = &iStatus; + User::RequestComplete( tmpStatus, err ); + SetActive(); + + LOG("[CBtPrintingDevice::OPPJobRollBack ]\t end"); +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::ContinuePrintJobL +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::ContinuePrintJobL() +{ + LOG1("CBtPrintingDevice::ContinuePrintJobL returns with: %d", KErrNotSupported); + return KErrNotSupported; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetNumPrintPages +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::GetNumPrintPages() +{ + LOG("[CBtPrintingDevice::GetNumPrintPages]\t"); + + if( iPrintingJob ) + return iPrintingJob->Sheets(); + else + return KErrInvalidSequence; +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetPrintJobStatus +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::GetPrintJobStatus() +{ + LOG1("CBtPrintingDevice::GetPrintJobStatus returns with: %d", KErrNotSupported); + return KErrNotSupported; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetPrinterStatus +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::GetPrinterStatus(TInt /*aDeviceID*/) +{ + LOG1("CBtPrintingDevice::GetPrinterStatus returns with: %d", KErrNotSupported); + return KErrNotSupported; +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetDeviceCapabilityIDsL +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::GetDeviceCapabilityIDsL(TInt aDeviceID, RArray& aCapabilityIDs) +{ + LOG1("[CBtPrintingDevice::GetDeviceCapabilityIDsL]\t begins with aDeviceID: %d", aDeviceID); + + TInt err = KErrNone; + aCapabilityIDs.Reset(); + + CRsBtDevice *printer = FindDevice( aDeviceID ); + if( printer == NULL ) + { + LOG("[CBtPrintingDevice::GetDeviceCapabilityIDsL]\t no device found, returning error"); + return KErrInvalidData; + } + + GetCapabilities(*printer); + + printer->GetCapabilityIDs(aCapabilityIDs); + + LOG1("[CBtPrintingDevice::GetDeviceCapabilityIDsL]\t ends with err: %d", err); + return err; +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetDeviceCapabilityL +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::GetDeviceCapabilityL(TInt aDeviceID, TInt aCapabilityID, TPrintCapability& aCapability) +{ + LOG1("CBtPrintingDevice::GetDeviceCapabilityL begins with aDeviceID: %d", aDeviceID); + LOG1("CBtPrintingDevice::GetDeviceCapabilityL begins with aCapabilityID: %d", aCapabilityID); + + TInt err = KErrNone; + + CRsBtDevice* printer = FindDevice(aDeviceID); + if( printer ) + { + printer->GetCapability(aCapabilityID, aCapability); + } + else + { + err = KErrInvalidData; + } + LOG1("CBtPrintingDevice::GetDeviceCapabilityL ends with err: %d", err); + return err; +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetJobSetting +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::GetJobSetting(TInt aCapabilityID, TInt& aValue) +{ + LOG1("CBtPrintingDevice::GetJobSetting begins with aCapabilityID: %d", aCapabilityID); + + TInt res = KErrInvalidSequence; + aValue = KErrNotFound; + + if(iPrintingJob) + res = iPrintingJob->GetPrintSetting(aCapabilityID, aValue); + + return res; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::SetJobSettingL +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::SetJobSettingL(TInt aCapabilityID, TInt aValue, TInt& aAffectedCapability) + { + LOG1("[CBtPrintingDevice::SetJobSettingL]\t begins with aCapabilityID: %d", aCapabilityID); + LOG1("[CBtPrintingDevice::SetJobSettingL]\t begins with aValue: %d", aValue); + LOG1("[CBtPrintingDevice::SetJobSettingL]\t begins with aAffectedCapability: %d", aAffectedCapability); + + if( !iPrintingJob || iPrintingJob->JobState() == CPrintJob::EStateNone ) + { + LOG1("[CBtPrintingDevice::SetJobSettingL]\t iPrintingJob: %d || job state == EJobStateNone; return KErrInvalidSequence", iPrintingJob); + return KErrInvalidSequence; + } + + aAffectedCapability = 0; + + // Get the Target printer and capability + CRsBtDevice* printer = FindDevice( iPrintingJob->PrinterId() ); + if( printer == NULL ) + { + LOG1("[CBtPrintingDevice::SetJobSettingL]\t printer == NULL; return %d", KErrInvalidData); + return KErrInvalidData; + } + + TInt res = printer->SetDefaultCapability(aCapabilityID, aValue); + if(KErrNone == res) + { + iPrintingJob->SetPrintSetting(aCapabilityID, aValue); + aAffectedCapability = aCapabilityID; + TRAPD(err, iDeviceContainer->StoreL()); + if(KErrNone != err) + { + LOG1("[CBtPrintingDevice::SetJobSettingL]\t Storing fails: %d", err); + } + } + LOG1("[CBtPrintingDevice::SetJobSettingL]\t ends. aAffectedCapability: %d", aAffectedCapability); + return res; +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetNumPreviewPages +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::GetNumPreviewPages() +{ + LOG1("CBtPrintingDevice::GetNumPreviewPages ends with: %d", 1); + return 1; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetJobTemplateIconL +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::GetJobTemplateIconL(TInt /*aTemplateID*/, TInt& /*aFsBitmapHandle*/) +{ + return KErrNone; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CreatePreviewImage +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::CreatePreviewImage(TInt /*aPageNumber*/) +{ + return KErrNone; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CreateJobResponse +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::CreateJobResponse( TInt aJobId, TInt aErrorCode ) +{ + LOG2("[CBtPrintingDevice::CreateJobResponse]\t iState: %d, Error: %d", iState, aErrorCode); + + ResetTimer(); + + if (ECancelJob == iState) + { + LOG2("[CBtPrintingDevice::CreateJobResponse]\t wrong sequence: iState: %d, iPrintingJob->JobState(): %d", iState, iPrintingJob->JobState()); + return; + } + + if(KErrNone != aErrorCode) + { + LOG1("[CBtPrintingDevice::CreateJobResponse]\t error occured: %d. Finish.", aErrorCode); + ManagePrintingState(KErrNotFound, EBtStateAborted, EBtStateIdle, KErrNone, aErrorCode); + return; + } + + iPrintingJob->SetJobId(aJobId); + + iState = EJobProgress; + + LOG( "[CBtPrintingDevice]\t ******"); + LOG1("[CBtPrintingDevice]\t -Printing started with job id: * %2d", aJobId); + LOG( "[CBtPrintingDevice]\t ******"); + + // Printing started - restart timer + StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) ); + +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CancelJobResponse +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::CancelJobResponse(TInt aErrorCode ) +{ + LOG1("[CUPnPPrintingDevice::CancelJobResponse]\t Error: %d", aErrorCode); + ManagePrintingState(iPrintingJob->JobId(), EBtStateCancelled, EBtStateIdle, KErrNone, aErrorCode); + +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetPrinterStateResponse +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetPrinterStateResponse(TInt aState, TInt aStateReasons, + TInt aOperationStatus, TInt aDeviceId) +{ + LOG2("[CBtPrintingDevice::GetPrinterStateResponse]\t iState: %d, Error: %d", iState, aOperationStatus); + + if(EGetPrinterState != iState) + return; + + Deactivate(); + + CRsBtDevice* printer = FindDevice( aDeviceId ); + if(!printer) + { + LOG("[CBtPrintingDevice::GetPrinterStateResponse]\t panic PANIC panic: printer not found"); + return; + } + + LOG2("[CBtPrintingDevice::GetPrinterStateResponse] Printer state: %d - %d", aState, aOperationStatus); + if(KErrNone != aOperationStatus) + { + // handle operation status in ManagePrintingState as a printer state + aState = EBtStateStopped; + aStateReasons = aOperationStatus; + } + + if(EBtStateStopped == aState) + { + ManagePrintingState(KErrNotFound, EBtStateUnknown, aState, aStateReasons, aOperationStatus); + return; + } + else if (EBtStateIdle == aState) + { + // maybe we cannot touch to iState: it maybe set to somethin on purpose... + //iState = EReady; + } +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetEventResponse +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetEventResponse(TInt aJobId, TInt aJobState, TInt aPrinterState, + TInt aStateReasons, TInt aOperationStatus) +{ + LOG("[CBtPrintingDevice::GetEventResponse]\t"); + + ManagePrintingState(aJobId, aJobState, aPrinterState, aStateReasons, aOperationStatus); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetJobAttributesResponse +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetJobAttributesResponse( TInt aJobState, + const TDesC8& aJobName, + const TDesC8& /*aOriginator*/, + TInt aSheetsCompleted, + TInt aPendingJobs, + TInt aOperationStatus ) +{ + + LOG1("[CBtPrintingDevice::GetJobAttributesResponse]\t iState: %d", iState); + LOG2("[CBtPrintingDevice::GetJobAttributesResponse]\t aOperationStatus: %d / 0x%X", aOperationStatus, aOperationStatus); + LOG2("[CBtPrintingDevice::GetJobAttributesResponse]\t aJobState: %d aSheetsCompleted: %d", aJobState, aSheetsCompleted); + LOG82("[CBtPrintingDevice::GetJobAttributesResponse]\t aPendingJobs: %d aJobName: %S", aPendingJobs, &aJobName); + + if(EFinish == iState) + { + LOG("[CBtPrintingDevice::GetJobAttributesResponse]\t Finishing... return."); + return; + } + + if(KErrNone == aOperationStatus) + { + LOG("[CBtPrintingDevice::GetJobAttributesResponse]\t aOperationStatus OK"); + + if(0 < aPendingJobs) + { + LOG1("[CBtPrintingDevice::GetJobAttributesResponse]\t pending: %d", aPendingJobs); + aJobState = EBtStateWaiting; + } + else if(iPrintingJob->Sheets() == aSheetsCompleted) + { + LOG("[CBtPrintingDevice::GetJobAttributesResponse]\t Job Completed."); + aJobState = EBtStateCompleted; + + if(CPrintJob::EStateCancel == iPrintingJob->JobState()) + iPrintingJob->UpdateJobState(CPrintJob::EStatePrinting); + } + else if(KPendingLimit == iPendingCount) + { + LOG1("[CBtPrintingDevice::GetJobAttributesResponse]\t timeout. pending too long: %d", iPendingCount); + aOperationStatus = EPbCheckPrinter; + } + else if (aJobState == EBtStateStopped || aJobState == EBtStateAborted || aJobState == EBtStateUnknown || aJobState == EBtStateWaiting || aJobState == EBtStateCompleted) + { + Deactivate(); + + LOG1("[CBtPrintingDevice::GetJobAttributesResponse]\t aJobState NOK: %d. Get printer attributes", aJobState); + TRequestStatus* tmpStatus = &iStatus; + iState = EGetPrinterState; + User::RequestComplete(tmpStatus, KErrNone); + + SetActive(); + return; + } + else + { + iState = EGetJobAttributes; + aJobState = EBtStatePrinting; + } + } + + ManagePrintingState(iPrintingJob->JobId(), aJobState, EBtStatePrinting, ENoMessage, aOperationStatus); + + return; +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::FindDevice +// +//-------------------------------------------------------------------------------------------- +CRsBtDevice* CBtPrintingDevice::FindDevice(TInt aDeviceID) +{ + LOG1("[CBtPrintingDevice::FindDevice] begins with aDeviceID: %d", aDeviceID); + TInt pos = iDeviceContainer->Find(aDeviceID); + if(KErrNotFound != pos) + { + return iDeviceContainer->At(pos); + } + LOG("[CBtPrintingDevice::FindDevice] device NOT found"); + return NULL; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::SetNumsOfCopiesL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::SetNumsOfCopiesL( const RArray& aNumsOfCopies, TInt& aErr ) + { + if( !iPrintingJob || iPrintingJob->JobState() != CPrintJob::EStateCreated ) + { + aErr = KErrInvalidSequence; + return; + } + + LOG1("[CBtPrintingDevice::SetNumsOfCopiesL]\t iPrintingJob->JobState(): %d", iPrintingJob->JobState()); + + LOG2("[CBtPrintingDevice::SetNumsOfCopiesL]\t ImageCount(): %d, copies count: %d ", + iPrintingJob->ImageCount(), aNumsOfCopies.Count()); + if( iPrintingJob->ImageCount() != aNumsOfCopies.Count() ) + { + aErr = KErrInvalidData; + return; + } + + aErr = iPrintingJob->SetNumsOfCopies(aNumsOfCopies); + LOG1("CBtPrintingDevice::SetNumsOfCopiesL aErr: %d", aErr); + } + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::InitJobL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::InitJobL(CRsBtDevice *aPrinter, RPointerArray& aImages) +{ + LOG("[CBtPrintingDevice::InitJobL]"); + + if (iPrintingJob) + { + delete iPrintingJob; + iPrintingJob = NULL; + } + + // Change format of file list + RArray imageList; + CleanupClosePushL(imageList); + for (TInt i=0; i < aImages.Count(); i++) + { + LOG1("[InitJobL]\t %S", aImages[i]); + imageList.Append( *(aImages[i]) ); + } + + // Get local BT name + TBuf8<0x100> name; + GetLocalBTNameL(name); + + // Create job object + iPrintingJob = CPrintJob::NewL(aPrinter, imageList, name); + CleanupStack::PopAndDestroy(&imageList); + + RArray capabIDs; + CleanupClosePushL(capabIDs); + aPrinter ->GetCapabilityIDs(capabIDs); + + for(TInt i = 0; i < capabIDs.Count(); ++i) + { + TPrintCapability capab; + aPrinter->GetCapability(capabIDs[i], capab); + iPrintingJob->SetPrintSetting(capabIDs[i], capab.iDefaultValue); + } + CleanupStack::PopAndDestroy(&capabIDs); + +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetCapabilities +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetCapabilities(CRsBtDevice& aPrinter, TBool aForcedGet) + { + // gets printer capabilities. If cannot get, sets defaults. + LOG1("[CBtPrintingDevice::GetCapabilities] already found %d", aPrinter.CapabilityCount()); + + // Capabilities already got + if (0 < aPrinter.CapabilityCount() && !aForcedGet ) + return; + + TDeviceState tmpState = iState; + iPendingCount = 0; + StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) ); + + /*Get printer's capabilities*/ + TRAPD(leave, iPrinterController->GetCapabilitiesL(aPrinter) ); + LOG1("[CBtPrintingDevice::GetCapabilities] GetCapabilitiesL leaves with %d", leave); + + if ( ( leave == KErrNotFound && aPrinter.UsedProtocol() == KImagePrint_PrinterProtocol_BPP ) || + ( leave == KErrArgument && aPrinter.UsedProtocol() == KImagePrint_PrinterProtocol_BPP ) ) + { + LOG( "Capabilities not received from BPP Printer - Thus Force OPP ON to avoid problems "); + LOG( "This case indicates that there is possible problem in the BPP printer. "); + aPrinter.SetUsedProtocol( KImagePrint_PrinterProtocol_OPP_Printer ); + aPrinter.SetSupportedProtocols( KImagePrint_PrinterProtocol_OPP_Printer ); + iUsedBtProfile = KImagePrint_PrinterProtocol_OPP_Printer; + leave = KErrNone; + } + ResetTimer(); + iPendingCount = 0; + iState = tmpState; + + if(KErrNone != leave) + { + // cleanup connections + Cancel(); + iPrinterController->Stop(); + + RArray c; + GetDefaultCapabilities(c); + for (TInt i = 0; i < c.Count(); ++i) + { + aPrinter.AddCapability(c[i]); + } + c.Close(); + } + else + { + // store connected printer + aPrinter.SetUsed(ETrue); + // If this fails, no can do. Continue. + TRAP_IGNORE( iDeviceContainer->StoreL() ); + } + } + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetDefaultCapabilities +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetDefaultCapabilities(RArray& aCapabilities) +{ + // Layout + TPrintCapability layout; + layout.iCapabilityID = EPrintCapabLayout; + layout.iType = TPrintCapability::Enum; + layout.iDefaultValue = EPrintCapabLayout1Up; + layout.iLow = 0; + layout.iHigh = 0; + layout.iEnumCodes[0] = layout.iDefaultValue; + layout.iEnumCount = 1; + + // Quality + TPrintCapability quality; + quality.iCapabilityID = EPrintCapabQuality; + quality.iType = TPrintCapability::Enum; + quality.iDefaultValue = EPrintCapabQualityDefault; + quality.iLow = 0; + quality.iHigh = 0; + quality.iEnumCodes[0] = quality.iDefaultValue; + quality.iEnumCount = 1; + + // Paper size + TPrintCapability paper; + paper.iCapabilityID = EPrintCapabPaperSize; + paper.iType = TPrintCapability::Enum; + paper.iDefaultValue = EPrintCapabPaperSizeAuto; + paper.iLow = 0; + paper.iHigh = 0; + paper.iEnumCodes[0] = paper.iDefaultValue; + paper.iEnumCount = 1; + + aCapabilities.Append(layout); + aCapabilities.Append(quality); + aCapabilities.Append(paper); + +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::FoundDevice +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::FoundDeviceL(CRsBtDevice& aDevice) +{ + LOG2("[CBtPrintingDevice::FoundDeviceL]\t protocol: %d, DeviceId: %d", aDevice.UsedProtocol(), aDevice.DeviceId()); + + TBool inform = EFalse; + + if( aDevice.UsedProtocol() == KImagePrint_PrinterProtocol_BPP ) + { + inform = ETrue; + } + else if( aDevice.UsedProtocol() == KImagePrint_PrinterProtocol_OPP_Printer ) + { + inform = ETrue; + } + else if( aDevice.UsedProtocol() == KImagePrint_PrinterProtocol_OPP_PC ) + { + inform = ETrue; + } + else + { + // avoid lint error + inform = EFalse; + } + + + if( iDiscoveryObserver && inform) + { + TPrinter printer = aDevice.ToTPrinter(); + iDiscoveryObserver->FoundDeviceL( printer ); + LOG("[CBtPrintingDevice::FoundDeviceL] observer informed"); + } +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::AddBtDeviceL +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::AddBtDeviceL(CRsBtDevice& aDevice) +{ + + LOG("[CBtPrintingDevice::AddBtDeviceL]\t"); + + CRsBtDevice* device = NULL; + + TInt pos = iDeviceContainer->Find(aDevice); + LOG1("[CBtPrintingDevice::AddBtDeviceL]\t pos: %d", pos); + if(KErrNotFound != pos) + { + LOG("[CBtPrintingDevice::AddBtDeviceL]\t device exists"); + device = iDeviceContainer->At(pos); + // create TPrinter of old device for informing of update + TPrinter oldPrinter = device->ToTPrinter(); + + // update existing + TBool modified = device->UpdateUsedL(aDevice); + device->SetJustFound(ETrue); + + // Be sure the if updated device is updated in observer + if( iDiscoveryObserver && modified) + { + iDiscoveryObserver->RemoveDeviceL( oldPrinter ); + LOG1("[CBtPrintingDevice::FoundDeviceL] observer informed: remove \"%S\"", &oldPrinter.iDisplayName); + TPrinter printer = device->ToTPrinter(); + iDiscoveryObserver->FoundDeviceL( printer ); + LOG1("[CBtPrintingDevice::FoundDeviceL] observer informed: found \"%S\"", &printer.iDisplayName); + } + + return KErrNone; + } + + device = CRsBtDevice::NewL(aDevice); + LOG1("[CBtPrintingDevice::AddBtDeviceL]\t newDevice address: %d", (TInt)device); + + device->SetUsed(EFalse); + device->SetDisappeared(EFalse); + device->ComposeUsedProtocol(iRequestedProtocols); + + LOG1("[CBtPrintingDevice::AddBtDeviceL]\t usedProtocol: %d", device->UsedProtocol()); + + iDeviceContainer->AppendL(device); + + LOG("[CBtPrintingDevice::AddBtDeviceL]\t preparing info for observer"); + + FoundDeviceL( *device ); + return KErrNone; +} +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetUsedDevicesL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetUsedDevicesL() +{ + LOG("[CBtPrintingDevice::GetUsedDevicesL]\t"); + iDeviceContainer->RestoreL(); + + LOG1("[CBtPrintingDevice::GetUsedDevicesL]\t found %d devices.", iDeviceContainer->Count()); + for(TInt i = 0; i < iDeviceContainer->Count(); ++i) + { + iDeviceContainer->At(i)->ComposeUsedProtocol(iRequestedProtocols); + FoundDeviceL( *(iDeviceContainer->At(i)) ); + } +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::FinishPrinting +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::FinishPrinting(TInt aErrorCode) +{ + LOG("[CBtPrintingDevice::FinishPrinting]\t "); + + iState = EFinish; + + LOG("[CBtPrintingDevice::FinishPrinting]\t -Reset timer"); + Deactivate(); + + LOG("[CBtPrintingDevice::FinishPrinting]\t -Init ids"); + iPendingCount = KPendingLimit; + + // if error occures when geting capabilities, the job not created yet. + if(iPrintingJob) + { + //Cancel job. if leaves, there is no chance to cancel the job -> continue + //else return, the timeout or cancel job response will complete finish + TRAPD(leave, CancelJobL()); + if(KErrNone != leave) + LOG1("[CBtPrintingDevice::FinishPrinting]\t -CancelJobL() leaves with %d", leave); + else + return; + + iPrintingJob->UpdateJobState(CPrintJob::EStateCreated); + } + + LOG1("[CBtPrintingDevice::FinishPrinting]\t FinishPrinting: state=%d", iState); + + // Inform controller + iPrinterController->FinishPrinting(); + + if(KErrNone != aErrorCode) + { + if (iPrintEventObserver) + iPrintEventObserver->PrintJobErrorEvent(aErrorCode); + } + + iState = EReady; + LOG("[CBtPrintingDevice::FinishPrinting]\t -out"); +} + + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::DeviceDiscovered +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::DeviceDiscovered( CRsBtDevice& aDevice ) +{ + LOG("[CBtPrintingDevice::DeviceDiscovered]\t"); + TInt err; // for remove compiling errors + TRAP(err, AddBtDeviceL(aDevice)); + LOG1("[CBtPrintingDevice::DeviceDiscovered]\t Device added with leave: %d", err); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::DeviceDisappeared +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::DeviceDisappeared( CRsBtDevice& aDevice ) +{ + LOG("[CBtPrintingDevice::DeviceDisappeared]\t"); + + CRsBtDevice* device = FindDevice(aDevice.DeviceId()); + if(!device) + { + LOG("[CBtPrintingDevice::DeviceDisappeared]\t Device not found. Return."); + return; + } + + TPrinter printer = device->ToTPrinter(); + LOG1("[CBtPrintingDevice::DeviceDisappeared]\t printer.iDisplayName: %S", &(printer.iDisplayName)); + device->SetDisappeared(ETrue); + + // Ignore leave; the call back + TRAP_IGNORE(iDiscoveryObserver->RemoveDeviceL(printer)); + + LOG("[CBtPrintingDevice::DeviceDisappeared]\t end"); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::ResetTimer +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::ResetTimer() +{ + LOG("[CBtPrintingDevice::ResetTimer]\t"); + + if(iPrinterTimer) + { + if(iPrinterTimer->IsActive()) + iPrinterTimer->Cancel(); + } + iPendingCount = 0; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::StartTimer +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::StartTimer(TTimeIntervalMicroSeconds32 aDelay, + TTimeIntervalMicroSeconds32 anInterval, + TCallBack aCallBack) +{ + LOG("[CBtPrintingDevice::StartTimer]\t"); + + ResetTimer(); + + iPrinterTimer->Start(aDelay, anInterval, aCallBack); + +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::ConnectionTimeout +// +//-------------------------------------------------------------------------------------------- +TBool CBtPrintingDevice::HandleTimeout(TAny *aWho) +{ + CBtPrintingDevice *cbTarget = static_cast(aWho); + return cbTarget->DoHandleTimeout(); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::DoConnectionTimeout +// +//-------------------------------------------------------------------------------------------- +TBool CBtPrintingDevice::DoHandleTimeout() +{ + LOG1("[CBtPrintingDevice::DoHandleTimeout]\t iState: %d", iState); + + TInt err = KErrTimedOut; + if(iUsedBtProfile != KImagePrint_PrinterProtocol_OPP_Printer) + { + if(KPendingLimit > iPendingCount) + { + ++iPendingCount; + LOG1("[CBtPrintingDevice::DoHandleTimeout]\t pending: %d", iPendingCount); + + //Continue waiting... + return ETrue; + } + + // when timeout occures during printing, try anyway get printer state + if(KPendingLimit == iPendingCount && EJobProgress == iState) + { + err = KErrNone; + iState = EGetJobAttributes; + --iPendingCount; + } + } + else + { + + if(KOppPendingLimit > iPendingCount) + { + ++iPendingCount; + LOG1("[CBtPrintingDevice::DoHandleTimeout]\t opp print pending: %d", iPendingCount); + + //Continue waiting... + return ETrue; + } + + // when timeout occures during printing, try anyway get printer state + if(KOppPendingLimit == iPendingCount && EJobProgress == iState) + { + err = KErrNone; + iState = EFinish; + --iPendingCount; + } + } + + Cancel(); + + TRequestStatus* tmpStatus = &iStatus; + User::RequestComplete(tmpStatus, err); + SetActive(); + + return EFalse; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::ManagePrintingState +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::ManagePrintingState(TInt aJobId, TInt aJobState, TInt aPrinterState, + TInt aStateReasons, TInt aOperationStatus) +{ + LOG1("[CBtPrintingDevice::ManagePrintingState]\t begin: iState: %d", iState); + LOG2("[CBtPrintingDevice::ManagePrintingState]\t aOperationStatus: %d / 0x%X", aOperationStatus, aOperationStatus); + LOG2("[CBtPrintingDevice::ManagePrintingState]\t jobId: %d state: %d", aJobId, aJobState); + LOG2("[CBtPrintingDevice::ManagePrintingState]\t aPrinterState: %d aStateReasons: %d", aPrinterState, aStateReasons); + + // already stopping, cancelling or idle... No reason to continue + if( EFinish == iState || EReady == iState ) + return; + + Deactivate(); + TInt percents = 0; + + // Always inform anyway. No matter the state. + // First the error cases: + TInt err = KErrNone; + + // Set tmpState + TDeviceState tmpState = EFinish; + + if(KErrNone != aOperationStatus) + { + // if cancelling, ignore errors + if(ECancelJob == iState && KErrDisconnected == aOperationStatus) + return; + + err = aOperationStatus; + } + else if(EBtStateStopped == aPrinterState) + { + LOG("[CBtPrintingDevice::ManagePrintingState] Printer state stopped."); + if(iPrintEventObserver) + iPrintEventObserver->PrinterStatusEvent(aStateReasons, KErrNone); + + // Mustn't give error here: + // inform via PrinterStatusEvent not at FinishPrinting via PrintJobErrorEvent + err = KErrNone; + } + else + { + switch (aJobState) + { + case EBtStateUnknown: + case EBtStateStopped: + case EBtStateAborted: + err = aStateReasons; + break; + case EBtStateWaiting: + LOG("[CBtPrintingDevice::ManagePrintingState]\t Waiting. Cancel."); + // Don't care if cancel fails: no can do anyway. + CancelPrintJob(); + err = EPbStatusErrorReasonHardwarePrinterBusy; + break; + case EBtStateCompleted: + LOG("[CBtPrintingDevice::ManagePrintingState]\t Completed."); + LOG1("[CBtPrintingDevice::ManagePrintingState]\t iPrinting->JobState: %d", iPrintingJob->JobState()); + + if(CPrintJob::EStatePrinting == iPrintingJob->JobState() || + CPrintJob::EStateSending == iPrintingJob->JobState()) + { + if(iPrintEventObserver) + iPrintEventObserver->PrintJobProgressEvent(EDone, 100, ENoMessage); + } + + else + { + err = EObexSendError; + } + + iPrintingJob->UpdateJobState(CPrintJob::EStateCreated); + break; + case EBtStateCancelled: + LOG("[CBtPrintingDevice::ManagePrintingState]\t Cancelled"); + + // If Bt print is cancelled by Image Print, show error "Check status of Printer" + err = EPbStatusErrorReasonNoReason; + break; + // continue cases + case EBtStatePrinting: + iPrintingJob->UpdateJobState(CPrintJob::EStatePrinting); + percents = UpdateProggress(); + LOG1("[CBtPrintingDevice::ManagePrintingState]\t Printing proggress %d", percents); + + if(iPrintEventObserver) + iPrintEventObserver->PrintJobProgressEvent(EActive, percents, EPrinting); + + tmpState = EGetJobAttributes; + StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) ); + break; + case EBtStateSending: + iPrintingJob->UpdateJobState(CPrintJob::EStateSending); + percents = UpdateProggress(); + LOG1("[CBtPrintingDevice::ManagePrintingState]\t Sending proggress %d", percents); + + if(iPrintEventObserver) + iPrintEventObserver->PrintJobProgressEvent(EActive, percents, ECopying); + + tmpState = EJobProgress; + StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) ); + return; + default: + tmpState = iState; + break; + } + } + + iPrintError = err; + + TRequestStatus* tmpStatus = &iStatus; + iState = tmpState; + User::RequestComplete(tmpStatus, err); + + SetActive(); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetJobAttributesL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetJobAttributesL() +{ + LOG1("[CBtPrintingDevice::GetJobAttributesL]\t begin: iState: %d", iState); + + CRsBtDevice* printer = static_cast(User::LeaveIfNull( + FindDevice(iPrintingJob->PrinterId()))); + + iPrinterController->GetJobAttributesL(*printer, iPrintingJob->JobId()); + iState = EGetJobAttributes; + + LOG("[CBtPrintingDevice::GetJobAttributesL]\t out"); + StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) ); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetPrinterAttributesL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetPrinterStateL() +{ + LOG1("[CBtPrintingDevice::GetPrinterAttributesL]\t begin: iState: %d", iState); + + CRsBtDevice* printer = static_cast(User::LeaveIfNull( + FindDevice(iPrintingJob->PrinterId()))); + + iPrinterController->GetPrinterStateL(*printer); + iState = EGetPrinterState; + + LOG("[CBtPrintingDevice::GetPrinterAttributesL]\t out"); + StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) ); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CancelJobL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::CancelJobL() +{ + LOG("[CBtPrintingDevice::CancelJobL]\t begin"); + + // If not submitted, return + if( !iPrintingJob || + (CPrintJob::EStateSubmitted != iPrintingJob->JobState() && + CPrintJob::EStateSending != iPrintingJob->JobState() && + CPrintJob::EStatePrinting != iPrintingJob->JobState()) ) + User::Leave(KErrInvalidSequence); + + LOG1("[CBtPrintingDevice::CancelJobL]\t begin at iPrintingJob->JobState(): %d", iPrintingJob->JobState()); + + CRsBtDevice* printer = static_cast(User::LeaveIfNull( + FindDevice(iPrintingJob->PrinterId()))); + + iPrintingJob->UpdateJobState(CPrintJob::EStateCancel); + + iPrinterController->CancelJobL(*printer, iPrintingJob->JobId()); + iState = ECancelJob; + + TRequestStatus* tmpStatus = &iStatus; + User::RequestComplete(tmpStatus, KErrNone); + SetActive(); + + LOG("[CBtPrintingDevice::CancelJobL]\t out"); + StartTimer(KPrinterResponseTimeout, KPrinterResponseTimeout, TCallBack(HandleTimeout, this) ); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::CheckProggress +// +//-------------------------------------------------------------------------------------------- +TInt CBtPrintingDevice::UpdateProggress() +{ + TInt percents = iPrinterController->GetPercentSent(); + + if(iProggress != percents && 0 != percents) + { + iProggress = percents; + iPendingCount = 0; + } + + // don't return 100% until the job is reported to be completed. + // that way also the physical printing is included in percents. + if(95 < iProggress) + return 95; + else + return iProggress; +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::GetLocalBTNameL +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::GetLocalBTNameL(TDes8& aName) +{ + RsUtils::GetLocalBTNameL(aName); + LOG81("[CBtPrintingDevice::GetLocalBTNameL]\t GetLocalBTNameL(%S)", &aName); +} + +//-------------------------------------------------------------------------------------------- +// +// CBtPrintingDevice::OPPSendProgress +// +//-------------------------------------------------------------------------------------------- +void CBtPrintingDevice::OPPSendProgress( TInt aProgress ) + { + if(iPrintEventObserver) + { + // If sendind is finished ( Bytes sent == Job size) it's OK to remove progress bar. + if (aProgress == 100) + { + iPrintEventObserver->PrintJobProgressEvent(EDone, 100, ENoMessage); + } + else + { + // If sending is in progress update progress bar. + iPrintEventObserver->PrintJobProgressEvent(EActive, aProgress, EPrinting); + } + } + } + +// End of File