/*

* 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:    Generic fetch context to retrieve attributes

*

*/

#include <AknUtils.h>

#include "glxattributecontext.h"

#include "mglxmedialist.h"

#include "glxerrormanager.h"

#include "glxtracer.h"

#include "glxlog.h"

#include "glxlistutils.h"

#include "glxthumbnailattributeinfo.h"

// Default granularity of items to request for

const TUint KGlxAttributeContextDefaultGranularity = 200;

const TInt KVisibleItemsCorrectionValue = 1;

const TInt KVisibleItemsModFactor = 2;

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

// Constructor

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

//

EXPORT_C CGlxAttributeContext::CGlxAttributeContext(MGlxMediaListIterator* aIterator) :

        iIterator(aIterator),

        iGranularity(KGlxAttributeContextDefaultGranularity)

    {

    TRACER("CGlxAttributeContext::Default Constructor");

    __ASSERT_DEBUG(aIterator, Panic(EGlxPanicNullPointer));

    }

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

// Destructor

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

//

EXPORT_C CGlxAttributeContext::~CGlxAttributeContext()

    {

    TRACER("CGlxAttributeContext:: Destructor");

    iAttributes.Close();

    }

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

// Adds an attribute to be retrieved for all items

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

//

EXPORT_C void CGlxAttributeContext::AddAttributeL(const TMPXAttribute& aAttribute)

    {

    TRACER("CGlxAttributeContext::AddAttributeL");

    // Check that the attribute is not added twice

    TIdentityRelation<TMPXAttribute> match (&TMPXAttribute::Match);

    TInt index = iAttributes.Find(aAttribute, match);

    // Add the attribute

    if (KErrNotFound == index) 

        {

        iAttributes.AppendL(aAttribute);

        }

    }

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

// Removes an attribute from the "retrieval instructions"

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

//

EXPORT_C void CGlxAttributeContext::RemoveAttribute(const TMPXAttribute& aAttribute)

    {

    TRACER("CGlxAttributeContext::RemoveAttribute");

    // Check that the attribute to be removed exists

    TIdentityRelation<TMPXAttribute> match (&TMPXAttribute::Match);

    TInt index = iAttributes.Find(aAttribute, match);

    // Remove the attribute

    if (KErrNotFound != index) 

        {

        iAttributes.Remove(index);

        }

    }

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

// CGlxDefaultAttributeContext::AttributeCount

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

//	

EXPORT_C TInt CGlxAttributeContext::AttributeCount()

	{

	TRACER("CGlxAttributeContext::AttributeCount");

	return iAttributes.Count();

	}

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

// Sets granularity of the item index array returned from AttributeRequestL

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

EXPORT_C void CGlxAttributeContext::SetGranularity(TUint aGranularity)

    {

    TRACER("CGlxAttributeContext::SetGranularity");

    iGranularity = aGranularity;

    }

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

// Get attributes request for an item

// From MGlxFetchContext

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

//

TInt CGlxAttributeContext::AttributeRequestL(const MGlxMediaList* aList, 

        RArray<TInt>& aItemIndices, RArray<TMPXAttribute>& aAttributes, 

        CMPXAttributeSpecs*& aDetailedSpecs) const

    {

    TRACER("CGlxAttributeContext::AttributeRequestL");

    TInt itemCount = aList->Count();

    if (0 == itemCount || !iIterator) 

        {

        return 0;

        }

    // Check through the items in the order defined by the iterator

    iIterator->SetToFirst(aList);

    // Loop until iterator does not give any more indexes or granularity reached

    TInt index = KErrNotFound;

    TInt error = KErrNone;

    TBool firstItem = ETrue;

    TInt defaultVisItems = GlxListUtils::VisibleItemsGranularityL();

    if (defaultVisItems%KVisibleItemsModFactor == 0)

        {

        defaultVisItems += KVisibleItemsCorrectionValue;

        }

    while ((KErrNotFound != (index = (*iIterator)++)) && (aItemIndices.Count() < iGranularity) && (KErrNone == error))

        {

        // Check if this item is lacking attributes

        TBool attributesAdded = AddItemAttributesL(index, aList, aAttributes, error, firstItem);

        if (attributesAdded)

            {

            aItemIndices.AppendL(index);

            GLX_DEBUG3("CGlxAttributeContext::AttributeRequestL() index=%d, Media Id=%d", 

                                                    index, aList->Item(index).Id().Value());

            firstItem = EFalse;

            // Fetch the visible items attrib first

            if (aItemIndices[0] == (aList->VisibleWindowIndex()+ (defaultVisItems/2))

                && aItemIndices.Count() == defaultVisItems)

                {

                GLX_DEBUG1("Break to fetch the visible items attrib first");

                break;

				}

            }

        else if ( firstItem && ( error != KErrNone ) )

            {

            // Continue iterating through the list

            // if the first item had errors

            // See EMYP-79VDHP

            error = KErrNone;

            }

        }

    // If the attribute request is for Thumbnail, Check if there is a match found.

    // And set the size and thumbnail quality

	TIdentityRelation<TMPXAttribute> matchContent(&TMPXAttribute::MatchContentId);

	TMPXAttribute tnAttr(KGlxMediaIdThumbnail, 0);

		{

		// Allocate CMPXAttributeSpecs

		CMPXAttributeSpecs* attributeSpecs = CMPXAttributeSpecs::NewL();

		CleanupStack::PushL(attributeSpecs);

					   KGlxAttribSpecThumbnailSize ), 

					   TSize(iDefaultSpecSize.iWidth,iDefaultSpecSize.iHeight) );

		attributeSpecs->SetTObjectValueL(

		   TMPXAttribute( KGlxMediaIdThumbnail,

					   KGlxAttribSpecThumbnailQualityOverSpeed ), ETrue );

		aDetailedSpecs = attributeSpecs;

		// Pop from stack

		CleanupStack::Pop(attributeSpecs);

		}

    // If an error was found, return KErrGeneral

    if (error != KErrNone)

        {

        return KErrGeneral;

        }

    GLX_DEBUG2("CGlxAttributeContext::AttributeRequestL() aItemIndices.Count()=%d",

                                      aItemIndices.Count());

    return aItemIndices.Count();

    }

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

// Get all attributes required for the item (whether the are fetched or not)

// From MGlxFetchContext

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

//

void CGlxAttributeContext::AllAttributesL(const MGlxMediaList* aList, TInt aListIndex, 

        RArray<TMPXAttribute>& aAttributes) const 

    {

    TRACER("CGlxAttributeContext::AllAttributesL");

    // An empty request makes no sense, but won't do any harm.

    // If no iterator, no request

    if (!iIterator || !iAttributes.Count())

        {

        return;

        }

    // No requests outside range

    iIterator->SetToFirst(aList);

    if (!iIterator->InRange(aListIndex))

        {

        return;

        }

    CleanupClosePushL(aAttributes);

    // Just list all attributes specified for this context

    TInt count = iAttributes.Count();

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

        {

        aAttributes.AppendL(iAttributes[i]);

        }

    CleanupStack::Pop(&aAttributes);

    }

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

// Number of current requests

// From MGlxFetchContext

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

TInt CGlxAttributeContext::RequestCountL(const MGlxMediaList* aList) const

    {

    TRACER("CGlxAttributeContext::RequestCountL");

    RArray<TInt> itemIndices;

    CleanupClosePushL(itemIndices);

    RArray<TMPXAttribute> attributes;

    CleanupClosePushL(attributes);

    CMPXAttributeSpecs* attrSpecs = NULL;

    TInt requestCount = AttributeRequestL(aList, itemIndices, attributes, attrSpecs);

    delete attrSpecs;

    CleanupStack::PopAndDestroy(&attributes);

    CleanupStack::PopAndDestroy(&itemIndices);

    return requestCount;

    }

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

// Check if the item at the index requires any attributes to be added to request

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

TBool CGlxAttributeContext::AddItemAttributesL(TInt aIndexInList, 

        const MGlxMediaList* aList, RArray<TMPXAttribute>& aAttributes,

        TInt& aError, TBool aFirstItem) const

    {

    TRACER("CGlxAttributeContext::AddItemAttributesL");

    TInt attributesAdded = EFalse;

    const TGlxMedia& m = aList->Item(aIndexInList);

    if (!m.IsStatic())

    	{

    	const CGlxMedia* media = m.Properties();

	    TInt attributeCount = iAttributes.Count();

	    if (!media)

	        {

	        // There are no attributes for this item

	        // Add all attributes

	        for (TInt count = 0; count < attributeCount; ++count)

	            {

	            AddItemAttributeL(aAttributes, iAttributes[count]);

	            }

	        if ( attributeCount > 0 )

	            {

	            attributesAdded = ETrue;

	            }

	        }

	    else

	        {

	        if ( GlxErrorManager::HasError(media) )

	            {

	            // Item has one or more errors on its attributes

	            // Check if we are going to try to add an attribute that may have an error on it

	            for (TInt count = 0; (count < attributeCount) && (KErrNone == aError); ++count)

	                {

	                aError = GlxErrorManager::HasAttributeErrorL(media, iAttributes[count]);

	                }

	            }

	        // Always allow attribute adding if it's the first item

	        if ( KErrNone == aError || aFirstItem )

	            {

	            // There may be some attributes for this item

	            // Add attributes that don't exist yet

	            for (TInt count = 0; count < attributeCount; ++count)

	                {

	                const TMPXAttribute& attribute = iAttributes[count];

	                if (!media->IsSupported(attribute))

	                    {

	                    if ( KErrNone == GlxErrorManager::HasAttributeErrorL(media, iAttributes[count]) )

	                        {

	                        AddItemAttributeL(aAttributes, attribute);

	                        attributesAdded = ETrue;

	                        }

	                    }

	                }

	            }

	        }

    	}

    return attributesAdded;

    }

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

// Add attribute to array, no duplicates

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

void CGlxAttributeContext::AddItemAttributeL(RArray<TMPXAttribute>& aAttributes, 

        const TMPXAttribute& aAttribute) const

    {

    TRACER("CGlxAttributeContext::AddItemAttributeL");

    CleanupClosePushL(aAttributes);

    TIdentityRelation<TMPXAttribute> match(&TMPXAttribute::Match);

    TInt index = aAttributes.Find(aAttribute, match);

    if (index == KErrNotFound)

        {

        aAttributes.AppendL(aAttribute);

        }

    CleanupStack::Pop(&aAttributes);

    }

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

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

// CGlxDefaultAttributeContext

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

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

//

// NewL

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

//

EXPORT_C CGlxDefaultAttributeContext* CGlxDefaultAttributeContext::NewL()

    {

    TRACER("CGlxDefaultAttributeContext::NewL");

    CGlxDefaultAttributeContext* obj = new (ELeave) CGlxDefaultAttributeContext();

    return obj;

    }

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

// Constructor

// Sets the iterator of base class to be TGlxFromFocusOutwardIterator

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

//

CGlxDefaultAttributeContext::CGlxDefaultAttributeContext() :

        CGlxAttributeContext(&iFromFocusIterator)

    {

    }

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

// Destructor

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

//

EXPORT_C CGlxDefaultAttributeContext::~CGlxDefaultAttributeContext()

    {

    TRACER("CGlxDefaultAttributeContext::Destructor");

    }

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

// Set range offsets

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

//

EXPORT_C void CGlxDefaultAttributeContext::SetRangeOffsets(TInt aFrontOffset, TInt aRearOffset)

    {

    TRACER("CGlxDefaultAttributeContext::SetRangeOffsets");

    iFromFocusIterator.SetRangeOffsets(aRearOffset, aFrontOffset);

    }

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

// Sets the default fetch specification

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

//

EXPORT_C void CGlxAttributeContext::SetDefaultSpec(TInt aWidth, TInt aHeight)

    {

    TRACER( " CGlxAttributeContext::SetDefaultSpec");

    iDefaultSpecSize = TSize(aWidth, aHeight);

    }