/*

* 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--"));

   }