/*

* Copyright (c) 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: 

*

*/

/*glxmlwrapper_p.cpp*/

//external includes

#include <hbicon.h>

#include <glxtracer.h>

#include <mglxmedialist.h>

#include <glxlog.h>

#include <glxthumbnailcontext.h>

#include <glxattributecontext.h>

#include <glxuistd.h>

#include <glxcollectionpluginall.hrh>

#include <glxcollectionpluginalbums.hrh>

#include <glxcollectiongeneraldefs.h>

#include <glxthumbnailattributeinfo.h>

#include <glxfilterfactory.h>

#include <glxmedia.h>

#include <glxerrormanager.h>

#include <glxattributecontext.h>

#include <glxuistd.h>

#include <glxlistdefs.h>

#include <hal.h>

#include <hal_data.h>

#include <glxmediaid.h>

#include <caf/caferr.h>

//internal includes 

#include "glxmlwrapper_p.h"

#include "glxmlgenericobserver.h"

#include "glxattributeretriever.h"

//#define GLXPERFORMANCE_LOG  

#include <glxperformancemacro.h>

//constant declaration

const TInt KItemsPerPage(18);

const TInt KTBAttributeAvailable(1);

const TInt KTBAttributeUnavailable(0);

const TInt KTBAttributeCorrupt(-1);

const TInt KListDataWindowSize(10);

const TInt KGridTNWIdth (128);

const TInt KGridTNHeight (128);

const TInt KFullScreenTNLSWidth (640);

const TInt KFullScreenTNLSHeight (360);

const TInt KFullScreenTNPTWidth (360);

const TInt KFullScreenTNPTHeight (640);

// ======== MEMBER FUNCTIONS ========

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

// Two-phased constructor.

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

//

GlxMLWrapperPrivate* GlxMLWrapperPrivate::Instance(GlxMLWrapper* aMLWrapper,

    int aCollectionId, int aHierarchyId, TGlxFilterItemType aFilterType)

    {

    TRACER("GlxMLWrapperPrivate::NewLC()");

    GlxMLWrapperPrivate* self = new GlxMLWrapperPrivate(aMLWrapper);

   if(self){

	   TRAPD(err,self->ConstructL(aCollectionId, aHierarchyId, aFilterType));

	   if(err != KErrNone){

		   delete self;

		   self = NULL;

		   }

	   }

    return self;

    }

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

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

GlxMLWrapperPrivate::GlxMLWrapperPrivate(GlxMLWrapper* aMLWrapper): iMLWrapper(aMLWrapper),

								iGridContextActivated(EFalse), iLsFsContextActivated(EFalse),

								iPtFsContextActivated(EFalse), iPtListContextActivated(EFalse),

								iSelectionListContextActivated(EFalse)

    {

    TRACER("GlxMLWrapperPrivate::GlxMLWrapperPrivate");

	iGridThumbnailContext = NULL;

	iPtFsThumbnailContext = NULL;

	iLsFsThumbnailContext = NULL;

	iTitleAttributeContext = NULL;

	iSubtitleAttributeContext = NULL;

    iListThumbnailContext = NULL;

    iFocusGridThumbnailContext = NULL;

    iFocusFsThumbnailContext = NULL;

    }

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

// Symbian 2nd phase constructor can leave.

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

//  

void GlxMLWrapperPrivate::ConstructL(int aCollectionId, int aHierarchyId, TGlxFilterItemType aFilterType)

    {

    TRACER("GlxMLWrapperPrivate::ConstructL");

	if(aCollectionId != KGlxAlbumsMediaId)

		{

		CreateMediaListL(aCollectionId, aHierarchyId,aFilterType);

		}

	else

		{

		//for creating Medial List for Albums Media path Items

		CreateMediaListAlbumItemL(aCollectionId, aHierarchyId,aFilterType);

		}

	iMLGenericObserver = CGlxMLGenericObserver::NewL(*iMediaList,this);

	iFsFromFocusOutwardIterator.SetRangeOffsets(2,2);

	iFsFromFocusOutwardIteratorForFocus.SetRangeOffsets(0,0);

	iBlockyIteratorForFocus.SetRangeOffsets(0,0);

    }

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

// Destructor

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

//

GlxMLWrapperPrivate::~GlxMLWrapperPrivate()

    {

    TRACER("GlxMLWrapperPrivate::~GlxMLWrapperPrivate");

	RemoveGridContext();

	RemovePtFsContext();

	RemoveLsFsContext();

	RemoveListContext();

	delete iMLGenericObserver;

	iMLGenericObserver = NULL;

	if (iMediaList)

        {

         iMediaList->Close();

        }

    }

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

// SetContextMode

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

//

void GlxMLWrapperPrivate::SetContextMode(GlxContextMode aContextMode)

    {

	TInt err = KErrNone;

	if(aContextMode <= GlxContextPtFs) 

		{  

		TRAP(err, SetThumbnailContextL(aContextMode) ); //todo add a trap here

		}

	else 

		{

		TRAP(err, SetListContextL(aContextMode) );

		}

	GLX_LOG_INFO1("GlxMLWrapperPrivate::SetContextMode error %d", err);

	iContextMode = aContextMode;

	}

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

// SetListContextL

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

//

void GlxMLWrapperPrivate::SetListContextL(GlxContextMode aContextMode)

{

	if(GlxContextLsList == aContextMode || GlxContextPtList == aContextMode)

		{

		if(!iPtListContextActivated)

			{

			if(NULL == iTitleAttributeContext)

				{

				iTitleAttributeContext = CGlxDefaultAttributeContext::NewL();

			    iTitleAttributeContext->SetRangeOffsets( KListDataWindowSize, 

						KListDataWindowSize );

			    iTitleAttributeContext->AddAttributeL( KMPXMediaGeneralTitle );

				iMediaList->AddContextL( iTitleAttributeContext, KMaxTInt );

				}

			if(NULL == iSubtitleAttributeContext)

				{

			    iSubtitleAttributeContext = CGlxDefaultAttributeContext::NewL();

				iSubtitleAttributeContext->SetRangeOffsets( KListDataWindowSize, 

						 KListDataWindowSize );

				iSubtitleAttributeContext->AddAttributeL( 

								 KGlxMediaCollectionPluginSpecificSubTitle );

				iMediaList->AddContextL( iSubtitleAttributeContext, KMaxTInt );

				}

            if(NULL == iListThumbnailContext)

	            {

	        	iListThumbnailContext = CGlxThumbnailContext::NewL( &iThumbnailIterator ); // set the thumbnail context

	        	iThumbnailIterator.SetRange( 10 ); 

	        	iListThumbnailContext->SetDefaultSpec( KGridTNWIdth,KGridTNHeight );

	        	iMediaList->AddContextL(iListThumbnailContext ,KGlxFetchContextPriorityNormal );

	            }

			iPtListContextActivated = ETrue;

			}

		}

        else if(GlxContextSelectionList == aContextMode )

        {

            if(NULL == iTitleAttributeContext)

            {

                iTitleAttributeContext = CGlxDefaultAttributeContext::NewL();

                iTitleAttributeContext->SetRangeOffsets( KListDataWindowSize, KListDataWindowSize );

                iTitleAttributeContext->AddAttributeL( KMPXMediaGeneralTitle );

                iMediaList->AddContextL( iTitleAttributeContext, KMaxTInt );

            }

        iSelectionListContextActivated = ETrue;

        }

}

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

// CreateThumbnailContext

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

//

void GlxMLWrapperPrivate::SetThumbnailContextL(GlxContextMode aContextMode)

{

	TRACER("GlxMLWrapperPrivate::SetThumbnailContext()");

	if(aContextMode == GlxContextGrid) {

		if(!iGridContextActivated) {

			CreateGridContextL();

		}

		if(iPtFsContextActivated)

			{

			RemovePtFsContext();

			}

		if(iLsFsContextActivated)

			{

			RemoveLsFsContext();

			}

		}

	if(aContextMode == GlxContextLsFs && !iLsFsContextActivated)

		{

		if(!iGridContextActivated)

			{

			CreateGridContextL();

			}

		if(iPtFsContextActivated)

			{

			RemovePtFsContext();

			}

		CreateLsFsContextL();

		}

	if(aContextMode == GlxContextPtFs && !iPtFsContextActivated)

		{

		if(!iGridContextActivated)

			{

			CreateGridContextL();

			}

		if(iLsFsContextActivated)

			{

			RemoveLsFsContext();

			}

		CreatePtFsContextL();

		}

}

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

// CreateGridContextL

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

//

void GlxMLWrapperPrivate::CreateGridContextL()

    {

	TRACER("GlxMLWrapperPrivate::CreateGridContextL()");

	if(iGridThumbnailContext && !iGridContextActivated)

		{

		delete iGridThumbnailContext;

		iGridThumbnailContext = NULL;

		}

	if(!iGridContextActivated)

		{

		iGridThumbnailContext = CGlxThumbnailContext::NewL( &iBlockyIterator ); // set the thumbnail context

	    iGridThumbnailContext->SetDefaultSpec( KGridTNWIdth, KGridTNHeight );  //todo get these image sizes from  the layout.

        // show static items if required

        iMediaList->SetStaticItemsEnabled(EFalse);

	    iMediaList->AddContextL(iGridThumbnailContext, KGlxFetchContextPriorityNormal );

		iGridContextActivated = ETrue;

		}

	}

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

// CreateLsFsContextL

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

//

void GlxMLWrapperPrivate::CreateLsFsContextL()

    {

	TRACER("GlxMLWrapperPrivate::CreateGridContextL()");

	if(iLsFsThumbnailContext && !iLsFsContextActivated)

		{

		delete iLsFsThumbnailContext;

		iLsFsThumbnailContext = NULL;

		}

	if(!iLsFsContextActivated)

		{

		iLsFsThumbnailContext = CGlxThumbnailContext::NewL( &iFsFromFocusOutwardIterator ); // set the thumbnail context

	    iLsFsThumbnailContext->SetDefaultSpec( KFullScreenTNLSWidth, KFullScreenTNLSHeight );  //todo get these image sizes from  the layout.

        if(!iFocusFsThumbnailContext)

            {

            iFocusFsThumbnailContext = CGlxThumbnailContext::NewL( &iFsFromFocusOutwardIteratorForFocus ); // set Focus FS thumbthe thumbnail context

            iFocusFsThumbnailContext->SetDefaultSpec( KFullScreenTNLSWidth, KFullScreenTNLSHeight );  //todo get these image sizes from  the layout.

            }

        if(!iFocusGridThumbnailContext)

            {

            iFocusGridThumbnailContext = CGlxThumbnailContext::NewL( &iBlockyIteratorForFocus ); // set the thumbnail context for Focus Grid

            iFocusGridThumbnailContext->SetDefaultSpec( KGridTNWIdth, KGridTNHeight );  //todo get these image sizes from  the layout.

            }

        // show static items if required

        iMediaList->SetStaticItemsEnabled(EFalse);

        iMediaList->AddContextL(iFocusFsThumbnailContext, 7 );      // Temp will change this number  

        iMediaList->AddContextL(iFocusGridThumbnailContext, 8 );    // Temp will change this number  

	    iMediaList->AddContextL(iLsFsThumbnailContext, KGlxFetchContextPriorityGridViewFullscreenVisibleThumbnail );

		iLsFsContextActivated = ETrue;

		}

	}

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

// CreatePtFsContextL

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

//

void GlxMLWrapperPrivate::CreatePtFsContextL()

    {

	TRACER("GlxMLWrapperPrivate::CreateGridContextL()");

	if(iPtFsThumbnailContext && !iPtFsContextActivated)

		{

		delete iPtFsThumbnailContext;

		iPtFsThumbnailContext = NULL;

		}

	if(!iPtFsContextActivated)

		{

		iPtFsThumbnailContext = CGlxThumbnailContext::NewL( &iFsFromFocusOutwardIterator ); // set the thumbnail context

	    iPtFsThumbnailContext->SetDefaultSpec( KFullScreenTNPTWidth, KFullScreenTNPTHeight );  //todo get these image sizes from  the layout.

	    if(!iFocusFsThumbnailContext)

	        {

	        iFocusFsThumbnailContext = CGlxThumbnailContext::NewL( &iFsFromFocusOutwardIteratorForFocus ); // set Focus FS thumbthe thumbnail context

	        iFocusFsThumbnailContext->SetDefaultSpec( KFullScreenTNLSWidth, KFullScreenTNLSHeight );  //todo get these image sizes from  the layout.

	        }

	    if(!iFocusGridThumbnailContext)

	        {

	        iFocusGridThumbnailContext = CGlxThumbnailContext::NewL( &iBlockyIteratorForFocus ); // set the thumbnail context for Focus Grid

	        iFocusGridThumbnailContext->SetDefaultSpec( KGridTNWIdth, KGridTNHeight );  //todo get these image sizes from  the layout.

	        }

		// show static items if required

        iMediaList->SetStaticItemsEnabled(EFalse);

        iMediaList->AddContextL(iFocusFsThumbnailContext, 7 );      // Temp will change this number  

        iMediaList->AddContextL(iFocusGridThumbnailContext, 8 );    // Temp will change this number  

	    iMediaList->AddContextL(iPtFsThumbnailContext, KGlxFetchContextPriorityGridViewFullscreenVisibleThumbnail );

	    iPtFsContextActivated = ETrue;

		}

	}

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

// RemoveGridContext

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

//

void GlxMLWrapperPrivate::RemoveGridContext()

    {

	if(iGridThumbnailContext && iGridContextActivated)

		{

		iMediaList->RemoveContext(iGridThumbnailContext);

		delete iGridThumbnailContext;

		iGridThumbnailContext = NULL;

		iGridContextActivated = EFalse;

		}

	}

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

// RemoveLsFsContext

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

//

void GlxMLWrapperPrivate::RemoveLsFsContext()

    {

	if(iLsFsThumbnailContext && iLsFsContextActivated)

		{

		iMediaList->RemoveContext(iLsFsThumbnailContext);

		delete iLsFsThumbnailContext;

		iLsFsThumbnailContext = NULL;

		if(iFocusFsThumbnailContext)

		    {

            iMediaList->RemoveContext(iFocusFsThumbnailContext);

            delete iFocusFsThumbnailContext;

            iFocusFsThumbnailContext = NULL;

		    }

		if(iFocusGridThumbnailContext)

		    {

            iMediaList->RemoveContext(iFocusGridThumbnailContext);

            delete iFocusGridThumbnailContext;

            iFocusGridThumbnailContext = NULL;

		    }

		iLsFsContextActivated = EFalse;

		}

	}

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

// RemovePtFsContext

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

//

void GlxMLWrapperPrivate::RemovePtFsContext()

    {

	if(iPtFsThumbnailContext && iPtFsContextActivated)

		{

		iMediaList->RemoveContext(iPtFsThumbnailContext);

		delete iPtFsThumbnailContext;

		iPtFsThumbnailContext = NULL;

        if(iFocusFsThumbnailContext)

            {

            iMediaList->RemoveContext(iFocusFsThumbnailContext);

            delete iFocusFsThumbnailContext;

            iFocusFsThumbnailContext = NULL;

            }

        if(iFocusGridThumbnailContext)

            {

            iMediaList->RemoveContext(iFocusGridThumbnailContext);

            delete iFocusGridThumbnailContext;

            iFocusGridThumbnailContext = NULL;

            }

		iPtFsContextActivated = EFalse;

		}

	}

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

// RemoveListContext

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

//

void GlxMLWrapperPrivate::RemoveListContext()

	{

	if(iPtListContextActivated || iSelectionListContextActivated)

	    {

		if(iTitleAttributeContext)

			{

			iMediaList->RemoveContext(iTitleAttributeContext);

			delete iTitleAttributeContext;

			iTitleAttributeContext = NULL;

			}

		if(iSubtitleAttributeContext)

			{

			iMediaList->RemoveContext(iSubtitleAttributeContext);

			delete iSubtitleAttributeContext;

			iSubtitleAttributeContext = NULL;

			}

		if(iListThumbnailContext)

			{

			iMediaList->RemoveContext(iListThumbnailContext);

			delete iListThumbnailContext;

			iListThumbnailContext = NULL;

			}

		iPtListContextActivated = EFalse;

	    iSelectionListContextActivated = EFalse;

		}

	}

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

// GetItemCount

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

//

int GlxMLWrapperPrivate::GetItemCount()

    {

	return iMediaList->Count();

    }

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

// CreateMediaListAlbumItemL()

// Creates the media list for the album Item 

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

void GlxMLWrapperPrivate::CreateMediaListAlbumItemL(int aCollectionId, int aHierarchyId, TGlxFilterItemType aFilterType)

	{

	TRACER("GlxMLWrapperPrivate::CreateMediaListAlbumItemL");

	Q_UNUSED(aCollectionId);

	Q_UNUSED(aHierarchyId);

	//retrieve the instance of Media list for ALBUMS LIST which will be saved in iMediaList

	CreateMediaListL(KGlxCollectionPluginAlbumsImplementationUid,0,EGlxFilterAlbum);

	//retrieve the path of the focussed item of the MediaList

	CMPXCollectionPath* path = iMediaList->PathLC(NGlxListDefs:: EPathFocusOrSelection);

	//close the existing instance of Media List

	iMediaList->Close();

	iMediaList = NULL;

	//create new media list with the derived path

	CMPXFilter* filter = TGlxFilterFactory::CreateItemTypeFilterL(aFilterType);   //todo take actual filter type

	CleanupStack::PushL(filter);

	iMediaList = MGlxMediaList::InstanceL( *path, 

	                  TGlxHierarchyId(0), filter );  //todo take actual hierarchy

	CleanupStack::PopAndDestroy( filter );

	GLX_LOG_INFO1("GlxMLWrapperPrivate::CreateMediaListAlbumItemL  - Path level = %d",

	                                                     path->Levels());

	CleanupStack::PopAndDestroy(path);

	}

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

// CreateMediaListL()

// Creates a collection path

// Create a filter as requested filtertype

// Creates the medialist

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

void GlxMLWrapperPrivate::CreateMediaListL(int aCollectionId, int aHierarchyId, TGlxFilterItemType aFilterType) 

	{

	TRACER("GlxMLWrapperPrivate::CreateMediaListL");

  	Q_UNUSED(aHierarchyId);	

	// Create path to the list of images and videos

	CMPXCollectionPath* path = CMPXCollectionPath::NewL();

	CleanupStack::PushL( path );

	//path->AppendL(KGlxCollectionPluginAllImplementationUid);	// All item collection plugin  //todo take actual collection path

	path->AppendL(aCollectionId);

	// Create filter to filter out either images or videos

	GLX_LOG_INFO1("GlxMLWrapperPrivate::MediaListL  - Filter Type = %d",aFilterType);

	CMPXFilter* filter = NULL;

	if( EGlxFilterExcludeCamera == aFilterType)

		{

		filter = TGlxFilterFactory::CreateCameraAlbumExclusionFilterL();

		CleanupStack::PushL(filter);