--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videocollection/videocollectionwrapper/src/videocollectionlistener.cpp Fri Apr 16 14:59:52 2010 +0300
@@ -0,0 +1,519 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "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: VideoCollectionClient class implementation
+*
+*/
+
+// INCLUDE FILES
+
+#include <mpxmediageneraldefs.h>
+#include <mpxmessagegeneraldefs.h>
+#include <mpxmessage2.h>
+#include <mpxcollectionmessagedefs.h>
+#include <mpxcollectionmessage.h>
+#include <mpxmessagecontainerdefs.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxcommandgeneraldefs.h>
+#include <mpxcollectioncommanddefs.h>
+#include <vcxmyvideosdefs.h>
+#include <vcxmyvideosuids.h>
+
+#include "videocollectionlistener.h"
+#include "videocollectionclient.h"
+#include "videodatasignalreceiver.h"
+#include "videocollectionutils.h"
+#include "videocollectioncommon.h"
+
+// -----------------------------------------------------------------------------
+// VideoCollectionListener
+// -----------------------------------------------------------------------------
+//
+VideoCollectionListener::VideoCollectionListener(VideoCollectionClient &collectionClient,
+ VideoDataSignalReceiver &signalReceiver) :
+mCollectionClient(collectionClient),
+mSignalReceiver(signalReceiver),
+mVideoUtils(VideoCollectionUtils::instance())
+{
+
+}
+
+// -----------------------------------------------------------------------------
+// ~VideoCollectionListener
+// -----------------------------------------------------------------------------
+//
+VideoCollectionListener::~VideoCollectionListener()
+{
+
+}
+
+// -----------------------------------------------------------------------------
+// HandleCollectionMediaL
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::HandleCollectionMediaL(
+ const CMPXMedia& /*aMedia*/,
+ TInt /*aError*/)
+{
+ // NOP
+}
+
+// -----------------------------------------------------------------------------
+// HandleOpenL
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::HandleOpenL(
+ const CMPXMedia& aEntries,
+ TInt /*aIndex*/,
+ TBool /*aComplete*/,
+ TInt aError)
+{
+ if(aError != KErrNone)
+ {
+ return;
+ }
+
+ // Check that current level is valid and entries has collection path.
+ if(mCollectionClient.getCollectionLevel() < VideoCollectionCommon::ELevelCategory ||
+ !aEntries.IsSupported(KMPXMediaGeneralContainerPath))
+ {
+ return;
+ }
+
+ CMPXMediaArray *array =
+ mVideoUtils.mediaValuePtr<CMPXMessageArray>(&aEntries, KMPXMediaArrayContents);
+ if(!array)
+ {
+ // no videos!
+ return;
+ }
+
+ CMPXCollectionPath* path = aEntries.Value<CMPXCollectionPath>(KMPXMediaGeneralContainerPath);
+ if(!path)
+ {
+ return;
+ }
+
+ TMPXItemId pathId = path->Id();
+
+ TBool categoryOrAlbumVideoList = false;
+ if(path->Levels() == VideoCollectionCommon::PathLevelVideos && pathId.iId2 != KVcxMvcMediaTypeVideo)
+ {
+ categoryOrAlbumVideoList = true;
+ }
+
+ if(categoryOrAlbumVideoList)
+ {
+ mSignalReceiver.albumListAvailableSlot(pathId, array);
+
+ // Update also all video list in case this is a default category.
+ if(pathId.iId2 == KVcxMvcMediaTypeCategory)
+ {
+ mSignalReceiver.newVideoListSlot(array);
+ }
+ }
+ else
+ {
+ mSignalReceiver.newVideoListSlot(array);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// HandleOpenL
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::HandleOpenL(
+ const CMPXCollectionPlaylist& /*aPlaylist*/,
+ TInt /*aError*/)
+{
+ // NOP
+}
+
+// -----------------------------------------------------------------------------
+// HandleCommandComplete
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::HandleCommandComplete(
+ CMPXCommand* aCommandResult,
+ TInt aError)
+{
+ if(aError != KErrNone || !aCommandResult)
+ {
+ return;
+ }
+ int commandId = -1;
+
+ if(mVideoUtils.mediaValue<int>(aCommandResult, KVcxMediaMyVideosCommandId, commandId))
+ {
+ if(commandId == KVcxCommandMyVideosGetMediaFullDetailsByMpxId)
+ {
+ handleGetVideoDetailsResp(aCommandResult);
+ }
+ else if(commandId == KVcxCommandMyVideosRemoveAlbums)
+ {
+ CMPXMediaArray *messageArray =
+ mVideoUtils.mediaValuePtr<CMPXMediaArray>(aCommandResult, KMPXMediaArrayContents);
+
+ if(!messageArray || messageArray->Count() == 0)
+ {
+ return;
+ }
+ QList<TMPXItemId> failedIds;
+ TMPXItemId itemId;
+ int count = messageArray->Count();
+ int failedFlag = 0;
+ CMPXMedia* item = NULL;
+
+ // go throught all removed albums and see if some has failed
+ for (int i = 0; i < count; ++i)
+ {
+ item = (*messageArray)[i];
+ if(!mVideoUtils.mediaValue<TMPXItemId>(item, KMPXMediaGeneralId, itemId))
+ {
+ // invalid message, return
+ return;
+ }
+ // if there's error while fetching value, it means that value does not exists,
+ // so we can assume remove was succefull
+ if(mVideoUtils.mediaValue<int>(item, KVcxMediaMyVideosInt32Value, failedFlag))
+ {
+ if (failedFlag)
+ {
+ failedIds.append(itemId);
+ }
+ failedFlag = 0;
+ }
+ }
+ if (failedIds.count())
+ {
+ mSignalReceiver.albumRemoveFailureSlot(&failedIds);
+ }
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// HandleCollectionMessage
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::HandleCollectionMessage(
+ CMPXMessage* aMessage,
+ TInt aError )
+{
+ if(aError)
+ {
+ return;
+ }
+
+ TMPXMessageId mainMessageId;
+ if(!mVideoUtils.mediaValue<TMPXMessageId>(aMessage, KMPXMessageGeneralId, mainMessageId))
+ {
+ return;
+ }
+
+ if(mCollectionClient.getOpenStatus() == VideoCollectionClient::ECollectionOpened )
+ {
+ // after colletion has been opened we handle messages from our collection plugin only
+ TUid collectionUid = {0};
+ bool status = mVideoUtils.mediaValue<TUid>(aMessage, KMPXMessageCollectionId, collectionUid);
+ if(!status || collectionUid.iUid != KVcxUidMyVideosMpxCollection)
+ {
+ return;
+ }
+ }
+ else
+ {
+ // before opening we're just excepting general messages
+ if(mainMessageId == KMPXMessageGeneral)
+ {
+ handleGeneralMPXMessage(aMessage);
+ }
+ return;
+ }
+
+ if( mainMessageId == KVcxCommandIdMyVideos)
+ {
+ int myVideosMainMsgId = -1;
+
+ if(!mVideoUtils.mediaValue<int>(aMessage, KVcxMediaMyVideosCommandId, myVideosMainMsgId ))
+ {
+ return;
+ }
+
+ if ( myVideosMainMsgId == KVcxMessageMyVideosMessageArray )
+ {
+ handleMyVideosMessageArray(aMessage);
+ }
+ else
+ {
+ handleMyVideosMPXMessage(myVideosMainMsgId, aMessage);
+ }
+ }
+ else
+ {
+ handleMPXMessage(mainMessageId, aMessage);
+ }
+}
+
+// -----------------------------------------------------------------------------
+// handleMyVideosMessageArray
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::handleMyVideosMessageArray(CMPXMessage *aMessage)
+{
+ 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 )
+ {
+ singleMessage = (*messageArray)[i];
+ if(mVideoUtils.mediaValue<int>(singleMessage, KVcxMediaMyVideosCommandId, myVideosMsgId))
+ {
+ handleMyVideosMPXMessage(myVideosMsgId, singleMessage);
+ }
+ else if(mVideoUtils.mediaValue<TMPXMessageId>(
+ singleMessage, KMPXMessageGeneralId, mpxMessageId))
+ {
+ handleMPXMessage(mpxMessageId, singleMessage);
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// handleMyVideosMPXMessage
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::handleMyVideosMPXMessage(int &myVideosMsgId, CMPXMessage *aMessage)
+{
+ switch (myVideosMsgId)
+ {
+ case KVcxMessageMyVideosGetMediasByMpxIdResp:
+ handleGetMediasByMpxIdResp(aMessage);
+ break;
+ case KVcxMessageMyVideosDeleteResp:
+ handleMyVideosDeleteMessage(aMessage);
+ break;
+ case KVcxMessageMyVideosDeleteStarted:
+ break;
+ case KVcxMessageMyVideosListComplete:
+ mCollectionClient.startOpenCurrentState();
+ break;
+ case KVcxMessageMyVideosItemsAppended:
+ mCollectionClient.startOpenCurrentState();
+ break;
+ case KVcxMessageMyVideosMoveOrCopyStarted:
+ break;
+ case KVcxMessageMyVideosMoveResp:
+ break;
+ case KVcxMessageMyVideosCopyResp:
+ break;
+ default:
+ break;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// handleCommonMPXMessage
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::handleMPXMessage(TMPXMessageId &mpxMessageId, CMPXMessage *aMessage)
+{
+ switch(mpxMessageId)
+ {
+ case KMPXMessageGeneral:
+ handleGeneralMPXMessage(aMessage);
+ break;
+ case KMPXMessageIdItemChanged:
+ handleMyVideosItemsChanged(aMessage);
+ break;
+ default:
+ break;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// handleGeneralMPXMessage
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::handleGeneralMPXMessage(CMPXMessage* aMessage)
+{
+ if(mCollectionClient.getOpenStatus() != VideoCollectionClient::ECollectionOpening)
+ {
+ return;
+ }
+ int event = 0;
+ if(!mVideoUtils.mediaValue<int>(aMessage, KMPXMessageGeneralEvent, event))
+ {
+ return;
+ }
+
+ int data = 0;
+ if(!mVideoUtils.mediaValue<int>(aMessage, KMPXMessageGeneralData, data))
+ {
+ return;
+ }
+
+ if( event == TMPXCollectionMessage::EPathChanged &&
+ data == EMcContainerOpened )
+ {
+ mCollectionClient.setOpenStatus(VideoCollectionClient::ECollectionOpened);
+ }
+}
+
+// -----------------------------------------------------------------------------
+// handleMyVideosItemsChanged
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::handleMyVideosItemsChanged(CMPXMessage* aMessage)
+{
+
+ TMPXChangeEventType eventType = EMPXItemModified;
+ if(!mVideoUtils.mediaValue<TMPXChangeEventType>(
+ aMessage,KMPXMessageChangeEventType, eventType))
+ {
+ return;
+ }
+ TMPXItemId itemId = TMPXItemId::InvalidId();
+ if(!mVideoUtils.mediaValue<TMPXItemId>(
+ aMessage,KMPXMessageMediaGeneralId, itemId))
+ {
+ return;
+ }
+
+ switch(eventType)
+ {
+ case EMPXItemDeleted:
+ {
+ mSignalReceiver.itemDeletedSlot(itemId);
+ break;
+ }
+ case EMPXItemInserted:
+ {
+ CMPXMedia *media = mVideoUtils.mediaValuePtr<CMPXMedia>(
+ aMessage, KMPXCommandColAddMedia);
+ if (media)
+ {
+ mSignalReceiver.newVideoAvailableSlot(media);
+ }
+ else
+ {
+ mCollectionClient.fetchMpxMediaByMpxId(itemId);
+ }
+ break;
+ }
+ case EMPXItemModified:
+ {
+ if (itemId.iId2 == KVcxMvcMediaTypeAlbum)
+ {
+ // re-open the album in case album corresponds recently opened.
+ // to fetch the album contents.
+ mCollectionClient.openItem(itemId);
+ }
+ break;
+ }
+ default:
+ {
+ // invalid event type
+ break;
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// handleMyVideosDeleteMessage
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::handleMyVideosDeleteMessage(CMPXMessage* aMessage)
+ {
+
+ CMPXMediaArray *messageArray =
+ mVideoUtils.mediaValuePtr<CMPXMediaArray>(aMessage, KMPXMediaArrayContents);
+ if(!messageArray || messageArray->Count() == 0)
+ {
+ return;
+ }
+
+ QList<TMPXItemId> failedIds;
+ TMPXItemId itemId;
+ int count = messageArray->Count();
+ int failedFlag = 0;
+ CMPXMedia* item = NULL;
+
+ // go throught all removed videos and see if some has failed
+ for (int i = 0; i < count; ++i)
+ {
+ item = (*messageArray)[i];
+ if(!mVideoUtils.mediaValue<TMPXItemId>(item, KMPXMediaGeneralId, itemId))
+ {
+ // invalid message, return
+ return;
+ }
+ // if there's error while fetching value, it means that value does not exists,
+ // so we can assume deletion was succefull
+ if(mVideoUtils.mediaValue<int>(item, KVcxMediaMyVideosInt32Value, failedFlag))
+ {
+ if (failedFlag)
+ {
+ failedIds.append(itemId);
+ }
+ failedFlag = 0;
+ }
+ }
+ mSignalReceiver.videoDeleteCompletedSlot(count, &failedIds);
+}
+
+// -----------------------------------------------------------------------------
+// handleGetMediasByMpxIdResp
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::handleGetMediasByMpxIdResp(CMPXMessage* aMessage)
+{
+
+ CMPXMediaArray* array =
+ mVideoUtils.mediaValuePtr<CMPXMediaArray>(aMessage, KMPXMediaArrayContents);
+ if(!array || array->Count() < 1)
+ {
+ return;
+ }
+ mSignalReceiver.newVideoAvailableSlot((*array)[0]);
+}
+
+// -----------------------------------------------------------------------------
+// handleGetVideoDetailsResp
+// -----------------------------------------------------------------------------
+//
+void VideoCollectionListener::handleGetVideoDetailsResp(CMPXMessage* aMessage)
+{
+ CMPXMedia *item = mVideoUtils.mediaValuePtr<CMPXMedia>(aMessage,KMPXCommandColAddMedia);
+ if(!item)
+ {
+ return;
+ }
+ TMPXItemId itemId;
+ if( !mVideoUtils.mediaValue<TMPXItemId>(item, KMPXMediaGeneralId, itemId))
+ {
+ return;
+ }
+ mSignalReceiver.videoDetailsCompletedSlot(itemId);
+}
+