/*

* 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:    Data Source MDS Class

*

*/

// INCLUDE FILES

#include "glxdatasourcemds.h"

#include <e32base.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"

#ifdef USE_S60_TNM

const TInt KMaxGridThumbnailWidth = 200;

#else

const TInt KGlxThumbnailCleanupAfterDeletions = 200;

_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(KRelationDefNameContains, "Contains");

_LIT(KRelationDefNameContainsLocation, "ContainsLocation");

_LIT(KGlxMdeCameraAlbumUri, "defaultalbum_captured");

_LIT(KGlxMdeFavoritesUri, "defaultalbum_favourites");

#undef __USING_INTELLIGENT_UPDATE_FILTERING

const TInt KHarvestUpdateChunkSize = 1000;

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

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

	}

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

// CGlxMDSShutdownObserver::NewL()

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

//

CGlxMDSShutdownObserver* CGlxMDSShutdownObserver::NewL( MGlxMDSShutdownObserver& aObserver,

                                                const TUid& aKeyCategory,

                                                const TInt aPropertyKey,

                                                TBool aDefineKey)

    {

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

    CGlxMDSShutdownObserver* self = new( ELeave )CGlxMDSShutdownObserver( aObserver, 

                                                                  aKeyCategory,

                                                                  aPropertyKey,

                                                                  aDefineKey);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CGlxMDSShutdownObserver::CGlxMDSShutdownObserver()

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

//

CGlxMDSShutdownObserver::CGlxMDSShutdownObserver( MGlxMDSShutdownObserver& aObserver,

                                          const TUid& aKeyCategory,

                                          const TInt aPropertyKey,

                                          TBool aDefineKey)

    : CActive( CActive::EPriorityStandard ), iObserver( aObserver ),

      iKeyCategory( aKeyCategory ), iPropertyKey(aPropertyKey), iDefineKey( aDefineKey )

    {   

    TRACER("CGlxMDSShutdownObserver::CGlxMDSShutdownObserver()");

    CActiveScheduler::Add( this );

    }

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

// CGlxMDSShutdownObserver::ConstructL()

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

//

void CGlxMDSShutdownObserver::ConstructL()

    { 

    TRACER("void CGlxMDSShutdownObserver::ConstructL()");

    // define P&S property types

    if (iDefineKey)

        {

        RProperty::Define(iKeyCategory,iPropertyKey,

                          RProperty::EInt,KAllowAllPolicy,KPowerMgmtPolicy);

        }

    // attach to the property

    TInt err = iProperty.Attach(iKeyCategory,iPropertyKey,EOwnerThread);

    User::LeaveIfError(err);

    // wait for the previously attached property to be updated

    iProperty.Subscribe(iStatus);

    SetActive();

    }

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

// CGlxMDSShutdownObserver::~CGlxMDSShutdownObserver()

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

//

CGlxMDSShutdownObserver::~CGlxMDSShutdownObserver()

    {

    TRACER("CGlxMDSShutdownObserver::~CGlxMDSShutdownObserver()");

    Cancel();

    iProperty.Close();

    }

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

// CGlxMDSShutdownObserver::RunL()

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

//

void CGlxMDSShutdownObserver::RunL()

    {

    TRACER("void CGlxMDSShutdownObserver::RunL()");

    // resubscribe before processing new value to prevent missing updates

    iProperty.Subscribe(iStatus);

    SetActive();

    // retrieve the value

    TInt value = 0;

    TInt err = iProperty.Get(value);

    GLX_DEBUG2("CGlxMDSShutdownObserver::RunL(): iProperty.Get(value); returns %d", err);

    User::LeaveIfError(err);

    iObserver.ShutdownNotification(value);

    }

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

// CGlxMDSShutdownObserver::DoCancel()

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

//

void CGlxMDSShutdownObserver::DoCancel()

    {

    TRACER("void CGlxMDSShutdownObserver::DoCancel()");

    iProperty.Cancel();

    }

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

    iHC.Close();

    RFbsSession::Disconnect();

    iUpdateData.Close();

    iAddedItems.Reset();

    iAddedItems.Close();

    delete iUpdateCallback;

    delete iCreateSessionCallback;

    delete iMDSShutdownObserver ;

	}

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

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

    iTnRequestInProgress = EFalse;

#else

	iThumbnailCreator = CGlxtnThumbnailCreator::InstanceL();

	iThumbnailDatabase = CGlxtnThumbnailDatabase::NewL(

            	                        KGlxMdeDataSourceThumbnailDatabase, this);

#endif

    iCreateSessionCallback = new ( ELeave )

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

    iMDSShutdownObserver = CGlxMDSShutdownObserver::NewL( *this, KHarvesterPSShutdown, KMdSShutdown, EFalse );

    iUpdateCallback = new ( ELeave )

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

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

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

    iHC.AddHarvesterEventObserver(*this, EHEObserverTypePlaceholder, KHarvestUpdateChunkSize);

    iHarvestingOngoing = EFalse;

	}

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

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

        {

        iSessionOpen = ETrue;

        iDataSourceReady = ETrue;

        TryStartTask(ETrue);

        }

    else

        {

        HandleSessionError(aSession, err);

        }

    }

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

// from MMdESessionObserver

// CMPXCollectionMdEPlugin::HandleSessionError

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

//     

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

    {

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

    GLX_DEBUG2("void CGlxDataSourceMde::HandleSessionError() aError(%d)", aError);

    iDataSourceReady = EFalse;

    iSessionOpen = EFalse;

    // We wait till MDS restarts before starting the session if the current session is locked.

    // that is handled separately by the MDS Shutdown PUB SUB Framework.   

    // for everything else we use the generic method and continue.

    if ( (KErrLocked != aError) && ( KErrServerTerminated != aError) )

        {

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

		{

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

		{	

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

    iLocationDef = &iNameSpaceDef->GetObjectDefL(KObjectDefLocation);

	AddMdEObserversL();

	}

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

// AddMdEObserversL

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

//

void CGlxDataSourceMde::AddMdEObserversL()

    {

    TRACER("CGlxDataSourceMde::AddMdEObserversL()");

	iSession->AddRelationObserverL(*this);

	iSession->AddRelationPresentObserverL(*this);

	//when setting observing conditions,

	//add filters for all images, videos, Albums & Tags

	CMdELogicCondition* addCondition = CMdELogicCondition::NewLC( ELogicConditionOperatorOr );

	addCondition->AddObjectConditionL( *iImageDef );

	addCondition->AddObjectConditionL( *iVideoDef );

	addCondition->AddObjectConditionL( *iAlbumDef );

	addCondition->AddObjectConditionL( *iTagDef );

	iSession->AddObjectObserverL(*this, addCondition );

	iSession->AddObjectPresentObserverL(*this );

	// This addCondition should only be popped. 

	// As the ownership is transferred, the same will be destroyed by MdS.

	CleanupStack::Pop( addCondition ); 

    }