|
1 /* |
|
2 * Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Contains the CPBPrintingDevice class definition. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <e32std.h> |
|
20 #include <pictbridge.h> |
|
21 #include <s32file.h> |
|
22 #include <f32file.h> |
|
23 |
|
24 #include "cpbprintingdevice.h" |
|
25 #include "printcapabilitycodes.h" |
|
26 #include "printmessagecodes.h" |
|
27 #include "imageprint.h" |
|
28 #include "cpbconnect.h" |
|
29 #include "clog.h" |
|
30 |
|
31 // CONSTANTS |
|
32 namespace |
|
33 { |
|
34 const TInt KPBVersionMajor = 0; |
|
35 const TInt KPBVersionMinor = 0; |
|
36 const TInt KPBVersionBuild = 1; |
|
37 } |
|
38 |
|
39 const TInt KConfigLength = 16; |
|
40 const TInt KMaxRetry = 10; |
|
41 _LIT( KConfigInfoFile, "config.DPS"); |
|
42 |
|
43 |
|
44 MProtPrintingDevice* CPBPrintingDevice::NewL() |
|
45 { |
|
46 return new (ELeave) CPBPrintingDevice(); |
|
47 } |
|
48 |
|
49 |
|
50 CPBPrintingDevice::CPBPrintingDevice() : |
|
51 CActive( CActive::EPriorityStandard ), iState(EPBUninitialized), iDisconnectPrinter(EFalse) |
|
52 { |
|
53 CActiveScheduler::Add(this); |
|
54 } |
|
55 |
|
56 void CPBPrintingDevice::ConstructL(const TDesC& /*aDLLPath*/) |
|
57 { |
|
58 LOG("CPBPrintingDevice::ConstructL begin"); |
|
59 |
|
60 iDpsEngine = CDpsEngine::GetEngineL(); |
|
61 iConnect = CPBConnect::NewL( *iDpsEngine, *this ); |
|
62 |
|
63 iCongFileName = HBufC::NewL( iDpsEngine->DpsFolder().Length() + KConfigLength ); |
|
64 TInt k = iDpsEngine->DpsFolder().Length() + KConfigLength; |
|
65 iCongFileName->Des().Copy( iDpsEngine->DpsFolder() ); |
|
66 iCongFileName->Des().Append( KConfigInfoFile ); |
|
67 |
|
68 iCancelRetry = 0; |
|
69 |
|
70 // for Cert software to indicate that printing state and idle state |
|
71 iPrintingStateComplete = 0; |
|
72 |
|
73 iUserSelectedPaperSize = EDpsPaperSizeDefault; |
|
74 iNewJobOK = ETrue; |
|
75 |
|
76 LOG("CPBPrintingDevice::ConstructL end"); |
|
77 } |
|
78 |
|
79 |
|
80 CPBPrintingDevice::~CPBPrintingDevice() |
|
81 { |
|
82 LOG("CPBPrintingDevice::~CPBPrintingDevice begin"); |
|
83 Cancel(); |
|
84 delete iConnect; |
|
85 delete iCongFileName; |
|
86 if ( iDpsEngine ) |
|
87 { |
|
88 iDpsEngine->Delete(); |
|
89 } |
|
90 REComSession::DestroyedImplementation( iDtor_ID_Key ); |
|
91 LOG("CPBPrintingDevice::~CPBPrintingDevice end"); |
|
92 } |
|
93 |
|
94 |
|
95 TVersion CPBPrintingDevice::Version() |
|
96 { |
|
97 return TVersion(KPBVersionMajor, KPBVersionMinor, KPBVersionBuild); |
|
98 } |
|
99 |
|
100 TUint CPBPrintingDevice::SupportedProtocols() |
|
101 { |
|
102 return KImagePrint_PrinterProtocol_PictBridge; |
|
103 } |
|
104 |
|
105 void CPBPrintingDevice::StartDiscoveryL(MProtDiscoveryObserver& aObserver, TUint aProtocol) |
|
106 { |
|
107 LOG1("CPBPrintingDevice::StartDiscoveryL aProtocol: %d", aProtocol); |
|
108 iDiscoveryObserver = &aObserver; |
|
109 |
|
110 if ( IsActive() ) |
|
111 { |
|
112 LOG1("CPBPrintingDevice::StartDiscoveryL invalid state %d, cannot start discovery", iState); |
|
113 iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrInvalidSequence, 0 ); |
|
114 return; |
|
115 } |
|
116 |
|
117 if ( !( aProtocol & KImagePrint_PrinterProtocol_PictBridge ) ) |
|
118 { |
|
119 LOG("CPBPrintingDevice::StartDiscoveryL NO protocol match, ending discovery..."); |
|
120 iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNotSupported, 0 ); |
|
121 return; |
|
122 } |
|
123 |
|
124 if ( !iPrinterConnected ) |
|
125 { |
|
126 LOG("CPBPrintingDevice::StartDiscoveryL no printer connected, ending discovery"); |
|
127 iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNone, 0 ); |
|
128 return; |
|
129 } |
|
130 |
|
131 |
|
132 // clear capability map |
|
133 iCapToDps.Close(); |
|
134 |
|
135 iConfigS.iReqParam.Reset(); |
|
136 iDpsEngine->GetDpsConfigL( iConfigS.iReqParam ); |
|
137 iDpsEngine->DoDpsRequestL( &iConfigS, iStatus ); |
|
138 iState = EPBDiscovery; |
|
139 SetActive(); |
|
140 LOG("CPBPrintingDevice::StartDiscoveryL setting state to Discovery"); |
|
141 |
|
142 LOG("CPBPrintingDevice::StartDiscoveryL end"); |
|
143 } |
|
144 |
|
145 |
|
146 TInt CPBPrintingDevice::RemoveCachedDeviceL( TInt aDeviceID ) |
|
147 { |
|
148 LOG1("CPBPrintingDevice::RemoveCachedDeviceL, aDeviceID: %d", aDeviceID); |
|
149 return KErrInvalidData; |
|
150 } |
|
151 |
|
152 void CPBPrintingDevice::CancelDiscovery( TBool aDoCallBack ) |
|
153 { |
|
154 LOG2("CPBPrintingDevice::CancelDiscovery aDoCallBack %d, iState %d", aDoCallBack, iState ); |
|
155 if ( iState == EPBDiscovery ) |
|
156 { |
|
157 Cancel(); |
|
158 if ( aDoCallBack && iDiscoveryObserver ) |
|
159 { |
|
160 //We're not interested if the call back leaves |
|
161 TRAP_IGNORE( iDiscoveryObserver->DiscoveryStatusL( EDiscoveryCancelling, KErrNone, 0 ) ); |
|
162 //We're not interested if the call back leaves |
|
163 TRAP_IGNORE( iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNone, 0 ) ); |
|
164 } |
|
165 iState = EPBUninitialized; |
|
166 } |
|
167 LOG("CPBPrintingDevice::CancelDiscovery end"); |
|
168 } |
|
169 |
|
170 |
|
171 TInt CPBPrintingDevice::CreatePrintJobL(TInt aDeviceID, RPointerArray<TDesC>& aImages, MProtPrintEventObserver& aObserver) |
|
172 { |
|
173 LOG2("CPBPrintingDevice::CreatePrintJobL begin, deviceid %d imagecount %d", aDeviceID, aImages.Count()); |
|
174 iPrintEventObserver = &aObserver; |
|
175 |
|
176 if ( aDeviceID != 0 ) |
|
177 { |
|
178 LOG("CPBPrintingDevice::CreatePrintJobL invalid device"); |
|
179 return KErrArgument; |
|
180 } |
|
181 |
|
182 if ( iState != EPBReady && iState != EPBJobReady ) |
|
183 { |
|
184 LOG1("CPBPrintingDevice::CreatePrintJobL invalid state %d", iState); |
|
185 if(iDisconnectPrinter) // If printer is disconnected then return KErrDisconnected. |
|
186 return KErrDisconnected; |
|
187 else |
|
188 return KErrInvalidSequence; |
|
189 } |
|
190 |
|
191 iStart.iReqParam.Reset(); |
|
192 |
|
193 // these must be appended in same order as PBJobSettingIndex |
|
194 |
|
195 TDpsArgsInt arg; |
|
196 arg.iElement = EDpsArgPaperSize; |
|
197 arg.iContent = EDpsPaperSizeDefault; |
|
198 iStart.iReqParam.iJobConfig.Append(arg); |
|
199 |
|
200 arg.iElement = EDpsArgQuality; |
|
201 arg.iContent = EDpsPrintQualityDefault; |
|
202 iStart.iReqParam.iJobConfig.Append(arg); |
|
203 |
|
204 arg.iElement = EDpsArgLayout; |
|
205 arg.iContent = EDpsLayoutDefault; |
|
206 iStart.iReqParam.iJobConfig.Append(arg); |
|
207 |
|
208 for ( TInt i = 0; i < aImages.Count(); ++i ) |
|
209 { |
|
210 TDpsPrintInfo info; |
|
211 info.Reset(); |
|
212 const TDesC& image = *aImages[i]; |
|
213 LOG1("CPBPrintingDevice::CreatePrintJobL image %S", &image); |
|
214 info.iFile.Copy( image ); |
|
215 iStart.iReqParam.iPrintInfo.Append( info ); |
|
216 } |
|
217 |
|
218 LOG("CPBPrintingDevice::CreatePrintJobL setting state to JobReady"); |
|
219 iState = EPBJobReady; |
|
220 |
|
221 LOG("CPBPrintingDevice::CreatePrintJobL end"); |
|
222 return KErrNone; |
|
223 } |
|
224 |
|
225 void CPBPrintingDevice::SubmitPrintJobL() |
|
226 { |
|
227 LOG("CPBPrintingDevice::SubmitPrintJobL begin"); |
|
228 |
|
229 // Checking that job is ready and printer has send aStatus.iRepParam.iNewJobOk |
|
230 // Check PrinterNotify function |
|
231 if ( iState == EPBJobReady && iNewJobOK ) |
|
232 { |
|
233 iDpsEngine->DoDpsRequestL( &iStart, iStatus ); |
|
234 iState = EPBSubmittingJob; |
|
235 SetActive(); |
|
236 LOG("CPBPrintingDevice::SubmitPrintJobL setting state to SubmittingJob"); |
|
237 } |
|
238 else |
|
239 { |
|
240 LOG1("CPBPrintingDevice::SubmitPrintJobL invalid state %d", iState); |
|
241 if( iDisconnectPrinter ) |
|
242 { |
|
243 User::Leave( KErrDisconnected ); |
|
244 } |
|
245 else |
|
246 { |
|
247 // Job or printer not ready, inform user |
|
248 if( iPrintEventObserver ) |
|
249 { |
|
250 LOG("CPBPrintingDevice::SubmitPrintJobL sending EPbStatusErrorReasonHardwarePrinterBusy message to UI"); |
|
251 iPrintEventObserver->PrinterStatusEvent( EPbStatusErrorReasonHardwarePrinterBusy ); |
|
252 } |
|
253 else |
|
254 { |
|
255 LOG1("CPBPrintingDevice::SubmitPrintJobL invalid state %d", iState); |
|
256 User::Leave( KErrInvalidSequence ); |
|
257 } |
|
258 } |
|
259 |
|
260 } |
|
261 |
|
262 LOG("CPBPrintingDevice::SubmitPrintJobL end"); |
|
263 } |
|
264 |
|
265 TInt CPBPrintingDevice::CancelPrintJob() |
|
266 { |
|
267 LOG("CPBPrintingDevice::CancelPrintJob begin"); |
|
268 |
|
269 if( iCancelRetry > KMaxRetry ) |
|
270 { |
|
271 return KErrInUse; |
|
272 } |
|
273 |
|
274 if ( iState == EPBSubmittingJob || iState == EPBPrinting || iState == EPBCancelling ) |
|
275 { |
|
276 Cancel(); |
|
277 iAbort.iReqParam.iAbortStyle = EDpsAbortStyleImmediately; |
|
278 TRAPD( err, iDpsEngine->DoDpsRequestL( &iAbort, iStatus ) ); |
|
279 if ( err != KErrNone ) |
|
280 { |
|
281 LOG1("CPBPrintingDevice::CancelPrintJob FATAL, DoDpsRequestL failed %d, setting state to Uninitialized", err); |
|
282 iState = EPBUninitialized; |
|
283 return KErrGeneral; |
|
284 } |
|
285 iState = EPBCancelling; |
|
286 SetActive(); |
|
287 LOG("CPBPrintingDevice::CancelPrintJob setting state to Cancelling"); |
|
288 } |
|
289 else if ( iState == EPBJobReady ) |
|
290 { |
|
291 LOG("CPBPrintingDevice::CancelPrintJob state is JobReady so doing nothing"); |
|
292 return KErrNone; |
|
293 } |
|
294 else |
|
295 { |
|
296 LOG1("CPBPrintingDevice::CancelPrintJob invalid state %d", iState); |
|
297 return KErrInvalidSequence; |
|
298 } |
|
299 |
|
300 LOG("CPBPrintingDevice::CancelPrintJob end"); |
|
301 return KErrNone; |
|
302 } |
|
303 |
|
304 TInt CPBPrintingDevice::ContinuePrintJobL() |
|
305 { |
|
306 LOG1("CPBPrintingDevice::ContinuePrintJobL returns with: %d", KErrNotSupported); |
|
307 return KErrNotSupported; |
|
308 } |
|
309 |
|
310 TInt CPBPrintingDevice::GetNumPrintPages() |
|
311 { |
|
312 LOG("CPBPrintingDevice::GetNumPrintPages begin"); |
|
313 |
|
314 if ( iState != EPBJobReady && iState != EPBSubmittingJob && iState != EPBPrinting ) |
|
315 { |
|
316 LOG1("CPBPrintingDevice::GetNumPrintPages invalid state %d, returning 0", iState); |
|
317 return 0; |
|
318 } |
|
319 |
|
320 TInt imagesPerPage = 1; |
|
321 TDpsArgsInt& config = iStart.iReqParam.iJobConfig[EPBSettingLayout]; |
|
322 switch ( config.iContent ) |
|
323 { |
|
324 case EDpsLayout2Up: |
|
325 imagesPerPage = 2; |
|
326 break; |
|
327 case EDpsLayout4Up: |
|
328 imagesPerPage = 4; |
|
329 break; |
|
330 case EDpsLayout6Up: |
|
331 imagesPerPage = 6; |
|
332 break; |
|
333 case EDpsLayout9Up: |
|
334 imagesPerPage = 9; |
|
335 break; |
|
336 default: |
|
337 break; |
|
338 } |
|
339 |
|
340 TInt numPrintPages = (iStart.iReqParam.iPrintInfo.Count() + imagesPerPage - 1) / imagesPerPage; |
|
341 LOG1("CPBPrintingDevice::GetNumPrintPages end, result %d", numPrintPages); |
|
342 return numPrintPages; |
|
343 } |
|
344 |
|
345 TInt CPBPrintingDevice::GetPrintJobStatus() |
|
346 { |
|
347 LOG1("CPBPrintingDevice::GetPrintJobStatus returns with: %d", KErrNotSupported); |
|
348 return KErrNotSupported; |
|
349 } |
|
350 |
|
351 TInt CPBPrintingDevice::GetPrinterStatus(TInt /*aDeviceID*/) |
|
352 { |
|
353 LOG1("CPBPrintingDevice::GetPrinterStatus returns with: %d", KErrNotSupported); |
|
354 return KErrNotSupported; |
|
355 } |
|
356 |
|
357 TInt CPBPrintingDevice::GetDeviceCapabilityIDsL(TInt aDeviceID, RArray<TInt>& aCapabilityIDs) |
|
358 { |
|
359 LOG1("CPBPrintingDevice::GetDeviceCapabilityIDsL begins with aDeviceID: %d", aDeviceID); |
|
360 |
|
361 if ( aDeviceID != 0 ) |
|
362 { |
|
363 LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid device"); |
|
364 return KErrArgument; |
|
365 } |
|
366 |
|
367 if ( iState != EPBReady && iState != EPBJobReady ) |
|
368 { |
|
369 LOG1("CPBPrintingDevice::GetDeviceCapabilityL invalid state %d", iState); |
|
370 return KErrInvalidSequence; |
|
371 } |
|
372 |
|
373 aCapabilityIDs.Append( EPrintCapabLayout ); |
|
374 aCapabilityIDs.Append( EPrintCapabQuality ); |
|
375 aCapabilityIDs.Append( EPrintCapabPaperSize ); |
|
376 |
|
377 LOG("CPBPrintingDevice::GetDeviceCapabilityIDsL end"); |
|
378 return KErrNone; |
|
379 } |
|
380 |
|
381 TInt CPBPrintingDevice::GetDeviceCapabilityL(TInt aDeviceID, TInt aCapabilityID, TPrintCapability& aCapability) |
|
382 { |
|
383 LOG2("CPBPrintingDevice::GetDeviceCapabilityL begins with aDeviceID %d, aCapabilityID %d", aDeviceID, aCapabilityID); |
|
384 |
|
385 if ( aDeviceID != 0 ) |
|
386 { |
|
387 LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid device"); |
|
388 return KErrArgument; |
|
389 } |
|
390 |
|
391 if ( iState != EPBReady && iState != EPBJobReady ) |
|
392 { |
|
393 LOG1("CPBPrintingDevice::GetDeviceCapabilityL invalid state %d", iState); |
|
394 return KErrInvalidSequence; |
|
395 } |
|
396 |
|
397 if ( aCapabilityID == EPrintCapabPaperSize ) |
|
398 { |
|
399 // paper sizes |
|
400 iCap.iRepParam.Reset(); |
|
401 iCap.iReqParam.iCap = EDpsArgPaperSizes; |
|
402 iDpsEngine->DoDpsRequestL(&iCap, iStatus); |
|
403 SetActive(); |
|
404 iWait.Start(); |
|
405 HandlePapersizesResponseL( aCapability ); |
|
406 |
|
407 if ( !aCapability.iEnumCount ) |
|
408 { |
|
409 LOG("CPBPrintingDevice::GetDeviceCapabilityL paper sizes not supported, set to default"); |
|
410 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeAuto; |
|
411 iCapToDps.InsertL( EPrintCapabPaperSizeAuto, EDpsPaperSizeDefault ); |
|
412 } |
|
413 } |
|
414 else if ( aCapabilityID == EPrintCapabQuality ) |
|
415 { |
|
416 // qualities |
|
417 LOG("CPBPrintingDevice::GetDeviceCapabilityL qualities"); |
|
418 iCap.iRepParam.Reset(); |
|
419 iCap.iReqParam.iCap = EDpsArgQualities; |
|
420 iDpsEngine->DoDpsRequestL( &iCap, iStatus ); |
|
421 SetActive(); |
|
422 iWait.Start(); |
|
423 HandleQualitiesResponseL( aCapability ); |
|
424 } |
|
425 else if ( aCapabilityID == EPrintCapabLayout ) |
|
426 { |
|
427 // layouts |
|
428 LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts"); |
|
429 iCap.iRepParam.Reset(); |
|
430 iCap.iReqParam.iCap = EDpsArgLayouts; |
|
431 iCap.iReqParam.iAttribute = iUserSelectedPaperSize; |
|
432 LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts dodpsrequest"); |
|
433 iDpsEngine->DoDpsRequestL(&iCap, iStatus); |
|
434 SetActive(); |
|
435 LOG("CPBPrintingDevice::GetDeviceCapabilityL layouts wait"); |
|
436 iWait.Start(); |
|
437 HandleLayoutsResponseL( aCapability ); |
|
438 } |
|
439 else |
|
440 { |
|
441 LOG("CPBPrintingDevice::GetDeviceCapabilityL invalid capabilityID"); |
|
442 return KErrArgument; |
|
443 } |
|
444 |
|
445 LOG1("CPBPrintingDevice::GetDeviceCapabilityL iCapToDps count %d", iCapToDps.Count()); |
|
446 |
|
447 LOG("CPBPrintingDevice::GetDeviceCapabilityL end"); |
|
448 return KErrNone; |
|
449 } |
|
450 |
|
451 TInt CPBPrintingDevice::GetJobSetting(TInt aCapabilityID, TInt& aValue) |
|
452 { |
|
453 LOG1("CPBPrintingDevice::GetJobSetting begin, aCapabilityID %d", aCapabilityID); |
|
454 |
|
455 TInt err = KErrNone; |
|
456 if ( iState != EPBJobReady ) |
|
457 { |
|
458 LOG1("CPBPrintingDevice::GetJobSetting invalid state %d", iState); |
|
459 err = KErrInvalidSequence; |
|
460 } |
|
461 else if ( aCapabilityID == EPrintCapabPaperSize ) |
|
462 { |
|
463 err = GetPapersizeJobSetting( aValue ); |
|
464 } |
|
465 else if ( aCapabilityID == EPrintCapabQuality ) |
|
466 { |
|
467 err = GetQualityJobSetting( aValue ); |
|
468 } |
|
469 else if ( aCapabilityID == EPrintCapabLayout ) |
|
470 { |
|
471 err = GetLayoutJobSetting( aValue ); |
|
472 } |
|
473 else |
|
474 { |
|
475 LOG("CPBPrintingDevice::GetJobSetting invalid capabilityID"); |
|
476 err = KErrArgument; |
|
477 } |
|
478 |
|
479 LOG2("CPBPrintingDevice::GetJobSetting end, return code %d value %d", err, aValue); |
|
480 return err; |
|
481 } |
|
482 |
|
483 TInt CPBPrintingDevice::SetJobSettingL(TInt aCapabilityID, TInt aValue, TInt& aAffectedCapability) |
|
484 { |
|
485 LOG2("CPBPrintingDevice::SetJobSettingL begin, aCapabilityID %d aValue %d", aCapabilityID, aValue); |
|
486 |
|
487 aAffectedCapability = aCapabilityID; |
|
488 |
|
489 RArray<TDpsArgsInt>& config = iStart.iReqParam.iJobConfig; |
|
490 TInt err = KErrNone; |
|
491 if ( iState != EPBJobReady ) |
|
492 { |
|
493 LOG1("CPBPrintingDevice::SetJobSettingL invalid state %d", iState); |
|
494 err = KErrInvalidSequence; |
|
495 } |
|
496 else if ( aCapabilityID == EPrintCapabPaperSize ) |
|
497 { |
|
498 TInt* dpsValue = iCapToDps.Find( aValue ); |
|
499 if ( dpsValue ) |
|
500 { |
|
501 config[EPBSettingPaperSize].iContent = *dpsValue; |
|
502 |
|
503 // for CertSW: needs layouts for particular paper sizes |
|
504 iUserSelectedPaperSize = config[EPBSettingPaperSize].iContent; |
|
505 } |
|
506 else |
|
507 { |
|
508 LOG("CPBPrintingDevice::SetJobSettingL invalid value"); |
|
509 err = KErrInvalidData; |
|
510 } |
|
511 } |
|
512 else if ( aCapabilityID == EPrintCapabQuality ) |
|
513 { |
|
514 TInt* dpsValue = iCapToDps.Find( aValue ); |
|
515 if ( dpsValue ) |
|
516 { |
|
517 config[EPBSettingQuality].iContent = *dpsValue; |
|
518 } |
|
519 else |
|
520 { |
|
521 LOG("CPBPrintingDevice::SetJobSettingL invalid value"); |
|
522 err = KErrInvalidData; |
|
523 } |
|
524 } |
|
525 else if ( aCapabilityID == EPrintCapabLayout ) |
|
526 { |
|
527 TInt* dpsValue = iCapToDps.Find( aValue ); |
|
528 if ( dpsValue ) |
|
529 { |
|
530 config[EPBSettingLayout].iContent = *dpsValue; |
|
531 } |
|
532 else |
|
533 { |
|
534 LOG("CPBPrintingDevice::SetJobSettingL invalid value"); |
|
535 err = KErrInvalidData; |
|
536 } |
|
537 } |
|
538 else |
|
539 { |
|
540 LOG("CPBPrintingDevice::SetJobSettingL invalid capabilityID"); |
|
541 err = KErrArgument; |
|
542 } |
|
543 |
|
544 LOG1("CPBPrintingDevice::SetJobSettingL end, return code %d", err); |
|
545 return err; |
|
546 } |
|
547 |
|
548 |
|
549 TInt CPBPrintingDevice::GetNumPreviewPages() |
|
550 { |
|
551 LOG1("CPBPrintingDevice::GetNumPreviewPages ends with: %d", 1); |
|
552 return 1; |
|
553 } |
|
554 |
|
555 TInt CPBPrintingDevice::GetJobTemplateIconL( TInt /*aTemplateID*/, TInt& /*aFsBitmapHandle*/ ) |
|
556 { |
|
557 return KErrNone; |
|
558 } |
|
559 |
|
560 |
|
561 TInt CPBPrintingDevice::CreatePreviewImage(TInt /*aPageNumber*/) |
|
562 { |
|
563 return KErrNotSupported; |
|
564 } |
|
565 |
|
566 void CPBPrintingDevice::RegisterIdleObserver( MProtIdleObserver *aObserver ) |
|
567 { |
|
568 iIdleObserver = aObserver; |
|
569 } |
|
570 |
|
571 void CPBPrintingDevice::DoCancel() |
|
572 { |
|
573 iDpsEngine->CancelDpsRequest(); |
|
574 if ( iWait.IsStarted() ) |
|
575 { |
|
576 LOG("CPBPritingDevice::DoCancel() calling iWait.AsyncStop()"); |
|
577 iWait.AsyncStop(); |
|
578 } |
|
579 } |
|
580 |
|
581 void CPBPrintingDevice::RunL() |
|
582 { |
|
583 LOG2("CPBPrintingDevice::RunL begin, status %d state %d", iStatus.Int(), iState); |
|
584 |
|
585 if ( iWait.IsStarted() ) |
|
586 { |
|
587 LOG("CPBPrintingDevice::RunL calling iWait.AsyncStop() and returning"); |
|
588 iWait.AsyncStop(); |
|
589 return; |
|
590 } |
|
591 |
|
592 if ( iStatus.Int() == KErrNone ) // everything ok |
|
593 { |
|
594 switch( iState ) |
|
595 { |
|
596 case EPBDiscovery: |
|
597 { |
|
598 iPrinter.iPrinterID = 0; |
|
599 iPrinter.iProtocol = KImagePrint_PrinterProtocol_PictBridge; |
|
600 iPrinter.iProperties = 0; |
|
601 |
|
602 if( iConfigS.iResult.iMajorCode == EDpsResultOk ) |
|
603 { |
|
604 iPrinter.iVendor = TPrinter::EVendorNone; |
|
605 |
|
606 HBufC* buf = HBufC::NewLC( iConfigS.iRepParam.iProductName.Length() ); |
|
607 TPtr p = buf->Des(); |
|
608 p.Copy( iConfigS.iRepParam.iProductName ); |
|
609 if ( p.Length() > 84 ) |
|
610 { |
|
611 TPtrC p2 = p.Left( 84 ); |
|
612 iPrinter.iDisplayName = p2; |
|
613 } |
|
614 else |
|
615 { |
|
616 iPrinter.iDisplayName = p; |
|
617 } |
|
618 |
|
619 CleanupStack::PopAndDestroy( buf ); |
|
620 LOG1("CPBPrinterDevice::RunL config displayname %S", &iPrinter.iDisplayName); |
|
621 |
|
622 // Config info have to be saved in file, because it can retrieved only once |
|
623 // when cable is plugged in the device |
|
624 SaveConfigInfoL(); |
|
625 } |
|
626 |
|
627 if( iConfigS.iResult.iMajorCode == EDpsResultNotExecuted ) |
|
628 { |
|
629 // Read info from file |
|
630 ReadConfigInfoL(); |
|
631 } |
|
632 |
|
633 iDiscoveryObserver->FoundDeviceL( iPrinter ); |
|
634 iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNone, 0 ); |
|
635 iState = EPBReady; |
|
636 |
|
637 // Close Dps request to avoid -14 error |
|
638 iDpsEngine->CancelDpsRequest(); |
|
639 iDpsEngine->CancelDpsEventNotify(); |
|
640 |
|
641 LOG("CPBPrintingDevice::RunL setting state to Ready"); |
|
642 break; |
|
643 } |
|
644 case EPBSubmittingJob: |
|
645 LOG2("CPBPrintingDevice::RunL submittingjob result major 0x%x minor 0x%x", iStart.iResult.iMajorCode, iStart.iResult.iMinorCode); |
|
646 if ( iStart.iResult.iMajorCode == EDpsResultOk ) |
|
647 { |
|
648 LOG("CPBPrintingDevice::RunL setting state to Printing"); |
|
649 iState = EPBPrinting; |
|
650 |
|
651 // for Cert software remove dialog from UI |
|
652 iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage ); |
|
653 } |
|
654 else |
|
655 { |
|
656 LOG("CPBPrintingDevice::RunL error occurred, setting state to JobReady"); |
|
657 iState = EPBJobReady; |
|
658 if ( iPrintEventObserver ) |
|
659 { |
|
660 TPrintMessageCodes err = EPbStatusErrorReasonNoReason; |
|
661 if ( iStart.iResult.iMajorCode == EDpsResultNotSupported && |
|
662 iStart.iResult.iMinorCode == EDpsResultMissingParam ) |
|
663 { |
|
664 // image file is probably missing |
|
665 err = EPbFileNotFound; |
|
666 } |
|
667 iPrintEventObserver->PrinterStatusEvent( err ); |
|
668 iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ECancelling ); |
|
669 } |
|
670 } |
|
671 break; |
|
672 case EPBCancelling: |
|
673 LOG2("CPBPrintingDevice::RunL cancelling result major 0x%x minor 0x%x", iAbort.iResult.iMajorCode, iAbort.iResult.iMinorCode); |
|
674 |
|
675 if( iAbort.iResult.iMajorCode == EDpsResultNotExecuted ) |
|
676 { |
|
677 iCancelRetry++; |
|
678 CancelPrintJob(); |
|
679 } |
|
680 |
|
681 if( iAbort.iResult.iMajorCode == EDpsResultOk ) |
|
682 { |
|
683 if ( iPrintEventObserver ) |
|
684 { |
|
685 iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ECancelling ); |
|
686 } |
|
687 |
|
688 LOG("CPBPrintingDevice::RunL setting state to JobReady"); |
|
689 iState = EPBJobReady; |
|
690 iCancelRetry = 0; |
|
691 } |
|
692 break; |
|
693 default: |
|
694 LOG1("CPBPrintingDevice::RunL unrecognized state %d", iState); |
|
695 break; |
|
696 } |
|
697 } |
|
698 else // iStatus != KErrNone -> Handle error here |
|
699 { |
|
700 switch( iStatus.Int() ) |
|
701 { |
|
702 case KErrTimedOut: |
|
703 LOG( "CPBPrintingDevice::RunL KErrTimedOut" ); |
|
704 if ( iPrintEventObserver ) |
|
705 { |
|
706 LOG("CPBPrintingDevice::Timeout, finish printing..."); |
|
707 iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ECancelling ); |
|
708 } |
|
709 break; |
|
710 default: |
|
711 // Handle error here. |
|
712 LOG2( "CPBPrintingDevice::RunL error, status %d state %d", iStatus.Int(), iState ); |
|
713 break; |
|
714 } |
|
715 } |
|
716 |
|
717 LOG("CPBPrintingDevice::RunL end"); |
|
718 } |
|
719 |
|
720 TInt CPBPrintingDevice::RunError( TInt aError ) |
|
721 { |
|
722 LOG1("CPBPrintingDevice::RunError code %d", aError); |
|
723 if ( iWait.IsStarted() ) |
|
724 { |
|
725 LOG("CPBPrintingDevice::RunError calling iWait.AsyncStop()"); |
|
726 iWait.AsyncStop(); |
|
727 } |
|
728 return KErrNone; |
|
729 } |
|
730 |
|
731 |
|
732 void CPBPrintingDevice::SetNumsOfCopiesL( const RArray<TInt>& aNumsOfCopies, TInt& aErr ) |
|
733 { |
|
734 LOG("CPBPrintingDevice::SetNumsOfCopiesL begin"); |
|
735 |
|
736 if ( iState != EPBJobReady ) |
|
737 { |
|
738 LOG1("CPBPrintingDevice::SetNumsOfCopiesL invalid state %d", iState); |
|
739 aErr = KErrInvalidSequence; |
|
740 } |
|
741 else if ( aNumsOfCopies.Count() != iStart.iReqParam.iPrintInfo.Count() ) |
|
742 { |
|
743 LOG2("CPBPrintingDevice::SetNumsOfCopiesL counts don't match, %d %d", aNumsOfCopies.Count(), iStart.iReqParam.iPrintInfo.Count()); |
|
744 aErr = KErrInvalidData; |
|
745 } |
|
746 else |
|
747 { |
|
748 for ( TInt i = 0; i < aNumsOfCopies.Count(); ++i ) |
|
749 { |
|
750 iStart.iReqParam.iPrintInfo[i].iCopies = aNumsOfCopies[i]; |
|
751 } |
|
752 aErr = KErrNone; |
|
753 } |
|
754 |
|
755 LOG("CPBPrintingDevice::SetNumsOfCopiesL end"); |
|
756 } |
|
757 |
|
758 |
|
759 void CPBPrintingDevice::ConnectionNotifyL( TInt aStatus ) |
|
760 { |
|
761 LOG2("CPBPrintingDevice::ConnectionNotifyL begin, status %d iState %d", aStatus, iState); |
|
762 switch ( aStatus ) |
|
763 { |
|
764 case CDpsEngine::ENotConnected: |
|
765 LOG("CPBPrintingDevice::ConnectionNotify not connected"); |
|
766 break; |
|
767 case CDpsEngine::EPrinterConnected: |
|
768 LOG("CPBPrintingDevice::ConnectionNotifyL printer connected"); |
|
769 iPrinterConnected = ETrue; |
|
770 iDisconnectPrinter = EFalse; |
|
771 if ( iIdleObserver ) |
|
772 { |
|
773 LOG("CPBPrintingDevice::ConnectionNotifyL informing idle observer about connect"); |
|
774 TEvent event = { KImagePrint_PrinterProtocol_PictBridge, ENotSpecified, EConnect }; |
|
775 iIdleObserver->StatusEvent( event, KErrConnected, ENoMessage ); |
|
776 } |
|
777 break; |
|
778 case CDpsEngine::EPrinterDisconnected: |
|
779 iPrinterConnected = EFalse; |
|
780 iDisconnectPrinter = ETrue; |
|
781 if ( iState != EPBUninitialized ) |
|
782 { |
|
783 Cancel(); |
|
784 if ( iState == EPBDiscovery ) |
|
785 { |
|
786 //We're not interested if the call back leaves |
|
787 TRAP_IGNORE( iDiscoveryObserver->DiscoveryStatusL( EDiscoveryFinished, KErrNone, 0 ) ); |
|
788 } |
|
789 LOG("CPBPrintingDevice::ConnectionNotifyL printer disconnected, setting state to Uninitialized"); |
|
790 iState = EPBUninitialized; |
|
791 } |
|
792 if ( iIdleObserver ) |
|
793 { |
|
794 LOG("CPBPrintingDevice::ConnectionNotifyL informing idle observer about disconnect"); |
|
795 TEvent event = { KImagePrint_PrinterProtocol_PictBridge, ENotSpecified, EDisconnect }; |
|
796 iIdleObserver->StatusEvent( event, KErrDisconnected, ENoMessage ); |
|
797 } |
|
798 break; |
|
799 case CDpsEngine::EOtherConnected: |
|
800 LOG("CPBPrintingDevice::ConnectionNotify other connected"); |
|
801 break; |
|
802 case CDpsEngine::EWrongPrintModeConnected: |
|
803 LOG("CPBPrintingDevice::ConnectionNotify Other personality"); |
|
804 iPrinterConnected = ETrue; |
|
805 iDisconnectPrinter = EFalse; |
|
806 if ( iIdleObserver ) |
|
807 { |
|
808 LOG("CPBPrintingDevice::ConnectionNotifyL informing idle observer about connect"); |
|
809 TEvent event = { KImagePrint_PrinterProtocol_PictBridge, ENotSpecified, EConnect }; |
|
810 iIdleObserver->StatusEvent( event, KErrConnected, ENoMessage ); |
|
811 } |
|
812 break; |
|
813 default: |
|
814 LOG1("CPBPrintingDevice::ConnectionNotifyL unrecognized status %d", aStatus); |
|
815 break; |
|
816 } |
|
817 LOG("CPBPrintingDevice::ConnectionNotifyL end"); |
|
818 } |
|
819 |
|
820 void CPBPrintingDevice::JobNotify( const TDpsGetJobStatus& aStatus ) |
|
821 { |
|
822 LOG1("CPBPrintingDevice::JobNotify begin, state %d", iState); |
|
823 LOG2("CPBPrintingDevice::JobNotify progress %d, prtPID %d", aStatus.iRepParam.iProgress, aStatus.iRepParam.iPrtPID); |
|
824 LOG1("CPBPrintingDevice::JobNotify copyID %d", aStatus.iRepParam.iCopyID); |
|
825 LOG2("CPBPrintingDevice::JobNotify filepath %S, images printed %d", &aStatus.iRepParam.iFilePath, aStatus.iRepParam.iImagesPrinted); |
|
826 |
|
827 if ( iPrintEventObserver ) |
|
828 { |
|
829 iPrintEventObserver->PrintJobProgressEvent( EActive, aStatus.iRepParam.iProgress, ENoMessage ); |
|
830 } |
|
831 |
|
832 LOG("CPBPrintingDevice::JobNotify end"); |
|
833 } |
|
834 |
|
835 void CPBPrintingDevice::PrinterNotify( const TDpsGetPrinterStatus& aStatus ) |
|
836 { |
|
837 LOG1("CPBPrintingDevice::PrinterNotify begin, state %d", iState ); |
|
838 LOG2("CPBPrintingDevice::PrinterNotify service status 0x%x, job status 0x%x", aStatus.iRepParam.iPrintStatus, aStatus.iRepParam.iJobStatus); |
|
839 LOG2("CPBPrintingDevice::PrinterNotify error status 0x%x, job end reason 0x%x", aStatus.iRepParam.iErrorStatus, aStatus.iRepParam.iJobEndReason.iMajor); |
|
840 LOG1("CPBPrintingDevice::PrinterNotify aStatus.iRepParam.iNewJobOk 0x%x,", aStatus.iRepParam.iNewJobOk); |
|
841 |
|
842 // New job checking that job is ok and device status is ok. |
|
843 iNewJobOK = aStatus.iRepParam.iNewJobOk; |
|
844 |
|
845 TPBProtocolState oldState = iState; |
|
846 if ( iState == EPBPrinting ) |
|
847 { |
|
848 // for SWCert software to indicate that printing state has executed |
|
849 iPrintingStateComplete = 1; |
|
850 |
|
851 if ( aStatus.iRepParam.iJobStatus == EDpsJobStatusEndedOk ) |
|
852 { |
|
853 LOG("CPBPrintingDevice::PrinterNotify job finished successfully, setting state to JobReady"); |
|
854 if ( iPrintEventObserver ) |
|
855 { |
|
856 LOG("CPBPrintingDevice::PrinterNotify job finished iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage );"); |
|
857 iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage ); |
|
858 } |
|
859 iState = EPBJobReady; |
|
860 } |
|
861 else if ( aStatus.iRepParam.iJobStatus != EDpsJobStatusNotEnded ) |
|
862 { |
|
863 LOG("CPBPrintingDevice::PrinterNotify job aborted, setting state to JobReady"); |
|
864 if ( iPrintEventObserver ) |
|
865 { |
|
866 iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ECancelling ); |
|
867 } |
|
868 iState = EPBJobReady; |
|
869 } |
|
870 } |
|
871 |
|
872 if ( iState == EPBJobReady ) |
|
873 { |
|
874 // for Cert software: CertSW doesn't give any indication about aStatus.iRepParam.iJobStatus |
|
875 // it only indicate printer state. We have to send message to UI to remove generig progress bar. |
|
876 if ( aStatus.iRepParam.iPrintStatus == EDpsPrintServiceStatusIdle && iPrintingStateComplete ) |
|
877 { |
|
878 // for Cert software to indicate that idle state has executed |
|
879 iPrintingStateComplete = 0; |
|
880 |
|
881 if ( iPrintEventObserver ) |
|
882 { |
|
883 LOG("CPBPrintingDevice::PrinterNotify job finished iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage );"); |
|
884 |
|
885 // for Cert software remove dialog from UI |
|
886 iPrintEventObserver->PrintJobProgressEvent( EDone, 100, ENoMessage ); |
|
887 } |
|
888 } |
|
889 } |
|
890 |
|
891 if ( !iPrintEventObserver ) |
|
892 { |
|
893 LOG("CPBPrintingDevice::PrinterNotify no event observer, returning"); |
|
894 return; |
|
895 } |
|
896 |
|
897 TPrintMessageCodes err = DpsJobError( aStatus.iRepParam.iJobEndReason ); |
|
898 if ( err == ENoMessage && aStatus.iRepParam.iErrorStatus == EDpsErrorStatusFatal ) |
|
899 { |
|
900 // Show fatal error |
|
901 err = EPbStatusErrorReasonHardwareFatal; |
|
902 } |
|
903 |
|
904 if ( err == ENoMessage && aStatus.iRepParam.iErrorStatus == EDpsErrorStatusWarning ) |
|
905 { |
|
906 // Show warning |
|
907 err = EPbStatusErrorReasonWarning; |
|
908 } |
|
909 |
|
910 if ( err != ENoMessage ) |
|
911 { |
|
912 if ( oldState == EPBPrinting ) |
|
913 { |
|
914 LOG1("CPBPrintingDevice::PrinterNotify calling PrintJobErrorEvent with code %d", err); |
|
915 iPrintEventObserver->PrintJobErrorEvent( err ); |
|
916 } |
|
917 else |
|
918 { |
|
919 LOG1("CPBPrintingDevice::PrinterNotify calling PrinterStatusEvent with code %d", err); |
|
920 iPrintEventObserver->PrinterStatusEvent( err ); |
|
921 } |
|
922 } |
|
923 |
|
924 LOG("CPBPrintingDevice::PrinterNotify end"); |
|
925 } |
|
926 |
|
927 void CPBPrintingDevice::HandlePapersizesResponseL( TPrintCapability& aCapability ) |
|
928 { |
|
929 LOG2("CPBPrintingDevice::HandlePapersizesResponseL result major 0x%x minor 0x%x", iCap.iResult.iMajorCode, iCap.iResult.iMinorCode); |
|
930 LOG2("CPBPrintingDevice::HandlePapersizesResponseL cap 0x%x count %d", iCap.iRepParam.iCap, iCap.iRepParam.iContent.Count()); |
|
931 |
|
932 aCapability.iCapabilityID = EPrintCapabPaperSize; |
|
933 aCapability.iType = TPrintCapability::Int; |
|
934 aCapability.iDefaultValue = EPrintCapabPaperSizeAuto; |
|
935 aCapability.iEnumCount = 0; |
|
936 |
|
937 if ( iCap.iResult.iMajorCode == EDpsResultOk ) |
|
938 { |
|
939 for ( TInt i = 0; i < iCap.iRepParam.iContent.Count() && aCapability.iEnumCount < KMaxEnumAmount; ++i ) |
|
940 { |
|
941 LOG1("CPBPrintingDevice::HandlePapersizesResponseL content 0x%x", iCap.iRepParam.iContent[i]); |
|
942 switch ( iCap.iRepParam.iContent[i] ) |
|
943 { |
|
944 case EDpsPaperSizeDefault: |
|
945 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeAuto; |
|
946 iCapToDps.InsertL( EPrintCapabPaperSizeAuto, EDpsPaperSizeDefault ); |
|
947 break; |
|
948 case EDpsPaperSizeLetter: |
|
949 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeLetter; |
|
950 iCapToDps.InsertL( EPrintCapabPaperSizeLetter, EDpsPaperSizeLetter ); |
|
951 break; |
|
952 case EDpsPaperSizeA4: |
|
953 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeA4; |
|
954 iCapToDps.InsertL( EPrintCapabPaperSizeA4, EDpsPaperSizeA4 ); |
|
955 break; |
|
956 case EDpsPaperSizeA6: |
|
957 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSizeA6; |
|
958 iCapToDps.InsertL( EPrintCapabPaperSizeA6, EDpsPaperSizeA6 ); |
|
959 break; |
|
960 case EDpsPaperSize4x6: |
|
961 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSize4x6; |
|
962 iCapToDps.InsertL( EPrintCapabPaperSize4x6, EDpsPaperSize4x6 ); |
|
963 break; |
|
964 case EDpsPaperSize2L: |
|
965 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabPaperSize5x7; |
|
966 iCapToDps.InsertL( EPrintCapabPaperSize5x7, EDpsPaperSize2L ); |
|
967 break; |
|
968 default: |
|
969 break; |
|
970 } |
|
971 } |
|
972 } |
|
973 } |
|
974 |
|
975 |
|
976 void CPBPrintingDevice::HandleQualitiesResponseL( TPrintCapability& aCapability ) |
|
977 { |
|
978 LOG2("CPBPrintingDevice::HandleQualitiesResponseL result major 0x%x minor 0x%x", iCap.iResult.iMajorCode, iCap.iResult.iMinorCode); |
|
979 LOG2("CPBPrintingDevice::HandleQualitiesResponseL cap 0x%x count %d", iCap.iRepParam.iCap, iCap.iRepParam.iContent.Count()); |
|
980 |
|
981 aCapability.iCapabilityID = EPrintCapabQuality; |
|
982 aCapability.iType = TPrintCapability::Int; |
|
983 aCapability.iDefaultValue = EPrintCapabQualityDefault; |
|
984 aCapability.iEnumCount = 0; |
|
985 |
|
986 if ( iCap.iResult.iMajorCode == EDpsResultOk ) |
|
987 { |
|
988 for ( TInt i = 0; i < iCap.iRepParam.iContent.Count() && aCapability.iEnumCount < KMaxEnumAmount; ++i ) |
|
989 { |
|
990 LOG1("CPBPrintingDevice::HandleQualitiesResponseL content 0x%x", iCap.iRepParam.iContent[i]); |
|
991 switch ( iCap.iRepParam.iContent[i] ) |
|
992 { |
|
993 case EDpsPrintQualityDefault: |
|
994 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityDefault; |
|
995 iCapToDps.InsertL( EPrintCapabQualityDefault, EDpsPrintQualityDefault ); |
|
996 break; |
|
997 case EDpsPrintQualityNormal: |
|
998 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityNormal; |
|
999 iCapToDps.InsertL( EPrintCapabQualityNormal, EDpsPrintQualityNormal ); |
|
1000 break; |
|
1001 case EDpsPrintQualityDraft: |
|
1002 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityDraft; |
|
1003 iCapToDps.InsertL( EPrintCapabQualityDraft, EDpsPrintQualityDraft ); |
|
1004 break; |
|
1005 case EDpsPrintQualityFine: |
|
1006 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityFine; |
|
1007 iCapToDps.InsertL( EPrintCapabQualityFine, EDpsPrintQualityFine ); |
|
1008 break; |
|
1009 default: |
|
1010 break; |
|
1011 } |
|
1012 } |
|
1013 } |
|
1014 if ( !aCapability.iEnumCount ) |
|
1015 { |
|
1016 LOG("CPBPrintingDevice::HandleQualitiesResponseL not supported, set to default"); |
|
1017 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabQualityDefault; |
|
1018 iCapToDps.InsertL( EPrintCapabQualityDefault, EDpsPrintQualityDefault ); |
|
1019 } |
|
1020 } |
|
1021 |
|
1022 void CPBPrintingDevice::HandleLayoutsResponseL( TPrintCapability& aCapability ) |
|
1023 { |
|
1024 LOG2("CPBPrintingDevice::HandleLayoutsResponseL result major 0x%x minor 0x%x", iCap.iResult.iMajorCode, iCap.iResult.iMinorCode); |
|
1025 LOG2("CPBPrintingDevice::HandleLayoutsResponseL cap 0x%x count %d", iCap.iRepParam.iCap, iCap.iRepParam.iContent.Count()); |
|
1026 |
|
1027 aCapability.iCapabilityID = EPrintCapabLayout; |
|
1028 aCapability.iType = TPrintCapability::Int; |
|
1029 aCapability.iDefaultValue = EPrintCapabLayout1Up; |
|
1030 aCapability.iEnumCount = 0; |
|
1031 |
|
1032 if ( iCap.iResult.iMajorCode == EDpsResultOk ) |
|
1033 { |
|
1034 for ( TInt i = 0; i < iCap.iRepParam.iContent.Count() && aCapability.iEnumCount < KMaxEnumAmount; ++i ) |
|
1035 { |
|
1036 LOG1("CPBPrintingDevice::HandleLayoutsResponseL content 0x%x", iCap.iRepParam.iContent[i]); |
|
1037 switch ( iCap.iRepParam.iContent[i] ) |
|
1038 { |
|
1039 case EDpsLayout1Up: |
|
1040 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout1Up; |
|
1041 iCapToDps.InsertL( EPrintCapabLayout1Up, EDpsLayout1Up ); |
|
1042 break; |
|
1043 case EDpsLayout2Up: |
|
1044 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout2Up; |
|
1045 iCapToDps.InsertL( EPrintCapabLayout2Up, EDpsLayout2Up ); |
|
1046 break; |
|
1047 case EDpsLayout4Up: |
|
1048 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout4Up; |
|
1049 iCapToDps.InsertL( EPrintCapabLayout4Up, EDpsLayout4Up ); |
|
1050 break; |
|
1051 case EDpsLayout6Up: |
|
1052 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout6Up; |
|
1053 iCapToDps.InsertL( EPrintCapabLayout6Up, EDpsLayout6Up ); |
|
1054 break; |
|
1055 case EDpsLayout9Up: |
|
1056 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout9Up; |
|
1057 iCapToDps.InsertL( EPrintCapabLayout9Up, EDpsLayout9Up ); |
|
1058 break; |
|
1059 // do not support this EDpsLayoutBorderless, set default value |
|
1060 case EDpsLayoutBorderless: |
|
1061 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout1UpBorderless; |
|
1062 iCapToDps.InsertL( EPrintCapabLayout1UpBorderless, EDpsLayoutDefault ); |
|
1063 break; |
|
1064 default: |
|
1065 break; |
|
1066 } |
|
1067 } |
|
1068 } |
|
1069 if ( !aCapability.iEnumCount ) |
|
1070 { |
|
1071 LOG("CPBPrintingDevice::HandleLayoutsResponseL not supported, set to default"); |
|
1072 aCapability.iEnumCodes[aCapability.iEnumCount++] = EPrintCapabLayout1Up; |
|
1073 iCapToDps.InsertL( EPrintCapabLayout1Up, EDpsLayoutDefault ); |
|
1074 } |
|
1075 } |
|
1076 |
|
1077 TInt CPBPrintingDevice::GetPapersizeJobSetting( TInt& aValue ) |
|
1078 { |
|
1079 LOG("CPBPrintingDevice::GetPapersizeJobSetting begin"); |
|
1080 |
|
1081 TDpsArgsInt& paper = iStart.iReqParam.iJobConfig[EPBSettingPaperSize]; |
|
1082 switch ( paper.iContent ) |
|
1083 { |
|
1084 case EDpsPaperSizeDefault: |
|
1085 aValue = EPrintCapabPaperSizeAuto; |
|
1086 return KErrNone; |
|
1087 case EDpsPaperSizeLetter: |
|
1088 aValue = EPrintCapabPaperSizeLetter; |
|
1089 return KErrNone; |
|
1090 case EDpsPaperSizeA4: |
|
1091 aValue = EPrintCapabPaperSizeA4; |
|
1092 return KErrNone; |
|
1093 case EDpsPaperSizeA6: |
|
1094 aValue = EPrintCapabPaperSizeA6; |
|
1095 return KErrNone; |
|
1096 case EDpsPaperSize4x6: |
|
1097 aValue = EPrintCapabPaperSize4x6; |
|
1098 return KErrNone; |
|
1099 case EDpsPaperSize2L: |
|
1100 aValue = EPrintCapabPaperSize5x7; |
|
1101 return KErrNone; |
|
1102 default: |
|
1103 LOG1("CPBPrintingDevice::GetPapersizeJobSetting unknown %x", paper.iContent); |
|
1104 break; |
|
1105 } |
|
1106 |
|
1107 LOG("CPBPrintingDevice::GetPapersizeJobSetting end"); |
|
1108 return KErrInvalidData; |
|
1109 } |
|
1110 |
|
1111 TInt CPBPrintingDevice::GetQualityJobSetting( TInt& aValue ) |
|
1112 { |
|
1113 LOG("CPBPrintingDevice::GetQualityJobSetting begin"); |
|
1114 |
|
1115 TDpsArgsInt& config = iStart.iReqParam.iJobConfig[EPBSettingQuality]; |
|
1116 switch ( config.iContent ) |
|
1117 { |
|
1118 case EDpsPrintQualityDefault: |
|
1119 aValue = EPrintCapabQualityDefault; |
|
1120 return KErrNone; |
|
1121 case EDpsPrintQualityNormal: |
|
1122 aValue = EPrintCapabQualityNormal; |
|
1123 return KErrNone; |
|
1124 case EDpsPrintQualityDraft: |
|
1125 aValue = EPrintCapabQualityDraft; |
|
1126 return KErrNone; |
|
1127 case EDpsPrintQualityFine: |
|
1128 aValue = EPrintCapabQualityFine; |
|
1129 return KErrNone; |
|
1130 default: |
|
1131 LOG1("CPBPrintingDevice::GetQualityJobSetting unknown %x", config.iContent); |
|
1132 break; |
|
1133 } |
|
1134 |
|
1135 LOG("CPBPrintingDevice::GetQualityJobSetting end"); |
|
1136 return KErrInvalidData; |
|
1137 } |
|
1138 |
|
1139 TInt CPBPrintingDevice::GetLayoutJobSetting( TInt& aValue ) |
|
1140 { |
|
1141 LOG("CPBPrintingDevice::GetLayoutJobSetting begin"); |
|
1142 |
|
1143 TDpsArgsInt& config = iStart.iReqParam.iJobConfig[EPBSettingLayout]; |
|
1144 switch ( config.iContent ) |
|
1145 { |
|
1146 case EDpsLayoutDefault: |
|
1147 // Not supported default value is EPrintCapabLayout1UpBorderless |
|
1148 // because other protocols use it too |
|
1149 // EPrintCapabLayout1UpBorderless is mapped with EDpsLayoutDefault |
|
1150 aValue = EPrintCapabLayout1UpBorderless; |
|
1151 case EDpsLayout1Up: |
|
1152 aValue = EPrintCapabLayout1Up; |
|
1153 return KErrNone; |
|
1154 case EDpsLayout2Up: |
|
1155 aValue = EPrintCapabLayout2Up; |
|
1156 return KErrNone; |
|
1157 case EDpsLayout4Up: |
|
1158 aValue = EPrintCapabLayout4Up; |
|
1159 return KErrNone; |
|
1160 case EDpsLayout6Up: |
|
1161 aValue = EPrintCapabLayout6Up; |
|
1162 return KErrNone; |
|
1163 case EDpsLayout9Up: |
|
1164 aValue = EPrintCapabLayout9Up; |
|
1165 return KErrNone; |
|
1166 case EDpsLayoutBorderless: |
|
1167 aValue = EPrintCapabLayout1UpBorderless; |
|
1168 return KErrNone; |
|
1169 default: |
|
1170 LOG1("CPBPrintingDevice::GetLayoutJobSetting unknown %x", config.iContent); |
|
1171 break; |
|
1172 } |
|
1173 |
|
1174 LOG("CPBPrintingDevice::GetLayoutJobSetting end"); |
|
1175 return KErrInvalidData; |
|
1176 } |
|
1177 |
|
1178 TPrintMessageCodes CPBPrintingDevice::DpsJobError( const TDpsJobEndReason& aReason ) |
|
1179 { |
|
1180 TPrintMessageCodes err = ENoMessage; |
|
1181 switch ( aReason.iMajor ) |
|
1182 { |
|
1183 case EDpsJobErrorPaper: |
|
1184 LOG1("CPBPrintingDevice::DpsJobError paper error 0x%x", aReason.iPaperMinor); |
|
1185 HandlePaperError( aReason, err ); |
|
1186 break; |
|
1187 case EDpsJobErrorInk: |
|
1188 LOG1("CPBPrintingDevice::DpsJobError ink error 0x%x", aReason.iInkMinor); |
|
1189 HandleInkError( aReason, err ); |
|
1190 break; |
|
1191 case EDpsJobErrorHardware: |
|
1192 LOG1("CPBPrintingDevice::DpsJobError hardware error 0x%x", aReason.iHardMinor); |
|
1193 HandleHwError( aReason, err ); |
|
1194 break; |
|
1195 case EDpsJobErrorFile: |
|
1196 LOG1("CPBPrintingDevice::DpsJobError file error 0x%x", aReason.iFileMinor); |
|
1197 HandleFileError( aReason, err ); |
|
1198 break; |
|
1199 default: |
|
1200 break; |
|
1201 } |
|
1202 return err; |
|
1203 } |
|
1204 void CPBPrintingDevice::HandlePaperError ( const TDpsJobEndReason& aReason, TPrintMessageCodes& aErr ) |
|
1205 { |
|
1206 switch ( aReason.iPaperMinor ) |
|
1207 { |
|
1208 case EDpsPaperEmpty: |
|
1209 aErr = EPbStatusErrorReasonPaperEmpty; |
|
1210 break; |
|
1211 case EDpsPaperLoad: |
|
1212 aErr = EPbStatusErrorReasonPaperLoad; |
|
1213 break; |
|
1214 case EDpsPaperEject: |
|
1215 aErr = EPbStatusErrorReasonPaperEject; |
|
1216 break; |
|
1217 case EDpsPaperMedia: |
|
1218 aErr = EPbStatusErrorReasonPaperMedia; |
|
1219 break; |
|
1220 case EDpsPaperJam: |
|
1221 aErr = EPbStatusErrorReasonPaperJam; |
|
1222 break; |
|
1223 case EDpsPaperNearlyEmpty: |
|
1224 aErr = EPbStatusErrorReasonPaperNearlyEmpty; |
|
1225 break; |
|
1226 case EDpsPaperTypeSizeNoMatch: |
|
1227 aErr = EPbStatusErrorReasonPaperCombination; |
|
1228 break; |
|
1229 default: |
|
1230 aErr = EPbStatusErrorReasonPaper; |
|
1231 break; |
|
1232 } |
|
1233 } |
|
1234 |
|
1235 void CPBPrintingDevice::HandleInkError ( const TDpsJobEndReason& aReason, TPrintMessageCodes& aErr ) |
|
1236 { |
|
1237 switch ( aReason.iInkMinor ) |
|
1238 { |
|
1239 case EDpsInkEmpty: |
|
1240 aErr = EPbStatusErrorReasonInkEmpty; |
|
1241 break; |
|
1242 case EDpsInkLow: |
|
1243 aErr = EPbStatusErrorReasonInkLow; |
|
1244 break; |
|
1245 case EDpsInkWaste: |
|
1246 aErr = EPbStatusErrorReasonInkWaste; |
|
1247 break; |
|
1248 default: |
|
1249 aErr = EPbStatusErrorReasonInk; |
|
1250 break; |
|
1251 } |
|
1252 } |
|
1253 |
|
1254 void CPBPrintingDevice::HandleHwError ( const TDpsJobEndReason& aReason, TPrintMessageCodes& aErr ) |
|
1255 { |
|
1256 switch ( aReason.iHardMinor ) |
|
1257 { |
|
1258 case EDpsHardFatal: |
|
1259 aErr = EPbStatusErrorReasonHardwareFatal; |
|
1260 break; |
|
1261 case EDpsHardServiceCall: |
|
1262 aErr = EPbStatusErrorReasonHardwareServiceCall; |
|
1263 break; |
|
1264 case EDpsHardNotAvailable: |
|
1265 aErr = EPbStatusErrorReasonHardwarePrinterUnavailable; |
|
1266 break; |
|
1267 case EDpsHardBusy: |
|
1268 aErr = EPbStatusErrorReasonHardwarePrinterBusy; |
|
1269 break; |
|
1270 case EDpsHardLever: |
|
1271 aErr = EPbStatusErrorReasonHardwareLever; |
|
1272 break; |
|
1273 case EDpsHardCoverOpen: |
|
1274 aErr = EPbStatusErrorReasonHardwareCoverOpen; |
|
1275 break; |
|
1276 case EDpsHardNoMarkingHead: |
|
1277 aErr = EPbStatusErrorReasonHardwareNoMarkingAgent; |
|
1278 break; |
|
1279 case EDpsHardInkCoverOpen: |
|
1280 aErr = EPbStatusErrorReasonHardwareCoverOpen; |
|
1281 break; |
|
1282 case EDpsHardNoInkCartridge: |
|
1283 aErr = EPbStatusErrorReasonHardwareNoInkCartridge; |
|
1284 break; |
|
1285 default: |
|
1286 aErr = EPbStatusErrorReasonHardware; |
|
1287 break; |
|
1288 } |
|
1289 } |
|
1290 |
|
1291 void CPBPrintingDevice::HandleFileError ( const TDpsJobEndReason& aReason, TPrintMessageCodes& aErr ) |
|
1292 { |
|
1293 switch ( aReason.iFileMinor ) |
|
1294 { |
|
1295 case EDpsFilePrintInfo: |
|
1296 aErr = EPbStatusErrorReasonFilePrintInfo; |
|
1297 break; |
|
1298 case EDpsFileDecode: |
|
1299 aErr = EPbStatusErrorReasonFileFileDecode; |
|
1300 break; |
|
1301 default: |
|
1302 aErr = EPbStatusErrorReasonFile; |
|
1303 break; |
|
1304 } |
|
1305 } |
|
1306 |
|
1307 TBool CPBPrintingDevice::HasCapability( TPrintCapability& aCapability, TPrintCapabilityOptions aOption ) |
|
1308 { |
|
1309 for ( TInt i = 0; i < aCapability.iEnumCount; ++i ) |
|
1310 { |
|
1311 if ( aCapability.iEnumCodes[i] == aOption ) |
|
1312 { |
|
1313 return ETrue; |
|
1314 } |
|
1315 } |
|
1316 return EFalse; |
|
1317 } |
|
1318 |
|
1319 void CPBPrintingDevice::SaveConfigInfoL() |
|
1320 { |
|
1321 LOG("CPBPrintingDevice::SaveConfigInfoL begin"); |
|
1322 |
|
1323 RFs rFs; |
|
1324 RFile file; |
|
1325 |
|
1326 User::LeaveIfError( rFs.Connect() ); |
|
1327 CleanupClosePushL( rFs ); |
|
1328 |
|
1329 User::LeaveIfError( file.Replace( rFs, iCongFileName->Des() ,EFileWrite ) ); // create the file for writing |
|
1330 |
|
1331 RFileWriteStream stream( file ); |
|
1332 CleanupClosePushL( stream ); |
|
1333 |
|
1334 ExternalizeL( stream ); |
|
1335 |
|
1336 CleanupStack::PopAndDestroy( &stream ); |
|
1337 CleanupStack::PopAndDestroy( &rFs ); |
|
1338 |
|
1339 LOG("CPBPrintingDevice::SaveConfigInfoL end"); |
|
1340 } |
|
1341 |
|
1342 void CPBPrintingDevice::ExternalizeL( RWriteStream& aStream ) const |
|
1343 { |
|
1344 LOG("CPBPrintingDevice::ExternalizeL begin"); |
|
1345 |
|
1346 aStream << iPrinter.iDisplayName; |
|
1347 aStream.WriteUint32L( iPrinter.iVendor ); |
|
1348 aStream.CommitL(); |
|
1349 |
|
1350 LOG("CPBPrintingDevice::ExternalizeL end"); |
|
1351 } |
|
1352 |
|
1353 void CPBPrintingDevice::ReadConfigInfoL() |
|
1354 { |
|
1355 LOG("CPBPrintingDevice::ReadConfigInfoL begin"); |
|
1356 |
|
1357 RFs rFs; |
|
1358 RFile file; |
|
1359 |
|
1360 User::LeaveIfError( rFs.Connect() ); |
|
1361 CleanupClosePushL( rFs ); |
|
1362 |
|
1363 User::LeaveIfError( file.Open( rFs, iCongFileName->Des() ,EFileRead ) ); |
|
1364 |
|
1365 RFileReadStream readStream( file ); |
|
1366 CleanupClosePushL( readStream ); |
|
1367 |
|
1368 readStream >> iPrinter.iDisplayName; |
|
1369 iPrinter.iVendor = readStream.ReadUint32L(); |
|
1370 |
|
1371 CleanupStack::PopAndDestroy( &readStream ); |
|
1372 CleanupStack::PopAndDestroy( &rFs ); |
|
1373 |
|
1374 LOG("CPBPrintingDevice::ReadConfigInfoL end"); |
|
1375 } |
|
1376 |
|
1377 // End of File |