/*

* Copyright (c) 2006-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:

*

* Description:  Harvester image plugin

*

*/

#include <e32base.h>

#include <e32math.h>

#include <locationdatatype.h>

#include <harvesterdata.h>

#include <pathinfo.h>

#include "harvesterlog.h"

#include "mdsutils.h"

#include "harvesterexifutil.h"

#include "harvesterimageplugin.h"

#include "mdeobjectwrapper.h"

#include "mdscommoninternal.h"

using namespace MdeConstants;

// image mime types

_LIT( KJpegMime, "image/jpeg" );

_LIT( KJpeg2000Mime, "image/jp2" );

_LIT( KJpeg2000_2Mime, "image/jpx" );

_LIT( KTiffMime, "image/tiff" );

_LIT( KMsmMime, "application/x-msmetafile" );

_LIT( KGifMime, "image/gif" );

_LIT( KXbmpMime, "image/x-bmp" );

_LIT( KBmpMime, "image/bmp" );

_LIT( KPngMime, "image/png" );

_LIT( KMbmMime, "image/x-epoc-mbm" );

_LIT( KOtaMime, "image/vnd.nokia.ota-bitmap" );

_LIT( KXotaMime, "image/x-ota-bitmap" );

_LIT( KWbmpMime, "image/vnd.wap.wbmp" );

_LIT( KWmfMime, "image/x-wmf" );

_LIT( KOtbMime, "image/vnd.nokia.ota-bitmap" );

_LIT( KExtJpg, "JPG" );

_LIT( KExtJpeg, "JPEG" );

_LIT( KExtJp2, "JP2" );

_LIT( KExtJ2k, "J2K" ); 

_LIT( KExtJpx, "JPX" ); 

_LIT( KExtJpf, "JPF" );

_LIT( KExtMbm, "MBM" ); 

_LIT( KExtPng, "PNG" );

_LIT( KExtGif, "GIF" );

_LIT( KExtBmp, "BMP" );

_LIT( KExtTif, "TIF" );

_LIT( KExtTiff, "TIFF" );

_LIT( KExtOta, "OTA" );

_LIT( KExtWbmp, "WBMP" );

_LIT( KExtWmf, "WMF" ); 

_LIT( KExtOtb, "OTB" ); 

#ifdef MDS_MULTIPLE_STAGE_IMAGE_PROCESSING

const TUid KBGPSUid = { 0x0ADC2480 };

#endif

	{

	}

	{

	}

/**

* Default constructor

*/

CHarvesterImagePlugin::CHarvesterImagePlugin() : CHarvesterPlugin(),

    iExifUtil( NULL ), iDecoder( NULL ), iPropDefs( NULL )

	{

	}

/**

* Construction

* @return Harvester image plugin

*/

CHarvesterImagePlugin* CHarvesterImagePlugin::NewL()

	{

	WRITELOG( "CHarvesterImagePlugin::NewL()" );

	CHarvesterImagePlugin* self = new (ELeave) CHarvesterImagePlugin();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

/**

* Destruction

*/

CHarvesterImagePlugin::~CHarvesterImagePlugin()

	{

	WRITELOG( "CHarvesterImagePlugin::~CHarvesterImagePlugin()" );

	if (iDecoder)

		{

		iDecoder->Reset();

	    delete iDecoder;

		}   

    if (iExifUtil)

		{

		delete iExifUtil;

		}

    delete iPropDefs;

    delete iPhoneImagesPath;

    delete iMmcImagesPath;

    iMimeTypeMappings.Close();

    iFbs.Disconnect();

	}

/**

* 2nd phase constructor

*/

void CHarvesterImagePlugin::ConstructL()

	{

	WRITELOG( "CHarvesterImagePlugin::ConstructL()" );

	iDecoder = CBufferedImageDecoder::NewL( iFs );

	iExifUtil = CHarvesterExifUtil::NewL();

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

    TLinearOrder< TMimeTypeMapping<TImageMetadataHandling> > cmp(

    		TMimeTypeMapping<TImageMetadataHandling>::CompareFunction);

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtJpg(), KJpegMime(), EJpegHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtJpeg(), KJpegMime(), EJpegHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtGif(), KGifMime(), EGifHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtBmp(), KBmpMime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtJpf(), KJpeg2000_2Mime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtJpx(), KJpeg2000_2Mime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtJp2(), KJpeg2000Mime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtJ2k(), KJpeg2000Mime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtMbm(), KMbmMime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtOta(), KOtaMime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtPng(), KPngMime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtTif(), KTiffMime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtTiff(), KTiffMime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtWbmp(), KWbmpMime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

    		KExtWmf(), KWmfMime(), EOtherHandling ), cmp ) );

    User::LeaveIfError( iMimeTypeMappings.InsertInOrder( TMimeTypeMapping<TImageMetadataHandling>(

            KExtOtb(), KOtbMime(), EOtherHandling ), cmp ) );

    TFileName images = PathInfo::ImagesPath();

    TFileName phonePath = PathInfo::PhoneMemoryRootPath();

    phonePath.Append( images );

    iPhoneImagesPath = phonePath.AllocL();

    TFileName mmcPath = PathInfo::MemoryCardRootPath();

    mmcPath.Append( images );

    iMmcImagesPath = mmcPath.Right( mmcPath.Length() - 1 ).AllocL();

	}

void CHarvesterImagePlugin::HarvestL( CHarvesterData* aHD )

	{

	WRITELOG( "CHarvesterImagePlugin::HarvestL()" );

    CMdEObject& mdeObject = aHD->MdeObject();

    CFileData* fileData = CFileData::NewL();

    CleanupStack::PushL( fileData );

    CHarvestData* harvestData = CHarvestData::NewL();

    CleanupStack::PushL( harvestData );

    TInt errorCode( KErrNone );

    TRAPD( error, errorCode = GatherDataL( mdeObject, *fileData, *harvestData ) );

    if ( error == KErrNone && (errorCode == KErrNone || errorCode == KErrCompletion ) ) // ok, something got harvested

        {

        if ( mdeObject.Id() == 0 || mdeObject.Placeholder() ) // is a new object or placeholder

            {

            TRAP_IGNORE( HandleObjectPropertiesL( *harvestData, *fileData, *aHD, ETrue ) );

            mdeObject.SetPlaceholder( EFalse );

            }

        else   // not a new object

            {

            TRAP_IGNORE( HandleObjectPropertiesL( *harvestData, *fileData, *aHD, EFalse ) );

            }

        if( harvestData->iStoreGpsLatitudeAndLongitude ||

        	harvestData->iStoreGpsAltitude )

        	{

        	TLocationData* locData = new (ELeave) TLocationData();

        	if( harvestData->iStoreGpsAltitude )

        		{

        		locData->iPosition.SetCoordinate( 

        				harvestData->iGpsLatitude, harvestData->iGpsLongitude, 

        				harvestData->iGpsAltitude);

        		}

        	else

        		{

        		locData->iPosition.SetCoordinate( 

        				harvestData->iGpsLatitude, harvestData->iGpsLongitude);

        		}

        	// remove unnessesary values

        	locData->iNetworkInfo.iAreaKnown = EFalse;

        	TRealX nanX;

        	nanX.SetNaN();

        	nanX.GetTReal( locData->iQuality );

        	aHD->SetLocationData( locData );

        	}

        }

    else if( error != KErrNone)

        {

        WRITELOG1( "CHarvesterImagePlugin::HarvestL() - other error: %d", error );

        TInt convertedError = KErrNone;

        MdsUtils::ConvertTrapError( error, convertedError );

        aHD->SetErrorCode( convertedError );

        WRITELOG1( "CHarvesterImagePlugin::HarvestL() - returning: %d", convertedError );

        }

    else

        {

        WRITELOG1( "CHarvesterImagePlugin::HarvestL() - other error: %d", errorCode );

        TInt convertedError = KErrNone;

        MdsUtils::ConvertTrapError( errorCode, convertedError );

        aHD->SetErrorCode( convertedError );

        WRITELOG1( "CHarvesterImagePlugin::HarvestL() - returning: %d", convertedError );

        }

    // Delete image data.

    CleanupStack::PopAndDestroy( 2, fileData );

	}

// ---------------------------------------------------------------------------

// CHarvesterImagePlugin::GetMimeType (from CHarvesterPlugin)

// ---------------------------------------------------------------------------

//    

void CHarvesterImagePlugin::GetMimeType( const TDesC& aUri, TDes& aMimeType )

    {

    aMimeType.Zero();

    TPtrC ext;

    if( !MdsUtils::GetExt( aUri, ext ) )

        {

        return;

        }

    TMimeTypeMapping<TImageMetadataHandling> finder(ext);

    TLinearOrder< TMimeTypeMapping<TImageMetadataHandling> > cmp(

            TMimeTypeMapping<TImageMetadataHandling>::CompareFunction);

    const TInt pos = iMimeTypeMappings.FindInOrder( finder, cmp );

    if ( pos == KErrNotFound )

        {

        return;

        }

    aMimeType = iMimeTypeMappings[pos].iMimeType;

    }

// ---------------------------------------------------------------------------

// GatherData

// ---------------------------------------------------------------------------

//    

TInt CHarvesterImagePlugin::GatherDataL( CMdEObject& aMetadataObject,

    CFileData& aFileData, CHarvestData& aHarvestData )

    {

#ifdef _DEBUG

    TTime dStart, dStop;

    dStart.UniversalTime();

    dStop.UniversalTime();

    WRITELOG1( "CHarvesterImagePlugin::GatherData() start %d us", (TInt)dStop.MicroSecondsFrom(dStart).Int64() );

#endif

    WRITELOG( "CHarvesterImagePlugin::GatherData()" );

    TBool dataExtracted( aMetadataObject.Id() == 0 || aMetadataObject.Placeholder() );

    aFileData.iImageDef = &aMetadataObject.Def();

    if( dataExtracted )

        {

        CMdEProperty* prop = NULL;

        CMdEObjectDef& objectDef = *aFileData.iImageDef;

        aMetadataObject.Property( *iPropDefs->iSizePropertyDef, prop );

        if( prop )

            {

            aFileData.iFileSize  = prop->Uint32ValueL();

            }

        else

            {

            dataExtracted = EFalse;

            }

        aMetadataObject.Property( *iPropDefs->iLastModifiedDatePropertyDef, prop );

        if( prop )

            {

            aFileData.iModified  = prop->TimeValueL();

            }

        else

            {

            dataExtracted = EFalse;

            }

        }

    const TDesC& uri = aMetadataObject.Uri();

    if( !dataExtracted )

        {

        TEntry entry;

        const TInt errorcode = iFs.Entry( uri, entry );

        if ( errorcode != KErrNone )

            {

            return errorcode; // metadata cannot be gathered!

            }

        aFileData.iModified = entry.iModified;

        aFileData.iFileSize = (TUint)entry.iSize;

        }

    TPtrC imageFile = uri;

    aFileData.iUri = &imageFile;

    aFileData.iFrameCount = 1;

    TRAPD( readError, DataFromImageFileL( aFileData ) );

    if ( readError != KErrNone )

        {

        WRITELOG1( "CHarvesterImagePlugin::GatherData() - error reading image data, error: %d", readError );

        return KErrCompletion; // metadata item still can be created, thus KErrCompletion

        }

    TInt err = KErrNone;

    if ( aFileData.iExifSupported )

        {

        TRAP( err, iExifUtil->ReadExifDataL( aHarvestData, aFileData ) );

        }

    if( !aFileData.iExifSupported || err != KErrNone )

        {

        // Exif couldn't be found. Open the image with ICL decoder instead.

        WRITELOG( "CHarvesterImagePlugin::GatherData() - Exif could not be read. Using ICL." );

        TPtr8 imageDataPtr = aFileData.iImageData->Des();

        TRAP( err, iDecoder->OpenL(imageDataPtr, aFileData.iMime8,

                CImageDecoder::TOptions( CImageDecoder::EPreferFastDecode | CImageDecoder::EOptionIgnoreExifMetaData ) ) );

        if ( err != KErrNone )

            {

            WRITELOG1( "CHarvesterImagePlugin::GatherData() - ERROR: Decoder could not open image data! Code %d", err );

#ifdef _DEBUG

            if( err == KErrInUse || err == KErrLocked )

                {

                TPtrC fileName( uri.Mid(2) );

                WRITELOG1( "CHarvesterImagePlugin :: Checking open file handles to %S", &fileName );

                CFileList* fileList = 0;

                TOpenFileScan fileScan( iFs );

                fileScan.NextL( fileList );   

                while ( fileList )   

                    {

                    const TInt count( fileList->Count() );

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

                        {   

                        if ( (*fileList)[i].iName == uri.Mid(2) )

                            {

                            TFullName processName;

                            TFindThread find(_L("*"));

                            while( find.Next( processName ) == KErrNone )

                                {

                                RThread thread;

                                TInt err = thread.Open( processName );

                                if ( err == KErrNone )

                                    {

                                    if ( thread.Id().Id() ==  fileScan.ThreadId() )

                                        {

                                        processName = thread.Name();

                                        thread.Close();

                                        WRITELOG1( "CHarvesterImagePlugin:: %S has a file handle open", &processName );

                                        break;

                                        }

                                    thread.Close();

                                    }