--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/photosgallery/collectionframework/datasource/plugins/glxdatasourcemde/src/glxdatasourcemde.cpp Thu Dec 17 08:45:44 2009 +0200
@@ -0,0 +1,793 @@
+/*
+* 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)
+ {
+ GLX_LOG_ENTRY_EXIT("TContainerType CGlxDataSourceMde::ContainerType()");
+ TContainerType containerType = EContainerTypeNotAContainer;
+
+ if( 0 == aObject->Def().Compare(*iAlbumDef) )
+ {
+ containerType = EContainerTypeAlbum;
+ }
+ else if( 0 == aObject->Def().Compare(*iTagDef) )
+ {
+ containerType = EContainerTypeTag;
+ }
+ else if( 0 == aObject->Def().Compare(*iMonthDef) )
+ {
+ containerType = EContainerTypeMonth;
+ }
+
+ return containerType;
+ }
+
+CGlxDataSource::TContainerType CGlxDataSourceMde::ContainerType(CMdEObjectDef* aObjectDef)
+ {
+ GLX_LOG_ENTRY_EXIT("TContainerType CGlxDataSourceMde::ContainerType()");
+ TContainerType containerType = EContainerTypeNotAContainer;
+
+ if( 0 == aObjectDef->Compare(*iAlbumDef) )
+ {
+ containerType = EContainerTypeAlbum;
+ }
+ else if( 0 == aObjectDef->Compare(*iTagDef) )
+ {
+ containerType = EContainerTypeTag;
+ }
+ else if( 0 == aObjectDef->Compare(*iMonthDef) )
+ {
+ containerType = EContainerTypeMonth;
+ }
+
+ return containerType;
+ }
+CGlxDataSource::TItemType CGlxDataSourceMde::ItemType(CMdEObject* aObject)
+ {
+ GLX_LOG_ENTRY_EXIT("TItemType CGlxDataSourceMde::ItemType()");
+ TItemType itemType = EItemTypeNotAnItem;
+
+ if( 0 == aObject->Def().Compare(*iImageDef) )
+ {
+ itemType = EItemTypeImage;
+ }
+ else if(0 == aObject->Def().Compare(*iVideoDef) )
+ {
+ itemType = EItemTypeVideo;
+ }
+
+ return itemType;
+ }
+void CGlxDataSourceMde::PrepareMonthsL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceMde::PrepareMonthsL()");
+ TTime month(0);
+ iFirstMonth = month;
+ }
+const TGlxMediaId CGlxDataSourceMde::GetMonthIdL(const TTime& aMonth)
+ {
+ GLX_LOG_ENTRY_EXIT("TGlxMediaId CGlxDataSourceMde::GetMonthIdL()");
+ TTime monthStart = iFirstMonth + aMonth.MonthsFrom(iFirstMonth);
+ const TTimeIntervalMonths KGlxOneMonth = 1;
+ const TTimeIntervalMicroSeconds KGlxOneMicrosecond = 1;
+
+ TGlxMediaId monthId;
+ TInt monthIndex = iMonthArray.Find(monthStart);
+ if( monthIndex != KErrNotFound )
+ {
+ monthId = iMonthList[monthIndex];
+ }
+ else
+ {
+ _LIT(KGlxMonthTitleFormat, "%F%Y%M%D:");
+ const TInt KGlxMonthTitleLength = 12;
+ TBuf<KGlxMonthTitleLength> title;
+ monthStart.FormatL(title, KGlxMonthTitleFormat);
+
+ CMdEObject* month = iSession->GetObjectL(title);
+ if( month )
+ {
+ monthId = (TGlxMediaId)month->Id();
+ iMonthArray.AppendL(monthStart);
+ iMonthList.AppendL(monthId);
+ delete month;
+ }
+ else
+ {
+ TTime monthEnd = monthStart + KGlxOneMonth - KGlxOneMicrosecond;
+ month = iSession->NewObjectLC(*iMonthDef, title);
+
+ // A title property def of type text is required.
+ CMdEPropertyDef* titlePropertyDef = iObjectDef->GetPropertyDefL(KPropertyDefNameTitle);
+ if (!titlePropertyDef || titlePropertyDef->PropertyType() != EPropertyText)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ // Set the object title.
+ month->AddTextPropertyL (*titlePropertyDef, title);
+
+ // A size property is required.
+ CMdEPropertyDef* sizePropertyDef = iObjectDef->GetPropertyDefL(KPropertyDefNameSize);
+ if (!sizePropertyDef || sizePropertyDef->PropertyType() != EPropertyUint32)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ month->AddUint32PropertyL(*sizePropertyDef,0);
+
+
+ // A creation date property is required.
+ CMdEPropertyDef* creationDateDef = iObjectDef->GetPropertyDefL(KPropertyDefNameCreationDate);
+ if (!creationDateDef || creationDateDef->PropertyType() != EPropertyTime)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ month->AddTimePropertyL(*creationDateDef, monthStart);
+
+ // A last modified date property is required.
+ CMdEPropertyDef* lmDateDef = iObjectDef->GetPropertyDefL(KPropertyDefNameLastModifiedDate);
+ if (!lmDateDef || lmDateDef->PropertyType() != EPropertyTime)
+ {
+ User::Leave(KErrCorrupt);
+ }
+
+ month->AddTimePropertyL(*lmDateDef, monthEnd);
+
+ monthId = (TGlxMediaId)iSession->AddObjectL(*month);
+ CleanupStack::PopAndDestroy(month);
+ iMonthArray.AppendL(monthStart);
+ iMonthList.AppendL(monthId);
+ }
+ }
+ return monthId;
+ }
+TBool CGlxDataSourceMde::SameMonth(const TTime& aOldDate, const TTime& aNewDate)
+ {
+ GLX_LOG_ENTRY_EXIT("TBool CGlxDataSourceMde::SameMonth(const TTime& aOldDate, const TTime& aNewDate)");
+ return ( aOldDate.MonthsFrom(iFirstMonth) == aNewDate.MonthsFrom(iFirstMonth) );
+ }
+
+TBool CGlxDataSourceMde::ContainerIsLeft(CMdEObjectDef& aObjectDef)
+ {
+ GLX_LOG_ENTRY_EXIT("TBool CGlxDataSourceMde::ContainerIsLeft(CMdEObjectDef& aObjectDef)");
+ TBool containerLeft = EFalse;
+ if ( 0 == aObjectDef.Compare(AlbumDef()) )
+ {
+ containerLeft = ETrue;
+ }
+ return containerLeft;
+ }
+
+void CGlxDataSourceMde::TaskCompletedL()
+ {
+ iPauseUpdate = EFalse;
+ iUpdateCallback->CallBack();
+ }
+
+void CGlxDataSourceMde::TaskStartedL()
+ {
+ iPauseUpdate = ETrue;
+ }
+
+#ifdef USE_S60_TNM
+void CGlxDataSourceMde::FetchThumbnailL(CGlxRequest* aRequest, MThumbnailFetchRequestObserver& aObserver)
+ {
+ iTnFetchObserver = &aObserver;
+
+ CGlxThumbnailRequest* request = static_cast<CGlxThumbnailRequest*>(aRequest);
+
+ TGlxThumbnailRequest tnReq;
+ request->ThumbnailRequest(tnReq);
+ User::LeaveIfNull(request->ThumbnailInfo());
+
+ iTnHandle = tnReq.iBitmapHandle;
+ iMediaId = tnReq.iId;
+ CThumbnailObjectSource* source = CThumbnailObjectSource::NewLC(request->ThumbnailInfo()->FilePath());
+ iTnEngine->SetThumbnailSizeL(tnReq.iSizeClass);
+
+ if (tnReq.iSizeClass.iWidth < KMaxGridThumbnailWidth)
+ {
+ iTnEngine->SetFlagsL(CThumbnailManager::ECropToAspectRatio);
+ }
+
+ iTnThumbnailCbId = iTnEngine->GetThumbnailL(*source);
+ iTnRequestInProgress = ETrue;
+ CleanupStack::PopAndDestroy();
+ }
+
+TInt CGlxDataSourceMde::CancelFetchThumbnail()
+ {
+ TInt ret = KErrNone;
+ if (iTnRequestInProgress)
+ {
+ ret = iTnEngine->CancelRequest(iTnThumbnailCbId);
+ }
+ return ret;
+ }
+
+void CGlxDataSourceMde::ThumbnailPreviewReady(MThumbnailData& /*aThumbnail*/,
+ TThumbnailRequestId /*aId*/)
+ {
+ TRACER("CGlxDataSourceMde::ThumbnailPreviewReady");
+ }
+
+// Called when real thumbnail is created
+void CGlxDataSourceMde::ThumbnailReady(TInt aError,
+ MThumbnailData& aThumbnail, TThumbnailRequestId aId)
+ {
+ TRACER("CGlxDataSourceMde::ThumbnailReady");
+ GLX_LOG_INFO1("GlxDataSourceMde::ThumbnailReady aError=%d", aError);
+ ThumbnailReadyL(aError,
+ aThumbnail, aId);
+ }
+// ---------------------------------------------------------------------------
+// ThumbnailReadyL
+// ---------------------------------------------------------------------------
+//
+void CGlxDataSourceMde::ThumbnailReadyL(TInt aError,
+ MThumbnailData& aThumbnail, TThumbnailRequestId aId)
+ {
+ TRACER("CGlxDataSourceMde::ThumbnailReadyL")
+ if (iTnThumbnailCbId == aId)
+ {
+ iTnRequestInProgress = EFalse;
+
+ if (aError == KErrNone && iTnHandle)
+ {
+ if (iTnHandle == KGlxMessageIdBackgroundThumbnail)
+ {
+ BackgroundThumbnailMessageL(iMediaId, TSize(), aError);
+ }
+ else
+ {
+ delete iTnThumbnail;
+ iTnThumbnail = NULL;
+ iTnThumbnail = aThumbnail.DetachBitmap();
+
+ delete iThumbnail;
+ iThumbnail = NULL;
+ iThumbnail = new (ELeave) CFbsBitmap();
+ User::LeaveIfError( iThumbnail->Duplicate(iTnHandle));
+ User::LeaveIfError(iThumbnail->Resize(iTnThumbnail->SizeInPixels()));
+ CFbsBitmapDevice* device = CFbsBitmapDevice::NewL(iThumbnail);
+ CleanupStack::PushL(device );
+ CFbsBitGc* context = NULL;
+ User::LeaveIfError(device->CreateContext(context));
+ CleanupStack::PushL(context);
+ context->BitBlt( TPoint(), iTnThumbnail);
+ CleanupStack::PopAndDestroy(context);
+ CleanupStack::PopAndDestroy(device);
+
+ iTnHandle = KErrNone;
+ }
+ }
+ }
+ if (iTnFetchObserver)
+ {
+ iTnFetchObserver->ThumbnailFetchComplete(aError);
+ }
+
+ }
+#endif