/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: UI level handler for category data.*
*/
// INCLUDE FILES
#include <StringLoader.h>
#include <mpxmediageneraldefs.h>
#include <mpxmedia.h>
#include <mpxmediaarray.h>
#include <ganes/HgScroller.h>
#include <ganes/HgItem.h>
#include <vcxhgmyvideos.rsg>
#include <vcxmyvideosdefs.h>
#include "IptvDebug.h"
#include "vcxhgmyvideoscategorymodelhandler.h"
#include "vcxhgmyvideosmodel.h"
#include "vcxhgmyvideoscollectionclient.h"
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::CVcxHgMyVideosCategoryModelHandler()
// -----------------------------------------------------------------------------
//
CVcxHgMyVideosCategoryModelHandler::CVcxHgMyVideosCategoryModelHandler(
CVcxHgMyVideosModel& aModel, CHgScroller& aScroller )
: iModel( aModel ),
iScroller( aScroller )
{
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::~CVcxHgMyVideosCategoryModelHandler()
// -----------------------------------------------------------------------------
//
CVcxHgMyVideosCategoryModelHandler::~CVcxHgMyVideosCategoryModelHandler()
{
delete iCategoryList;
iCategoryIdArray.Reset();
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::DoModelActivateL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::DoModelActivateL()
{
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # CVcxHgMyVideosCategoryModelHandler::DoModelActivateL() - Enter" );
iModel.CollectionClient().SetCategoryModelObserver( this );
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # CVcxHgMyVideosCategoryModelHandler::DoModelActivateL() - Exit" );
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::DoModelDeactivate()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::DoModelDeactivate()
{
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # CVcxHgMyVideosCategoryModelHandler::DoModelDeactivate() - Enter" );
iModel.CollectionClient().SetCategoryModelObserver( NULL );
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # CVcxHgMyVideosCategoryModelHandler::DoModelDeactivate() - Exit" );
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::GetCategoryListL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::GetCategoryListL()
{
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # CVcxHgMyVideosCategoryModelHandler::GetCategoryListL() - Enter" );
iModel.CollectionClient().GetCategoryListL();
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # CVcxHgMyVideosCategoryModelHandler::GetCategoryListL() - Exit" );
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::Highlight()
// -----------------------------------------------------------------------------
//
TInt CVcxHgMyVideosCategoryModelHandler::Highlight()
{
return iScroller.SelectedIndex();
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::GetCategoryNameLC()
// -----------------------------------------------------------------------------
//
HBufC* CVcxHgMyVideosCategoryModelHandler::GetCategoryNameLC( TInt aIndex )
{
HBufC* name = NULL;
switch ( aIndex )
{
case KVcxMvcCategoryIdAll:
name = StringLoader::LoadLC( R_VCXHGMYVIDEOS_STORAGE_ALL_LIST );
break;
case KVcxMvcCategoryIdDownloads:
name = StringLoader::LoadLC( R_VCXHGMYVIDEOS_STORAGE_DOWNLOADS_LIST );
break;
case KVcxMvcCategoryIdCaptured:
name = StringLoader::LoadLC( R_VCXHGMYVIDEOS_STORAGE_CAPTURED_LIST );
break;
case KVcxMvcCategoryIdOther:
name = StringLoader::LoadLC( R_VCXHGMYVIDEOS_STORAGE_OTHER_LIST );
break;
default:
{
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # GetCategoryNameLC() Unexpected category!" );
}
break;
}
return name;
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::FormatCategorySecondRowLC()
// -----------------------------------------------------------------------------
//
HBufC* CVcxHgMyVideosCategoryModelHandler::FormatCategorySecondRowLC( CMPXMedia& aMedia )
{
HBufC* details = NULL;
HBufC* newVideoName = NULL;
TInt newVideos = 0;
TInt videos = 0;
if ( aMedia.IsSupported( KVcxMediaMyVideosCategoryNewItemCount ) )
{
newVideos = *( aMedia.Value<TInt>( KVcxMediaMyVideosCategoryNewItemCount ) );
}
if ( aMedia.IsSupported( KVcxMediaMyVideosCategoryItemCount ) )
{
videos = *( aMedia.Value<TInt>( KVcxMediaMyVideosCategoryItemCount ) );
}
if ( newVideos > 0 )
{
if ( aMedia.IsSupported( KVcxMediaMyVideosCategoryNewItemName ) )
{
newVideoName = aMedia.ValueText( KVcxMediaMyVideosCategoryNewItemName ).AllocLC();
}
else
{
newVideoName = KNullDesC().AllocLC();
}
if ( newVideos == 1 )
{
details = StringLoader::LoadL( R_VCXHGMYVIDEOS_ONE_NEW_VIDEO, *newVideoName );
}
else
{
CDesCArrayFlat* arrayForStrings = new ( ELeave ) CDesCArrayFlat( 1 );
CleanupStack::PushL( arrayForStrings );
arrayForStrings->AppendL( *newVideoName );
CArrayFixFlat<TInt>* arrayForInts = new ( ELeave ) CArrayFixFlat<TInt>( 3 );
CleanupStack::PushL( arrayForInts );
arrayForInts->AppendL( newVideos );
details = StringLoader::LoadL( R_VCXHGMYVIDEOS_N_NEW_VIDEOS,
*arrayForStrings,
*arrayForInts );
CleanupStack::PopAndDestroy( arrayForInts );
CleanupStack::PopAndDestroy( arrayForStrings );
}
CleanupStack::PopAndDestroy( newVideoName );
CleanupStack::PushL( details );
}
else
{
if ( videos == 0 )
{
details = StringLoader::LoadLC( R_VCXHGMYVIDEOS_NO_VIDEOS_IN_CATEGORY );
}
else if ( videos == 1 )
{
details = StringLoader::LoadLC( R_VCXHGMYVIDEOS_ONE_VIDEO_IN_CATEGORY );
}
else
{
details = StringLoader::LoadLC( R_VCXHGMYVIDEOS_VIDEOS_IN_CATEGORY, videos );
}
}
return details;
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::UiIndexFromMpxItemId()
// -----------------------------------------------------------------------------
//
TInt CVcxHgMyVideosCategoryModelHandler::UiIndexFromMpxItemId( TMPXItemId& aMpxItemId )
{
IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # UiIndexFromMpxItemId() - Enter" );
TInt index ( KErrNotFound );
if ( iCategoryList )
{
CMPXMedia* media = NULL;
TMPXItemId mpxItemId;
for ( TInt i = 0; i < iCategoryList->Count(); i++ )
{
media = (*iCategoryList)[i];
if ( media && media->IsSupported( KMPXMediaGeneralId ) )
{
mpxItemId = *media->Value<TMPXItemId>( KMPXMediaGeneralId );
if ( mpxItemId == aMpxItemId )
{
index = ResolveCategoryArrayIndexById( i );
break;
}
}
}
}
IPTVLOGSTRING2_LOW_LEVEL( "MPX My Videos UI # UiIndexFromMpxItemId(), index = %d - Exit", index );
return index;
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::ResolveCategoryArrayIndexById()
// -----------------------------------------------------------------------------
//
TInt CVcxHgMyVideosCategoryModelHandler::ResolveCategoryArrayIndexById( TInt aCategoryId )
{
TInt ret( 0 );
for(TInt i = 0; i < iCategoryIdArray.Count(); i++ )
{
if( iCategoryIdArray[ i ] == aCategoryId )
{
ret = i;
break;
}
}
return ret;
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::NewCategoryListL()
// MPX Collection calls this callback when new category list is available.
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::NewCategoryListL(
CMPXMediaArray* aCategoryList )
{
IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # NewCategoryListL() - Enter" );
delete iCategoryList;
iCategoryList = aCategoryList;
UpdateCategoryListL();
IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # NewCategoryListL() - Exit" );
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::CategoryListModifiedL()
// MPX Collection calls this callback when the category list is modified.
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::CategoryListModifiedL()
{
IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # CategoryListModifiedL() - Enter" );
UpdateCategoryListL();
IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # CategoryListModifiedL() - Exit" );
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::CategoryModifiedL()
// MPX Collection calls this callback when single category is modified.
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::CategoryModifiedL( TMPXChangeEventType aEventType,
TMPXItemId& aMpxItemId )
{
IPTVLOGSTRING2_LOW_LEVEL(
"MPX My Videos UI # CategoryModifiedL(event=%d)", aEventType );
switch ( aEventType )
{
case EMPXItemModified:
{
TInt uiIndex = UiIndexFromMpxItemId( aMpxItemId );
UpdateCategoryListItemL( uiIndex );
iScroller.RefreshScreen( uiIndex );
}
break;
case EMPXItemInserted:
case EMPXItemDeleted:
default:
{
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # CategoryModifiedL() Unexpected event!" );
}
break;
}
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::UpdateCategoryListL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::UpdateCategoryListL()
{
IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # UpdateCategoryListL() - Enter" );
if ( iCategoryList )
{
TInt categoryCount = iCategoryList->Count();
MakeCategoryIdArray( categoryCount );
IPTVLOGSTRING2_LOW_LEVEL(
"MPX My Videos UI # UpdateCategoryListL() - count = %d", categoryCount );
if ( iCategoryIdArray.Count() != iScroller.ItemCount() )
{
iScroller.ResizeL( iCategoryIdArray.Count() );
}
if ( iCategoryIdArray.Count() > 0 )
{
for ( TInt i = 0; i < iCategoryIdArray.Count(); i++ )
{
UpdateCategoryListItemL( i );
}
if ( iScroller.SelectedIndex() < 0 ||
iScroller.SelectedIndex() >= iScroller.ItemCount() )
{
iScroller.SetSelectedIndex( 0 );
}
}
// Refresh the whole list.
iScroller.DrawDeferred();
}
IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # UpdateCategoryListL() - Exit" );
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::UpdateCategoryListItemL()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::UpdateCategoryListItemL( TInt aListIndex )
{
IPTVLOGSTRING2_LOW_LEVEL(
"MPX My Videos UI # UpdateCategoryListItemL (index=%d)", aListIndex );
if( aListIndex >= 0 &&
aListIndex < iScroller.ItemCount() &&
aListIndex < iCategoryIdArray.Count() )
{
CHgItem& listItem = iScroller.ItemL( aListIndex );
CMPXMedia* media( NULL );
media = (*iCategoryList)[ iCategoryIdArray[ aListIndex ] ];
HBufC* categoryName( NULL );
categoryName = GetCategoryNameLC( iCategoryIdArray[ aListIndex ] );
if ( categoryName && media )
{
// Insert the category name into first row of list item.
listItem.SetTitleL( *categoryName );
CleanupStack::PopAndDestroy( categoryName );
// Insert video count into second row of list item.
HBufC* secondRow( NULL );
secondRow = FormatCategorySecondRowLC( *media );
listItem.SetTextL( *secondRow );
CleanupStack::PopAndDestroy( secondRow );
}
else
{
// If category name or media was not found then
// the whole list item should be removed.
RemoveCategoryListItem( aListIndex );
}
}
IPTVLOGSTRING_LOW_LEVEL(
"MPX My Videos UI # UpdateCategoryListItemL() - Exit" );
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::RemoveCategoryListItem()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::RemoveCategoryListItem( TInt aListIndex )
{
if ( aListIndex >= 0 && aListIndex < iScroller.ItemCount() )
{
iScroller.RemoveItem( aListIndex );
}
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::ResolveCategoryId()
// -----------------------------------------------------------------------------
//
TInt CVcxHgMyVideosCategoryModelHandler::ResolveCategoryId( TInt aScrollerIndex )
{
TInt ret( -1 );
if ( aScrollerIndex <= iCategoryIdArray.Count() )
{
ret = iCategoryIdArray[ aScrollerIndex ];
}
return ret;
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::MakeCategoryIdArray()
// -----------------------------------------------------------------------------
//
void CVcxHgMyVideosCategoryModelHandler::MakeCategoryIdArray( TInt aCategoriesAvailable )
{
IPTVLOGSTRING2_LOW_LEVEL(
"MPX My Videos UI # MakeCategoryArray (number of categories=%d)", aCategoriesAvailable );
iCategoryIdArray.Reset();
for(TInt i = 0; i < aCategoriesAvailable; i++)
{
if( AcceptCategory( i ) )
{
iCategoryIdArray.Append( i );
}
}
}
// -----------------------------------------------------------------------------
// CVcxHgMyVideosCategoryModelHandler::AcceptCategory()
// -----------------------------------------------------------------------------
//
TBool CVcxHgMyVideosCategoryModelHandler::AcceptCategory( TInt aCategoryId )
{
TBool ret(EFalse);
switch ( aCategoryId )
{
case KVcxMvcCategoryIdAll:
case KVcxMvcCategoryIdDownloads:
case KVcxMvcCategoryIdCaptured:
case KVcxMvcCategoryIdOther:
IPTVLOGSTRING2_LOW_LEVEL(
"MPX My Videos UI # AcceptCategory() Accepted category: %d", aCategoryId );
ret = ETrue;
break;
default:
IPTVLOGSTRING2_LOW_LEVEL(
"MPX My Videos UI # AcceptCategory() Uknowns category: %d", aCategoryId );
break;
}
return ret;
}