/*

* Copyright (c) 2006 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: the Data Source MDE class   

*

*/

/**

 * @internal reviewed 11/07/2007 by M Byrne

 */

// INCLUDE FILES

#include "glxdatasourcemde.h"

#include <fbs.h>

#include <glxbackgroundtnmessagedefs.h>

#include <glxcollectionmessagedefs.h>

#include <glxcommandrequest.h>

#include <glxgetrequest.h>

#include <glxidlistrequest.h>

#include <glxlog.h>

#include <glxtracer.h>

#include <glxrequest.h>

#include <glxthumbnailrequest.h>

#ifndef USE_S60_TNM

#include <glxtndatabase.h>

#include <glxtnthumbnailcreator.h>

#endif

#include <mdeobjectcondition.h>

#include <mderelationcondition.h>

#include <mderelationdef.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include "glxdatasourcetaskmde.h"

#include "glxdatasourcetaskmdeattribute.h"

#include "glxdatasourcetaskmdecommand.h"

#include "glxdatasourcetaskmdeidlist.h"

#include "glxdatasourcetaskmdethumbnail.h"

#ifdef USE_S60_TNM

const TInt KMaxGridThumbnailWidth = 120;

#else

_LIT(KGlxMdeDataSourceThumbnailDatabase, "glxmdstn");

#endif

_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(KObjectDefNameMonth, "MediaObject");/// @todo nasty hack remove and use base object

_LIT(KGlxMdeCameraAlbumUri, "Camera album");

_LIT(KGlxMdeFavoritesUri, "Favorites");

#undef __USING_INTELLIGENT_UPDATE_FILTERING

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

CGlxDataSourceMde* CGlxDataSourceMde::NewL()

	{

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

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

	CleanupStack::PushL(ds);

	ds->ConstructL();

	CleanupStack::Pop(ds); 

	return ds;

	}

CGlxDataSourceMde::~CGlxDataSourceMde()

	{

    GLX_LOG_ENTRY_EXIT("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()

	{

    GLX_LOG_ENTRY_EXIT("CGlxDataSourceMde::CGlxDataSourceMde()");

	}

void CGlxDataSourceMde::ConstructL()

	{

    GLX_LOG_ENTRY_EXIT("void 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->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 )    

    {

    GLX_LOG_ENTRY_EXIT("void 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*/ )    

    {

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

    iSession = NULL;

    iDataSourceReady = EFalse;

    iSessionOpen = EFalse;

    iCreateSessionCallback->CallBack();

    }

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

	{

    GLX_LOG_ENTRY_EXIT("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))

		{

        CleanupStack::PushL(aRequest);

        CGlxDataSourceTaskMdeAttribute* task = new (ELeave) CGlxDataSourceTaskMdeAttribute(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))

		{	

        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

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

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::ThumbnailAvailable()");

	//	no implementation

	}

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

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::BackgroundThumbnailError()");

	TSize size(0, 0);

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

	}

#endif

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

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::BackgroundThumbnailMessageL()");

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

	}

void CGlxDataSourceMde::DoSessionInitL()

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::DoSessionInitL()");

 	/// @todo check schema version number

    iNameSpaceDef = iSession->GetDefaultNamespaceDefL();

    if ( !iNameSpaceDef )

        {

        User::Leave(KErrCorrupt);

        }

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

    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();

	}

void CGlxDataSourceMde::AddMdEObserversL()

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::AddMdEObserversL()");

	iSession->AddRelationObserverL(*this);

	iSession->AddRelationPresentObserverL(*this);

	iSession->AddObjectObserverL(*this);

	iSession->AddObjectPresentObserverL(*this);

    }

void CGlxDataSourceMde::HandleObjectAdded(CMdESession& /*aSession*/, const RArray<TItemId>& aObjectIdArray)

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleObjectAdded()");

	ProcessUpdateArray(aObjectIdArray, EMPXItemInserted, ETrue);

	}

void CGlxDataSourceMde::HandleObjectModified(CMdESession& /*aSession*/, const RArray<TItemId>& aObjectIdArray)

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleObjectModified()");

	ProcessUpdateArray(aObjectIdArray, EMPXItemModified, ETrue);

	}

void CGlxDataSourceMde::HandleObjectRemoved(CMdESession& /*aSession*/, const RArray<TItemId>& aObjectIdArray)

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleObjectRemoved()");

	ProcessUpdateArray(aObjectIdArray, EMPXItemDeleted, ETrue);

	}

void CGlxDataSourceMde::HandleObjectPresent(CMdESession& /*aSession*/, const RArray<TItemId>& aObjectIdArray)

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleObjectPresent()");

	ProcessUpdateArray(aObjectIdArray, EMPXItemInserted, ETrue);

	}

void CGlxDataSourceMde::HandleObjectNotPresent(CMdESession& /*aSession*/, const RArray<TItemId>& aObjectIdArray)

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleObjectNotPresent()");

	ProcessUpdateArray(aObjectIdArray, EMPXItemDeleted, ETrue);

	}

void CGlxDataSourceMde::HandleRelationAdded(CMdESession& /*aSession*/, const RArray<TItemId>& aRelationIdArray)

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleRelationAdded()");

	ProcessUpdateArray(aRelationIdArray, EMPXItemInserted, EFalse);

	}

void CGlxDataSourceMde::HandleRelationRemoved(CMdESession& /*aSession*/, const RArray<TItemId>& aRelationIdArray)

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleRelationRemoved()");

	ProcessUpdateArray(aRelationIdArray, EMPXItemDeleted, EFalse);

	}

void CGlxDataSourceMde::HandleRelationModified(CMdESession& /*aSession*/, const RArray<TItemId>& /*aRelationIdArray*/)

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleRelationModified()");

	// not used until ordinals are required

	}

void CGlxDataSourceMde::HandleRelationPresent(CMdESession& /*aSession*/, const RArray<TItemId>& aRelationIdArray)

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleRelationPresent()");

	ProcessUpdateArray(aRelationIdArray, EMPXItemInserted, EFalse);

    }

void CGlxDataSourceMde::HandleRelationNotPresent(CMdESession& /*aSession*/, const RArray<TItemId>& aRelationIdArray)

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::HandleRelationNotPresent()");

	ProcessUpdateArray(aRelationIdArray, EMPXItemDeleted, EFalse);

    }

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

	{

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::ProcessUpdateArray()");

    // 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();

        }

	}

TInt CGlxDataSourceMde::CreateSession(TAny* aPtr)

    {

    GLX_LOG_ENTRY_EXIT("TInt CGlxDataSourceMde::CreateSession(TAny* aPtr)");

    CGlxDataSourceMde* self

                    = reinterpret_cast<CGlxDataSourceMde*>( aPtr );

    TRAP_IGNORE(self->CreateSessionL());

    return 0;

    }

void CGlxDataSourceMde::CreateSessionL()

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::CreateSessionL()");

	iSession = CMdESession::NewL( *this );

    }

TInt CGlxDataSourceMde::ProcessItemUpdate(TAny* aPtr)

    {

    GLX_LOG_ENTRY_EXIT("TInt CGlxDataSourceMde::ProcessItemUpdate(TAny* aPtr)");

    CGlxDataSourceMde* self

                    = reinterpret_cast<CGlxDataSourceMde*>( aPtr );

    TRAP_IGNORE(self->ProcessItemUpdateL());

    return 0;

    }

void CGlxDataSourceMde::ProcessItemUpdateL()

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::ProcessItemUpdateL()");

    if ( !iUpdateData.Count() || iPauseUpdate )

        {

        return;

        }

    CMPXMessage* message = CMPXMessage::NewL();

    CleanupStack::PushL(message);

    message->SetTObjectValueL<TInt>(KMPXMessageGeneralId, KMPXMessageIdItemChanged);

    message->SetTObjectValueL<TMPXChangeEventType>(KMPXMessageChangeEventType, iUpdateData[0].iType);

    TMPXGeneralCategory category = EMPXNoCategory;

	TMPXItemId id = iUpdateData[0].iId;

	GLX_LOG_INFO2("CGlxDataSourceMde::ProcessItemUpdateL() cat%d, item id %d", category, id.iId1);

#ifdef __USING_INTELLIGENT_UPDATE_FILTERING

	if ( !iUpdateData[0].iIsObject )

		{

		TMPXGeneralCategory containerCategory = EMPXNoCategory;

		TMPXItemId containerId;

		CMdERelation* relation = iSession->GetRelationL(id);

		if( relation )

			{

			TItemId rightId = relation->RightObjectId();

			TItemId leftId = relation->LeftObjectId();

    		delete relation;

    		CMdEObject* contObject = iSession->GetObjectL(leftId);

   		    __ASSERT_DEBUG(contObject, Panic(EGlxPanicIllegalState));

    		TContainerType container = ContainerType(contObject);

    		delete contObject;

	    	__ASSERT_DEBUG(( EContainerTypeTag != container), Panic(EGlxPanicIllegalState));

    		if( EContainerTypeNotAContainer == container )

    			{

    			CMdEObject* rightObject = iSession->GetObjectL(rightId);

    		    __ASSERT_DEBUG(rightObject, Panic(EGlxPanicIllegalState));

    			TContainerType rightContainer = ContainerType(rightObject);

    			delete rightObject;

   		    	__ASSERT_DEBUG(( EContainerTypeAlbum != rightContainer), Panic(EGlxPanicIllegalState));

    			if( EContainerTypeTag == rightContainer )

    				{

        			id = leftId;

        			containerId = rightId;

    		    	containerCategory = EMPXTag;

    				}

    			else if( EContainerTypeNotAContainer == rightContainer )

    				{

    				User::Leave(KErrNotSupported); // Not a gallery relation.

    				}

    			}

    		else if( EContainerTypeAlbum == container)

    	    	{

    			id = rightId;

    			containerId = leftId;

    	    	containerCategory = EMPXAlbum;

    	    	}

    		message->SetTObjectValueL<TMPXGeneralCategory>(KGlxCollectionMessageContainerCategory, containerCategory);

    		message->SetTObjectValueL<TMPXItemId>(KGlxCollectionMessageContainerId, containerId);

			}

	    else

	        {

	        // use id 0 to identify to ML that we don't know what was deleted

	        id = 0;

	        }

		}

	if ( id != 0 )

	    {

	    CMdEObject* object = iSession->GetObjectL(id);

    	if( object )

    		{

        	TContainerType container = ContainerType(object);

            if( EContainerTypeAlbum == container)

            	{

            	category = EMPXAlbum;

            	}

            else if( EContainerTypeTag == container)

            	{

            	category = EMPXTag;

            	}

            else

            	{

            	TItemType item = ItemType(object);

                if( EItemTypeImage == item)

                	{

                	category = EMPXImage;

                	}

                else if( EItemTypeVideo == item)

                	{

                	category = EMPXVideo;

                	}

            	}

        	delete object;

    		}

	    }

#endif // __USING_INTELLIGENT_UPDATE_FILTERING

	message->SetTObjectValueL<TMPXGeneralCategory>(KMPXMessageMediaGeneralCategory, category);

   	message->SetTObjectValueL<TMPXItemId>(KMPXMessageMediaGeneralId, id);

    BroadcastMessage(*message); 

    CleanupStack::PopAndDestroy(message);

    iUpdateData.Remove(0);

    }

CGlxDataSource::TContainerType CGlxDataSourceMde::ContainerType(CMdEObject* aObject)

	{