--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tsrc/VCXTestMyVideosCollectionClient/src/VCXTestMyVideosCollectionClient.cpp Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,1397 @@
+/*
+* Copyright (c) 2009 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:
+*
+*/
+
+
+// INCLUDES
+#include "VCXTestMyVideosCollectionClient.h"
+#include "VCXTestCommon.h"
+#include "VCXTestLog.h"
+#include "CIptvTestTimer.h"
+#include "CIptvTestActiveWait.h"
+
+#include <mpxcollectionutility.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxmediageneraldefs.h>
+#include <mpxmessagegeneraldefs.h>
+#include <mpxcollectionmessagedefs.h>
+#include <mpxcollectionpath.h>
+#include <mpxmessage2.h>
+#include <mpxcollectionmessage.h>
+#include <mpxmessagecontainerdefs.h>
+#include <mpxmediabase.h>
+#include <mpxcommandgeneraldefs.h>
+#include <mpxcollectioncommanddefs.h>
+
+#include <vcxmyvideosdefs.h>
+#include <vcxmyvideosuids.h>
+
+// CONSTANTS
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::NewL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CVCXTestMyVideosCollectionClient* CVCXTestMyVideosCollectionClient::NewL( MVCXTestMyVideosObserver* aObserver )
+ {
+ CVCXTestMyVideosCollectionClient* self = new (ELeave) CVCXTestMyVideosCollectionClient( aObserver );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::~CVCXTestMyVideosCollectionClient
+// -----------------------------------------------------------------------------
+//
+CVCXTestMyVideosCollectionClient::~CVCXTestMyVideosCollectionClient()
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::~CVCXTestMyVideosCollectionClient");
+ if( iTimer )
+ {
+ iTimer->CancelTimer();
+ delete iTimer;
+ iTimer = NULL;
+ }
+
+ if( iCollectionUtility )
+ {
+ iCollectionUtility->Close();
+ }
+ iCollectionUtility = NULL;
+
+ delete iCurrentEntries;
+ iCurrentEntries = NULL;
+
+ if( iMediaArray )
+ {
+ iMediaArray->Reset();
+ delete iMediaArray;
+ iMediaArray = NULL;
+ }
+
+ iFs.Close();
+
+ iActiveWait->Stop();
+ delete iActiveWait;
+ iActiveWait = NULL;
+
+ delete iTestCommon;
+ iTestCommon = NULL;
+
+ if( iDownloads )
+ {
+ iDownloads->Reset();
+ delete iDownloads;
+ iDownloads = NULL;
+ }
+
+ if( iVideos )
+ {
+ iVideos->Reset();
+ delete iVideos;
+ iVideos = NULL;
+ }
+
+ iInsertedVideoMdsIds.Reset();
+
+ iOngoingDownloads.Reset();
+
+ iCompletedDownloads.Reset();
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::~CVCXTestMyVideosCollectionClient");
+ }
+
+ // -----------------------------------------------------------------------------
+ // CVCXTestMyVideosCollectionClient::CVCXTestMyVideosCollectionClient
+ // -----------------------------------------------------------------------------
+ //
+CVCXTestMyVideosCollectionClient::CVCXTestMyVideosCollectionClient( MVCXTestMyVideosObserver* aObserver )
+ : iObserver( aObserver )
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::ConstructL( )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::ConstructL");
+ User::LeaveIfError( iFs.Connect() );
+
+ iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeIsolated );
+
+ iTestCommon = CVCXTestCommon::NewL();
+ iActiveWait = CIptvTestActiveWait::NewL();
+ iTimer = CIptvTestTimer::NewL( *this, 0 );
+
+ iCollectionUid = KVcxUidMyVideosMpxCollection;
+ iOpenLevelIndex = -1;
+
+ OpenCollectionL();
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::ConstructL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::OpenCollectionL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::OpenCollectionL( )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::OpenCollectionL =----->");
+
+ TInt levels = LevelsL();
+
+ if( levels == KVCXTestMpxLevelRoot || levels == 0 )
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Opening collection.");
+ // Open collection.
+ CMPXCollectionPath* path = CMPXCollectionPath::NewL();
+ CleanupStack::PushL( path );
+ path->AppendL( iCollectionUid );
+ iCollectionUtility->Collection().OpenL( *path );
+ CleanupStack::PopAndDestroy( path );
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::OpenCollectionL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::OpenCollectionLevelL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::OpenCollectionLevelL( TUint32 aIndex )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::OpenLevelL =----->");
+
+ TInt levels = LevelsL();
+
+ if( levels == KVCXTestMpxLevelCategory )
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Opening category.");
+ // Open all videos.
+ iOpenLevelIndex = aIndex;
+ iCollectionUtility->Collection().OpenL( iOpenLevelIndex );
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::OpenLevelL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::RefreshCollectionL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::RefreshCollectionL( )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::RefreshCollectionL =----->");
+
+ TInt levels = LevelsL();
+
+ if( levels >= KVCXTestMpxLevelCategory )
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Refreshing collection.");
+ // Just refresh
+ iCollectionUtility->Collection().OpenL();
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::RefreshCollectionL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::LevelsL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CVCXTestMyVideosCollectionClient::LevelsL()
+ {
+ if ( iCollectionUtility )
+ {
+ CMPXCollectionPath* path = iCollectionUtility->Collection().PathL();
+ TInt levels = path->Levels();
+ delete path;
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient:: levels: %d", levels);
+ return levels;
+ }
+ return KErrNotFound;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::UpdateVideoListL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::UpdateVideoListL( TBool aComplete )
+ {
+ if( !iCurrentEntries ) return;
+
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::UpdateVideoListL =----->");
+
+ // Create new list.
+ delete iVideos;
+ iVideos = CMPXMediaArray::NewL();
+
+ TBool isCategoryList( EFalse );
+
+ // Add videos to the list.
+
+ for( TInt i = 0; i < iMediaArray->Count(); i++ )
+ {
+ CMPXMedia* media = (*iMediaArray)[i];
+
+ TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));
+
+ if( itemId.iId2 != 0 )
+ {
+ isCategoryList = ETrue;
+ }
+
+ // Add non downloads and completed downloads to the list.
+ if( media->IsSupported( KVcxMediaMyVideosDownloadState ) )
+ {
+ TUint8 state = 0;
+ state = media->ValueTObjectL<TUint8>( KVcxMediaMyVideosDownloadState );
+
+ if( state == EVcxMyVideosDlStateDownloaded )
+ {
+ iVideos->AppendL( *media );
+ VCXLOGLO3("CVCXTestMyVideosCollectionClient::UpdateVideoListL media is completed download, id: %d, state: %d", itemId.iId1, state);
+ }
+ else
+ {
+ VCXLOGLO3("CVCXTestMyVideosCollectionClient::UpdateVideoListL media is downloading, id: %d, state: %d", itemId.iId1, state);
+ }
+ }
+ else
+ {
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateVideoListL media is video, id: %d", itemId.iId1);
+ iVideos->AppendL( *media );
+
+ // Send add video event if the video has been just added.
+ if( iInsertedVideoMdsIds.Find( itemId.iId1 ) != -1 )
+ {
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoVideoAdded, itemId.iId1, 0, KErrNone );
+ }
+ }
+ }
+
+ iInsertedVideoMdsIds.Reset();
+
+ if( isCategoryList )
+ {
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateVideoListL Categories (%d): =----->", iVideos->Count());
+ }
+ else
+ {
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateVideoListL Videos (%d): =----->", iVideos->Count());
+ }
+
+ PrintMediasL( iVideos );
+
+ if( aComplete )
+ {
+ if( !isCategoryList )
+ {
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoListRefreshed, 0, 0, KErrNone );
+ }
+
+ // Open category.
+ if( LevelsL() == KVCXTestMpxLevelCategory )
+ {
+ OpenCollectionLevelL( 0 );
+ }
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::UpdateVideoListL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::UpdateDownloadListL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::UpdateDownloadListL()
+ {
+ if( LevelsL() != KVCXTestMpxLevelVideo || !iCurrentEntries ) return;
+
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::UpdateDownloadListL =----->");
+
+ TBool ongoingDownloadsChanged( EFalse );
+ TInt iCompletedDownloadsBefore = iCompletedDownloads.Count();
+
+ TInt downloadCountBefore( 0 );
+ if( iDownloads )
+ {
+ downloadCountBefore = iDownloads->Count();
+ }
+
+ // Create new list.
+ delete iDownloads;
+ iDownloads = NULL;
+ iDownloads = CMPXMediaArray::NewL();
+
+ // Add videos to the list.
+ for( TInt i = 0; i < iMediaArray->Count(); i++ )
+ {
+ CMPXMedia* media = (*iMediaArray)[i];
+
+ TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));
+
+ // Add only downloads which are not complete to the list.
+ if( media->IsSupported( KVcxMediaMyVideosDownloadState ) )
+ {
+ TUint8 state = 0;
+ state = media->ValueTObjectL<TUint8>( KVcxMediaMyVideosDownloadState );
+
+ VCXLOGLO3("CVCXTestMyVideosCollectionClient::UpdateDownloadListL: media mpx id: %d, state: %d", itemId.iId1, state);
+
+ if( state != EVcxMyVideosDlStateDownloaded )
+ {
+ iDownloads->AppendL( *media );
+ }
+
+ if( UpdateDownloadL( media ) )
+ {
+ ongoingDownloadsChanged = ETrue;
+ }
+ }
+ else
+ {
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateDownloadListL: media mpx id %d is not a download.", itemId.iId1);
+ }
+ }
+
+ VCXLOGLO4("CVCXTestMyVideosCollectionClient::UpdateDownloadListL: ongoing downloads changed: %d, completed downloads before: %d and now: %d", ongoingDownloadsChanged, iCompletedDownloadsBefore, iCompletedDownloads.Count());
+
+ // Update video list if more downloads have been completed.
+ if( iCompletedDownloadsBefore != iCompletedDownloads.Count() )
+ {
+ UpdateVideoListL( ETrue );
+
+ // Inform client about new video(s).
+ TInt newCompletedDownloads = iCompletedDownloads.Count() - iCompletedDownloadsBefore;
+
+ for( TInt i = 0; i < newCompletedDownloads; i++ )
+ {
+ TInt index = ( iCompletedDownloads.Count() - 1 ) - i;
+ TInt32 mdsId = iCompletedDownloads[ index ].iMdsId;
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoVideoAdded, mdsId, 0, KErrNone );
+ }
+ }
+
+ // Print downloads if they have changed.
+ if( ongoingDownloadsChanged || downloadCountBefore != iDownloads->Count())
+ {
+ VCXLOGLO3("CVCXTestMyVideosCollectionClient:: Downloads (%d, ongoing: %d): =----->", iDownloads->Count(), iOngoingDownloads.Count());
+ PrintMediasL( iDownloads );
+
+ if( iOngoingDownloads.Count() == 0 && downloadCountBefore > 0 )
+ {
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoAllDownloadsCompleted, 0, 0, KErrNone );
+ }
+ }
+
+ // Start download update timer if there's downloads.
+ if( iDownloads->Count() > 0 )
+ {
+ iTimer->After( 1000000 );
+ }
+ else
+ {
+ iTimer->Cancel();
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::UpdateDownloadListL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::UpdateMediaArrayL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::UpdateMediaArrayL()
+ {
+ if( !iCurrentEntries ) return;
+
+ // Reset old medias.
+ if( iMediaArray )
+ {
+ iMediaArray->Reset();
+ delete iMediaArray;
+ iMediaArray = NULL;
+ }
+
+ // Create copies of the current medias.
+ iMediaArray = CMPXMediaArray::NewL();
+
+ CMPXMediaArray* medias = iCurrentEntries->Value<CMPXMediaArray>( KMPXMediaArrayContents );
+
+ // Make copies of the medias.
+ for( TInt i=0; i<medias->Count(); i++ )
+ {
+ CMPXMedia* media(NULL);
+ media = (*medias)[i];
+
+ TBool isOnRom( EFalse );
+ if( media->IsSupported( KMPXMediaGeneralUri ) )
+ {
+ const TDesC& url = media->ValueText( KMPXMediaGeneralUri );
+ if( url.FindC( _L("z:" ) ) != KErrNotFound )
+ {
+ isOnRom = ETrue;
+ }
+ }
+
+ if( !isOnRom )
+ {
+ iMediaArray->AppendL( *media );
+ }
+ }
+
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient::UpdateMediaArrayL: iMediaCount: %d", iMediaArray->Count());
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::PrintMediasL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::PrintMediasL( CMPXMediaArray* aMediaArray )
+ {
+ for( TInt i = 0; i < aMediaArray->Count(); i++ )
+ {
+ CMPXMedia* media = (*aMediaArray)[i];
+
+ TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));
+
+ // Category.
+ if( itemId.iId2 != 0 )
+ {
+ TBuf<256> title;
+ if( media->IsSupported( KMPXMediaGeneralTitle ) )
+ {
+ title = media->ValueText( KMPXMediaGeneralTitle );
+ }
+
+ TInt itemCount(0);
+ TInt newItemCount(0);
+ TBuf<256> newItemName;
+ if( media->IsSupported( KVcxMediaMyVideosCategoryNewItemName ) )
+ {
+ newItemName = media->ValueText( KVcxMediaMyVideosCategoryNewItemName );
+ }
+ if( media->IsSupported( KVcxMediaMyVideosCategoryItemCount ) )
+ {
+ itemCount = *(media->Value<TUint32>( KVcxMediaMyVideosCategoryItemCount ));
+ }
+ if( media->IsSupported( KVcxMediaMyVideosCategoryNewItemCount ) )
+ {
+ newItemCount = *(media->Value<TUint32>( KVcxMediaMyVideosCategoryNewItemCount ));
+ }
+ VCXLOGLO5("CVCXTestMyVideosCollectionClient: title: %S, medias: %d, new: %d, new media: %S", &title, itemCount, newItemCount, &newItemName);
+ }
+ // Media.
+ else
+ {
+ HBufC* pathBuff = NULL;
+ HBufC* titleBuff = NULL;
+ TInt size(0);
+ TInt origin(-1);
+
+ // Download specific.
+ HBufC* urlBuff = NULL;
+ TUint8 state = 0;
+ TInt8 progress = 0;
+ TUint32 downloadId = 0;
+ TInt32 downloadError = 0;
+ TInt32 globalError = 0;
+
+ if( media->IsSupported( KVcxMediaMyVideosDownloadState ) )
+ {
+ state = media->ValueTObjectL<TUint8>( KVcxMediaMyVideosDownloadState );
+ }
+
+ if( media->IsSupported( KVcxMediaMyVideosDownloadId ) )
+ {
+ downloadId = media->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId );
+ }
+
+ if( media->IsSupported( KMPXMediaGeneralUri ) )
+ {
+ const TDesC& url = media->ValueText( KMPXMediaGeneralUri );
+ pathBuff = url.AllocL();
+ CleanupStack::PushL( pathBuff );
+ }
+
+ if( media->IsSupported( KMPXMediaGeneralTitle ) )
+ {
+ const TDesC& title = media->ValueText( KMPXMediaGeneralTitle );
+ titleBuff = title.AllocL();
+ CleanupStack::PushL( titleBuff );
+ }
+
+ if( media->IsSupported( KMPXMediaGeneralSize ) )
+ {
+ size = *(media->Value<TInt>( KMPXMediaGeneralSize ));
+ }
+
+ if( media->IsSupported( KVcxMediaMyVideosOrigin ) )
+ {
+ origin = *(media->Value<TUint>( KVcxMediaMyVideosOrigin ));
+ }
+
+ if( media->IsSupported( KVcxMediaMyVideosRemoteUrl ) )
+ {
+ const TDesC& url = media->ValueText( KVcxMediaMyVideosRemoteUrl );
+ urlBuff = url.AllocL();
+ CleanupStack::PushL( urlBuff );
+ }
+
+ if( media->IsSupported( KVcxMediaMyVideosDownloadProgress ) )
+ {
+ progress = media->ValueTObjectL<TInt8>( KVcxMediaMyVideosDownloadProgress );
+ }
+
+ if( media->IsSupported( KVcxMediaMyVideosDownloadError ) )
+ {
+ downloadError = media->ValueTObjectL<TInt32>( KVcxMediaMyVideosDownloadError );
+ }
+
+ if( media->IsSupported( KVcxMediaMyVideosDownloadGlobalError ) )
+ {
+ globalError = media->ValueTObjectL<TInt32>( KVcxMediaMyVideosDownloadGlobalError );
+ }
+
+ VCXLOGLO3("CVCXTestMyVideosCollectionClient: iId1: %d, iId2: %d", itemId.iId1, itemId.iId2 );
+ VCXLOGLO5("CVCXTestMyVideosCollectionClient: title: %S, size: %d, origin: %d, path: %S", titleBuff, size, origin, pathBuff);
+ if( media->IsSupported( KVcxMediaMyVideosDownloadState ) )
+ {
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient: url: %S", urlBuff);
+ VCXLOGLO4("CVCXTestMyVideosCollectionClient: state: %d, progress: %d, dl id: %d", state, progress, downloadId);
+ if( downloadError != KErrNone || globalError != KErrNone )
+ {
+ VCXLOGLO3("CVCXTestMyVideosCollectionClient: downloadError: %d, globalError: %d, dl id: %d", downloadError, globalError);
+ }
+ }
+
+ if( urlBuff )
+ {
+ CleanupStack::PopAndDestroy( urlBuff );
+ }
+ if( titleBuff )
+ {
+ CleanupStack::PopAndDestroy( titleBuff );
+ }
+ if( pathBuff )
+ {
+ CleanupStack::PopAndDestroy( pathBuff );
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::UpdateDownloadL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CVCXTestMyVideosCollectionClient::UpdateDownloadL( CMPXMedia* aMedia )
+ {
+ if( !aMedia->IsSupported( KVcxMediaMyVideosDownloadState ) ||
+ !aMedia->IsSupported( KVcxMediaMyVideosDownloadId ) )
+ {
+ return EFalse;
+ }
+
+ TMPXItemId itemId = *(aMedia->Value<TMPXItemId>( KMPXMediaGeneralId ));
+
+ TUint8 state = 0;
+ TUint32 downloadId = 0;
+ TInt8 progress = 0;
+ TInt32 downloadError = 0;
+ TInt32 globalError = 0;
+
+ state = aMedia->ValueTObjectL<TUint8>( KVcxMediaMyVideosDownloadState );
+
+ downloadId = aMedia->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId );
+
+ if( aMedia->IsSupported( KVcxMediaMyVideosDownloadProgress ) )
+ {
+ progress = aMedia->ValueTObjectL<TInt8>( KVcxMediaMyVideosDownloadProgress );
+ }
+
+ if( aMedia->IsSupported( KVcxMediaMyVideosDownloadError ) )
+ {
+ downloadError = aMedia->ValueTObjectL<TInt32>( KVcxMediaMyVideosDownloadError );
+ }
+
+ if( aMedia->IsSupported( KVcxMediaMyVideosDownloadGlobalError ) )
+ {
+ globalError = aMedia->ValueTObjectL<TInt32>( KVcxMediaMyVideosDownloadGlobalError );
+ }
+
+ if( downloadError == KErrNone )
+ {
+ downloadError = globalError;
+ }
+
+ TVCXTestDownload download;
+ download.iMdsId = itemId.iId1;
+ download.iState = state;
+ download.iDownloadId = downloadId;
+ download.iProgress = progress;
+ download.iDownloadError = downloadError;
+ download.iGlobalError = globalError;
+
+ TInt index = iOngoingDownloads.Find( download, CVCXTestMyVideosCollectionClient::CompareDownloads );
+
+ TBool changesMade( EFalse );
+
+ switch( state )
+ {
+ case EVcxMyVideosDlStateDownloading:
+ {
+ // It's new download if not found, otherwise check for progress.
+ if( index == KErrNotFound )
+ {
+ iOngoingDownloads.AppendL( download );
+ iObserver->VideoEventL(
+ MVCXTestMyVideosObserver::EVCXTestVideoDownloadStarted, itemId.iId1, 0, KErrNone );
+ changesMade = ETrue;
+ }
+ else
+ {
+ if( progress >= iOngoingDownloads[index].iProgress+10 ||
+ ( progress == 100 && iOngoingDownloads[index].iProgress != 100 ) )
+ {
+ iOngoingDownloads.Remove( index );
+ iOngoingDownloads.AppendL( download );
+ iObserver->VideoEventL(
+ MVCXTestMyVideosObserver::EVCXTestVideoDownloadProgressed, itemId.iId1, progress, KErrNone );
+ changesMade = ETrue;
+ }
+ }
+ }
+ break;
+
+ case EVcxMyVideosDlStateFailed:
+ {
+ // Update only if state has changed.
+ if( index != KErrNotFound && iOngoingDownloads[index].iState != state )
+ {
+ iOngoingDownloads.Remove( index );
+ iObserver->VideoEventL(
+ MVCXTestMyVideosObserver::EVCXTestVideoDownloadFailed, itemId.iId1, 0, downloadError );
+ changesMade = ETrue;
+ }
+ }
+ break;
+
+ case EVcxMyVideosDlStatePaused:
+ {
+ // Update only if state has changed.
+ if( index != KErrNotFound && iOngoingDownloads[index].iState != state )
+ {
+ iOngoingDownloads.Remove( index );
+ iObserver->VideoEventL(
+ MVCXTestMyVideosObserver::EVCXTestVideoDownloadPaused, itemId.iId1, 0, KErrNone );
+ changesMade = ETrue;
+ }
+ }
+ break;
+
+ case EVcxMyVideosDlStateDownloaded:
+ {
+ // Remove from ongoing dl list.
+ if( index != KErrNotFound )
+ {
+ iOngoingDownloads.Remove( index );
+ iObserver->VideoEventL(
+ MVCXTestMyVideosObserver::EVCXTestVideoDownloadCompleted, itemId.iId1, 0, KErrNone );
+ changesMade = ETrue;
+ }
+
+ // Add to completed dl list.
+ index = iCompletedDownloads.Find( download, CVCXTestMyVideosCollectionClient::CompareDownloads );
+ if( index == KErrNotFound )
+ {
+ iCompletedDownloads.AppendL( download );
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ return changesMade;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::CompareDownloads
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CVCXTestMyVideosCollectionClient::CompareDownloads( const TVCXTestDownload& a1, const TVCXTestDownload& a2 )
+ {
+ return a1.iMdsId == a2.iMdsId;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::CreateMpxCommandLC
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMPXCommand* CVCXTestMyVideosCollectionClient::CreateMpxCommandLC( TInt aCommandGeneralId, TInt aMyVideosCommandId, TBool aSync )
+ {
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralId, aCommandGeneralId );
+ if( aCommandGeneralId == KVcxCommandIdMyVideos )
+ {
+ cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, aMyVideosCommandId );
+ }
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, aSync );
+
+ // If async command then set transaction ID.
+ if( !aSync )
+ {
+ cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, 0 );
+ }
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, iCollectionUid );
+
+ return cmd;
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::VideoCount
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CVCXTestMyVideosCollectionClient::VideoCount()
+ {
+ if( !iVideos )
+ {
+ return 0;
+ }
+ return iVideos->Count();
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::GetVideoL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CMPXMedia* CVCXTestMyVideosCollectionClient::GetVideoL( TUint aIndex )
+ {
+ CMPXMedia* media = NULL;
+
+ if( !iVideos || iVideos->Count() <= aIndex )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ media = (*iVideos)[aIndex];
+
+ return media;
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxMyVideosCollectionTester::RemoveVideoL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::RemoveVideoL( TUint aIndex )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::RemoveVideoL");
+
+ if( !iVideos || iVideos->Count() <= aIndex )
+ {
+ User::Leave( KErrNotReady );
+ }
+
+ CMPXMedia* media = NULL;
+
+ media = (*iVideos)[aIndex];
+ TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));
+
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient::RemoveVideoL: mpxId: %d", itemId.iId1);
+
+ CMPXCommand* cmd = CreateMpxCommandLC( KMPXCommandIdCollectionRemoveMedia, 0, EFalse );
+ cmd->SetTObjectValueL( KMPXMediaGeneralId, itemId );
+ iCollectionUtility->Collection().CommandL( *cmd );
+ CleanupStack::PopAndDestroy( cmd );
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::RemoveVideoL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::DownloadCount
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CVCXTestMyVideosCollectionClient::DownloadCount()
+ {
+ if( !iDownloads )
+ {
+ return 0;
+ }
+ return iDownloads->Count();
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxMyVideosCollectionTester::DownloadL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::DownloadL( const TDesC& aUrl, TUint aIapId, const TDesC& aUserName, const TDesC& aPassword )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::DownloadL");
+
+ CMPXCommand* cmd = CreateMpxCommandLC( KVcxCommandIdMyVideos, KVcxCommandMyVideosStartDownload, EFalse );
+
+ CMPXMedia* startDownloadReq(NULL);
+ startDownloadReq = CMPXMedia::NewL();
+ CleanupStack::PushL( startDownloadReq );
+
+ startDownloadReq->SetTObjectValueL( KVcxMediaMyVideosIapId, aIapId );
+ startDownloadReq->SetTObjectValueL( KMPXMediaGeneralFlags, EVcxMyVideosServiceHasReadOnlyIap | EVcxMyVideosSilent );
+ startDownloadReq->SetTextValueL( KMPXMediaGeneralTitle, _L("testdownload") );
+ startDownloadReq->SetTextValueL( KVcxMediaMyVideosRemoteUrl, aUrl );
+ startDownloadReq->SetTextValueL( KVcxMediaMyVideosUsername, aUserName);
+ startDownloadReq->SetTextValueL( KVcxMediaMyVideosPassword, aPassword);
+
+ cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, startDownloadReq );
+ iCollectionUtility->Collection().CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( startDownloadReq );
+ CleanupStack::PopAndDestroy( cmd );
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::DownloadL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::EnsureMediaFilesAreNotInUseL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::EnsureMediaFilesAreNotInUseL()
+ {
+ if( iMediaArray->Count() <= 0 ) return;
+
+ TInt retries = 4;
+ RFile file;
+ TInt error( KErrInUse );
+
+ // Check all files that they are not in use, retry few times.
+ while( --retries >= 0 && error == KErrInUse )
+ {
+ for( TInt i=0; i<iMediaArray->Count(); i++ )
+ {
+ CMPXMedia* media = (*iMediaArray)[i];
+
+ if( media->IsSupported( KMPXMediaGeneralUri ) )
+ {
+ const TDesC& localFilePath = media->ValueText( KMPXMediaGeneralUri );
+
+ error = file.Open( iFs, localFilePath, EFileShareExclusive );
+ if( error == KErrInUse )
+ {
+ User::After( 1000000 * 60 ); // Wait a minute
+ break;
+ }
+ file.Close();
+ }
+ }
+ }
+
+ if( error != KErrNone && error != KErrNotFound )
+ {
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient::EnsureMediaFilesAreNotInUseL: error: %d", error);
+ User::Leave( error );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::GetCountOfOngoingDownloads
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CVCXTestMyVideosCollectionClient::GetCountOfOngoingDownloads()
+ {
+ return iOngoingDownloads.Count();
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::GetCountOfNewVideos
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CVCXTestMyVideosCollectionClient::GetCountOfNewVideos( TBool aIncludeDownloads )
+ {
+ TInt count( 0 );
+
+ if( iVideos )
+ {
+ for( TInt i = 0; i < iVideos->Count(); i++ )
+ {
+ CMPXMedia* media = (*iVideos)[i];
+ if( media->IsSupported( KMPXMediaGeneralFlags ) )
+ {
+ TUint value = *(*media).Value<TUint>( KMPXMediaGeneralFlags );
+ if( value & EVcxMyVideosVideoNew )
+ {
+ count++;
+ }
+ }
+ }
+ }
+
+ if( aIncludeDownloads && iDownloads )
+ {
+ for( TInt i = 0; i < iDownloads->Count(); i++ )
+ {
+ CMPXMedia* media = (*iDownloads)[i];
+ if( media->IsSupported( KMPXMediaGeneralFlags ) )
+ {
+ TUint value = *(*media).Value<TUint>( KMPXMediaGeneralFlags );
+ if( value & EVcxMyVideosVideoNew )
+ {
+ count++;
+ }
+ }
+ }
+ }
+
+ return count;
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxMyVideosCollectionTester::CancelDownloadL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CVCXTestMyVideosCollectionClient::CancelDownloadL( TUint aIndex )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::CancelDownloadL");
+
+ if( !iDownloads || iDownloads->Count() <= aIndex )
+ {
+ User::Leave( KErrNotReady );
+ }
+
+ CMPXMedia* media = NULL;
+
+ media = (*iDownloads)[aIndex];
+ TMPXItemId itemId = *(media->Value<TMPXItemId>( KMPXMediaGeneralId ));
+
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient::CancelDownloadL: mpxId: %d", itemId.iId1);
+
+ if( media->IsSupported( KVcxMediaMyVideosDownloadId ) && media->IsSupported( KMPXMediaGeneralUri ) )
+ {
+ TUint32 downloadId = 0;
+ downloadId = media->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId );
+ HBufC* path = media->ValueText( KMPXMediaGeneralUri ).AllocL();
+ CleanupStack::PushL( path );
+
+ CMPXCommand* cmd = CreateMpxCommandLC( KVcxCommandIdMyVideos, KVcxCommandMyVideosCancelDownload, EFalse );
+
+ CMPXMedia* cancelDownloadReq = CMPXMedia::NewL();
+ CleanupStack::PushL( cancelDownloadReq );
+
+ cancelDownloadReq->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, TMPXItemId ( itemId.iId1, 0 ) );
+ cancelDownloadReq->SetTObjectValueL<TUint32>( KVcxMediaMyVideosDownloadId, downloadId );
+ cancelDownloadReq->SetTextValueL( KMPXMediaGeneralUri, *path );
+
+ cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, cancelDownloadReq );
+
+ CleanupStack::PopAndDestroy( cancelDownloadReq );
+ iCollectionUtility->Collection().CommandL( *cmd );
+ CleanupStack::PopAndDestroy( cmd );
+ CleanupStack::PopAndDestroy( path );
+ }
+ else
+ {
+ User::Leave( KErrArgument );
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::RemoveMediaL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleCollectionMediaL
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleCollectionMediaL(const CMPXMedia& aMedia,
+ TInt aError)
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::HandleCollectionMediaL");
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient:: aError: %d", aError);
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::HandleCollectionMediaL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleCollectionMessage
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleCollectionMessage( CMPXMessage* aMessage, TInt aError )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::HandleCollectionMessage");
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient:: aError: %d", aError);
+
+ if( !aMessage ) return;
+
+ if( aError == KErrNone )
+ {
+ TInt err( KErrNone );
+
+ TMPXMessageId messageId = *(aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ));
+
+ TInt myVideosCmd = -1;
+ if ( messageId == KVcxCommandIdMyVideos )
+ {
+ myVideosCmd = aMessage->ValueTObjectL<TInt>( KVcxMediaMyVideosCommandId );
+ }
+
+ // Handle single message.
+ if ( myVideosCmd != KVcxMessageMyVideosMessageArray )
+ {
+ TRAP( err, HandleSingleCollectionMessageL( aMessage ) );
+ }
+ else
+ {
+ // Expand and handle the messages in My Videos message array.
+ if( err == KErrNone && aMessage->IsSupported( KMPXMessageArrayContents ) )
+ {
+ const CMPXMessageArray* messageArray =
+ aMessage->Value<CMPXMessageArray>(KMPXMessageArrayContents);
+
+ TInt count = messageArray->Count();
+
+ for( TInt i = 0; i < count; i++ )
+ {
+ TRAP( err, HandleSingleCollectionMessageL( (*messageArray)[i] ) );
+ if( err != KErrNone )
+ {
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient:: Leave at handling, %d =----->", err);
+ }
+ }
+ }
+ }
+
+ if( err != KErrNone )
+ {
+ aError = err;
+ }
+ }
+
+ if( aError != KErrNone )
+ {
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoGeneral, 0, 0, aError );
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::HandleCollectionMessage");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleSingleCollectionMessageL
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleSingleCollectionMessageL( CMPXMessage* aMessage )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::HandleSingleCollectionMessageL");
+
+ TMPXMessageId messageId = *(aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ));
+
+ // Check that message is for open collection.
+ if( aMessage->IsSupported( KMPXMessageCollectionId ) )
+ {
+ TUid uid( *(aMessage->Value<TUid>( KMPXMessageCollectionId )) );
+ if( TUid::Uid( iCollectionUid ) != uid )
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: wrong collection id");
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::HandleSingleCollectionMessage");
+ return;
+ }
+ }
+
+ switch( messageId )
+ {
+ case KVcxCommandIdMyVideos:
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: KVcxCommandIdMyVideos =----->");
+ HandleMyVideosMessageL( aMessage );
+ }
+ break;
+
+ case KMPXMessageGeneral:
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: KMPXMessageGeneral =----->");
+ HandleGeneralMessageL( aMessage );
+ }
+ break;
+
+ case KMPXMessageIdItemChanged:
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: KMPXMessageIdItemChanged =----->");
+ HandleItemChangedMessageL( aMessage );
+ }
+ break;
+
+ default:
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: unknown message ID");
+ break;
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::HandleSingleCollectionMessageL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleMyVideosMessageL
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleMyVideosMessageL( CMPXMessage* aMessage )
+ {
+ if ( !aMessage->IsSupported( KVcxMediaMyVideosCommandId ) )
+ {
+ return;
+ }
+
+ TInt myVideosCommandId = *(aMessage->Value<TInt>( KVcxMediaMyVideosCommandId ));
+
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient:: KVcxMediaMyVideosCommandId: %d", myVideosCommandId);
+
+ switch ( myVideosCommandId )
+ {
+ case KVcxMessageMyVideosDeleteResp:
+ case KVcxMessageMyVideosDeleteStarted:
+ case KVcxMessageMyVideosCopyResp:
+ case KVcxMessageMyVideosMoveResp:
+ case KVcxMessageMyVideosMoveOrCopyStarted:
+ case KVcxMessageMyVideosGetMediasByMpxIdResp:
+ {
+ }
+ break;
+
+ /**
+ * This is received when list is open already and the list contains new items
+ */
+ case KVcxMessageMyVideosItemsAppended:
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: KVcxMessageMyVideosItemsAppended =----->");
+
+ if( LevelsL() < KVCXTestMpxLevelCategory )
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Category list or video list not open, ignoring.");
+ break;
+ }
+
+ UpdateMediaArrayL();
+ UpdateVideoListL( EFalse );
+ UpdateDownloadListL();
+ // Wait list complete event and do nothing here.
+ }
+ break;
+
+
+ /**
+ * Collection sends this message when media list fetching has ended
+ * and no more KVcxMessageMyVideosItemsAppended will be sent.
+ * If client has fetched items with KVcxCommandMyVideosGetMediasByMpxId,
+ * it should refetch items when this event arrives.
+ */
+ case KVcxMessageMyVideosListComplete:
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: KVcxMessageMyVideosListComplete =----->");
+
+ UpdateMediaArrayL();
+ UpdateVideoListL( ETrue );
+ UpdateDownloadListL();
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleGeneralMessageL
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleGeneralMessageL( CMPXMessage* aMessage )
+ {
+ TInt event( *(aMessage->Value<TInt>( KMPXMessageGeneralEvent )) );
+ TInt type( *(aMessage->Value<TInt>( KMPXMessageGeneralType )) );
+ TInt data( *(aMessage->Value<TInt>( KMPXMessageGeneralData )) );
+
+ VCXLOGLO4("CVCXTestMyVideosCollectionClient:: event: %d, type: %d, data: %d", event, type, data);
+
+ if ( event == TMPXCollectionMessage::EPathChanged && data == EMcContainerOpened ) // 4 & 1
+ {
+ RefreshCollectionL();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleItemChangedMessageL
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleItemChangedMessageL( CMPXMessage* aMessage )
+ {
+ TMPXItemId itemId( *aMessage->Value<TMPXItemId>(KMPXMessageMediaGeneralId) );
+ VCXLOGLO3("CVCXTestMyVideosCollectionClient:: Item Id1: %d, Id2: %d", itemId.iId1, itemId.iId2);
+
+ // Check the IDs for categories
+ if( itemId.iId2 != 0 && ( itemId.iId1 != KVcxMvcCategoryIdAll &&
+ itemId.iId1 != KVcxMvcCategoryIdDownloads &&
+ itemId.iId1 != KVcxMvcCategoryIdTvRecordings &&
+ itemId.iId1 != KVcxMvcCategoryIdCaptured &&
+ itemId.iId1 != KVcxMvcCategoryIdOther ) )
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Error. INVALID ITEM ID.");
+ return;
+ }
+
+ // Skip message if it's for category but not for the open category.
+ if( itemId.iId2 > 0 && itemId.iId1 != iOpenLevelIndex )
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: Not for open category. Skip.");
+ return;
+ }
+
+ TBool refreshNeeded( EFalse );
+
+ TMPXChangeEventType changeEvent( *aMessage->Value<TMPXChangeEventType>( KMPXMessageChangeEventType ) );
+
+ switch( changeEvent )
+ {
+ case EMPXItemInserted:
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: changeEvent EMPXItemInserted =----->");
+ refreshNeeded = ETrue;
+
+ iInsertedVideoMdsIds.Append( itemId.iId1 );
+ }
+ break;
+
+ case EMPXItemDeleted:
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: changeEvent EMPXItemDeleted =----->");
+ refreshNeeded = ETrue;
+
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoVideoDeleted, itemId.iId1, 0, KErrNone );
+ }
+ break;
+
+ case EMPXItemModified:
+ {
+ VCXLOGLO1("CVCXTestMyVideosCollectionClient:: changeEvent EMPXItemModified =----->");
+
+ if ( aMessage->IsSupported( KVcxMediaMyVideosInt32Value ) )
+ {
+ TInt32 extraInfo = aMessage->ValueTObjectL<TInt32>( KVcxMediaMyVideosInt32Value );
+ if ( extraInfo == EVcxMyVideosVideoListOrderChanged )
+ {
+ VCXLOGLO1("CVcxMyVideosCollectionTester:: Received EVcxMyVideosVideoListOrderChanged");
+ refreshNeeded = ETrue;
+ }
+ }
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ if( refreshNeeded )
+ {
+ RefreshCollectionL();
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleOpenL
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleOpenL( const CMPXMedia& aEntries,
+ TInt aIndex, TBool aComplete, TInt aError )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::HandleOpenL");
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient:: aError: %d", aError);
+
+ if( aError == KErrNone )
+ {
+ delete iCurrentEntries;
+ iCurrentEntries = NULL;
+ iCurrentEntries = CMPXMedia::NewL( aEntries );
+ }
+
+ UpdateMediaArrayL();
+ UpdateVideoListL( aComplete );
+ UpdateDownloadListL();
+
+ if( aError != KErrNone )
+ {
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoGeneral, 0, 0, aError );
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::HandleOpenL");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleOpenL
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleOpenL( const CMPXCollectionPlaylist& aPlaylist,
+ TInt aError )
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::HandleOpenL (playlist)");
+
+ if( aError != KErrNone )
+ {
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoGeneral, 0, 0, aError );
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::HandleOpenL (playlist)");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::HandleCommandComplete
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::HandleCommandComplete( CMPXCommand* /* aCommandResult */,
+ TInt aError)
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::HandleCommandComplete");
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient:: aError: %d", aError);
+
+ if( aError != KErrNone )
+ {
+ iObserver->VideoEventL( MVCXTestMyVideosObserver::EVCXTestVideoGeneral, 0, 0, aError );
+ }
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::HandleCommandComplete");
+ }
+
+// -----------------------------------------------------------------------------
+// CVCXTestMyVideosCollectionClient::TimerComplete
+// -----------------------------------------------------------------------------
+//
+void CVCXTestMyVideosCollectionClient::TimerComplete(TInt /* aTimerId */, TInt aError)
+ {
+ VCXLOGLO1(">>>CVCXTestMyVideosCollectionClient::TimerComplete");
+ VCXLOGLO2("CVCXTestMyVideosCollectionClient:: aError: %d", aError);
+
+ UpdateDownloadListL();
+
+ VCXLOGLO1("<<<CVCXTestMyVideosCollectionClient::TimerComplete");
+ }
+
+// EOF