--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/EngSrc/IEEngineImp.cpp Fri Oct 15 10:18:29 2010 +0900
@@ -0,0 +1,616 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors: Juha Kauppinen, Mika Hokkanen
+*
+* Description: Photo Browser
+*
+*/
+
+// Include files
+#include <e32uid.h>
+#include <BAUTILS.H>
+#include <IEImageProcessing.h>//thumbnail client
+#include "IEEngineImp.h"
+#ifdef IMAGE_EDITOR
+#include "IEEditor.h"
+#endif
+#include "IEFileLoader.h"
+#include "IEImageList.h"
+#include "ImageMonitorAO.h"
+#include "IEImageList.h"
+#include "IEEngineUtils.h"
+
+
+// ============================ MEMBER FUNCTIONS =========================== //
+
+EXPORT_C CIEEngine* CIEEngine::NewL(MIEEngineObserver& aObserver)
+{
+ DP0_IMAGIC(_L("CIEEngine::NewL"));
+ return CIEEngineImp::NewL(aObserver);
+}
+
+EXPORT_C CIEEngine::~CIEEngine()
+ {
+
+ }
+
+CIEEngineImp* CIEEngineImp::NewL(MIEEngineObserver& aObserver)
+{
+ DP0_IMAGIC(_L("CIEEngine::NewL"));
+ CIEEngineImp* self = new (ELeave) CIEEngineImp(aObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+}
+
+CIEEngineImp::~CIEEngineImp()
+ {
+ DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp++"));
+
+#if 0
+ if(iIEImageProcessing)
+ {
+ delete iIEImageProcessing;
+ iIEImageProcessing = NULL;
+ }
+#endif
+
+#ifdef IMAGE_EDITOR
+ if(iImageEditor)
+ {
+ DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iImageEditor"));
+ delete iImageEditor;
+ iImageEditor = NULL;
+ }
+#endif
+
+ if(iFileLoader)
+ {
+ DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iFileLoader"));
+ delete iFileLoader;
+ iFileLoader = NULL;
+ }
+
+ if(iBitmapLoader)
+ {
+ DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iBitmapLoader"));
+ iBitmapLoader->CancelFullSizeLoading();
+ DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iBitmapLoader 2"));
+ delete iBitmapLoader;
+ iBitmapLoader = NULL;
+ }
+
+ if(iIEBgpsController)
+ {
+ DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp - delete iIEBgpsController"));
+ delete iIEBgpsController;
+ iIEBgpsController = NULL;
+ }
+#ifdef _ACCELEROMETER_SUPPORTED_
+ if(iSensorMonitor)
+ {
+ iSensorMonitor->StopMonitoring();
+ delete iSensorMonitor;
+ iSensorMonitor = NULL;
+ }
+#endif //_ACCELEROMETER_SUPPORTED_
+
+ iFileServer.Close();
+ iCritical.Close();
+
+ DP0_IMAGIC(_L("CIEEngine::~CIEEngineImp--"));
+ }
+
+CIEEngineImp::CIEEngineImp(MIEEngineObserver& aObserver) :
+ iEngineObserver(aObserver),
+ iIEEngineUtils(iFileServer)
+ {
+ }
+
+void CIEEngineImp::ConstructL()
+ {
+ DP0_IMAGIC(_L("CIEEngine::ConstructL++"));
+
+ iCritical.CreateLocal();
+
+ User::LeaveIfError(iFileServer.Connect());
+
+ /*Creating Engine Utility class pointer */
+ iCurrentEditingMode = EEditModeNone;
+ iEditingMode = EEditModeNone;
+ iImageEdited = EFalse;
+ iImageArrayMode = EImages;
+ iAllFilesScanned = EFalse;
+ iPrevDeviceOrientation = EOrientationDisplayLeftUp;
+
+
+ TInt err = KErrNone;
+ //Create Bitmap loader
+ iBitmapLoader = CIEBitmapLoader::NewL(iFileServer, *this, &iCritical);
+ //Create BGPS controller
+ iIEBgpsController = CIEBgpsController::NewL(iFileServer, *this, iIEEngineUtils, &iCritical);
+ //Create Fileloader
+ TRAP(err, iFileLoader = CIEFileLoader::NewL(iFileServer, this, &iCritical));
+ if(err != KErrNone)
+ {
+ DP1_IMAGIC(_L("CIEEngine::ConstructL - Error creating file loader, err: %d"),err);
+ User::Leave(err);
+ }
+
+#ifdef _ACCELEROMETER_SUPPORTED_
+ iDeviceOrientation = EOrientationDisplayLeftUp;
+ err = KErrNone;
+ TRAP(err, iSensorMonitor = CIESensorMonitor::NewL(*this));
+ DP1_IMAGIC(_L("CIEEngine::ConstructL - iSensorMonitor error: %d"), err);
+ if(err == KErrNone)
+ {
+ DP0_IMAGIC(_L("CIEEngine::ConstructL - iSensorMonitor->StartMonitoring()"));
+ iSensorMonitor->StartMonitoring();
+ }
+ else
+ {
+ iSensorMonitor = NULL;
+ }
+
+#endif
+
+ iIEBgpsController->SetFileLoader(iFileLoader);
+
+ DP0_IMAGIC(_L("CIEEngine::ConstructL--"));
+}
+
+void CIEEngineImp::SetDBChanged(CImageData* aImageData)
+ {
+ TFileName filename;
+ aImageData->GetFileName(filename, EFullSize);
+ iFileLoader->GetImageList().SetChanged(filename);
+ }
+
+CIEImageList& CIEEngineImp::GetImageList()
+ {
+ return iFileLoader->GetImageList();
+ }
+
+void CIEEngineImp::AppUIReady()
+ {
+ DP0_IMAGIC(_L("CIEEngine::AppUIReady"));
+
+ //Create ImageProcessing
+ iIEBgpsController->CreateImageProcessing();
+ }
+
+void CIEEngineImp::CancelFullSizeLoading()
+ {
+ DP0_IMAGIC(_L("CIEEngine::CancelLoading"));
+
+ iBitmapLoader->CancelFullSizeLoading();
+ }
+
+
+void CIEEngineImp::SetImageDataMode(TImageArrayMode aMode)
+ {
+ iImageArrayMode = aMode;
+
+ iBitmapLoader->SetImageDataMode(aMode);
+ }
+
+MIEEngineObserver& CIEEngineImp::GetObserver()
+ {
+ return iEngineObserver;
+ }
+
+void CIEEngineImp::TNGenerationComplete(TThumbSize aTNRes)
+ {
+ DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete++"));
+
+ iEngineObserver.TNCreationCompleteL(aTNRes);
+
+ DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete--"));
+ }
+
+void CIEEngineImp::SingleTNGenerationComplete(TInt aIndex, TThumbSize aTNRes)
+ {
+ DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete++"));
+
+ iEngineObserver.SingleTNCreationCompletedL(aIndex, aTNRes);
+
+ DP0_IMAGIC(_L("CIEEngine::TNGenerationComplete--"));
+ }
+
+void CIEEngineImp::FaceDetectionComplete()
+ {
+ DP0_IMAGIC(_L("CIEEngine::FaceDetectionComplete"));
+ iEngineObserver.FaceDetectionComplete();
+ }
+
+void CIEEngineImp::SingleFaceDetectionComplete()
+ {
+ DP0_IMAGIC(_L("CIEEngine::SingleFaceDetectionComplete"));
+
+ iEngineObserver.SingleFaceDetectionComplete();
+ }
+
+void CIEEngineImp::AllFilesAddedToFilenameArrayL()
+ {
+ DP0_IMAGIC(_L("CIEEngine::AllFilesAddedToFilenameArrayL"));
+
+ iIEBgpsController->AllFilesAddedToFilenameArrayL();
+ iEngineObserver.AllFilesScanned();
+ iAllFilesScanned = ETrue;
+ }
+
+CIEEngineUtils * CIEEngineImp::GetEngineUtils()
+ {
+ DP0_IMAGIC(_L("CIEEngine::GetEngineUtils"));
+
+ return &iIEEngineUtils;
+ }
+
+CIEFileLoader* CIEEngineImp::GetFileLoader()
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::GetFileLoader"));
+
+ return iFileLoader;
+ }
+
+void CIEEngineImp::BitmapsLoadedL(TInt aError)
+{
+ DP0_IMAGIC(_L("CIEEngineImp::BitmapsLoaded"));
+
+ iEngineObserver.ImagesLoadedL(aError);
+}
+
+TBool CIEEngineImp::IsScanningFiles() const
+ {
+ return !iAllFilesScanned;
+ }
+
+void CIEEngineImp::GetTotalNumOfImages(TInt& aNumOfImages, TInt& aNumOfFaces)
+ {
+ //DP0_IMAGIC(_L("CIEEngineImp::GetTotalNumOfImages"));
+
+ iFileLoader->GetTotalNumOfImages(aNumOfImages, aNumOfFaces);
+ }
+
+TInt CIEEngineImp::GetTotalNumOfImages()
+ {
+ //DP0_IMAGIC(_L("CIEEngineImp::GetTotalNumOfImages"));
+ //return iFileLoader->GetTotalNumOfImages();
+
+ TInt numOfImages, numOfFaces;
+ if(iImageArrayMode == EImages)
+ {
+ iFileLoader->GetTotalNumOfImages(numOfImages, numOfFaces);
+ return numOfImages;
+ }
+
+ else if(iImageArrayMode == EFaces)
+ {
+ iFileLoader->GetTotalNumOfImages(numOfImages, numOfFaces);
+ return numOfFaces;
+ }
+ else
+ return 0;
+
+ }
+
+TInt CIEEngineImp::DeleteFile(TInt aIndex)
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::DeleteFile++"));
+ TInt err;
+ if(iImageArrayMode == EImages)
+ {
+ err = iFileLoader->DeleteFile(aIndex);
+ iIEBgpsController->FilenameArrayCountChanged(iFileLoader->GetFileNameArray());
+ }
+ else//EFaces
+ {
+ err = iFileLoader->DeleteFaceFile(aIndex);
+ TInt numOfImages = 0;
+ TInt numOfFaces = 0;
+ iFileLoader->GetUpdatedNumOfImages(numOfImages, numOfFaces);
+ }
+ DP1_IMAGIC(_L("CIEEngineImp::DeleteFile-- %d"), err);
+ return err;
+ }
+
+TInt CIEEngineImp::GetImageName(const TInt aIndex, TFileName& aFileName, TThumbSize aThumbRes)
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::GetImageName"));
+
+ TInt error = KErrNone;
+ TRAP(error, iFileLoader->GetFileNameL(aIndex, aFileName, aThumbRes));
+ return error;
+ }
+
+void CIEEngineImp::GetBitmapL(CImageData* aImageData, CFbsBitmap* aBitmap, TThumbSize aThumbRes)
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::GetBitmapL"));
+
+ iBitmapLoader->GetOneBitmapL(aImageData, aBitmap, aThumbRes);
+ }
+
+void CIEEngineImp::GetFileNameL(const TInt aIndex, TThumbSize aThumbRes, TFileName& aFilename)
+ {
+ iFileLoader->GetFileNameL(aIndex, aFilename, aThumbRes);
+ }
+
+void CIEEngineImp::StopTNGeneration(TInt& /*aValue*/)
+ {
+ //iIEBgpsController->StopTNGeneration(aValue);
+ iIEBgpsController->CancelTNGeneration();
+ }
+
+TReal CIEEngineImp::GetAspectRatio(TInt aIndex)
+ {
+ return iIEBgpsController->GetAspectRatio(aIndex);
+ }
+
+TReal CIEEngineImp::GetFacesAspectRatio(TInt aIndex)
+ {
+ return iIEBgpsController->GetFacesAspectRatio(aIndex);
+ }
+
+//This function is called in editing mode only when we did not have 320x320 TN ready
+void CIEEngineImp::GenerateThumbNailL(const TDes &aOrgFile, TThumbSize aTNResolution)
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::GenerateThumbNail++"));
+
+ iIEBgpsController->GenerateThumbNailL(aOrgFile, aTNResolution);
+
+ DP0_IMAGIC(_L("CIEEngineImp::GenerateThumbNail--"));
+ }
+
+//This is used to get face coords from already processed image
+void CIEEngineImp::GetFaceCoordinates(const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray)
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::GetFaceCoordinates"));
+ aFaceCoordinateArray.Reset();
+ //iIEBgpsController->GetFaceCoordinates(aTNFileName, aFaceCoordinateArray);
+ }
+
+void CIEEngineImp::AddImageToFaceNameArray()
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::AddImageToFaceNameArray++"));
+
+ //Tarkista etta jos kuva on jo olemassa sita ei lisata enaa uudelleen
+
+ for(TInt i=0; i<iCroppedFilenames.Count(); i++)
+ {
+ //Add newly cropped filenames to filename array
+ CImageData* tmpImageData = CImageData::NewL(EFullSize);
+
+ TRAP_IGNORE(tmpImageData->SetFileNameL(iCroppedFilenames[i]));
+
+ DP1_IMAGIC(_L("CIEEngineImp::FaceCroppingComplete - Add face, Filename: %S"), &iCroppedFilenames[i] );
+
+ TSize size;
+ TRAPD(err, iIEEngineUtils.GetImageSizeL(iCroppedFilenames[i], size));
+ if (err == KErrNone)
+ tmpImageData->SetSize(size);
+
+ iFileLoader->AddNewFaceCropImage(tmpImageData, 0);
+ }
+
+ TInt numOfImages, numOfFaces;
+ iFileLoader->GetUpdatedNumOfImages(numOfImages, numOfFaces);
+
+ //TotalNumberOfFaceImagesChanged(numOfFaces);
+
+ //Empty data from array after using it
+ TInt count = iCroppedFilenames.Count();
+ for(TInt i=0; i<count; i++)
+ {
+ iCroppedFilenames.Remove(0);
+ }
+ //iFileLoader->StopFileSystemMonitoring();
+
+ DP0_IMAGIC(_L("CIEEngineImp::AddImageToFaceNameArray--"));
+ }
+
+//If background face Detection is still continuing, we have to use GetSingleFaceCoordinates() function to get face coordinates
+void CIEEngineImp::GetSingleFaceCoordinates(TInt aIndex, const TFileName aTNFileName, RArray<TRect>& aFaceCoordinateArray)
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::GetSingleFaceCoordinates"));
+
+ iIEBgpsController->GetSingleFaceCoordinates(aIndex, aTNFileName, aFaceCoordinateArray);
+ }
+
+
+CImageData* CIEEngineImp::GetImageData(TInt aIndex/*, TImageArrayMode aMode*/)
+ {
+ return iFileLoader->GetImageData(aIndex/*, aMode*/);
+ }
+
+void CIEEngineImp::SetImageData(TInt aIndex, CImageData* aGridData)
+ {
+ iFileLoader->SetImageData(aIndex, aGridData);
+ }
+
+TInt CIEEngineImp::GetSelectedImageIndex()
+ {
+ return iEngineObserver.GetImageIndex();
+ }
+
+
+
+#ifdef _ACCELEROMETER_SUPPORTED_
+
+void CIEEngineImp::SensorDataAvailable(TImagicDeviceOrientation aOrientation, TBool aValue)
+ {
+ //DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable++"));
+
+ if(iPrevDeviceOrientation == aOrientation)
+ {
+ //DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - Orientation not changed--"));
+ return;
+ }
+
+ iPrevDeviceOrientation = aOrientation;
+
+ CImageData* currentImage = NULL ; //GetGridData(GetSelectedImageIndex(), EImages);
+ TInt totalImages = GetTotalNumOfImages();
+
+ switch ( aOrientation )
+ {
+#ifdef _S60_3x_ACCELEROMETER_
+ case EOrientationDisplayDown: // Portrait Up
+#else if _S60_5x_ACCELEROMETER_
+ case TSensrvOrientationData::EOrientationDisplayUp: // Portrait Up
+ //case TSensrvOrientationData::EOrientationDisplayDown: // Portrait Up
+#endif
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - EOrientationDisplayUp"));
+
+ for ( TInt imageIndex = 0 ; imageIndex < totalImages ; imageIndex++ )
+ {
+ currentImage = GetImageData(imageIndex);
+ currentImage->iGridData.iTargetRotationAngle = (currentImage->GetOrientation() + 90)%360;
+
+ TReal targetA = currentImage->iGridData.iTargetRotationAngle;
+ TReal currentA = currentImage->iGridData.iRotationAngle;
+
+ currentImage->iGridData.iTargetRotationAngle = targetA;
+
+ }
+
+ iPrevDeviceOrientation = iDeviceOrientation = EOrientationDisplayDown;
+ break;
+ }
+
+#ifdef _S60_3x_ACCELEROMETER_
+ case EOrientationDisplayLeftUp: // Landscape Up
+#else if _S60_5x_ACCELEROMETER_
+ case TSensrvOrientationData::EOrientationDisplayRightUp: // Landscape Up
+ //case TSensrvOrientationData::EOrientationDisplayLeftUp: // Landscape Up
+#endif
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - EOrientationDisplayLeftUp"));
+
+ for ( TInt imageIndex = 0 ; imageIndex < totalImages ; imageIndex++ )
+ {
+ currentImage = GetImageData(imageIndex);
+ if ( currentImage->iGridData.iRotationAngle == 270 )
+ {
+ currentImage->iGridData.iRotationAngle = -90; // Rotate
+ }
+ currentImage->iGridData.iTargetRotationAngle = (currentImage->GetOrientation() )%360;
+
+ TReal targetA = currentImage->iGridData.iTargetRotationAngle;
+ TReal currentA = currentImage->iGridData.iRotationAngle;
+
+ currentImage->iGridData.iTargetRotationAngle = targetA;
+ }
+
+ iPrevDeviceOrientation = iDeviceOrientation = EOrientationDisplayLeftUp;
+ break;
+ }
+
+ default:
+ {
+ DP1_IMAGIC(_L("CIEEngineImp::SensorDataAvailable - Ignored orientation: %d"),aOrientation);
+ //progressBuf.Append( _L( "Unknown orientation" ) );
+ break;
+ }
+ }
+ iEngineObserver.ImageRotated(iDeviceOrientation);
+
+ DP0_IMAGIC(_L("CIEEngineImp::SensorDataAvailable--"));
+ }
+
+void CIEEngineImp::SetImageRotation(TInt aIndex)
+ {
+ CImageData* currentImage = NULL ; //GetGridData(GetSelectedImageIndex(), EImages);
+ //TInt totalImages = GetTotalNumOfImages();
+
+ currentImage = GetImageData(aIndex);
+
+ TReal targetAngle = (currentImage->GetOrientation())%360;
+ //TReal currentAngle = currentImage->iGridData.iRotationAngle;
+
+ currentImage->iGridData.iTargetRotationAngle = targetAngle;
+
+ }
+
+
+TImagicDeviceOrientation CIEEngineImp::GetDeviceOrientation()
+ {
+ DP1_IMAGIC(_L("CIEEngineImp::GetDeviceOrientation: %d"),iDeviceOrientation);
+ return iDeviceOrientation;
+ }
+
+void CIEEngineImp::SetDeviceOrientation(TImagicDeviceOrientation aOrientation)
+ {
+ DP1_IMAGIC(_L("CIEEngineImp::SetDeviceOrientation: %d"),aOrientation);
+
+ SensorDataAvailable(aOrientation, EFalse);
+ }
+
+void CIEEngineImp::StartAccSensorMonitoring()
+ {
+ if(iSensorMonitor)
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::StartAccSensorMonitoring"));
+ iSensorMonitor->StartMonitoring();
+ }
+
+ }
+
+void CIEEngineImp::StopAccSensorMonitoring()
+ {
+ if(iSensorMonitor)
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::StopAccSensorMonitoring"));
+ iSensorMonitor->StopMonitoring();
+ }
+ }
+
+#endif
+
+void CIEEngineImp::Stop()
+ {
+ /*TInt err = KErrNone;
+ StopTNGeneration(err);
+ StopFaceDetection(err);*/
+ iFileLoader->StopImageFinder();
+ }
+
+TBool CIEEngineImp::IsRunning()
+ {
+ //iIEBgpsController->
+ return (iFileLoader->ImageFinderState() != CIEFileLoader::EImageFinderStopped);
+ //return ETrue;
+ }
+
+TBool CIEEngineImp::IsAccelerometerExists()
+ {
+ DP0_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists"));
+
+#ifdef _S60_3x_ACCELEROMETER_
+#ifdef SENSOR_API_LOAD_DYNAMICALLY
+ DP1_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists - iSensorMonitor exists: %d"),iSensorMonitor);
+ return (iSensorMonitor != NULL);
+#endif
+#endif
+ DP0_IMAGIC(_L("CIEEngineImp::IsAccelerometerExists - iSensorMonitor not exists"));
+ return EFalse;
+ }
+
+TInt CIEEngineImp::GetGleMaxRes()
+ {
+ return iEngineObserver.GetGleMaxRes();
+ }
+
+
+// EOF
+