mmappcomponents/collectionhelper/src/mpxcollectionuihelperimp.cpp
branchRCL_3
changeset 15 d240f0a77280
parent 2 7a9a8e73f54b
child 30 6f9f6e99a23e
equal deleted inserted replaced
14:05b0d2323768 15:d240f0a77280
  1025     else
  1025     else
  1026         {
  1026         {
  1027         // currently only used by incremental add
  1027         // currently only used by incremental add
  1028         iTaskQueue->CancelRequests();
  1028         iTaskQueue->CancelRequests();
  1029         
  1029         
       
  1030         if( iTask == ETaskIncAddMedia || iTask == ETaskIncAppendMedia )
       
  1031             {
       
  1032             // complete task from scheduler
       
  1033             iTaskQueue->CompleteTask();
       
  1034             }
       
  1035         
  1030         // clean up iInputMedia
  1036         // clean up iInputMedia
  1031         if( iInputMedia )
  1037         if( iInputMedia )
  1032             {
  1038             {
  1033             delete iInputMedia;
  1039             delete iInputMedia;
  1034             iInputMedia = NULL;
  1040             iInputMedia = NULL;
  1249 //
  1255 //
  1250 void CMPXCollectionUiHelperImp::HandleOpenL(const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/)
  1256 void CMPXCollectionUiHelperImp::HandleOpenL(const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/)
  1251     {
  1257     {
  1252     // Not used
  1258     // Not used
  1253     ASSERT(0);
  1259     ASSERT(0);
       
  1260     }
       
  1261 
       
  1262 // ---------------------------------------------------------------------------
       
  1263 // From MMPXCollectionObserver
       
  1264 // ---------------------------------------------------------------------------
       
  1265 //
       
  1266 void CMPXCollectionUiHelperImp::HandleCommandComplete(CMPXCommand* aCommandResult, TInt aError)
       
  1267     {
       
  1268     MPX_DEBUG3("CMPXCollectionUiHelperImp::HandleCommandComplete iTask=%d, aError=%d", 
       
  1269         iTask, aError);
       
  1270 
       
  1271     if( iTask == ETaskIncAddMedia && iInputMedia )
       
  1272         {
       
  1273         if ( iChunkNumber == 0 )
       
  1274             {
       
  1275             // save playlistId in input media & use it for subsequent appending operations
       
  1276             if( aCommandResult )
       
  1277                 {
       
  1278                 TMPXItemId playlistId = 
       
  1279                     aCommandResult->ValueTObjectL<TMPXItemId>(KMPXCommandColAddRtnId);
       
  1280                     
       
  1281                 iInputMedia->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, playlistId);
       
  1282                 }
       
  1283             
       
  1284             iChunkNumber++;  // move on to next chunk
       
  1285             
       
  1286             CompleteTask(iTask, aError);
       
  1287             }
       
  1288         else if ( iChunkNumber == iTotalChunkNumber-1 )  // last chunk
       
  1289             {
       
  1290             CompleteTask(ETaskIncFinish, aError);  // finish inc task
       
  1291             }
       
  1292         else // intermedia chunks
       
  1293             {
       
  1294             iChunkNumber++;  // move on to next chunk
       
  1295             
       
  1296             CompleteTask(iTask, aError);
       
  1297             }
       
  1298         }
       
  1299     else if( iTask == ETaskIncAppendMedia && iInputMedia )
       
  1300         {
       
  1301         // last chunk
       
  1302         // for the case that there is only one chunk (first & last chunk at the same 
       
  1303         // time), Inc Add is not used
       
  1304         if( iChunkNumber == iTotalChunkNumber-1 )
       
  1305             {
       
  1306             // update input media as well
       
  1307             FillInPlaylistDetailsL(*iInputMedia);
       
  1308             CompleteTask(ETaskIncFinish, aError);        
       
  1309             }
       
  1310         else // intermediate chunks, including first chunk
       
  1311             {       
       
  1312             iChunkNumber++;
       
  1313             CompleteTask(iTask, aError);
       
  1314             }
       
  1315         }
  1254     }
  1316     }
  1255 
  1317 
  1256 // ----------------------------------------------------------------------------
  1318 // ----------------------------------------------------------------------------
  1257 // Handles completion of moving an object, just a proxy
  1319 // Handles completion of moving an object, just a proxy
  1258 // ----------------------------------------------------------------------------
  1320 // ----------------------------------------------------------------------------
  1679 // ---------------------------------------------------------------------------
  1741 // ---------------------------------------------------------------------------
  1680 //
  1742 //
  1681 void CMPXCollectionUiHelperImp::DoIncAddMediaL()
  1743 void CMPXCollectionUiHelperImp::DoIncAddMediaL()
  1682     {
  1744     {
  1683     /***** include only aSize/iChunkSize number of songs *****/
  1745     /***** include only aSize/iChunkSize number of songs *****/
  1684     
  1746     MPX_DEBUG5("CMPXCollectionUiHelperImp::DoIncAddMediaL (%d, %d, %d, %d)", 
       
  1747         iChunkNumber, iChunkSize, iTotalChunkNumber, iRemainder);
  1685     // copy media
  1748     // copy media
  1686     CMPXMedia* media = CMPXMedia::CopyL(*iInputMedia);
  1749     CMPXMedia* media = CMPXMedia::CopyL(*iInputMedia);
  1687     CleanupStack::PushL(media);
  1750     CleanupStack::PushL(media);
  1688     
  1751     
  1689     CMPXMediaArray* tracksArray = iInputMedia->Value<CMPXMediaArray>( KMPXMediaArrayContents );  
  1752     CMPXMediaArray* tracksArray = iInputMedia->Value<CMPXMediaArray>( KMPXMediaArrayContents );  
  1737         iInputMedia->SetTObjectValueL<TUid>(
  1800         iInputMedia->SetTObjectValueL<TUid>(
  1738                 KMPXMediaGeneralCollectionId, TUid::Uid( collectionId ));
  1801                 KMPXMediaGeneralCollectionId, TUid::Uid( collectionId ));
  1739         
  1802         
  1740         CleanupStack::PopAndDestroy(playlistExtension); 
  1803         CleanupStack::PopAndDestroy(playlistExtension); 
  1741 
  1804 
  1742         iMediator->AddItemL( media );  // this creates the new playlist
  1805         iMediator->AddItemAsyncL( media );  // this creates the new playlist
  1743         
       
  1744         // save playlistId in input media & use it for subsequent appending operations
       
  1745         TMPXItemId playlistId = media->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
       
  1746         iInputMedia->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, playlistId);
       
  1747         
       
  1748         iChunkNumber++;  // move on to next chunk
       
  1749         
       
  1750         CompleteTask(iTask, KErrNone);
       
  1751         }
  1806         }
  1752     else if ( iChunkNumber == iTotalChunkNumber-1 )  // last chunk
  1807     else if ( iChunkNumber == iTotalChunkNumber-1 )  // last chunk
  1753         {
  1808         {
  1754         // get saved collection id from input media & set it in current media
  1809         // get saved collection id from input media & set it in current media
  1755         TUid id = iInputMedia->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId);
  1810         TUid id = iInputMedia->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId);
  1757  
  1812  
  1758         // get playlistId from input media & set it in current media
  1813         // get playlistId from input media & set it in current media
  1759         TMPXItemId playlistId = iInputMedia->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
  1814         TMPXItemId playlistId = iInputMedia->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
  1760         media->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, playlistId);
  1815         media->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, playlistId);
  1761         
  1816         
  1762         iMediator->AddItemL( media );
  1817         iMediator->AddItemAsyncL( media );
  1763         
       
  1764         CompleteTask(ETaskIncFinish, KErrNone);  // finish inc task
       
  1765         }
  1818         }
  1766     else // intermedia chunks
  1819     else // intermedia chunks
  1767         {
  1820         {
  1768         // get saved collection id from input media & set it in current media
  1821         // get saved collection id from input media & set it in current media
  1769         TUid id = iInputMedia->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId);
  1822         TUid id = iInputMedia->ValueTObjectL<TUid>(KMPXMediaGeneralCollectionId);
  1771         
  1824         
  1772         // get playlistId from original media & set it in current media
  1825         // get playlistId from original media & set it in current media
  1773         TMPXItemId playlistId = iInputMedia->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
  1826         TMPXItemId playlistId = iInputMedia->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId);
  1774         media->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, playlistId);
  1827         media->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, playlistId);
  1775 
  1828 
  1776         iMediator->AddItemL( media );
  1829         iMediator->AddItemAsyncL( media );
  1777         
       
  1778         iChunkNumber++;  // move on to next chunk
       
  1779         
       
  1780         CompleteTask(iTask, KErrNone);
       
  1781         }
  1830         }
  1782     
  1831     
  1783     CleanupStack::PopAndDestroy(cArray);
  1832     CleanupStack::PopAndDestroy(cArray);
  1784     CleanupStack::PopAndDestroy(media);
  1833     CleanupStack::PopAndDestroy(media);
  1785     }
  1834     }
  1828     
  1877     
  1829     /***** logic to see which chunk this code is in *****/
  1878     /***** logic to see which chunk this code is in *****/
  1830 
  1879 
  1831     // update media then append to playlist
  1880     // update media then append to playlist
  1832     FillInPlaylistDetailsL(*media);
  1881     FillInPlaylistDetailsL(*media);
  1833     iMediator->AddItemL( media );
  1882     iMediator->AddItemAsyncL( media );
  1834 
  1883 
  1835     // last chunk
       
  1836     // for the case that there is only one chunk (first & last chunk at the same 
       
  1837     // time), Inc Add is not used
       
  1838     if( iChunkNumber == iTotalChunkNumber-1 )
       
  1839         {
       
  1840         // update input media as well
       
  1841         FillInPlaylistDetailsL(*iInputMedia);
       
  1842         CompleteTask(ETaskIncFinish, KErrNone);        
       
  1843         }
       
  1844     else // intermediate chunks, including first chunk
       
  1845         {       
       
  1846         iChunkNumber++;
       
  1847         CompleteTask(iTask, KErrNone);
       
  1848         }
       
  1849    
       
  1850     CleanupStack::PopAndDestroy(cArray);
  1884     CleanupStack::PopAndDestroy(cArray);
  1851     CleanupStack::PopAndDestroy(media);
  1885     CleanupStack::PopAndDestroy(media);
  1852     }
  1886     }
  1853 
  1887 
  1854 // ---------------------------------------------------------------------------
  1888 // ---------------------------------------------------------------------------