* Description:  Handles collection Open operation related functionality.

*

#include "vcxmyvideosalbums.h"

#include "vcxmyvideosmdsalbums.h"

    iVideoListsBeingOpened.Reset();

    iAlbumIdsBeingOpened.Reset();

    iAlbumVideoListsBeingOpened.Reset();

    iAlbumIdsBeingOpened.Close();

    count = iAlbumVideoListsBeingOpened.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        delete iAlbumVideoListsBeingOpened[i];

        iAlbumVideoListsBeingOpened[i] = NULL; 

        }

    iAlbumVideoListsBeingOpened.Close();    

    iPath = &aPath;

    const TInt categoryLevel = 1;

    const TInt videosLevel   = 2;

    const TInt playlistLevel = 3;

        case categoryLevel:

            //we are at root level, return main level items (categories + albums)

            iCollection.AlbumsL().CreateAlbumListL(); //async

            // This is needed to update category counters.

            // Goes to queue if CreateAlbumListL command goes to execution

                MPX_DEBUG2("iCache->CreateVideoListL() left: %d. Returning categories and albums anyway.", err);

            CMPXMedia* itemList = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();

            CleanupStack::PushL( itemList );

            TVcxMyVideosCollectionUtil::AppendToListL( *itemList, *iCollection.CategoriesL().iList );

            TVcxMyVideosCollectionUtil::AppendToListL( *itemList, *iCollection.AlbumsL().iAlbumList );

            itemList->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

            iCollection.iObs->HandleOpen( itemList, KErrNone );

            CleanupStack::PopAndDestroy( itemList );

            MPX_DEBUG1("CVcxMyVideosOpenHandler:: called HandleOpen for categories + albums");

        case videosLevel:

            //we are at second level, return video list from some category or album

            TMPXItemId categoryId( aPath.Id() );

            if ( ( categoryId.iId2 == KVcxMvcMediaTypeCategory ) ||

                    ( categoryId.iId2 == KVcxMvcMediaTypeVideo ) && 

                 (categoryId.iId1 == KVcxMvcCategoryIdAll ||

                 categoryId.iId1 == KVcxMvcCategoryIdDownloads ||

                 categoryId.iId1 == KVcxMvcCategoryIdTvRecordings ||

                 categoryId.iId1 == KVcxMvcCategoryIdCaptured ||

                 categoryId.iId1 == KVcxMvcCategoryIdOther) )

                MPX_DEBUG2("CVcxMyVideosOpenHandler:: opening category %d", categoryId.iId1 );

                OpenCategoryL( categoryId.iId1 );

            else

                MPX_DEBUG2("CVcxMyVideosOpenHandler:: opening album %d", categoryId.iId1 );

                iCollection.AlbumsL().CreateAlbumListL(); //async

                iPendingAlbumOpenId = categoryId.iId1;

                if ( iCollection.AlbumsL().iAlbumListIsComplete ) 

                    HandleAlbumOpenL(); // iPendingAlbumOpenId goes to 0

                    return;

                    // We will continue at HandleAlbumOpenL when album list arrives, iPendingAlbumOpenId is left != 0

                    return;

                }            

            }

        case playlistLevel:

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

// CVcxMyVideosOpenHandler::OpenCategoryL

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

//

void CVcxMyVideosOpenHandler::OpenCategoryL( TUint32 aCategoryId )

    {

    TUint8 origin = static_cast<TUint8>( TVcxMyVideosCollectionUtil::Origin( aCategoryId ) );

    iCache.CreateVideoListL(); // Causes async call to MDS, callbacks to DoHandleCreateVideoListRespL will follow.

                               // If iCache.iVideoList is complete and can be used (correct sorting order),

                               // then nothing is done.

    if ( !iCache.iVideoListIsPartial )

        {

        MPX_DEBUG1("CVcxMyVideosOpenHandler:: videolist complete");

        // iCache.iVideoList is complete

        if ( aCategoryId == KVcxMvcCategoryIdAll )

            {

            MPX_DEBUG1("CVcxMyVideosOpenHandler:: KVcxMvcCategoryIdAll: calling HandleOpen(iCache.iVideoList)");

            iCache.iVideoList->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

            iCollection.iObs->HandleOpen( iCache.iVideoList, KErrNone );                    

            }

        else

            {

            MPX_DEBUG1("CVcxMyVideosOpenHandler:: other than KVcxMvcCategoryIdAll: creating new category video list");

            CMPXMedia* videoList = iCache.CreateVideoListByOriginL( origin );

            MPX_DEBUG1("CVcxMyVideosOpenHandler:: calling HandleOpen(new list)");

            videoList->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

            iCollection.iObs->HandleOpen( videoList, KErrNone );

            delete videoList;

            }

        iCollection.iMessageList->AddEventL( KVcxMessageMyVideosListComplete );

        iCollection.iMessageList->SendL();

        // No append events will arrive anymore -> we create our own version of the

        // video list.

        iCache.ReCreateVideoListL();

        }

    else

        {

        MPX_DEBUG1("CVcxMyVideosOpenHandler:: video list incomplete");

        // iCache.iVideoList is incomplete                

        if ( aCategoryId == KVcxMvcCategoryIdAll )

            {

            MPX_DEBUG1("CVcxMyVideosOpenHandler:: KVcxMvcCategoryIdAll, calling HandleOpen");

            iCache.iVideoList->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

            iCollection.iObs->HandleOpen( iCache.iVideoList, KErrNone  );

            }

        else

            {   

            MPX_DEBUG1("CVcxMyVideosOpenHandler:: other than KVcxMvcCategoryIdAll");

            TInt pos = iCategoryIdsBeingOpened.Find( aCategoryId );

            if ( pos == KErrNotFound )

                {

                MPX_DEBUG1("CVcxMyVideosOpenHandler:: category was not opened yet, creating list for it");

                iCategoryIdsBeingOpened.AppendL( aCategoryId ); 

                CMPXMedia* videoList = iCache.CreateVideoListByOriginL( origin );

                CleanupStack::PushL( videoList );

                iVideoListsBeingOpened.AppendL( videoList );

                CleanupStack::Pop( videoList );

                MPX_DEBUG1("CVcxMyVideosOpenHandler:: calling HandleOpen");

                iCache.iVideoList->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

                iCollection.iObs->HandleOpen( iCache.iVideoList, KErrNone  );

                }

            else

                {

                MPX_DEBUG1("CVcxMyVideosOpenHandler:: category was already being opened, calling HandleOpen with that");                        

                iVideoListsBeingOpened[pos]->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

                iCollection.iObs->HandleOpen( iVideoListsBeingOpened[pos], KErrNone  );

                }

            }

        }

    }

// New items fetched from MDS. iCollection.iCache->iVideoList = &aVideoList.

    {    

    TInt categoryCount = iCategoryIdsBeingOpened.Count();

    for ( TInt i = 0; i < categoryCount; i++ )

    // Append new items to album video lists.

    TInt albumCount = iAlbumVideoListsBeingOpened.Count();

    for ( TInt i = 0; i < albumCount; i++ )

        {

        iCollection.iAlbums->Album( iAlbumIdsBeingOpened[i] )->AppendToVideoListL(

                *aVideoList, *(iAlbumVideoListsBeingOpened[i]), aNewItemsStartIndex );

        }

        iCache.IsFetchingVideoList = EFalse;

        for ( TInt i = 0; i < categoryCount; i++ )

        for ( TInt i = 0; i < albumCount; i++ )

            {

            // Create modify event for albums.

            // This will cause client to make a new OpenL() call.

            // Also this causes collection framework to purge its possibly outdated

            // (KVcxMessageMyVideosItemsAppended events don't update collection frameworks cache) cache.

            MPX_DEBUG3("CVcxMyVideosOpenHandler:: adding modify event for album %d, extra info = %d",

                    iAlbumIdsBeingOpened[i], EVcxMyVideosVideoListOrderChanged );

            iCollection.iMessageList->AddEventL( TMPXItemId( iAlbumIdsBeingOpened[i], 2 ), EMPXItemModified,

                    EVcxMyVideosVideoListOrderChanged );

            // We dont send here, the send is at the end of this function.

            delete iAlbumVideoListsBeingOpened[i]; // we can delete our copy, client has its own copy

            iAlbumVideoListsBeingOpened[i] = NULL;

            }

        iAlbumVideoListsBeingOpened.Reset();

        iAlbumIdsBeingOpened.Reset();

        // All category, lets delete our copy and start using new one, this gives the full

        // ownership of the list to client. Video objects will continue to point to the same shared data.

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

// CVcxMyVideosOpenHandler::HandleAlbumOpenL

// Album list has been fetched already.

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

//

void CVcxMyVideosOpenHandler::HandleAlbumOpenL()

    {

    //TODO: If iVideoList is partial and fetching is already going on -> use the implementation below.

    //      If iVideoList is partial but fetching is not going on -> fetch only album items to iCache.

    MPX_DEBUG1("CVcxMyVideosOpenHandler::HandleAlbumOpenL() start");

    CVcxMyVideosAlbum* album = iCollection.AlbumsL().Album( iPendingAlbumOpenId );

    if ( album )

        {

        if ( !iCollection.iCache->iVideoListIsPartial )

            {

            //videolist complete

            CMPXMedia* videoList = album->CreateVideoListL();

            videoList->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

            iCollection.iObs->HandleOpen( videoList, KErrNone );

            delete videoList;

            iCollection.iMessageList->AddEventL( KVcxMessageMyVideosListComplete );

            iCollection.iMessageList->SendL();

            }

        else

            {

            if ( iCollection.iCache->IsFetchingVideoList )

                {

                MPX_DEBUG1("CVcxMyVideosOpenHandler:: videolist fetching already in progress -> use that to populate album");

                // videolist incomplete and fetching already going on

                TInt pos = iAlbumIdsBeingOpened.Find( iPendingAlbumOpenId );

                if ( pos == KErrNotFound )

                    {

                    //store video list for append events

                    CMPXMedia* videoList = album->CreateVideoListL();

                    CleanupStack::PushL( videoList );

                    iAlbumVideoListsBeingOpened.AppendL( videoList );

                    CleanupStack::Pop( videoList );

                    iAlbumIdsBeingOpened.AppendL( iPendingAlbumOpenId );

                    videoList->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

                    iCollection.iObs->HandleOpen( videoList, KErrNone );

                    }

                else

                    {

                    //video list already stored

                    iAlbumVideoListsBeingOpened[pos]->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

                    iCollection.iObs->HandleOpen( iAlbumVideoListsBeingOpened[pos],

                            KErrNone );

                    }

                }

            else

                {

                // videolist incomplete and fetching hasn't been started

                // TODO: Test how fast this is. If slow, then ditch the separate album fetching.

                MPX_DEBUG1("CVcxMyVideosOpenHandler:: videolist partial and no fetching going on -> fetch the album videos separately");

                delete iAlbumVideoList;

                iAlbumVideoList = NULL;

                iAlbumVideoList = TVcxMyVideosCollectionUtil::CreateEmptyMediaListL();

                iCollection.iMyVideosMdsDb->iAlbums->GetAlbumContentVideosL( iPendingAlbumOpenId,

                        *iAlbumVideoList, *this );

                return;

                }

            }

        }

    else

        {

        MPX_DEBUG2("CVcxMyVideosOpenHandler:: album ID not valid (%d) -> calling HandleOpen with KErrNotFound",

                iPendingAlbumOpenId);

        iCollection.iObs->HandleOpen( static_cast<CMPXMedia*>(NULL), KErrNotFound );

        }

    iPendingAlbumOpenId = 0;

    MPX_DEBUG1("CVcxMyVideosOpenHandler::HandleAlbumOpenL() exit");

    }

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

// CVcxMyVideosOpenHandler::HandleGetAlbumContentVideosResp

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

//

void CVcxMyVideosOpenHandler::HandleGetAlbumContentVideosResp(

        TUint32 aAlbumId, CMPXMedia& aVideoList, TInt aError,

        TInt aFirstNewItemIndex, TInt aNewItemCount, TBool aComplete )

    {

    TRAPD( err, HandleGetAlbumContentVideosRespL( aAlbumId, aVideoList, aError,

            aFirstNewItemIndex, aNewItemCount, aComplete ));

    if ( err != KErrNone )

        {

        MPX_DEBUG2("CVcxMyVideosOpenHandler:: HandleGetAlbumContentVideosRespL leaved: %d", err);

        }

    }

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

// CVcxMyVideosOpenHandler::HandleGetAlbumContentVideosRespL

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

//

void CVcxMyVideosOpenHandler::HandleGetAlbumContentVideosRespL(

        TUint32 aAlbumId, CMPXMedia& /*aVideoList*/, TInt aError,

        TInt /*aFirstNewItemIndex*/, TInt /*aNewItemCount*/, TBool aComplete )

    {

    MPX_DEBUG1("CVcxMyVideosOpenHandler::HandleGetAlbumContentVideosRespL() start");

    if ( aError != KErrNone )

        {

        MPX_DEBUG2("CVcxMyVideosOpenHandler:: error %d occured when fetching album videos", aError );        

        }

    MPX_DEBUG3("CVcxMyVideosOpenHandler:: iPendingAlbumOpenId = %d, aAlbumId = %d", iPendingAlbumOpenId, aAlbumId );

    if ( iPendingAlbumOpenId == aAlbumId )

        {

        MPX_DEBUG2("CVcxMyVideosOpenHandler:: First videos for album %d arrived, calling HandleOpen()", aAlbumId);

        iAlbumVideoList->SetCObjectValueL( KMPXMediaGeneralContainerPath, iPath );

        iCollection.iObs->HandleOpen( iAlbumVideoList, aError );

        iPendingAlbumOpenId = 0;

        }

    if ( !aComplete )

        {