FCL/sf/app/videoplayer: comparison videocollection/videocollectionwrapper/src/videocollectionlistener.cpp

equal deleted inserted replaced

-:3738fe97f027
+:8aed59de29f9
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
-* Description:   VideoCollectionClient class implementation
+* Description:   VideoCollectionListener class implementation
 *
 */
+// Version : %version: 32 %
 // INCLUDE FILES
 #include <mpxmediageneraldefs.h>
 #include <mpxmessagegeneraldefs.h>
 #include <mpxmessage2.h>
 #include <mpxcollectionmessagedefs.h>
 #include <mpxcollectionmessage.h>
 #include "videocollectionlistener.h"
 #include "videocollectionclient.h"
 #include "videodatasignalreceiver.h"
 #include "videocollectionutils.h"
 #include "videocollectioncommon.h"
+#include "videocollectiontrace.h"
 // -----------------------------------------------------------------------------
 // VideoCollectionListener
 // -----------------------------------------------------------------------------
 //
-VideoCollectionListener::VideoCollectionListener(VideoCollectionClient &collectionClient,
+VideoCollectionListener::VideoCollectionListener( VideoCollectionClient &collectionClient,
-VideoDataSignalReceiver &signalReceiver) :
+VideoDataSignalReceiver &signalReceiver)
-mCollectionClient(collectionClient),
+: mCollectionClient( collectionClient )
-mSignalReceiver(signalReceiver),
+, mSignalReceiver( signalReceiver )
-mVideoUtils(VideoCollectionUtils::instance())
+, mVideoUtils( VideoCollectionUtils::instance() )
 {
+	FUNC_LOG;
 }
 // -----------------------------------------------------------------------------
 // ~VideoCollectionListener
 // -----------------------------------------------------------------------------
 //
 VideoCollectionListener::~VideoCollectionListener()
 {
+	FUNC_LOG;
 }
 // -----------------------------------------------------------------------------
 // HandleCollectionMediaL
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::HandleCollectionMediaL(
 const CMPXMedia& /*aMedia*/,
 TInt /*aError*/)
 {
-// NOP
+	FUNC_LOG;
 }
 // -----------------------------------------------------------------------------
 // HandleOpenL
 // -----------------------------------------------------------------------------
 const CMPXMedia& aEntries,
 TInt /*aIndex*/,
 TBool /*aComplete*/,
 TInt aError)
 {
+	FUNC_LOG;
 if(aError != KErrNone)
 {
+ERROR(aError, "VideoCollectionListener::HandleOpenL()");
 return;
 }
 // Check that current level is valid and entries has collection path.
-if(mCollectionClient.getCollectionLevel() < VideoCollectionCommon::ELevelCategory ||
+if(mCollectionClient.getCollectionLevel() < VideoCollectionCommon::ELevelCategory )
-!aEntries.IsSupported(KMPXMediaGeneralContainerPath))
+{
-{
+ERROR(-1, "VideoCollectionListener::HandleOpenL() invalid level");
 return;
 }
 CMPXMediaArray *array =
 mVideoUtils.mediaValuePtr<CMPXMessageArray>(&aEntries, KMPXMediaArrayContents);
 if(!array)
 {
-// no videos!
+ERROR(-1, "VideoCollectionListener::HandleOpenL() array contents is NULL.");
 return;
 }
-CMPXCollectionPath* path = aEntries.Value<CMPXCollectionPath>(KMPXMediaGeneralContainerPath);
+CMPXCollectionPath* path =
+mVideoUtils.mediaValuePtr<CMPXCollectionPath>(&aEntries, KMPXMediaGeneralContainerPath);
 if(!path)
 	{
+ERROR(-1, "VideoCollectionListener::HandleOpenL() no container path in message.");
 return;
 	}
 TMPXItemId pathId = path->Id();
 //
 void VideoCollectionListener::HandleOpenL(
 const CMPXCollectionPlaylist& /*aPlaylist*/,
 TInt /*aError*/)
 {
-// NOP
+	FUNC_LOG;
 }
 // -----------------------------------------------------------------------------
 // HandleCommandComplete
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::HandleCommandComplete(
 CMPXCommand* aCommandResult,
 TInt aError)
 {
+	FUNC_LOG;
 if(aError != KErrNone || !aCommandResult)
 {
+ERROR_1(aError, "VideoCollectionListener::HandleCommandComplete() result: %d", aCommandResult);
 return;
 }
 int commandId = -1;
 if(mVideoUtils.mediaValue<int>(aCommandResult, KVcxMediaMyVideosCommandId, commandId))
 //
 void VideoCollectionListener::HandleCollectionMessage(
 CMPXMessage* aMessage,
 TInt aError )
 {
+	FUNC_LOG;
 if(aError)
 {
+ERROR(aError, "VideoCollectionListener::HandleCollectionMessage()");
 return;
 }
 TMPXMessageId mainMessageId;
 if(!mVideoUtils.mediaValue<TMPXMessageId>(aMessage, KMPXMessageGeneralId, mainMessageId))
 {
 handleGeneralMPXMessage(aMessage);
 }
 return;
 }
 if( mainMessageId == KVcxCommandIdMyVideos)
 {
 int myVideosMainMsgId = -1;
-if(!mVideoUtils.mediaValue<int>(aMessage, KVcxMediaMyVideosCommandId, myVideosMainMsgId ))
+if(!mVideoUtils.mediaValue<int>(aMessage, KVcxMediaMyVideosCommandId, myVideosMainMsgId))
 {
 return;
 }
-if ( myVideosMainMsgId == KVcxMessageMyVideosMessageArray )
+if (myVideosMainMsgId == KVcxMessageMyVideosMessageArray)
 {
 handleMyVideosMessageArray(aMessage);
 }
 else
 {
 // handleMyVideosMessageArray
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::handleMyVideosMessageArray(CMPXMessage *aMessage)
 {
+	FUNC_LOG;
 CMPXMessageArray* messageArray = NULL;
 messageArray = mVideoUtils.mediaValuePtr<CMPXMessageArray>(aMessage, KMPXMessageArrayContents);
 if(!messageArray)
 {
 return;
 }
 int count = messageArray->Count();
 int myVideosMsgId;
 TMPXMessageId mpxMessageId;
 CMPXMessage *singleMessage;
 for ( int i = 0; i < count; ++i )
 // handleMyVideosMPXMessage
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::handleMyVideosMPXMessage(int &myVideosMsgId, CMPXMessage *aMessage)
 {
+	FUNC_LOG;
 switch (myVideosMsgId)
 {
 case KVcxMessageMyVideosGetMediasByMpxIdResp:
 handleGetMediasByMpxIdResp(aMessage);
 break;
 // handleCommonMPXMessage
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::handleMPXMessage(TMPXMessageId &mpxMessageId, CMPXMessage *aMessage)
 {
+	FUNC_LOG;
 switch(mpxMessageId)
 {
 case KMPXMessageGeneral:
 handleGeneralMPXMessage(aMessage);
 break;
 // handleGeneralMPXMessage
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::handleGeneralMPXMessage(CMPXMessage* aMessage)
 {
+	FUNC_LOG;
 if(mCollectionClient.getOpenStatus() != VideoCollectionClient::ECollectionOpening)
 {
 return;
 }
 int event = 0;
 // handleMyVideosItemsChanged
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::handleMyVideosItemsChanged(CMPXMessage* aMessage)
 {
+	FUNC_LOG;
 TMPXChangeEventType eventType = EMPXItemModified;
 if(!mVideoUtils.mediaValue<TMPXChangeEventType>(
 aMessage,KMPXMessageChangeEventType, eventType))
 {
 return;
 if(!mVideoUtils.mediaValue<TMPXItemId>(
 aMessage,KMPXMessageMediaGeneralId, itemId))
 {
 return;
 }
+INFO_3("VideoCollectionListener::handleMyVideosItemsChanged event: %d - item id1: %d id2: %d", eventType, itemId.iId1, itemId.iId2);
 switch(eventType)
 {
 case EMPXItemDeleted:
 {
 mSignalReceiver.itemDeletedSlot(itemId);
 }
 case EMPXItemInserted:
 {
 CMPXMedia *media = mVideoUtils.mediaValuePtr<CMPXMedia>(
 aMessage, KMPXCommandColAddMedia);
-if (media)
+if(media)
 {
 mSignalReceiver.newVideoAvailableSlot(media);
 }
 else
 {
 }
 break;
 }
 case EMPXItemModified:
 {
-if (itemId.iId2 == KVcxMvcMediaTypeAlbum)
+INFO("VideoCollectionListener::handleMyVideosItemsChanged EMPXItemModified");
+// Inform that item data has changed.
+mSignalReceiver.itemModifiedSlot(itemId);
+// Update category contents.
+if(itemId.iId2 == KVcxMvcMediaTypeAlbum ||
+itemId.iId2 == KVcxMvcMediaTypeCategory)
 {
-// re-open the album in case album corresponds recently opened.
+INFO("VideoCollectionListener::handleMyVideosItemsChanged album or category modified, opening.");
-// to fetch the album contents.
 mCollectionClient.openItem(itemId);
+// collection is already opened at this stage, so we can safely set value here
+// to make sure we do not let any other messages unhandled
+mCollectionClient.setOpenStatus(VideoCollectionClient::ECollectionOpened, false);
 }
 break;
 }
 default:
 {
 // handleMyVideosDeleteMessage
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::handleMyVideosDeleteMessage(CMPXMessage* aMessage)
 {
+	FUNC_LOG;
 CMPXMediaArray *messageArray =
 mVideoUtils.mediaValuePtr<CMPXMediaArray>(aMessage, KMPXMediaArrayContents);
 if(!messageArray || messageArray->Count() == 0)
 {
 return;
 // handleGetMediasByMpxIdResp
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::handleGetMediasByMpxIdResp(CMPXMessage* aMessage)
 {
+	FUNC_LOG;
 CMPXMediaArray* array =
 mVideoUtils.mediaValuePtr<CMPXMediaArray>(aMessage, KMPXMediaArrayContents);
 if(!array || array->Count() < 1)
 {
 return;
 }
 mSignalReceiver.newVideoAvailableSlot((*array)[0]);
 }
 // -----------------------------------------------------------------------------
 // handleGetVideoDetailsResp
 // -----------------------------------------------------------------------------
 //
 void VideoCollectionListener::handleGetVideoDetailsResp(CMPXMessage* aMessage)
 {
+	FUNC_LOG;
 CMPXMedia *item = mVideoUtils.mediaValuePtr<CMPXMedia>(aMessage,KMPXCommandColAddMedia);
 if(!item)
 {
 return;
 }
-TMPXItemId itemId;
+mSignalReceiver.videoDetailsCompletedSlot(item);
-if( !mVideoUtils.mediaValue<TMPXItemId>(item, KMPXMediaGeneralId, itemId))
+}
-{
-return;
+// End of file.
-}
-mSignalReceiver.videoDetailsCompletedSlot(itemId);
-}

changeset 36	8aed59de29f9
parent 35	3738fe97f027
child 38	ff53afa8ad05