|
1 // Copyright (c) 2008-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 // mmcamerasession.cpp |
|
15 // |
|
16 // |
|
17 |
|
18 /** |
|
19 @file |
|
20 @internalComponent |
|
21 */ |
|
22 |
|
23 #include "mmcameraserversession.h" |
|
24 #include "mmcameraservercontroller.h" |
|
25 |
|
26 |
|
27 CMMCameraServerSession::CMMCameraServerSession() |
|
28 :iCameraIndex(0), |
|
29 iHandle(KECamHandleNotKnown), |
|
30 iPriority(KECamNoPriority), |
|
31 iMMCapability(ETrue), |
|
32 iCollaborativeClient(EFalse), |
|
33 iReserved(EFalse), |
|
34 iPoweredUp(EFalse) |
|
35 { |
|
36 } |
|
37 |
|
38 void CMMCameraServerSession::CreateL() |
|
39 { |
|
40 iCameraServer = static_cast<CMMCameraServer*>(const_cast<CServer2*>(CSession2::Server())); |
|
41 // Get server policymanager |
|
42 iPolicyManager = Server()->PolicyManager(); |
|
43 |
|
44 //load camera control etc in OpenCamera... |
|
45 Server()->AddSession(); |
|
46 } |
|
47 |
|
48 CMMCameraServerSession::~CMMCameraServerSession() |
|
49 { |
|
50 // CameraController()->Reset(); |
|
51 Server()->DropSession(); |
|
52 |
|
53 //deque the session queued in controller |
|
54 iCamSessionLink.Deque(); //safe to deque if it does not exists in the queue. |
|
55 iCamSessionLink.iNext = NULL; |
|
56 } |
|
57 |
|
58 void CMMCameraServerSession::Disconnect(const RMessage2 &aMessage) |
|
59 { |
|
60 if(!iOverthrowMessage.IsNull()) |
|
61 { |
|
62 iOverthrowMessage.Complete(KErrCancel); |
|
63 } |
|
64 CSession2::Disconnect(aMessage); |
|
65 } |
|
66 |
|
67 void CMMCameraServerSession::ServiceL(const RMessage2& aMessage) |
|
68 { |
|
69 |
|
70 // Do policy manager checks |
|
71 iPolicyManager->ServiceHandlerL(aMessage); |
|
72 |
|
73 switch (aMessage.Function()) |
|
74 { |
|
75 case ECamQueryCamerasAvailable: |
|
76 { |
|
77 CamerasAvailable(aMessage); |
|
78 break; |
|
79 } |
|
80 |
|
81 case ECamOpenCamera: |
|
82 { |
|
83 OpenCamera(aMessage); |
|
84 break; |
|
85 } |
|
86 |
|
87 case ECamCameraAccessControl: |
|
88 { |
|
89 switch(aMessage.Int0()) |
|
90 { |
|
91 case ECameraRelease: |
|
92 { |
|
93 Release(aMessage); |
|
94 break; |
|
95 } |
|
96 |
|
97 case ECameraReservedNotification: |
|
98 { |
|
99 Reserve(aMessage); |
|
100 break; |
|
101 } |
|
102 |
|
103 case ECameraCancelReservedNotification: |
|
104 { |
|
105 CancelReserve(aMessage); |
|
106 break; |
|
107 } |
|
108 |
|
109 case ECameraOverthrowNotification: |
|
110 { |
|
111 if(iOverthrowMessage.IsNull()) |
|
112 { |
|
113 iOverthrowMessage = aMessage; |
|
114 } |
|
115 else |
|
116 { |
|
117 aMessage.Complete(KErrServerBusy); |
|
118 } |
|
119 break; |
|
120 } |
|
121 |
|
122 case ECameraCancelOverthrowNotification: |
|
123 { |
|
124 if(!iOverthrowMessage.IsNull()) |
|
125 { |
|
126 iOverthrowMessage.Complete(KErrCancel); |
|
127 } |
|
128 CameraController()->Reset(); //Stops VF, VC. Cancels ImageCapture if issued using this session. |
|
129 aMessage.Complete(KErrNone); |
|
130 break; |
|
131 } |
|
132 |
|
133 default: |
|
134 aMessage.Complete(KErrArgument); |
|
135 } |
|
136 break; |
|
137 } |
|
138 case ECamPowerCamera: |
|
139 { |
|
140 switch(aMessage.Int0()) |
|
141 { |
|
142 case ECameraPowerOnNotification: |
|
143 { |
|
144 PowerOn(aMessage); |
|
145 break; |
|
146 } |
|
147 case ECameraPowerOff: |
|
148 { |
|
149 PowerOff(); |
|
150 aMessage.Complete(KErrNone); |
|
151 break; |
|
152 } |
|
153 case ECameraCancelPowerOnNotification: |
|
154 { |
|
155 CancelPowerOn(); |
|
156 aMessage.Complete(KErrNone); |
|
157 break; |
|
158 } |
|
159 } |
|
160 break; |
|
161 } |
|
162 |
|
163 case ECamPrepareDirectViewFinder: |
|
164 { |
|
165 PrepareDirectViewFinder(aMessage); |
|
166 break; |
|
167 } |
|
168 |
|
169 case ECamStartDirectViewFinder: |
|
170 { |
|
171 StartDirectViewFinder(aMessage); |
|
172 break; |
|
173 } |
|
174 |
|
175 case ECamStopDirectViewFinder: |
|
176 { |
|
177 StopDirectViewFinder(aMessage); |
|
178 break; |
|
179 } |
|
180 |
|
181 case ECamPauseDirectViewFinder: |
|
182 { |
|
183 PauseDirectViewFinder(aMessage); |
|
184 break; |
|
185 } |
|
186 |
|
187 case ECamResumeDirectViewFinder: |
|
188 { |
|
189 ResumeDirectViewFinder(aMessage); |
|
190 break; |
|
191 } |
|
192 |
|
193 case ECamDirectViewFinderState: |
|
194 { |
|
195 DirectViewFinderState(aMessage); |
|
196 break; |
|
197 } |
|
198 |
|
199 case ECamSetDirectViewFinderMirror: |
|
200 { |
|
201 SetDirectViewFinderMirror(aMessage); |
|
202 break; |
|
203 } |
|
204 |
|
205 case ECamGetDirectViewFinderMirror: |
|
206 { |
|
207 GetDirectViewFinderMirror(aMessage); |
|
208 break; |
|
209 } |
|
210 |
|
211 case ECamDirectViewFinderProperties: |
|
212 { |
|
213 DirectViewFinderProperties(aMessage); |
|
214 break; |
|
215 } |
|
216 case ECamSetParameter: |
|
217 { |
|
218 SetCameraParameter(aMessage); |
|
219 break; |
|
220 } |
|
221 |
|
222 case ECamGetParameter: |
|
223 { |
|
224 GetCameraParameter(aMessage); |
|
225 break; |
|
226 } |
|
227 |
|
228 case ECamCameraHandle: |
|
229 { |
|
230 CameraHandle(aMessage); |
|
231 break; |
|
232 } |
|
233 |
|
234 default: |
|
235 Server()->PanicClient(aMessage, EPanicNotSupported); |
|
236 break; |
|
237 } |
|
238 } |
|
239 |
|
240 /** |
|
241 * Queries controller to find out how many cameras are available to clients. |
|
242 */ |
|
243 void CMMCameraServerSession::CamerasAvailable(const RMessage2& aMessage) |
|
244 { |
|
245 TCamerasAvailable info; |
|
246 |
|
247 CMMCameraServerControllerQuery* query = NULL; |
|
248 TRAPD(error, Server()->GetCameraControllerQueryL(query)); |
|
249 if (error == KErrNone) |
|
250 { |
|
251 info.iCameraCount = query->GetCamerasAvailable(); |
|
252 delete query; |
|
253 |
|
254 TCamerasAvailablePckg pckg(info); |
|
255 error = aMessage.Write(TInt(0), pckg); |
|
256 } |
|
257 |
|
258 aMessage.Complete(error); |
|
259 } |
|
260 |
|
261 /** |
|
262 * Stores client information and retrieves camera controller for required camera index. |
|
263 * |
|
264 * Called when client connects to the server for the first time. |
|
265 */ |
|
266 void CMMCameraServerSession::OpenCamera(const RMessage2& aMessage) |
|
267 { |
|
268 TOpenCamera parameters; |
|
269 TOpenCameraPckg parametersBuf(parameters); |
|
270 |
|
271 TInt error = aMessage.Read(TInt(0),parametersBuf); |
|
272 if (error != KErrNone) |
|
273 { |
|
274 aMessage.Complete(error); |
|
275 } |
|
276 |
|
277 parameters = parametersBuf(); |
|
278 |
|
279 iCameraIndex = parameters.iCameraIndex; // Store the required member variables |
|
280 iPriority = parameters.iPriority; |
|
281 iMMCapability = parameters.iMMCapability; |
|
282 iHandle = parameters.iHandle; |
|
283 iCollaborativeClient = parameters.iCollaborativeClient; |
|
284 |
|
285 TRAP(error, Server()->GetCameraControllerL(iCameraIndex, iCameraController)); |
|
286 |
|
287 aMessage.Complete(error); |
|
288 } |
|
289 |
|
290 /** |
|
291 * Reserves the camera. |
|
292 * |
|
293 * Delegates the responsibility to the policy manager |
|
294 */ |
|
295 void CMMCameraServerSession::Release(const RMessage2& aMessage) |
|
296 { |
|
297 if(!iReserved) |
|
298 { |
|
299 aMessage.Complete(KErrAlreadyExists); |
|
300 } |
|
301 else |
|
302 { |
|
303 CameraController()->Reset(); //Stops VF, VC. Cancels ImageCapture if issued using this session. |
|
304 |
|
305 iPolicyManager->ReleaseClient(this); |
|
306 |
|
307 iReserved = EFalse; |
|
308 iPoweredUp = EFalse; |
|
309 |
|
310 if(!iOverthrowMessage.IsNull()) |
|
311 { |
|
312 iOverthrowMessage.Complete(KErrCancel); |
|
313 } |
|
314 |
|
315 aMessage.Complete(KErrNone); |
|
316 } |
|
317 } |
|
318 |
|
319 void CMMCameraServerSession::CompleteOverthrow () |
|
320 { |
|
321 if(!iOverthrowMessage.IsNull()) |
|
322 { |
|
323 // Complete means sucess |
|
324 iOverthrowMessage.Complete(KErrNone); |
|
325 } |
|
326 |
|
327 iPoweredUp = EFalse; |
|
328 } |
|
329 |
|
330 /** |
|
331 * Releases the camera. |
|
332 * |
|
333 * Delegates the responsibility to the policy manager |
|
334 */ |
|
335 void CMMCameraServerSession::Reserve(const RMessage2& aMessage) |
|
336 { |
|
337 if (iReserved) |
|
338 { |
|
339 aMessage.Complete(KErrInUse); |
|
340 return; |
|
341 } |
|
342 |
|
343 iReserved = iPolicyManager->ReserveClient(this); |
|
344 |
|
345 if(!iReserved) |
|
346 { |
|
347 aMessage.Complete(KErrAccessDenied); |
|
348 } |
|
349 else |
|
350 { |
|
351 aMessage.Complete(KErrNone); |
|
352 } |
|
353 } |
|
354 |
|
355 /** |
|
356 * Cancels on ongoing Reserve() operation. |
|
357 */ |
|
358 void CMMCameraServerSession::CancelReserve(const RMessage2& aMessage) |
|
359 { |
|
360 Release(aMessage); |
|
361 } |
|
362 |
|
363 /** |
|
364 * Powers on the device. |
|
365 * |
|
366 * Simply returns with KErrNone or KErrNotReady since device is not powered on until VF is activated. |
|
367 */ |
|
368 void CMMCameraServerSession::PowerOn(const RMessage2& aMessage) |
|
369 { |
|
370 if(!iReserved) |
|
371 { |
|
372 aMessage.Complete(KErrNotReady); |
|
373 } |
|
374 else if (iPoweredUp) |
|
375 { |
|
376 aMessage.Complete(KErrInUse); |
|
377 } |
|
378 else |
|
379 { |
|
380 iPoweredUp = ETrue; |
|
381 aMessage.Complete(KErrNone); |
|
382 } |
|
383 } |
|
384 |
|
385 /** |
|
386 * Powers off the device. |
|
387 * |
|
388 * Simply stops any viewfinder activity. |
|
389 */ |
|
390 void CMMCameraServerSession::PowerOff() |
|
391 { |
|
392 CameraController()->Reset(); |
|
393 |
|
394 iPoweredUp = EFalse; |
|
395 } |
|
396 |
|
397 void CMMCameraServerSession::CancelPowerOn() |
|
398 { |
|
399 iPoweredUp = EFalse; |
|
400 } |
|
401 |
|
402 /** |
|
403 * Prepares the view finder. |
|
404 * |
|
405 * First step before viewfinder is started. |
|
406 */ |
|
407 void CMMCameraServerSession::PrepareDirectViewFinder(const RMessage2& aMessage) |
|
408 { |
|
409 TDirectViewFinderInfo viewFinderInfo; |
|
410 TDirectViewFinderInfoPckg viewFinderInfoPckg(viewFinderInfo); |
|
411 |
|
412 TInt error = aMessage.Read(TInt(0), viewFinderInfoPckg); |
|
413 if(error == KErrNone) |
|
414 { |
|
415 viewFinderInfo = viewFinderInfoPckg(); |
|
416 TRAP(error, CameraController()->PrepareDirectViewFinderL(viewFinderInfo)); |
|
417 if(error == KErrNone) |
|
418 { |
|
419 TDirectViewFinderInfoPckg pckg(viewFinderInfo); |
|
420 error = aMessage.Write(TInt(0), pckg); |
|
421 } |
|
422 } |
|
423 |
|
424 aMessage.Complete(error); |
|
425 } |
|
426 |
|
427 /** |
|
428 * Starts the viewfinder |
|
429 */ |
|
430 void CMMCameraServerSession::StartDirectViewFinder(const RMessage2& aMessage) |
|
431 { |
|
432 TInt error = CameraController()->StartDirectViewFinder(); |
|
433 aMessage.Complete(error); |
|
434 } |
|
435 |
|
436 /** |
|
437 * Stops the viewfinder. |
|
438 * |
|
439 * Returns KErrNone even if stop is called when the viewfinder is not active, as client API must fail silently if error occurs. |
|
440 */ |
|
441 void CMMCameraServerSession::StopDirectViewFinder(const RMessage2& aMessage) |
|
442 { |
|
443 if (CameraController()->GetDirectViewFinderState() == CCamera::CCameraV2DirectViewFinder::EViewFinderActive) |
|
444 { |
|
445 CameraController()->StopDirectViewFinder(); |
|
446 } |
|
447 |
|
448 aMessage.Complete(KErrNone); |
|
449 } |
|
450 |
|
451 /** |
|
452 * Pauses the viewfinder. |
|
453 * |
|
454 * Returns KErrNone even if pause is called when the viewfinder is not active, as client API must fail silently if error occurs. |
|
455 */ |
|
456 void CMMCameraServerSession::PauseDirectViewFinder(const RMessage2& aMessage) |
|
457 { |
|
458 if (CameraController()->GetDirectViewFinderState() == CCamera::CCameraV2DirectViewFinder::EViewFinderActive) |
|
459 { |
|
460 CameraController()->PauseDirectViewFinder(); |
|
461 } |
|
462 |
|
463 aMessage.Complete(KErrNone); |
|
464 } |
|
465 |
|
466 /** |
|
467 * Resumes the viewfinder if previously paused. |
|
468 * |
|
469 * Returns KErrNone even if resume is called when the viewfinder is not paused, as client API must fail silently if error occurs. |
|
470 */ |
|
471 void CMMCameraServerSession::ResumeDirectViewFinder(const RMessage2& aMessage) |
|
472 { |
|
473 if (CameraController()->GetDirectViewFinderState() == CCamera::CCameraV2DirectViewFinder::EViewFinderPause) |
|
474 { |
|
475 CameraController()->ResumeDirectViewFinder(); |
|
476 } |
|
477 |
|
478 aMessage.Complete(KErrNone); |
|
479 } |
|
480 |
|
481 /** |
|
482 * Retrieves the state of the viewfinder |
|
483 */ |
|
484 void CMMCameraServerSession::DirectViewFinderState(const RMessage2& aMessage) |
|
485 { |
|
486 TDirectViewFinderState state; |
|
487 |
|
488 state.iState = CameraController()->GetDirectViewFinderState(); |
|
489 |
|
490 TDirectViewFinderStatePckg pckg(state); |
|
491 TInt error = aMessage.Write(TInt(0), pckg); |
|
492 |
|
493 aMessage.Complete(error); |
|
494 } |
|
495 |
|
496 /** |
|
497 * Sets viewfinder mirror mode on or off. |
|
498 */ |
|
499 void CMMCameraServerSession::SetDirectViewFinderMirror(const RMessage2& aMessage) |
|
500 { |
|
501 TViewFinderMirror viewFinderMirror; |
|
502 TViewFinderMirrorPckg pckg(viewFinderMirror); |
|
503 |
|
504 TInt error = aMessage.Read(TInt(0), pckg); |
|
505 if (error == KErrNone) |
|
506 { |
|
507 viewFinderMirror = pckg(); |
|
508 error = CameraController()->SetDirectViewFinderMirror(viewFinderMirror.iMirror); |
|
509 } |
|
510 |
|
511 aMessage.Complete(error); |
|
512 } |
|
513 |
|
514 /** |
|
515 * Retrieves whether viewfinder mirror mode is activated or not. |
|
516 */ |
|
517 void CMMCameraServerSession::GetDirectViewFinderMirror(const RMessage2& aMessage) |
|
518 { |
|
519 TViewFinderMirror viewFinderMirror; |
|
520 |
|
521 TInt error = CameraController()->GetDirectViewFinderMirror(viewFinderMirror.iMirror); |
|
522 if (error == KErrNone) |
|
523 { |
|
524 TViewFinderMirrorPckg pckg(viewFinderMirror); |
|
525 error = aMessage.Write(TInt(0), pckg); |
|
526 } |
|
527 |
|
528 aMessage.Complete(error); |
|
529 } |
|
530 |
|
531 /** |
|
532 * Retrieves the viewfinder properties |
|
533 */ |
|
534 void CMMCameraServerSession::DirectViewFinderProperties(const RMessage2& aMessage) |
|
535 { |
|
536 TDirectViewFinderInfo info; |
|
537 |
|
538 TInt error = CameraController()->DirectViewFinderProperties(info.iScreenNum, info.iScreenRect, info.iClipRect); |
|
539 if (error == KErrNone) |
|
540 { |
|
541 TDirectViewFinderInfoPckg pckg(info); |
|
542 error = aMessage.Write(TInt(0), pckg); |
|
543 } |
|
544 |
|
545 aMessage.Complete(error); |
|
546 } |
|
547 |
|
548 /** |
|
549 * Sets various camera parameters depending on what the client wishes to set. |
|
550 */ |
|
551 void CMMCameraServerSession::SetCameraParameter(const RMessage2& aMessage) |
|
552 { |
|
553 TInt error = KErrNone; |
|
554 |
|
555 switch(aMessage.Int0()) |
|
556 { |
|
557 case EZoomFactor: |
|
558 { |
|
559 TInt zoom = aMessage.Int1(); |
|
560 error = CameraController()->SetZoom(zoom); |
|
561 aMessage.Complete(error); |
|
562 break; |
|
563 } |
|
564 |
|
565 case EDigitalZoomFactor: |
|
566 { |
|
567 TInt digitalZoom = aMessage.Int1(); |
|
568 error = CameraController()->SetDigitalZoom(digitalZoom); |
|
569 aMessage.Complete(error); |
|
570 break; |
|
571 } |
|
572 |
|
573 case EContrast: |
|
574 { |
|
575 TInt contrast = aMessage.Int1(); |
|
576 error = CameraController()->SetContrast(contrast); |
|
577 aMessage.Complete(error); |
|
578 break; |
|
579 } |
|
580 |
|
581 case EBrightness: |
|
582 { |
|
583 TInt brightness = aMessage.Int1(); |
|
584 error = CameraController()->SetBrightness(brightness); |
|
585 aMessage.Complete(error); |
|
586 break; |
|
587 } |
|
588 |
|
589 case EFlash: |
|
590 { |
|
591 TCameraFlash flash; |
|
592 TCameraFlashPckg pckg(flash); |
|
593 |
|
594 error = aMessage.Read(TInt(1), pckg); |
|
595 if (error == KErrNone) |
|
596 { |
|
597 flash = pckg(); |
|
598 error = CameraController()->SetFlash(flash.iFlash); |
|
599 } |
|
600 aMessage.Complete(error); |
|
601 break; |
|
602 } |
|
603 |
|
604 case EExposure: |
|
605 { |
|
606 TCameraExposure exposure; |
|
607 TCameraExposurePckg pckg(exposure); |
|
608 |
|
609 error = aMessage.Read(TInt(1), pckg); |
|
610 if (error == KErrNone) |
|
611 { |
|
612 exposure = pckg(); |
|
613 error = CameraController()->SetExposure(exposure.iExposure); |
|
614 } |
|
615 aMessage.Complete(error); |
|
616 break; |
|
617 } |
|
618 |
|
619 case EWhiteBalance: |
|
620 { |
|
621 TCameraWhiteBalance whiteBalance; |
|
622 TCameraWhiteBalancePckg pckg(whiteBalance); |
|
623 |
|
624 error = aMessage.Read(TInt(1), pckg); |
|
625 if (error == KErrNone) |
|
626 { |
|
627 whiteBalance = pckg(); |
|
628 error = CameraController()->SetWhiteBalance(whiteBalance.iWhiteBalance); |
|
629 } |
|
630 aMessage.Complete(error); |
|
631 break; |
|
632 } |
|
633 |
|
634 default: |
|
635 { |
|
636 Server()->PanicClient(aMessage, EPanicNotSupported); |
|
637 break; |
|
638 } |
|
639 } |
|
640 } |
|
641 |
|
642 /** |
|
643 * Gets various camera parameters depending on what information the client wishes to retrieve. |
|
644 */ |
|
645 void CMMCameraServerSession::GetCameraParameter(const RMessage2& aMessage) |
|
646 { |
|
647 TInt error = KErrNone; |
|
648 |
|
649 switch(aMessage.Int0()) |
|
650 { |
|
651 case EZoomFactor: |
|
652 { |
|
653 TCameraZoom zoom; |
|
654 error = CameraController()->GetZoom(zoom.iZoom); |
|
655 if (error == KErrNone) |
|
656 { |
|
657 TCameraZoomPckg pckg(zoom); |
|
658 error = aMessage.Write(TInt(1), pckg); |
|
659 } |
|
660 break; |
|
661 } |
|
662 |
|
663 case EDigitalZoomFactor: |
|
664 { |
|
665 TCameraDigitalZoom digitalZoom; |
|
666 error = CameraController()->GetDigitalZoom(digitalZoom.iDigitalZoom); |
|
667 if (error == KErrNone) |
|
668 { |
|
669 TCameraDigitalZoomPckg pckg(digitalZoom); |
|
670 error = aMessage.Write(TInt(1), pckg); |
|
671 } |
|
672 break; |
|
673 } |
|
674 |
|
675 case EContrast: |
|
676 { |
|
677 TCameraContrast contrast; |
|
678 error = CameraController()->GetContrast(contrast.iContrast); |
|
679 if (error == KErrNone) |
|
680 { |
|
681 TCameraContrastPckg pckg(contrast); |
|
682 error = aMessage.Write(TInt(1), pckg); |
|
683 } |
|
684 break; |
|
685 } |
|
686 |
|
687 case EBrightness: |
|
688 { |
|
689 TCameraBrightness brightness; |
|
690 error = CameraController()->GetBrightness(brightness.iBrightness); |
|
691 if (error == KErrNone) |
|
692 { |
|
693 TCameraBrightnessPckg pckg(brightness); |
|
694 error = aMessage.Write(TInt(1), pckg); |
|
695 } |
|
696 break; |
|
697 } |
|
698 |
|
699 case EFlash: |
|
700 { |
|
701 TCameraFlash flash; |
|
702 error = CameraController()->GetFlash(flash.iFlash); |
|
703 if (error == KErrNone) |
|
704 { |
|
705 TCameraFlashPckg pckg(flash); |
|
706 error = aMessage.Write(TInt(1), pckg); |
|
707 } |
|
708 break; |
|
709 } |
|
710 |
|
711 case EExposure: |
|
712 { |
|
713 TCameraExposure exposure; |
|
714 error = CameraController()->GetExposure(exposure.iExposure); |
|
715 if (error == KErrNone) |
|
716 { |
|
717 TCameraExposurePckg pckg(exposure); |
|
718 error = aMessage.Write(TInt(1), pckg); |
|
719 } |
|
720 break; |
|
721 } |
|
722 |
|
723 case EWhiteBalance: |
|
724 { |
|
725 TCameraWhiteBalance whiteBalance; |
|
726 error = CameraController()->GetWhiteBalance(whiteBalance.iWhiteBalance); |
|
727 if (error == KErrNone) |
|
728 { |
|
729 TCameraWhiteBalancePckg pckg(whiteBalance); |
|
730 error = aMessage.Write(TInt(1), pckg); |
|
731 } |
|
732 break; |
|
733 } |
|
734 |
|
735 default: |
|
736 { |
|
737 Server()->PanicClient(aMessage, EPanicNotSupported); |
|
738 break; |
|
739 } |
|
740 } |
|
741 |
|
742 aMessage.Complete(error); |
|
743 } |
|
744 |
|
745 /** |
|
746 * Retrives the camera handle |
|
747 */ |
|
748 void CMMCameraServerSession::CameraHandle(const RMessage2& aMessage) |
|
749 { |
|
750 TCameraHandle cameraHandle; |
|
751 |
|
752 cameraHandle.iHandle = CameraController()->CameraHandle(); |
|
753 TCameraHandlePckg pckg(cameraHandle); |
|
754 |
|
755 aMessage.Write(TInt(0), pckg); |
|
756 aMessage.Complete(KErrNone); |
|
757 } |
|
758 |
|
759 void CMMCameraServerSession::SetHandle (TInt aHandle) |
|
760 { |
|
761 iHandle = aHandle; |
|
762 } |
|
763 |
|
764 void CMMCameraServerSession::SetPriority (TInt aPriority) |
|
765 { |
|
766 iPriority = aPriority; |
|
767 } |
|
768 |
|
769 void CMMCameraServerSession::SetReserved (TBool aReserved) |
|
770 { |
|
771 iReserved = aReserved; |
|
772 } |
|
773 |
|
774 CMMCameraServer* CMMCameraServerSession::Server() |
|
775 { |
|
776 return iCameraServer; |
|
777 } |
|
778 |
|
779 CMMCameraServerController* CMMCameraServerSession::CameraController() |
|
780 { |
|
781 return iCameraController; |
|
782 } |