/*
* 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:    Video list cache. Contains cached data from MDS.*
*/




// INCLUDE FILES
#include <mpxlog.h>
#include <mpxmedia.h>
#include <mpxmediaarray.h>
#include <mpxmediageneraldefs.h>
#include <mpxmediageneralextdefs.h>
#include <mpxmediacontainerdefs.h>
#include <vcxmyvideosdefs.h>
#include <centralrepository.h>
#include <collate.h>
#include <mpxmediavideodefs.h>
#include "vcxmyvideosvideocache.h"
#include "vcxmyvideoscollectionplugin.h"
#include "vcxmyvideosdownloadutil.h"
#include "vcxmyvideoscollectionutil.h"
#include "vcxmyvideoscategories.h"
#include "vcxmyvideosdownloadcache.h"
#include "vcxmyvideosmessagelist.h"
#include "vcxmyvideosopenhandler.h"

//       If video list fetching is going on and at the same time add/delete events
//       arrive from mds, what to do?

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

// ----------------------------------------------------------------------------
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CVcxMyVideosVideoCache* CVcxMyVideosVideoCache::NewL(
    CVcxMyVideosCollectionPlugin& aMyVideosCollectionPlugin )
    {
    MPX_FUNC("CVcxMyVideosCollectionCache::NewL");

    CVcxMyVideosVideoCache* self = new (ELeave) CVcxMyVideosVideoCache( aMyVideosCollectionPlugin );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// ----------------------------------------------------------------------------
// Destructor.
// ----------------------------------------------------------------------------
//
CVcxMyVideosVideoCache::~CVcxMyVideosVideoCache()
    {
    MPX_FUNC("CVcxMyVideosVideoCache::~CVcxMyVideosVideoCache");
    
    delete iVideoList;
    delete iDownloadCache;
    delete iCenRep;
    
    DeletePartialList();
    }

// ----------------------------------------------------------------------------
// Constructor.
// ----------------------------------------------------------------------------
//
CVcxMyVideosVideoCache::CVcxMyVideosVideoCache(
        CVcxMyVideosCollectionPlugin& aMyVideosCollectionPlugin )
: iCollection( aMyVideosCollectionPlugin )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::CVcxMyVideosVideoCache");
    }

// ----------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::ConstructL ()
    {
    MPX_FUNC("CVcxMyVideosVideoCache::ConstructL");

    iVideoList          = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();
    iVideoListIsPartial = ETrue;

    iDownloadCache = CVcxMyVideosDownloadCache::NewL();
    iPartialVideoList.Reset();
    }

// ----------------------------------------------------------------------------------------------------------
// CVcxMyVideosVideoCache::CreateVideoListByOriginL
// ----------------------------------------------------------------------------------------------------------
//
CMPXMedia* CVcxMyVideosVideoCache::CreateVideoListByOriginL( TUint8 aOrigin )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::CreateVideoListByOriginL()");
    
    CMPXMediaArray* allVideosArray = NULL;
    TInt allVideosArrayCount       = 0;

    if ( aOrigin == EVcxMyVideosOriginSideLoaded )
        {
        aOrigin = EVcxMyVideosOriginOther;
        }
            
    allVideosArray = iVideoList->Value<CMPXMediaArray>(
            KMPXMediaArrayContents);

    allVideosArrayCount = allVideosArray->Count();

    MPX_DEBUG2("CVcxMyVideosVideoCache:: iVideoList count = %d", allVideosArrayCount );
    
    CMPXMedia* filteredVideos =
            TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();
    CleanupStack::PushL( filteredVideos ); // 1->
                        
    CMPXMediaArray* filteredVideosArray = filteredVideos->Value<CMPXMediaArray>(
            KMPXMediaArrayContents );

    CMPXMedia* media = NULL;
    
    for( TInt i = 0; i < allVideosArrayCount; i++ )
        {
        media = (*allVideosArray)[i];

        TUint8 mediaOrigin = EVcxMyVideosOriginOther;

        if ( media->IsSupported( KVcxMediaMyVideosOrigin ) )
            {
            mediaOrigin = *(media->Value<TUint8>( KVcxMediaMyVideosOrigin ));
            
            if ( mediaOrigin == EVcxMyVideosOriginSideLoaded )
                {
                mediaOrigin = EVcxMyVideosOriginOther;
                }
            }
            
        if ( mediaOrigin == aOrigin )
            {
            filteredVideosArray->AppendL( *media );
            }
        }
    
    filteredVideos->SetTObjectValueL( KMPXMediaArrayCount, filteredVideosArray->Count() );
    
    CleanupStack::Pop( filteredVideos );  // <-1
    return filteredVideos;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::AppendToListL
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::AppendToListL( CMPXMedia& aToList, CMPXMedia& aFromList,
        TUint8 aOrigin, TInt aNewItemsStartIndex )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::AppendToListL()");
    
    if ( aNewItemsStartIndex < 0 )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: aNewItemsStartIndex < 0 -> skipping");
        return;
        }
        
    CMPXMediaArray* toArray = aToList.Value<CMPXMediaArray>(
            KMPXMediaArrayContents );

    CMPXMediaArray* fromArray = aFromList.Value<CMPXMediaArray>(
            KMPXMediaArrayContents );

    TInt fromCount = fromArray->Count();
    TInt origin;
    CMPXMedia* media;
    for ( TInt i = aNewItemsStartIndex; i < fromCount; i++ )
        {
        media  = fromArray->AtL( i );
        origin = TVcxMyVideosCollectionUtil::OriginL( *media );
        if ( origin == aOrigin )
            {
            toArray->AppendL( *media );
            } 
        }
    }
    
// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::FindVideoByUriL
// ----------------------------------------------------------------------------
//
CMPXMedia* CVcxMyVideosVideoCache::FindVideoByUriL( const TDesC& aUri )
    {    
    CMPXMediaArray* cachedVideoArray = iVideoList->Value<CMPXMediaArray>(
                                KMPXMediaArrayContents);

    for ( TInt i = 0; i < cachedVideoArray->Count(); i++ )
        {       
        if ( (*cachedVideoArray)[i]->ValueText( KVcxMediaMyVideosRemoteUrl ) == aUri )
            {
            return (*cachedVideoArray)[i];
            }
        }
    return NULL;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::FindVideoByMdsIdL
// ----------------------------------------------------------------------------
//
CMPXMedia* CVcxMyVideosVideoCache::FindVideoByMdsIdL( TUint32 aMdsId, TInt& aPos )
    {
    //MPX_FUNC("CVcxMyVideosVideoCache::FindVideoByMdsIdL()");
    
    //MPX_DEBUG2("CVcxMyVideosVideoCache:: looking for %d MDS ID from cache", aMdsId);
    
    aPos = KErrNotFound;
    
    if ( !iVideoList )
        {
        return NULL;
        }
        
    CMPXMediaArray* cachedVideoArray = iVideoList->Value<CMPXMediaArray>(
                                KMPXMediaArrayContents);
   
    TMPXItemId mpxItemId;
    CMPXMedia* media;
    TInt count = cachedVideoArray->Count();
    for ( TInt i = 0; i < count; i++ )
        {
        media = cachedVideoArray->AtL( i );
        if ( media->IsSupported( KMPXMediaGeneralId ))
            {
            mpxItemId = media->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
            if ( mpxItemId.iId1 == aMdsId && mpxItemId.iId2 == 0 )
                {
                MPX_DEBUG2("CVcxMyVideosVideoCache::FindVideoByMdsIdL() found %d from iVideoList", aMdsId );
                aPos = i;
                return media;
                }
            }
        }

    count = iPartialVideoList.Count();
    TMPXItemId mpxId;  
    for ( TInt i = 0; i < count; i++ )
        {
        mpxId = TVcxMyVideosCollectionUtil::IdL( *(iPartialVideoList[i]) );
        if ( aMdsId ==  mpxId.iId1 )
            {
            MPX_DEBUG2("CVcxMyVideosVideoCache::FindVideoByMdsIdL() found %d from iPartialVideoList", aMdsId );
            MPX_DEBUG1("CVcxMyVideosVideoCache::FindVideoByMdsIdL() returning the pointer and setting aPos to KErrNotFound");
            aPos = KErrNotFound; // this indicates that not found from iVideoList
            return iPartialVideoList[i];
            }       
        }

    MPX_DEBUG2("CVcxMyVideosCollectionPlugin::FindVideoByMdsIdL() MDSID %d NOT FOUND", aMdsId);
    return NULL;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::FindVideoByDownloadIdL
// ----------------------------------------------------------------------------
//
CMPXMedia* CVcxMyVideosVideoCache::FindVideoByDownloadIdL( TUint aDownloadId )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::FindVideoByDownloadIdL()");
    
    MPX_DEBUG2("CVcxMyVideosVideoCache:: looking for MPX item  with download ID %d from cache", aDownloadId);
        
    if ( aDownloadId == 0 )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: dl id == 0 -> NOT FOUND");
        return NULL;
        }
    
    if ( !iVideoList )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: iVideoList is NULL -> NOT FOUND");
        return NULL;
        }

    CMPXMedia* video = iDownloadCache->Get( aDownloadId );
    if ( video )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: found from Download Cache");
        return video;
        }

    MPX_DEBUG1("CVcxMyVideosVideoCache:: not found from Download Cache");

    CMPXMediaArray* cachedVideoArray = iVideoList->Value<CMPXMediaArray>(
                                KMPXMediaArrayContents);
              
    TUint32 downloadId;
    TInt count = cachedVideoArray->Count();
    for ( TInt i = 0; i < count; i++ )
        {
        downloadId = TVcxMyVideosCollectionUtil::DownloadIdL( *cachedVideoArray->AtL( i ) );
        if ( downloadId == aDownloadId )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: found from iVideoList");
            MPX_DEBUG1("CVcxMyVideosVideoCache:: adding to iDownloadCache");
            iDownloadCache->Add( downloadId, (*cachedVideoArray)[i] );
            return (*cachedVideoArray)[i];
            }
        }
    
    count = iPartialVideoList.Count();  
    for ( TInt i = 0; i < count; i++ )
        {
        downloadId = TVcxMyVideosCollectionUtil::DownloadIdL( *(iPartialVideoList[i]) );
        if ( downloadId ==  aDownloadId )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: found from iPartialVideoList");
            MPX_DEBUG1("CVcxMyVideosVideoCache:: adding to iDownloadCache");
            iDownloadCache->Add( downloadId, iPartialVideoList[i] );
            return iPartialVideoList[i];
            }       
        }
        
    MPX_DEBUG1("CVcxMyVideosVideoCache:: NOT FOUND");
    return NULL;
    }


// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::GetVideosL
// ----------------------------------------------------------------------------
//
CMPXMedia* CVcxMyVideosVideoCache::GetVideosL( RArray<TUint32> aMdsIds )
    {
    CMPXMessage* videoList = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();
    CleanupStack::PushL( videoList ); // 1->

    // copy from iVideoList
    TVcxMyVideosCollectionUtil::CopyFromListToListL(
            *iVideoList, *videoList, aMdsIds );

    // copy from iPartialVideoList
    TVcxMyVideosCollectionUtil::CopyFromListToListL(
            iPartialVideoList, *videoList, aMdsIds );
    
    CleanupStack::Pop( videoList ); // <-1
    return videoList;
    }
    
// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::AddVideosFromMdsL
// Called when item inserted events arrive from mds or from
// KVcxCommandMyVideosGetMediasByMpxId cmd handler.
// Synchronizing with downloads is not done here, caller must take care of it.
// If mpx item is already in cache, or MDS does not contain the item (or was not video item),
// then it is removed from aMdsIds. Ie after this function call aMdsIds contains
// only IDs which are actually added to cache.
// ----------------------------------------------------------------------------
//    
void CVcxMyVideosVideoCache::AddVideosFromMdsL( RArray<TUint32>& aMdsIds,
        TBool& aListFetchingWasCanceled )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::AddVideosFromMdsL");

    TVcxMyVideosSortingOrder sortingOrder = SortingOrderL();
  
    aListFetchingWasCanceled = EFalse;

    MPX_DEBUG2("CVcxMyVideosVideoCache:: adding %d items", aMdsIds.Count());

    for ( TInt j = aMdsIds.Count()-1; j >= 0 ; j-- )
        {
        CMPXMedia* videoToCache;
        TInt pos;
        if ( !FindVideoByMdsIdL( aMdsIds[j], pos ) )
            {
            MPX_DEBUG2("CVcxMyVideosVideoCache:: MDSID(%d) not found from cache, ok", aMdsIds[j]);
            
            if ( iCollection.iMyVideosMdsDb->iVideoListFetchingIsOngoing )
                {
                // If list fetching is not canceled, CreateVideoObjectL will leave with KErrNotReady.
                MPX_DEBUG1("CVcxMyVideosVideoCache:: video list fetching is ongoing, canceling it to be able to fetch single items!");
                iCollection.iMyVideosMdsDb->Cancel();
                aListFetchingWasCanceled = ETrue;
                }

            videoToCache = iCollection.iMyVideosMdsDb->CreateVideoL( 
                    aMdsIds[j], EFalse /* brief details */);
                                
            if ( videoToCache )
                {
                CleanupStack::PushL( videoToCache ); // 1->

                TInt err = AddL( videoToCache, sortingOrder );
                
                if ( err == KErrNone )
                    {
                    CleanupStack::Pop( videoToCache ); // <-1
                    }
                else
                    {
                    CleanupStack::PopAndDestroy( videoToCache ); // <-1
                    }
                    
                MPX_DEBUG3("CVcxMyVideosVideoCache:: %d (pointer = %x) added to cache", aMdsIds[j], videoToCache);
                }
            else
                {
                MPX_DEBUG2("CVcxMyVideosVideoCache:: video with %d ID not found from MDS -> skipping add to cache and deleting from id array", aMdsIds[j] );
                aMdsIds.Remove( j );
                }
            }
        else
            {
            MPX_DEBUG2("CVcxMyVideosVideoCache:: %d was already in cache -> skipping add, and deleting from id array", aMdsIds[j]);
            aMdsIds.Remove( j );
            }
        }

    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::AddL()
// This is for single adds, video list fetching does not call this.
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::AddL( CMPXMedia* aVideo, TVcxMyVideosSortingOrder aSortingOrder )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::AddL");
    
    if ( iVideoListIsPartial )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: iVideoList is partial, adding to iPartialVideoList");
        return AddToPartialListL( aVideo );
        }
    else
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: iVideoList is complete, adding to iVideoList");
        return AddToCorrectPlaceL( *aVideo, aSortingOrder );
        }
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::CheckForPartialVideoListItemsL()
// This is called by iCollection during video list fetching.
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::CheckForPartialVideoListItemsL( TInt aNewItemsStartIndex )
    {
    // Replace items in iVideoList with iPartialVideoList items.
    if ( !iVideoList || !iVideoList->IsSupported( KMPXMediaArrayContents ) )
        {
        return;
        }
        
    CMPXMediaArray* videoArray = iVideoList->Value<CMPXMediaArray>(
                                KMPXMediaArrayContents);
    
    TInt videoArrayCount = videoArray->Count();

    MPX_DEBUG2("  videoArrayCount           = %d", videoArrayCount);
    MPX_DEBUG2("  iPartialVideoList.Count() = %d", iPartialVideoList.Count());
    
    for ( TInt i = iPartialVideoList.Count()-1; i >= 0 ; i-- )
        {
        for ( TInt j = aNewItemsStartIndex; j < videoArrayCount; j++ )
            {
            if ( TVcxMyVideosCollectionUtil::IdL( *(iPartialVideoList[i]) )
                    == TVcxMyVideosCollectionUtil::IdL( *(videoArray->AtL( j )) ) )
                {
                // Replace item in iVideoList with item from iPartialVideoList
                MPX_DEBUG2( "CVcxMyVideosVideoCache:: replacing %d, in iVideoList with item from iPartialVideoList",
                        TVcxMyVideosCollectionUtil::IdL( *(iPartialVideoList[i]) ).iId1 );

                if ( j == videoArray->Count() -1 )
                    {
                    videoArray->Remove( j );
                    videoArray->AppendL( iPartialVideoList[i] );
                    }
                else
                    {
                    videoArray->Remove( j );
                    videoArray->Insert( iPartialVideoList[i], j );
                    }
                iPartialVideoList.Remove( i );
                iPartialVideoList.Compress();                    
                break; // found -> break from for loop
                }
            }
        }    
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::PosOnPartialVideoListL()
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::PosOnPartialVideoListL( CMPXMedia& aVideo )
    {
    TInt count    = iPartialVideoList.Count();
    TUint32 mdsId = TVcxMyVideosCollectionUtil::IdL( aVideo );
    
    for ( TInt i = 0; i < count; i++ )
        {
        if ( TVcxMyVideosCollectionUtil::IdL( *(iPartialVideoList[i]) ).iId1 == mdsId )
            {
            return i;
            }        
        }
    return KErrNotFound;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::PosOnVideoListL()
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::PosOnVideoListL( CMPXMedia& aVideo )
    {
    CMPXMediaArray* videoArray = iVideoList->Value<CMPXMediaArray>(
            KMPXMediaArrayContents);

    TInt count    = videoArray->Count();
    TUint32 mdsId = TVcxMyVideosCollectionUtil::IdL( aVideo );
    
    for ( TInt i = 0; i < count; i++ )
        {
        if ( TVcxMyVideosCollectionUtil::IdL( *(videoArray->AtL( i )) ).iId1 == mdsId )
            {
            return i;
            }        
        }
    return KErrNotFound;
    }
    
// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::AddToPartialListL()
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::AddToPartialListL( CMPXMedia* aVideo )
    {
    TInt pos = PosOnPartialVideoListL( *aVideo );
     
    TInt result;
    if ( pos == KErrNotFound )
        {
        iPartialVideoList.Append( aVideo );
        result = KErrNone;
        }
    else
        {
        result = KErrAlreadyExists;
        }
    return result;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::DeletePartialList()
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::DeletePartialList()
    {
    TInt count( iPartialVideoList.Count() );
    for ( TInt i = count -1; i >= 0; i-- )
        {
        delete iPartialVideoList[i];
        iPartialVideoList[i] = NULL;
        }
    iPartialVideoList.Close();
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::CreateVideoListL
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::CreateVideoListL( TBool aForce )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::CreateVideoListL");

    MPX_DEBUG2("CVcxMyVideosVideoCache:: aForce = %d", aForce );
    
    TVcxMyVideosSortingOrder sortingOrder = SortingOrderL();
        
    if ( iCollection.iMyVideosMdsDb->iVideoListFetchingIsOngoing
            && sortingOrder == iLastSortingOrder && !aForce )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: iVideoList creation is already ongoing, skipping");
        return;
        }
                   
    if ( iVideoListIsPartial || (sortingOrder != iLastSortingOrder) || aForce )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: iVideoList was partial or in wrong order or aForce was ETrue, recreating");

        if ( iCollection.iMyVideosMdsDb->iVideoListFetchingIsOngoing )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: video list fetching is ongoing, canceling it");
            iCollection.iMyVideosMdsDb->Cancel();
            }
        
        ResetVideoListL();
                        
        TBool ascending = ETrue;
        
        switch ( sortingOrder )
            {
            case EVcxMyVideosSortingId:
            case EVcxMyVideosSortingName:
            case EVcxMyVideosSortingSize:
                ascending = ETrue;
                break;
            case EVcxMyVideosSortingCreationDate:
            case EVcxMyVideosSortingModified:
                ascending = EFalse;
                break;
            }
            
        iCollection.iMyVideosMdsDb->CreateVideoListL( 
                sortingOrder,
                ascending,
                EFalse /* brief list */,
                iVideoList /* use existing */ );

        iLastSortingOrder   = sortingOrder;
        iVideoListIsPartial = ETrue;
        }
    else
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: iVideoList is complete and in right sorting order, doing nothing");
        }              
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::UpdateVideoL
// ----------------------------------------------------------------------------
//
TBool CVcxMyVideosVideoCache::UpdateVideoL( CMPXMedia& aVideo )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::UpdateVideoL");
    
    TInt pos;
    CMPXMedia* videoInCache = FindVideoByMdsIdL( aVideo.ValueTObjectL<TMPXItemId>(
            KMPXMediaGeneralId ).iId1, pos );
    if ( !videoInCache )
        {
        MPX_DEBUG2("CVcxMyVideosVideoCache:: MDS ID %d not found from cache, leaving",
            aVideo.ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ).iId1 );
        User::Leave( KErrNotFound );
        }

    TBool changed = EFalse;
        
    // 1 MPX ID cant be changed
    // 2 
    if ( aVideo.IsSupported( KMPXMediaGeneralTitle ) )
        {
        if ( videoInCache->ValueText( KMPXMediaGeneralTitle ) !=
                aVideo.ValueText( KMPXMediaGeneralTitle ) )
            {
            videoInCache->SetTextValueL( KMPXMediaGeneralTitle,
                    aVideo.ValueText( KMPXMediaGeneralTitle ) );

            //updates sorting order and category attributes if necessarry
            HandleVideoTitleModifiedL( videoInCache );

            changed = ETrue;
            }
        }
    // 3
    if ( aVideo.IsSupported( KMPXMediaGeneralComment ) )
        {
        if ( videoInCache->ValueText( KMPXMediaGeneralComment ) != 
                aVideo.ValueText( KMPXMediaGeneralComment ) )
            {
            videoInCache->SetTextValueL( KMPXMediaGeneralComment,
                    aVideo.ValueText( KMPXMediaGeneralComment ) );
            changed = ETrue;
            }
        }
    // 4
    if ( aVideo.IsSupported( KMPXMediaGeneralUri ) )
        {
        MPX_DEBUG2("CVcxMyVideosVideoCache:: old file path: %S", &videoInCache->ValueText( KMPXMediaGeneralUri ));
        MPX_DEBUG2("CVcxMyVideosVideoCache:: new file path: %S", &aVideo.ValueText( KMPXMediaGeneralUri ));

        if ( videoInCache->ValueText( KMPXMediaGeneralUri ) !=
               aVideo.ValueText( KMPXMediaGeneralUri ) ) 
            {
#if 0 // this should be in mds, or mds should keep title empty if it is not set by client
            TParse parse;
            HBufC* oldTitle = HBufC::NewL( videoInCache->ValueText( KMPXMediaGeneralTitle ).Length() );
            CleanupStack::PushL( oldTitle ); // 1->
            oldTitle->Des() = videoInCache->ValueText( KMPXMediaGeneralTitle );
            oldTitle->Des().LowerCase();
            
            parse.Set( videoInCache->ValueText( KMPXMediaGeneralUri ), NULL, NULL );
            MPX_DEBUG2("CVcxMyVideosVideoCache:: title generated from old file name: %S", &parse.Name());
            MPX_DEBUG2("CVcxMyVideosVideoCache:: old title (lower cased): %S", oldTitle);
            if ( parse.Name() == *oldTitle )
                {
                // filename has been used as a title -> update title also to new filename
                MPX_DEBUG1("CVcxMyVideosVideoCache:: filename has been used as a title -> changing title to new filename");
                parse.Set( aVideo.ValueText( KMPXMediaGeneralUri ), NULL, NULL );
                videoInCache->SetTextValueL( KMPXMediaGeneralTitle, parse.Name() );
                
                //updates sorting order and category attributes if necessarry
                HandleVideoTitleModifiedL( videoInCache );
                }
            CleanupStack::PopAndDestroy( oldTitle ); // <-1
#endif
            
            videoInCache->SetTextValueL( KMPXMediaGeneralUri,
                    aVideo.ValueText( KMPXMediaGeneralUri ) );
    
            changed = ETrue;
            }
        }
    // 5
	// With 64bit file support this is obsolete.
	// Can be removed if this attribute is removed from MPX framework code
    if ( aVideo.IsSupported( KMPXMediaGeneralSize ) )
        {
        if ( aVideo.ValueTObjectL<TInt>( KMPXMediaGeneralSize ) !=
                videoInCache->ValueTObjectL<TInt>( KMPXMediaGeneralSize ) )
            {
            videoInCache->SetTObjectValueL<TInt>( KMPXMediaGeneralSize,
                    aVideo.ValueTObjectL<TInt>( KMPXMediaGeneralSize ) );

#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
            TVcxMyVideosSortingOrder sortingOrder = SortingOrderL();
            if ( sortingOrder == EVcxMyVideosSortingSize )
                {
                MPX_DEBUG1("CVcxMyVideosVideoCache:: size updated && sorting order is by size, moving video to correct place on cache");
                MoveToCorrectPlaceL( *videoInCache, sortingOrder );
                videoInCache = FindVideoByMdsIdL( aVideo.ValueTObjectL<TMPXItemId>(
                        KMPXMediaGeneralId ).iId1, pos );

                iCollection.CategoriesL().GenerateCategoryModifiedEventL(
                        *videoInCache, ETrue /* flush */, EVcxMyVideosVideoListOrderChanged );
                }
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
            changed = ETrue;
            }
        }

    // 6 Creation date changes values when item is moved from one memory to another.
    //   The first the object is created to MDS with current date, and when file is added
    //   to file system the value is changed to files creation date.
    if ( aVideo.IsSupported( KMPXMediaGeneralDate ) )
        {
        TInt64 newCreationDate;
        TInt64 oldCreationDate;
        newCreationDate = aVideo.ValueTObjectL<TInt64>( KMPXMediaGeneralDate );
        oldCreationDate = videoInCache->ValueTObjectL<TInt64>( KMPXMediaGeneralDate );
        if ( newCreationDate != oldCreationDate )
            {
            videoInCache->SetTObjectValueL<TInt64>( KMPXMediaGeneralDate,
                newCreationDate );

            TVcxMyVideosSortingOrder sortingOrder = SortingOrderL();
            if ( sortingOrder == EVcxMyVideosSortingCreationDate )
                {
                MPX_DEBUG1("CVcxMyVideosVideoCache:: creation date updated && sorting order is by creation date, moving video to correct place on cache");
                MoveToCorrectPlaceL( *videoInCache, sortingOrder );
                videoInCache = FindVideoByMdsIdL( aVideo.ValueTObjectL<TMPXItemId>(
                        KMPXMediaGeneralId ).iId1, pos );

                iCollection.CategoriesL().GenerateCategoryModifiedEventL(
                        *videoInCache, ETrue /* flush */, EVcxMyVideosVideoListOrderChanged );
                }

            changed = ETrue;
            }
        }

    // 7
    if ( aVideo.IsSupported( KMPXMediaGeneralFlags ) )
        {
        TUint32 oldFlags = videoInCache->ValueTObjectL<TUint32>( KMPXMediaGeneralFlags );
        TUint32 newFlags = aVideo.ValueTObjectL<TUint32>( KMPXMediaGeneralFlags );

        MPX_DEBUG3("CVcxMyVideosVideoCache:: %x -> %x", oldFlags, newFlags);

        // Play pos is written only after playback. Reset new video flag
        // now, so there's no need for changing the flag explitically
        if ( aVideo.IsSupported( KMPXMediaGeneralLastPlaybackPosition ) )
            {
            newFlags &= ~EVcxMyVideosVideoNew;
            MPX_DEBUG3("CVcxMyVideosVideoCache:: %x -> %x", oldFlags, newFlags);
            }

        if ( oldFlags != newFlags )
            {        
            videoInCache->SetTObjectValueL<TUint32>( KMPXMediaGeneralFlags, newFlags );

            if ( (newFlags & EVcxMyVideosVideoNew) != (oldFlags & EVcxMyVideosVideoNew) )
                {
                MPX_DEBUG1("CVcxMyVideosVideoCache:: new video flag modified-> updating categories' new video names and counters");
    
                TBool modified = EFalse;
                iCollection.CategoriesL().UpdateCategoryNewVideoNameAndDateL(
                        *videoInCache, modified );
    
                iCollection.CategoriesL().NewVideoFlagChangedL(
                        oldFlags, newFlags,
                        videoInCache->ValueTObjectL<TUint8>( KVcxMediaMyVideosOrigin ),
                        modified );
                
                if ( !(newFlags & EVcxMyVideosVideoNew) && 
                        TVcxMyVideosCollectionUtil::OriginL( *videoInCache ) == EVcxMyVideosOriginDownloaded )
                    {
                    MPX_DEBUG1("CVcxMyVideosVideoCache::UpdateVideoL - Count of new videos in Downloaded origin has decreased, sending mediator event to notification launcher");                   
                    iCollection.NotifyNewVideosCountDecreasedL( *videoInCache );
                    }
                }
            changed = ETrue;
            }
        }
    // 8
    if ( aVideo.IsSupported( KMPXMediaGeneralCopyright ) )
        {
        if ( videoInCache->ValueText( KMPXMediaGeneralCopyright ) !=
                aVideo.ValueText( KMPXMediaGeneralCopyright ) )
            {
            videoInCache->SetTextValueL( KMPXMediaGeneralCopyright,
                    aVideo.ValueText( KMPXMediaGeneralCopyright ) );
            changed = ETrue;
            }
        }
#if 0 // type cant be changed
    // 9
    if ( aVideo.IsSupported( KMPXMediaGeneralMimeType ) )
        {
        videoInCache->SetTextValueL( aVideo.ValueText( KMPXMediaGeneralMimeType ) );
        changed = ETrue;
        }
#endif

    // 11
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
    if ( aVideo.IsSupported( KMPXMediaGeneralExtSizeInt64 ) )
        {
        if ( aVideo.ValueTObjectL<TInt64>( KMPXMediaGeneralExtSizeInt64 ) !=
                videoInCache->ValueTObjectL<TInt64>( KMPXMediaGeneralExtSizeInt64 ) )
            {
            videoInCache->SetTObjectValueL<TInt64>( KMPXMediaGeneralExtSizeInt64,
                    aVideo.ValueTObjectL<TInt64>( KMPXMediaGeneralExtSizeInt64 ) );

            TVcxMyVideosSortingOrder sortingOrder = SortingOrderL();
            if ( sortingOrder == EVcxMyVideosSortingSize )
                {
                MPX_DEBUG1("CVcxMyVideosVideoCache:: size updated && sorting order is by size, moving video to correct place on cache");
                MoveToCorrectPlaceL( *videoInCache, sortingOrder );
                videoInCache = FindVideoByMdsIdL( aVideo.ValueTObjectL<TMPXItemId>(
                        KMPXMediaGeneralId ).iId1, pos );

                iCollection.CategoriesL().GenerateCategoryModifiedEventL(
                        *videoInCache, ETrue /* flush */, EVcxMyVideosVideoListOrderChanged );
                }
            changed = ETrue;
            }
        }
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    // 12
    if ( aVideo.IsSupported( KVcxMediaMyVideosModifiedDate ) )
        {
        if ( videoInCache->ValueTObjectL<TInt64>( KVcxMediaMyVideosModifiedDate ) !=
                aVideo.ValueTObjectL<TInt64>( KVcxMediaMyVideosModifiedDate ) )
            {
            videoInCache->SetTObjectValueL<TInt64>( KVcxMediaMyVideosModifiedDate,
                    aVideo.ValueTObjectL<TInt64>( KVcxMediaMyVideosModifiedDate ) );
            changed = ETrue;
            }
        }
    // 13
    if ( aVideo.IsSupported( KVcxMediaMyVideosAgeProfile ) )
        {
        if ( videoInCache->ValueTObjectL<TInt32>( KVcxMediaMyVideosAgeProfile ) != 
                aVideo.ValueTObjectL<TInt32>( KVcxMediaMyVideosAgeProfile ) )
            {
            videoInCache->SetTObjectValueL<TInt32>( KVcxMediaMyVideosAgeProfile,
                    aVideo.ValueTObjectL<TInt32>( KVcxMediaMyVideosAgeProfile ) );
            changed = ETrue;
            }
        }
    // 14
    if ( aVideo.IsSupported( KVcxMediaMyVideosAudioLanguage ) )
        {
        if ( videoInCache->ValueText( KVcxMediaMyVideosAudioLanguage ) != 
                aVideo.ValueText( KVcxMediaMyVideosAudioLanguage ) )
            {
            videoInCache->SetTextValueL( KVcxMediaMyVideosAudioLanguage,
                    aVideo.ValueText( KVcxMediaMyVideosAudioLanguage ) );
            changed = ETrue;
            }
        }
    // 15
    if ( aVideo.IsSupported( KVcxMediaMyVideosAuthor ) )
        {
        if ( videoInCache->ValueText( KVcxMediaMyVideosAuthor ) !=
                aVideo.ValueText( KVcxMediaMyVideosAuthor ))
            {
            videoInCache->SetTextValueL( KVcxMediaMyVideosAuthor,
                    aVideo.ValueText( KVcxMediaMyVideosAuthor ) );
            changed = ETrue;
            }
        }

    // 16
    if ( aVideo.IsSupported( KVcxMediaMyVideosOrigin ) )
        {
        TUint8 prevOrigin( TVcxMyVideosCollectionUtil::OriginL( *videoInCache ) );
        TUint8 newOrigin( TVcxMyVideosCollectionUtil::OriginL( aVideo ) );
                    
        if ( newOrigin != prevOrigin )
            {
            videoInCache->SetTObjectValueL<TUint8>( KVcxMediaMyVideosOrigin, newOrigin );
            iCollection.CategoriesL().OriginChangedL( *videoInCache, prevOrigin, newOrigin );            
            changed = ETrue;
            }
        }

    // 17
    if ( aVideo.IsSupported( KVcxMediaMyVideosDuration ) )
        {
        TReal32 durationInCache = TVcxMyVideosCollectionUtil::DurationL( *videoInCache );
        TReal32 newDuration     = TVcxMyVideosCollectionUtil::DurationL( aVideo );
        
        MPX_DEBUG2("SETTING DURATION TO: %f", newDuration );
        
        if ( durationInCache != newDuration )
            {
            videoInCache->SetTObjectValueL<TReal32>( KVcxMediaMyVideosDuration, newDuration );
            changed = ETrue;
            }
        }
    // 10
    if ( aVideo.IsSupported( KMPXMediaGeneralLastPlaybackPosition ) )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache::UpdateVideo Last play pos is supported");
        
        if ( videoInCache->ValueTObjectL<TInt>( KMPXMediaGeneralLastPlaybackPosition ) !=
                aVideo.ValueTObjectL<TInt>( KMPXMediaGeneralLastPlaybackPosition ))
            {
            videoInCache->SetTObjectValueL<TInt>( KMPXMediaGeneralLastPlaybackPosition,
                    aVideo.ValueTObjectL<TInt>( KMPXMediaGeneralLastPlaybackPosition ) );
            changed = ETrue;
            }
        }
    // 18
    if ( aVideo.IsSupported( KVcxMediaMyVideosDownloadId ) )
        {
        TUint32 downloadIdInCache( TVcxMyVideosCollectionUtil::DownloadIdL( *videoInCache ) );
        TUint32 downloadIdInNew( TVcxMyVideosCollectionUtil::DownloadIdL( aVideo ) );
        if (  downloadIdInNew != downloadIdInCache )
            {
            videoInCache->SetTObjectValueL<TUint32>( KVcxMediaMyVideosDownloadId,
                    downloadIdInNew );

            if ( downloadIdInNew == 0 )
                {
                iDownloadCache->Delete( videoInCache );
                }
            changed = ETrue;
            }
        }
    // 19
    if ( aVideo.IsSupported( KVcxMediaMyVideosRating ) )
        {
        TUint8 ratingInCache( TVcxMyVideosCollectionUtil::RatingL( *videoInCache ) );
        TUint8 ratingInNew( TVcxMyVideosCollectionUtil::RatingL( aVideo ) );
        if (  ratingInNew != ratingInCache )
            {
            videoInCache->SetTObjectValueL<TUint32>( KVcxMediaMyVideosRating,
                    ratingInNew );

            changed = ETrue;
            }
        }

    // 20
    if ( aVideo.IsSupported( KMPXMediaVideoBitRate ) )
        {
        TUint16 bitRate = aVideo.ValueTObjectL<TUint16>( KMPXMediaVideoBitRate ); 
        if ( bitRate != videoInCache->ValueTObjectL<TUint16>( KMPXMediaVideoBitRate ) )
            {
            videoInCache->SetTObjectValueL<TUint16>( KMPXMediaVideoBitRate,
                                                     bitRate );
            
            changed = ETrue;
            }
        }

    // 21
    if ( aVideo.IsSupported( KVcxMediaMyVideosAudioFourCc ) )
        {
        TUint32 AudioFourCcInCache( TVcxMyVideosCollectionUtil::DownloadIdL( *videoInCache ) );
        TUint32 AudioFourCcInNew( TVcxMyVideosCollectionUtil::AudioFourCcL( aVideo ) );
        if (  AudioFourCcInNew != AudioFourCcInCache )
            {
            videoInCache->SetTObjectValueL<TUint32>( KVcxMediaMyVideosAudioFourCc,
                    AudioFourCcInNew );

            if ( AudioFourCcInNew == 0 )
                {
                iDownloadCache->Delete( videoInCache );
                }
            changed = ETrue;
            }
        }

    // 22
    if ( aVideo.IsSupported( KMPXMediaVideoWidth ) )
        {
        TUint16 width = aVideo.ValueTObjectL<TUint16>( KMPXMediaVideoWidth ); 
        if ( width != videoInCache->ValueTObjectL<TUint16>( KMPXMediaVideoWidth ) )
            {
            videoInCache->SetTObjectValueL<TUint16>( KMPXMediaVideoWidth,
                    width );
            
            changed = ETrue;
            }
        }
    
    // 23
    if ( aVideo.IsSupported( KMPXMediaVideoHeight ) )
        {
        TUint16 height = aVideo.ValueTObjectL<TUint16>( KMPXMediaVideoHeight ); 
        if ( height != videoInCache->ValueTObjectL<TUint16>( KMPXMediaVideoHeight ) )
            {
            videoInCache->SetTObjectValueL<TUint16>( KMPXMediaVideoHeight,
                    height );
            
            changed = ETrue;
            }
        }
                
    // 24 
    if ( aVideo.IsSupported( KMPXMediaVideoArtist ) )
        {
        if ( videoInCache->ValueText( KMPXMediaVideoArtist ) !=
                aVideo.ValueText( KMPXMediaVideoArtist ) )
            {
            videoInCache->SetTextValueL( KMPXMediaVideoArtist,
                    aVideo.ValueText( KMPXMediaVideoArtist ) );

            changed = ETrue;
            }
        }
        
    return changed;    
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::HandleVideoTitleModifiedL
// Updates sorting order and category attributes if necessarry
// NOTICE that aVideoInCache is not allowed to own the media object, since this
// function may change the pointer value to point to a new object.
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::HandleVideoTitleModifiedL( CMPXMedia*& aVideoInCache )
    {
    MPX_DEBUG1("CVcxMyVideosVideoCache:: video title in cache modified");
    MPX_DEBUG1("                         -> updating categories new video names");

    TBool modified = EFalse;
    iCollection.CategoriesL().UpdateCategoryNewVideoNameAndDateL(
            *aVideoInCache, modified );

    TVcxMyVideosSortingOrder sortingOrder = SortingOrderL();
    if ( sortingOrder == EVcxMyVideosSortingName )
        {
        MPX_DEBUG1(" Title modified and sorting by Name -> moving item to correct place");
        
        TMPXItemId mpxId( aVideoInCache->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );
        
        // Deletes the old media object and creates a new one to a new position
        MoveToCorrectPlaceL( *aVideoInCache, SortingOrderL() );
        // Find the new object
        TInt pos;
        aVideoInCache = FindVideoByMdsIdL( mpxId.iId1, pos );
        
        iCollection.CategoriesL().GenerateCategoryModifiedEventL(
                *aVideoInCache, ETrue /* flush */, EVcxMyVideosVideoListOrderChanged );
        }
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::FindCorrectPositionL
// Finds the correct position using bisection method.
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::FindCorrectPositionL( CMPXMedia& aMedia,
        TVcxMyVideosSortingOrder aSortingOrder )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::FindCorrectPositionL()");
            
    CMPXMediaArray* cachedVideoArray = iVideoList->Value<CMPXMediaArray>(
                                KMPXMediaArrayContents);

    TInt videoCount = cachedVideoArray->Count();

    MPX_DEBUG2("CVcxMyVideosVideoCache:: video count = %d", videoCount);

    if ( videoCount == 0 )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: video count was 0, returning pos 0");
        return 0;
        }
        
    TInt stepSize     = 0;
    TInt upLimit      = videoCount - 1; //highest possible place
    TInt downLimit    = 0;              //lowest possible place
    TInt pos          = videoCount / 2; // start from the middle
    
    if ( videoCount > 5 )
        {
        stepSize = videoCount / 4; // we start at middle, the first step size is half of the middle = 1/4
        MPX_DEBUG2("CVcxMyVideosVideoCache:: stepsize: %d", stepSize);
        }
    else
        {
        stepSize = 1;
        MPX_DEBUG1("CVcxMyVideosVideoCache:: Moving with single steps.");
        MPX_DEBUG2("CVcxMyVideosVideoCache:: stepsize: %d", stepSize);

        if ( videoCount == 1 )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: only one video -> stepSize = 0");
            pos      = 0;
            stepSize = 0;
            }
        }
    
    MPX_DEBUG2("CVcxMyVideosVideoCache:: start pos = %d", pos);

    TBool found = EFalse;
    TInt compare;
    while ( !found )
        {
        compare = CompareL( aMedia, *cachedVideoArray->AtL( pos ), aSortingOrder ); 
        if ( compare == 0 )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: equal item found");
            found = ETrue;
            break;
            }            
        else if ( compare == 1 )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: greater item found");
            upLimit = pos - 1;
            if ( upLimit < 0 )
                {
                upLimit = 0;
                }
            if ( upLimit < downLimit )
                {
                upLimit = downLimit;
                }
            pos -= stepSize;
            if ( pos < downLimit )
                {
                pos += stepSize;
                MPX_DEBUG1("CVcxMyVideosVideoCache:: hit the limiter");
                }
            }
        else if ( compare == -1 )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: smaller item found");
            downLimit = pos + 1;
            if ( downLimit > videoCount - 1 )
                {
                downLimit = videoCount - 1;
                }
            if ( downLimit > upLimit )
                {
                downLimit = upLimit;
                }
            pos += stepSize;
            if ( pos > upLimit )
                {
                pos -= stepSize;
                MPX_DEBUG1("CVcxMyVideosVideoCache:: hit the limiter");
                }
            }
        MPX_DEBUG3("CVcxMyVideosVideoCache:: item is between: %d - %d", downLimit, upLimit );            
        MPX_DEBUG2("CVcxMyVideosVideoCache:: new pos = %d", pos);
        
        if ( downLimit == upLimit )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: downLimit and upLimit are the same, this is last item to check");
            compare = CompareL( aMedia, *cachedVideoArray->AtL( pos ), aSortingOrder ); 

            if ( compare == 1 )
                {
                MPX_DEBUG1("CVcxMyVideosVideoCache:: the last possible item had greater value -> this is the correct place");
                }
            else
                {
                MPX_DEBUG1("CVcxMyVideosVideoCache:: last possible item had smaller value (or equal) -> adding one to pos");
                pos++;
                }
            found = ETrue;
            break;
            }

        stepSize = (upLimit - downLimit) / 4;
        MPX_DEBUG2("CVcxMyVideosVideoCache:: stepsize: %d", stepSize);
            
        if ( stepSize < 1 )
            {
            MPX_DEBUG1("CVcxMyVideosVideoCache:: Moving with single steps.");
            stepSize = 1;
            MPX_DEBUG2("CVcxMyVideosVideoCache:: stepsize: %d", stepSize);
            }

        MPX_DEBUG1("CVcxMyVideosVideoCache:: ---- new round ----");
        }        
    MPX_DEBUG2("CVcxMyVideosVideoCache:: returning pos %d", pos);
    return pos;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::CompareL
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::CompareL( CMPXMedia& aNewVideo, CMPXMedia& aVideoInList,
        TVcxMyVideosSortingOrder aSortingOrder )
    {
    TInt result = 0;
    
    switch ( aSortingOrder )
        {
        case EVcxMyVideosSortingCreationDate:
            {
            TInt64 newItemsDate  = aNewVideo.ValueTObjectL<TInt64>( KMPXMediaGeneralDate );
            TInt64 listItemsDate = aVideoInList.ValueTObjectL<TInt64>( KMPXMediaGeneralDate );
            MPX_DEBUG3("CVcxMyVideosVideoCache:: new date = %d, list item date = %d", newItemsDate, listItemsDate);
            if ( listItemsDate > newItemsDate /*static_cast<TInt64>(listItemsDate) > static_cast<TInt64>(newItemsDate)*/ )
                {
                result = -1;
                }
            else
                {
                if ( listItemsDate == newItemsDate/*static_cast<TInt64>(listItemsDate) == static_cast<TInt64>(newItemsDate)*/ )
                    {
                    result = 0;
                    }
                else
                    {
                    result = 1;
                    }
                }
            }              
            break;
            
        case EVcxMyVideosSortingName:
            {
            TPtrC newVideoName( aNewVideo.ValueText( KMPXMediaGeneralTitle ) );
            TPtrC videoInListName( aVideoInList.ValueText( KMPXMediaGeneralTitle ));
            MPX_DEBUG3("CVcxMyVideosVideoCache:: newVideoName = %S, videoInListName = %S", &newVideoName, &videoInListName);
            TCollationMethod collationMethod = *Mem::CollationMethodByIndex(0); // get the standard method
            collationMethod.iFlags |= TCollationMethod::EFoldCase;
            result = newVideoName.CompareC( videoInListName, 3, &collationMethod) * -1;
            if ( result < 0 )
                {
                result = -1;
                }
            if ( result > 0 )
                {
                result = 1;
                }
            }
            break;
            
        case EVcxMyVideosSortingSize:
            {
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
            TInt64 newItemsSize  = aNewVideo.ValueTObjectL<TInt64>( KMPXMediaGeneralExtSizeInt64 );
            TInt64 listItemsSize = aVideoInList.ValueTObjectL<TInt64>( KMPXMediaGeneralExtSizeInt64 );
#else
            TInt newItemsSize  = aNewVideo.ValueTObjectL<TInt>( KMPXMediaGeneralSize );
            TInt listItemsSize = aVideoInList.ValueTObjectL<TInt>( KMPXMediaGeneralSize );
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
            MPX_DEBUG3("CVcxMyVideosVideoCache:: newItemsSize = %ld, listItemsSize = %ld", newItemsSize, listItemsSize);
            if ( listItemsSize > newItemsSize )
                {
                result = 1;
                }
            else
                {
                if ( listItemsSize == newItemsSize )
                    {
                    result = 0;
                    }
                else
                    {
                    result = -1;
                    }
                }
            }              
            break;
        }
        
    return result;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::SortingOrderL
// ----------------------------------------------------------------------------
//    
TVcxMyVideosSortingOrder CVcxMyVideosVideoCache::SortingOrderL()
    {

    if( !iCenRep ) 
        {
        TUid uid;
        uid.iUid = KVcxMyVideosCollectionCenrepUid;
		iCenRep = CRepository::NewL( uid );
        }
    
    TInt sortingOrderInCenrep;

    TInt cenRepError = iCenRep->Get( KVcxMyVideosCollectionCenrepKeySortingOrder,
            sortingOrderInCenrep );
    
    TVcxMyVideosSortingOrder sortingOrder;
    
    if ( cenRepError != KErrNone )
        {
        MPX_DEBUG2("CVcxMyVideosVideoCache:: error %d while reading sorting order from Cenrep", cenRepError );
        sortingOrder = EVcxMyVideosSortingCreationDate;
        }
    else
        {
        sortingOrder = static_cast<TVcxMyVideosSortingOrder>( sortingOrderInCenrep );
        }
    return sortingOrder;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::AddToCorrectPlaceL
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::AddToCorrectPlaceL( CMPXMedia& aVideo,
        TVcxMyVideosSortingOrder aSortingOrder, TBool aUpdateCategories )
    {    
    if ( PosOnVideoListL( aVideo ) != KErrNotFound )
        {
        MPX_DEBUG2( "CVcxMyVideosVideoCache::AddToCorrectPlaceL() %d is already on iVideoList, skipping add",
                TVcxMyVideosCollectionUtil::IdL( aVideo ).iId1 );
        return KErrAlreadyExists;
        }
        
    TInt pos = FindCorrectPositionL( aVideo, aSortingOrder );

    CMPXMediaArray* cachedVideoArray = NULL;            
    cachedVideoArray = iVideoList->Value<CMPXMediaArray>(
            KMPXMediaArrayContents );

    if ( pos > (cachedVideoArray->Count() -1) )
        {
        cachedVideoArray->AppendL( aVideo );                    
        }
    else
        {
        cachedVideoArray->InsertL( aVideo, pos );
        }
        
    if ( aUpdateCategories )
        {
        iCollection.CategoriesL().VideoAddedL( aVideo );
        }

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::MoveToCorrectPlaceL
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::MoveToCorrectPlaceL( CMPXMedia& aVideo,
        TVcxMyVideosSortingOrder aSortingOrder )
    {
    if ( PosOnPartialVideoListL( aVideo ) != KErrNotFound )
        {
        MPX_DEBUG2("CVcxMyVideosVideoCache::MoveToCorrectPlaceL() item %d was on iPartialVideoList, not moving ",
                TVcxMyVideosCollectionUtil::IdL( aVideo ).iId1);
        return;
        }
        
    CMPXMedia* video = CMPXMedia::NewL( aVideo );
    CleanupStack::PushL( video ); // 1->
    RemoveL( *video, EFalse /* dont update categories */ );
    AddToCorrectPlaceL( *video, aSortingOrder, EFalse /* dont update categories */ );
    CleanupStack::PopAndDestroy( video ); // <-1
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::RemoveL
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::RemoveL( CMPXMedia& aVideo, TBool aUpdateCategories )
    {
    return RemoveL( TVcxMyVideosCollectionUtil::IdL( aVideo ).iId1, aUpdateCategories );
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::RemoveL
// ----------------------------------------------------------------------------
//
TInt CVcxMyVideosVideoCache::RemoveL( TUint32 aMdsId, TBool aUpdateCategories )
    {
    MPX_FUNC("CVcxMyVideosVideoCache::RemoveL");
    
    TInt pos;
    CMPXMedia* video = FindVideoByMdsIdL( aMdsId, pos );

    if ( !video )
        {
        MPX_DEBUG1("CVcxMyVideosVideoCache:: RemoveL failed since the item wasn't on cache");
        return KErrNotFound;
        }

    iDownloadCache->Delete( video );

    TUint32 flags( 0 );
	if ( video->IsSupported( KMPXMediaGeneralFlags ) )
	    {
		flags = video->ValueTObjectL<TUint32>( KMPXMediaGeneralFlags );
		}
    
    if ( ( flags & EVcxMyVideosVideoNew ) && 
            TVcxMyVideosCollectionUtil::OriginL( *video ) == EVcxMyVideosOriginDownloaded )
        {       
        MPX_DEBUG1("CVcxMyVideosVideoCache::RemoveL - New video has been removed from Downloaded origin -> sending mediator event to notification launcher");
        iCollection.NotifyNewVideosCountDecreasedL( *video );
        }
    
    if ( aUpdateCategories &&
            pos != KErrNotFound /* no need to update if item is on iPartialVideoList*/ )
        {
        iCollection.CategoriesL().VideoRemovedL( *video );
        }
        
    if ( pos != KErrNotFound )
        {
        CMPXMediaArray* cachedVideoArray = iVideoList->Value<CMPXMediaArray>(
                KMPXMediaArrayContents );
        
        MPX_DEBUG2("CVcxMyVideosVideoCache:: %d removed from iVideoList", aMdsId);
        cachedVideoArray->Remove( pos );
        }
    else
        {
        MPX_DEBUG2("CVcxMyVideosVideoCache:: %d removed from iPartialVideoList", aMdsId);
        iPartialVideoList.Remove( PosOnPartialVideoListL( *video ) );
        iPartialVideoList.Compress();        
        }
        
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::RemoveL
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::RemoveL( RArray<TUint32>& aMdsIds, TBool aUpdateCategories )
    {        
    for ( TInt i = 0; i < aMdsIds.Count(); i++ )
        {
        RemoveL( aMdsIds[i], aUpdateCategories );
        }
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::ResetVideoListL
// iVideoList stays the same, media array is deleted and recreated to 0 length,
// media items are deleted.
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::ResetVideoListL()
    {
    MPX_FUNC("CVcxMyVideosVideoCache::ResetVideoListL");

    iCollection.iMyVideosMdsDb->Cancel();

    CMPXMediaArray* mediaArray =
            iVideoList->ValueCObjectL<CMPXMediaArray>( KMPXMediaArrayContents );
    CleanupStack::PushL( mediaArray ); // 1->
    
    for ( TInt i = mediaArray->Count() - 1; i >= 0; i-- )
        {
        mediaArray->Remove( i );
        }        

    iVideoList->Delete( KMPXMediaArrayContents );
    iVideoList->SetCObjectValueL<CMPXMediaArray>( KMPXMediaArrayContents, mediaArray );

    CleanupStack::PopAndDestroy( mediaArray ); // <-1
    
    TInt count = iCollection.iOpenHandler->iVideoListsBeingOpened.Count();
    
    for ( TInt i = 0; i < count; i++ )
        {
        CMPXMedia* videoList = iCollection.iOpenHandler->iVideoListsBeingOpened[i];
        if ( videoList )
            {
            MPX_DEBUG3("CVcxMyVideosVideoCache:: reset iVideoListsBeingOpened[%d] category: %d",
                    i, iCollection.iOpenHandler->iCategoryIdsBeingOpened[i] );
            mediaArray = videoList->ValueCObjectL<CMPXMediaArray>( KMPXMediaArrayContents );
            CleanupStack::PushL( mediaArray ); // 1->
            for ( TInt i = mediaArray->Count() - 1; i >= 0; i-- )
                {
                mediaArray->Remove( i );
                }
            videoList->Delete( KMPXMediaArrayContents );
            videoList->SetCObjectValueL<CMPXMediaArray>( KMPXMediaArrayContents,
                    mediaArray );
            CleanupStack::PopAndDestroy( mediaArray ); // <-1
            }
        }
        
    iVideoListIsPartial = ETrue;

    delete iDownloadCache;
    iDownloadCache = NULL;
    iDownloadCache = CVcxMyVideosDownloadCache::NewL();
                
    iCollection.CategoriesL().ResetVideoCountersL(); //this does not send events
    }

// ----------------------------------------------------------------------------
// CVcxMyVideosVideoCache::ReCreateVideoListL
// iVideoList and its media array are deleted and recreated. New instances point to
// different global heap position. Media objects stay the same and point to
// same global heap.
// ----------------------------------------------------------------------------
//
void CVcxMyVideosVideoCache::ReCreateVideoListL()
    {
    MPX_FUNC("CVcxMyVideosVideoCache::ReCreateVideoListL");
    
    CMPXMedia* newList = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();
    CleanupStack::PushL( newList ); // 1->

    CMPXMediaArray* oldArray = iVideoList->Value<CMPXMediaArray>(
            KMPXMediaArrayContents );
    TInt count = oldArray->Count();

    CMPXMediaArray* newArray = newList->Value<CMPXMediaArray>(
            KMPXMediaArrayContents );
    
    CMPXMedia* video;
    for ( TInt i = 0; i < count; i++ )
        {
        video = CMPXMedia::NewL( *oldArray->AtL( i ) ); // points to same heap object
        CleanupStack::PushL( video ); // 2->
        newArray->AppendL( video ); // ownership moves
        CleanupStack::Pop( video ); // <-2
        }
    
    delete iVideoList;
    iVideoList = NULL;
    iVideoList = newList;
    CleanupStack::Pop( newList ); // <-1

    delete iDownloadCache;
    iDownloadCache = NULL;
    iDownloadCache = CVcxMyVideosDownloadCache::NewL();
    }
// End of file

