/*
* 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:Implementation of preview thumbnail binding for the
* list view
*
*/
#include <mul/mulvisualitem.h>
#include <mglxmedialist.h>
#include <glxthumbnailcontext.h>
#include <glxfilterfactory.h> // For TGlxFilterFactory
#include <glxthumbnailattributeinfo.h>
#include "glxpreviewthumbnailbinding.h"
#include "glxuiutility.h"
#include "glxmulthumbnailvarianttype.h"
#include "glxgeneraluiutilities.h"
#include <glxtracer.h>
#include <glxlog.h>
#include <glxuistd.h> // Fetch context priority def'ns
const TInt KThumbnailStartTimeDelay(2000000);
const TInt KThumbnailIntervalTimeDelay(2000000);
const TInt KPreviewThumbnailProgressiveCount(14); // iterates from -1 to < 14 thumbnail
const TInt KPreviewThumbnailFetchCount(15); // const that is used to fetch fifteen thumbnail
// attributes
const TInt KPotraitSlot(1);
const TInt KLandscapeSlot(3);
using namespace Alf;
// ----------------------------------------------------------------------------
// NewL
// ----------------------------------------------------------------------------
//
CGlxPreviewThumbnailBinding* CGlxPreviewThumbnailBinding::NewL()
{
TRACER("CGlxPreviewThumbnailBinding::NewL");
CGlxPreviewThumbnailBinding* self = CGlxPreviewThumbnailBinding::NewLC();
CleanupStack::Pop(self);
return self;
}
// ----------------------------------------------------------------------------
// NewLC
// ----------------------------------------------------------------------------
//
CGlxPreviewThumbnailBinding* CGlxPreviewThumbnailBinding::NewLC()
{
TRACER("CGlxPreviewThumbnailBinding::NewLC");
CGlxPreviewThumbnailBinding* self = new(ELeave)CGlxPreviewThumbnailBinding;
self->ConstructL();
CleanupStack::PushL(self);
return self;
}
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
//
CGlxPreviewThumbnailBinding::CGlxPreviewThumbnailBinding()
{
}
// ----------------------------------------------------------------------------
// ConstructL
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::ConstructL()
{
TRACER("CGlxPreviewThumbnailBinding::ConstructL");
iUiUtility = CGlxUiUtility::UtilityL();
iTimer = CPeriodic::NewL( CActive::EPriorityStandard );
}
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
//
CGlxPreviewThumbnailBinding::~CGlxPreviewThumbnailBinding()
{
TRACER("CGlxPreviewThumbnailBinding::~CGlxPreviewThumbnailBinding");
// close any medialist that exist
if( iMediaList )
{
iMediaList->RemoveMediaListObserver( this );
iMediaList->RemoveContext(iThumbnailContext);
delete iThumbnailContext;
iMediaList->Close();
iMediaList = NULL;
}
if ( iUiUtility)
{
iUiUtility->Close ();
}
// cancel any outstanding request of the timer
if(iTimer->IsActive())
{
iTimer->Cancel();
}
delete iTimer;
iTimer = NULL;
iPreviewItemCount.Close();
}
// ----------------------------------------------------------------------------
// CreateThumbnail
// ----------------------------------------------------------------------------
//
std::auto_ptr< GlxThumbnailVariantType > CGlxPreviewThumbnailBinding::CreateThumbnailL( TInt aIndex )const
{
TRACER("CGlxPreviewThumbnailBinding::CreateThumbnailL");
const TGlxMedia& media = iMediaList->Item( aIndex );
return auto_ptr< GlxThumbnailVariantType >( GlxThumbnailVariantType::NewL( media,
iUiUtility->GetGridIconSize() ) );
}
// ----------------------------------------------------------------------------
// PopulateT
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::PopulateT(Alf::MulVisualItem& aItem, const TGlxMedia& aMedia,
TBool aIsFocused, TInt /*aTextureId*/ )const
{
TRACER("CGlxPreviewThumbnailBinding::PopulateT");
//T is used for throws as per C++ standard.Hence used instead of "L"
//Ignoring this for code scanner warnings - Leaving functions called in non-leaving functions.
if ( aMedia.Properties() && aIsFocused && iStartedShowingThumbnails && iProgressIndex != KErrNotFound )
{
if( !iCurrentOrientationLandscape )
{
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1,
CreateThumbnailL( MediaIndexBySlotIndex( iProgressIndex, 0 ) ).release() );
}
// if orientation is landscape
else
{
// shows thumbnials with an interval of 2 sec at different slot
if( iMediaList->Count() > iSlots && iPreviewItemCount.Count() >= iSlots && iTimerTicked )
{
GLX_LOG_INFO("inside if( iTimerTicked && iMediaList->Count() > KLandscapeSlot)");
SetThumbnailAttributeL(aItem);
}
else
{
// shows thumbnail simultaneously
GLX_LOG_INFO("inside else");
SetInitialThumbnailAttributeL(aItem, iSlots );
}
} // end of else
} // end of if
}
// ----------------------------------------------------------------------------
// SetInitialThumbnailAttribute: setting initial thumbnails to slot to show
// simutaneously
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::SetInitialThumbnailAttributeL(Alf::MulVisualItem& aItem,
TInt aSlots ) const
{
TRACER("CGlxPreviewThumbnailBinding::SetInitialThumbnailAttribute");
aSlots = Min( iPreviewItemCount.Count(),aSlots );
switch( aSlots )
{
case 1:
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1,
CreateThumbnailL( iPreviewItemCount[0] ).release() );
break;
case 2:
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon2,
CreateThumbnailL( iPreviewItemCount[0] ).release() );
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1,
CreateThumbnailL( iPreviewItemCount[1] ).release() );
break;
case 3:
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon3,
CreateThumbnailL( iPreviewItemCount[0] ).release() );
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon2,
CreateThumbnailL( iPreviewItemCount[1] ).release() );
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1,
CreateThumbnailL( iPreviewItemCount[2] ).release() );
break;
}
}
// function that sets the thumbnail to different slots
// ----------------------------------------------------------------------------
// SetThumbnailAttribute: setting thumbnial to visual item at appropriate slot
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::SetThumbnailAttributeL(Alf::MulVisualItem& aItem ) const
{
TRACER("CGlxPreviewThumbnailBinding::SetThumbnailAttribute");
switch( iSlotIndex )
{
case 0:
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon3,
CreateThumbnailL( MediaIndexBySlotIndex( iProgressIndex, iSlotIndex ) ).release() );
PreviewSlotIndex( iSlots, iSlotIndex );
break;
case 1:
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon2,
CreateThumbnailL( MediaIndexBySlotIndex( iProgressIndex, iSlotIndex ) ).release() );
PreviewSlotIndex( iSlots, iSlotIndex );
break;
case 2:
aItem.SetAttribute( Alf::mulvisualitem::KMulIcon1,
CreateThumbnailL( MediaIndexBySlotIndex( iProgressIndex, iSlotIndex ) ).release() );
PreviewSlotIndex( iSlots, iSlotIndex );
break;
}
}
// ----------------------------------------------------------------------------
// PreviewSlotIndex: returns the next index where thumbails to be shown
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::PreviewSlotIndex( TInt aSlot, TInt aSlotIndex ) const
{
TRACER("CGlxPreviewThumbnailBinding::PreviewSlotIndex");
if(aSlot > aSlotIndex + 1)
{
iSlotIndex++;
}
else
{
iSlotIndex = 0;
}
}
// ----------------------------------------------------------------------------
// MediaIndexBySlotIndex: returns the index for which to retrieve thumbnail
// ----------------------------------------------------------------------------
//
TInt CGlxPreviewThumbnailBinding::MediaIndexBySlotIndex(TInt aProgressIndex,
TInt /*aSlotIndex*/ ) const
{
TRACER("CGlxPreviewThumbnailBinding::MediaIndexBySlotIndex");
return aProgressIndex;
}
// ----------------------------------------------------------------------------
// TimerTicked: we need to update only when required i.e, when the thumbnail count
// has not reached till the max limit to be shown
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::TimerTicked()
{
TRACER("CGlxPreviewThumbnailBinding::TimerTicked");
iCurrentOrientationLandscape = GlxGeneralUiUtilities::IsLandscape();
if(iMediaList)
{
iSlots = Min( iMediaList->Count(),
iCurrentOrientationLandscape ? KLandscapeSlot : KPotraitSlot );
if( iPreviewItemCount.Count() >= iSlots && iProgressIndex < KPreviewThumbnailProgressiveCount
&& iProgressIndex < iMediaList->Count()-1)
{
iTimerTicked = ETrue;
iProgressIndex++;
Update();
}
else
{
iProgressIndex = KErrNotFound;
}
}
}
// ----------------------------------------------------------------------------
// IsTime callback function invoked when timer expires
// ----------------------------------------------------------------------------
//
TInt CGlxPreviewThumbnailBinding::IsTime( TAny* aSelf )
{
TRACER("CGlxPreviewThumbnailBinding::IsTime");
if (aSelf)
{
TRACER("CGlxPreviewThumbnailBinding::IsTime");
CGlxPreviewThumbnailBinding* self = static_cast<CGlxPreviewThumbnailBinding*>(aSelf);
if(self)
{
self->TimerTicked();
}
}
return KErrNone;
}
// ----------------------------------------------------------------------------
// HandleFocusChanged
// This function resets any existing timer and starts a new timer tick
// ----------------------------------------------------------------------------
//
CGlxBinding::TResponse CGlxPreviewThumbnailBinding::HandleFocusChanged(
TBool aIsGained)
{
TRACER("CGlxPreviewThumbnailBinding::HandleFocusChanged");
if (aIsGained && iTimer)
{
if (iTimer->IsActive())
{
iTimer->Cancel();
}
if (!iTimer->IsActive())
{
iTimer->Start(KThumbnailStartTimeDelay,
KThumbnailIntervalTimeDelay, TCallBack(IsTime, this));
}
}
return ENoUpdateNeeded;
}
// ----------------------------------------------------------------------------
// HandleItemChangedL
// This function basically closes the old medialist if any for ex. Tags,
// Captured.. and then opens a new medialist with teh required filter.
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleItemChangedL(const CMPXCollectionPath& aPath )
{
TRACER("CGlxPreviewThumbnailBinding::HandleItemChangedL");
iStartedShowingThumbnails = EFalse;
iTimerTicked = EFalse;
iProgressIndex = KErrNotFound;
iPreviewItemCount.Close();
// remove and close old medialist
if( iMediaList )
{
iMediaList->RemoveMediaListObserver( this );
iMediaList->RemoveContext(iThumbnailContext);
delete iThumbnailContext;
iMediaList->Close();
iMediaList = NULL;
}
// Filter that filters out any GIF, corrupted images
CMPXFilter* filter = NULL;
filter = TGlxFilterFactory::CreatePreviewFilterL();
CleanupStack::PushL( filter );
// create new medialist with the required filter which filters out all DRM, GIFS and corrupt
// thumbnial
iMediaList = MGlxMediaList::InstanceL( aPath ,KGlxIdNone, filter);
iThumbnailContext = CGlxThumbnailContext::NewL( &iThumbnailIterator ); // set the thumbnail context
iThumbnailIterator.SetRange( KPreviewThumbnailFetchCount ); // request for fifiteen thumbnails
iThumbnailContext->SetDefaultSpec( iUiUtility->GetGridIconSize().iWidth,iUiUtility->GetGridIconSize().iHeight );
iMediaList->AddContextL(iThumbnailContext ,KGlxFetchContextPriorityNormal );
// adding the medialist to observ any changes or updates done
iMediaList->AddMediaListObserverL(this);
CleanupStack::PopAndDestroy( filter );
}
// ----------------------------------------------------------------------------
// HasFirstThumbnail
// ----------------------------------------------------------------------------
//
TBool CGlxPreviewThumbnailBinding::HasFirstThumbnail( const RArray< TMPXAttribute >& aAttributes )
{
TRACER("CGlxPreviewThumbnailBinding::HasFirstThumbnail");
TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail,
GlxFullThumbnailAttributeId( ETrue,
iUiUtility->GetGridIconSize().iWidth,iUiUtility->GetGridIconSize().iHeight) );
TIdentityRelation< TMPXAttribute > match ( &TMPXAttribute::Match );
return ( KErrNotFound != aAttributes.Find( thumbnailAttribute, match ) );
}
// ----------------------------------------------------------------------------
// HandleItemAddedL
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleItemAddedL( TInt aStartIndex, TInt
aEndIndex, MGlxMediaList* /*aList*/ )
{
TRACER("CGlxPreviewThumbnailBinding::HandleItemAddedL");
TMPXAttribute thumbnailAttribute(KGlxMediaIdThumbnail,
GlxFullThumbnailAttributeId( ETrue, iUiUtility->GetGridIconSize().iWidth, iUiUtility->GetGridIconSize().iHeight ) );
for(TInt i = aStartIndex; i <= aEndIndex; i++)
{
const TGlxMedia& item = iMediaList->Item( i );
const CGlxThumbnailAttribute* value = item.ThumbnailAttribute( thumbnailAttribute );
if (value)
{
iPreviewItemCount.AppendL( i );
iStartedShowingThumbnails = ETrue;
iProgressIndex = 0;
}
}
if(!iTimer->IsActive() && iMediaList && iMediaList->Count())
{
GLX_LOG_INFO("CGlxPreviewThumbnailBinding::HandleItemAddedL start timer");
iTimer->Start(KErrNone, KThumbnailIntervalTimeDelay, TCallBack(IsTime,this));
}
}
// ----------------------------------------------------------------------------
// HandleItemRemoved
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleItemRemovedL( TInt /*aStartIndex*/, TInt
/*aEndIndex*/, MGlxMediaList* /*aList*/ )
{
}
// ----------------------------------------------------------------------------
// HandleAttributesAvailableL
// Inside this function we are going to append the index for which we have valid
// thumbnails and when the number of available thumbnails become equal to the
// number of slots where thumbnail to be shown we go for updating them to visual
// item.
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleAttributesAvailableL( TInt aItemIndex,
const RArray<TMPXAttribute>& aAttributes, MGlxMediaList* /*aList*/ )
{
TRACER("CGlxPreviewThumbnailBinding::HandleAttributesAvailableL");
GLX_LOG_INFO1("CGlxPreviewThumbnailBinding::HandleAttributesAvailableL aItemIndex %d ", aItemIndex);
TInt count = aAttributes.Count();
// whether orientation is landscape or portrait
iCurrentOrientationLandscape = GlxGeneralUiUtilities::IsLandscape();
// islots has number as to how many slots need to be filled
iSlots = Min( iMediaList->Count(),
iCurrentOrientationLandscape ? KLandscapeSlot : KPotraitSlot );
for(TInt i = 0; i< count; i++)
{
TMPXAttribute attribute = aAttributes[i];
}
if( !iStartedShowingThumbnails )
{
GLX_LOG_INFO(" inside if( !iStartedShowingThumbnails )");
iStartedShowingThumbnails = HasFirstThumbnail(aAttributes);
if( iStartedShowingThumbnails )
{
//if relevent thumbnial then add the index to an array
GLX_LOG_INFO("inside if( iStartedShowingThumbnails");
iStartedShowingThumbnails = EFalse;
iPreviewItemCount.AppendL( aItemIndex );
iProgressIndex++;
// checks if the number of thumbnials are ready to display
if(iPreviewItemCount.Count() == iSlots )
{
GLX_LOG_INFO("inside if(iPreviewItemCount.Count() >= iSlots && iTimerTicked )");
// update the thumbnails and set the flag iStartShowingThumbnails which willbe
// checked at the time of populating teh visual item.
iStartedShowingThumbnails = ETrue;
Update();
}// end of if(iPreviewItemCount.Count() == iSlots )
}// end of if(iStartedShowingThumbnails)
}
}
// ----------------------------------------------------------------------------
// HandleFocusChangedL
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleFocusChangedL( NGlxListDefs::
TFocusChangeType /*aType*/, TInt /*aNewIndex*/, TInt /*aOldIndex*/, MGlxMediaList* /*aList*/ )
{
TRACER("CGlxPreviewThumbnailBinding::HandleFocusChangedL");
}
// ---------- ------------------------------------------------------------------
// HandleItemSelected
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleItemSelectedL(TInt /*aIndex*/,
TBool /*aSelected*/, MGlxMediaList* /*aList*/ )
{
}
// ----------------------------------------------------------------------------
// HandleMessageL
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleMessageL( const CMPXMessage& /*aMessage*/,
MGlxMediaList* /*aList*/ )
{
}
// ----------------------------------------------------------------------------
// HandleError
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleError( TInt /*aError*/ )
{
}
// ----------------------------------------------------------------------------
// HandleCommandCompleteL
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleCommandCompleteL( CMPXCommand* /*aCommandResult*/,
TInt /*aError*/, MGlxMediaList* /*aList*/ )
{
}
// ----------------------------------------------------------------------------
// HandleMediaL
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleMediaL( TInt /*aListIndex*/, MGlxMediaList* /*aList*/ )
{
}
// ----------------------------------------------------------------------------
// HandleItemModifiedL
// ----------------------------------------------------------------------------
//
void CGlxPreviewThumbnailBinding::HandleItemModifiedL( const RArray<TInt>& /*aItemIndexes*/,
MGlxMediaList* /*aList*/ )
{
}