|
1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include <f32file.h> |
|
17 #include <ecom/ecom.h> |
|
18 #include <ecom/implementationproxy.h> |
|
19 #include <ecamuids.hrh> |
|
20 #include <ecam.h> |
|
21 #include <ecam/ecamadvsettingsintfuids.hrh> |
|
22 #include "ECamUnitTestPlugin.h" |
|
23 #include "ECamUnitTestPluginUids.hrh" |
|
24 #include "AdvancedSettings.h" |
|
25 #include <ecam/ecamcommonuids.hrh> |
|
26 #include "EnhanceFunctionality.h" |
|
27 #include "directviewfinder.h" |
|
28 #include "extended_functionality.h" |
|
29 |
|
30 const TBool KTestCamerasPresent[] = {ETrue, EFalse, EFalse}; |
|
31 const CCamera::CCameraAdvancedSettings::TCameraType KTestCamerasTypes[] = |
|
32 { |
|
33 CCamera::CCameraAdvancedSettings::ECameraOnBoard, |
|
34 CCamera::CCameraAdvancedSettings::ECameraPluggable, |
|
35 CCamera::CCameraAdvancedSettings::ECameraPluggable |
|
36 }; |
|
37 |
|
38 // |
|
39 // Main stuff |
|
40 // |
|
41 static void Panic(TInt aReason) |
|
42 { |
|
43 _LIT(KDllName, "ECam Unit Test Plugin"); |
|
44 User::Panic(KDllName, aReason); |
|
45 } |
|
46 |
|
47 // |
|
48 // CCamUnitTestPlugin |
|
49 // |
|
50 CCamUnitTestPlugin::CCamUnitTestPlugin() |
|
51 { |
|
52 iPresets.Reset(); |
|
53 iSupportedISORates.Reset(); |
|
54 iIsoRate = KDefaultIsoRate; |
|
55 for ( TInt i = 0; i< KECamSetAvailableCameras; i++) |
|
56 { |
|
57 iCameras[i] = KTestCamerasPresent[i]; |
|
58 iCameraTypes[i] = KTestCamerasTypes[i]; |
|
59 } |
|
60 |
|
61 iVFHandleGenerater = 0; |
|
62 } |
|
63 |
|
64 CCamUnitTestPlugin::~CCamUnitTestPlugin() |
|
65 { |
|
66 iSupportedISORates.Close(); |
|
67 } |
|
68 |
|
69 CCamUnitTestPlugin* CCamUnitTestPlugin::NewL() |
|
70 { |
|
71 FileDependencyUtil::CheckFileDependencyL(); |
|
72 return new (ELeave) CCamUnitTestPlugin; |
|
73 } |
|
74 |
|
75 // |
|
76 // 2nd stage ConstructL calls called by framework |
|
77 // |
|
78 |
|
79 void CCamUnitTestPlugin::Construct2L(MCameraObserver& aObserver,TInt aCameraIndex) |
|
80 { |
|
81 iObserver = &aObserver; |
|
82 iCameraIndex = aCameraIndex; |
|
83 } |
|
84 |
|
85 void CCamUnitTestPlugin::Construct2DupL(MCameraObserver& aObserver,TInt aCameraHandle) |
|
86 { |
|
87 iObserver = &aObserver; |
|
88 iCameraHandle = aCameraHandle; |
|
89 } |
|
90 |
|
91 |
|
92 void CCamUnitTestPlugin::Construct2L(MCameraObserver2& aObserver,TInt aCameraIndex,TInt aPriority) |
|
93 { |
|
94 iObserver2 = &aObserver; |
|
95 iCameraIndex = aCameraIndex; |
|
96 iPriority = aPriority; |
|
97 |
|
98 iSupportedISORates.AppendL(KMinIsoRate); |
|
99 iSupportedISORates.AppendL(KDefaultIsoRate); |
|
100 iSupportedISORates.AppendL(KIsoRate1); |
|
101 iSupportedISORates.AppendL(KIsoRate2); |
|
102 iSupportedISORates.AppendL(KIsoRate3); |
|
103 iSupportedISORates.AppendL(KIsoRate4); |
|
104 iSupportedISORates.AppendL(KIsoRate5); |
|
105 iSupportedISORates.AppendL(KMaxIsoRate); |
|
106 } |
|
107 |
|
108 void CCamUnitTestPlugin::Construct2DupL(MCameraObserver2& aObserver,TInt aCameraHandle) |
|
109 { |
|
110 iObserver2 = &aObserver; |
|
111 iCameraHandle = aCameraHandle; |
|
112 |
|
113 |
|
114 iSupportedISORates.AppendL(KMinIsoRate); |
|
115 iSupportedISORates.AppendL(KDefaultIsoRate); |
|
116 iSupportedISORates.AppendL(KIsoRate1); |
|
117 iSupportedISORates.AppendL(KIsoRate2); |
|
118 iSupportedISORates.AppendL(KIsoRate3); |
|
119 iSupportedISORates.AppendL(KIsoRate4); |
|
120 iSupportedISORates.AppendL(KIsoRate5); |
|
121 iSupportedISORates.AppendL(KMaxIsoRate); |
|
122 } |
|
123 |
|
124 |
|
125 |
|
126 // |
|
127 // Dummy versions of virtual functions |
|
128 // |
|
129 |
|
130 void CCamUnitTestPlugin::CameraInfo(TCameraInfo& /*aInfo*/) const |
|
131 { |
|
132 } |
|
133 |
|
134 void CCamUnitTestPlugin::Reserve() |
|
135 { |
|
136 } |
|
137 |
|
138 |
|
139 void CCamUnitTestPlugin::Release() |
|
140 { |
|
141 } |
|
142 |
|
143 void CCamUnitTestPlugin::PowerOn() |
|
144 { |
|
145 } |
|
146 |
|
147 void CCamUnitTestPlugin::PowerOff() |
|
148 { |
|
149 } |
|
150 |
|
151 TInt CCamUnitTestPlugin::Handle() |
|
152 { |
|
153 return 0; |
|
154 } |
|
155 |
|
156 void CCamUnitTestPlugin::SetZoomFactorL(TInt /*aZoomFactor = 0*/) |
|
157 { |
|
158 } |
|
159 |
|
160 TInt CCamUnitTestPlugin::ZoomFactor() const |
|
161 { |
|
162 return 0; |
|
163 } |
|
164 |
|
165 void CCamUnitTestPlugin::SetDigitalZoomFactorL(TInt /*aDigitalZoomFactor = 0*/) |
|
166 { |
|
167 } |
|
168 |
|
169 TInt CCamUnitTestPlugin::DigitalZoomFactor() const |
|
170 { |
|
171 return 0; |
|
172 } |
|
173 |
|
174 void CCamUnitTestPlugin::SetContrastL(TInt /*aContrast*/) |
|
175 { |
|
176 } |
|
177 |
|
178 TInt CCamUnitTestPlugin::Contrast() const |
|
179 { |
|
180 return 0; |
|
181 } |
|
182 |
|
183 void CCamUnitTestPlugin::SetBrightnessL(TInt /*aBrightness*/) |
|
184 { |
|
185 } |
|
186 |
|
187 TInt CCamUnitTestPlugin::Brightness() const |
|
188 { |
|
189 return 0; |
|
190 } |
|
191 |
|
192 |
|
193 void CCamUnitTestPlugin::SetFlashL(TFlash /*aFlash = EFlashNone*/) |
|
194 { |
|
195 Panic(EPanicUnimplemented); |
|
196 } |
|
197 |
|
198 CCamera::TFlash CCamUnitTestPlugin::Flash() const |
|
199 { |
|
200 Panic(EPanicUnimplemented); |
|
201 return EFlashNone; |
|
202 } |
|
203 |
|
204 void CCamUnitTestPlugin::SetExposureL(TExposure /*aExposure = EExposureAuto*/) |
|
205 { |
|
206 Panic(EPanicUnimplemented); |
|
207 } |
|
208 |
|
209 CCamera::TExposure CCamUnitTestPlugin::Exposure() const |
|
210 { |
|
211 Panic(EPanicUnimplemented); |
|
212 return EExposureAuto; |
|
213 } |
|
214 |
|
215 void CCamUnitTestPlugin::SetWhiteBalanceL(TWhiteBalance /*aWhiteBalance = EWBAuto*/) |
|
216 { |
|
217 Panic(EPanicUnimplemented); |
|
218 } |
|
219 |
|
220 CCamera::TWhiteBalance CCamUnitTestPlugin::WhiteBalance() const |
|
221 { |
|
222 Panic(EPanicUnimplemented); |
|
223 return EWBAuto; |
|
224 } |
|
225 |
|
226 void CCamUnitTestPlugin::StartViewFinderDirectL(RWsSession& /*aWs*/,CWsScreenDevice& /*aScreenDevice*/,RWindowBase& /*aWindow*/,TRect& /*aScreenRect*/) |
|
227 { |
|
228 Panic(EPanicUnimplemented); |
|
229 } |
|
230 |
|
231 void CCamUnitTestPlugin::StartViewFinderDirectL(RWsSession& /*aWs*/,CWsScreenDevice& /*aScreenDevice*/,RWindowBase& /*aWindow*/,TRect& /*aScreenRect*/,TRect& /*aClipRect*/) |
|
232 { |
|
233 Panic(EPanicUnimplemented); |
|
234 } |
|
235 |
|
236 void CCamUnitTestPlugin::StartViewFinderBitmapsL(TSize& /*aSize*/) |
|
237 { |
|
238 Panic(EPanicUnimplemented); |
|
239 } |
|
240 |
|
241 void CCamUnitTestPlugin::StartViewFinderBitmapsL(TSize& /*aSize*/,TRect& /*aClipRect*/) |
|
242 { |
|
243 Panic(EPanicUnimplemented); |
|
244 } |
|
245 |
|
246 |
|
247 void CCamUnitTestPlugin::StartViewFinderL(TFormat /*aImageFormat*/,TSize& /*aSize*/) |
|
248 { |
|
249 Panic(EPanicUnimplemented); |
|
250 } |
|
251 |
|
252 void CCamUnitTestPlugin::StartViewFinderL(TFormat /*aImageFormat*/,TSize& /*aSize*/,TRect& /*aClipRect*/) |
|
253 { |
|
254 Panic(EPanicUnimplemented); |
|
255 } |
|
256 |
|
257 |
|
258 void CCamUnitTestPlugin::StopViewFinder() |
|
259 { |
|
260 Panic(EPanicUnimplemented); |
|
261 } |
|
262 |
|
263 TBool CCamUnitTestPlugin::ViewFinderActive() const |
|
264 { |
|
265 Panic(EPanicUnimplemented); |
|
266 return EFalse; |
|
267 } |
|
268 |
|
269 void CCamUnitTestPlugin::SetViewFinderMirrorL(TBool /*aMirror*/) |
|
270 { |
|
271 Panic(EPanicUnimplemented); |
|
272 } |
|
273 |
|
274 TBool CCamUnitTestPlugin::ViewFinderMirror() const |
|
275 { |
|
276 Panic(EPanicUnimplemented); |
|
277 return EFalse; |
|
278 } |
|
279 |
|
280 void CCamUnitTestPlugin::PrepareImageCaptureL(TFormat /*aImageFormat*/,TInt /*aSizeIndex*/) |
|
281 { |
|
282 Panic(EPanicUnimplemented); |
|
283 } |
|
284 |
|
285 void CCamUnitTestPlugin::PrepareImageCaptureL(TFormat /*aImageFormat*/,TInt /*aSizeIndex*/,const TRect& /*aClipRect*/) |
|
286 { |
|
287 Panic(EPanicUnimplemented); |
|
288 } |
|
289 |
|
290 void CCamUnitTestPlugin::CaptureImage() |
|
291 { |
|
292 Panic(EPanicUnimplemented); |
|
293 } |
|
294 |
|
295 void CCamUnitTestPlugin::CancelCaptureImage() |
|
296 { |
|
297 Panic(EPanicUnimplemented); |
|
298 } |
|
299 |
|
300 void CCamUnitTestPlugin::EnumerateCaptureSizes(TSize& /*aSize*/,TInt /*aSizeIndex*/,TFormat /*aFormat*/) const |
|
301 { |
|
302 Panic(EPanicUnimplemented); |
|
303 } |
|
304 |
|
305 void CCamUnitTestPlugin::PrepareVideoCaptureL(TFormat /*aFormat*/,TInt /*aSizeIndex*/,TInt /*aRateIndex*/,TInt /*aBuffersToUse*/,TInt /*aFramesPerBuffer*/) |
|
306 { |
|
307 Panic(EPanicUnimplemented); |
|
308 } |
|
309 |
|
310 void CCamUnitTestPlugin::PrepareVideoCaptureL(TFormat /*aFormat*/,TInt /*aSizeIndex*/,TInt /*aRateIndex*/,TInt /*aBuffersToUse*/,TInt /*aFramesPerBuffer*/,const TRect& /*aClipRect*/) |
|
311 { |
|
312 Panic(EPanicUnimplemented); |
|
313 } |
|
314 |
|
315 void CCamUnitTestPlugin::StartVideoCapture() |
|
316 { |
|
317 Panic(EPanicUnimplemented); |
|
318 } |
|
319 |
|
320 void CCamUnitTestPlugin::StopVideoCapture() |
|
321 { |
|
322 Panic(EPanicUnimplemented); |
|
323 } |
|
324 |
|
325 TBool CCamUnitTestPlugin::VideoCaptureActive() const |
|
326 { |
|
327 Panic(EPanicUnimplemented); |
|
328 return EFalse; |
|
329 } |
|
330 |
|
331 void CCamUnitTestPlugin::EnumerateVideoFrameSizes(TSize& /*aSize*/,TInt /*aSizeIndex*/,TFormat /*aFormat*/) const |
|
332 { |
|
333 Panic(EPanicUnimplemented); |
|
334 } |
|
335 |
|
336 void CCamUnitTestPlugin::EnumerateVideoFrameRates(TReal32& /*aRate*/,TInt /*aRateIndex*/,TFormat /*aFormat*/,TInt /*aSizeIndex*/,TExposure /*aExposure = EExposureAuto*/) const |
|
337 { |
|
338 Panic(EPanicUnimplemented); |
|
339 } |
|
340 |
|
341 void CCamUnitTestPlugin::GetFrameSize(TSize& /*aSize*/) const |
|
342 { |
|
343 Panic(EPanicUnimplemented); |
|
344 } |
|
345 |
|
346 TReal32 CCamUnitTestPlugin::FrameRate() const |
|
347 { |
|
348 Panic(EPanicUnimplemented); |
|
349 return 0.0; |
|
350 } |
|
351 |
|
352 TInt CCamUnitTestPlugin::BuffersInUse() const |
|
353 { |
|
354 Panic(EPanicUnimplemented); |
|
355 return 0; |
|
356 } |
|
357 |
|
358 TInt CCamUnitTestPlugin::FramesPerBuffer() const |
|
359 { |
|
360 Panic(EPanicUnimplemented); |
|
361 return 0; |
|
362 } |
|
363 |
|
364 void CCamUnitTestPlugin::SetJpegQuality(TInt /*aQuality*/) |
|
365 { |
|
366 Panic(EPanicUnimplemented); |
|
367 } |
|
368 |
|
369 TInt CCamUnitTestPlugin::JpegQuality() const |
|
370 { |
|
371 Panic(EPanicUnimplemented); |
|
372 return 0; |
|
373 } |
|
374 |
|
375 TAny* CCamUnitTestPlugin::CustomInterface(TUid aInterfaceUid) |
|
376 { |
|
377 TAny* advSettingObject = NULL; |
|
378 // use the fact that the parent is a friend of the class |
|
379 |
|
380 TRAPD(err, advSettingObject = CCamera::CustomInterface(aInterfaceUid)); |
|
381 |
|
382 if (err == KErrNone) |
|
383 { |
|
384 return advSettingObject; |
|
385 } |
|
386 /*else if (err == KErrNoMemory) |
|
387 { |
|
388 User::Leave(KErrNoMemory); |
|
389 }*/ |
|
390 return NULL; |
|
391 } |
|
392 |
|
393 |
|
394 TAny* CCamera::CustomInterface(TUid aInterfaceUid) |
|
395 { |
|
396 switch (aInterfaceUid.iUid) |
|
397 { |
|
398 // presets |
|
399 case KECamPresetsUidValue: |
|
400 { |
|
401 CCamera::CCameraPresets* presets = new (ELeave)CCamera::CCameraPresets(*this); |
|
402 CleanupStack::PushL(presets); |
|
403 presets->ConstructL(); |
|
404 CleanupStack::Pop(presets); |
|
405 |
|
406 return static_cast<TAny*>(presets); |
|
407 } |
|
408 |
|
409 case KECamMCameraPresetsUidValue: |
|
410 { |
|
411 return static_cast<MCameraPresets*>(CCamPresets::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
412 } |
|
413 |
|
414 case KECamMCameraPresets2UidValue: |
|
415 { |
|
416 return static_cast<MCameraPresets2*>(CCamPresets::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
417 } |
|
418 |
|
419 // image processing |
|
420 case KECamImageProcessingUidValue: |
|
421 { |
|
422 CCamera::CCameraImageProcessing* processing = new (ELeave)CCamera::CCameraImageProcessing(*this); |
|
423 CleanupStack::PushL(processing); |
|
424 processing->ConstructL(); |
|
425 CleanupStack::Pop(processing); |
|
426 |
|
427 return static_cast<TAny*>(processing); |
|
428 } |
|
429 |
|
430 case KECamMCameraImageProcessingUidValue: |
|
431 { |
|
432 return static_cast<MCameraImageProcessing*>(CCamImgProc::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
433 } |
|
434 |
|
435 case KECamMCameraImageProcessing2UidValue: |
|
436 { |
|
437 return static_cast<MCameraImageProcessing2*>(CCamImgProc::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
438 } |
|
439 |
|
440 case KECamMCameraImageProcessing3UidValue: |
|
441 { |
|
442 return static_cast<MCameraImageProcessing3*>(CCamImgProc::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
443 } |
|
444 |
|
445 // advanced settings |
|
446 case KECamAdvancedSettingUidValue: |
|
447 { |
|
448 CCamera::CCameraAdvancedSettings* settings = new (ELeave)CCamera::CCameraAdvancedSettings(*this); |
|
449 CleanupStack::PushL(settings); |
|
450 settings->ConstructL(); |
|
451 CleanupStack::Pop(settings); |
|
452 |
|
453 return static_cast<TAny*>(settings); |
|
454 } |
|
455 |
|
456 case KECamMCameraAdvancedSettingsUidValue: |
|
457 { |
|
458 return static_cast<MCameraAdvancedSettings*>(CCamAdvSet::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
459 } |
|
460 |
|
461 case KECamMCameraAdvancedSettings2UidValue: |
|
462 { |
|
463 return static_cast<MCameraAdvancedSettings2*>(CCamAdvSet::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
464 } |
|
465 |
|
466 case KECamMCameraAdvancedSettings3UidValue: |
|
467 { |
|
468 return static_cast<MCameraAdvancedSettings3*>(CCamAdvSet::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
469 } |
|
470 |
|
471 case KECamMCameraAdvancedSettings4UidValue: |
|
472 { |
|
473 return static_cast<MCameraAdvancedSettings4*>(CCamAdvSet::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
474 } |
|
475 |
|
476 case KUidCameraManagementUidValue: |
|
477 { |
|
478 return (CCamManagement::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
479 } |
|
480 |
|
481 // |
|
482 // enhance camera functionality // |
|
483 // |
|
484 case KECamHistogramUidValue: |
|
485 { |
|
486 return static_cast<TAny*>(CCamera::CCameraHistogram::NewL(*this)); |
|
487 } |
|
488 |
|
489 case KECamMCameraHistogramUidValue: |
|
490 { |
|
491 return static_cast<MCameraHistogram*>(CCamHistogram::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
492 } |
|
493 |
|
494 case KECamOverlayUidValue: |
|
495 { |
|
496 return static_cast<TAny*>(CCamera::CCameraOverlay::NewL(*this)); |
|
497 } |
|
498 |
|
499 case KECamMCameraOverlayUidValue: |
|
500 { |
|
501 return static_cast<MCameraOverlay*>(CCamOverlay::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
502 } |
|
503 |
|
504 case KECamMCameraOverlay2UidValue: |
|
505 { |
|
506 return static_cast<MCameraOverlay2*>(CCamOverlay::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
507 } |
|
508 |
|
509 case KECamSnapshotUidValue: |
|
510 { |
|
511 return static_cast<TAny*>(CCamera::CCameraSnapshot::NewL(*this)); |
|
512 } |
|
513 |
|
514 case KECamMCameraSnapshotUidValue: |
|
515 { |
|
516 return static_cast<MCameraSnapshot*>(CCamSnapshot::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
517 } |
|
518 |
|
519 // |
|
520 // direct viewfinder functionality // |
|
521 // |
|
522 case KECamDirectViewFinderUidValue: |
|
523 { |
|
524 return static_cast<TAny*>(CCamera::CCameraDirectViewFinder::NewL(*this)); |
|
525 } |
|
526 |
|
527 case KECamMCameraDirectViewFinderUidValue: |
|
528 { |
|
529 return static_cast<MCameraDirectViewFinder*>(CCamDirectViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
530 } |
|
531 |
|
532 case KECamMCameraPreImageCaptureControlUidValue: |
|
533 { |
|
534 return static_cast<MCameraPreImageCaptureControl*>(CCamPreImageCaptureControl::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
535 } |
|
536 |
|
537 case KECamMCameraImageCaptureUidValue: |
|
538 { |
|
539 return static_cast<MCameraImageCapture*>(CCamImageCapture::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
540 } |
|
541 |
|
542 case KECamMCameraVideoCaptureControlUidValue: |
|
543 { |
|
544 return static_cast<MCameraVideoCaptureControl*>(CCamVideoCaptureControl::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
545 } |
|
546 |
|
547 case KECamMCameraClientViewFinderUidValue: |
|
548 { |
|
549 return static_cast<MCameraClientViewFinder*>(CCamClientViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
550 } |
|
551 |
|
552 case KECamMCameraBaseClientViewFinderUidValue: |
|
553 { |
|
554 return static_cast<MCameraViewFinder*>(CCamClientViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
555 } |
|
556 |
|
557 case KECamMCameraV2DirectViewFinderUidValue: |
|
558 { |
|
559 return static_cast<MCameraV2DirectViewFinder*>(CCamV2DirectViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
560 } |
|
561 |
|
562 case KECamMCameraBaseV2DirectViewFinderUidValue: |
|
563 { |
|
564 return static_cast<MCameraViewFinder*>(CCamV2DirectViewFinder::NewL(static_cast<CCamUnitTestPlugin&>(*this))); |
|
565 } |
|
566 default: |
|
567 { |
|
568 return NULL; |
|
569 } |
|
570 } |
|
571 } |
|
572 |
|
573 void CCamUnitTestPlugin::GenerateVFHandle(TInt& aVFHandle) |
|
574 { |
|
575 iVFHandleGenerater++; |
|
576 aVFHandle = iVFHandleGenerater; |
|
577 } |
|
578 |
|
579 void CCamUnitTestPlugin::Notify(TUid aMessageId, TInt aError) |
|
580 { |
|
581 if (iObserver2 != NULL) |
|
582 { |
|
583 iObserver2->HandleEvent(TECAMEvent(aMessageId, aError)); |
|
584 } |
|
585 } |
|
586 |
|
587 void CCamUnitTestPlugin::Notify2(TUid aMessageId, TInt aError, TInt aParam) |
|
588 { |
|
589 if (iObserver2 != NULL) |
|
590 { |
|
591 iObserver2->HandleEvent(TECAMEvent2(aMessageId, aError, aParam)); |
|
592 } |
|
593 } |
|
594 |
|
595 // |
|
596 // CCamUnitTestPluginInfo |
|
597 // |
|
598 |
|
599 CCamUnitTestPluginInfo::CCamUnitTestPluginInfo() |
|
600 { |
|
601 } |
|
602 |
|
603 CCamUnitTestPluginInfo::~CCamUnitTestPluginInfo() |
|
604 { |
|
605 } |
|
606 |
|
607 CCamUnitTestPluginInfo* CCamUnitTestPluginInfo::NewL() |
|
608 { |
|
609 FileDependencyUtil::CheckFileDependencyL(); |
|
610 return new (ELeave) CCamUnitTestPluginInfo; |
|
611 } |
|
612 |
|
613 TInt CCamUnitTestPluginInfo::CamerasAvailable() |
|
614 { |
|
615 return KECamSetAvailableCameras; |
|
616 } |
|
617 |
|
618 // |
|
619 // CCamUnitTestPluginSecureId |
|
620 // |
|
621 |
|
622 CCamUnitTestPluginSecureId::CCamUnitTestPluginSecureId() |
|
623 { |
|
624 } |
|
625 |
|
626 CCamUnitTestPluginSecureId::~CCamUnitTestPluginSecureId() |
|
627 { |
|
628 } |
|
629 |
|
630 CCamUnitTestPluginSecureId* CCamUnitTestPluginSecureId::NewL() |
|
631 { |
|
632 CCamUnitTestPluginSecureId* pluginSecureId = new (ELeave) CCamUnitTestPluginSecureId; |
|
633 return pluginSecureId; |
|
634 } |
|
635 |
|
636 void CCamUnitTestPluginSecureId::Release() |
|
637 { |
|
638 delete this; |
|
639 } |
|
640 |
|
641 void CCamUnitTestPluginSecureId::GetSecureIdL(TInt& aSecureId) const |
|
642 { |
|
643 TSecureId secureId = User::CreatorSecureId(); |
|
644 aSecureId = secureId.iId; |
|
645 } |
|
646 |
|
647 void FileDependencyUtil::CheckFileDependencyL() |
|
648 { |
|
649 RFs fsSession; |
|
650 RFile file; |
|
651 |
|
652 User::LeaveIfError(fsSession.Connect()); |
|
653 CleanupClosePushL(fsSession); |
|
654 TInt err = file.Open(fsSession, KECamUnitTestPluginName, EFileRead); |
|
655 file.Close(); |
|
656 |
|
657 if(err != KErrNone) |
|
658 { |
|
659 User::LeaveIfError(KErrNotSupported); |
|
660 } |
|
661 CleanupStack::PopAndDestroy(); //fsSession |
|
662 |
|
663 } |
|
664 |
|
665 // __________________________________________________________________________ |
|
666 // Exported proxy for instantiation method resolution |
|
667 // Define the interface UIDs |
|
668 const TImplementationProxy ImplementationTable[] = |
|
669 { |
|
670 IMPLEMENTATION_PROXY_ENTRY(KUidCameraUnitTestPlugin, CCamUnitTestPlugin::NewL), |
|
671 IMPLEMENTATION_PROXY_ENTRY(KUidCameraUnitTestInfo, CCamUnitTestPluginInfo::NewL), |
|
672 IMPLEMENTATION_PROXY_ENTRY(KUidCameraUnitTestSecureId, CCamUnitTestPluginSecureId::NewL) |
|
673 }; |
|
674 |
|
675 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) |
|
676 { |
|
677 aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy); |
|
678 |
|
679 return ImplementationTable; |
|
680 } |
|
681 |