/*

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

*

*/

/**

 * @internal reviewed 11/07/2007 by M Byrne

 * @internal reviewed 24/07/2007 by K Hoikka, SCO 403-8472 removal of all view

 */

#include "glxdatasourcetaskmds.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 <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 "glxdatasourcemds.h"

#include "glxdatasourcemds.hrh"

#include "glxdatasourcemdsutility.h"

// CONSTANTS

_LIT(KPropertyDefNameCreationDate, "CreationDate");

_LIT(KPropertyDefNameLastModifiedDate, "LastModifiedDate");

_LIT(KPropertyDefNameTitle, "Title");

_LIT(KPropertyDefNameFrameCount, "FrameCount");

_LIT(KPropertyDefNameOrigin, "Origin");

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

//  Constructor

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

//  

CGlxDataSourceTaskMde:: CGlxDataSourceTaskMde(CGlxRequest* aRequest, 

        MGlxDataSourceRequestObserver& aObserver, CGlxDataSource* aDataSource)

    : CGlxDataSourceTask(aRequest, aObserver, aDataSource)

    {

    // No implementation required

    }

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

//  Destructor

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

//  

CGlxDataSourceTaskMde::~CGlxDataSourceTaskMde()

    {

    DestroyQueries();

    }

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

//  Second stage constructor

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

//  	

void CGlxDataSourceTaskMde::ConstructL()

    {

    CreateResponseL();

#ifdef USE_S60_TNM

    DataSource()->CancelFetchThumbnail();

#else    

    DataSource()->ThumbnailCreator().CancelRequest( TGlxMediaId(0) );

#endif

    }

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

//  CGlxDataSourceTaskMde::CancelRequest

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

//  

void CGlxDataSourceTaskMde::CancelRequest()

    {

    iCancelled = ETrue;

    }

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

//  CGlxDataSourceTaskMde::HandleQueryNewResults

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

//      

void CGlxDataSourceTaskMde::HandleQueryNewResults( CMdEQuery& /*aQuery*/,

                                                     TInt /*aFirstNewItemIndex*/,

                                                     TInt /*aNewItemCount*/ )

    {

    // Not used.

    }

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

//  CGlxDataSourceTaskMde::HandleQueryNewResults

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

//    

void CGlxDataSourceTaskMde::HandleQueryNewResults( CMdEQuery& /*aQuery*/,

                                TInt /*aNewObjectItemCount*/,

                                TInt /*aNewRelationItemCount*/,

                                TInt /*aNewEventItemCount*/)

    {

    // Not used.

    }

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

// CGlxDataSourceTaskMde::HandleQueryCompleted

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

//

void CGlxDataSourceTaskMde::HandleQueryCompleted(CMdEQuery& aQuery, TInt aError)

    {

    __ASSERT_ALWAYS(&aQuery == iQueries[0], Panic(EGlxPanicQueryLogicError));

    TInt err = aError;

    if (err == KErrNone)

        {

        TRAP(err, HandleQueryCompletedL(aQuery));

        }

        {

        HandleRequestComplete(err);

        }

    }

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

//  CGlxDataSourceTaskMde::DataSource

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

//   

CGlxDataSourceMde* CGlxDataSourceTaskMde::DataSource()

    {

    return static_cast<CGlxDataSourceMde*>(iDataSource);

    }

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

//  CGlxDataSourceTaskMde::AddMonthFilterL

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

//     

    {

    CMdEObject* month = DataSource()->Session().GetObjectL(aContainerId.Value());

    if( !month )

        {

        User::Leave(KErrNotFound);

        }

    CleanupStack::PushL(month);

    AddMonthFilterL(month, aFilterProperties);

    CleanupStack::PopAndDestroy(month);

    }

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

//  CGlxDataSourceTaskMde::AddMonthFilterL

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

//   

    {

    if (creationDateDef.PropertyType() != EPropertyTime)

        {

        User::Leave(KErrCorrupt);

        }

    if (lmDateDef.PropertyType() != EPropertyTime)

        {

        User::Leave(KErrCorrupt);

        }

    CMdEProperty* startDate;

    TInt startDateIndex = aMonth->Property(creationDateDef, startDate);

    if( KErrNotFound == startDateIndex) 

        {

        User::Leave(KErrCorrupt);

        }

    aFilterProperties.iStartDate = static_cast<CMdETimeProperty*>(startDate)->Value();

    CMdEProperty* endDate;

    TInt endDateIndex = aMonth->Property(lmDateDef, endDate);

    if( KErrNotFound == endDateIndex) 

        {

        User::Leave(KErrCorrupt);

        }

    aFilterProperties.iEndDate = static_cast<CMdETimeProperty*>(endDate)->Value();

    }

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

//  CGlxDataSourceTaskMde::SetQueryConditionsL

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

//    

    {

    CMdELogicCondition& rootCondition = aQuery.Conditions();

    CMdEObjectDef* objectDef = &aObjectDef;

    SetQueryFilterConditionsL(rootCondition, *objectDef, aFilterProperties);

    if( KGlxCollectionRootId != aContainerId.Value() )

        {

        CMdELogicCondition* containerCondition = NULL;

        CMdERelationCondition* relationCondition = NULL;

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

        if( DataSource()->ContainerIsLeft(aObjectDef) )

            {

            containerCondition = &relationCondition->LeftL();

            }

        else

            {

            containerCondition = &relationCondition->RightL();

            }

        containerCondition->AddObjectConditionL(aContainerId.Value());

        }

    }

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

//  CGlxDataSourceTaskMde::SetQueryFilterConditionsL

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

//  

void CGlxDataSourceTaskMde::SetQueryFilterConditionsL(CMdELogicCondition& 

                                   aLogicCondition, CMdEObjectDef& aObjectDef,

                                 const TGlxFilterProperties& aFilterProperties)

    {

    if( aFilterProperties.iUri )

        {

        aLogicCondition.AddObjectConditionL(EObjectConditionCompareUri, 

                                                     *aFilterProperties.iUri);

        }

    if( 0 == aObjectDef.Compare(DataSource()->ObjectDef()) ) 

        {

        // Filter on content type

        if ( EGlxFilterVideoAndImages == aFilterProperties.iItemType )

            {

            CMdELogicCondition& logicCondition = 

                aLogicCondition.AddLogicConditionL(ELogicConditionOperatorOr);

            logicCondition.AddObjectConditionL( DataSource()->ImageDef() ); 

            logicCondition.AddObjectConditionL( DataSource()->VideoDef() );

            }

        }

        {        

		aLogicCondition.AddObjectConditionL(range);

        }

    if( 0 != aFilterProperties.iContainsItem.Value() )

        {

        if( DataSource()->ContainerIsLeft(aObjectDef) )

            {

            CMdERelationCondition& relationCondition = 

            }

        else

            {

            relationCondition.LeftL().AddObjectConditionL(aFilterProperties.iContainsItem.Value());

            }

        }

    if( EGlxFilterOriginNotUsed != aFilterProperties.iOrigin )

        {

        CMdEPropertyDef& originProperty = aObjectDef.GetPropertyDefL(KPropertyDefNameOrigin);

        if( EGlxFilterOriginDownload == aFilterProperties.iOrigin )

            {

            // The download collection shows all but captured items

            }

		else if(EGlxFilterOriginCamera == aFilterProperties.iOrigin )            

			{

			// The camera collection Shows the captured Items

			}

        }

    if( aFilterProperties.iExcludeAnimation )

        {

        // Exclude any image with a frame count > 1

        const TInt excludeAllImagesAboveOrEqualToThisFrameCount = 2;

        }

    if( aFilterProperties.iNoDRM )

        {

        }

    if( aFilterProperties.iPath )          // If this is set. Then we need to filter on the Ids it supplies

        {

        TArray<TInt> selection = aFilterProperties.iPath->Selection();

        TInt selectionCount = selection.Count();

        RArray<TItemId> itemList;

        CleanupClosePushL(itemList);

        GLX_DEBUG2("Reading Ids from Path, count = %d", selectionCount);

        if( selectionCount )

            {

            for( TInt i = 0; i < selectionCount; i++ )

                {

                const TMPXItemId& itemId = aFilterProperties.iPath->IdOfIndex(selection[i]);

                itemList.AppendL(itemId);

                }

            aLogicCondition.AddObjectConditionL(itemList);

            }

        CleanupStack::Pop(&itemList);

        }

    if( !aFilterProperties.iIncludeCameraAlbum )

        {

        objectCondition.SetNegate(ETrue);

        }

    if( TTime(0) != aFilterProperties.iStartDate )

        {

        if (creationDateDef.PropertyType() != EPropertyTime)

            {

            User::Leave(KErrCorrupt);

            }

        }

    }

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

//  CGlxDataSourceTaskMde::SetSortOrderL

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

// 

void CGlxDataSourceTaskMde::SetSortOrderL(CMdEQuery& aQuery, CMdEObjectDef& aObjectDef, 

                                         const TGlxFilterProperties& aFilterProperties)

    {

    switch(aFilterProperties.iSortOrder)

        {

        case EGlxFilterSortOrderAlphabetical:

            {

            CMdEPropertyDef& titleProperty = aObjectDef.GetPropertyDefL(KPropertyDefNameTitle);

            orderRule.SetType(EOrderRuleTypeProperty);

            orderRule.SetCaseSensitive(EFalse);

            aQuery.AppendOrderRuleL(orderRule);

            break;

            }

         case EGlxFilterSortOrderItemCount:

            {            

            aQuery.AppendOrderRuleL(orderRule);            

            break;

            }

        case EGlxFilterSortOrderCaptureDate:

            {

            orderRule.SetType(EOrderRuleTypeProperty);

            aQuery.AppendOrderRuleL(orderRule);

            aQuery.AppendOrderRuleL(orderRule2);

            break;

            }

         case EGlxFilterSortOrderModifiedDate:

            {

            orderRule.SetType(EOrderRuleTypeProperty);

            aQuery.AppendOrderRuleL(orderRule);

            aQuery.AppendOrderRuleL(orderRule2);

            break;

            }

        case EGlxFilterSortOrderNotUsed:

            {

            break;

            }

        }

    }

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

//  CGlxDataSourceTaskMde::MaxQueryResultsCount

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

// 

    {

    TInt ret = KMdEQueryDefaultMaxCount;

        {

        ret = 1;

        }

    return ret;

    }

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

//  CGlxDataSourceTaskMde::RemoveQuery

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

// 

void CGlxDataSourceTaskMde::RemoveQuery()

    {

    CMdEQuery* query = iQueries[0];

    iQueryTypes.Remove(0);

    iQueries.Remove(0);

    query->RemoveObserver(*this);

    delete query;

    }

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

//  CGlxDataSourceTaskMde::DoQueryL

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

// 	

void CGlxDataSourceTaskMde::DoQueryL(CMdEObjectDef& aObjectDef,