/*

* 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 <eikenv.h>

#include <exifread.h>

#include <f32file.h>

#include "IEImageFinder.h"

#include "IEImageList.h"

#include "IEImageProcessing.h"

#include "IEImageData.h"

#include "IEEngineImp.h"

#include "IEEngineUtils.h"

#ifdef _S60_5x_ACCELEROMETER_

#include "IESensorMonitor.h"

#endif

#define LATETHUMBCHECK

// ================= MEMBER FUNCTIONS =======================

CIEImageFinder* CIEImageFinder::NewL(

        CIEFileLoader* aCallback, 

        RArray<CImageData*>& aFileNameData, 

        RArray<CImageData*>& aFaceFileNameData,

        RCriticalSection* aCritical)

    {

    CIEImageFinder* self = new(ELeave) CIEImageFinder(aCallback, aFileNameData, aFaceFileNameData, aCritical);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CIEImageFinder* CIEImageFinder::NewLC(

        CIEFileLoader* aCallback, 

        RArray<CImageData*>& aFileNameData, 

        RArray<CImageData*>& aFaceFileNameData, 

        RCriticalSection* aCritical)

    {

    CIEImageFinder* self = new(ELeave) CIEImageFinder(aCallback, aFileNameData, aFaceFileNameData, aCritical);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CIEImageFinder::CIEImageFinder(

        CIEFileLoader* aCallback, 

        RArray<CImageData*>& aFileNameData, 

        RArray<CImageData*>& aFaceFileNameData, 

        RCriticalSection* aCritical) :

        //iList(aFileNameData, aCallback),

        iCallback(aCallback),

        iFileNameData(aFileNameData),

        iFaceFileNameData(aFaceFileNameData),

        iCritical(aCritical),

        iIEEngineUtils(iFileServer)

    {

    DP0_IMAGIC(_L("CIEImageFinder::CIEImageFinder++ --"));

    }

void CIEImageFinder::ConstructL()

    {

    DP0_IMAGIC(_L("CIEImageFinder::ConstructL++"));

    User::LeaveIfError(iFileServer.Connect());

    iImageList = &iCallback->GetImageList();

    //iFileSystemMonitor = CFileSystemMonitorAO::NewL(iFileServer, this);

    // Creating Engine Utility class pointer */

    DP0_IMAGIC(_L("CIEImageFinder::ConstructL--"));

    }

CIEImageFinder::~CIEImageFinder()

    {

    DP0_IMAGIC(_L("CIEImageFinder::~CIEImageFinder++"));

    iFileServer.Close();

  	DP0_IMAGIC(_L("CIEImageFinder::~CIEImageFinder--"));

    }

TBool CIEImageFinder::IsSearching() const

    {

    return (iCallback->ImageFinderState() == CIEFileLoader::EImageFinderRunning);

    }

void CIEImageFinder::StartFinderL(const TDesC& aSearchName)

    {

    DP0_IMAGIC(_L("CIEImageFinder::StartFinderL++"));

#ifdef IMAGIC_DATABASE

    // Read initial list from database

    TRAP_IGNORE(iImageList->ReadDatabaseL());

#endif    

    if (IsSearching())

        SearchFilesL(aSearchName);

    DP0_IMAGIC(_L("CIEImageFinder::StartFinderL--"));

    }

void CIEImageFinder::SearchFilesL(const TDesC& aSearchName)

    {

    DP0_IMAGIC(_L("CIEImageFinder::SearchFilesL++"));

    // Use phone memory, external memory card and internal memory card for file scanning 

    TFileName rootPathPhoneMemory = PathInfo::PhoneMemoryRootPath();

    rootPathPhoneMemory.Append(ImagePath);

    TFileName rootPathMCard = PathInfo::MemoryCardRootPath();

    rootPathMCard.Append(ImagePath);

    TFileName rootPathFDrive;

    rootPathFDrive.Copy(KRootPathFDrive);

    rootPathFDrive.Append(ImagePath);

    //Append drives to array

    RArray<TFileName> drives;

    drives.Append(rootPathPhoneMemory);

    drives.Append(rootPathMCard);

    drives.Append(rootPathFDrive);

    DP0_IMAGIC(_L("CIEImageFinder::SearchFilesL start"));    

    for(TInt i=0; i<drives.Count() && IsSearching(); i++)

        {

        if(BaflUtils::PathExists(iFileServer, drives[i]))

            {

            DP2_IMAGIC(_L("CIEImageFinder::SearchFilesL  aRootPath = %S, aSearchName = %S ++"), &drives[i], &aSearchName);

            CDirScan* dirScan = CDirScan::NewL(iFileServer);

            TRAPD(err, dirScan->SetScanDataL(

                    drives[i], 

                    KEntryAttDir|KEntryAttMatchExclusive, 

                    EDirDescending/*|EDescending*/|ESortByDate, 

                    CDirScan::EScanUpTree));

            if(err == KErrNone)

                {

                CDir* dir;

                while(IsSearching())

                    {

                    TRAP(err, dirScan->NextL(dir));

                    if(err != KErrNone || dir == NULL)

                        {

                        if (dir)

                            delete dir;

                        break;

                        }

                    TRAP(err, ScanDirL(dir, dirScan->FullPath(), aSearchName));

                    delete dir;

                    if (err != KErrNone)

                        break;

                    }

                }

            delete dirScan;

            }

        }

#ifdef IMAGIC_DATABASE      

        // Remove files from deleted directories

    if (IsSearching())

        iImageList->RemoveNonExistImagesL(NULL, iFileServer);

#endif

#ifdef LATETHUMBCHECK    

    // Check all thumbnails

    for (TInt i = 0;i < iFileNameData.Count() && IsSearching();i++)

        {

        CheckCreatedThumbnails(*iFileNameData[i]);

        // Number of faces is unknown and thumbnail exists

        if (iFileNameData[i]->GetNumberOfFaces() < 0 &&

            iFileNameData[i]->IsImageReady(ESize512x512))

            {

            // Read number of faces from thumb's exif

            RArray<TRect> faceCoordinates;

            TFileName fileName;

            iFileNameData[i]->GetFileName(fileName, ESize512x512);

            TRAPD(error, iIEEngineUtils.ReadFaceCoordinatesL(fileName, faceCoordinates));

            if (error == KErrNone)

                {

                TInt count = faceCoordinates.Count();

                DP2_IMAGIC(_L("Read face# %d for %S"), count, &fileName);

                iFileNameData[i]->SetNumberOfFaces(count);

                iImageList->SetChanged(fileName);

                }

            }

        }

#endif    

    // Let engine know that all file has been added to filename array

    //iCallback->AllFilesAddedToFilenameArray();

    drives.Close();

#ifdef IMAGIC_DATABASE    

    // Write list to database

    TRAP_IGNORE(iImageList->WriteDatabaseL());

#endif    

    DP0_IMAGIC(_L("CIEImageFinder::SearchFilesL--"));

    }

void CIEImageFinder::ScanDirL(CDir* aDir, const TDesC& aDirPath, const TDesC& aWild)

    {

    DP1_IMAGIC(_L("CIEImageFinder::ScanDirL++ %S"), &aDirPath);

    TParse parse;

    parse.Set(aWild, &aDirPath, NULL);

    TPtrC spec(parse.FullName());

    /*if(aDirPath.Find(KCRootBgroundImages) != KErrNotFound)

        return;*/

    TFindFile findFile(iFileServer);

    if (findFile.FindWildByPath(parse.FullName(), NULL, aDir) == KErrNone)

        {

        // Sort in time order

        aDir->Sort(EDescending|ESortByDate);

        // Go through dir in inverted order

        for(TInt i = 0;i < aDir->Count() && IsSearching();i++)

            {

            parse.Set((*aDir)[i].iName, &spec, NULL);

            // Full filename with path of original image

            TFileName imageFileName;

            imageFileName = parse.FullName();

            // Check if file exist and not be hidden

            TBool visible = EFalse;

            TRAPD(err, visible = iImageList->IsImageViewableL(imageFileName, iFileServer));

            if (err != KErrNone || !visible)

                {

                DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - not found or hidden file"));

                continue;

                }

            CImageData* imageData = iImageList->GetImageData(imageFileName);

            // Read file time

            TTime fileTime(0);

            TRAP(err, iIEEngineUtils.GetModifiedTimeL(imageFileName, fileTime));

            if (err != KErrNone)

                {

                DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - get file time failed"));

                // File is locked for writing, use old file time if possible

                if (imageData == NULL)

                    continue;

                else

                    fileTime = imageData->GetFileTime();

                }

            // Image already exist in list

            if (imageData != NULL)

                {

                DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - image exist"));

                // File has been changed

                if (imageData->GetFileTime() != fileTime)

                    {

                    DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - file time is different"));

                    // Delete thumbnails and remove image from the list

                    iIEEngineUtils.DeleteThumbnails(imageFileName, iFileServer);

                    iImageList->Remove(iImageList->GetImageIndex(imageData), iFileServer);

                    imageData = NULL;

                    }

                }

            // Image already exist

            if (imageData == NULL)

                {

                // Read aspect ratio

                TSize size;

                TRAP(err, iIEEngineUtils.GetImageSizeL(imageFileName, size));

                if (err != KErrNone)

                    {

                    DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - get size failed"));

                    continue;

                    }

                // Read EXIF created time (use file time if EXIF fails)

                TTime createdTime;

                TUint16 orientation = 0;

                TRAP(err, iIEEngineUtils.GetExifDateTimeAndOrientationL(

                        imageFileName, 

                        createdTime, 

                        orientation));

                if (err != KErrNone) 

                    {

                    DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - No EXIF date"));

                    createdTime = fileTime;

                    }

                // Add image to list

                DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - Call AddImageL"));

                TRAP(err, imageData = iImageList->CreateImageDataL(imageFileName, createdTime, orientation));

                DP1_IMAGIC(_L("CIEImageFinder::ScanDirL - AddImageL returned: err:% d"), err);

                if (err != KErrNone)

                    {

                    imageData = NULL;

                    }

                else if (imageData) 

				    {

                    imageData->SetFileTime(fileTime);

                    imageData->SetSize(size);

                    iImageList->AddImage(imageData);

                    }

                iImageList->SetChanged(imageFileName);

                }

            DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - 03"));

            // Mark original image as ready

            if (imageData)

                {

                DP0_IMAGIC(_L("CIEImageFinder::ScanDirL - 04"));

                imageData->SetImageReady(EFullSize, ETrue);

                }

            }

            delete aDir;

        }

#ifdef IMAGIC_DATABASE    

    //RemoveDeletedImagesL(*array, &aDirPath);

#endif    

    DP0_IMAGIC(_L("CIEImageFinder::ScanDirL--"));

    }

void CIEImageFinder::CheckCreatedThumbnails(CImageData& aImageData) const

    {

    TThumbSize sizes[] = { /*EFullSize,*/ ESize512x512, ESize128x128, ESize32x32 };

    TInt numSizes = sizeof(sizes) / sizeof(TThumbSize);

    for (TInt i = 0;i < numSizes; i++)

        {

        TFileName fileName;

        aImageData.GetFileName(fileName, sizes[i]);

        if (BaflUtils::FileExists(iFileServer, fileName))

            aImageData.SetImageReady(sizes[i], ETrue);

        else

            // Mark all smaller sizes non-exist

            //while (i < numSizes)

                {

                aImageData.SetImageReady(sizes[i], EFalse);

                //i++;

                }

        }    

    }

void CIEImageFinder::FileSystemChanged()

    {

    //Scan filesystem for new images

    //SearchForNewFilesL(KRootImagePath, KFileString);

#ifdef __WINS__

    SearchFilesL(KFileString);

#else

    TFileName rootPath = PathInfo::MemoryCardRootPath();

    rootPath.Append(ImagePath);

    SearchFilesL(KFileString);

#endif

    }