photosgallery/controllers/fetcher/src/glxfetchercontainer.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Wed, 13 Oct 2010 14:32:09 +0300
branchRCL_3
changeset 75 01504893d9cb
parent 60 5b3385a43d68
permissions -rw-r--r--
Revision: 201039 Kit: 201041

/*
* 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:    Container for Fecther Dialog
*
*/




// System includes
#include <avkon.rsg>                    
#include <AknUtils.h>                               // For AknLayoutUtils to calculate rect
#include <data_caging_path_literals.hrh>            // KDC_APP_RESOURCE_DIR			
#include <StringLoader.h>                           // For Empty text reading from resource
#include <akntitle.h>                               // Title Pane 

#include <mpxcollectionutility.h>                   // Mpx Collection path for medialist craetion
#include <gulicon.h>                                // Gul Icon 
#include <ganes/HgItem.h>                           // HG Item 
#include <ganes/HgGrid.h>                           // Hg Grid Widget
#include <AknsBasicBackgroundControlContext.h>      // Background Context

#include <glxuistd.h>                               // KGlxFetchontextPriorityNormal and KGlxIconsFilename           
#include <glxcollectionpluginall.hrh> 	            // All item collection plugin id
#include <glxfilterfactory.h>                       // For Filters required in Medilaits
#include <glxresourceutilities.h>                   // for CGlxResourceUtilities
#include <glxfetcherdialog.rsg>                     // FOR GETTING Dialog ID AND RESOURCE ID
#include <glxattributecontext.h>                    // TMPXAttribute
#include <glxattributeretriever.h>  	            // CGlxAttributeRetriever
#include <glxfetchcontextremover.h>                 // TGlxfetchContextRemover
#include <glxuiutility.h>                           // AknIconUtils and EikStatusPane
#include <glxtracer.h>                              // For Tracer logs
#include <glxlog.h>                                 // Glx Logger
#include <glxgridviewmlobserver.h>                  // Medialistobserver for HgGrid
#include <glxthumbnailcontext.h>                    // Thumbnailcontext for HgGrid
#include <glxicons.mbg>                             // Glx Icons for HgGrid                     
#include <mglxmedialist.h>				            // MGlxMediaList, CMPXCollectionPath
#include <glxcommandhandlers.hrh>                   // For EGlxCmdEndMultiplemarking and EGlxCmdStartMultiplemarking 
#include <glxthumbnailattributeinfo.h>              // KGlxMediaIdThumbnail
#include <glxerrormanager.h>
#include <glxdrmutility.h>                          // DRM utility class to provide DRM-related functionality

// User includes
#include "glxfetchercontainer.h"
#include "mglxeventobserver.h"
#include "glxfetcher.hrh"
#include "glxfetchercommandhandler.h"

const TInt KPadding(7);
const TInt KNoOfPages(4);
const TInt KBufferTreshold(1);
const TInt KItemsPerPage(18);
const TInt KBufferSize(KNoOfPages * KItemsPerPage);
const TInt KBufferTresholdSize(KBufferTreshold * KItemsPerPage);

//-----------------------------------------------------------------------------
// Two-phased constructor.
//-----------------------------------------------------------------------------
CGlxFetcherContainer* CGlxFetcherContainer::NewL(
        TGlxFilterItemType aFilterType, const TDesC& aTitle, 
        MGlxEventObserver& aEventObserver, TBool aMultiSelectionEnabled ) 
	{
	TRACER("CGlxFetcherContainer::NewL");
	CGlxFetcherContainer* self = 
	    new( ELeave ) CGlxFetcherContainer( aFilterType ,aTitle, 
	            aEventObserver, aMultiSelectionEnabled);
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self ); 
	return self;
	}

//-----------------------------------------------------------------------------
// C++ default constructor.
//-----------------------------------------------------------------------------
CGlxFetcherContainer::CGlxFetcherContainer(
        TGlxFilterItemType aFilterType ,const TDesC& aTitle,
        MGlxEventObserver& aEventObserver, TBool aMultiSelectionEnabled )
    : iFilterType( aFilterType ),
    iTitle( aTitle ),iEventObserver(aEventObserver),
    iMultiSelectionEnabled(aMultiSelectionEnabled)      
    {
    TRACER("CGlxFetcherContainer::CGlxFetcherContainer");
    // No implementation required
    }

// ---------------------------------------------------------------------------
// ConstructL()
// ---------------------------------------------------------------------------
void CGlxFetcherContainer::ConstructL()
    {
    TRACER("CGlxFetcherContainer::ConstructL");
    iBgContext = CAknsBasicBackgroundControlContext::NewL( 
            KAknsIIDQsnBgAreaMain, Rect(), EFalse );
    iUiUtility = CGlxUiUtility::UtilityL();
    iGridIconSize = iUiUtility->GetGridIconSize();

    // For DRM Utility
    iDRMUtility = CGlxDRMUtility::InstanceL();    
    SetFileAttached(EFalse);
    }

//-----------------------------------------------------------------------------
// Destructor
//-----------------------------------------------------------------------------
CGlxFetcherContainer::~CGlxFetcherContainer()
    {
    TRACER("CGlxFetcherContainer::~CGlxFetcherContainer");
    if (iDRMUtility)
        {
        iDRMUtility->Close();
        }            
    delete iBgContext;
    delete iPreviousTitle;
    delete iFetcherCommandHandler;
    delete iGlxGridMLObserver;  
    if (iHgGrid)
        {
        iHgGrid->SetFocus(EFalse);
        delete iHgGrid;
        iHgGrid = NULL;
        }
    if (iMediaList)
        {
        iMediaList->RemoveContext(iThumbnailContext);
        delete iThumbnailContext;
        iMediaList->Close();
        }
    if (iUiUtility)
        {
        iUiUtility->Close() ;
        }
    }


// ---------------------------------------------------------------------------
// CreateAndDisplayGridL
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::CreateAndDisplayGridL()
	{
	TRACER("CGlxFetcherContainer::CreateAndDisplayGridL");
    //Create Medialist
    CreateMediaListL();
    
	// Create the control here
    CreateHgGridWidgetL();
    
    CreateGridMediaListObserverL();
	
	// If multiple image selection is allowed, then set marking flag on grid widget.
	if(iMultiSelectionEnabled)
	    {
	    // Fetcher CommandHandler must be created after creating the medialist
	    iFetcherCommandHandler = CGlxFetcherCommandHandler::NewL( this , this );
	    
	    iHgGrid->SetFlags( CHgScroller::EHgScrollerSelectionMode );
	    iMultipleMarkNotStarted = EFalse;
	    }
	}
// ---------------------------------------------------------------------------
// CreateMediaListL()
// Creates a collection path
// Create a filter as requested filtertype
// Creates the medialist
// ---------------------------------------------------------------------------
void CGlxFetcherContainer::CreateMediaListL() 
	{
	TRACER("CGlxFetcherContainer::CreateMediaListL");
   		
	// Create path to the list of images and videos
	CMPXCollectionPath* path = CMPXCollectionPath::NewL();
	CleanupStack::PushL( path );
	path->AppendL(KGlxCollectionPluginAllImplementationUid);	// All item collection plugin  
	
	// Create filter to filter out either images or videos
	GLX_LOG_INFO1("CGlxFetcherContainer::MediaListL  - Filter Type = %d",iFilterType);
	CMPXFilter* filter = TGlxFilterFactory::CreateItemTypeFilterL(iFilterType);  
	CleanupStack::PushL(filter);
	
	// Create the media list
	iMediaList =  MGlxMediaList::InstanceL( *path, 
	                  TGlxHierarchyId(KGlxFetcherDllUid), filter );
	CleanupStack::PopAndDestroy( filter );
	
	GLX_LOG_INFO1("CGlxFetcherContainer::MediaListL  - Path level = %d",
	                                                     path->Levels());
	
	CleanupStack::PopAndDestroy( path );
	}
// ---------------------------------------------------------------------------
// CreateHgGridWidgetL
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::CreateHgGridWidgetL()
	{
    TRACER("CGlxFetcherContainer::CreateHgGridWidgetL");
    //Setting the Title
    SetTitleL( iTitle);

    iThumbnailContext = CGlxThumbnailContext::NewL( &iBlockyIterator ); // set the thumbnail context
    iThumbnailContext->SetDefaultSpec( iUiUtility->GetGridIconSize().iWidth,
            iUiUtility->GetGridIconSize().iHeight );

    iMediaList->AddContextL(iThumbnailContext, KGlxFetchContextPriorityNormal );

    if (!iHgGrid)
        {
        TRect rect;
        AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);
        TSize iconSize (iUiUtility->GetGridIconSize().iWidth - (2*KPadding),
                iUiUtility->GetGridIconSize().iHeight -(2*KPadding));
        TFileName resFile(KDC_APP_BITMAP_DIR);
        resFile.Append(KGlxIconsFilename);
        CFbsBitmap* bitmap = NULL;
        CFbsBitmap* mask = NULL;
        AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,
                bitmap, mask, resFile, EMbmGlxiconsQgn_prop_image_notcreated,
                EMbmGlxiconsQgn_prop_image_notcreated_mask);
        __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));
        __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));

        AknIconUtils::SetSize(bitmap, CHgGrid::PreferredImageSize(),
                EAspectRatioPreservedAndUnusedSpaceRemoved);
        AknIconUtils::SetSize(mask, CHgGrid::PreferredImageSize(),
                EAspectRatioPreservedAndUnusedSpaceRemoved);

        // Create Hg grid object
        iHgGrid = CHgGrid::NewL(rect, iMediaList->Count(), CGulIcon::NewL(
                bitmap, mask));
        CleanupStack::Pop(mask);
        CleanupStack::Pop(bitmap);
        }

	// Set the grid to use different layout for landscape mode in fetcher
    iHgGrid->SetToolbarVisibility(EFalse);
    // Setting to MopParent to update background skin
    iHgGrid->SetMopParent(this);
    // Setting Selction observer for getting callback on key event change
    iHgGrid->SetSelectionObserver(*this);
    // This Displays the scrollbar at the opening of the Grid view
    iHgGrid->SetScrollBarTypeL(CHgScroller::EHgScrollerTimeStrip );
    // Enable Buffer support
    iHgGrid->EnableScrollBufferL(*this, KBufferSize, KBufferTresholdSize);
    // Enable Marking support
    iHgGrid->SetMarkingObserver(*this);

	iHgGrid->SetFocus(ETrue);
	}

// ---------------------------------------------------------------------------
// CreateGridMediaListObserverL
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::CreateGridMediaListObserverL()
    {
    iGlxGridMLObserver = CGlxGridViewMLObserver::NewL(*iMediaList, iHgGrid,
            iFilterType);
    }
    
// ---------------------------------------------------------------------------
// BufferPositionChanged
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::Request(TInt aRequestStart, TInt aRequestEnd,
        THgScrollDirection /*aDirection*/)
    {
    TRACER("CGlxFetcherContainer::Request()");
    TRAP_IGNORE(RequestL( aRequestStart, aRequestEnd ));
    }
// ---------------------------------------------------------------------------
// RequestL
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::RequestL(TInt aRequestStart, TInt aRequestEnd)
    {
    TRACER("CGlxFetcherContainer::RequestL()");
    TInt mediaCount = iMediaList->Count();

    aRequestStart = (aRequestStart<0 ? 0 : aRequestStart) ;
    aRequestEnd = (aRequestEnd>=mediaCount? (mediaCount -1): aRequestEnd);

    if (aRequestEnd - aRequestStart)
        {
        TInt visIndex = iHgGrid->FirstIndexOnScreen();
        if(visIndex >= mediaCount )
            {
            visIndex = mediaCount-1;
            }
        if(visIndex<0 || mediaCount<=0)
            {
            visIndex = 0;
            }
		
        GLX_LOG_INFO1("CGlxGridViewImp::Request - SetVisibleWindowIndex "
                "visIndex(%d)", visIndex);
        iMediaList->SetVisibleWindowIndexL(visIndex);
        }
    for (TInt i=aRequestStart; i<= aRequestEnd; i++)
        {
        SetIconsL(i);
        TInt firstIndex = iHgGrid->FirstIndexOnScreen();
        TInt lastOnScreen = firstIndex + iHgGrid->ItemsOnScreen() - 1;
        if (i >= firstIndex && i <= lastOnScreen)
            {
            GLX_LOG_INFO1("CGlxGridViewImp::Request - RefreshScreen i(%d)", i);
            iHgGrid->RefreshScreen(i);
            }
        }
    }
// ---------------------------------------------------------------------------
// SetIcons
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::SetIconsL(TInt aIndex)
    {
    TRACER("CGlxFetcherContainer::SetIconsL()");
    const TGlxMedia& item = iMediaList->Item(aIndex);
    TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail, 
            GlxFullThumbnailAttributeId( ETrue,  iGridIconSize.iWidth, 
                    iGridIconSize.iHeight ) );

    TFileName resFile(KDC_APP_BITMAP_DIR);
    resFile.Append(KGlxIconsFilename);
    TIconInfo icon;
    TInt tnError = GlxErrorManager::HasAttributeErrorL(
            item.Properties(), KGlxMediaIdThumbnail );

    const CGlxThumbnailAttribute* value = item.ThumbnailAttribute( thumbnailAttribute );
    if (value)
        {
        CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
        bitmap->Duplicate( value->iBitmap->Handle());
        iHgGrid->ItemL(aIndex).SetIcon(CGulIcon::NewL(bitmap));
        GLX_LOG_INFO1("### CGlxGridViewImp::Request value-Index is %d",aIndex);
        }
    else if (item.GetIconInfo(icon))
        {
        GLX_LOG_INFO1("CGlxGridViewImp::Request - icon(%d)", aIndex);
        CFbsBitmap* bitmap = NULL;
        CFbsBitmap* mask = NULL;
        AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,
                bitmap, mask, icon.bmpfile, icon.bitmapId, icon.maskId);
        __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));
        __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));

        AknIconUtils::SetSize(bitmap, CHgGrid::PreferredImageSize(),
                EAspectRatioPreservedAndUnusedSpaceRemoved);
        AknIconUtils::SetSize(mask, CHgGrid::PreferredImageSize(),
                EAspectRatioPreservedAndUnusedSpaceRemoved);

        iHgGrid->ItemL(aIndex).SetIcon(CGulIcon::NewL(bitmap, mask));
        CleanupStack::Pop(mask);
        CleanupStack::Pop(bitmap);
        GLX_LOG_INFO1("### CGlxGridViewImp::Request GetIconInfo-Index is %d",
                aIndex);
        }
    else if (KErrNone != tnError && KErrNotSupported != tnError)
        {
        GLX_LOG_INFO2(
                "CGlxGridViewImp::Request - image_corrupted tnError(%d), "
                    "i(%d)", tnError, aIndex);

        CFbsBitmap* bitmap = NULL;
        CFbsBitmap* mask = NULL;
        AknsUtils::CreateIconLC(AknsUtils::SkinInstance(), KAknsIIDNone,
                bitmap, mask, resFile, EMbmGlxiconsQgn_prop_image_corrupted,
                EMbmGlxiconsQgn_prop_image_corrupted_mask);
        __ASSERT_DEBUG(bitmap, Panic(EGlxPanicNullPointer));
        __ASSERT_DEBUG(mask, Panic(EGlxPanicNullPointer));

        AknIconUtils::SetSize(bitmap, CHgGrid::PreferredImageSize(),
                EAspectRatioPreservedAndUnusedSpaceRemoved);
        AknIconUtils::SetSize(mask, CHgGrid::PreferredImageSize(),
                EAspectRatioPreservedAndUnusedSpaceRemoved);

        iHgGrid->ItemL(aIndex).SetIcon(CGulIcon::NewL(bitmap, mask));
        CleanupStack::Pop(mask);
        CleanupStack::Pop(bitmap);
        }

    if (item.IsDrmProtected())
        {
        const TDesC& uri = item.Uri();
        if( uri.Length() > 0)
            {
            if(iDRMUtility->IsForwardLockedL(uri))
                {
                iHgGrid->ItemL(aIndex).SetFlags(
                        CHgItem::EHgItemFlagsDrmRightsValid);
                }
            else 
                {
                TMPXGeneralCategory  cat = item.Category();                  
                TBool checkViewRights = (cat==EMPXImage);

                if(iDRMUtility->ItemRightsValidityCheckL(uri, checkViewRights))
                    {
                    iHgGrid->ItemL(aIndex).SetFlags(
                            CHgItem::EHgItemFlagsDrmRightsValid);
                    }
                else
                    {
                    iHgGrid->ItemL(aIndex).SetFlags(
                            CHgItem::EHgItemFlagsDrmRightsExpired);
                    }
                }
            }
        }
    TTime time(0);
    if (item.GetDate(time))
        {
        iHgGrid->ItemL(aIndex).SetTime(time);
        }

    if (item.Category() == EMPXVideo)
        {
        iHgGrid->ItemL(aIndex).SetFlags(CHgItem::EHgItemFlagsVideo);
        }
    }

// ---------------------------------------------------------------------------
// Release
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::Release(TInt /*aReleaseStart*/, TInt /*aReleaseEnd*/)
    {
    TRACER("CGlxFetcherContainer::Release()");
    // This has to do nothing on default
    }

// ---------------------------------------------------------------------------
// HandleSelect
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::HandleSelectL( TInt aIndex )
    {
    TRACER("CGlxGridViewImp::HandleSelect()");
    // Make sure that the Selection Index is inside medialist count
    if (aIndex <iMediaList->Count() && aIndex >=0)
        {
        // Setting the focus of the medialist
        iMediaList->SetFocusL(NGlxListDefs::EAbsolute, aIndex);        
        }
    }

// ---------------------------------------------------------------------------
// HandleOpen
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::HandleOpenL( TInt aIndex )
    {
    TRACER("CGlxFetcherContainer::HandleOpenL()");
    GLX_LOG_INFO1("CGlxFetcherContainer::HandleOpenL(%d)", aIndex);
    
    // Make sure that the Selection Index is inside medialist count
    if (aIndex <iMediaList->Count() && aIndex >=0)
        {
        //ignore multiple tap events for single selection cases
        //if file has already been selected
        if(!iMultiSelectionEnabled && !iIsFileAttached)
	        {
	        iEventObserver.HandleDoubleTapEventL(EAknSoftkeySelect);
	        }
        }
    }

// ---------------------------------------------------------------------------
// HandleMarkingL
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::HandleMarkingL( TInt aIndex, TBool/* aMarked*/ )
    {
    TRACER("CGlxGridViewImp::HandleMarkingL()");
    HandleMultipleMarkingL(aIndex);
    iEventObserver.HandleMarkEventL();    
    }

// ---------------------------------------------------------------------------
// HandleMultipleMarkingL
// ---------------------------------------------------------------------------
//  
void CGlxFetcherContainer::HandleMultipleMarkingL(TInt aIndex )
    {
    TRACER("CGlxGridViewImp::HandleMultipleMarkingL()");
    if(iMediaList->IsSelected(aIndex))
        {
        if(iHgGrid)
            {
            if(iMultiSelectionEnabled)
	            {
	            iFetcherCommandHandler->DoExecuteL(EAknCmdUnmark, MediaList());	
	            }
            }
        }
    else
        {
        if(iHgGrid)
            {
            if(iUiUtility->IsPenSupported())
                {
                //This is required for the touch because here when we select
                //we do not get the event for mark in processcommandL 
                //of FetcherDialog. So we explicitly send the event to ourselves 
                //to mark the item.
                if (!iMultipleMarkNotStarted)
                    {
                    DoExecuteL(EAknCmdMark);
                    }
                }
            if(iMultiSelectionEnabled)
	            {
	            iFetcherCommandHandler->DoExecuteL(EAknCmdMark, MediaList());	
	            }            	
            }
        }
    }

// ---------------------------------------------------------------------------
// DoExecuteL()
// ---------------------------------------------------------------------------
TBool CGlxFetcherContainer::DoExecuteL(TInt aCommandId)
    {
    TRACER("CGlxFetcherContainer::DoExecuteL");

    TBool retVal = EFalse;
    /*
    * fix for  EBYU-7UV4MW-- when user presses selection key
    * very fast that time if hggrid is not created and we are trying to 
    * access hghgrid for marking it is giving crash. So need to chk if 
    * hggrid id created or not.same will also happen if media list is 
    * not created
    */
    if(!iHgGrid || !iMediaList)
    	{
    	return retVal;
    	}
    	
    TInt focusIndex = iMediaList->FocusIndex();
    
    switch(aCommandId)
        {
        case EAknCmdMark:
        case EAknMarkAll:
        case EGlxCmdStartMultipleMarking:
            {
            //@ fix for ELWU-7RA7NX 
            if (iMultiSelectionEnabled )
                {
                if (!iMultipleMarkNotStarted)
                	{
                	//This will start multiple marking and not mark any items
					iFetcherCommandHandler->DoExecuteL(EAknCmdMark, MediaList());
                	iMultipleMarkNotStarted = ETrue ;
                	}
	    		//@ Mark in HG Grid
				iHgGrid->Mark(focusIndex);
				iHgGrid->RefreshScreen(focusIndex);
				
                }
            retVal = ETrue;
            break;
            }
        case EAknCmdUnmark:            
        case EAknUnmarkAll:   
            {
            //@ fix for ELWU-7RA7NX 
            if (iMultiSelectionEnabled)
                {
                //@ UnMark in HG Grid
                iHgGrid->UnMark(focusIndex);
                iHgGrid->RefreshScreen(focusIndex);
                }

            if( iMediaList->SelectionCount() <= 0 )
                {
                iMultipleMarkNotStarted = EFalse;
                }            
            retVal = ETrue;
            break;
            }
        case EGlxCmdEndMultipleMarking:
            {
            iHgGrid->ClearFlags( CHgScroller::EHgScrollerSelectionMode );                
            iFetcherCommandHandler->DoExecuteL(aCommandId, MediaList());              
            } 
            retVal = ETrue;
            break;
        default:
            break;
        }    
    return retVal;
    }


// -----------------------------------------------------------------------------
// Retrieve Uris
// -----------------------------------------------------------------------------
TBool CGlxFetcherContainer::RetrieveUrisL( CDesCArray& aSelectedFiles, TBool& aFetchUri)
    {
    TRACER("CGlxFetcherContainer::RetrieveUrisL");
    // check that the medialist is really constructed
    // we can get this call while MGlxMediaList::InstanceL has not yet returned
    // as it starts a new asynch wait loop and during that it is possible 
    // to send key events to the dialog.
    if( !iMediaList || !iHgGrid )
        {
        aFetchUri = EFalse;		
        SetFileAttached(EFalse);
        return iIsFileAttached;
        }
    //To Block call to HandleDoubleTapEventL() when control is in RetrieveUrisL()    
    SetFileAttached(ETrue);
    GLX_LOG_INFO1("CGlxFetcherContainer::RetrieveUrisL() Medialist count is %d",
                iMediaList->Count());
    TGlxSelectionIterator iterator;
	CGlxAttributeContext* context = new (ELeave) CGlxAttributeContext( &iterator );
	CleanupStack::PushL( context );
	
	// Configure the context to retrieve the URI attribute
	context->AddAttributeL( KMPXMediaGeneralUri );
	
	iMediaList->AddContextL( context, KGlxFetchContextPriorityBlocking );

	// Create remover object to remove the context from the list
	// even if a leave occurs
	TGlxFetchContextRemover remover( context, *iMediaList );
	// put to cleanupstack as cleanupstack is emptied before stack objects
	// are deleted
	CleanupClosePushL( remover );
    // block until all content retrieved (shows progress note)
    TInt error = GlxAttributeRetriever::RetrieveL( *context, 
            *iMediaList, ETrue ) ;
    GLX_LOG_INFO1("CGlxFetcherContainer::RetrieveUrisL() Error %d", error);
    // context off the list
    CleanupStack::PopAndDestroy( &remover );
    GLX_LOG_INFO1("CGlxFetcherContainer::RetrieveUrisL() Medialist count after GlxAttributeRetriever is %d",
                iMediaList->Count());
    
    // if error or if medialist count is 0 then do not proceed further with the iterator.
    if (error == KErrNone && iMediaList->Count() !=0)
        {
        GLX_LOG_INFO1("CGlxFetcherContainer::RetrieveUrisL() inside loop and medialist count is %d",
                iMediaList->Count());
        // Add all selected items to client's array
        iterator.SetToFirst( iMediaList );
        TInt index = KErrNotFound;
        while ( KErrNotFound != (index = iterator++) )
            {
            const TDesC& uri = iMediaList->Item( index ).Uri();
            if( uri != KNullDesC )
                {
                aSelectedFiles.AppendL( uri );
                SetFileAttached(ETrue);
                }   
            else
                {                
                SetFileAttached(EFalse);
                }
            }
        }
    CleanupStack::PopAndDestroy( context );
    // Set the Fetch uri value as false, as it could be a drm image and calling 
    // application might not allow that to be selected, thus fetcher could be launched again.
    aFetchUri = EFalse;
	return iIsFileAttached;
    }

//-----------------------------------------------------------------------------
// CGlxFetcherContainer::OfferKeyEventL
//-----------------------------------------------------------------------------
TKeyResponse CGlxFetcherContainer::OfferKeyEventL(
        const TKeyEvent& aKeyEvent,TEventCode aType )
    {
    TRACER("CGlxFetcherContainer::OfferKeyEventL");
	return iHgGrid->OfferKeyEventL(aKeyEvent,aType);
    }
    
// ---------------------------------------------------------------------------
// SetTitleL()
// ---------------------------------------------------------------------------
void CGlxFetcherContainer::SetTitleL(const TDesC& aTitleText)
    {
    TRACER("CGlxFetcherContainer::SetTitleL");
    CEikStatusPane* statusPane = iEikonEnv->AppUiFactory()->StatusPane();
    CleanupStack::PushL(statusPane);
    CAknTitlePane* titlePane = ( CAknTitlePane* )statusPane->ControlL(
            TUid::Uid( EEikStatusPaneUidTitle ));       
    CleanupStack::PushL(titlePane);
    // To Store Title and to make sure, Previous Title is only stored once
    if (!iPreviousTitle)
        {
        iPreviousTitle = titlePane->Text()->AllocL();    
        }
    
    // Set the required Title
    titlePane->SetTextL( aTitleText );
    CleanupStack::Pop(titlePane);
    CleanupStack::Pop(statusPane);
    }

// ---------------------------------------------------------------------------
// SetPreviousTitleL()
// ---------------------------------------------------------------------------
void CGlxFetcherContainer::SetPreviousTitleL()
    {
    TRACER("CGlxFetcherContainer::SetPreviousTitleL");
    CEikStatusPane* prevStatusPane = iEikonEnv->AppUiFactory()->StatusPane();
    CleanupStack::PushL(prevStatusPane);
    CAknTitlePane* prevTitlePane = ( CAknTitlePane* )prevStatusPane->ControlL(
            TUid::Uid( EEikStatusPaneUidTitle ));       
    CleanupStack::PushL(prevTitlePane);
    
    // Restore the Title back of the Calling Application
    prevTitlePane->SetTextL( *iPreviousTitle );
    CleanupStack::Pop(prevTitlePane);
    CleanupStack::Pop(prevStatusPane);
    }

// -----------------------------------------------------------------------------
// UpdateTitle
// -----------------------------------------------------------------------------
//
void CGlxFetcherContainer::UpdateTitleL()
    {
    TRACER("CGlxFetcherContainer::UpdateTitleL");
    SetTitleL( iTitle);
    }
 
// -----------------------------------------------------------------------------
// MediaList
// -----------------------------------------------------------------------------
//
MGlxMediaList& CGlxFetcherContainer::MediaList()
    {
    TRACER("CGlxFetcherContainer::MediaList");
    return *iMediaList;
    }

// -----------------------------------------------------------------------------
// HandleSizeChange
// -----------------------------------------------------------------------------
//
void CGlxFetcherContainer::HandleSizeChangeL ( )
    {
    TRACER("CGlxFetcherContainer::HandleSizeChangeL");
    SetTitleL(iTitle);
    TRect rect;
    if(iHgGrid)
        {
        AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);
        iHgGrid->InitScreenL(rect);
        }
    if ( iBgContext )
        {
        AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EApplicationWindow, rect);
        iBgContext->SetRect( rect );
        }
    }

// -----------------------------------------------------------------------------
// MopSupplyObject
// -----------------------------------------------------------------------------
//
TTypeUid::Ptr CGlxFetcherContainer::MopSupplyObject(TTypeUid aId)
    {
    TRACER("CGlxFetcherContainer::MopSupplyObject");
    if (iBgContext)
        {
        return MAknsControlContext::SupplyMopObject(aId, iBgContext );
        }
    return CCoeControl::MopSupplyObject(aId);
    }

// -----------------------------------------------------------------------------
// SetFileAttached
// -----------------------------------------------------------------------------
//
void CGlxFetcherContainer::SetFileAttached(TBool aIsFileAttached)
    {
    iIsFileAttached = aIsFileAttached;
    }

//END OF FILE