|
1 /* |
|
2 * Copyright (c) 2009 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: Juha Kauppinen, Mika Hokkanen |
|
13 * |
|
14 * Description: Photo Browser |
|
15 * |
|
16 */ |
|
17 |
|
18 // Include files |
|
19 #include <e32uid.h> |
|
20 #include <BAUTILS.H> |
|
21 #include <IEImageProcessing.h>//thumbnail client |
|
22 #include "IEEngineImp.h" |
|
23 #ifdef IMAGE_EDITOR |
|
24 #include "IEEditor.h" |
|
25 #endif |
|
26 #include "IEFileLoader.h" |
|
27 #include "IEImageList.h" |
|
28 #include "ImageMonitorAO.h" |
|
29 #include "IEImageList.h" |
|
30 #include "IEEngineUtils.h" |
|
31 |
|
32 |
|
33 // ============================ MEMBER FUNCTIONS =========================== // |
|
34 |
|
35 EXPORT_C CIEEngine* CIEEngine::NewL(MIEEngineObserver& aObserver) |
|
36 { |
|
37 DP0_IMAGIC(_L("CIEEngine::NewL")); |
|
38 return CIEEngineImp::NewL(aObserver); |
|
39 } |
|
40 |
|
41 EXPORT_C CIEEngine::~CIEEngine() |
|
42 { |
|
43 |
|
44 } |
|
45 |
|
46 CIEEngineImp* CIEEngineImp::NewL(MIEEngineObserver& aObserver) |
|
47 { |
|
48 DP0_IMAGIC(_L("CIEEngine::NewL")); |
|
49 CIEEngineImp* self = new (ELeave) CIEEngineImp(aObserver); |
|
50 CleanupStack::PushL(self); |
|
51 self->ConstructL(); |
|
52 CleanupStack::Pop(); |
|
53 return self; |
|
54 } |
|
55 |
|
56 CIEEngineImp::~CIEEngineImp() |
|
57 { |
|
58 DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp++")); |
|
59 |
|
60 #if 0 |
|
61 if(iIEImageProcessing) |
|
62 { |
|
63 delete iIEImageProcessing; |
|
64 iIEImageProcessing = NULL; |
|
65 } |
|
66 #endif |
|
67 |
|
68 #ifdef IMAGE_EDITOR |
|
69 if(iImageEditor) |
|
70 { |
|
71 DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iImageEditor")); |
|
72 delete iImageEditor; |
|
73 iImageEditor = NULL; |
|
74 } |
|
75 #endif |
|
76 |
|
77 if(iFileLoader) |
|
78 { |
|
79 DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iFileLoader")); |
|
80 delete iFileLoader; |
|
81 iFileLoader = NULL; |
|
82 } |
|
83 |
|
84 if(iBitmapLoader) |
|
85 { |
|
86 DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iBitmapLoader")); |
|
87 iBitmapLoader->CancelFullSizeLoading(); |
|
88 DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iBitmapLoader 2")); |
|
89 delete iBitmapLoader; |
|
90 iBitmapLoader = NULL; |
|
91 } |
|
92 |
|
93 if(iIEBgpsController) |
|
94 { |
|
95 DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iIEBgpsController")); |
|
96 delete iIEBgpsController; |
|
97 iIEBgpsController = NULL; |
|
98 } |
|
99 #ifdef _ACCELEROMETER_SUPPORTED_ |
|
100 if(iSensorMonitor) |
|
101 { |
|
102 iSensorMonitor->StopMonitoring(); |
|
103 delete iSensorMonitor; |
|
104 iSensorMonitor = NULL; |
|
105 } |
|
106 #endif //_ACCELEROMETER_SUPPORTED_ |
|
107 |
|
108 iFileServer.Close(); |
|
109 iCritical.Close(); |
|
110 |
|
111 DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp--")); |
|
112 } |
|
113 |
|
114 CIEEngineImp::CIEEngineImp(MIEEngineObserver& aObserver) : |
|
115 iEngineObserver(aObserver), |
|
116 iIEEngineUtils(iFileServer) |
|
117 { |
|
118 } |
|
119 |
|
120 void CIEEngineImp::ConstructL() |
|
121 { |
|
122 DP0_IMAGIC(_L("CIEEngine::ConstructL++")); |
|
123 |
|
124 iCritical.CreateLocal(); |
|
125 |
|
126 User::LeaveIfError(iFileServer.Connect()); |
|
127 |
|
128 /*Creating Engine Utility class pointer */ |
|
129 iCurrentEditingMode = EEditModeNone; |
|
130 iEditingMode = EEditModeNone; |
|
131 iImageEdited = EFalse; |
|
132 iImageArrayMode = EImages; |
|
133 iAllFilesScanned = EFalse; |
|
134 iPrevDeviceOrientation = EOrientationDisplayLeftUp; |
|
135 |
|
136 |
|
137 TInt err = KErrNone; |
|
138 //Create Bitmap loader |
|
139 iBitmapLoader = CIEBitmapLoader::NewL(iFileServer, *this, &iCritical); |
|
140 //Create BGPS controller |
|
141 iIEBgpsController = CIEBgpsController::NewL(iFileServer, *this, iIEEngineUtils, &iCritical); |
|
142 //Create Fileloader |
|
143 TRAP(err, iFileLoader = CIEFileLoader::NewL(iFileServer, this, &iCritical)); |
|
144 if(err != KErrNone) |
|
145 { |
|
146 DP1_IMAGIC(_L("CIEEngine::ConstructL - Error creating file loader, err: %d"),err); |
|
147 User::Leave(err); |
|
148 } |
|
149 |
|
150 #ifdef _ACCELEROMETER_SUPPORTED_ |
|
151 iDeviceOrientation = EOrientationDisplayLeftUp; |
|
152 err = KErrNone; |
|
153 TRAP(err, iSensorMonitor = CIESensorMonitor::NewL(*this)); |
|
154 DP1_IMAGIC(_L("CIEEngine::ConstructL - iSensorMonitor error: %d"), err); |
|
155 if(err == KErrNone) |
|
156 { |
|
157 DP0_IMAGIC(_L("CIEEngine::ConstructL - iSensorMonitor->StartMonitoring()")); |
|
158 iSensorMonitor->StartMonitoring(); |
|
159 } |
|
160 else |
|
161 { |
|
162 iSensorMonitor = NULL; |
|
163 } |
|
164 |
|
165 #endif |
|
166 |
|
167 iIEBgpsController->SetFileLoader(iFileLoader); |
|
168 |
|
169 DP0_IMAGIC(_L("CIEEngine::ConstructL--")); |
|
170 } |
|
171 |
|
172 void CIEEngineImp::SetDBChanged(CImageData* aImageData) |
|
173 { |
|
174 TFileName filename; |
|
175 aImageData->GetFileName(filename, EFullSize); |
|
176 iFileLoader->GetImageList().SetChanged(filename); |
|
177 } |
|
178 |
|
179 CIEImageList& CIEEngineImp::GetImageList() |
|
180 { |
|
181 return iFileLoader->GetImageList(); |
|
182 } |
|
183 |
|
184 void CIEEngineImp::AppUIReady() |
|
185 { |
|
186 DP0_IMAGIC(_L("CIEEngine::AppUIReady")); |
|
187 |
|
188 //Create ImageProcessing |
|
189 iIEBgpsController->CreateImageProcessing(); |
|
190 } |
|
191 |
|
192 void CIEEngineImp::CancelFullSizeLoading() |
|
193 { |
|
194 DP0_IMAGIC(_L("CIEEngine::CancelLoading")); |
|
195 |
|
196 iBitmapLoader->CancelFullSizeLoading(); |
|
197 } |
|
198 |
|
199 |
|
200 void CIEEngineImp::SetImageDataMode(TImageArrayMode aMode) |
|
201 { |
|
202 iImageArrayMode = aMode; |
|
203 |
|
204 iBitmapLoader->SetImageDataMode(aMode); |
|
205 } |
|
206 |
|
207 MIEEngineObserver& CIEEngineImp::GetObserver() |
|
208 { |
|
209 return iEngineObserver; |
|
210 } |
|
211 |
|
212 void CIEEngineImp::TNGenerationComplete(TThumbSize aTNRes) |
|
213 { |
|
214 DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete++")); |
|
215 |
|
216 iEngineObserver.TNCreationCompleteL(aTNRes); |
|
217 |
|
218 DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete--")); |
|
219 } |
|
220 |
|
221 void CIEEngineImp::SingleTNGenerationComplete(TInt aIndex, TThumbSize aTNRes) |
|
222 { |
|
223 DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete++")); |
|
224 |
|
225 iEngineObserver.SingleTNCreationCompletedL(aIndex, aTNRes); |
|
226 |
|
227 DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete--")); |
|
228 } |
|
229 |
|
230 void CIEEngineImp::FaceDetectionComplete() |
|
231 { |
|
232 DP0_IMAGIC(_L("CIEEngine::FaceDetectionComplete")); |
|
233 iEngineObserver.FaceDetectionComplete(); |
|
234 } |
|
235 |
|
236 void CIEEngineImp::SingleFaceDetectionComplete() |
|
237 { |
|
238 DP0_IMAGIC(_L("CIEEngine::SingleFaceDetectionComplete")); |
|
239 |
|
240 iEngineObserver.SingleFaceDetectionComplete(); |
|
241 } |
|
242 |
|
243 void CIEEngineImp::AllFilesAddedToFilenameArrayL() |
|
244 { |
|
245 DP0_IMAGIC(_L("CIEEngine::AllFilesAddedToFilenameArrayL")); |
|
246 |
|
247 iIEBgpsController->AllFilesAddedToFilenameArrayL(); |
|
248 iEngineObserver.AllFilesScanned(); |
|
249 iAllFilesScanned = ETrue; |
|
250 } |
|
251 |
|
252 CIEEngineUtils * CIEEngineImp::GetEngineUtils() |
|
253 { |
|
254 DP0_IMAGIC(_L("CIEEngine::GetEngineUtils")); |
|
255 |
|
256 return &iIEEngineUtils; |
|
257 } |
|
258 |
|
259 CIEFileLoader* CIEEngineImp::GetFileLoader() |
|
260 { |
|
261 DP0_IMAGIC(_L("CIEEngineImp::GetFileLoader")); |
|
262 |
|
263 return iFileLoader; |
|
264 } |
|
265 |
|
266 void CIEEngineImp::BitmapsLoadedL(TInt aError) |
|
267 { |
|
268 DP0_IMAGIC(_L("CIEEngineImp::BitmapsLoaded")); |
|
269 |
|
270 iEngineObserver.ImagesLoadedL(aError); |
|
271 } |
|
272 |
|
273 TBool CIEEngineImp::IsScanningFiles() const |
|
274 { |
|
275 return !iAllFilesScanned; |
|
276 } |
|
277 |
|
278 void CIEEngineImp::GetTotalNumOfImages(TInt& aNumOfImages, TInt& aNumOfFaces) |
|
279 { |
|
280 //DP0_IMAGIC(_L("CIEEngineImp::GetTotalNumOfImages")); |
|
281 |
|
282 iFileLoader->GetTotalNumOfImages(aNumOfImages, aNumOfFaces); |
|
283 } |
|
284 |
|
285 TInt CIEEngineImp::GetTotalNumOfImages() |
|
286 { |
|
287 //DP0_IMAGIC(_L("CIEEngineImp::GetTotalNumOfImages")); |
|
288 //return iFileLoader->GetTotalNumOfImages(); |
|
289 |
|
290 TInt numOfImages, numOfFaces; |
|
291 if(iImageArrayMode == EImages) |
|
292 { |
|
293 iFileLoader->GetTotalNumOfImages(numOfImages, numOfFaces); |
|
294 return numOfImages; |
|
295 } |
|
296 |
|
297 else if(iImageArrayMode == EFaces) |
|
298 { |
|
299 iFileLoader->GetTotalNumOfImages(numOfImages, numOfFaces); |
|
300 return numOfFaces; |
|
301 } |
|
302 else |
|
303 return 0; |
|
304 |
|
305 } |
|
306 |
|
307 TInt CIEEngineImp::DeleteFile(TInt aIndex) |
|
308 { |
|
309 DP0_IMAGIC(_L("CIEEngineImp::DeleteFile++")); |
|
310 TInt err; |
|
311 if(iImageArrayMode == EImages) |
|
312 { |
|
313 err = iFileLoader->DeleteFile(aIndex); |
|
314 iIEBgpsController->FilenameArrayCountChanged(iFileLoader->GetFileNameArray()); |
|
315 } |
|
316 else//EFaces |
|
317 { |
|
318 err = iFileLoader->DeleteFaceFile(aIndex); |
|
319 TInt numOfImages = 0; |
|
320 TInt numOfFaces = 0; |
|
321 iFileLoader->GetUpdatedNumOfImages(numOfImages, numOfFaces); |
|
322 } |
|
323 DP1_IMAGIC(_L("CIEEngineImp::DeleteFile-- %d"), err); |
|
324 return err; |
|
325 } |
|
326 |
|
327 TInt CIEEngineImp::GetImageName(const TInt aIndex, TFileName& aFileName, TThumbSize aThumbRes) |
|
328 { |
|
329 DP0_IMAGIC(_L("CIEEngineImp::GetImageName")); |
|
330 |
|
331 TInt error = KErrNone; |
|
332 TRAP(error, iFileLoader->GetFileNameL(aIndex, aFileName, aThumbRes)); |
|
333 return error; |
|
334 } |
|
335 |
|
336 void CIEEngineImp::GetBitmapL(CImageData* aImageData, CFbsBitmap* aBitmap, TThumbSize aThumbRes) |
|
337 { |
|
338 DP0_IMAGIC(_L("CIEEngineImp::GetBitmapL")); |
|
339 |
|
340 iBitmapLoader->GetOneBitmapL(aImageData, aBitmap, aThumbRes); |
|
341 } |
|
342 |
|
343 void CIEEngineImp::GetFileNameL(const TInt aIndex, TThumbSize aThumbRes, TFileName& aFilename) |
|
344 { |
|
345 iFileLoader->GetFileNameL(aIndex, aFilename, aThumbRes); |
|
346 } |
|
347 |
|
348 void CIEEngineImp::StopTNGeneration(TInt& /*aValue*/) |
|
349 { |
|
350 //iIEBgpsController->StopTNGeneration(aValue); |
|
351 iIEBgpsController->CancelTNGeneration(); |
|
352 } |
|
353 |
|
354 TReal CIEEngineImp::GetAspectRatio(TInt aIndex) |
|
355 { |
|
356 return iIEBgpsController->GetAspectRatio(aIndex); |
|
357 } |
|
358 |
|
359 TReal CIEEngineImp::GetFacesAspectRatio(TInt aIndex) |
|
360 { |
|
361 return iIEBgpsController->GetFacesAspectRatio(aIndex); |
|
362 } |
|
363 |
|
364 //This function is called in editing mode only when we did not have 320x320 TN ready |
|
365 void CIEEngineImp::GenerateThumbNailL(const TDes &aOrgFile, TThumbSize aTNResolution) |
|
366 { |
|
367 DP0_IMAGIC(_L("CIEEngineImp::GenerateThumbNail++")); |
|
368 |
|
369 iIEBgpsController->GenerateThumbNailL(aOrgFile, aTNResolution); |
|
370 |
|
371 DP0_IMAGIC(_L("CIEEngineImp::GenerateThumbNail--")); |
|
372 } |
|
373 |
|
374 //This is used to get face coords from already processed image |
|
375 void CIEEngineImp::GetFaceCoordinates(const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray) |
|
376 { |
|
377 DP0_IMAGIC(_L("CIEEngineImp::GetFaceCoordinates")); |
|
378 aFaceCoordinateArray.Reset(); |
|
379 //iIEBgpsController->GetFaceCoordinates(aTNFileName, aFaceCoordinateArray); |
|
380 } |
|
381 |
|
382 void CIEEngineImp::AddImageToFaceNameArray() |
|
383 { |
|
384 DP0_IMAGIC(_L("CIEEngineImp::AddImageToFaceNameArray++")); |
|
385 |
|
386 //Tarkista etta jos kuva on jo olemassa sita ei lisata enaa uudelleen |
|
387 |
|
388 for(TInt i=0; i<iCroppedFilenames.Count(); i++) |
|
389 { |
|
390 //Add newly cropped filenames to filename array |
|
391 CImageData* tmpImageData = CImageData::NewL(EFullSize); |
|
392 |
|
393 TRAP_IGNORE(tmpImageData->SetFileNameL(iCroppedFilenames[i])); |
|
394 |
|
395 DP1_IMAGIC(_L("CIEEngineImp::FaceCroppingComplete - Add face, Filename: %S"), &iCroppedFilenames[i] ); |
|
396 |
|
397 TSize size; |
|
398 TRAPD(err, iIEEngineUtils.GetImageSizeL(iCroppedFilenames[i], size)); |
|
399 if (err == KErrNone) |
|
400 tmpImageData->SetSize(size); |
|
401 |
|
402 iFileLoader->AddNewFaceCropImage(tmpImageData, 0); |
|
403 } |
|
404 |
|
405 TInt numOfImages, numOfFaces; |
|
406 iFileLoader->GetUpdatedNumOfImages(numOfImages, numOfFaces); |
|
407 |
|
408 //TotalNumberOfFaceImagesChanged(numOfFaces); |
|
409 |
|
410 //Empty data from array after using it |
|
411 TInt count = iCroppedFilenames.Count(); |
|
412 for(TInt i=0; i<count; i++) |
|
413 { |
|
414 iCroppedFilenames.Remove(0); |
|
415 } |
|
416 //iFileLoader->StopFileSystemMonitoring(); |
|
417 |
|
418 DP0_IMAGIC(_L("CIEEngineImp::AddImageToFaceNameArray--")); |
|
419 } |
|
420 |
|
421 //If background face Detection is still continuing, we have to use GetSingleFaceCoordinates() function to get face coordinates |
|
422 void CIEEngineImp::GetSingleFaceCoordinates(TInt aIndex, const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray) |
|
423 { |
|
424 DP0_IMAGIC(_L("CIEEngineImp::GetSingleFaceCoordinates")); |
|
425 |
|
426 iIEBgpsController->GetSingleFaceCoordinates(aIndex, aTNFileName, aFaceCoordinateArray); |
|
427 } |
|
428 |
|
429 |
|
430 CImageData* CIEEngineImp::GetImageData(TInt aIndex/*, TImageArrayMode aMode*/) |
|
431 { |
|
432 return iFileLoader->GetImageData(aIndex/*, aMode*/); |
|
433 } |
|
434 |
|
435 void CIEEngineImp::SetImageData(TInt aIndex, CImageData* aGridData) |
|
436 { |
|
437 iFileLoader->SetImageData(aIndex, aGridData); |
|
438 } |
|
439 |
|
440 TInt CIEEngineImp::GetSelectedImageIndex() |
|
441 { |
|
442 return iEngineObserver.GetImageIndex(); |
|
443 } |
|
444 |
|
445 |
|
446 |
|
447 #ifdef _ACCELEROMETER_SUPPORTED_ |
|
448 |
|
449 void CIEEngineImp::SensorDataAvailable(TImagicDeviceOrientation aOrientation, TBool aValue) |
|
450 { |
|
451 //DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable++")); |
|
452 |
|
453 if(iPrevDeviceOrientation == aOrientation) |
|
454 { |
|
455 //DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - Orientation not changed--")); |
|
456 return; |
|
457 } |
|
458 |
|
459 iPrevDeviceOrientation = aOrientation; |
|
460 |
|
461 CImageData* currentImage = NULL ; //GetGridData(GetSelectedImageIndex(), EImages); |
|
462 TInt totalImages = GetTotalNumOfImages(); |
|
463 |
|
464 switch ( aOrientation ) |
|
465 { |
|
466 #ifdef _S60_3x_ACCELEROMETER_ |
|
467 case EOrientationDisplayDown: // Portrait Up |
|
468 #else if _S60_5x_ACCELEROMETER_ |
|
469 case TSensrvOrientationData::EOrientationDisplayUp: // Portrait Up |
|
470 //case TSensrvOrientationData::EOrientationDisplayDown: // Portrait Up |
|
471 #endif |
|
472 { |
|
473 DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - EOrientationDisplayUp")); |
|
474 |
|
475 for ( TInt imageIndex = 0 ; imageIndex < totalImages ; imageIndex++ ) |
|
476 { |
|
477 currentImage = GetImageData(imageIndex); |
|
478 currentImage->iGridData.iTargetRotationAngle = (currentImage->GetOrientation() + 90)%360; |
|
479 |
|
480 TReal targetA = currentImage->iGridData.iTargetRotationAngle; |
|
481 TReal currentA = currentImage->iGridData.iRotationAngle; |
|
482 |
|
483 currentImage->iGridData.iTargetRotationAngle = targetA; |
|
484 |
|
485 } |
|
486 |
|
487 iPrevDeviceOrientation = iDeviceOrientation = EOrientationDisplayDown; |
|
488 break; |
|
489 } |
|
490 |
|
491 #ifdef _S60_3x_ACCELEROMETER_ |
|
492 case EOrientationDisplayLeftUp: // Landscape Up |
|
493 #else if _S60_5x_ACCELEROMETER_ |
|
494 case TSensrvOrientationData::EOrientationDisplayRightUp: // Landscape Up |
|
495 //case TSensrvOrientationData::EOrientationDisplayLeftUp: // Landscape Up |
|
496 #endif |
|
497 { |
|
498 DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - EOrientationDisplayLeftUp")); |
|
499 |
|
500 for ( TInt imageIndex = 0 ; imageIndex < totalImages ; imageIndex++ ) |
|
501 { |
|
502 currentImage = GetImageData(imageIndex); |
|
503 if ( currentImage->iGridData.iRotationAngle == 270 ) |
|
504 { |
|
505 currentImage->iGridData.iRotationAngle = -90; // Rotate |
|
506 } |
|
507 currentImage->iGridData.iTargetRotationAngle = (currentImage->GetOrientation() )%360; |
|
508 |
|
509 TReal targetA = currentImage->iGridData.iTargetRotationAngle; |
|
510 TReal currentA = currentImage->iGridData.iRotationAngle; |
|
511 |
|
512 currentImage->iGridData.iTargetRotationAngle = targetA; |
|
513 } |
|
514 |
|
515 iPrevDeviceOrientation = iDeviceOrientation = EOrientationDisplayLeftUp; |
|
516 break; |
|
517 } |
|
518 |
|
519 default: |
|
520 { |
|
521 DP1_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - Ignored orientation: %d"),aOrientation); |
|
522 //progressBuf.Append( _L( "Unknown orientation" ) ); |
|
523 break; |
|
524 } |
|
525 } |
|
526 iEngineObserver.ImageRotated(iDeviceOrientation); |
|
527 |
|
528 DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable--")); |
|
529 } |
|
530 |
|
531 void CIEEngineImp::SetImageRotation(TInt aIndex) |
|
532 { |
|
533 CImageData* currentImage = NULL ; //GetGridData(GetSelectedImageIndex(), EImages); |
|
534 //TInt totalImages = GetTotalNumOfImages(); |
|
535 |
|
536 currentImage = GetImageData(aIndex); |
|
537 |
|
538 TReal targetAngle = (currentImage->GetOrientation())%360; |
|
539 //TReal currentAngle = currentImage->iGridData.iRotationAngle; |
|
540 |
|
541 currentImage->iGridData.iTargetRotationAngle = targetAngle; |
|
542 |
|
543 } |
|
544 |
|
545 |
|
546 TImagicDeviceOrientation CIEEngineImp::GetDeviceOrientation() |
|
547 { |
|
548 DP1_IMAGIC(_L("CIEEngineImp::GetDeviceOrientation: %d"),iDeviceOrientation); |
|
549 return iDeviceOrientation; |
|
550 } |
|
551 |
|
552 void CIEEngineImp::SetDeviceOrientation(TImagicDeviceOrientation aOrientation) |
|
553 { |
|
554 DP1_IMAGIC(_L("CIEEngineImp::SetDeviceOrientation: %d"),aOrientation); |
|
555 |
|
556 SensorDataAvailable(aOrientation, EFalse); |
|
557 } |
|
558 |
|
559 void CIEEngineImp::StartAccSensorMonitoring() |
|
560 { |
|
561 if(iSensorMonitor) |
|
562 { |
|
563 DP0_IMAGIC(_L("CIEEngineImp::StartAccSensorMonitoring")); |
|
564 iSensorMonitor->StartMonitoring(); |
|
565 } |
|
566 |
|
567 } |
|
568 |
|
569 void CIEEngineImp::StopAccSensorMonitoring() |
|
570 { |
|
571 if(iSensorMonitor) |
|
572 { |
|
573 DP0_IMAGIC(_L("CIEEngineImp::StopAccSensorMonitoring")); |
|
574 iSensorMonitor->StopMonitoring(); |
|
575 } |
|
576 } |
|
577 |
|
578 #endif |
|
579 |
|
580 void CIEEngineImp::Stop() |
|
581 { |
|
582 /*TInt err = KErrNone; |
|
583 StopTNGeneration(err); |
|
584 StopFaceDetection(err);*/ |
|
585 iFileLoader->StopImageFinder(); |
|
586 } |
|
587 |
|
588 TBool CIEEngineImp::IsRunning() |
|
589 { |
|
590 //iIEBgpsController-> |
|
591 return (iFileLoader->ImageFinderState() != CIEFileLoader::EImageFinderStopped); |
|
592 //return ETrue; |
|
593 } |
|
594 |
|
595 TBool CIEEngineImp::IsAccelerometerExists() |
|
596 { |
|
597 DP0_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists")); |
|
598 |
|
599 #ifdef _S60_3x_ACCELEROMETER_ |
|
600 #ifdef SENSOR_API_LOAD_DYNAMICALLY |
|
601 DP1_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists - iSensorMonitor exists: %d"),iSensorMonitor); |
|
602 return (iSensorMonitor != NULL); |
|
603 #endif |
|
604 #endif |
|
605 DP0_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists - iSensorMonitor not exists")); |
|
606 return EFalse; |
|
607 } |
|
608 |
|
609 TInt CIEEngineImp::GetGleMaxRes() |
|
610 { |
|
611 return iEngineObserver.GetGleMaxRes(); |
|
612 } |
|
613 |
|
614 |
|
615 // EOF |
|
616 |