/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:    Data Source task MDS attribute Class

*

*/

#include "glxdatasourcetaskmdsattribute.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 <glxtracer.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 <imageconversion.h>

#include <caf/content.h>

#include "glxdatasourcemds.h"

#include "glxdatasourcemds.hrh"

#include "glxdatasourcemdsutility.h"

// CONSTANTS

_LIT(KPropertyDefNameAlbumType, "Type");

_LIT(KPropertyDefNameItemType, "ItemType");

_LIT(KPropertyDefNameCreationDate, "CreationDate");

_LIT(KPropertyDefNameLastModifiedDate, "LastModifiedDate");

_LIT(KPropertyDefNameSize, "Size");

_LIT(KPropertyDefNameTitle, "Title");

_LIT(KPropertyDefNameDuration, "Duration");

_LIT(KPropertyDefNameComment, "Comment");

_LIT(KPropertyDefNameWidth, "Width");

_LIT(KPropertyDefNameHeight, "Height");

_LIT(KPropertyDefNameDRM, "DRM");

_LIT(KPropertyDefNameFrameCount, "FrameCount");

_LIT(KPropertyDefNameLatitude, "Latitude");

_LIT(KPropertyDefNameLongitude, "Longitude");

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

//  Constructor

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

//  

CGlxDataSourceTaskMdeAttributeMde::CGlxDataSourceTaskMdeAttributeMde(

        CGlxGetRequest* aRequest,MGlxDataSourceRequestObserver& aObserver,

            CGlxDataSource* aDataSource)

    : CGlxDataSourceTaskMde(aRequest, aObserver, aDataSource)

    {

    TRACER("CGlxDataSourceTaskMdeAttribute::CGlxDataSourceTaskMdeAttribute()")

    iFilterProperties = TGlxFilterFactory::ExtractAttributes(iRequest->Filter());

    }

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

//  Destructor

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

//  

CGlxDataSourceTaskMdeAttributeMde::~CGlxDataSourceTaskMdeAttributeMde()

	{

    TRACER("CGlxDataSourceTaskMdeAttribute::~CGlxDataSourceTaskMdeAttribute()")

    delete iMediaArray;

    iQueryAttributes.Close();

	}

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

//  CGlxDataSourceTaskMdeAttribute::ExecuteRequestL

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

//      

void CGlxDataSourceTaskMdeAttributeMde::ExecuteRequestL()

    {

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

    	QueueImageVideoObjectQueriesL(request->MediaIds(), iFilterProperties);

    	QueueAlbumObjectQueryL(request->MediaIds());

        QueueTagObjectQueryL(request->MediaIds());

        QueueMonthObjectQueryL(request->MediaIds());

	    if (LocationAttributeRequested())

	        {

	        QueueLocaitonQueryL();

	        }

    	*/

        __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));

        CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);   

// Not used anywhere, commenting out this line to avoid BAD warning

//        const RArray<TItemId>& mediaIds = reinterpret_cast<const RArray<TItemId>&>(request->MediaIds());

        switch(iFilterProperties.iItemType)

            {

            case EGlxFilterVideoAndImages:

            case EGlxFilterImage:

            case EGlxFilterVideo:

                {

            	QueueImageVideoObjectQueriesL(request->MediaIds(), iFilterProperties);

        	    if (LocationAttributeRequested())

        	        {

        	        QueueLocaitonQueryL();

        	        }

                break;

                }

            case EGlxFilterAlbum:

                {

            	QueueAlbumObjectQueryL(request->MediaIds());

                break;

                }

            case EGlxFilterTag:

                {

                QueueTagObjectQueryL(request->MediaIds());

                break;

                }

            case EGlxFilterMonth:

                {

                QueueMonthObjectQueryL(request->MediaIds());

                break;

                }

            }

    	}

    DoNextQueryL();

    }

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

// CGlxDataSourceTaskMde::DoHandleQueryCompletedL

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

//

void CGlxDataSourceTaskMdeAttributeMde::DoHandleQueryCompletedL(CMdEQuery& /*aQuery*/)

    {

    TRACER("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 CGlxDataSourceTaskMdeAttributeMde::DoNextQueryL()

    {

    TRACER("CGlxDataSourceTaskMdeAttribute::DoNextQueryL()")

    if (iQueries.Count())

        {

        ExecuteQueryL();

        }

    else

    	{

    	DoHandleAttributeResponseCompleteL();

    	}

    }

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

//  CGlxDataSourceTaskMdeAttribute::DoHandleAttributeResponseCompleteL

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

//     

void CGlxDataSourceTaskMdeAttributeMde::DoHandleAttributeResponseCompleteL()

    {

    TRACER("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 CGlxDataSourceTaskMdeAttributeMde::AddAttributesL(CMdEObject& aObject, CMPXMedia* aEntry)

    {

    TRACER("CGlxDataSourceTaskMdeAttribute::AddAttributesL()")

    __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 CGlxDataSourceTaskMdeAttributeMde::AddCollectionAttributesL(CMPXMedia* aEntry)

    {

    TRACER("CGlxDataSourceTaskMdeAttribute::AddCollectionAttributesL()")

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

            }

        //Attributes to get the Count of Images in Collection                

        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:

					{   

#if 0 	/// AB camera album				     		

					container = DataSource()->CameraAlbumId();

					objectDef = &DataSource()->AlbumDef();

#endif					

					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 Collection                    	

         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:

					{   

#if 0 	/// AB camera album					     		

					container = DataSource()->CameraAlbumId();

					objectDef = &DataSource()->AlbumDef();

#endif					

					filterProperties.iItemType = EGlxFilterVideo;

					QueueObjectQueryL(*objectDef, isContent, EAttributeQuery, 

					        EQueryResultModeCount, container,

					        request->Attributes()[i],aEntry,  filterProperties);

					break;                    	

					}

				default:

					{

					break;	

					}

				}

			}

        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:

                    {

					filterProperties.iOrigin = EGlxFilterOriginCamera;

                    break;

                    }

                case KGlxTagCollectionPluginImplementationUid: 

                    {

                    isContent = EFalse;

                    objectDef = &DataSource()->TagDef();

                    break;

                    }

                case KGlxCollectionPluginMonthsImplementationUid:

                    {

					filterProperties.iOrigin = EGlxFilterOriginAll;

                    break;

                    }

              /*  case KGlxCollectionPluginDownloadsImplementationUid:

                    {

                    filterProperties.iOrigin = EGlxFilterOriginDownload;

                    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 )

            {

            TGlxMediaId container = TGlxMediaId(KGlxCollectionRootId);

            TGlxFilterProperties filterProperties = iFilterProperties;

            filterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;

            filterProperties.iSortDirection = EGlxFilterSortDirectionAscending;

            filterProperties.iOrigin = EGlxFilterOriginAll;

            QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery, 

                    EQueryResultModeItem, container, 

                    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 if ( request->Attributes()[i] == KGlxMediaGeneralDRMRightsValid )            	

        	{

        	aEntry->SetTObjectValueL(KGlxMediaGeneralDRMRightsValid, EGlxDrmRightsValid); 

            }

        else

            {

            User::Leave(KErrNotSupported);

            }

        }

    }

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

// CGlxDataSourceTaskMdeAttribute::AddContainerAttributesL

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

//

void CGlxDataSourceTaskMdeAttributeMde::AddContainerAttributesL(CMPXMedia* aEntry, 

        CMdEObject* aContainer, CGlxDataSource::TContainerType aType)

    {

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

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