diff -r f7f0874bfe7d -r 74c9f037fd5d engine/collectionframework/datasource/plugins/glxdatasourcemde/src/glxdatasourcetaskmdeattribute.cpp --- /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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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(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(iRequest), Panic(EGlxPanicLogicError)); + CGlxGetRequest* request = static_cast(iRequest); + + const RArray& mediaIds = reinterpret_cast&>(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(iRequest), Panic(EGlxPanicLogicError)); + CGlxGetRequest* request = static_cast(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(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(iRequest), Panic(EGlxPanicLogicError)); + CGlxGetRequest* request = static_cast(iRequest); + + for ( TInt i = 0; i < request->Attributes().Count(); i++ ) + { + if ( request->Attributes()[i] == KMPXMediaGeneralId ) + { + aEntry->SetTObjectValueL(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(iRequest), Panic(EGlxPanicLogicError)); + CGlxGetRequest* request = static_cast(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(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(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(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(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(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(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(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(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(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(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(iRequest), Panic(EGlxPanicLogicError)); + CGlxGetRequest* request = static_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(KMPXMediaGeneralId); + if (id.iId1 == relation.LeftObjectId()) + { + targetMedia = media; + break; + } + } + } + else + { + targetMedia = iResponse; +#ifdef _DEBUG + TMPXItemId id = targetMedia->ValueTObjectL(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(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(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(iRequest), Panic(EGlxPanicLogicError)); + CGlxGetRequest* request = static_cast(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 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(iRequest), Panic(EGlxPanicLogicError)); + CGlxGetRequest* request = static_cast(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); + } + }