diff -r 839377eedc2b -r befca0ec475f videocollection/hgmyvideos/src/vcxhgmyvideoscollectionclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videocollection/hgmyvideos/src/vcxhgmyvideoscollectionclient.cpp Wed Sep 01 12:30:28 2010 +0100 @@ -0,0 +1,1171 @@ +/* +* 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: Client class for My Videos MPX Collection.* +*/ + + + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "IptvDebug.h" +#include "vcxhgmyvideoscollectionclient.h" +#include "vcxhgmyvideosdownloadclient.h" +#include "vcxhgmyvideoscategorymodelobserver.h" +#include "vcxhgmyvideosvideomodelobserver.h" + + +// CONSTANTS +const TInt KVcxHgEventLevelRoot = 1; +const TInt KVcxHgEventLevelCategory = 2; +const TInt KVcxHgEventLevelVideo = 3; + +const TInt KVcxMpxLevelCategories = 2; +const TInt KVcxMpxLevelVideos = 3; + +const TUint32 KVcxHgMyVideosTransactionId = 5; + +const TInt KMpxMediaId2 = 0; + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::CVcxHgMyVideosCollectionClient() +// ----------------------------------------------------------------------------- +// +CVcxHgMyVideosCollectionClient::CVcxHgMyVideosCollectionClient() + : iCollectionOpenStatus( EVcxHgCollectionNotOpen ), + iPendingCommand( EVcxHgMyVideosCollectionCommandNone ), + iCollectionLevel( KErrNotFound ) + { + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::NewL() +// ----------------------------------------------------------------------------- +// +CVcxHgMyVideosCollectionClient* CVcxHgMyVideosCollectionClient::NewL() + { + CVcxHgMyVideosCollectionClient* self = + CVcxHgMyVideosCollectionClient::NewLC(); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::NewLC() +// ----------------------------------------------------------------------------- +// +CVcxHgMyVideosCollectionClient* CVcxHgMyVideosCollectionClient::NewLC() + { + CVcxHgMyVideosCollectionClient* self = + new (ELeave) CVcxHgMyVideosCollectionClient(); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::ConstructL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::ConstructL() + { + iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeDefault ); + iDownloadClient = CVcxHgMyVideosDownloadClient::NewL( *this, *iCollectionUtility ); + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::~CVcxHgMyVideosCollectionClient() +// ----------------------------------------------------------------------------- +// +CVcxHgMyVideosCollectionClient::~CVcxHgMyVideosCollectionClient() + { + delete iDownloadClient; + if ( iCollectionUtility ) + { + iCollectionUtility->Close(); + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::DownloadClient() +// ----------------------------------------------------------------------------- +// +CVcxHgMyVideosDownloadClient& CVcxHgMyVideosCollectionClient::DownloadClient() + { + return *iDownloadClient; + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HasPendingCommand() +// ----------------------------------------------------------------------------- +// +TBool CVcxHgMyVideosCollectionClient::HasPendingCommand() + { + return iPendingCommand != EVcxHgMyVideosCollectionCommandNone; + } + +// --------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::SetCategoryModelObserver() +// --------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::SetCategoryModelObserver( + MVcxHgMyVideosCategoryModelObserver* aCategoryModelObserver ) + { + iCategoryModelObserver = aCategoryModelObserver; + } + +// --------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::SetVideoModelObserver() +// --------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::SetVideoModelObserver( + MVcxHgMyVideosVideoModelObserver* aVideoModelObserver ) + { + iVideoModelObserver = aVideoModelObserver; + } + +// --------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::CollectionLevelL() +// --------------------------------------------------------------------------- +// +TInt CVcxHgMyVideosCollectionClient::CollectionLevelL() + { + CMPXCollectionPath* path = iCollectionUtility->Collection().PathL(); + CleanupStack::PushL( path ); + TInt collectionLevel = path->Levels(); + CleanupStack::PopAndDestroy( path ); + + return collectionLevel; + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::GetCategoryListL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::GetCategoryListL() + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # GetCategoryListL()" ); + + if ( iCollectionOpenStatus == EVcxHgCollectionNotOpen ) + { + CMPXCollectionPath* collectionPath = CMPXCollectionPath::NewL(); + CleanupStack::PushL( collectionPath ); + collectionPath->AppendL( KVcxUidMyVideosMpxCollection ); + iCollectionUtility->Collection().OpenL( *collectionPath ); + CleanupStack::PopAndDestroy( collectionPath ); + + iCollectionOpenStatus = EVcxHgCollectionOpening; + } + else + { + if ( iCollectionLevel == KErrNotFound ) + { + iCollectionLevel = CollectionLevelL(); + } + if ( iCollectionLevel == KVcxMpxLevelVideos ) + { + iCollectionUtility->Collection().BackL(); + iCollectionLevel = KErrNotFound; + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::GetVideoListL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::GetVideoListL( TInt aIndex ) + { + IPTVLOGSTRING2_LOW_LEVEL( + "MPX My Videos UI # GetVideoListL(%d)", aIndex ); + + if ( iCollectionLevel == KErrNotFound ) + { + iCollectionLevel = CollectionLevelL(); + } + if ( iCollectionLevel == KVcxMpxLevelCategories ) + { + iCollectionUtility->Collection().OpenL( aIndex ); + iCollectionLevel = KErrNotFound; + } + else if ( iCollectionLevel == KVcxMpxLevelVideos ) + { + // OpenL() will return a list if there has been any changes. + // No reply if list is same as with previous OpenL(). + iCollectionUtility->Collection().OpenL(); + } + else + { + // NOP + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::ArrayIndexToMpxItemIdL() +// ----------------------------------------------------------------------------- +// +TMPXItemId CVcxHgMyVideosCollectionClient::ArrayIndexToMpxItemIdL( TInt aArrayIndex, + CMPXMediaArray* aArray ) + { + if ( aArrayIndex < 0 || aArrayIndex >= aArray->Count() ) + { + User::Leave( KErrArgument ); + } + + return (*aArray)[aArrayIndex]->ValueTObjectL( KMPXMediaGeneralId ); + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::DeleteVideosL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::DeleteVideosL( CMPXMediaArray* aMediasToDelete ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # CVcxHgMyVideosCollectionClient::DeleteVideosL()" ); + + if ( ! HasPendingCommand() && ! iDownloadClient->HasPendingCommand() ) + { + CMPXCommand* cmd = CMPXMedia::NewL(); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos ); + cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosDelete ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse ); + cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, + TUid::Uid( KVcxUidMyVideosMpxCollection ) ); + cmd->SetCObjectValueL( KMPXMediaArrayContents, aMediasToDelete ); + + iCollectionUtility->Collection().CommandL( *cmd ); + + iPendingCommand = EVcxHgMyVideosCollectionCommandMultiDelete_Starting; + CleanupStack::PopAndDestroy( cmd ); + } + else + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # CVcxHgMyVideosCollectionClient::DeleteVideosL() LEAVE: KErrNotReady" ); + User::Leave( KErrNotReady ); + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::CancelDeleteVideosL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::CancelDeleteVideosL() + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # CVcxHgMyVideosCollectionClient::CancelDeleteVideosL()" ); + + // Deletion can be cancelled right away if deletion has already started. If we + // are only waiting for it, we modify the pending command to indicate cancellation. + if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMultiDelete_Started || + iPendingCommand == EVcxHgMyVideosCollectionCommandMultiDelete_Finished ) + { + CMPXCommand* cmd = CMPXMedia::NewL(); + CleanupStack::PushL( cmd ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos ); + cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosCancelDelete ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, + TUid::Uid( KVcxUidMyVideosMpxCollection ) ); + iCollectionUtility->Collection().CommandL( *cmd ); + CleanupStack::PopAndDestroy( cmd ); + + iPendingCommand = EVcxHgMyVideosCollectionCommandCancelDelete_Completed; + } + else if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMultiDelete_Starting ) + { + iPendingCommand = EVcxHgMyVideosCollectionCommandCancelDelete_Requested; + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::MoveOrCopyVideosL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::MoveOrCopyVideosL( CMPXMediaArray* mediasToMoveOrCopy, + TInt aTargetDrive, + TBool aCopy ) + { + CMPXCommand* cmd = CMPXMedia::NewL(); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos ); + if ( aCopy ) + { + cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosCopy ); + } + else + { + cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosMove ); + } + cmd->SetTObjectValueL( KVcxMediaMyVideosInt32Value, aTargetDrive ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse ); + cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, + TUid::Uid( KVcxUidMyVideosMpxCollection ) ); + cmd->SetCObjectValueL( KMPXMediaArrayContents, mediasToMoveOrCopy ); + + iCollectionUtility->Collection().CommandL(*cmd); + iPendingCommand = EVcxHgMyVideosCollectionCommandMoveCopy_Starting; + CleanupStack::PopAndDestroy( cmd ); + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::CancelMoveOrCopyVideosL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::CancelMoveOrCopyVideosL() + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # CVcxHgMyVideosCollectionClient::CancelMoveOrCopyVideosL()" ); + + if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMoveCopy_Started || + iPendingCommand == EVcxHgMyVideosCollectionCommandMoveCopy_Finished ) + { + CMPXCommand* cmd = CMPXMedia::NewL(); + CleanupStack::PushL( cmd ); + cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos ); + cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosCancelMoveOrCopy ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, + TUid::Uid( KVcxUidMyVideosMpxCollection ) ); + iCollectionUtility->Collection().CommandL( *cmd ); + CleanupStack::PopAndDestroy( cmd ); + + iPendingCommand = EVcxHgMyVideosCollectionCommandCancelMoveCopy_Completed; + } + else if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMoveCopy_Starting ) + { + iPendingCommand = EVcxHgMyVideosCollectionCommandCancelMoveCopy_Requested; + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::PlayVideoL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::PlayVideoL( TMPXItemId aMpxItemId ) + { + IPTVLOGSTRING2_LOW_LEVEL( + "CVcxHgMyVideosCollectionClient::PlayVideoL: Play video at collection index %d", aMpxItemId.iId1 ); + + CMPXCollectionPath* path = CMPXCollectionPath::NewL(); + CleanupStack::PushL(path); + + path->AppendL( KVcxUidMyVideosMpxCollection ); + path->AppendL( KVcxMvcCategoryIdAll ); + path->AppendL( aMpxItemId ); + path->SelectL( aMpxItemId ); + + iCollectionUtility->Collection().OpenL( *path ); + CleanupStack::PopAndDestroy(path); + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::FetchMpxMediaByMpxIdL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::FetchMpxMediaByMpxIdL( TMPXItemId& aMpxId ) + { + if ( ! iDownloadClient->HasPendingCommand() ) + { + CMPXCommand* cmd = CMPXCommand::NewL(); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos ); + cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosGetMediasByMpxId ); + cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, + TUid::Uid( KVcxUidMyVideosMpxCollection ) ); + cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, KVcxHgMyVideosTransactionId ); + CMPXMediaArray* idMediaArray = CMPXMediaArray::NewL(); + CleanupStack::PushL( idMediaArray ); + CMPXMedia* media = CMPXMedia::NewL(); + CleanupStack::PushL( media ); + media->SetTObjectValueL( KMPXMessageMediaGeneralId, aMpxId ); + idMediaArray->AppendL( *media ); + CleanupStack::PopAndDestroy( media ); + cmd->SetCObjectValueL( KMPXMediaArrayContents, idMediaArray ); + cmd->SetTObjectValueL( KMPXMediaArrayCount, idMediaArray->Count() ); + + iCollectionUtility->Collection().CommandL( *cmd ); + + CleanupStack::PopAndDestroy( idMediaArray ); + CleanupStack::PopAndDestroy( cmd ); + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::GetVideoDetailsL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::GetVideoDetailsL( TMPXItemId& aMpxId ) + { + if ( ! HasPendingCommand() && ! iDownloadClient->HasPendingCommand() ) + { + CMPXCommand* cmd = CMPXCommand::NewL(); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos ); + cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosGetMediaFullDetailsByMpxId ); + cmd->SetTObjectValueL( KMPXMediaGeneralId, aMpxId ); + + iCollectionUtility->Collection().CommandL( *cmd ); + iPendingCommand = EVcxHgMyVideosCollectionCommandVideoDetails_Requested; + CleanupStack::PopAndDestroy( cmd ); + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleCollectionMediaL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleCollectionMediaL( + const CMPXMedia& /*aMedia*/, + TInt /*aError*/ ) + { + // No implemetation required. + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleCollectionMessage() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleCollectionMessage( + CMPXMessage* aMessage, + TInt aError ) + { + TRAP_IGNORE( HandleCollectionMessageL( aMessage, aError ) ); + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleCollectionMessageL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleCollectionMessageL( + CMPXMessage* aMessage, + TInt aError ) + { + TInt myVideosCmd( KErrNotFound ); + if ( aMessage->ValueTObjectL( KMPXMessageGeneralId ) == KVcxCommandIdMyVideos ) + { + myVideosCmd = aMessage->ValueTObjectL( KVcxMediaMyVideosCommandId ); + } + + if ( myVideosCmd == KVcxMessageMyVideosMessageArray ) + { + if ( aMessage->IsSupported( KMPXMessageArrayContents ) ) + { + const CMPXMessageArray* messageArray = + aMessage->Value(KMPXMessageArrayContents); + for ( TInt i = 0; i < messageArray->Count(); i++ ) + { + HandleSingleCollectionMessageL( (*messageArray)[i], KErrNone ); + } + } + } + else + { + HandleSingleCollectionMessageL( aMessage, aError ); + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleSingleCollectionMessageL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleSingleCollectionMessageL( + CMPXMessage* aMessage, + TInt aError ) + { +#ifdef _DEBUG + if ( aMessage->IsSupported( KVcxMediaMyVideosMessageId ) ) + { + IPTVLOGSTRING3_LOW_LEVEL( + "MPX My Videos UI # HandleSingleCollectionMessageL(xxx,%d) MessageId: %d", + aError, + static_cast( *( aMessage->Value( KVcxMediaMyVideosMessageId ) ) ) ); + } + else +#endif // _DEBUG + { + IPTVLOGSTRING2_LOW_LEVEL( + "MPX My Videos UI # HandleSingleCollectionMessageL(xxx,%d)", aError ); + } + + if ( aMessage && aError == KErrNone ) + { + switch ( *( aMessage->Value( KMPXMessageGeneralId ) ) ) + { + case KVcxCommandIdMyVideos: + { + if ( aMessage->IsSupported( KVcxMediaMyVideosCommandId ) ) + { + TInt mvMsgId = *(aMessage->Value( KVcxMediaMyVideosCommandId ) ); + + switch ( mvMsgId ) + { + case KVcxMessageMyVideosGetMediasByMpxIdResp: + HandleGetMediasByMpxIdRespL( aMessage, aError ); + break; + case KVcxMessageMyVideosItemsAppended: + HandleMyVideosItemsAppendedL( aMessage, aError ); + break; + case KVcxMessageMyVideosListComplete: + HandleMyVideosListCompleteL( aMessage, aError ); + break; + case KVcxMessageMyVideosDeleteStarted: + case KVcxMessageMyVideosDeleteResp: + HandleMyVideosDeleteMessageL( aMessage, aError ); + break; + case KVcxMessageMyVideosMoveOrCopyStarted: + case KVcxMessageMyVideosMoveResp: + case KVcxMessageMyVideosCopyResp: + HandleMyVideosMoveOrCopyMessageL( aMessage, aError ); + break; + default: + break; + } + } + } + break; + case KMPXMessageGeneral: + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # KMPXMessageGeneral" ); + + TInt event( *(aMessage->Value( KMPXMessageGeneralEvent )) ); + TInt data( *(aMessage->Value( KMPXMessageGeneralData )) ); + + switch ( event ) + { + case TMPXCollectionMessage::EPathChanged: + { + if ( data == EMcContainerOpened ) + { + if ( iCollectionOpenStatus == EVcxHgCollectionOpening ) + { + iCollectionOpenStatus = EVcxHgCollectionOpened; + } + iCollectionUtility->Collection().OpenL(); + } + iCollectionLevel = CollectionLevelL(); + } + break; + case TMPXCollectionMessage::ECollectionChanged: + { + // NOP, called when My Videos collection initially opened. + } + break; + case TMPXCollectionMessage::EBroadcastEvent: + case TMPXCollectionMessage::ENoEvent: + case TMPXCollectionMessage::EError: + case TMPXCollectionMessage::EMediaChanged: + case TMPXCollectionMessage::EItemChanged: + case TMPXCollectionMessage::EFocusChanged: + case TMPXCollectionMessage::EAsyncOpComplete: + case TMPXCollectionMessage::EExtendedMessage: + default: + break; + } + } + break; + case KMPXMessageIdItemChanged: + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleSingleCollectionMessageL() KMPXMessageIdItemChanged" ); + // Handle messages from our plugin only, this check skips also array messages (KMPXMessageArrayContents) + if ( aMessage->IsSupported( KMPXMessageCollectionId ) ) + { + TUid collectionUid( *(aMessage->Value( KMPXMessageCollectionId )) ); + IPTVLOGSTRING2_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosItemsChangedL() CollectionUid=%X", collectionUid.iUid ); + if ( collectionUid.iUid == KVcxUidMyVideosMpxCollection ) + { + HandleMyVideosItemsChangedL( aMessage, aError ); + } + } + } + break; + default: + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleSingleCollectionMessageL() ???" ); + } + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleOpenL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleOpenL( + const CMPXMedia& aEntries, + TInt /*aIndex*/, + TBool /*aComplete*/, + TInt aError ) + { + IPTVLOGSTRING2_LOW_LEVEL( + "MPX My Videos UI # HandleOpenL(aError=%d)", aError ); + + if ( aError == KErrNone ) + { + TInt levels = CollectionLevelL(); + + if ( levels == KVcxMpxLevelCategories ) + { + // Check that entry has an array of contents. + if ( aEntries.IsSupported( KMPXMediaArrayContents ) ) + { + CMPXMediaArray* pointerArray = + aEntries.Value(KMPXMediaArrayContents); + CMPXMediaArray* categoryArray = CMPXMediaArray::NewL( *pointerArray ); + CleanupStack::PushL( categoryArray ); + + if ( iCategoryModelObserver ) + { + TBool isPartial( EFalse ); + if ( aEntries.IsSupported( KVcxMediaMyVideosVideoListIsPartial ) ) + { + isPartial = aEntries.ValueTObjectL( KVcxMediaMyVideosVideoListIsPartial ); + } + iCategoryModelObserver->NewCategoryListL( categoryArray, isPartial ); + CleanupStack::Pop( categoryArray ); + } + else + { + CleanupStack::PopAndDestroy( categoryArray ); + } + } + } + else if ( levels == KVcxMpxLevelVideos ) + { + // Check that entry has an array of contents. + if ( aEntries.IsSupported( KMPXMediaArrayContents ) ) + { + CMPXMediaArray* pointerArray = + aEntries.Value(KMPXMediaArrayContents); + CMPXMediaArray* videoArray = CMPXMediaArray::NewL( *pointerArray ); + CleanupStack::PushL( videoArray ); + +#if defined(_DEBUG) && IPTV_LOGGING_METHOD != 0 + DebugPrintVideoListL( videoArray ); +#endif // _DEBUG && IPTV_LOGGING_METHOD + + if ( iVideoModelObserver ) + { + iVideoModelObserver->NewVideoListL( *videoArray ); + } + CleanupStack::PopAndDestroy( videoArray ); + } + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleOpenL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleOpenL( + const CMPXCollectionPlaylist& /*aPlaylist*/, + TInt /*aError*/ ) + { + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleCommandComplete() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleCommandComplete( + CMPXCommand* aCommandResult, + TInt aError ) + { + IPTVLOGSTRING2_LOW_LEVEL( + "MPX My Videos UI # HandleCommandComplete(xxx,%d)", aError ); + + if ( iDownloadClient->HasPendingCommand() ) + { + TRAP_IGNORE( iDownloadClient->CommandCompleteL( aError ) ); + } + else if ( HasPendingCommand() ) + { + // If "HandleCommandComplete" is received before our state has moved to + // "Operation_Finished", MPX has mixed the events asynchronously. In those + // cases we don't clear the pending command yet, but instead we mark what + // happened and the "Operation_Finished" handler will clear the command. + if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMoveCopy_Started ) + { + iPendingCommand = EVcxHgMyVideosCollectionCommandMoveCopy_Finished; + } + else if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMultiDelete_Started ) + { + iPendingCommand = EVcxHgMyVideosCollectionCommandMultiDelete_Finished; + } + else if ( iPendingCommand == EVcxHgMyVideosCollectionCommandVideoDetails_Requested ) + { + TRAP_IGNORE( HandleGetVideoDetailsRespL( aCommandResult, aError ) ); + iPendingCommand = EVcxHgMyVideosCollectionCommandNone; + } + else if ( iPendingCommand != EVcxHgMyVideosCollectionCommandCancelDelete_Completed && + iPendingCommand != EVcxHgMyVideosCollectionCommandCancelMoveCopy_Completed ) + { + iPendingCommand = EVcxHgMyVideosCollectionCommandNone; + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleMyVideosItemsAppendedL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleMyVideosItemsAppendedL( CMPXMessage* aMessage, + TInt /*aError*/ ) + { + IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # HandleMyVideosItemsAppendedL()" ); + + TInt levels = CollectionLevelL(); + TBool categoryEvent( EFalse ); + + if ( aMessage->IsSupported( KMPXMessageGeneralId ) ) + { + categoryEvent = ( aMessage->Value( KMPXMessageGeneralId )->iId2 == 1 ); + } + + // Check that necessary events are not filtered out. + + if ( levels == KVcxMpxLevelCategories ) + { + if ( iCategoryModelObserver && categoryEvent ) + { + iCategoryModelObserver->CategoryListModifiedL(); + } + } + else if ( levels == KVcxMpxLevelVideos ) + { + if ( iVideoModelObserver && ! categoryEvent ) + { + iVideoModelObserver->VideoListModifiedL(); + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleMyVideosItemsChangedL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleMyVideosItemsChangedL( CMPXMessage* aMessage, + TInt /*aError*/ ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosItemsChangedL()" ); + + TMPXChangeEventType eventType( + *aMessage->Value( KMPXMessageChangeEventType ) ); + TMPXItemId eventData( + *aMessage->Value( KMPXMessageMediaGeneralId ) ); + + TInt levels = CollectionLevelL(); + TInt eventlevel( KVcxHgEventLevelVideo ); + + if ( eventData.iId2 == KVcxUidMyVideosMpxCollection ) + { + eventlevel = KVcxHgEventLevelRoot; + } + else if ( eventData.iId2 == 1 ) + { + eventlevel = KVcxHgEventLevelCategory; + } + else + { + eventlevel = KVcxHgEventLevelVideo; + } + + // Check that necessary events are not filtered out. + + // If root level is modified, it means that MMC has been plugged / + // unplugged. For video view the changed video list will be retrieved + // based on change of parent category, but for category view we need + // to re-open the list. + if ( eventlevel == KVcxHgEventLevelRoot ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosItemsChangedL() - MMC plugged/unplugged." ); + + if ( levels == KVcxMpxLevelCategories ) + { + iCollectionUtility->Collection().OpenL(); + } + } + else + { + if ( levels == KVcxMpxLevelCategories ) + { + if ( iCategoryModelObserver ) + { + iCategoryModelObserver->CategoryModifiedL( eventType, eventData ); + } + } + else if ( levels == KVcxMpxLevelVideos ) + { + TInt32 extraInfo( EVcxMyVideosListNoInfo ); + if ( aMessage->IsSupported( KVcxMediaMyVideosInt32Value ) ) + { + extraInfo = aMessage->ValueTObjectL( KVcxMediaMyVideosInt32Value ); + } + + if ( iVideoModelObserver && + ( eventlevel == KVcxHgEventLevelVideo || + extraInfo == EVcxMyVideosVideoListOrderChanged ) ) + { + iVideoModelObserver->VideoModifiedL( eventType, eventData, extraInfo ); + } + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleMyVideosDeleteMessageL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleMyVideosDeleteMessageL( CMPXMessage* aMessage, + TInt aError ) + { + IPTVLOGSTRING2_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosDeleteMessageL() aError = %d", aError ); + + TInt mvMsgId( aMessage->ValueTObjectL( KVcxMediaMyVideosCommandId ) ); + + // CancelDelete_Requested is used to indicate that user wanted to cancel the deletion + // when we still hadn't received KVcxMessageMyVideosDeleteStarted message. Therefore + // we needed to wait until now to cancel the deletion. + if ( iPendingCommand == EVcxHgMyVideosCollectionCommandCancelDelete_Requested ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosDeleteMessageL() - Cancelling." ); + + // Use convenient value so that CancelDeleteVideosL() will perform immediate cancel. + iPendingCommand = EVcxHgMyVideosCollectionCommandMultiDelete_Started; + + CancelDeleteVideosL(); + return; + } + // CancelDelete_Completed is used to indicate that cancellation of deletion is now + // completed. Cancel never shows error notes, that's why special handling is needed. + else if ( iPendingCommand == EVcxHgMyVideosCollectionCommandCancelDelete_Completed ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosDeleteMessageL() - Cancelled." ); + + if ( iVideoModelObserver ) + { + TMPXItemId emptyMpxItemId; + iVideoModelObserver->VideoDeletionCompletedL( 0, emptyMpxItemId ); + } + iPendingCommand = EVcxHgMyVideosCollectionCommandNone; + return; + } + + if ( mvMsgId == KVcxMessageMyVideosDeleteStarted ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosDeleteMessageL() - Delete started." ); + + iPendingCommand = EVcxHgMyVideosCollectionCommandMultiDelete_Started; + } + else // aMessage == KVcxMessageMyVideosDeleteResp + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosDeleteMessageL() - Delete Resp (finished)." ); + + // See HandleCommandComplete(). + if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMultiDelete_Finished ) + { + iPendingCommand = EVcxHgMyVideosCollectionCommandNone; + } + else + { + iPendingCommand = EVcxHgMyVideosCollectionCommandMultiDelete_Finished; + } + + CMPXMediaArray* messageArray = aMessage->Value( + KMPXMediaArrayContents ); + + TInt32 failedCount( 0 ); + TMPXItemId latestMpxItemId; + + for ( TInt i = 0; i < messageArray->Count(); i++ ) + { + if ( messageArray->AtL( i )->ValueTObjectL( KVcxMediaMyVideosInt32Value ) + != KErrNone ) + { + failedCount++; + latestMpxItemId = + messageArray->AtL( i )->ValueTObjectL( KMPXMediaGeneralId ); + } + else + { + if ( iVideoModelObserver ) + { + // Sending remove request to video list model. This ensures that + // the deleted videos has removed from a video list before the + // progress bar disappears. + TMPXItemId removedItemId = + messageArray->AtL( i )->ValueTObjectL( KMPXMediaGeneralId ); + iVideoModelObserver->VideoModifiedL( + EMPXItemDeleted, removedItemId, EVcxMyVideosListNoInfo ); + } + } + } + + if ( iVideoModelObserver ) + { + iVideoModelObserver->VideoDeletionCompletedL( failedCount, latestMpxItemId ); + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleMyVideosMoveOrCopyMessageL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleMyVideosMoveOrCopyMessageL( CMPXMessage* aMessage, + TInt aError ) + { + IPTVLOGSTRING2_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosMoveOrCopyMessageL() aError = %d", aError ); + + TInt mvMsgId( aMessage->ValueTObjectL( KVcxMediaMyVideosCommandId ) ); + + if ( iPendingCommand == EVcxHgMyVideosCollectionCommandCancelMoveCopy_Requested ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosMoveOrCopyMessageL() - Cancelling." ); + iPendingCommand = EVcxHgMyVideosCollectionCommandMoveCopy_Started; + CancelMoveOrCopyVideosL(); + return; + } + else if ( iPendingCommand == EVcxHgMyVideosCollectionCommandCancelMoveCopy_Completed ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosMoveOrCopyMessageL() - Cancelled." ); + if ( iVideoModelObserver ) + { + TMPXItemId emptyMpxItemId; + iVideoModelObserver->VideoMoveOrCopyCompletedL( 0, emptyMpxItemId ); + } + iPendingCommand = EVcxHgMyVideosCollectionCommandNone; + return; + } + + if ( mvMsgId == KVcxMessageMyVideosMoveOrCopyStarted ) + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosMoveOrCopyMessageL() - Move/copy started." ); + + iPendingCommand = EVcxHgMyVideosCollectionCommandMoveCopy_Started; + } + else // KVcxMessageMyVideosMoveResp || KVcxMessageMyVideosCopyResp + { + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # HandleMyVideosMoveOrCopyMessageL() - Move/copy finished." ); + + // See HandleCommandComplete(). + if ( iPendingCommand == EVcxHgMyVideosCollectionCommandMoveCopy_Finished ) + { + iPendingCommand = EVcxHgMyVideosCollectionCommandNone; + } + else if ( iPendingCommand != EVcxHgMyVideosCollectionCommandNone ) + { + iPendingCommand = EVcxHgMyVideosCollectionCommandMoveCopy_Finished; + } + + CMPXMediaArray* messageArray = aMessage->Value( + KMPXMediaArrayContents ); + + TInt32 failedCount( 0 ); + TMPXItemId latestMpxItemId; + + for ( TInt i = 0; i < messageArray->Count(); i++ ) + { + TInt err = messageArray->AtL( i )->ValueTObjectL( KVcxMediaMyVideosInt32Value ); + if ( err != KErrNone && err != KErrAlreadyExists ) + { + failedCount++; + + latestMpxItemId = + messageArray->AtL( i )->ValueTObjectL( KMPXMediaGeneralId ); + } + } + + if ( iVideoModelObserver ) + { + iVideoModelObserver->VideoMoveOrCopyCompletedL( failedCount, latestMpxItemId ); + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleGetMediasByMpxIdRespL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleGetMediasByMpxIdRespL( CMPXMessage* aMessage, + TInt aError ) + { + IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # HandleGetMediasByMpxIdRespL()" ); + + if ( aError == KErrNone ) + { + CMPXMedia* entries = CMPXMedia::NewL( *aMessage ); + CleanupStack::PushL( entries ); + CMPXMediaArray* array = entries->Value( KMPXMediaArrayContents ); + if ( array->Count() >= 1 ) + { + TUint32 transactionId( 0 ); + + if ( aMessage->IsSupported( KVcxMediaMyVideosTransactionId ) ) + { + transactionId = aMessage->ValueTObjectL( KVcxMediaMyVideosTransactionId ); + } + + if ( transactionId == KVcxHgMyVideosTransactionId ) + { + if ( iVideoModelObserver ) + { + CMPXMedia* media = CMPXMedia::NewL( *( ( *array )[0] ) ); + // Ownership is transferred. + iVideoModelObserver->VideoFetchingCompletedL( media ); + } + } + } + CleanupStack::PopAndDestroy( entries ); + } + } + +// ----------------------------------------------------------------------------- +// +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleMyVideosListCompleteL( CMPXMessage* /*aMessage*/, + TInt aError ) + { + IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # HandleMyVideosListCompleteL()" ); + if ( aError == KErrNone ) + { + if ( iCategoryModelObserver ) + { + iCategoryModelObserver->CategoryListFetchingCompletedL(); + } + } + } + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::SetFlagsL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::SetFlagsL( TMPXItemId aMpxItemId, TUint32 aFlags ) +{ + CMPXMedia* msg = CMPXMedia::NewL(); + CleanupStack::PushL( msg ); + + msg->SetTObjectValueL( KMPXMediaGeneralId, TMPXItemId( aMpxItemId, KMpxMediaId2 )); + msg->SetTObjectValueL( KMPXMediaGeneralFlags, aFlags ); + + CMPXCommand* cmd = CMPXCommand::NewL(); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdCollectionSet ); + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + cmd->SetCObjectValueL( KMPXCommandColSetMedia, msg ); + cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, KVcxUidMyVideosMpxCollection ); + + iCollectionUtility->Collection().CommandL( *cmd ); + + CleanupStack::PopAndDestroy( cmd ); + CleanupStack::PopAndDestroy( msg ); +} + +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::HandleGetVideoDetailsRespL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::HandleGetVideoDetailsRespL( CMPXMessage* aMessage, + TInt aError ) + { + IPTVLOGSTRING_LOW_LEVEL( "MPX My Videos UI # HandleGetVideoDetailsRespL()" ); + + CMPXMedia* media( NULL ); + + if ( aError == KErrNone && aMessage && + aMessage->IsSupported( KMPXCommandColAddMedia ) ) + { + media = aMessage->Value( KMPXCommandColAddMedia ); + } + + if ( iVideoModelObserver && media ) + { + iVideoModelObserver->VideoDetailsCompletedL( *media ); + } + } + +#if defined(_DEBUG) && IPTV_LOGGING_METHOD != 0 +// ----------------------------------------------------------------------------- +// CVcxHgMyVideosCollectionClient::DebugPrintVideoListL() +// ----------------------------------------------------------------------------- +// +void CVcxHgMyVideosCollectionClient::DebugPrintVideoListL( CMPXMediaArray* aVideoArray ) + { + CMPXMedia* media = NULL; + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # --------------------------------------------------------" ); + for ( TInt i = 0; i < aVideoArray->Count(); i++ ) + { + media = (*aVideoArray)[i]; + + if ( media->IsSupported( KMPXMediaGeneralTitle ) && + media->IsSupported( KMPXMediaGeneralUri ) && + media->IsSupported( KMPXMediaGeneralId ) ) + { + IPTVLOGSTRING4_LOW_LEVEL( + "Video: %S / %S / %d", + &media->ValueText( KMPXMediaGeneralUri ), + &media->ValueText( KMPXMediaGeneralTitle ), + ( media->ValueTObjectL( KMPXMediaGeneralId ) ).iId1 ); + } + } + IPTVLOGSTRING_LOW_LEVEL( + "MPX My Videos UI # --------------------------------------------------------" ); + } +#endif // _DEBUG && IPTV_LOGGING_METHOD