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