|
1 /* |
|
2 * Copyright (c) 2009-2010 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: |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <xqserviceutil.h> |
|
19 |
|
20 #include "cxeenginesymbian.h" |
|
21 #include "cxecameradevicecontrolsymbian.h" |
|
22 #include "cxestillcapturecontrolsymbian.h" |
|
23 #include "cxevideocapturecontrolsymbian.h" |
|
24 #include "cxesettingscontrolsymbian.h" |
|
25 #include "cxeviewfindercontrolsymbian.h" |
|
26 #include "cxesnapshotcontrol.h" |
|
27 #include "cxefilenamegeneratorsymbian.h" |
|
28 #include "cxeautofocuscontrolsymbian.h" |
|
29 #include "cxezoomcontrolsymbian.h" |
|
30 #include "cxequalitypresetssymbian.h" |
|
31 #include "cxutils.h" |
|
32 #include "cxesettingsimp.h" |
|
33 #include "cxefeaturemanagerimp.h" |
|
34 #include "cxesettingscenrepstore.h" |
|
35 #include "cxesoundplayersymbian.h" |
|
36 #include "cxesensoreventhandlersymbian.h" |
|
37 #include "cxefilesavethread.h" |
|
38 #include "cxecameradevice.h" |
|
39 #include "cxememorymonitor.h" |
|
40 #include "cxediskmonitor.h" |
|
41 #include "cxegeotaggingtrail.h" |
|
42 #include "cxeexception.h" |
|
43 |
|
44 #include "OstTraceDefinitions.h" |
|
45 #ifdef OST_TRACE_COMPILER_IN_USE |
|
46 #include "cxeenginesymbianTraces.h" |
|
47 #endif |
|
48 |
|
49 |
|
50 // Member Functions |
|
51 |
|
52 CxeEngineSymbian::CxeEngineSymbian() |
|
53 : mCameraDeviceControl(NULL), |
|
54 mCameraDevice(NULL), |
|
55 mViewfinderControl(NULL), |
|
56 mSnapshotControl(NULL), |
|
57 mStillCaptureControl(NULL), |
|
58 mVideoCaptureControl(NULL), |
|
59 mSettingsControl(NULL), |
|
60 mAutoFocusControl(NULL), |
|
61 mZoomControl(NULL), |
|
62 mSettings(NULL), |
|
63 mFeatureManager(NULL), |
|
64 mFilenameGenerator(NULL), |
|
65 mSensorEventHandler(NULL), |
|
66 mQualityPresets(NULL), |
|
67 mFileSaveThread(NULL), |
|
68 mDiskMonitor(NULL), |
|
69 mMemoryMonitor(NULL), |
|
70 mGeoTaggingTrail(NULL) |
|
71 { |
|
72 CX_DEBUG_IN_FUNCTION(); |
|
73 } |
|
74 |
|
75 |
|
76 /*! |
|
77 Create all control classes and connect relevant signals |
|
78 */ |
|
79 void CxeEngineSymbian::construct() |
|
80 { |
|
81 CX_DEBUG_ENTER_FUNCTION(); |
|
82 |
|
83 createControls(); |
|
84 connectSignals(); |
|
85 |
|
86 CX_DEBUG_EXIT_FUNCTION(); |
|
87 } |
|
88 |
|
89 |
|
90 /*! |
|
91 Create all control classes. |
|
92 Note: Throws an error, if free memory request by CxeMemoryMonitor constructor fails! |
|
93 */ |
|
94 void CxeEngineSymbian::createControls() |
|
95 { |
|
96 CX_DEBUG_ENTER_FUNCTION(); |
|
97 |
|
98 // Check we do this only once. |
|
99 if (!mSettings) { |
|
100 OstTrace0(camerax_performance, CXEENGINESYMBIAN_CREATECONTROLS_IN, "msg: e_CX_ENGINE_CREATE_CONTROLS 1"); |
|
101 |
|
102 CxeCameraDeviceControlSymbian *deviceControl = new CxeCameraDeviceControlSymbian(); |
|
103 mCameraDeviceControl = deviceControl; |
|
104 mCameraDevice = deviceControl->cameraDevice(); |
|
105 |
|
106 CX_ASSERT_ALWAYS(mCameraDeviceControl); |
|
107 CX_ASSERT_ALWAYS(mCameraDevice); |
|
108 |
|
109 mCameraDeviceControl->init(); |
|
110 |
|
111 CxeSettingsCenRepStore *settingsStore(NULL); |
|
112 if (XQServiceUtil::isService()) { |
|
113 settingsStore = new CxeSettingsLocalStore(); |
|
114 } else { |
|
115 settingsStore = new CxeSettingsCenRepStore(); |
|
116 } |
|
117 |
|
118 //ownership of settings store transferred to the settings |
|
119 mSettings = new CxeSettingsImp(settingsStore); |
|
120 |
|
121 // Loading current camera mode value from settings store and updating |
|
122 // devicecontrol |
|
123 Cxe::CameraMode cameraMode = Cxe::ImageMode; |
|
124 |
|
125 try { |
|
126 cameraMode = mSettings->get<Cxe::CameraMode>(CxeSettingIds::CAMERA_MODE); |
|
127 } catch (CxeException &e) { |
|
128 CX_DEBUG(("Failed to read camera mode from settings, using image mode. Error code: %d", e.error())); |
|
129 } |
|
130 |
|
131 // set current camera mode to devicecontrol. |
|
132 mCameraDeviceControl->setMode(cameraMode); |
|
133 |
|
134 //! @todo a temporary hack to change the startup sequence to avoid GOOM problems |
|
135 static_cast<CxeSettingsImp*>(mSettings)->loadSettings(mode()); |
|
136 |
|
137 |
|
138 // Connect P&S key updates to settings signal. |
|
139 connect(settingsStore, SIGNAL(settingValueChanged(long int, unsigned long int, QVariant)), |
|
140 mSettings, SIGNAL(settingValueChanged(long int, unsigned long int, QVariant))); |
|
141 |
|
142 mFeatureManager = new CxeFeatureManagerImp(*mSettings); |
|
143 |
|
144 // Memory monitor needed as early as possible to request free memory. |
|
145 // Note: Throws error if enough memory cannot be freed! |
|
146 mMemoryMonitor = new CxeMemoryMonitor(*mFeatureManager); |
|
147 |
|
148 mDiskMonitor = new CxeDiskMonitor(*mSettings); |
|
149 |
|
150 mQualityPresets = new CxeQualityPresetsSymbian(*mSettings); |
|
151 CX_DEBUG_ASSERT(mQualityPresets); |
|
152 |
|
153 // sensor event handler initialization |
|
154 mSensorEventHandler = new CxeSensorEventHandlerSymbian(); |
|
155 |
|
156 mFilenameGenerator = new CxeFilenameGeneratorSymbian(*mSettings, |
|
157 mode()); |
|
158 |
|
159 mViewfinderControl = new CxeViewfinderControlSymbian(*mCameraDevice, |
|
160 *mCameraDeviceControl); |
|
161 |
|
162 mSnapshotControl = new CxeSnapshotControl(*mCameraDevice); |
|
163 |
|
164 mAutoFocusControl = new CxeAutoFocusControlSymbian(*mCameraDevice, |
|
165 *mSettings); |
|
166 |
|
167 mFileSaveThread = CxeFileSaveThreadFactory::createFileSaveThread(); |
|
168 |
|
169 mStillCaptureControl = new CxeStillCaptureControlSymbian( |
|
170 *mCameraDevice, *mViewfinderControl, *mSnapshotControl, *mCameraDeviceControl, |
|
171 *mFilenameGenerator, *mSensorEventHandler, *mAutoFocusControl, |
|
172 *mSettings, *mQualityPresets, *mFileSaveThread, *mDiskMonitor); |
|
173 |
|
174 mZoomControl = new CxeZoomControlSymbian( |
|
175 *mCameraDevice, *mCameraDeviceControl, *mSettings, *mFeatureManager); |
|
176 |
|
177 mVideoCaptureControl = new CxeVideoCaptureControlSymbian( |
|
178 *mCameraDevice, *mViewfinderControl, *mSnapshotControl, *mCameraDeviceControl, |
|
179 *mFilenameGenerator, *mSettings, *mQualityPresets, *mDiskMonitor); |
|
180 |
|
181 mSettingsControl = new CxeSettingsControlSymbian(*mCameraDevice, *mSettings); |
|
182 |
|
183 mGeoTaggingTrail = new CxeGeoTaggingTrail(*mStillCaptureControl, |
|
184 *mVideoCaptureControl, |
|
185 *mSettings); |
|
186 |
|
187 OstTrace0(camerax_performance, CXEENGINESYMBIAN_CREATECONTROLS_OUT, "msg: e_CX_ENGINE_CREATE_CONTROLS 0"); |
|
188 } |
|
189 |
|
190 CX_DEBUG_EXIT_FUNCTION(); |
|
191 } |
|
192 |
|
193 /*! |
|
194 Connect internal signals for control classes |
|
195 */ |
|
196 void CxeEngineSymbian::connectSignals() |
|
197 { |
|
198 CX_DEBUG_ENTER_FUNCTION(); |
|
199 OstTrace0(camerax_performance, CXEENGINESYMBIAN_CONNECTSIGNALS_IN, "msg: e_CX_ENGINE_CONNECT_SIGNALS 1"); |
|
200 |
|
201 // enabling scene setting change callbacks to Autofocus control |
|
202 mSettings->listenForSetting(CxeSettingIds::IMAGE_SCENE_DATA, mAutoFocusControl, SLOT(handleSceneChanged(const QVariant&))); |
|
203 mSettings->listenForSetting(CxeSettingIds::VIDEO_SCENE_DATA, mAutoFocusControl, SLOT(handleSceneChanged(const QVariant&))); |
|
204 |
|
205 // connecting Autofocus state change callbacks to stillcapturecontrol |
|
206 connect(mAutoFocusControl, |
|
207 SIGNAL(stateChanged(CxeAutoFocusControl::State, CxeError::Id)), |
|
208 mStillCaptureControl, |
|
209 SLOT(handleAutofocusStateChanged(CxeAutoFocusControl::State,CxeError::Id))); |
|
210 |
|
211 // Connect signals for ECam events |
|
212 connect(mCameraDeviceControl, |
|
213 SIGNAL(cameraEvent(int,int)), |
|
214 mSnapshotControl, |
|
215 SLOT(handleCameraEvent(int,int))); |
|
216 |
|
217 connect(mCameraDeviceControl, |
|
218 SIGNAL(cameraEvent(int,int)), |
|
219 mAutoFocusControl, |
|
220 SLOT(handleCameraEvent(int,int))); |
|
221 |
|
222 connect(mCameraDeviceControl, |
|
223 SIGNAL(cameraEvent(int,int)), |
|
224 mStillCaptureControl, |
|
225 SLOT(handleCameraEvent(int,int))); |
|
226 |
|
227 // Connect signal for device ready events |
|
228 connect(mCameraDeviceControl, |
|
229 SIGNAL(deviceReady()), |
|
230 this, |
|
231 SLOT(doInit())); |
|
232 |
|
233 // Connect image and video init complete signals to |
|
234 // CameraDeviceControl initModeComplete |
|
235 connect(mStillCaptureControl, |
|
236 SIGNAL(imagePrepareComplete(CxeError::Id)), |
|
237 mCameraDeviceControl, |
|
238 SIGNAL(initModeComplete(CxeError::Id))); |
|
239 |
|
240 connect(mVideoCaptureControl, |
|
241 SIGNAL(videoPrepareComplete(CxeError::Id)), |
|
242 mCameraDeviceControl, |
|
243 SIGNAL(initModeComplete(CxeError::Id))); |
|
244 |
|
245 // Zoom is prepared once the image/video emits prepare zoom signals |
|
246 connect(mStillCaptureControl, |
|
247 SIGNAL(prepareZoomForStill(int)), |
|
248 mZoomControl, |
|
249 SLOT(prepareZoomForStill(int))); |
|
250 |
|
251 connect(mVideoCaptureControl, |
|
252 SIGNAL(prepareZoomForVideo()), |
|
253 mZoomControl, |
|
254 SLOT(prepareZoomForVideo())); |
|
255 |
|
256 // Connect file saving thread to snapshot signals and video saved signal. |
|
257 // Image saving it handles internally. |
|
258 connect(mStillCaptureControl, |
|
259 SIGNAL(snapshotReady(CxeError::Id, const QImage&, int)), |
|
260 mFileSaveThread, |
|
261 SLOT(handleSnapshotReady(CxeError::Id, const QImage&, int))); |
|
262 connect(mVideoCaptureControl, |
|
263 SIGNAL(videoComposed(CxeError::Id, const QString&)), |
|
264 mFileSaveThread, |
|
265 SLOT(handleVideoSaved(CxeError::Id, const QString&))); |
|
266 connect(mVideoCaptureControl, |
|
267 SIGNAL(snapshotReady(CxeError::Id, const QImage&, const QString&)), |
|
268 mFileSaveThread, |
|
269 SLOT(handleSnapshotReady(CxeError::Id, const QImage&, const QString&))); |
|
270 |
|
271 // stop location trail when releasing camera. |
|
272 connect(mCameraDevice, |
|
273 SIGNAL(prepareForRelease()), |
|
274 mGeoTaggingTrail, |
|
275 SLOT(stop()), |
|
276 Qt::UniqueConnection); |
|
277 |
|
278 // Use MCameraUseCaseHint API before calling Reserve() |
|
279 connect(mCameraDevice, |
|
280 SIGNAL(aboutToReserve()), |
|
281 mStillCaptureControl, |
|
282 SLOT(hintUseCase()), |
|
283 Qt::UniqueConnection); |
|
284 connect(mCameraDevice, |
|
285 SIGNAL(aboutToReserve()), |
|
286 mVideoCaptureControl, |
|
287 SLOT(hintUseCase()), |
|
288 Qt::UniqueConnection); |
|
289 |
|
290 // Start / stop geotagging based on mode. |
|
291 // Do this later to reduce startup time. |
|
292 connect(mStillCaptureControl, |
|
293 SIGNAL(imagePrepareComplete(CxeError::Id)), |
|
294 this, |
|
295 SLOT(initGeotagging())); |
|
296 connect(mVideoCaptureControl, |
|
297 SIGNAL(videoPrepareComplete(CxeError::Id)), |
|
298 this, |
|
299 SLOT(initGeotagging())); |
|
300 |
|
301 OstTrace0(camerax_performance, CXEENGINESYMBIAN_CONNECTSIGNALS_OUT, "msg: e_CX_ENGINE_CONNECT_SIGNALS 0"); |
|
302 |
|
303 CX_DEBUG_EXIT_FUNCTION(); |
|
304 } |
|
305 |
|
306 CxeEngineSymbian::~CxeEngineSymbian() |
|
307 { |
|
308 CX_DEBUG_ENTER_FUNCTION(); |
|
309 |
|
310 // Saving current camera mode to cenrep |
|
311 saveMode(); |
|
312 |
|
313 delete mGeoTaggingTrail; |
|
314 delete mAutoFocusControl; |
|
315 delete mZoomControl; |
|
316 delete mSettingsControl; |
|
317 delete mStillCaptureControl; |
|
318 delete mVideoCaptureControl; |
|
319 delete mSnapshotControl; |
|
320 delete mViewfinderControl; |
|
321 delete mFilenameGenerator; |
|
322 delete mDiskMonitor; |
|
323 delete mMemoryMonitor; |
|
324 delete mFeatureManager; |
|
325 delete mSettings; |
|
326 delete mCameraDeviceControl; |
|
327 delete mQualityPresets; |
|
328 delete mFileSaveThread; |
|
329 |
|
330 CX_DEBUG_EXIT_FUNCTION(); |
|
331 } |
|
332 |
|
333 CxeCameraDeviceControl &CxeEngineSymbian::cameraDeviceControl() |
|
334 { |
|
335 return *mCameraDeviceControl; |
|
336 } |
|
337 |
|
338 CxeViewfinderControl &CxeEngineSymbian::viewfinderControl() |
|
339 { |
|
340 return *mViewfinderControl; |
|
341 } |
|
342 |
|
343 CxeSnapshotControl &CxeEngineSymbian::snapshotControl() |
|
344 { |
|
345 return *mSnapshotControl; |
|
346 } |
|
347 |
|
348 CxeStillCaptureControl &CxeEngineSymbian::stillCaptureControl() |
|
349 { |
|
350 return *mStillCaptureControl; |
|
351 } |
|
352 |
|
353 CxeVideoCaptureControl &CxeEngineSymbian::videoCaptureControl() |
|
354 { |
|
355 return *mVideoCaptureControl; |
|
356 } |
|
357 |
|
358 CxeAutoFocusControl &CxeEngineSymbian::autoFocusControl() |
|
359 { |
|
360 return *mAutoFocusControl; |
|
361 } |
|
362 |
|
363 CxeZoomControl &CxeEngineSymbian::zoomControl() |
|
364 { |
|
365 return *mZoomControl; |
|
366 } |
|
367 |
|
368 /*! |
|
369 Returns the settings handle |
|
370 */ |
|
371 CxeSettings &CxeEngineSymbian::settings() |
|
372 { |
|
373 return *mSettings; |
|
374 } |
|
375 |
|
376 /*! |
|
377 Returns the sensor event handle |
|
378 */ |
|
379 CxeSensorEventHandler &CxeEngineSymbian::sensorEventHandler() |
|
380 { |
|
381 return *mSensorEventHandler; |
|
382 } |
|
383 |
|
384 |
|
385 CxeFeatureManager &CxeEngineSymbian::featureManager() |
|
386 { |
|
387 return *mFeatureManager; |
|
388 } |
|
389 |
|
390 /*! |
|
391 * Returns memory monitor utility handle. |
|
392 */ |
|
393 CxeMemoryMonitor &CxeEngineSymbian::memoryMonitor() |
|
394 { |
|
395 return *mMemoryMonitor; |
|
396 } |
|
397 |
|
398 |
|
399 /*! |
|
400 Returns geotaggingtrail handle |
|
401 */ |
|
402 CxeGeoTaggingTrail &CxeEngineSymbian::geoTaggingTrail() |
|
403 { |
|
404 return *mGeoTaggingTrail; |
|
405 } |
|
406 |
|
407 /*! |
|
408 * Returns true, if the engine is ready or else false. |
|
409 */ |
|
410 bool CxeEngineSymbian::isEngineReady() |
|
411 { |
|
412 bool ready = false; |
|
413 if (mCameraDeviceControl->state() == CxeCameraDeviceControl::Ready && |
|
414 mViewfinderControl->state() == CxeViewfinderControl::Running) { |
|
415 if (mode() == Cxe::ImageMode) { |
|
416 if (mStillCaptureControl->state() == CxeStillCaptureControl::Ready) { |
|
417 ready = true; |
|
418 } |
|
419 } else if (mode() == Cxe::VideoMode) { |
|
420 if (mVideoCaptureControl->state() == CxeVideoCaptureControl::Ready) { |
|
421 ready = true; |
|
422 } |
|
423 } |
|
424 } |
|
425 return ready; |
|
426 } |
|
427 |
|
428 /*! |
|
429 Prepare current capture control (CxeVideoCaptureControl in video mode, |
|
430 CxeStillCaptureControl in still image mode). |
|
431 */ |
|
432 void CxeEngineSymbian::doInit() |
|
433 { |
|
434 CX_DEBUG_ENTER_FUNCTION(); |
|
435 OstTrace0(camerax_performance, CXEENGINESYMBIAN_DOINIT_IN, "msg: e_CX_ENGINE_DO_INIT 1"); |
|
436 |
|
437 mFilenameGenerator->init(mode()); |
|
438 // load settings whenever we change mode or start camera or switch camera |
|
439 CxeSettingsImp *settingsImp = qobject_cast<CxeSettingsImp*>(mSettings); |
|
440 if (settingsImp) { |
|
441 settingsImp->loadSettings(mode()); |
|
442 } |
|
443 |
|
444 if (mode() == Cxe::ImageMode) { |
|
445 mVideoCaptureControl->deinit(); |
|
446 mStillCaptureControl->init(); |
|
447 } else if (mode() == Cxe::VideoMode) { |
|
448 mStillCaptureControl->deinit(); |
|
449 mVideoCaptureControl->init(); |
|
450 } |
|
451 |
|
452 OstTrace0(camerax_performance, CXEENGINESYMBIAN_DOINIT_OUT, "msg: e_CX_ENGINE_DO_INIT 0"); |
|
453 |
|
454 CX_DEBUG_EXIT_FUNCTION(); |
|
455 } |
|
456 |
|
457 /*! |
|
458 * Returns camera mode. |
|
459 */ |
|
460 Cxe::CameraMode CxeEngineSymbian::mode() const |
|
461 { |
|
462 return mCameraDeviceControl->mode(); |
|
463 } |
|
464 |
|
465 /*! |
|
466 * Sets the camera mode. |
|
467 * \parama mode New camera mode |
|
468 */ |
|
469 void CxeEngineSymbian::setMode(Cxe::CameraMode mode) |
|
470 { |
|
471 CX_DEBUG_ENTER_FUNCTION(); |
|
472 mCameraDeviceControl->setMode(mode); |
|
473 CX_DEBUG_EXIT_FUNCTION(); |
|
474 } |
|
475 /*! |
|
476 Check if we need to reserve camera. |
|
477 */ |
|
478 bool CxeEngineSymbian::reserveNeeded() |
|
479 { |
|
480 // If camera device control is in Idle or pending release state, |
|
481 // we need to call reserve() |
|
482 return (mCameraDeviceControl->state() == CxeCameraDeviceControl::Idle || |
|
483 mCameraDeviceControl->state() == CxeCameraDeviceControl::PendingRelease); |
|
484 } |
|
485 |
|
486 /*! |
|
487 Check if we need to prepare image/video capture. |
|
488 */ |
|
489 bool CxeEngineSymbian::initNeeded() |
|
490 { |
|
491 bool result = false; |
|
492 |
|
493 if (mCameraDeviceControl->state() == CxeCameraDeviceControl::Ready) { |
|
494 if (mode() == Cxe::ImageMode) { |
|
495 if(mStillCaptureControl->state() == CxeStillCaptureControl::Uninitialized) { |
|
496 // We're in still image mode, camera is reserved and ready, but |
|
497 // we need to prepare still image control |
|
498 result = true; |
|
499 } |
|
500 } else if (mode() == Cxe::VideoMode) { |
|
501 if (mVideoCaptureControl->state() == CxeVideoCaptureControl::Idle || |
|
502 mVideoCaptureControl->state() == CxeVideoCaptureControl::Initialized) { |
|
503 // We're in video mode, camera is reserved and ready, but |
|
504 // we need to prepare for video recording. |
|
505 result = true; |
|
506 } |
|
507 } |
|
508 } |
|
509 |
|
510 return result; |
|
511 } |
|
512 |
|
513 /*! |
|
514 Check if we need to start viewfinder. |
|
515 */ |
|
516 bool CxeEngineSymbian::startViewfinderNeeded() |
|
517 { |
|
518 bool result = false; |
|
519 |
|
520 if (mViewfinderControl->state() != CxeViewfinderControl::Running) { |
|
521 if (mode() == Cxe::ImageMode && |
|
522 mStillCaptureControl->state() == CxeStillCaptureControl::Ready) { |
|
523 // We're in still image mode and ready for capturing... we just need to |
|
524 // start viewfinder. |
|
525 result = true; |
|
526 } else if (mode() == Cxe::VideoMode && |
|
527 mVideoCaptureControl->state() == CxeVideoCaptureControl::Ready) { |
|
528 // We're in video mode and ready for capturing... we just need to |
|
529 // start viewfinder. |
|
530 result = true; |
|
531 } |
|
532 } |
|
533 |
|
534 return result; |
|
535 } |
|
536 |
|
537 void CxeEngineSymbian::initMode(Cxe::CameraMode cameraMode) |
|
538 { |
|
539 CX_DEBUG_ENTER_FUNCTION(); |
|
540 OstTrace0(camerax_performance, CXEENGINE_INITMODE_IN, "msg: e_CX_ENGINE_INIT_MODE 1"); |
|
541 |
|
542 if (mode() == cameraMode) { |
|
543 CX_DEBUG(("initMode() called for current mode")); |
|
544 |
|
545 // We're already in the requested mode. However, it is possible |
|
546 // that we need to reserve and power on camera and/or prepare |
|
547 // the capture control. |
|
548 if (reserveNeeded()) { |
|
549 // Camera needs to be reserved. Initialization will continue |
|
550 // when we get the deviceReady() signal. |
|
551 CX_DEBUG(("initMode() - calling reserve()")); |
|
552 reserve(); |
|
553 } else if (initNeeded()) { |
|
554 // Camera is reserved and ready, but we need to prepare still image control or |
|
555 // video capture control |
|
556 CX_DEBUG(("initMode() - calling doInit()")); |
|
557 doInit(); |
|
558 } else if (startViewfinderNeeded()) { |
|
559 // Everything is ready and prepared, but we viewfinder is not yet running |
|
560 CX_DEBUG(("initMode() - calling viewfinder start()")); |
|
561 mViewfinderControl->start(); |
|
562 } else { |
|
563 CX_DEBUG(("initMode() - no actions needed")); |
|
564 // Do nothing. |
|
565 // We are either already ready to capture or the we're pending |
|
566 // on prepare complete callback. |
|
567 } |
|
568 } else { |
|
569 CX_DEBUG(("initMode() called for mode switch")); |
|
570 |
|
571 // Mode switch |
|
572 mCameraDeviceControl->setMode(cameraMode); |
|
573 // stop the vf |
|
574 mViewfinderControl->stop(); |
|
575 |
|
576 if (reserveNeeded()) { |
|
577 CX_DEBUG(("initMode() - calling reserve()")); |
|
578 reserve(); |
|
579 } else if (mCameraDeviceControl->state() == CxeCameraDeviceControl::Ready) { |
|
580 CX_DEBUG(("initMode() - calling doInit()")); |
|
581 // Camera device is ready... we only need to prepare video or still |
|
582 // capture control, depending on current mode. |
|
583 doInit(); |
|
584 } else { |
|
585 CX_DEBUG(("initMode() - no actions needed")); |
|
586 // Do nothing. |
|
587 // Camera device control is in Initializing state. Initialization will continue |
|
588 // when we get the deviceReady() callback. |
|
589 } |
|
590 } |
|
591 |
|
592 OstTrace0(camerax_performance, CXEENGINE_INITMODE_OUT, "msg: e_CX_ENGINE_INIT_MODE 0"); |
|
593 CX_DEBUG_EXIT_FUNCTION(); |
|
594 } |
|
595 |
|
596 void CxeEngineSymbian::reserve() |
|
597 { |
|
598 CX_DEBUG_ENTER_FUNCTION(); |
|
599 // Start reserving camera HW. |
|
600 mCameraDeviceControl->reserve(); |
|
601 emit reserveStarted(); |
|
602 CX_DEBUG_EXIT_FUNCTION(); |
|
603 } |
|
604 |
|
605 |
|
606 /*! |
|
607 * Saves current mode to the cenrep |
|
608 */ |
|
609 void CxeEngineSymbian::saveMode() |
|
610 { |
|
611 CX_DEBUG_ENTER_FUNCTION(); |
|
612 |
|
613 if (mCameraDeviceControl && mSettings) { |
|
614 try { |
|
615 mSettings->set(CxeSettingIds::CAMERA_MODE, mCameraDeviceControl->mode()); |
|
616 } catch (CxeException &e) { |
|
617 CX_DEBUG(("Failed to save camera mode, error=%d", e.error())); |
|
618 } |
|
619 } |
|
620 |
|
621 CX_DEBUG_EXIT_FUNCTION(); |
|
622 } |
|
623 |
|
624 |
|
625 /*! |
|
626 * Initialize geotagging. |
|
627 * Check if we are allowed to start the geotagging and if it's supported in current mode. |
|
628 */ |
|
629 void CxeEngineSymbian::initGeotagging() |
|
630 { |
|
631 CX_DEBUG_ENTER_FUNCTION(); |
|
632 OstTrace0(camerax_performance, CXEENGINE_START_GEO_IN, "msg: e_CX_ENGINE_START_GEOTAGGING 1"); |
|
633 |
|
634 if (mGeoTaggingTrail && mSettings) { |
|
635 if (mode() == Cxe::ImageMode) { |
|
636 // Location trail is limited to image mode only for now. |
|
637 Cxe::GeoTaggingDisclaimer value = |
|
638 mSettings->get<Cxe::GeoTaggingDisclaimer>( |
|
639 CxeSettingIds::GEOTAGGING_DISCLAIMER, Cxe::GeoTaggingDisclaimerDisabled); |
|
640 |
|
641 // we start location trail only when Geotagging First-time-use note is accepted by user. |
|
642 if (value == Cxe::GeoTaggingDisclaimerDisabled) { |
|
643 mGeoTaggingTrail->start(); |
|
644 } |
|
645 } else { |
|
646 // Geotagging is not (yet) supported in video mode. |
|
647 mGeoTaggingTrail->stop(); |
|
648 } |
|
649 } |
|
650 |
|
651 OstTrace0(camerax_performance, CXEENGINE_START_GEO_OUT, "msg: e_CX_ENGINE_START_GEOTAGGING 0"); |
|
652 CX_DEBUG_EXIT_FUNCTION(); |
|
653 } |
|
654 |
|
655 // End of file |