/*

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

*

*/

// INCLUDE FILES

#include "glxdatasourcemds.h"

#include <fbs.h>

#include <glxbackgroundtnmessagedefs.h>

#include <glxcollectionmessagedefs.h>

#include <glxcommandrequest.h>

#include <glxgetrequest.h>

#include <glxidlistrequest.h>

#include <glxrequest.h>

#include <glxthumbnailrequest.h>

#ifndef USE_S60_TNM

#include <glxtndatabase.h>

#include <glxtnthumbnailcreator.h>

#endif

#include <glxtracer.h>

#include <glxlog.h>

#include <mdeobjectcondition.h>

#include <mderelationcondition.h>

#include <mderelationdef.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include "glxdatasourcetaskmds.h"

#include "glxdatasourcetaskmdsattribute.h"

#include "glxdatasourcetaskmdscommand.h"

#include "glxdatasourcetaskmdsidlist.h"

#include "glxdatasourcetaskmdsthumbnail.h"

#ifndef USE_S60_TNM

const TInt KGlxThumbnailCleanupAfterDeletions = 200;

_LIT(KGlxMdeDataSourceThumbnailDatabase, "glxmdstn");

#endif

const TInt KMaxGridThumbnailWidth = 200;

_LIT(KObjectDefLocation, "Location");

_LIT(KObjectDefNameAlbum, "Album");

_LIT(KObjectDefNameImage, "Image");

_LIT(KObjectDefNameMedia, "MediaObject");

_LIT(KObjectDefNameObject, "Object");

_LIT(KObjectDefNameTag, "Tag");

_LIT(KObjectDefNameVideo, "Video");

_LIT(KPropertyDefNameCreationDate, "CreationDate");

_LIT(KPropertyDefNameLastModifiedDate, "LastModifiedDate");

_LIT(KPropertyDefNameSize, "Size");

_LIT(KPropertyDefNameTitle, "Title");

_LIT(KRelationDefNameContains, "Contains");

_LIT(KRelationDefNameContainsLocation, "ContainsLocation");

_LIT(KObjectDefNameMonth, "MediaObject");/// @todo nasty hack remove and use base object

_LIT(KGlxMdeCameraAlbumUri, "defaultalbum_captured");

_LIT(KGlxMdeFavoritesUri, "defaultalbum_favourites");

#undef __USING_INTELLIGENT_UPDATE_FILTERING

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

// MPXChangeEventType

// Helper method

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

//

TMPXChangeEventType MPXChangeEventType(const TObserverNotificationType& aType)

	{

	TMPXChangeEventType type = EMPXItemInserted;

	switch (aType)

		{

		case ENotifyAdd:

			type = EMPXItemInserted;

		break;

		case ENotifyModify:

			type = EMPXItemModified;

		break;

		case ENotifyRemove:

			type = EMPXItemDeleted;

		break;

		}

	return type;

	}

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

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

// NewL()

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

//

CGlxDataSourceMde* CGlxDataSourceMde::NewL()

	{

    TRACER("CGlxDataSourceMde* CGlxDataSourceMde::NewL()");

	CGlxDataSourceMde* ds = new (ELeave) CGlxDataSourceMde();

	CleanupStack::PushL(ds);

	ds->ConstructL();

	CleanupStack::Pop(ds); 

	return ds;

	}

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

// ~CGlxDataSourceMde()

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

//

CGlxDataSourceMde::~CGlxDataSourceMde()

	{

    TRACER("CGlxDataSourceMde::~CGlxDataSourceMde()");

    delete iSession;

#ifdef USE_S60_TNM

    delete iTnThumbnail;

    iTnThumbnail = NULL;    

    delete iThumbnail;

    iThumbnail = NULL;    

    delete iTnEngine;

    iTnEngine = NULL;    

#else 

     if (iThumbnailCreator)

    	{

    	iThumbnailCreator->Close(iThumbnailDatabase);

    	}

    delete iThumbnailDatabase;

#endif

    iFs.Close();

    RFbsSession::Disconnect();

    iMonthArray.Close();

    iMonthList.Close();

    iUpdateData.Close();

    delete iUpdateCallback;

    delete iCreateSessionCallback;

	}

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

// CGlxDataSourceMde()

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

//

CGlxDataSourceMde::CGlxDataSourceMde()

	{

    TRACER("CGlxDataSourceMde::CGlxDataSourceMde()")

    //No Implementation

	}

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

// ConstructL()

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

//

void CGlxDataSourceMde::ConstructL()

	{

    TRACER("CGlxDataSourceMde::ConstructL()")

	iDataSourceReady = EFalse;			

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

	iSession = CMdESession::NewL( *this );

    User::LeaveIfError(RFbsSession::Connect());

#ifdef USE_S60_TNM

    iTnEngine = CThumbnailManager::NewL( *this);

    iTnEngine->SetFlagsL(CThumbnailManager::EAllowAnySize);

    iTnEngine->SetDisplayModeL( EColor64K );

    iTnRequestInProgress = EFalse;

#else

	iThumbnailCreator = CGlxtnThumbnailCreator::InstanceL();

	iThumbnailDatabase = CGlxtnThumbnailDatabase::NewL(

            	                        KGlxMdeDataSourceThumbnailDatabase, this);

#endif

    iCreateSessionCallback = new ( ELeave )

	    CAsyncCallBack( TCallBack( CreateSession, this ), CActive::EPriorityHigh );

    iUpdateCallback = new ( ELeave )

	    CAsyncCallBack( TCallBack( ProcessItemUpdate, this ), CActive::EPriorityLow );

    iUpdateData.Reserve(100); // ignore if it fails

	}

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

// from MMdESessionObserver

// CMPXCollectionMdEPlugin::HandleSessionOpened

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

//    

void CGlxDataSourceMde::HandleSessionOpened( CMdESession& aSession, TInt aError )    

    {

    TRACER("CGlxDataSourceMde::HandleSessionOpened(CMdESession& aSession, TInt aError)")

    if( KErrNone != aError )

        {

        HandleSessionError(aSession, aError);

        }

    TRAPD(err, DoSessionInitL());

    if( KErrNone != err )

        {

        HandleSessionError(aSession, err);

        }

    iSessionOpen = ETrue;

    iDataSourceReady = ETrue;

	TryStartTask(ETrue);

    }

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

// from MMdESessionObserver

// CMPXCollectionMdEPlugin::HandleSessionError

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

//     

void CGlxDataSourceMde::HandleSessionError(CMdESession& /*aSession*/, TInt /*aError*/ )    

    {

    TRACER("CGlxDataSourceMde::HandleSessionError(CMdESession& /*aSession*/, TInt /*aError*/)")

    iSession = NULL;

    iDataSourceReady = EFalse;

    iSessionOpen = EFalse;

    iCreateSessionCallback->CallBack();

    }

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

// CreateTaskL

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

//

CGlxDataSourceTask* CGlxDataSourceMde::CreateTaskL(CGlxRequest* aRequest, MGlxDataSourceRequestObserver& aObserver)

	{

    TRACER("CGlxDataSourceTask* CGlxDataSourceMde::CreateTaskL(CGlxRequest* aRequest, MGlxDataSourceRequestObserver& aObserver)")	

	if(dynamic_cast<CGlxCommandRequest*>(aRequest))

		{

        CleanupStack::PushL(aRequest);

        CGlxDataSourceTaskMdeCommand* task = new (ELeave) CGlxDataSourceTaskMdeCommand(static_cast<CGlxCommandRequest*>(aRequest), aObserver, this);

		CleanupStack::Pop(aRequest); // now owned by task

        CleanupStack::PushL(task);

        task->ConstructL();

		CleanupStack::Pop(task);

		return task;

		}

	else if (dynamic_cast< CGlxGetRequest *>(aRequest))

		{

	    _LIT( KFormatTimeStamp, "[%H:%T:%S.%*C5]");

	    RDebug::Print(_L("==> CGlxDataSourceMde::CreateTaskL - CGlxDataSourceTaskMdeAttributeMde+"));

	    TTime time;

	    time.HomeTime(); // Get home time

	    TBuf<32> timeStampBuf;

	    time.FormatL(timeStampBuf, KFormatTimeStamp);

	    RDebug::Print(_L("%S"), &timeStampBuf);    

        CleanupStack::PushL(aRequest);

        CGlxDataSourceTaskMdeAttributeMde* task = new (ELeave) CGlxDataSourceTaskMdeAttributeMde(static_cast<CGlxGetRequest*>(aRequest), aObserver, this);

		CleanupStack::Pop(aRequest); // now owned by task

        CleanupStack::PushL(task);

        task->ConstructL();

		CleanupStack::Pop(task);

		return task;

		}

	else if (dynamic_cast< CGlxIdListRequest *>(aRequest))

		{	

        CleanupStack::PushL(aRequest);

        CGlxDataSourceTaskMdeIdList* task = new (ELeave) CGlxDataSourceTaskMdeIdList(static_cast<CGlxIdListRequest*>(aRequest), aObserver, this);

        CleanupStack::Pop(aRequest); // now owned by task

        CleanupStack::PushL(task); 

        task->ConstructL();

        CleanupStack::Pop(task);

        return task;

		}

	else if (dynamic_cast< CGlxThumbnailRequest *>(aRequest))

		{	

	    _LIT( KFormatTimeStamp, "[%H:%T:%S.%*C5]");

	    RDebug::Print(_L("==> CGlxDataSourceMde::CreateTaskL - CGlxDataSourceTaskMdeThumbnail+"));

	    TTime time;

	    time.HomeTime(); // Get home time

	    TBuf<32> timeStampBuf;

	    time.FormatL(timeStampBuf, KFormatTimeStamp);

	    RDebug::Print(_L("%S"), &timeStampBuf);    

        CleanupStack::PushL(aRequest);

        CGlxDataSourceTaskMdeThumbnail* task = new (ELeave) CGlxDataSourceTaskMdeThumbnail(static_cast<CGlxThumbnailRequest*>(aRequest), aObserver, this);

        CleanupStack::Pop(aRequest); // now owned by task

        CleanupStack::PushL(task); 

        task->ConstructL();

        CleanupStack::Pop(task);

        return task;

		}

	else

		{

		User::Leave(KErrNotSupported);

		return NULL; // stops compiler warning

		}

	}

#ifndef USE_S60_TNM

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

// ThumbnailAvailable

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

//

void CGlxDataSourceMde::ThumbnailAvailable(const TGlxMediaId& /*aId*/, const TSize& /*aSize*/)

	{

    TRACER("CGlxDataSourceMde::ThumbnailAvailable(const TGlxMediaId& /*aId*/, const TSize& /*aSize*/)")

	//No implementation

	}

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

// BackgroundThumbnailError

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

//

void CGlxDataSourceMde::BackgroundThumbnailError(const TGlxMediaId& aId, TInt aError)

	{

    TRACER("CGlxDataSourceMde::BackgroundThumbnailError(const TGlxMediaId& aId, TInt aError)")

	TSize size(0, 0);

	TRAP_IGNORE(BackgroundThumbnailMessageL(aId, size, aError));

	}

#endif

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

// BackgroundThumbnailMessageL

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

//

void CGlxDataSourceMde::BackgroundThumbnailMessageL(const TGlxMediaId& aId, const TSize& aSize, TInt aError)

	{

    TRACER("CGlxDataSourceMde::BackgroundThumbnailMessageL(const TGlxMediaId& aId, const TSize& aSize, TInt aError)")

	CMPXMessage* message = CMPXMessage::NewL();

	CleanupStack::PushL(message);

	message->SetTObjectValueL(KMPXMessageGeneralId, KGlxMessageIdBackgroundThumbnail);

	message->SetTObjectValueL<TMPXItemId>(KGlxBackgroundThumbnailMediaId, aId.Value());

	message->SetTObjectValueL(KGlxBackgroundThumbnailSize, aSize);

	message->SetTObjectValueL(KGlxBackgroundThumbnailError, aError);

	BroadcastMessage(*message);

	CleanupStack::PopAndDestroy(message);

	}

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

// DoSessionInitL

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

//

void CGlxDataSourceMde::DoSessionInitL()

	{

    TRACER("CGlxDataSourceMde::DoSessionInitL()")

	/// @todo check schema version number

    iNameSpaceDef = &iSession->GetDefaultNamespaceDefL();

	CMdEObject* cameraAlbum = iSession->GetObjectL(KGlxMdeCameraAlbumUri);

	if ( !cameraAlbum )

		{

		User::Leave(KErrCorrupt);

		}

	iCameraAlbumId = (TGlxMediaId)cameraAlbum->Id();

	delete cameraAlbum;

    CMdEObject* favorites = iSession->GetObjectL(KGlxMdeFavoritesUri);

	if ( !favorites )

		{

		User::Leave(KErrCorrupt);

		}

	iFavoritesId = (TGlxMediaId)favorites->Id();

	delete favorites;

    iContainsDef = &iNameSpaceDef->GetRelationDefL(KRelationDefNameContains);

    iContainsLocationDef = &iNameSpaceDef->GetRelationDefL(KRelationDefNameContainsLocation);

    iObjectDef = &iNameSpaceDef->GetObjectDefL(KObjectDefNameObject);

    iImageDef = &iNameSpaceDef->GetObjectDefL(KObjectDefNameImage);

    iVideoDef = &iNameSpaceDef->GetObjectDefL(KObjectDefNameVideo);

    iMediaDef = &iNameSpaceDef->GetObjectDefL(KObjectDefNameMedia);

    iAlbumDef = &iNameSpaceDef->GetObjectDefL(KObjectDefNameAlbum);

    iTagDef = &iNameSpaceDef->GetObjectDefL(KObjectDefNameTag);

    iMonthDef = &iNameSpaceDef->GetObjectDefL(KObjectDefNameMonth);

    iLocationDef = &iNameSpaceDef->GetObjectDefL(KObjectDefLocation);

	AddMdEObserversL();

	PrepareMonthsL();

	}

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

// AddMdEObserversL

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

//

void CGlxDataSourceMde::AddMdEObserversL()

    {

    TRACER("CGlxDataSourceMde::AddMdEObserversL()")

	iSession->AddRelationObserverL(*this);

	iSession->AddRelationPresentObserverL(*this);

	iSession->AddObjectObserverL(*this);

	iSession->AddObjectPresentObserverL(*this);

    }

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

// CGlxDataSourceMde::HandleObjectNotification

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

//

///@todo AB test this

void CGlxDataSourceMde::HandleObjectNotification(CMdESession& /*aSession*/, 

					TObserverNotificationType aType,

					const RArray<TItemId>& aObjectIdArray)

	{

    TRACER("CGlxDataSourceMde::HandleObjectNotification()")

	ProcessUpdateArray(aObjectIdArray,  MPXChangeEventType(aType), ETrue);

#ifndef USE_S60_TNM

	if(MPXChangeEventType(aType) == EMPXItemDeleted )

		{			

		TInt count = aObjectIdArray.Count();

		iDeletedCount += count;

		if(iDeletedCount > KGlxThumbnailCleanupAfterDeletions)

		    {

	    	TRAPD(err, ThumbnailCreator().CleanupThumbnailsL(iThumbnailDatabase));

	    	if(!err)

	    	    {

	    	    iDeletedCount = 0;

	    	    }

		    }

		}

#endif		

	}

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

// CGlxDataSourceMde::HandleObjectPresentNotification

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

//

///@todo AB test this

void CGlxDataSourceMde::HandleObjectPresentNotification(CMdESession& /*aSession*/, 

		TBool aPresent, const RArray<TItemId>& aObjectIdArray)

	{

    TRACER("CGlxDataSourceMde::HandleObjectPresentNotification()")

	if (aPresent)

		{

		ProcessUpdateArray(aObjectIdArray, EMPXItemInserted, ETrue);

		}

	else

		{

		ProcessUpdateArray(aObjectIdArray,  EMPXItemDeleted, ETrue);

		}

	}

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

// CGlxDataSourceMde::HandleRelationNotification

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

//

///@todo AB test this

void CGlxDataSourceMde::HandleRelationNotification(CMdESession& /*aSession*/, 

			TObserverNotificationType aType,

			const RArray<TItemId>& aRelationIdArray)

	{

    TRACER("CGlxDataSourceMde::HandleRelationNotification()")

	ProcessUpdateArray(aRelationIdArray, MPXChangeEventType(aType), EFalse);

	}

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

// CGlxDataSourceMde::HandleRelationPresentNotification

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

//

///@todo AB test this

void CGlxDataSourceMde::HandleRelationPresentNotification(CMdESession& /*aSession*/,

			TBool aPresent, const RArray<TItemId>& aRelationIdArray)

	{

    TRACER("CGlxDataSourceMde::HandleRelationPresentNotification()")

	if (aPresent)

		{

		ProcessUpdateArray(aRelationIdArray, EMPXItemInserted, EFalse);

		}

	else

		{

		ProcessUpdateArray(aRelationIdArray, EMPXItemDeleted, EFalse);

		}

	}

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

// ProcessUpdateArray

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

//

void CGlxDataSourceMde::ProcessUpdateArray(const RArray<TItemId>& aArray, TMPXChangeEventType aType, TBool aIsObject)

	{

    TRACER("CGlxDataSourceMde::ProcessUpdateArray(const RArray<TItemId>& aArray, TMPXChangeEventType aType, TBool aIsObject)")

    // only need one message so process first item

    TUpdateData update;

    update.iId = aArray[0];

    update.iType = aType;

    update.iIsObject = aIsObject;

    if( iUpdateData.Count() )

        {

        if( ( iUpdateData[0].iType == aType ) && ( iUpdateData[0].iIsObject ) )

            {

            return;

            }

        }

    if( iUpdateData.Append(update) == KErrNone ) // if we can't allocate space for the update, ignore it

        {

        iUpdateCallback->CallBack();

        }

	}

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

// MPXChangeEventType

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

//

TInt CGlxDataSourceMde::CreateSession(TAny* aPtr)

    {

    TRACER("CGlxDataSourceMde::CreateSession(TAny* aPtr)")

    CGlxDataSourceMde* self

                    = reinterpret_cast<CGlxDataSourceMde*>( aPtr );

    TRAP_IGNORE(self->CreateSessionL());

    return 0;

    }

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

// CreateSessionL

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

//

void CGlxDataSourceMde::CreateSessionL()

    {

    TRACER("CGlxDataSourceMde::CreateSessionL()")