--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videofeeds/vcnsuiengine/src/vcxnsmpxcollectionclienthandler.cpp Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,1693 @@
+/*
+* 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: Class for handling mpx collection interactions*
+*/
+
+
+
+
+#include <bldvariant.hrh>
+#include "IptvDebug.h"
+#include "CIptvUtil.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 <mpxlog.h>
+#include <mpxitemid.h>
+#include <mpxmessagecontainerdefs.h>
+#include <vcxmyvideosdefs.h>
+#include <vcxmyvideosuids.h>
+#include <mpxcommandgeneraldefs.h>
+#include <mpxcollectioncommanddefs.h>
+#include <HttpDownloadMgrCommon.h>
+
+#include "CIptvMyVideosGlobalFileId.h"
+#include "vcxnsmpxcollectionclienthandler.h"
+#include "vcxnscontentclienthandler.h"
+#include "vcxnsuiengine.h"
+#include "vcxnseventrouter.h"
+#include "vcxnscontentprovider.h"
+
+#include "vcxnsservice.h"
+#include "vcxnscontent.h"
+#include "vcxnscontentaccess.h"
+#include "vcxnsdownloadupdater.h"
+
+const TInt KMpxMediaId2 = 0;
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+CVcxNsMpxCollectionClientHandler::CVcxNsMpxCollectionClientHandler( CVcxNsUiEngine& aUiEngine )
+ : iUiEngine( aUiEngine ),
+ iMarkAsWatchedId( KErrNotFound )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+CVcxNsMpxCollectionClientHandler* CVcxNsMpxCollectionClientHandler::NewL(
+ CVcxNsUiEngine& aUiEngine )
+ {
+ CVcxNsMpxCollectionClientHandler* self =
+ new (ELeave) CVcxNsMpxCollectionClientHandler( aUiEngine );
+
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::ConstructL()
+ {
+ iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeDefault );
+
+ CMPXCollectionPath* path = CMPXCollectionPath::NewL();
+ CleanupStack::PushL( path );
+ path->AppendL( KVcxUidMyVideosMpxCollection );
+ iCollectionUtility->Collection().OpenL( *path );
+ CleanupStack::PopAndDestroy( path );
+
+ iDownloadUpdater = CVcxNsDownloadUpdater::NewL( this );
+
+ iGetMediaDetailWait = new ( ELeave ) CActiveSchedulerWait;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+CVcxNsMpxCollectionClientHandler::~CVcxNsMpxCollectionClientHandler()
+ {
+ iLastFetchedMedias.ResetAndDestroy();
+
+ iResumeArray.Close();
+ delete iDownloadUpdater;
+
+ if( iCollectionUtility )
+ {
+ iCollectionUtility->Close();
+ }
+
+ iDownloadedContents.Reset();
+
+ delete iGetMediaDetailWait;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVcxNsMpxCollectionClientHandler::DownloadL( CVcxNsService& aService,
+ CVcxNsContent& aContent )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DownloadL(s,c) IN");
+
+ aContent.SetDlFailNotified( EFalse );
+ aContent.SetUsernameL( aService.GetUserName() );
+ aContent.SetPasswordL( aService.GetPassword() );
+
+ if( aContent.PendingCommand() == CVcxNsContent::EVcxNsMpxContentCommandStartDownload ||
+ aContent.PendingCommand() == CVcxNsContent::EVcxNsMpxContentCommandResumeDownload ||
+ aContent.PendingCommand() == CVcxNsContent::EVcxNsMpxContentCommandWaitingForMpxItem )
+ {
+ // Download request is already made, but
+ // Collection hasn't processed it yet.
+ return KErrAlreadyExists;
+ }
+
+ if( aContent.PendingCommand() == CVcxNsContent::EVcxNsMpxContentCommandCancelDownload )
+ {
+ // Download request is already made, and user has cancelled
+ // it already, but Collection hasn't process the requests yet.
+ // So reset just the pending cmd data.
+ aContent.SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandNone );
+
+ return KErrNone;
+ }
+
+ TInt ret( KErrGeneral );
+
+ if( aContent.GetUrl( CVcxNsContent::EVcxContentTypeVideo ).Length() == 0 )
+ {
+ ret = KErrArgument;
+ }
+ else
+ {
+ TUint32 transactionId( 0 );
+
+ ret = DownloadL( aContent.GetUrl( CVcxNsContent::EVcxContentTypeVideo ),
+ aContent.GetName(),
+ aService.GetIap(),
+ aService.GetIsReadOnlyIap(),
+ aService.GetUserName(),
+ aService.GetPassword(),
+ transactionId );
+
+ if ( ret == KErrNone )
+ {
+ // To the download list. Content from Mpx events
+ // is resolved from the list.
+ AppendToDownloadList( &aContent );
+
+ aContent.SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandStartDownload );
+ aContent.SetCmdTransactionId( transactionId );
+
+ iUiEngine.ContentProvider()->UpdateContent( &aContent );
+ }
+ else
+ {
+ aContent.SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandNone );
+ }
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DownloadL(s,c) OUT");
+
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVcxNsMpxCollectionClientHandler::DownloadL( const TDesC& aAddress,
+ const TDesC& aName,
+ TUint32 aIapId,
+ TBool aIsReadOnlyIap,
+ const TDesC& aUserName,
+ const TDesC& aPassword,
+ TUint32& aTransactionId )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DownloadL() start");
+
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd ); // 1->
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );
+ cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosStartDownload );
+ cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse /* = async */ );
+ cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, ++iLatestTransactionId );
+ aTransactionId = iLatestTransactionId;
+
+ TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );
+ cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
+
+ CMPXMedia* startDownloadReq = CMPXMedia::NewL();
+ CleanupStack::PushL( startDownloadReq ); // 2->
+
+ TUint flags = ( aIsReadOnlyIap ? EVcxMyVideosServiceHasReadOnlyIap : 0 ) |
+ EVcxMyVideosSilent;
+
+ startDownloadReq->SetTObjectValueL( KMPXMediaGeneralFlags, flags );
+
+ if( aIsReadOnlyIap )
+ {
+ startDownloadReq->SetTObjectValueL( KVcxMediaMyVideosIapId, aIapId );
+ }
+ else
+ {
+ // not a read only iap, set iap 0 so download utility
+ // can select iap via connectionutility
+ startDownloadReq->SetTObjectValueL( KVcxMediaMyVideosIapId, 0 );
+ }
+
+ startDownloadReq->SetTextValueL( KVcxMediaMyVideosRemoteUrl, aAddress );
+ startDownloadReq->SetTextValueL( KVcxMediaMyVideosUsername, aUserName );
+ startDownloadReq->SetTextValueL( KVcxMediaMyVideosPassword, aPassword );
+ startDownloadReq->SetTextValueL( KMPXMediaGeneralTitle, aName );
+
+ cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, startDownloadReq );
+
+ iCollectionUtility->Collection().CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( startDownloadReq ); // <-2
+ CleanupStack::PopAndDestroy( cmd ); // <-1
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DownloadL() exit");
+
+ return KErrNone;
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVcxNsMpxCollectionClientHandler::PauseDownloadL( CVcxNsContent& aContent )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::PauseDownloadL IN");
+
+ TInt ret( KErrNone );
+
+ if( !aContent.GetMpxMedia() ||
+ !aContent.GetMpxMedia()->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId ) )
+ {
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::PauseDownloadL OUT, bad argument");
+
+ ret = KErrArgument;
+ }
+ else
+ {
+ CMPXMedia* media = CMPXMedia::NewL( *(aContent.GetMpxMedia()) );
+ CleanupStack::PushL( media );
+
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );
+ cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosPauseDownload );
+ cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse );
+
+ TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );
+ cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
+
+ TUint32 downloadId = media->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId );
+ cmd->SetTObjectValueL( KVcxMediaMyVideosDownloadId, downloadId );
+ iCollectionUtility->Collection().CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( cmd );
+ CleanupStack::PopAndDestroy( media );
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::PauseDownloadL OUT");
+
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVcxNsMpxCollectionClientHandler::ResumeDownloadL( CVcxNsContent& aContent )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::ResumeDownloadL IN");
+
+ aContent.SetDlFailNotified( EFalse );
+
+ TInt ret( KErrNone );
+
+ if( !aContent.GetMpxMedia() ||
+ !aContent.GetMpxMedia()->ValueTObjectL<TUint32>( KVcxMediaMyVideosDownloadId ) )
+ {
+ ret = KErrArgument;
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::ResumeDownloadL OUT, bad argument");
+ }
+ else
+ {
+ CMPXMedia* media = CMPXMedia::NewL( *(aContent.GetMpxMedia()) );
+ CleanupStack::PushL( media );
+
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );
+ cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosStartDownload );
+ cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse );
+
+ TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );
+ cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
+ cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, ++iLatestTransactionId );
+
+ IPTVLOGSTRING2_LOW_LEVEL("CVcxNsMpxCollectionClientHandler:: TR ID = %d", iLatestTransactionId);
+
+ TUint32 transactionId = iLatestTransactionId;
+
+ media->SetTObjectValueL( KVcxMediaMyVideosIapId, 0 );
+ media->SetTextValueL( KVcxMediaMyVideosUsername, aContent.GetUsername() );
+ media->SetTextValueL( KVcxMediaMyVideosPassword, aContent.GetPassword() );
+
+ cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, media );
+ iCollectionUtility->Collection().CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( cmd );
+ CleanupStack::PopAndDestroy( media );
+
+ aContent.SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandResumeDownload );
+ aContent.SetCmdTransactionId( transactionId );
+
+ AppendToDownloadList( &aContent );
+ iUiEngine.ContentProvider()->UpdateContent( &aContent );
+
+ TUint32 mpxId = aContent.GetMpxId();
+ if ( iResumeArray.Find( mpxId ) == KErrNotFound )
+ {
+ iResumeArray.AppendL( mpxId );
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::ResumeDownloadL OUT, cmd OK.");
+ }
+
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TInt CVcxNsMpxCollectionClientHandler::CancelDownloadL( CVcxNsContent& aContent )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::CancelDownloadL IN");
+
+ aContent.SetDlFailNotified( EFalse );
+
+ TInt ret( KErrNone );
+
+ if( !aContent.GetMpxMedia(CVcxNsContent::EVcxContentTypeVideo) )
+ {
+ // Even though cancel cannot be called now, it must be called later
+ // So mark the content to be pending the cancel.
+ aContent.SetPendingCommand ( CVcxNsContent::EVcxNsMpxContentCommandCancelDownload );
+
+ // Incremet cmd id, so the cmd is not reset when this
+ // content's previous cmd's complete msg arrives.
+ aContent.SetCmdTransactionId ( ++iLatestTransactionId );
+
+ // Redraw the fake state to user.
+ iUiEngine.ContentProvider()->UpdateContent( &aContent );
+ }
+ else
+ {
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );
+
+ cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId,
+ KVcxCommandMyVideosCancelDownload );
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, EFalse /* = async */ );
+ TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );
+ cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
+
+ CMPXMedia* media = aContent.GetMpxMedia( CVcxNsContent::EVcxContentTypeVideo );
+
+ if ( media )
+ {
+ cmd->SetCObjectValueL<CMPXMedia>( KMPXCommandColAddMedia, media );
+ cmd->SetTObjectValueL( KVcxMediaMyVideosTransactionId, ++iLatestTransactionId );
+
+ iCollectionUtility->Collection().CommandL( *cmd );
+ }
+
+ CleanupStack::PopAndDestroy( cmd );
+
+ aContent.SetPendingCommand ( CVcxNsContent::EVcxNsMpxContentCommandCancelDownload );
+ aContent.SetCmdTransactionId ( iLatestTransactionId );
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::CancelDownloadL OUT");
+
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectsL()
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectsL IN");
+
+ RArray<TUint32> ids;
+ CleanupClosePushL( ids );
+
+ for( TInt i = 0; i < iDownloadedContents.Count(); i++ )
+ {
+ if( (iDownloadedContents[i])->GetMpxId() )
+ {
+ ids.Append( (iDownloadedContents[i])->GetMpxId() );
+ }
+ }
+
+ GetMediaByMpxIdReqL( ids );
+ CleanupStack::PopAndDestroy( &ids );
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectsL OUT");
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectL( TUint32 aMpxId )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectL IN");
+
+ RArray<TUint32> id;
+ CleanupClosePushL( id );
+ id.Append( aMpxId );
+ GetMediaByMpxIdReqL( id );
+ CleanupStack::PopAndDestroy( &id );
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LoadMpxMediaObjectL OUT");
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::HandleCollectionMediaL( const CMPXMedia& aMedia,
+ TInt aError )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleCollectionMediaL");
+
+ if ( aError == KErrNone )
+ {
+ SearchAndAddMpxMediaL( & const_cast<CMPXMedia&>( aMedia ) );
+
+ if ( aMedia.IsSupported( KMPXMediaGeneralId ) )
+ {
+ iLastFetchedMedias.ResetAndDestroy();
+ iLastFetchedMedias.Append( CMPXMedia::NewL( aMedia ) );
+ }
+ }
+
+ if ( iGetMediaDetailWait->IsStarted() )
+ {
+ iGetMediaDetailWait->AsyncStop();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::HandleCollectionMessage
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::HandleCollectionMessage(CMPXMessage* aMessage,
+ TInt aError )
+ {
+ TRAPD( err, ExplodeCollectionMessagesL( aMessage, aError ) );
+
+ if ( err != KErrNone )
+ {
+ IPTVLOGSTRING2_LOW_LEVEL(
+"CVcxNsMpxCollectionClientHandler::ExplodeCollectionMessagesL() leaved with error code %d", err);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::ExplodeCollectionMessagesL
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::ExplodeCollectionMessagesL(CMPXMessage* aMessage,
+ TInt aError )
+ {
+ if ( !aMessage )
+ {
+ return;
+ }
+
+ TInt cmdId = aMessage->ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId );
+ TInt myVideosCmd = -1;
+
+ if ( cmdId == KVcxCommandIdMyVideos )
+ {
+ myVideosCmd = aMessage->ValueTObjectL<TInt>( KVcxMediaMyVideosCommandId );
+ }
+
+ if ( myVideosCmd != KVcxMessageMyVideosMessageArray )
+ {
+ HandleSingleCollectionMessageL( aMessage, aError );
+ }
+ else
+ {
+ if ( aMessage->IsSupported( KMPXMessageArrayContents ) )
+ {
+ const CMPXMessageArray* messageArray =
+ aMessage->Value<CMPXMessageArray>(KMPXMessageArrayContents);
+
+ if ( messageArray->Count() > 0 )
+ {
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler:: ----------------------.");
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler:: MESSAGE ARRAY ARRIVED |");
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler:: ----------------------'");
+ }
+
+ for( TInt i = 0; i < messageArray->Count(); i++ )
+ {
+ HandleSingleCollectionMessageL( messageArray->AtL( i ), aError );
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::HandleSingleCollectionMessageL( CMPXMessage* aMsg,
+ TInt aErr )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleSingleCollectionMessageL IN");
+
+#ifdef _DEBUG
+
+ TMPXMessageId msgId = 0;
+ if ( aMsg->IsSupported( KMPXMessageGeneralId ) )
+ {
+ msgId = aMsg->ValueTObjectL<TMPXMessageId>(KMPXMessageGeneralId);
+ }
+
+ TUid colId;
+ colId.iUid = 0;
+ if ( aMsg->IsSupported( KMPXMessageCollectionId ) )
+ {
+ colId = aMsg->ValueTObjectL<TUid>(KMPXMessageCollectionId);
+ }
+
+ TMPXChangeEventType type = static_cast<TMPXChangeEventType>( -1 );
+ if ( aMsg->IsSupported( KMPXMessageChangeEventType ) )
+ {
+ type = aMsg->ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType);
+ }
+
+ TMPXItemId itemId(0,0);
+ if ( aMsg->IsSupported( KMPXMessageMediaGeneralId ) )
+ {
+ itemId = aMsg->ValueTObjectL<TMPXItemId>( KMPXMessageMediaGeneralId );
+ }
+ else
+ {
+ IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## HandleSingleCollectionMessageL() : KMPXMessageMediaGeneralId not supported!");
+ }
+
+ TInt cmdId = -1;
+ if ( aMsg->IsSupported( KVcxMediaMyVideosCommandId ) )
+ {
+ cmdId = aMsg->ValueTObjectL<TInt>( KVcxMediaMyVideosCommandId );
+ }
+
+ IPTVLOGSTRING2_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : msgId = %d", msgId );
+ IPTVLOGSTRING2_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : colId = %x", colId );
+
+ switch ( type )
+ {
+ case EMPXItemDeleted:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : type = EMPXItemDeleted" );
+ break;
+ case EMPXItemInserted:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : type = EMPXItemInserted" );
+ break;
+ case EMPXItemModified:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : type = EMPXItemModified" );
+ break;
+ }
+
+ IPTVLOGSTRING3_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : KMPXMessageMediaGeneralId = %d,%d", itemId.iId1, itemId.iId2 );
+ IPTVLOGSTRING2_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : aErr = %d", aErr );
+
+ switch ( cmdId )
+ {
+ case KVcxMessageMyVideosGetMediasByMpxIdResp:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : cmd Id = KVcxMessageMyVideosGetMediasByMpxIdResp" );
+
+ if ( aMsg->IsSupported( KMPXMediaArrayContents ) )
+ {
+ const CMPXMessageArray* videoArray =
+ aMsg->Value<CMPXMessageArray>(KMPXMediaArrayContents);
+
+ TInt count = videoArray->Count();
+ CMPXMedia* video;
+ TMPXItemId mpxId;
+ for ( TInt i = 0; i < count; i++ )
+ {
+ video = videoArray->AtL( i );
+ mpxId = video->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+ IPTVLOGSTRING3_HIGH_LEVEL("UI Engine ## HandleSingleCollectionMessageL() : contains video MPXID: %d,%d", mpxId.iId1, mpxId.iId2 );
+ }
+ }
+ else
+ {
+ IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## HandleSingleCollectionMessageL() : EMPTY KVcxMessageMyVideosGetMediasByMpxIdResp, SHOULD NOT HAPPEN");
+ }
+
+ break;
+
+ case KVcxMessageMyVideosItemsAppended:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : cmd Id = KVcxMessageMyVideosItemsAppended" );
+ break;
+
+ case KVcxMessageMyVideosListComplete:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : cmd Id = KVcxMessageMyVideosListComplete" );
+ break;
+
+ case KVcxMessageMyVideosMoveOrCopyStarted:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : cmd Id = KVcxMessageMyVideosMoveOrCopyStarted" );
+ break;
+
+ case KVcxMessageMyVideosDeleteStarted:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : cmd Id = KVcxMessageMyVideosDeleteStarted" );
+ break;
+
+ case KVcxMessageMyVideosMoveResp:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : cmd Id = KVcxMessageMyVideosMoveResp" );
+ break;
+
+ case KVcxMessageMyVideosCopyResp:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : cmd Id = KVcxMessageMyVideosCopyResp" );
+ break;
+
+ case KVcxMessageMyVideosDeleteResp:
+ IPTVLOGSTRING_HIGH_LEVEL(
+ "UI Engine ## HandleSingleCollectionMessageL() : cmd Id = KVcxMessageMyVideosDeleteResp" );
+ break;
+
+ }
+
+
+#endif // _DEBUG
+
+ DoHandleSingleCollectionMessageL( aMsg, aErr );
+
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::HandleSingleCollectionMessage OUT");
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::HandleOpenL( const CMPXCollectionPlaylist&
+ /*aPlaylist*/, TInt /*aError*/ )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleOpenL( playlist )");
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::HandleOpenL( const CMPXMedia& /*aEntries*/,
+ TInt /*aIndex*/, TBool /*aComplete*/, TInt /*aError*/ )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleOpenL( aEntries )");
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::HandleCommandComplete( CMPXCommand* aCommandResult,
+ TInt /*aError*/ )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleCommandComplete IN");
+
+ TInt32 error( KErrNone );
+
+ if ( aCommandResult->IsSupported( KVcxMediaMyVideosInt32Value ) )
+ {
+ error = aCommandResult->ValueTObjectL<TInt32>( KVcxMediaMyVideosInt32Value );
+ }
+
+ TInt tid = -1;
+
+ if( aCommandResult->IsSupported( KVcxMediaMyVideosTransactionId ) )
+ {
+ tid = aCommandResult->ValueTObjectL<TInt>( KVcxMediaMyVideosTransactionId );
+ }
+
+ TMPXItemId mpxId( 0, 0 );
+
+ if ( aCommandResult->IsSupported( KMPXMediaGeneralId ) )
+ {
+ mpxId = aCommandResult->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+ }
+
+ if( error != KErrNone )
+ {
+ for( TInt i = iDownloadedContents.Count() - 1; i >= 0; i-- )
+ {
+ if( (iDownloadedContents[i])->CmdTransactionId() == tid )
+ {
+ IPTVLOGSTRING2_HIGH_LEVEL( "UI Engine ## clearing failed (TR ID = %d) command", tid);
+ (iDownloadedContents[i])->SetPendingCommand(
+ CVcxNsContent::EVcxNsMpxContentCommandNone );
+ iUiEngine.ContentProvider()->UpdateContent( iDownloadedContents[i] );
+ break;
+ }
+ }
+ IPTVLOGSTRING2_HIGH_LEVEL( "UI Engine ## HandleCommandComplete() OUT, error = %d ",
+ error);
+ return;
+ }
+
+ if( !aCommandResult )
+ {
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::HandleCommandComplete OUT, aResult == NULL");
+ return;
+ }
+
+ if( aCommandResult->IsSupported( KVcxMediaMyVideosTransactionId ) )
+ {
+ IPTVLOGSTRING2_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::HandleCommandComplete , trid == %d", tid );
+
+ // See which content's request is processed.
+ for( TInt i = iDownloadedContents.Count() - 1; i >= 0 ; i-- )
+ {
+ if( (iDownloadedContents[i])->CmdTransactionId() == tid )
+ {
+ switch ( (iDownloadedContents[i])->PendingCommand() )
+ {
+ case CVcxNsContent::EVcxNsMpxContentCommandCancelDownload:
+ {
+ IPTVLOGSTRING_LOW_LEVEL("UI Engine ## command complete EVcxNsMpxContentCommandCancelDownload OK");
+ (iDownloadedContents[i])->SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandNone );
+ TMPXItemId mpxId = aCommandResult->Value<CMPXMedia>( KMPXCommandColAddMedia )
+ ->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+ DeleteDownload( mpxId );
+ }
+ break;
+
+ case CVcxNsContent::EVcxNsMpxContentCommandStartDownload:
+ (iDownloadedContents[i])->SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandWaitingForMpxItem );
+ break;
+
+ default:
+ (iDownloadedContents[i])->SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandNone );
+ iUiEngine.ContentProvider()->UpdateContent( iDownloadedContents[i] );
+ break;
+ }
+ break;
+ }
+ }
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleCommandComplete OUT");
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::GetMediaByMpxIdReqL
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::GetMediaByMpxIdReqL( RArray<TUint32>& aMpxIds )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::GetMediaByMpxIdReqL IN");
+
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralId, KVcxCommandIdMyVideos );
+ cmd->SetTObjectValueL( KVcxMediaMyVideosCommandId, KVcxCommandMyVideosGetMediasByMpxId );
+ TUid colId = TUid::Uid( KVcxUidMyVideosMpxCollection );
+ cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, colId.iUid );
+
+ CMPXMediaArray* idMediaArray = CMPXMediaArray::NewL();
+ CleanupStack::PushL( idMediaArray );
+
+ CMPXMedia* media;
+ TMPXItemId mpxId;
+ for ( TInt i = 0; i < aMpxIds.Count(); i++ )
+ {
+ media = CMPXMedia::NewL();
+ CleanupStack::PushL( media );
+
+ mpxId.iId1 = aMpxIds[i];
+ mpxId.iId2 = KMpxMediaId2;
+
+ media->SetTObjectValueL( KMPXMessageMediaGeneralId, mpxId );
+ idMediaArray->AppendL( *media );
+ CleanupStack::PopAndDestroy( media );
+ }
+
+ cmd->SetCObjectValueL<CMPXMediaArray>( KMPXMediaArrayContents, idMediaArray );
+
+ cmd->SetTObjectValueL( KMPXMediaArrayCount, idMediaArray->Count() );
+
+ iCollectionUtility->Collection().CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( idMediaArray );
+ CleanupStack::PopAndDestroy( cmd );
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::GetMediaByMpxIdReqL OUT");
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::LinkMediaObjectsL
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::LinkMediaObjectsL( CMPXMediaArray* aArray )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LinkMediaObjectsL IN");
+
+ if ( aArray )
+ {
+ for ( TInt i = aArray->Count()-1; i >= 0; i-- )
+ {
+ SearchAndAddMpxMediaL( (*aArray)[i] );
+ }
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::LinkMediaObjectsL OUT");
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::SearchAndAddMpxMediaL
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::SearchAndAddMpxMediaL( CMPXMedia* aMedia )
+ {
+ //NOTE: It takes a while before this is called after download has been started.
+ // If application is closed before the media item has arrived, metadata is lost
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::SearchAndAddMpxMediaL IN");
+ CVcxNsContent* content = NULL;
+ TUint32 mpxId = aMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ).iId1;
+ TPtrC uri = aMedia->ValueText( KVcxMediaMyVideosRemoteUrl );
+
+ // search from dl first by mpx id
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::SearchAndAddMpxMediaL: SearchFromDownloadList( mpxId )");
+ content = SearchFromDownloadList( mpxId );
+
+ if( !content )
+ {
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::SearchAndAddMpxMediaL: SearchFromDownloadList( uri ) ");
+ // Not found from dl list, this
+ // is new media. search by uri.
+ content = SearchFromDownloadList( uri );
+ }
+
+ // Cancel can be called before the media object
+ // has arrived. If so, cancel it now.
+ if( content &&
+ content->PendingCommand()==CVcxNsContent::EVcxNsMpxContentCommandCancelDownload )
+ {
+ content->SetMpxMediaL( aMedia );
+ CancelDownloadL( *content );
+ // Dont link, object will be removed.
+ return;
+ }
+
+ if( !content )
+ {
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::SearchAndAddMpxMediaL: SearchContentByUri( uri ) ");
+
+ // Still not found from dl list, dl is not currently visible
+ // -> search from all contents.
+
+ if( iUiEngine.GetContentProviderL() )
+ {
+ content = iUiEngine.ContentProvider()->SearchContentByUri( uri );
+ }
+
+ // Content was found, but the download was not started directly
+ // from Vod. Add to download list.
+ if ( content && content->GetServiceId() == iUiEngine.ActiveService() )
+ {
+ AppendToDownloadList( content );
+ }
+ }
+
+ if ( content )
+ {
+ CVcxNsContentAccess* contentAccess =
+ content->GetContentAccess( CVcxNsContent::EVcxContentTypeVideo );
+ if ( contentAccess )
+ {
+ content->SetMpxMediaL( aMedia );
+
+ if( !content->GetMpxId() || content->GetMpxId() != mpxId )
+ {
+ content->SetMpxId( mpxId );
+ iUiEngine.GetContentClientHandlerL()->
+ StoreMpxIdToEcgDbL( content->GetServiceId(),
+ content->GetContentId(),
+ contentAccess->iIndex,
+ mpxId );
+
+ CopyEcgDataToMpxColL( content, mpxId );
+ }
+
+ if ( !content->GetMpxMedia()->IsSupported( KMPXMediaGeneralIcon ) &&
+ content->GetIconPath().Length() > 0 )
+ {
+ TIconInfo icon;
+ icon.bmpfile = content->GetIconPath();
+ content->GetMpxMedia()->SetTObjectValueL( KMPXMediaGeneralIcon, icon );
+ }
+
+ iUiEngine.ContentProvider()->UpdateContent( content );
+
+ CVcxNsContent::TVcxContentDlStatus status = content->GetDlStatus();
+
+ if( status == CVcxNsContent::EVcxContentDlStateDownloading )
+ {
+ iDownloadUpdater->AddDownload( content );
+ }
+ }
+ }
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::SearchAndAddMpxMediaL OUT");
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::AppendToDownloadList
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::AppendToDownloadList( CVcxNsContent* aContent )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::AppendToDownloadList");
+
+ if( iDownloadedContents.Find( aContent ) == KErrNotFound )
+ {
+ iDownloadedContents.Append( aContent );
+ }
+
+ if( aContent->GetMpxMedia() )
+ {
+ CVcxNsContent::TVcxContentDlStatus status = aContent->GetDlStatus();
+
+ if( status == CVcxNsContent::EVcxContentDlStateDownloading )
+ {
+ iDownloadUpdater->AddDownload( aContent );
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::RemoveFromDownloadList
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::RemoveFromDownloadList( CVcxNsContent* aContent )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::RemoveFromDownloadList");
+
+ TInt index = iDownloadedContents.Find( aContent );
+
+ if( index >= 0 )
+ {
+ iDownloadedContents.Remove( index );
+
+ if( aContent->GetMpxMedia() )
+ {
+ iDownloadUpdater->RemoveDownload( aContent );
+ }
+ }
+
+ index = iResumeArray.Find( aContent->GetMpxId() );
+ if ( index >= 0 )
+ {
+ iResumeArray.Remove( index );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::ResetDownloadList
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::ResetDownloadList( TBool aResetCmdsFromContentItems )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::ResetDownloadList");
+
+ if ( aResetCmdsFromContentItems )
+ {
+ for( TInt i = iDownloadedContents.Count()-1; i >= 0 ; i-- )
+ {
+ // Reset the pending cmds before removing from the list.
+ (iDownloadedContents[i])->SetPendingCommand( CVcxNsContent::EVcxNsMpxContentCommandNone );
+ }
+ }
+
+
+ iDownloadedContents.Reset();
+ iDownloadUpdater->RemoveAllDownloads();
+
+ iResumeArray.Reset();
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::SearchFromDownloadList
+// -----------------------------------------------------------------------------
+//
+CVcxNsContent* CVcxNsMpxCollectionClientHandler::SearchFromDownloadList( const TDesC& aUri )
+ {
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::SearchFromDownloadList (aUri) IN");
+
+ for( TInt i = iDownloadedContents.Count()-1; i >= 0 ; i-- )
+ {
+ TPtrC contentUri = TPtrC( (iDownloadedContents[i])->GetUrl( CVcxNsContent::EVcxContentTypeVideo ) );
+
+ if ( contentUri.CompareF( aUri ) == 0 )
+ {
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::SearchFromDownloadList (aUri) OUT, content found");
+ return iDownloadedContents[i];
+ }
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler::SearchFromDownloadList (aUri) OUT, not found");
+
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::SearchFromDownloadList
+// -----------------------------------------------------------------------------
+//
+CVcxNsContent* CVcxNsMpxCollectionClientHandler::SearchFromDownloadList( const TUint32 aMpxId )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::SearchFromDownloadList (aId) IN");
+
+ for( TInt i = iDownloadedContents.Count()-1; i >= 0 ; i-- )
+ {
+ TUint32 mpxId = (iDownloadedContents[i])->GetMpxId();
+
+ if ( mpxId == aMpxId )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::SearchFromDownloadList (aId) OUT, found");
+ return iDownloadedContents[i];
+ }
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::SearchFromDownloadList (aId) OUT, not found");
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CVcxNsMpxCollectionClientHandler::DoHandleSingleCollectionMessageL
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::DoHandleSingleCollectionMessageL( CMPXMessage* aMsg, TInt aErr )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DoHandleSingleCollectionMessageL IN");
+
+ if ( aMsg && aErr == KErrNone )
+ {
+ TMPXMessageId mpxMsgId = *( aMsg->Value<TMPXMessageId>( KMPXMessageGeneralId ) );
+
+ TInt mpxCmdId( -1 );
+ if ( aMsg->IsSupported( KVcxMediaMyVideosCommandId ) )
+ {
+ mpxCmdId = aMsg->ValueTObjectL<TInt>( KVcxMediaMyVideosCommandId );
+ }
+
+ if ( mpxMsgId == KMPXMessageGeneral )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DoHandleSingleCollectionMessageL KMPXMessageGeneral");
+ }
+ else if ( mpxMsgId == KMPXMessageIdItemChanged )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DoHandleSingleCollectionMessageL: KMPXMessageIdItemChanged");
+
+ TMPXItemId id( 0, 0 );
+ if ( aMsg->IsSupported( KMPXMessageMediaGeneralId ) )
+ {
+ id = aMsg->ValueTObjectL<TMPXItemId>( KMPXMessageMediaGeneralId );
+ }
+
+ if ( id.iId1 == KVcxUidMyVideosMpxCollection )
+ {
+ // the whole collection changed
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DoHandleSingleCollectionMessageL: The whole collection changed, fetching all items.");
+ LoadMpxMediaObjectsL();
+ }
+ else
+ {
+ iUiEngine.GetEventRouter()->HandleCollectionMessageL( aMsg, aErr );
+ HandleMpxItemChangedL( aMsg, aErr );
+ }
+ }
+
+ else if ( mpxCmdId == KVcxMessageMyVideosGetMediasByMpxIdResp )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DoHandleSingleCollectionMessageL KVcxMessageMyVideosGetMediasByMpxIdResp");
+ CMPXMedia* entries = CMPXMedia::NewL( *aMsg );
+ CleanupStack::PushL( entries );
+
+ CMPXMediaArray* array = entries->Value<CMPXMediaArray>( KMPXMediaArrayContents );
+
+ if ( array && 0 < array->Count() )
+ {
+ iLastFetchedMedias.ResetAndDestroy();
+
+ for ( TInt i = 0; i < array->Count(); i++ )
+ {
+ iLastFetchedMedias.Append( CMPXMedia::NewL( *(*array)[i]) );
+ }
+ }
+
+ SearchAndMarkItemAsWatchedL( array );
+
+ LinkMediaObjectsL( array );
+
+ CleanupStack::PopAndDestroy( entries );
+ }
+ else if ( mpxCmdId == KVcxMessageMyVideosListComplete )
+ {
+ LoadMpxMediaObjectsL();
+ }
+ }
+
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::DoHandleSingleCollectionMessageL OUT");
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::HandleMpxItemChangedL( CMPXMessage* aMsg, TInt /*aErr*/ )
+ {
+ if( !iUiEngine.ContentProvider() )
+ {
+ return;
+ }
+
+ TUid colId = aMsg->ValueTObjectL<TUid>(KMPXMessageCollectionId);
+ TMPXChangeEventType type = aMsg->ValueTObjectL<TMPXChangeEventType>(KMPXMessageChangeEventType);
+
+ if( colId.iUid == KVcxUidMyVideosMpxCollection )
+ {
+ TMPXItemId itemId = aMsg->ValueTObjectL<TMPXItemId>( KMPXMessageMediaGeneralId );
+
+ if ( type == EMPXItemModified )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleCollectionMessageL EMPXItemModified");
+ CVcxNsContent* content = SearchFromDownloadList( itemId );
+ if( content )
+ {
+ if ( content->GetMpxMedia() && !content->GetMpxMedia()->IsSupported( KVcxMediaMyVideosDownloadState ) )
+ {
+ // Media can be invalid, refetch
+ LoadMpxMediaObjectL( aMsg->Value<TMPXItemId>( KMPXMessageMediaGeneralId )->iId1 );
+ }
+
+ if( iUiEngine.VcAppState() == EStateContentView )
+ {
+ CVcxNsContent::TVcxContentDlStatus status = content->GetDlStatus();
+
+ if( status == CVcxNsContent::EVcxContentDlStateDownloading )
+ {
+ iDownloadUpdater->AddDownload( content );
+ }
+ else
+ {
+ iDownloadUpdater->RemoveDownload( content );
+ }
+
+ if( status == CVcxNsContent::EVcxContentDlStateFailed &&
+ ! content->DlFailNotified() )
+ {
+ NotifyDownloadErrorL( content->GetMpxMedia(), *content );
+ }
+ }
+ }
+ }
+ else if ( type == EMPXItemInserted )
+ {
+ LoadMpxMediaObjectL( aMsg->Value<TMPXItemId>( KMPXMessageMediaGeneralId )->iId1 );
+ }
+ else if( type == EMPXItemDeleted )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler::HandleCollectionMessageL EMPXItemDeleted");
+ DeleteDownload( itemId );
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::DeleteDownload( TMPXItemId itemId )
+ {
+ CVcxNsContent* content = iUiEngine.ContentProvider()->SearchContentByMpxId( itemId );
+ if ( content )
+ {
+ iDownloadUpdater->RemoveDownload( content );
+ content->SetMpxId( 0, CVcxNsContent::EVcxContentTypeVideo );
+ TRAP_IGNORE(
+ content->SetMpxMediaL( NULL, CVcxNsContent::EVcxContentTypeVideo );
+ RemoveFromDownloadList( content );
+
+ CVcxNsContentAccess* contentAccess =
+ content->GetContentAccess( CVcxNsContent::EVcxContentTypeVideo );
+
+ if ( contentAccess )
+ {
+ iUiEngine.GetContentClientHandlerL()->StoreMpxIdToEcgDbL(
+ content->GetServiceId(),
+ content->GetContentId(),
+ contentAccess->iIndex,
+ 0 /*mpx id*/ );
+ }
+ )
+ iUiEngine.ContentProvider()->UpdateContent( content );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::UpdateVideoObject( TUint32 aMpxId )
+ {
+ if( iUiEngine.ContentProvider() )
+ {
+ CVcxNsContent* content = SearchFromDownloadList( aMpxId );
+
+ if( content )
+ {
+ iUiEngine.ContentProvider()->UpdateContent( content );
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::ResumeStartedFromBeginningL( TUint32 aMpxId )
+ {
+ TInt index = iResumeArray.Find( aMpxId );
+ if ( index >= 0 )
+ {
+ iResumeArray.Remove( index );
+
+ CVcxNsContent* content = SearchFromDownloadList( aMpxId );
+ if ( content )
+ {
+ iUiEngine.GetEventRouter()->HandleDlErrorL( EIptvResumingFromBeginning, *content );
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::CopyEcgDataToMpxColL( CVcxNsContent *aContent,
+ TUint32 aMpxId )
+ {
+ if ( !aContent->GetDescription().Length() &&
+ !aContent->GetAuthor().Length() &&
+ !aContent->GetCopyright().Length() )
+ {
+ iUiEngine.ContentProvider()->FetchFullDetailsL( aContent );
+ }
+
+ CMPXMedia* msg = CMPXMedia::NewL();
+ CleanupStack::PushL( msg );
+
+ msg->SetTObjectValueL( KMPXMediaGeneralId, TMPXItemId( aMpxId, KMpxMediaId2 ) );
+
+ //Language
+ if ( aContent->GetLanguage().Length() > 0 )
+ {
+ msg->SetTextValueL( KVcxMediaMyVideosAudioLanguage, aContent->GetLanguage() ) ;
+ }
+
+ //Length
+ if ( aContent->GetLength() )
+ {
+ msg->SetTObjectValueL<TReal32>( KVcxMediaMyVideosDuration, aContent->GetLength() );
+ }
+
+ //Description
+ if ( aContent->GetDescription().Length() > 0 )
+ {
+ msg->SetTextValueL( KMPXMediaGeneralComment, aContent->GetDescription() );
+ }
+
+ //Author
+ if ( aContent->GetAuthor().Length() > 0 )
+ {
+ msg->SetTextValueL( KVcxMediaMyVideosAuthor, aContent->GetAuthor() );
+ }
+
+ //Copyright
+ if ( aContent->GetCopyright().Length() > 0 )
+ {
+ msg->SetTextValueL( KMPXMediaGeneralCopyright, aContent->GetCopyright() );
+ }
+
+ // Age profile
+ if ( aContent->GetAgeProfile() > 0 )
+ {
+ msg->SetTObjectValueL<TInt32>( KVcxMediaMyVideosAgeProfile, aContent->GetAgeProfile() );
+ }
+
+ WriteMsgToColL( msg );
+
+ CleanupStack::PopAndDestroy( msg );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::NotifyDownloadErrorL(
+ CMPXMedia* aMedia,
+ CVcxNsContent& aContent )
+ {
+ if( !aMedia )
+ {
+ return;
+ }
+
+ TIptvDlError error = GetDownloadErrorL( aMedia );
+
+ aContent.SetDlFailNotified( ETrue );
+
+ iUiEngine.GetEventRouter()->HandleDlErrorL( error, aContent );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+TIptvDlError CVcxNsMpxCollectionClientHandler::GetDownloadErrorL( CMPXMedia* aMedia )
+ {
+ TInt32 errorId = aMedia->ValueTObjectL<TInt32>( KVcxMediaMyVideosDownloadError );
+ TInt32 globalErrorId = aMedia->ValueTObjectL<TInt32>( KVcxMediaMyVideosDownloadGlobalError );
+ TIptvDlError vcxError;
+
+ IPTVLOGSTRING2_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler: DL error ID: %d", errorId );
+ IPTVLOGSTRING2_LOW_LEVEL(
+ "CVcxNsMpxCollectionClientHandler: DL global error ID: %d", globalErrorId );
+
+ switch ( errorId )
+ {
+ case EConnectionFailed:
+ vcxError = EIptvDlConnectionFailed;
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlConnectionFailed");
+ if ( globalErrorId == KErrServerBusy )
+ {
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlGeneral");
+ vcxError = EIptvDlGeneral;
+ }
+ break;
+ case EHttpAuthenticationFailed:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlAuthFailed");
+ vcxError = EIptvDlAuthFailed;
+ // Add download authentication error handling
+ break;
+ case EProxyAuthenticationFailed:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlProxyAuthFailed");
+ vcxError = EIptvDlProxyAuthFailed;
+ break;
+ case EDestFileInUse:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlDestFileInUse");
+ vcxError = EIptvDlDestFileInUse;
+ break;
+ case EBadUrl:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlBadUrl");
+ vcxError = EIptvDlBadUrl;
+ break;
+ case EMMCRemoved:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlMmcRemoved");
+ vcxError = EIptvDlMmcRemoved;
+ break;
+ case EDiskFull:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlDiskFull");
+ vcxError = EIptvDlDiskFull;
+ break;
+ case EObjectNotFound:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlContentNotFound");
+ vcxError = EIptvDlContentNotFound;
+ break;
+ case ETransactionFailed:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlInvalidIap");
+ vcxError = EIptvDlInvalidIap;
+ break;
+ default:
+ IPTVLOGSTRING_LOW_LEVEL("CVcxNsMpxCollectionClientHandler: EIptvDlGeneral");
+ vcxError = EIptvDlGeneral;
+ break;
+ }
+
+ return vcxError;
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::MarkVideoAsWatchedL( const TUint32 aMpxId )
+ {
+ TBool found( EFalse );
+
+ for ( TInt i = 0; i < iLastFetchedMedias.Count(); i++ )
+ {
+ if ( iLastFetchedMedias[i]->IsSupported( KMPXMediaGeneralId ) &&
+ iLastFetchedMedias[i]->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ).iId1 == aMpxId )
+ {
+ MarkItemAsWatchedL( iLastFetchedMedias[i] );
+ found = ETrue;
+ break;
+ }
+ }
+
+ if ( !found )
+ {
+ RArray<TUint32> mpxIds;
+ CleanupClosePushL( mpxIds );
+ mpxIds.Append( aMpxId );
+ iMarkAsWatchedId = aMpxId;
+ GetMediaByMpxIdReqL( mpxIds );
+ CleanupStack::PopAndDestroy( &mpxIds );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::SetlastPlayPosL( const TUint32 aMpxId, TInt32 aPos )
+ {
+ if ( CIptvUtil::LastPlaybackPositionFeatureSupported() )
+ {
+ WriteAttrToColL( KMPXMediaGeneralLastPlaybackPosition,
+ aPos,
+ aMpxId );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::SearchAndMarkItemAsWatchedL( CMPXMediaArray* aArray )
+ {
+ if( !aArray || iMarkAsWatchedId == KErrNotFound )
+ {
+ return;
+ }
+
+ CMPXMedia* pMedia;
+
+ for( TInt i = 0; i < aArray->Count(); i++ )
+ {
+ pMedia = ( *aArray )[i];
+
+ TUint32 mpxid = pMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+
+ if ( iMarkAsWatchedId == mpxid )
+ {
+ iMarkAsWatchedId = KErrNotFound;
+ MarkItemAsWatchedL( pMedia );
+ break;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::MarkItemAsWatchedL( CMPXMedia* aMedia )
+ {
+ if( !aMedia || !aMedia->IsSupported( KMPXMediaGeneralFlags ) )
+ {
+ return;
+ }
+
+ TUint32 flags = aMedia->ValueTObjectL<TUint32>( KMPXMediaGeneralFlags );
+
+ if ( flags & EVcxMyVideosVideoNew )
+ {
+ flags &= ~EVcxMyVideosVideoNew;
+
+ TUint32 mpxid = aMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );
+
+ TInt32 val( flags );
+
+ WriteAttrToColL( KMPXMediaGeneralFlags, val, mpxid );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::WriteAttrToColL( TMPXAttributeData aAttribute,
+ TInt32 aValue,
+ TUint32 aMpxId )
+ {
+ CMPXMedia* msg = CMPXMedia::NewL();
+ CleanupStack::PushL( msg );
+
+ msg->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, TMPXItemId( aMpxId, KMpxMediaId2 ) );
+ msg->SetTObjectValueL<TInt32>( aAttribute, aValue );
+
+ WriteMsgToColL( msg );
+
+ CleanupStack::PopAndDestroy( msg );
+ }
+
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::WriteAttrToColL( TMPXAttributeData aAttribute,
+ TReal32 aValue,
+ TUint32 aMpxId )
+ {
+ CMPXMedia* msg = CMPXMedia::NewL();
+ CleanupStack::PushL( msg );
+
+ msg->SetTObjectValueL<TMPXItemId>( KMPXMediaGeneralId, TMPXItemId( aMpxId, KMpxMediaId2 ) );
+ msg->SetTObjectValueL<TReal32>( aAttribute, aValue );
+
+ WriteMsgToColL( msg );
+
+ CleanupStack::PopAndDestroy( msg );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::WriteMsgToColL( CMPXMedia* aMsg )
+ {
+ CMPXCommand* cmd = CMPXCommand::NewL();
+ CleanupStack::PushL( cmd );
+
+ cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdCollectionSet );
+ cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue );
+ cmd->SetCObjectValueL( KMPXCommandColSetMedia, aMsg );
+ cmd->SetTObjectValueL( KMPXCommandGeneralCollectionId, KVcxUidMyVideosMpxCollection );
+
+ iCollectionUtility->Collection().CommandL( *cmd );
+
+ CleanupStack::PopAndDestroy( cmd );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::GetMediaDetailsL( TUint32 aMpxId )
+ {
+ if ( iGetMediaDetailWait->IsStarted() )
+ {
+ User::Leave( KErrNotReady );
+ }
+
+ RArray<TMPXAttribute> attrs;
+ CleanupClosePushL( attrs );
+
+ attrs.Append( KMPXMediaGeneralId );
+ attrs.Append( KMPXMediaGeneralFlags );
+ attrs.Append( KMPXMediaGeneralLastPlaybackPosition );
+
+ CMPXCollectionPath* path = CMPXCollectionPath::NewL();
+ CleanupStack::PushL( path );
+
+ path->AppendL( KVcxUidMyVideosMpxCollection );
+ path->AppendL( KVcxMvcCategoryIdAll );
+ path->AppendL( TMPXItemId( aMpxId, KMpxMediaId2 ) );
+ path->SelectL( TMPXItemId( aMpxId, KMpxMediaId2 ) );
+
+ iCollectionUtility->Collection().MediaL( *path, attrs.Array() );
+
+ CleanupStack::PopAndDestroy( path );
+
+ CleanupStack::PopAndDestroy( &attrs );
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::GetMediaDetailsSyncL( TUint32 aMpxId )
+ {
+ if ( !iGetMediaDetailWait->IsStarted() )
+ {
+ GetMediaDetailsL( aMpxId );
+ iGetMediaDetailWait->Start();
+ }
+ else
+ {
+ User::Leave( KErrNotReady );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+//
+void CVcxNsMpxCollectionClientHandler::PlayVideoL( TUint32 aMpxId )
+ {
+ CMPXCollectionPath* path = CMPXCollectionPath::NewL();
+ CleanupStack::PushL(path);
+
+ path->AppendL( KVcxUidMyVideosMpxCollection );
+ path->AppendL( KVcxMvcCategoryIdAll );
+ path->AppendL( TMPXItemId( aMpxId, KMpxMediaId2 ) );
+ path->SelectL( TMPXItemId( aMpxId, KMpxMediaId2 ) );
+
+ iCollectionUtility->Collection().OpenL( *path );
+ CleanupStack::PopAndDestroy(path);
+ }