/*

* 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:    List of media items

*

*/

#include "glxmedialist.h"

#include <glxcollectionplugintype.hrh>

#include <glxassert.h>

#include <glxcollectiongeneraldefs.h>

#include <glxerrorposter.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcollectionutility.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <glxtracer.h>

#include <glxlog.h>

#include "glxcachemanager.h"

#include "glxmedialistarray.h"

#include "glxnavigablelist.h"

#include "mglxfetchcontext.h"

#include "mglxmedialistobserver.h"

#include "glxmediastaticitemdefs.h"

/**

 * Min & Max wait interval for a modify event, in microseconds

 * This is to allow thumbnail manager to procees the event first.

 */

const TInt KModifyEventMinWaitInterval = 2000000;

const TInt KModifyEventMaxWaitInterval = 3000000;

/**

 * Maximum items count for minimum wait interval.

 */

const TInt KMaxItemsCount = 500;

/**

 * Time between Callbacks to determine a batch delete operation.

 */

const TInt KCallbackInterval = 200000;

namespace NGlxMediaList

    {

    /**

     * Interface to notify observers. Allows different notifications to use

     * the same (complicated) iteration loop

     */

    class TNotificationStrategy 

        {

        public:

            TNotificationStrategy( MGlxMediaList& aList )

                    : iList( aList )

                {

                }

            /** 

             * Notify observer

             * @param aObserver Observer to notify 

             */

            virtual void NotifyL( MGlxMediaListObserver& aObserver ) = 0;

        protected:

            MGlxMediaList& iList;

        };

    /**

     * Notification strategy for items being added

     */

    class TItemsAddedNotificationStrategy : public TNotificationStrategy 

        {

        public:

            /**

             * Constructor 

             * @param aFirstAddedIndex Index of the first item added

             * @param aCount number of items added

             * @param aList Media list that sends the notification

             */

            TItemsAddedNotificationStrategy( TInt aFirstAddedIndex, 

                TInt aCount, MGlxMediaList& aList )

                    : TNotificationStrategy( aList )

                {

                iFirstAddedIndex = aFirstAddedIndex;

                iLastAddedIndex = aFirstAddedIndex + aCount - 1;

                }

            // From MGlxNotificationStrategy

            void NotifyL( MGlxMediaListObserver& aObserver )

                {

                aObserver.HandleItemAddedL( iFirstAddedIndex, iLastAddedIndex, 

                    &iList );

                }        

        private:

            /// Index of the first item added

            TInt iFirstAddedIndex;

            /// Index of the last item added

            TInt iLastAddedIndex;

        };

    /**

     * Notification strategy for items being removed

     */

    class TItemsRemovedNotificationStrategy : public TNotificationStrategy 

        {

        public:

            /**

             * Constructor 

             * @param aFirstRemovedIndex Index of the first item removed

             * @param aCount number of items removed

             * @param aList Media list that sends the notification

             */

            TItemsRemovedNotificationStrategy( TInt aFirstRemovedIndex, 

                TInt aCount, MGlxMediaList& aList )

                    : TNotificationStrategy( aList )

                {

                iFirstRemovedIndex = aFirstRemovedIndex;

                iLastRemovedIndex = aFirstRemovedIndex + aCount - 1;

                }

            // From MGlxNotificationStrategy

            void NotifyL( MGlxMediaListObserver& aObserver )

                {

                aObserver.HandleItemRemovedL( iFirstRemovedIndex, 

                    iLastRemovedIndex, &iList );

                }        

        private:

            /// Index of the first item removed

            TInt iFirstRemovedIndex;

            /// Index of the last item removed

            TInt iLastRemovedIndex;

        };

    /**

     * Notification strategy for focus being changed

     */

    class TFocusChangedNotificationStrategy : public TNotificationStrategy 

        {

        public:

            /**

             * Constructor 

             * @param aFirstRemovedIndex Index of the first item removed

             * @param aCount number of items removed

             * @param aList Media list that sends the notification

             */

            TFocusChangedNotificationStrategy( NGlxListDefs::TFocusChangeType aType, 

                TInt aNewIndex, TInt aOldIndex, MGlxMediaList& aList )

                    : TNotificationStrategy( aList )

                {

                iType = aType;

                iNewIndex = aNewIndex;

                iOldIndex = aOldIndex;

                }

            // From MGlxNotificationStrategy

            void NotifyL( MGlxMediaListObserver& aObserver )

                {

                aObserver.HandleFocusChangedL( iType, iNewIndex, iOldIndex, &iList );

                }        

        private:

            /// Focus change type

            NGlxListDefs::TFocusChangeType iType;

            /// New focus index

            TInt iNewIndex;

            /// Old focus index

            TInt iOldIndex;

        };

    /**

     * Notification strategy for selection being changed

     */

    class TItemSelectedNotificationStrategy : public TNotificationStrategy 

        {

        public:

            /**

             * Constructor 

             * @param aIndex Index of item being selected/deselected

             * @param aSelected Selection/deselection info

             * @param aList Media list that sends the notification

             */

            TItemSelectedNotificationStrategy( TInt aIndex, TBool aSelected,

                MGlxMediaList& aList )

                    : TNotificationStrategy( aList )

                {

                iIndex = aIndex;

                iSelected = aSelected;

                }

            // From MGlxNotificationStrategy

            void NotifyL( MGlxMediaListObserver& aObserver )

                {

                aObserver.HandleItemSelectedL( iIndex, iSelected, &iList );

                }        

        private:

            /// Index of item being selected/deselected

            TInt iIndex;

            /// Selection/deselection info

            TBool iSelected;

        };    

    /**

     * Notification strategy for command being completed

     */

    class TCommandCompletedNotificationStrategy : public TNotificationStrategy 

        {

        public:

            /**

             * Constructor 

             * @param aSessionId Session id of client that issued the command

             * @param aCommand Command which was completed

             * @param aError Error code from execution of the command

             * @param aList Media list that sends the notification

             */

            TCommandCompletedNotificationStrategy( TAny* aSessionId, 

                CMPXCommand* aCommand, TInt aError, MGlxMediaList& aList )

                    : TNotificationStrategy( aList )

                {

                iSessionId = aSessionId;

                iCommand = aCommand;

                iError = aError;

                }

            // From MGlxNotificationStrategy

            void NotifyL( MGlxMediaListObserver& aObserver )

                {

                /// @todo: make this call leaving

                aObserver.HandleCommandCompleteL( iSessionId, iCommand, iError, &iList );

                }        

        private:

            /// Session id of client that issued the command

            TAny* iSessionId;

            /// Command which was completed

            CMPXCommand* iCommand;

            /// Error code 

            TBool iError;

        };            

    /**

     * Notification strategy for list population

     */

    class TListPopulatedNotificationStrategy : public TNotificationStrategy 

        {

        public:

            /**

             * Constructor 

             * @param aList Media list that sends the notification

             */

            TListPopulatedNotificationStrategy ( MGlxMediaList& aList )

                    : TNotificationStrategy( aList )

                {

                }

            // From MGlxNotificationStrategy

            void NotifyL( MGlxMediaListObserver& aObserver )

                {

                aObserver.HandlePopulatedL( &iList );

                }        

        }; 

    /**

     * Notification strategy for messages

     */

    class TMessageNotificationStrategy : public TNotificationStrategy

        {

        public:

            /**

             * Constructor

             * @param aList Media list that sends the notification

             */

            TMessageNotificationStrategy ( const CMPXMessage& aMessage, MGlxMediaList& aList ) :

                    TNotificationStrategy( aList ),

                    iMessage( aMessage )

                {

                }

            // From MGlxNotificationStrategy

            void NotifyL( MGlxMediaListObserver& aObserver )

                {

                aObserver.HandleMessageL( iMessage, &iList );

                }

        private:

            /// Message which was received

            const CMPXMessage& iMessage;

        };

    } // namespace NGlxMediaList

using namespace NGlxMediaList;

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

// Returns a new/existing media list interface

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

CGlxMediaList* CGlxMediaList::InstanceL(const CMPXCollectionPath& aPath, 

        const TGlxHierarchyId& aHierarchyId, CMPXFilter* aFilter)

    {

    TRACER("CGlxMediaList::InstanceL" );

    CGlxMediaListArray* mediaListArray = CGlxMediaListArray::InstanceL();

    CleanupClosePushL(*mediaListArray);

    RPointerArray<CGlxMediaList>& mediaLists =  mediaListArray->Array();

    TInt matchIndex = KErrNotFound;

    CGlxMediaList* mediaListInstance = NULL; // List to return

    // Try to find an existing media list to return (by matching the path)

    TInt listCount = mediaLists.Count();

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

        {

        CGlxMediaList* mediaList = mediaLists[count];

        // See if path's and hierarchy id's match

        // Filter is ignored

        if (mediaList->Equals(aPath) && (mediaList->iHierarchyId == aHierarchyId))

            {

            // Found a match

            matchIndex = count;

            mediaListInstance = mediaList;

            break;

            }

        }

    // Create a new media list if could not use an existing one

    if (matchIndex == KErrNotFound)

        {

        __ASSERT_DEBUG(!mediaListInstance, Panic(EGlxPanicAlreadyInitialised));

        mediaListInstance = CGlxMediaList::NewLC(aHierarchyId);

        // Set specified filter (if any) before opening the collection to path

        mediaListInstance->SetFilterL(aFilter);

        mediaListInstance->OpenL(aPath);

        // Insert media list as highest priority

        mediaLists.InsertL(mediaListInstance, 0);

        CleanupStack::Pop(mediaListInstance);

        }

    else

        {

        __ASSERT_DEBUG(mediaListInstance, Panic(EGlxPanicNullPointer));

        // Match found, set as highest priority

        mediaLists.InsertL(mediaListInstance, 0);

        mediaLists.Remove(matchIndex + 1);

        }

    mediaListInstance->AddReference(); // Add user

    CleanupStack::PopAndDestroy(mediaListArray);

    return mediaListInstance;

    }

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

// Gives an array of all media lists in current use

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

RPointerArray<CGlxMediaList>& CGlxMediaList::MediaListsL()

    {

    TRACER("CGlxMediaList::MediaListsL" );

    CGlxMediaListArray* mediaListArray = CGlxMediaListArray::InstanceL();

    RPointerArray<CGlxMediaList>& array = mediaListArray->Array();

    mediaListArray->Close();

    return array;

    }

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

// OfferMedia

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

//

void CGlxMediaList::OfferMedia(const TGlxIdSpaceId& aIdSpaceId, CGlxMedia* aMedia) 

    {

    TRACER("CGlxMediaList::OfferMedia" );

    // try to find the matching item in this list

    TInt index = Index( aIdSpaceId, aMedia->Id() );

    // if matching item found, link media object

    if ( KErrNotFound != index )

        {

        TGlxMedia& item = iItemList->Item( index );

        // static items should not be offered

        if ( !item.IsStatic() )

            {

            item.SetMedia( aMedia, *this, index );

            }

        }

    }

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

// NotifyThumbnailAvailableL

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

//

void CGlxMediaList::HandleAttributesAvailableL(TInt aIndex, 

        const RArray<TMPXAttribute>& aAttributes)

    {

    TRACER("CGlxMediaList::HandleAttributesAvailableL" );

    __ASSERT_DEBUG(aIndex >= 0, Panic(EGlxPanicLogicError)); // Must exist

    // Need to get exact count of iItemListObservers at

    // every iteration because it is possible that 

    // RemoveMediaListObserver might call during this iteration

    for (TInt i = 0; i < iItemListObservers.Count(); i++)

        {

        iItemListObservers[i]->HandleAttributesAvailableL(aIndex, aAttributes, this);

        }

    }

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

// Ask if the list has any requests to place

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

//

void CGlxMediaList::AttributeRequestL(RArray<TInt>& aItemIndexes,

		RArray<TGlxMediaId>& aItemIds, 

        RArray<TMPXAttribute>& aAttributes, 

        CMPXAttributeSpecs*& aDetailedSpecs) const

    {

    TRACER("CGlxMediaList::AttributeRequestL" );

    // Find the highest priority context that has something to request

    TInt count = iContexts.Count();

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

        {

        // Determine items (referenced by index) to request attributes for

        iContexts[i].iContext->AttributeRequestL(this, aItemIndexes, aAttributes, aDetailedSpecs);

        // Map item indices to item Ids

        TInt itemIndicesCount = aItemIndexes.Count();

        for (TInt itemIndicesCounter = 0; itemIndicesCounter < itemIndicesCount; ++itemIndicesCounter)

            {

            const TGlxMedia& item = iItemList->Item( aItemIndexes[itemIndicesCounter] );

            if (!item.IsStatic())

                {

                aItemIds.AppendL( item.Id() );

                }

            }

        // break if context has something to request

        if (itemIndicesCount > 0)

            {

            break;

            }

        }

    }

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

// AllAttributesL

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

//

void CGlxMediaList::GetRequiredAttributesL(TInt aIndex, RArray<TMPXAttribute>& aAttributes)

    {

    TRACER("CGlxMediaList::GetRequiredAttributesL" );

    TLinearOrder<TMPXAttribute> orderer (&AttributeOrder);

    // Determine all attributes to request for an item, for all contexts

    TInt contextCount = iContexts.Count();

    for ( TInt contextIndex = 0; contextIndex < contextCount; contextIndex++ )

        {

        const MGlxFetchContext* context = iContexts[contextIndex].iContext;

        if ( context )

            {

            // Determine all attributes to request for an item, for this context

            context->AllAttributesL(this, aIndex, aAttributes);

            }

        }

    }

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

// AttributeOrder

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

//

TInt CGlxMediaList::AttributeOrder(const TMPXAttribute& aItem1, 

        const TMPXAttribute& aItem2) 

    {

    TRACER("CGlxMediaList::AttributeOrder");

    TInt contentId1 = aItem1.ContentId();

    TInt contentId2 = aItem2.ContentId();

    if (contentId1 < contentId2) 

        {

        return -1;

        }

    if (contentId1 > contentId2) 

        {

        return 1;

        }

    TUint attributeId1 = aItem1.AttributeId();

    TUint attributeId2 = aItem2.AttributeId();

    if (attributeId1 < attributeId2) 

        {

        return -1;

        }

    if (attributeId1 > attributeId2) 

        {

        return 1;

        }

    return 0;

    }