--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/engine/collectionframework/datasource/plugins/glxdatasourcemde/src/glxdatasourcetaskmdeattribute.cpp Fri Mar 19 09:28:59 2010 +0200
@@ -0,0 +1,1277 @@
+/*
+* 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:
+*
+*/
+
+
+
+#include "glxdatasourcetaskmdeattribute.h"
+
+#include <glxcollectionpluginCamera.hrh>
+#include <glxcollectionpluginDownloads.hrh>
+#include <glxcollectionpluginMonths.hrh>
+#include <glxcollectionpluginalbums.hrh>
+#include <glxcollectionpluginall.hrh>
+#include <glxcollectionplugintags.hrh>
+#include <glxerrors.h>
+#include <glxfilterfactory.h>
+#include <glxgetrequest.h>
+#include <glxgetrequest.h>
+#include <glxidlistrequest.h>
+#include <glxlog.h>
+#include <glxmediacollectioninternaldefs.h>
+#include <glxmediageneraldefs.h>
+#include <glxrequest.h>
+#include <glxthumbnailattributeinfo.h>
+#include <glxthumbnailrequest.h>
+#include <glxtndatabase.h>
+#include <glxtnfileinfo.h>
+#include <glxtnthumbnailcreator.h>
+#include <imageconversion.h>
+#include <lbsposition.h>
+#include <mdeconstants.h>
+#include <mdelogiccondition.h>
+#include <mdeobject.h>
+#include <mdeobjectdef.h>
+#include <mdeobjectquery.h>
+#include <mdepropertydef.h>
+#include <mderelationdef.h>
+#include <mdesession.h>
+#include <mdetextproperty.h>
+#include <mpxmedia.h>
+#include <mpxmediaarray.h>
+#include <mpxmediacollectiondetaildefs.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxmediadrmdefs.h>
+#include <mpxmediageneraldefs.h>
+
+#include "glxdatasourcemde.h"
+#include "glxdatasourcemde.h"
+#include "glxdatasourcemde.hrh"
+
+// CONSTANTS
+
+_LIT(KPropertyDefNameAlbumType, "Type");
+_LIT(KPropertyDefNameComment, "Comment");
+_LIT(KPropertyDefNameCreationDate, "CreationDate");
+_LIT(KPropertyDefNameDRM, "DRM");
+_LIT(KPropertyDefNameDuration, "Duration");
+_LIT(KPropertyDefNameFrameCount, "FrameCount");
+_LIT(KPropertyDefNameHeight, "Height");
+_LIT(KPropertyDefNameItemType, "ItemType");
+_LIT(KPropertyDefNameLastModifiedDate, "LastModifiedDate");
+_LIT(KPropertyDefNameLatitude, "Latitude");
+_LIT(KPropertyDefNameLongitude, "Longitude");
+_LIT(KPropertyDefNameSize, "Size");
+_LIT(KPropertyDefNameTitle, "Title");
+_LIT(KPropertyDefNameUsageCount, "UsageCount");
+_LIT(KPropertyDefNameWidth, "Width");
+
+// ----------------------------------------------------------------------------
+// Constructor
+// ----------------------------------------------------------------------------
+//
+CGlxDataSourceTaskMdeAttribute::CGlxDataSourceTaskMdeAttribute(CGlxGetRequest* aRequest, MGlxDataSourceRequestObserver& aObserver, CGlxDataSource* aDataSource)
+ : CGlxDataSourceTaskMde(aRequest, aObserver, aDataSource)
+ {
+ GLX_LOG_ENTRY_EXIT("CGlxDataSourceTaskMdeAttribute::CGlxDataSourceTaskMdeAttribute()");
+ iFilterProperties = TGlxFilterFactory::ExtractAttributes(iRequest->Filter());
+ }
+
+// ----------------------------------------------------------------------------
+// Destructor
+// ----------------------------------------------------------------------------
+//
+CGlxDataSourceTaskMdeAttribute::~CGlxDataSourceTaskMdeAttribute()
+ {
+ GLX_LOG_ENTRY_EXIT("CGlxDataSourceTaskMdeAttribute::~CGlxDataSourceTaskMdeAttribute()");
+ delete iMediaArray;
+ iQueryAttributes.Close();
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::ExecuteRequestL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::ExecuteRequestL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::ExecuteRequestL()");
+ CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);
+
+ __ASSERT_DEBUG(request->MediaIds().Count() > 0, User::Invariant());
+
+ if (request->MediaIds().Count() > 1)
+ {
+ iMediaArray = CMPXMediaArray::NewL();
+ }
+
+ if (request->MediaIds()[0] == KGlxCollectionRootId)
+ {
+ __ASSERT_DEBUG(request->MediaIds().Count() == 1, User::Invariant());
+ AddCollectionAttributesL(iResponse);
+ }
+ else
+ {
+
+ __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));
+ CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);
+
+ const RArray<TItemId>& mediaIds = reinterpret_cast<const RArray<TItemId>&>(request->MediaIds());
+
+ switch(iFilterProperties.iItemType)
+ {
+ case EGlxFilterVideoAndImages:
+ case EGlxFilterImage:
+ case EGlxFilterVideo:
+ {
+ QueueImageVideoObjectQueriesL(mediaIds, iFilterProperties);
+ if (LocationAttributeRequested())
+ {
+ QueueLocaitonQueryL();
+ }
+ break;
+ }
+ case EGlxFilterAlbum:
+ {
+ QueueAlbumObjectQueryL(mediaIds);
+ break;
+ }
+ case EGlxFilterTag:
+ {
+ QueueTagObjectQueryL(mediaIds);
+ break;
+ }
+ case EGlxFilterMonth:
+ {
+ QueueMonthObjectQueryL(mediaIds);
+ break;
+ }
+ }
+
+ }
+
+ DoNextQueryL();
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMde::DoHandleQueryCompletedL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::DoHandleQueryCompletedL(CMdEQuery& /*aQuery*/)
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoHandleQueryCompletedL()");
+ switch (iQueryTypes[0])
+ {
+ case ELocationAttributeQuery:
+ DoHandleLocationQueryCompletedL();
+ break;
+ case EAttributeQuery:
+ DoHandleAttributeQueryCompletedL();
+ break;
+ case EImageVideoQuery:
+ DoHandleImageVideoQueryCompletedL();
+ break;
+ case EContainerFirstItemQuery:
+ // Fall through to panic, DoHandleQueryCompletedL can't handle this query type.
+ default:
+ Panic(EGlxPanicLogicError);
+ break;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::DoNextQueryL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::DoNextQueryL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoNextQueryL()");
+ if (iQueries.Count())
+ {
+ ExecuteQueryL();
+ }
+ else
+ {
+ DoHandleAttributeResponseCompleteL();
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::DoHandleAttributeResponseCompleteL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::DoHandleAttributeResponseCompleteL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoHandleAttributeResponseCompleteL()");
+ __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));
+ CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);
+ if(request->MediaIds().Count() > 1)
+ {
+ iResponse->SetCObjectValueL(KMPXMediaArrayContents, iMediaArray);
+ iResponse->SetTObjectValueL(KMPXMediaArrayCount, iMediaArray->Count());
+ delete iMediaArray;
+ iMediaArray = NULL;
+ }
+ HandleRequestComplete(KErrNone);
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::AddAttributesLC
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::AddAttributesL(CMdEObject& aObject, CMPXMedia* aEntry)
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::AddAttributesL(CMdEObject& aObject, CMPXMedia* aEntry)");
+ __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));
+
+ CGlxDataSource::TContainerType containerType = DataSource()->ContainerType(&aObject);
+ if( containerType != CGlxDataSource::EContainerTypeNotAContainer )
+ {
+ AddContainerAttributesL(aEntry, &aObject, containerType);
+ }
+ else
+ {
+ CGlxDataSource::TItemType itemType = DataSource()->ItemType(&aObject);
+ if ( itemType != CGlxDataSource::EItemTypeNotAnItem )
+ {
+ AddItemAttributesL(aEntry, &aObject, itemType);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::AddCollectionAttributesL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::AddCollectionAttributesL(CMPXMedia* aEntry)
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::AddCollectionAttributesL(CMPXMedia* aEntry)");
+ __ASSERT_DEBUG(aEntry, Panic(EGlxPanicLogicError));
+ __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));
+ CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);
+
+ for ( TInt i = 0; i < request->Attributes().Count(); i++ )
+ {
+ if ( request->Attributes()[i] == KMPXMediaGeneralId )
+ {
+ aEntry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, (TMPXItemId)request->CollectionPluginUid().iUid);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralType )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralType, EMPXNoType);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralCategory )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXCollection);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralTitle )
+ {
+ request->AppendCpiAttributeL(KMPXMediaGeneralTitle);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralSystemItem )
+ {
+ aEntry->SetTObjectValueL(KGlxMediaGeneralSystemItem, ETrue);
+ }
+
+
+ #ifdef GLX_SUB_TITLE_REL8
+
+ //Attributes to get the Count of Images in Container
+ else if ( request->Attributes()[i] == KGlxMediaItemTypeImage )
+ {
+ TGlxMediaId container = TGlxMediaId(KGlxCollectionRootId);
+ CMdEObjectDef* objectDef = &DataSource()->ObjectDef();
+ TBool isContent = ETrue;
+ TGlxFilterProperties filterProperties = iFilterProperties;
+
+ switch(iRequest->CollectionPluginUid().iUid)
+ {
+ case KGlxCollectionPluginCameraImplementationUid:
+ {
+ container = DataSource()->CameraAlbumId();
+ objectDef = &DataSource()->AlbumDef();
+ filterProperties.iItemType = EGlxFilterImage;
+ QueueObjectQueryL(*objectDef, isContent, EAttributeQuery, EQueryResultModeCount, container, request->Attributes()[i], aEntry, filterProperties);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+
+ //Attributes to get the Count of Videos in Container
+ else if ( request->Attributes()[i] == KGlxMediaItemTypeVideo )
+ {
+ TGlxMediaId container = TGlxMediaId(KGlxCollectionRootId);
+ CMdEObjectDef* objectDef = &DataSource()->ObjectDef();
+ TBool isContent = ETrue;
+ TGlxFilterProperties filterProperties = iFilterProperties;
+
+ switch(iRequest->CollectionPluginUid().iUid)
+ {
+ case KGlxCollectionPluginCameraImplementationUid:
+ {
+ container = DataSource()->CameraAlbumId();
+ objectDef = &DataSource()->AlbumDef();
+ filterProperties.iItemType = EGlxFilterVideo;
+ QueueObjectQueryL(*objectDef, isContent, EAttributeQuery, EQueryResultModeCount, container, request->Attributes()[i], aEntry, filterProperties);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+#endif
+
+
+ else if ( ( request->Attributes()[i] == KMPXMediaGeneralCount ) || ( request->Attributes()[i] == KGlxMediaCollectionInternalUsageCount ) )
+ {
+ TGlxMediaId container = TGlxMediaId(KGlxCollectionRootId);
+ CMdEObjectDef* objectDef = &DataSource()->ObjectDef();
+ TBool isContent = ETrue;
+ TGlxFilterProperties filterProperties = iFilterProperties;
+
+ switch(iRequest->CollectionPluginUid().iUid)
+ {
+
+ case KGlxCollectionPluginAlbumsImplementationUid:
+ {
+ isContent = EFalse;
+ objectDef = &DataSource()->AlbumDef();
+ break;
+ }
+ case KGlxCollectionPluginCameraImplementationUid:
+ {
+ container = DataSource()->CameraAlbumId();
+ objectDef = &DataSource()->AlbumDef();
+ break;
+ }
+ case KGlxTagCollectionPluginImplementationUid:
+ {
+ isContent = EFalse;
+ objectDef = &DataSource()->TagDef();
+ break;
+ }
+ case KGlxCollectionPluginMonthsImplementationUid:
+ {
+ container = DataSource()->CameraAlbumId();
+ objectDef = &DataSource()->AlbumDef();
+ break;
+ }
+ default:
+ {
+ // default gallery query returns all objects as per filter
+ break;
+ }
+ }
+ QueueObjectQueryL(*objectDef, isContent, EAttributeQuery, EQueryResultModeCount, container, request->Attributes()[i], aEntry, filterProperties);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaColDetailSpaceId )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaColDetailSpaceId, KGlxDataSourceMdeImplementationUid);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaCollectionInternalStartDate )
+ {
+ TGlxFilterProperties filterProperties = iFilterProperties;
+ filterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;
+ filterProperties.iSortDirection = EGlxFilterSortDirectionAscending;
+
+ QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery, EQueryResultModeObjectWithoutFreetexts, DataSource()->CameraAlbumId(), KGlxMediaCollectionInternalStartDate, aEntry, filterProperties);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaCollectionInternalEndDate )
+ {
+ // not necessary to be requested, returned when StartDate requested
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralSlideshowableContent )
+ {
+ aEntry->SetTObjectValueL(KGlxMediaGeneralSlideshowableContent, 0);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaDrmProtected )
+ {
+ // collection itself is not protected
+ aEntry->SetTObjectValueL(KMPXMediaDrmProtected, EFalse);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+ }
+
+
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::AddContainerAttributesL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::AddContainerAttributesL(CMPXMedia* aEntry, CMdEObject* aContainer, CGlxDataSource::TContainerType aType)
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::AddContainerAttributesL()");
+ __ASSERT_DEBUG(aEntry, Panic(EGlxPanicLogicError));
+ __ASSERT_DEBUG(aContainer, Panic(EGlxPanicLogicError));
+ __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));
+ CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);
+
+ /// @todo check property defs are valid and type is correct
+ for ( TInt i = 0; i < request->Attributes().Count(); i++ )
+ {
+ if ( request->Attributes()[i] == KMPXMediaGeneralId )
+ {
+ aEntry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, (TMPXItemId)aContainer->Id());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralType )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralType, EMPXGroup);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralCategory )
+ {
+ if( CGlxDataSource::EContainerTypeAlbum == aType)
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXAlbum);
+ }
+ else if( CGlxDataSource::EContainerTypeTag == aType)
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXTag);
+ }
+ else if( CGlxDataSource::EContainerTypeMonth == aType)
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXMonth);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralUri )
+ {
+ aEntry->SetTextValueL(KMPXMediaGeneralUri, aContainer->Uri());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralTitle )
+ {
+ CMdEProperty* title;
+ CMdEPropertyDef* titleProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameTitle);
+ TInt titleIndex = aContainer->Property(*titleProperty, title);
+ if(titleIndex == KErrNotFound)
+ {
+ TParsePtrC parser(aContainer->Uri());
+ aEntry->SetTextValueL(KMPXMediaGeneralTitle, parser.Name());
+ }
+ else
+ {
+ aEntry->SetTextValueL(KMPXMediaGeneralTitle, static_cast<CMdETextProperty*>(title)->Value());
+ }
+ switch (aType)
+ {
+ case CGlxDataSource::EContainerTypeAlbum:
+ {
+ CMdEProperty* albumType;
+ CMdEPropertyDef* albumTypeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameAlbumType);
+ TInt albumTypeIndex = aContainer->Property(*albumTypeProperty, albumType);
+ if( KErrNotFound != albumTypeIndex )
+ {
+ TUint16 albumTypeValue = static_cast<CMdEUint16Property*>(albumType)->Value();
+ if ( albumTypeValue != MdeConstants::Album::EAlbumUser )
+ {
+ request->AppendCpiAttributeL(KMPXMediaGeneralTitle);
+ aEntry->SetTObjectValueL(KGlxMediaCollectionInternalSystemItemType, albumTypeValue);
+ }
+ }
+ break;
+ }
+ case CGlxDataSource::EContainerTypeTag:
+ {
+ break;
+ }
+ case CGlxDataSource::EContainerTypeMonth:
+ {
+ request->AppendCpiAttributeL(KMPXMediaGeneralTitle);
+ CMdEProperty* time;
+ CMdEPropertyDef* timeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameCreationDate);
+ TInt timeIndex = aContainer->Property(*timeProperty, time);
+ if( KErrNotFound == timeIndex )
+ {
+ User::Leave(KErrCorrupt);
+ }
+
+ aEntry->SetTObjectValueL(KGlxMediaCollectionInternalStartDate, static_cast<CMdETimeProperty*>(time)->Value());
+ break;
+ }
+ }
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralDate )
+ {
+ CMdEProperty* time;
+ CMdEPropertyDef* timeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameCreationDate);
+ TInt timeIndex = aContainer->Property(*timeProperty, time);
+ if( KErrNotFound == timeIndex )
+ {
+ User::Leave(KErrCorrupt);
+ }
+
+ aEntry->SetTObjectValueL(KMPXMediaGeneralDate, static_cast<CMdETimeProperty*>(time)->Value());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralSize )
+ {
+ CMdEProperty* size;
+ CMdEPropertyDef* sizeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameSize);
+ TInt sizeIndex = aContainer->Property(*sizeProperty, size);
+ TInt sizeValue;
+ if(sizeIndex == KErrNotFound)
+ {
+ sizeValue = 0;
+ }
+ else
+ {
+ sizeValue = static_cast<CMdEInt32Property*>(size)->Value();
+ }
+ aEntry->SetTObjectValueL(KMPXMediaGeneralSize, sizeValue);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralDrive )
+ {
+ TParsePtrC parser(aContainer->Uri());
+ aEntry->SetTextValueL(KMPXMediaGeneralDrive, parser.Drive());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralMimeType )
+ {
+ CMdEProperty* mimeType;
+ CMdEPropertyDef* mimeTypeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameItemType);
+ TInt mimeTypeIndex = aContainer->Property(*mimeTypeProperty, mimeType);
+ if( KErrNotFound == mimeTypeIndex)
+ {
+ aEntry->SetTextValueL(KMPXMediaGeneralMimeType, KNullDesC);
+ }
+ else
+ {
+ aEntry->SetTextValueL(KMPXMediaGeneralMimeType, static_cast<CMdETextProperty*>(mimeType)->Value());
+ }
+ }
+ else if ( ( request->Attributes()[i] == KMPXMediaGeneralCount ) || ( request->Attributes()[i] == KGlxMediaCollectionInternalUsageCount ) )
+ {
+ switch (aType)
+ {
+ case CGlxDataSource::EContainerTypeAlbum:
+ case CGlxDataSource::EContainerTypeTag:
+ {
+ CMdEProperty* countType;
+ CMdEPropertyDef* countTypeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameUsageCount);
+ TInt countTypeIndex = aContainer->Property(*countTypeProperty, countType);
+ if( KErrNotFound != countTypeIndex )
+ {
+ TUint count = static_cast<CMdEUint32Property*>(countType)->Value();
+ aEntry->SetTObjectValueL(request->Attributes()[i], count);
+ }
+ else
+ {
+ aEntry->SetTObjectValueL(request->Attributes()[i], 0);
+ }
+ break;
+ }
+ case CGlxDataSource::EContainerTypeMonth:
+ {
+ TGlxFilterProperties filterProperties = iFilterProperties;
+ AddMonthFilterL(aContainer, filterProperties);
+ QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery, EQueryResultModeCount, DataSource()->CameraAlbumId(), request->Attributes()[i], aEntry, filterProperties);
+ break;
+ }
+ }
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralSystemItem )
+ {
+ TBool systemItem = EFalse;
+ switch (aType)
+ {
+ case CGlxDataSource::EContainerTypeAlbum:
+ {
+ CMdEProperty* albumType;
+ CMdEPropertyDef* albumTypeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameAlbumType);
+ TInt albumTypeIndex = aContainer->Property(*albumTypeProperty, albumType);
+ if( KErrNotFound != albumTypeIndex )
+ {
+ TInt albumTypeValue = static_cast<CMdEUint16Property*>(albumType)->Value();
+ if( (albumTypeValue == MdeConstants::Album::EAlbumSystemCamera) || (albumTypeValue == MdeConstants::Album::EAlbumSystemFavourite ) )
+ {
+ systemItem = ETrue;
+ }
+ }
+ break;
+ }
+ case CGlxDataSource::EContainerTypeTag:
+ {
+ systemItem = EFalse;
+ break;
+ }
+ case CGlxDataSource::EContainerTypeMonth:
+ {
+ systemItem = ETrue;
+ break;
+ }
+ }
+ aEntry->SetTObjectValueL(KGlxMediaGeneralSystemItem, systemItem);
+ }
+
+ //Attributes to get the Count of Images in Container
+ else if ( request->Attributes()[i] == KGlxMediaItemTypeImage )
+ {
+ switch (aType)
+ {
+ case CGlxDataSource::EContainerTypeMonth:
+ {
+ TGlxFilterProperties filterProperties = iFilterProperties;
+ AddMonthFilterL(aContainer, filterProperties);
+ filterProperties.iItemType = EGlxFilterImage;
+ QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery, EQueryResultModeCount, DataSource()->CameraAlbumId(), request->Attributes()[i], aEntry, filterProperties);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ // Attributes to get the Count of Videos in Container
+
+ else if ( request->Attributes()[i] == KGlxMediaItemTypeVideo )
+ {
+ switch (aType)
+ {
+ case CGlxDataSource::EContainerTypeMonth:
+ {
+ TGlxFilterProperties filterProperties = iFilterProperties;
+ AddMonthFilterL(aContainer, filterProperties);
+ filterProperties.iItemType = EGlxFilterVideo;
+ QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery, EQueryResultModeCount, DataSource()->CameraAlbumId(), request->Attributes()[i], aEntry, filterProperties);
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+
+ else if ( request->Attributes()[i] == KMPXMediaColDetailSpaceId )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaColDetailSpaceId, KGlxDataSourceMdeImplementationUid);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaCollectionInternalStartDate )
+ {
+ // nothing returned for container but is valid for CPI to request
+ }
+ else if ( request->Attributes()[i] == KGlxMediaCollectionInternalEndDate )
+ {
+ // nothing returned for container but is valid for CPI to request
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralDimensions )
+ {
+ // return zero size for container (thumbnail only used in preview list)
+ aEntry->SetTObjectValueL(KGlxMediaGeneralDimensions, TSize(0,0));
+ }
+ else if ( request->Attributes()[i] == KMPXMediaDrmProtected )
+ {
+ // container itself is not protected
+ aEntry->SetTObjectValueL(KMPXMediaDrmProtected, EFalse);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralFramecount )
+ {
+ aEntry->SetTObjectValueL(KGlxMediaGeneralFramecount, 1);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralSlideshowableContent )
+ {
+ TGlxFilterProperties filterProperties = iFilterProperties;
+ filterProperties.iItemType = EGlxFilterImage;
+ filterProperties.iNoDRM = ETrue;
+ filterProperties.iExcludeAnimation = ETrue;
+ switch (aType)
+ {
+ case CGlxDataSource::EContainerTypeAlbum:
+ case CGlxDataSource::EContainerTypeTag:
+ {
+ QueueObjectQueryL(aContainer->Def(), ETrue, EAttributeQuery, EQueryResultModeCount, TGlxMediaId(aContainer->Id()), request->Attributes()[i], aEntry, filterProperties);
+ break;
+ }
+ case CGlxDataSource::EContainerTypeMonth:
+ {
+ AddMonthFilterL(aContainer, filterProperties);
+ QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery, EQueryResultModeCount, DataSource()->CameraAlbumId(), request->Attributes()[i], aEntry, filterProperties);
+ break;
+ }
+ }
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralLastModifiedDate )
+ {
+ CMdEProperty* time;
+ CMdEPropertyDef* timeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameLastModifiedDate);
+ TInt timeIndex = aContainer->Property(*timeProperty, time);
+ if( KErrNotFound == timeIndex)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ aEntry->SetTObjectValueL(KGlxMediaGeneralLastModifiedDate, static_cast<CMdETimeProperty*>(time)->Value());
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralDimensions )
+ {
+ TSize dimensions(0,0);
+
+ aEntry->SetTObjectValueL(KGlxMediaGeneralDimensions, dimensions);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::AddItemAttributesL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::AddItemAttributesL(CMPXMedia* aEntry, CMdEObject* aItem, CGlxDataSource::TItemType aType)
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::AddItemAttributesL(CMPXMedia* aEntry, CMdEObject* aItem, CGlxDataSource::TItemType aType)");
+ __ASSERT_DEBUG(aEntry, Panic(EGlxPanicLogicError));
+ __ASSERT_DEBUG(aItem, Panic(EGlxPanicLogicError));
+ __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));
+ CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);
+
+ /// @todo check property defs are valid and type is correct
+ for ( TInt i = 0; i < request->Attributes().Count(); i++ )
+ {
+ if ( request->Attributes()[i] == KMPXMediaGeneralId )
+ {
+ aEntry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, (TMPXItemId)aItem->Id());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralType )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralType, EMPXItem);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralCategory )
+ {
+ if( CGlxDataSource::EItemTypeImage == aType)
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXImage);
+ }
+ else if( CGlxDataSource::EItemTypeVideo == aType)
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXVideo);
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralUri )
+ {
+ aEntry->SetTextValueL(KMPXMediaGeneralUri, aItem->Uri());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralTitle )
+ {
+ CMdEProperty* title;
+ CMdEPropertyDef* titleProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameTitle);
+ TInt titleIndex = aItem->Property(*titleProperty, title);
+ if( KErrNotFound == titleIndex )
+ {
+ TParsePtrC parser(aItem->Uri());
+ aEntry->SetTextValueL(KMPXMediaGeneralTitle, parser.Name());
+ }
+ else
+ {
+ aEntry->SetTextValueL(KMPXMediaGeneralTitle, static_cast<CMdETextProperty*>(title)->Value());
+ }
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralDate )
+ {
+ CMdEProperty* time;
+ CMdEPropertyDef* timeProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameCreationDate);
+ TInt timeIndex = aItem->Property(*timeProperty, time);
+ if( KErrNotFound == timeIndex)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ aEntry->SetTObjectValueL(KMPXMediaGeneralDate, static_cast<CMdETimeProperty*>(time)->Value());
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralLastModifiedDate )
+ {
+ CMdEProperty* time;
+ CMdEPropertyDef* timeProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameLastModifiedDate);
+ TInt timeIndex = aItem->Property(*timeProperty, time);
+ if( KErrNotFound == timeIndex)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ aEntry->SetTObjectValueL(KGlxMediaGeneralLastModifiedDate, static_cast<CMdETimeProperty*>(time)->Value());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralSize )
+ {
+ CMdEProperty* size;
+ CMdEPropertyDef* sizeProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameSize);
+ TInt sizeIndex = aItem->Property(*sizeProperty, size);
+ User::LeaveIfError(sizeIndex);
+
+ aEntry->SetTObjectValueL(KMPXMediaGeneralSize, static_cast<CMdEInt32Property*>(size)->Value());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralDrive )
+ {
+ TParsePtrC parser(aItem->Uri());
+ aEntry->SetTextValueL(KMPXMediaGeneralDrive, parser.Drive());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralMimeType )
+ {
+ CMdEProperty* mimeType;
+ CMdEPropertyDef* mimeTypeProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameItemType);
+ TInt mimeTypeIndex = aItem->Property(*mimeTypeProperty, mimeType);
+
+ User::LeaveIfError(mimeTypeIndex);
+ aEntry->SetTextValueL(KMPXMediaGeneralMimeType, static_cast<CMdETextProperty*>(mimeType)->Value());
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralDuration )
+ {
+ if( CGlxDataSource::EItemTypeImage == aType )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralDuration, 0);
+ }
+ else
+ {
+ CMdEProperty* duration;
+ CMdEPropertyDef* durationProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameDuration);
+ TInt durationIndex = aItem->Property(*durationProperty, duration);
+ User::LeaveIfError(durationIndex);
+
+ aEntry->SetTObjectValueL(KMPXMediaGeneralDuration, static_cast<CMdEUint32Property*>(duration)->Value());
+ }
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralSystemItem)
+ {
+ aEntry->SetTObjectValueL(KGlxMediaGeneralSystemItem, EFalse);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralDimensions )
+ {
+ TSize dimensions(0,0);
+
+ CMdEProperty* xDim;
+ CMdEPropertyDef* xDimProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameWidth);
+ TInt xDimIndex = aItem->Property(*xDimProperty, xDim);
+ if( KErrNotFound == xDimIndex )
+ {
+ //User::Leave(KErrCorrupt);
+ }
+ else
+ {
+ dimensions.iWidth = static_cast<CMdEUint16Property*>(xDim)->Value();
+ }
+
+ CMdEProperty* yDim;
+ CMdEPropertyDef* yDimProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameHeight);
+ TInt yDimIndex = aItem->Property(*yDimProperty, yDim);
+ if( KErrNotFound == yDimIndex )
+ {
+ //User::Leave(KErrCorrupt);
+ }
+ else
+ {
+ dimensions.iHeight = static_cast<CMdEUint16Property*>(yDim)->Value();
+ }
+ if ( ( dimensions.iWidth == 0 ) || ( dimensions.iHeight == 0 ) )
+ {
+ if( CGlxDataSource::EItemTypeImage == aType)
+ {
+ // EXIF header is corrupt, must read size from file.
+ CImageDecoder* decoder = NULL;
+
+ TRAPD(err, decoder = CImageDecoder::FileNewL( DataSource()->FileServerSession(), aItem->Uri(), CImageDecoder::EOptionNone ));
+ if (err == KErrNone)
+ {
+ dimensions = decoder->FrameInfo().iOverallSizeInPixels;
+ }
+ delete decoder;
+ }
+ }
+
+ aEntry->SetTObjectValueL(KGlxMediaGeneralDimensions, dimensions);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralFramecount )
+ {
+ CMdEProperty* framecount;
+ TInt fcount = 1;
+ CMdEPropertyDef* framecountProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameFrameCount);
+ if( framecountProperty )
+ {
+ TInt framecountIndex = aItem->Property(*framecountProperty, framecount);
+ if( KErrNotFound != framecountIndex )
+ {
+ fcount = static_cast<CMdEUint32Property*>(framecount)->Value();
+ }
+ }
+ aEntry->SetTObjectValueL(KGlxMediaGeneralFramecount, fcount);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralComment )
+ {
+ CMdEProperty* comment;
+ CMdEPropertyDef* commentProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameComment); /// @todo using Exif Comment field for comment as spec is not clear
+ TInt commentIndex = aItem->Property(*commentProperty, comment);
+ if( KErrNotFound == commentIndex)
+ {
+ aEntry->SetTextValueL(KMPXMediaGeneralComment, KNullDesC);
+ }
+ else
+ {
+ aEntry->SetTextValueL(KMPXMediaGeneralComment, static_cast<CMdETextProperty*>(comment)->Value());
+ }
+ }
+ else if ( request->Attributes()[i] == KMPXMediaDrmProtected )
+ {
+ CMdEProperty* drmProtected;
+ CMdEPropertyDef* drmProtectedProperty = aItem->Def().GetPropertyDefL(KPropertyDefNameDRM);
+ TInt drmProtectedIndex = aItem->Property(*drmProtectedProperty, drmProtected);
+ if( KErrNotFound == drmProtectedIndex)
+ {
+ aEntry->SetTObjectValueL(KMPXMediaDrmProtected, EFalse);
+ }
+ else
+ {
+ aEntry->SetTObjectValueL(KMPXMediaDrmProtected, static_cast<CMdEBoolProperty*>(drmProtected)->Value());
+ }
+ }
+ else if ( request->Attributes()[i] == KMPXMediaGeneralCount )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaGeneralCount, 1);
+ }
+ else if ( request->Attributes()[i] == KMPXMediaColDetailSpaceId )
+ {
+ aEntry->SetTObjectValueL(KMPXMediaColDetailSpaceId, KGlxDataSourceMdeImplementationUid);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralSlideshowableContent )
+ {
+ aEntry->SetTObjectValueL(KGlxMediaGeneralSlideshowableContent, -1);
+ }
+ else if ( request->Attributes()[i] == KGlxMediaGeneralLocation)
+ {
+ // Set the attribute to a TCoordinate initialised to NaN.
+ aEntry->SetTObjectValueL(KGlxMediaGeneralLocation, TCoordinate());
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMde::AddLocationAttributeToMediaL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::AddLocationAttributeToMediaL(CMPXMedia& aMedia, const TItemId& aLocationId)
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::AddLocationAttributeToMediaL(CMPXMedia& aMedia, const TItemId& aLocationId)");
+ CMdEObject* location = DataSource()->Session().GetObjectL(aLocationId, DataSource()->LocationDef());
+ if(!location)
+ {
+ User::Leave(KErrNotFound);
+ }
+ CleanupStack::PushL(location);
+ CMdEProperty* longitude = NULL;
+ CMdEPropertyDef* longitudePropertyDef = location->Def().GetPropertyDefL(KPropertyDefNameLongitude);
+ TInt longitudeIndex = location->Property(*longitudePropertyDef, longitude);
+ CMdEProperty* latitude = NULL;
+ CMdEPropertyDef* latitudePropertyDef = location->Def().GetPropertyDefL(KPropertyDefNameLatitude);
+ TInt latitudeIndex = location->Property(*latitudePropertyDef, latitude);
+
+ if (longitudeIndex > KErrNotFound && latitudeIndex > KErrNotFound)
+ {
+ TCoordinate coordinate(static_cast< CMdEReal64Property *>(latitude)->Value(),static_cast< CMdEReal64Property *>(longitude)->Value());
+ aMedia.SetTObjectValueL(KGlxMediaGeneralLocation, coordinate);
+ }
+
+ CleanupStack::PopAndDestroy(location);
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::DoHandleAttributeQueryCompletedL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::DoHandleAttributeQueryCompletedL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoHandleAttributeQueryCompletedL()");
+ __ASSERT_DEBUG(iQueryAttributes.Count(), Panic(EGlxPanicIllegalState));
+ CMdEQuery* query = iQueries[0];
+
+ if( EQueryResultModeObjectWithoutFreetexts == query->ResultMode() )
+ {
+ __ASSERT_DEBUG(( iQueryAttributes[0].iAttribute == KGlxMediaCollectionInternalStartDate ), Panic(EGlxPanicIllegalState));
+ CMdEPropertyDef* creationDateDef = DataSource()->ObjectDef().GetPropertyDefL(KPropertyDefNameCreationDate);
+ if (!creationDateDef || creationDateDef->PropertyType() != EPropertyTime)
+ {
+ User::Leave(KErrCorrupt);
+ }
+ TTime startMonth(0);
+ TTime endMonth(0);
+ if(iQueries[0]->Count() )
+ {
+ CMdEProperty* startTime;
+ CMdEObject& startObject = (CMdEObject&)query->ResultItem(0);
+ TInt timeIndex = startObject.Property(*creationDateDef, startTime);
+ if( KErrNotFound == timeIndex )
+ {
+ User::Leave(KErrCorrupt);
+ }
+ startMonth = static_cast<CMdETimeProperty*>(startTime)->Value();
+ CMdEProperty* endTime;
+ CMdEObject& endObject = (CMdEObject&)query->ResultItem(query->Count()-1);
+ timeIndex = endObject.Property(*creationDateDef, endTime);
+ if( KErrNotFound == timeIndex )
+ {
+ User::Leave(KErrCorrupt);
+ }
+ endMonth = static_cast<CMdETimeProperty*>(endTime)->Value();
+ }
+ iQueryAttributes[0].iMedia->SetTObjectValueL(KGlxMediaCollectionInternalStartDate, startMonth);
+ iQueryAttributes[0].iMedia->SetTObjectValueL(KGlxMediaCollectionInternalEndDate, endMonth);
+ }
+ else if( EQueryResultModeCount == query->ResultMode() )
+ {
+ iQueryAttributes[0].iMedia->SetTObjectValueL(iQueryAttributes[0].iAttribute, query->Count());
+ }
+ else
+ {
+ Panic(EGlxPanicIllegalState);
+ }
+ iQueryAttributes.Remove(0);
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMde::DoHandleLocationQueryCompletedL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::DoHandleLocationQueryCompletedL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoHandleLocationQueryCompletedL()");
+ TInt queryResultsCount = iQueries[0]->Count();
+
+ for (TInt queryResultsPos = 0; queryResultsPos < queryResultsCount; queryResultsPos++)
+ {
+ CMdERelation& relation = static_cast<CMdERelation&>(iQueries[0]->ResultItem(queryResultsPos));
+ CMPXMedia* targetMedia = NULL;
+ if (iMediaArray)
+ {
+ TInt mediaArrayCount = iMediaArray->Count();
+ for (TInt mediaArrayPos = 0; mediaArrayPos < mediaArrayCount; mediaArrayPos++)
+ {
+ CMPXMedia* media = (*iMediaArray)[mediaArrayPos];
+ TMPXItemId id = media->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
+ if (id.iId1 == relation.LeftObjectId())
+ {
+ targetMedia = media;
+ break;
+ }
+ }
+ }
+ else
+ {
+ targetMedia = iResponse;
+#ifdef _DEBUG
+ TMPXItemId id = targetMedia->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
+ __ASSERT_DEBUG(id.iId1 == relation.LeftObjectId(), Panic(EGlxPanicLogicError));
+#endif
+ }
+
+ __ASSERT_DEBUG(targetMedia, Panic(EGlxPanicLogicError));
+ AddLocationAttributeToMediaL(*targetMedia, relation.RightObjectId());
+
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::DoHandleImageVideoQueryCompletedL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::DoHandleImageVideoQueryCompletedL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoHandleImageVideoQueryCompletedL()");
+ CMdEQuery* query = iQueries[0];
+
+ TInt queryResultsCount = query->Count();
+
+ if( ( queryResultsCount == 1 ) && ( !iMediaArray ) )
+ {
+ CMdEObject& object = static_cast<CMdEObject&>(query->ResultItem(0));
+
+ delete iResponse;
+ // setiing iResponse to NULL to remove CodeScanner warning
+ iResponse = NULL;
+ iResponse = CMPXMedia::NewL();
+ AddAttributesL(object, iResponse);
+ }
+ else
+ {
+ for (TInt i = 0; i < queryResultsCount; i++)
+ {
+ CMdEObject& object = static_cast<CMdEObject&>(query->ResultItem(i));
+
+ CMPXMedia* entry = CMPXMedia::NewL();
+ CleanupStack::PushL(entry);
+ iMediaArray->AppendL(entry);
+ CleanupStack::Pop(entry);
+ AddAttributesL(object, (*iMediaArray)[iMediaArray->Count() - 1]);
+ }
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::QueueLocaitonQueryL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::QueueLocaitonQueryL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::QueueLocaitonQueryL()");
+ __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));
+ CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);
+
+ CMdEQuery* query = DataSource()->Session().NewRelationQueryL(*DataSource()->NamespaceDef(), this);
+ CleanupStack::PushL(query);
+
+ CMdELogicCondition& rootCondition = query->Conditions();
+ CMdERelationCondition& containerRelationCondition = rootCondition.AddRelationConditionL(DataSource()->ContainsDef(), ERelationConditionSideRight);
+ CMdELogicCondition& itemLogicCondition = containerRelationCondition.LeftL();
+ CMdELogicCondition& locationLogicCondition = containerRelationCondition.RightL();
+ locationLogicCondition.AddObjectConditionL(DataSource()->LocationDef());
+ locationLogicCondition.SetOperator(ELogicConditionOperatorOr);
+ itemLogicCondition.SetOperator(ELogicConditionOperatorOr);
+
+ TInt mediaIdCount = request->MediaIds().Count();
+
+ RArray<TItemId> mediaIdArray;
+ CleanupClosePushL(mediaIdArray);
+
+ for (TInt i = 0; i < mediaIdCount; i++)
+ {
+ mediaIdArray.AppendL(request->MediaIds()[i].Value());
+ }
+
+ itemLogicCondition.AddObjectConditionL(mediaIdArray);
+ CleanupStack::PopAndDestroy(&mediaIdArray);
+
+ query->SetResultMode(EQueryResultModeItem);
+
+ CleanupStack::Pop(query);
+ AppendQueryL(query, ELocationAttributeQuery);
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTask::ExecuteQueryL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::ExecuteQueryL()
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::ExecuteQueryL()");
+ switch (iQueryTypes[0])
+ {
+ case EAttributeQuery:
+ {
+ iQueries[0]->FindL(MaxQueryResultsCount(iQueryAttributes[0].iFilterProperties));
+ }
+ break;
+ case EImageVideoQuery: // fall through
+ case ELocationAttributeQuery:
+ {
+ iQueries[0]->FindL();
+ }
+ break;
+ default:
+ {
+ Panic(EGlxPanicUnsupportedQueryType);
+ }
+ break;
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTaskMdeAttribute::LocationAttributeRequested
+// ----------------------------------------------------------------------------
+//
+TBool CGlxDataSourceTaskMdeAttribute::LocationAttributeRequested()
+ {
+ GLX_LOG_ENTRY_EXIT("TBool CGlxDataSourceTaskMdeAttribute::LocationAttributeRequested()");
+ __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));
+ CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);
+
+ TInt attributeArrayCount = request->Attributes().Count();
+ for (TInt i = 0; i < attributeArrayCount; i++)
+ {
+ if (request->Attributes()[i] == KGlxMediaGeneralLocation)
+ {
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CGlxDataSourceTask::QueueObjectQueryL
+// ----------------------------------------------------------------------------
+//
+void CGlxDataSourceTaskMdeAttribute::QueueObjectQueryL(CMdEObjectDef& aObjectDef, TBool aIsContent, TGlxQueryType aQueryType,
+ TQueryResultMode aResultMode, const TGlxMediaId& aContainerId, TMPXAttribute aAttribute, CMPXMedia* aEntry,
+ const TGlxFilterProperties& aFilterProperties)
+ {
+ GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::QueueObjectQueryL()");
+ CMdEObjectDef* queryBaseObject = &aObjectDef;
+ if( aIsContent )
+ {
+ switch(aFilterProperties.iItemType)
+ {
+ case EGlxFilterImage:
+ {
+ queryBaseObject = &DataSource()->ImageDef();
+ break;
+ }
+ case EGlxFilterVideo:
+ {
+ queryBaseObject = &DataSource()->VideoDef();
+ break;
+ }
+ default:
+ {
+ queryBaseObject = &DataSource()->ObjectDef();
+ break;
+ }
+ }
+ }
+
+ CMdEQuery* query = DataSource()->Session().NewObjectQueryL(*DataSource()->NamespaceDef(), *queryBaseObject, this);
+ CleanupStack::PushL(query);
+ SetQueryConditionsL(*query, aFilterProperties, aContainerId, aObjectDef);
+ query->SetResultMode(aResultMode);
+
+ iQueryAttributes.AppendL(TGlxQueryAttribute(aAttribute, aEntry, aFilterProperties));
+
+ CleanupStack::Pop(query);
+
+ TRAPD(err, AppendQueryL(query,aQueryType));
+
+ if (err != KErrNone)
+ {
+ iQueryAttributes.Remove(iQueryAttributes.Count() - 1);
+ }
+ }