videocollection/videocollectionwrapper/src/videocollectionlistener.cpp
changeset 36 8aed59de29f9
parent 35 3738fe97f027
child 38 ff53afa8ad05
equal deleted inserted replaced
35:3738fe97f027 36:8aed59de29f9
     9 * Initial Contributors:
     9 * Initial Contributors:
    10 * Nokia Corporation - initial contribution.
    10 * Nokia Corporation - initial contribution.
    11 *
    11 *
    12 * Contributors:
    12 * Contributors:
    13 *
    13 *
    14 * Description:   VideoCollectionClient class implementation
    14 * Description:   VideoCollectionListener class implementation
    15 * 
    15 * 
    16 */
    16 */
    17 
    17 
       
    18 // Version : %version: 32 %
       
    19 
    18 // INCLUDE FILES
    20 // INCLUDE FILES
    19 
       
    20 #include <mpxmediageneraldefs.h>
    21 #include <mpxmediageneraldefs.h>
    21 #include <mpxmessagegeneraldefs.h>
    22 #include <mpxmessagegeneraldefs.h>
    22 #include <mpxmessage2.h>
    23 #include <mpxmessage2.h>
    23 #include <mpxcollectionmessagedefs.h>
    24 #include <mpxcollectionmessagedefs.h>
    24 #include <mpxcollectionmessage.h>
    25 #include <mpxcollectionmessage.h>
    32 #include "videocollectionlistener.h"
    33 #include "videocollectionlistener.h"
    33 #include "videocollectionclient.h"
    34 #include "videocollectionclient.h"
    34 #include "videodatasignalreceiver.h"
    35 #include "videodatasignalreceiver.h"
    35 #include "videocollectionutils.h"
    36 #include "videocollectionutils.h"
    36 #include "videocollectioncommon.h"
    37 #include "videocollectioncommon.h"
       
    38 #include "videocollectiontrace.h"
    37 
    39 
    38 // -----------------------------------------------------------------------------
    40 // -----------------------------------------------------------------------------
    39 // VideoCollectionListener
    41 // VideoCollectionListener
    40 // -----------------------------------------------------------------------------
    42 // -----------------------------------------------------------------------------
    41 //
    43 //
    42 VideoCollectionListener::VideoCollectionListener(VideoCollectionClient &collectionClient,
    44 VideoCollectionListener::VideoCollectionListener( VideoCollectionClient &collectionClient,
    43                                                 VideoDataSignalReceiver &signalReceiver) : 
    45                                                   VideoDataSignalReceiver &signalReceiver)  
    44 mCollectionClient(collectionClient),
    46     : mCollectionClient( collectionClient )
    45 mSignalReceiver(signalReceiver),
    47     , mSignalReceiver( signalReceiver )
    46 mVideoUtils(VideoCollectionUtils::instance())
    48     , mVideoUtils( VideoCollectionUtils::instance() )
    47 {
    49 {
    48 
    50 	FUNC_LOG;
    49 }
    51 }
    50 
    52 
    51 // -----------------------------------------------------------------------------
    53 // -----------------------------------------------------------------------------
    52 // ~VideoCollectionListener
    54 // ~VideoCollectionListener
    53 // -----------------------------------------------------------------------------
    55 // -----------------------------------------------------------------------------
    54 //
    56 //
    55 VideoCollectionListener::~VideoCollectionListener()
    57 VideoCollectionListener::~VideoCollectionListener()
    56 {
    58 {
    57 
    59 	FUNC_LOG;
    58 }
    60 }
    59 
    61 
    60 // -----------------------------------------------------------------------------
    62 // -----------------------------------------------------------------------------
    61 // HandleCollectionMediaL
    63 // HandleCollectionMediaL
    62 // -----------------------------------------------------------------------------
    64 // -----------------------------------------------------------------------------
    63 //
    65 //
    64 void VideoCollectionListener::HandleCollectionMediaL( 
    66 void VideoCollectionListener::HandleCollectionMediaL( 
    65         const CMPXMedia& /*aMedia*/,
    67         const CMPXMedia& /*aMedia*/,
    66         TInt /*aError*/)
    68         TInt /*aError*/)
    67 {
    69 {
    68    // NOP
    70 	FUNC_LOG;
    69 }
    71 }
    70 
    72 
    71 // -----------------------------------------------------------------------------
    73 // -----------------------------------------------------------------------------
    72 // HandleOpenL
    74 // HandleOpenL
    73 // -----------------------------------------------------------------------------
    75 // -----------------------------------------------------------------------------
    76         const CMPXMedia& aEntries,
    78         const CMPXMedia& aEntries,
    77         TInt /*aIndex*/,
    79         TInt /*aIndex*/,
    78         TBool /*aComplete*/,
    80         TBool /*aComplete*/,
    79         TInt aError)
    81         TInt aError)
    80 {
    82 {
       
    83 	FUNC_LOG;
    81     if(aError != KErrNone)
    84     if(aError != KErrNone)
    82     {
    85     {
       
    86         ERROR(aError, "VideoCollectionListener::HandleOpenL()");
    83         return;
    87         return;
    84     }
    88     }
    85 
    89 
    86     // Check that current level is valid and entries has collection path. 
    90     // Check that current level is valid and entries has collection path. 
    87     if(mCollectionClient.getCollectionLevel() < VideoCollectionCommon::ELevelCategory || 
    91     if(mCollectionClient.getCollectionLevel() < VideoCollectionCommon::ELevelCategory )
    88        !aEntries.IsSupported(KMPXMediaGeneralContainerPath))
    92     {
    89     {
    93         ERROR(-1, "VideoCollectionListener::HandleOpenL() invalid level");
    90         return;
    94         return;
    91     }
    95     }
    92     
    96 
    93     CMPXMediaArray *array =
    97     CMPXMediaArray *array =
    94                     mVideoUtils.mediaValuePtr<CMPXMessageArray>(&aEntries, KMPXMediaArrayContents);
    98                     mVideoUtils.mediaValuePtr<CMPXMessageArray>(&aEntries, KMPXMediaArrayContents);
    95     if(!array)
    99     if(!array)
    96     {
   100     {
    97         // no videos!
   101         ERROR(-1, "VideoCollectionListener::HandleOpenL() array contents is NULL.");
    98         return;
   102         return;
    99     }
   103     }
   100 
   104 
   101     CMPXCollectionPath* path = aEntries.Value<CMPXCollectionPath>(KMPXMediaGeneralContainerPath); 
   105     CMPXCollectionPath* path = 
       
   106                     mVideoUtils.mediaValuePtr<CMPXCollectionPath>(&aEntries, KMPXMediaGeneralContainerPath);
   102     if(!path)
   107     if(!path)
   103 	{
   108 	{
       
   109         ERROR(-1, "VideoCollectionListener::HandleOpenL() no container path in message.");
   104         return;
   110         return;
   105 	}
   111 	}
   106 
   112 
   107     TMPXItemId pathId = path->Id();
   113     TMPXItemId pathId = path->Id();
   108     
   114     
   134 //                      
   140 //                      
   135 void VideoCollectionListener::HandleOpenL( 
   141 void VideoCollectionListener::HandleOpenL( 
   136         const CMPXCollectionPlaylist& /*aPlaylist*/,
   142         const CMPXCollectionPlaylist& /*aPlaylist*/,
   137         TInt /*aError*/)
   143         TInt /*aError*/)
   138 {
   144 {
   139     // NOP
   145 	FUNC_LOG;
   140 }
   146 }
   141 
   147 
   142 // -----------------------------------------------------------------------------
   148 // -----------------------------------------------------------------------------
   143 // HandleCommandComplete
   149 // HandleCommandComplete
   144 // -----------------------------------------------------------------------------
   150 // -----------------------------------------------------------------------------
   145 //
   151 //
   146 void VideoCollectionListener::HandleCommandComplete( 
   152 void VideoCollectionListener::HandleCommandComplete( 
   147         CMPXCommand* aCommandResult, 
   153         CMPXCommand* aCommandResult, 
   148         TInt aError)
   154         TInt aError)
   149 {
   155 {
       
   156 	FUNC_LOG;
   150     if(aError != KErrNone || !aCommandResult)
   157     if(aError != KErrNone || !aCommandResult)
   151     {
   158     {
       
   159         ERROR_1(aError, "VideoCollectionListener::HandleCommandComplete() result: %d", aCommandResult);
   152         return;
   160         return;
   153     }
   161     }
   154     int commandId = -1;
   162     int commandId = -1;
   155     
   163     
   156     if(mVideoUtils.mediaValue<int>(aCommandResult, KVcxMediaMyVideosCommandId, commandId))
   164     if(mVideoUtils.mediaValue<int>(aCommandResult, KVcxMediaMyVideosCommandId, commandId))
   208 //
   216 //
   209 void VideoCollectionListener::HandleCollectionMessage( 
   217 void VideoCollectionListener::HandleCollectionMessage( 
   210         CMPXMessage* aMessage,
   218         CMPXMessage* aMessage,
   211         TInt aError )
   219         TInt aError )
   212 {
   220 {
       
   221 	FUNC_LOG;
   213     if(aError)
   222     if(aError)
   214     {
   223     {
       
   224         ERROR(aError, "VideoCollectionListener::HandleCollectionMessage()");
   215         return;
   225         return;
   216     }  
   226     }  
   217 
   227 
   218     TMPXMessageId mainMessageId;
   228     TMPXMessageId mainMessageId;
   219     if(!mVideoUtils.mediaValue<TMPXMessageId>(aMessage, KMPXMessageGeneralId, mainMessageId))
   229     if(!mVideoUtils.mediaValue<TMPXMessageId>(aMessage, KMPXMessageGeneralId, mainMessageId))
   238         {
   248         {
   239             handleGeneralMPXMessage(aMessage);
   249             handleGeneralMPXMessage(aMessage);
   240         }
   250         }
   241         return;
   251         return;
   242     }
   252     }
   243            
   253 
   244     if( mainMessageId == KVcxCommandIdMyVideos)
   254     if( mainMessageId == KVcxCommandIdMyVideos)
   245     {        
   255     {        
   246         int myVideosMainMsgId = -1; 
   256         int myVideosMainMsgId = -1; 
   247 
   257 
   248         if(!mVideoUtils.mediaValue<int>(aMessage, KVcxMediaMyVideosCommandId, myVideosMainMsgId ))
   258         if(!mVideoUtils.mediaValue<int>(aMessage, KVcxMediaMyVideosCommandId, myVideosMainMsgId))
   249         {
   259         {
   250             return;
   260             return;
   251         }
   261         }
   252 
   262 
   253         if ( myVideosMainMsgId == KVcxMessageMyVideosMessageArray )
   263         if (myVideosMainMsgId == KVcxMessageMyVideosMessageArray)
   254         {
   264         {
   255             handleMyVideosMessageArray(aMessage); 
   265             handleMyVideosMessageArray(aMessage); 
   256         }
   266         }
   257         else
   267         else
   258         {
   268         {
   269 // handleMyVideosMessageArray
   279 // handleMyVideosMessageArray
   270 // -----------------------------------------------------------------------------
   280 // -----------------------------------------------------------------------------
   271 //
   281 //
   272 void VideoCollectionListener::handleMyVideosMessageArray(CMPXMessage *aMessage)
   282 void VideoCollectionListener::handleMyVideosMessageArray(CMPXMessage *aMessage)
   273 {   
   283 {   
       
   284 	FUNC_LOG;
   274     CMPXMessageArray* messageArray = NULL;
   285     CMPXMessageArray* messageArray = NULL;
   275     
   286     
   276     messageArray = mVideoUtils.mediaValuePtr<CMPXMessageArray>(aMessage, KMPXMessageArrayContents);
   287     messageArray = mVideoUtils.mediaValuePtr<CMPXMessageArray>(aMessage, KMPXMessageArrayContents);
   277     if(!messageArray)
   288     if(!messageArray)
   278     {
   289     {
   279         return;
   290         return;
   280     }
   291     }
   281     
   292     
   282     int count = messageArray->Count();    
   293     int count = messageArray->Count();
   283     int myVideosMsgId;
   294     int myVideosMsgId;
   284     TMPXMessageId mpxMessageId;
   295     TMPXMessageId mpxMessageId;
   285     
   296     
   286     CMPXMessage *singleMessage;
   297     CMPXMessage *singleMessage;
   287     for ( int i = 0; i < count; ++i )
   298     for ( int i = 0; i < count; ++i )
   303 // handleMyVideosMPXMessage
   314 // handleMyVideosMPXMessage
   304 // -----------------------------------------------------------------------------
   315 // -----------------------------------------------------------------------------
   305 //
   316 //
   306 void VideoCollectionListener::handleMyVideosMPXMessage(int &myVideosMsgId, CMPXMessage *aMessage)
   317 void VideoCollectionListener::handleMyVideosMPXMessage(int &myVideosMsgId, CMPXMessage *aMessage)
   307 {
   318 {
       
   319 	FUNC_LOG;
   308     switch (myVideosMsgId)
   320     switch (myVideosMsgId)
   309     {
   321     {
   310         case KVcxMessageMyVideosGetMediasByMpxIdResp:
   322         case KVcxMessageMyVideosGetMediasByMpxIdResp:
   311             handleGetMediasByMpxIdResp(aMessage);
   323             handleGetMediasByMpxIdResp(aMessage);
   312             break;
   324             break;
   336 // handleCommonMPXMessage
   348 // handleCommonMPXMessage
   337 // -----------------------------------------------------------------------------
   349 // -----------------------------------------------------------------------------
   338 //
   350 //
   339 void VideoCollectionListener::handleMPXMessage(TMPXMessageId &mpxMessageId, CMPXMessage *aMessage)
   351 void VideoCollectionListener::handleMPXMessage(TMPXMessageId &mpxMessageId, CMPXMessage *aMessage)
   340 {
   352 {
       
   353 	FUNC_LOG;
   341     switch(mpxMessageId)
   354     switch(mpxMessageId)
   342     {
   355     {
   343         case KMPXMessageGeneral:
   356         case KMPXMessageGeneral:
   344             handleGeneralMPXMessage(aMessage);
   357             handleGeneralMPXMessage(aMessage);
   345         break;
   358         break;
   355 // handleGeneralMPXMessage
   368 // handleGeneralMPXMessage
   356 // -----------------------------------------------------------------------------
   369 // -----------------------------------------------------------------------------
   357 //
   370 //
   358 void VideoCollectionListener::handleGeneralMPXMessage(CMPXMessage* aMessage)
   371 void VideoCollectionListener::handleGeneralMPXMessage(CMPXMessage* aMessage)
   359 {
   372 {
       
   373 	FUNC_LOG;
   360     if(mCollectionClient.getOpenStatus() != VideoCollectionClient::ECollectionOpening)
   374     if(mCollectionClient.getOpenStatus() != VideoCollectionClient::ECollectionOpening)
   361     {
   375     {
   362         return;
   376         return;
   363     }
   377     }
   364     int event = 0;
   378     int event = 0;
   384 // handleMyVideosItemsChanged
   398 // handleMyVideosItemsChanged
   385 // -----------------------------------------------------------------------------
   399 // -----------------------------------------------------------------------------
   386 //
   400 //
   387 void VideoCollectionListener::handleMyVideosItemsChanged(CMPXMessage* aMessage)
   401 void VideoCollectionListener::handleMyVideosItemsChanged(CMPXMessage* aMessage)
   388 {
   402 {
   389 
   403 	FUNC_LOG;
   390     TMPXChangeEventType eventType = EMPXItemModified; 
   404     TMPXChangeEventType eventType = EMPXItemModified; 
   391     if(!mVideoUtils.mediaValue<TMPXChangeEventType>(
   405     if(!mVideoUtils.mediaValue<TMPXChangeEventType>(
   392         aMessage,KMPXMessageChangeEventType, eventType))
   406         aMessage,KMPXMessageChangeEventType, eventType))
   393     {
   407     {
   394         return;
   408         return;
   397     if(!mVideoUtils.mediaValue<TMPXItemId>(
   411     if(!mVideoUtils.mediaValue<TMPXItemId>(
   398         aMessage,KMPXMessageMediaGeneralId, itemId))
   412         aMessage,KMPXMessageMediaGeneralId, itemId))
   399     {       
   413     {       
   400         return;
   414         return;
   401     }
   415     }
   402     
   416     INFO_3("VideoCollectionListener::handleMyVideosItemsChanged event: %d - item id1: %d id2: %d", eventType, itemId.iId1, itemId.iId2);
   403     switch(eventType)
   417     switch(eventType)
   404     {
   418     {
   405         case EMPXItemDeleted:
   419         case EMPXItemDeleted:
   406         {
   420         {
   407             mSignalReceiver.itemDeletedSlot(itemId);
   421             mSignalReceiver.itemDeletedSlot(itemId);
   409         }
   423         }
   410         case EMPXItemInserted:
   424         case EMPXItemInserted:
   411         {
   425         {
   412             CMPXMedia *media = mVideoUtils.mediaValuePtr<CMPXMedia>(
   426             CMPXMedia *media = mVideoUtils.mediaValuePtr<CMPXMedia>(
   413                 aMessage, KMPXCommandColAddMedia);
   427                 aMessage, KMPXCommandColAddMedia);
   414             if (media)
   428             if(media)
   415             {
   429             {
   416                 mSignalReceiver.newVideoAvailableSlot(media); 
   430                 mSignalReceiver.newVideoAvailableSlot(media); 
   417             }
   431             }
   418             else
   432             else
   419             {
   433             {
   421             }
   435             }
   422             break;
   436             break;
   423         }
   437         }
   424         case EMPXItemModified:
   438         case EMPXItemModified:
   425         {
   439         {
   426             if (itemId.iId2 == KVcxMvcMediaTypeAlbum)
   440             INFO("VideoCollectionListener::handleMyVideosItemsChanged EMPXItemModified");
       
   441             // Inform that item data has changed.
       
   442             mSignalReceiver.itemModifiedSlot(itemId);
       
   443             // Update category contents.
       
   444             if(itemId.iId2 == KVcxMvcMediaTypeAlbum ||
       
   445                itemId.iId2 == KVcxMvcMediaTypeCategory)
   427             {
   446             {
   428                 // re-open the album in case album corresponds recently opened.
   447                 INFO("VideoCollectionListener::handleMyVideosItemsChanged album or category modified, opening.");
   429                 // to fetch the album contents.
       
   430                 mCollectionClient.openItem(itemId);
   448                 mCollectionClient.openItem(itemId);
       
   449                 // collection is already opened at this stage, so we can safely set value here
       
   450                 // to make sure we do not let any other messages unhandled 
       
   451                 mCollectionClient.setOpenStatus(VideoCollectionClient::ECollectionOpened, false);
   431             }
   452             }
   432             break;
   453             break;
   433         }
   454         }
   434         default:
   455         default:
   435         {
   456         {
   443 // handleMyVideosDeleteMessage
   464 // handleMyVideosDeleteMessage
   444 // -----------------------------------------------------------------------------
   465 // -----------------------------------------------------------------------------
   445 //
   466 //
   446 void VideoCollectionListener::handleMyVideosDeleteMessage(CMPXMessage* aMessage)
   467 void VideoCollectionListener::handleMyVideosDeleteMessage(CMPXMessage* aMessage)
   447     {
   468     {
   448 
   469 	FUNC_LOG;
   449     CMPXMediaArray *messageArray = 
   470     CMPXMediaArray *messageArray = 
   450         mVideoUtils.mediaValuePtr<CMPXMediaArray>(aMessage, KMPXMediaArrayContents);
   471         mVideoUtils.mediaValuePtr<CMPXMediaArray>(aMessage, KMPXMediaArrayContents);
   451     if(!messageArray || messageArray->Count() == 0)
   472     if(!messageArray || messageArray->Count() == 0)
   452     {
   473     {
   453         return;
   474         return;
   486 // handleGetMediasByMpxIdResp
   507 // handleGetMediasByMpxIdResp
   487 // -----------------------------------------------------------------------------
   508 // -----------------------------------------------------------------------------
   488 //
   509 //
   489 void VideoCollectionListener::handleGetMediasByMpxIdResp(CMPXMessage* aMessage)
   510 void VideoCollectionListener::handleGetMediasByMpxIdResp(CMPXMessage* aMessage)
   490 {
   511 {
   491     
   512 	FUNC_LOG;
   492     CMPXMediaArray* array = 
   513     CMPXMediaArray* array = 
   493         mVideoUtils.mediaValuePtr<CMPXMediaArray>(aMessage, KMPXMediaArrayContents);
   514         mVideoUtils.mediaValuePtr<CMPXMediaArray>(aMessage, KMPXMediaArrayContents);
   494     if(!array || array->Count() < 1)
   515     if(!array || array->Count() < 1)
   495     {
   516     {
   496         return;
   517         return;
   497     }
   518     }
   498     mSignalReceiver.newVideoAvailableSlot((*array)[0]);    
   519     mSignalReceiver.newVideoAvailableSlot((*array)[0]);
   499 }
   520 }
   500 
   521 
   501 // -----------------------------------------------------------------------------
   522 // -----------------------------------------------------------------------------
   502 // handleGetVideoDetailsResp
   523 // handleGetVideoDetailsResp
   503 // -----------------------------------------------------------------------------
   524 // -----------------------------------------------------------------------------
   504 //
   525 //
   505 void VideoCollectionListener::handleGetVideoDetailsResp(CMPXMessage* aMessage)
   526 void VideoCollectionListener::handleGetVideoDetailsResp(CMPXMessage* aMessage)
   506 {
   527 {
       
   528 	FUNC_LOG;
   507     CMPXMedia *item = mVideoUtils.mediaValuePtr<CMPXMedia>(aMessage,KMPXCommandColAddMedia); 
   529     CMPXMedia *item = mVideoUtils.mediaValuePtr<CMPXMedia>(aMessage,KMPXCommandColAddMedia); 
   508     if(!item)
   530     if(!item)
   509     {
   531     {
   510         return;
   532         return;
   511     }
   533     }
   512     TMPXItemId itemId;
   534     mSignalReceiver.videoDetailsCompletedSlot(item);
   513     if( !mVideoUtils.mediaValue<TMPXItemId>(item, KMPXMediaGeneralId, itemId))
   535 }
   514     {
   536 
   515         return;
   537 // End of file.
   516     }
       
   517     mSignalReceiver.videoDetailsCompletedSlot(itemId);
       
   518 }
       
   519