364  	IRLOG_DEBUG( "CIRSongHistoryDb::GetAllSongHistoryListL" );

   364  	IRLOG_DEBUG( "CIRSongHistoryDb::GetAllSongHistoryListL" ); 	 

   365 

   366  	TInt error = KErrNone;

   386     columns = NULL;

   384     columns = NULL; 	 

   387 

   385     

   388 	// Comparer function to find channel in channelHistoryArr

   386  	TInt song = 0;

   389 	TIdentityRelation<CIRChannelInfo> comparer( CIRSongHistoryDb::CompareChannelInfos );

   387  	

   390 	

   388  	

   391  	// Find out channels in order

   389     for ( iSongHistoryTable.LastL(); iSongHistoryTable.AtRow(); iSongHistoryTable.PreviousL() ) 	 

   392  	RPointerArray<CIRChannelInfo> channelHistoryArr;

   393     for ( iSongHistoryTable.LastL(); iSongHistoryTable.AtRow(); iSongHistoryTable.PreviousL() )

   396 

   392         

   397 		CIRChannelInfo *pChannelInfo = new ( ELeave ) CIRChannelInfo;

   393         RBuf songName;

   398 		CleanupStack::PushL( pChannelInfo );

   394         RBuf artistName;

   399 		pChannelInfo->iChannelName.Create(iSongHistoryTable.ColDes( channelColumn ));

   395         RBuf channelName;

   400 		pChannelInfo->iChannelUrl.Create(iSongHistoryTable.ColDes( channelUrlColumn ));

   396         RBuf channelUrl;

   401 		pChannelInfo->iChannelType = iSongHistoryTable.ColUint16( channelTypeColumn );

   397         TInt channelType;

   402        

   398         TInt channelId;

   403 		// Verify the channel is not in our list already

   399         TInt bitrate;

   404 		if( channelHistoryArr.Find(pChannelInfo, comparer) == KErrNotFound )

   400         RBuf channelDesc;

   405 		{

   401         RBuf imageUrl;

   406 			error = channelHistoryArr.Append( pChannelInfo );

   402         RBuf channelMusicStatus;

   407 		 	if( error!=KErrNone )

   403         

   408 		 	{

   404         songName.CreateL(iSongHistoryTable.ColDes( songColumn ));

   409 		 		CleanupStack::PopAndDestroy( pChannelInfo );

   405         songName.CleanupClosePushL();

   410 		 		channelHistoryArr.ResetAndDestroy();

   406         

   411 			 	User::LeaveIfError(error);

   407         artistName.CreateL(iSongHistoryTable.ColDes( artistColumn ));

   412 		 	}

   408         artistName.CleanupClosePushL();

   413 

   409         

   414 			CleanupStack::Pop( pChannelInfo );

   410         channelName.CreateL(iSongHistoryTable.ColDes( channelColumn ));

   415 

   411         channelName.CleanupClosePushL();

   416 

   412         

   417 		}

   413         channelUrl.CreateL(iSongHistoryTable.ColDes( channelUrlColumn ));

   418 		else

   414         channelUrl.CleanupClosePushL();

   419 		{

   415         

   420 			CleanupStack::PopAndDestroy( pChannelInfo );

   416         channelType=iSongHistoryTable.ColUint8( channelTypeColumn );

   421 		}

   417         

   422 	}

   418         channelId=iSongHistoryTable.ColUint16( channelIdColumn );

   423 

   419         

   424 	// Find out songs for each channel in order

   420         bitrate=iSongHistoryTable.ColUint16( bitrateColumn );

   425 

   421         

   426 	TInt song = 0;

   422         channelDesc.CreateL(iSongHistoryTable.ColDes( channelDescColumn ));

   427 	for( TInt channelIndex = 0; channelIndex < channelHistoryArr.Count(); ++channelIndex )

   423         channelDesc.CleanupClosePushL();

   428 	{

   424 

   429 		for ( iSongHistoryTable.LastL(); iSongHistoryTable.AtRow(); iSongHistoryTable.PreviousL() )

   425         imageUrl.CreateL(iSongHistoryTable.ColDes( imageUrlColumn ));

   430 		{

   426         imageUrl.CleanupClosePushL();

   431 			iSongHistoryTable.GetL();

   427 

   432 			// Extracting the values from the database.

   428         channelMusicStatus.CreateL(iSongHistoryTable.ColDes( musicStatusColumn ));

   433 			if(song < aHistoryDataArr.Count())

   429         channelMusicStatus.CleanupClosePushL();

   434 			{

   430  

   435 				RBuf songName;

   431         aHistoryDataArr[song]->SetHistoryInfo(songName, artistName, channelUrl,

   436 				RBuf artistName;

   432                          channelName,channelType,channelId,bitrate,channelDesc ,

   437 				RBuf channelName;

   433                          imageUrl, channelMusicStatus);

   438 				RBuf channelUrl;

   434         ++song;

   439 				TInt channelType;

   435  

   440 				TInt channelId;

   436         

   441 				TInt bitrate;

   437         CleanupStack::PopAndDestroy(&channelMusicStatus);

   442                 RBuf channelDesc;

   438         CleanupStack::PopAndDestroy(&imageUrl);

   443                 RBuf imageUrl;

   439         CleanupStack::PopAndDestroy(&channelDesc);

   444                 RBuf channelMusicStatus;

   440         CleanupStack::PopAndDestroy(&channelUrl);

   445                 

   441         CleanupStack::PopAndDestroy(&channelName);

   446 				songName.Create(iSongHistoryTable.ColDes( songColumn ));

   442         CleanupStack::PopAndDestroy(&artistName);

   447 				songName.CleanupClosePushL();

   443         CleanupStack::PopAndDestroy(&songName);

   448 				

   444     }        

   449 				artistName.Create(iSongHistoryTable.ColDes( artistColumn ));

   445  

   450 				artistName.CleanupClosePushL();

   451 				

   452 				channelName.Create(iSongHistoryTable.ColDes( channelColumn ));

   453 				channelName.CleanupClosePushL();

   454 				

   455 				channelUrl.Create(iSongHistoryTable.ColDes( channelUrlColumn ));

   456 				channelUrl.CleanupClosePushL();

   457 				

   458 				channelType=iSongHistoryTable.ColUint8( channelTypeColumn );

   459 				

   460 				channelId=iSongHistoryTable.ColUint16( channelIdColumn );

   461 				

   462 				bitrate=iSongHistoryTable.ColUint16( bitrateColumn );

   463                 

   464                 channelDesc.Create(iSongHistoryTable.ColDes( channelDescColumn ));

   465                 channelDesc.CleanupClosePushL();

   466 

   467                 imageUrl.Create(iSongHistoryTable.ColDes( imageUrlColumn ));

   468                 imageUrl.CleanupClosePushL();

   469 

   470                 channelMusicStatus.Create(iSongHistoryTable.ColDes( musicStatusColumn ));

   471                 channelMusicStatus.CleanupClosePushL();

   472                 

   473 				if( channelHistoryArr[channelIndex]->iChannelName == channelName && 

   474 							channelHistoryArr[channelIndex]->iChannelUrl == channelUrl &&

   475 							channelHistoryArr[channelIndex]->iChannelType == channelType

   476 							)

   477 				{

   478 					aHistoryDataArr[song]->SetHistoryInfo(songName, artistName, channelUrl,

   479 								 channelName,channelType,channelId,bitrate,channelDesc ,

   480 								 imageUrl, channelMusicStatus);

   481 					++song;

   482 				}

   483                 

   484                 CleanupStack::PopAndDestroy(&channelMusicStatus);

   485                 CleanupStack::PopAndDestroy(&imageUrl);

   486 				CleanupStack::PopAndDestroy(&channelDesc);

   487 				CleanupStack::PopAndDestroy(&channelUrl);

   488 				CleanupStack::PopAndDestroy(&channelName);

   489 				CleanupStack::PopAndDestroy(&artistName);

   490 				CleanupStack::PopAndDestroy(&songName);

   491 

   492 			}

   493 			else

   494 			{

   495 				//Should not enter this scenario as aHistoryDataArr is suppose to give

   496 				//required memory allocated. But should it enter here should appendL into

   497 				//the list and increment "iSong"

   498 			}

   499 		}

   500 	}

   501 

   502 	channelHistoryArr.ResetAndDestroy();

   626     

   569 	

   627     iSongHistoryTable.FirstL();

   570     iSongHistoryTable.LastL();

   631         TRAPD(error,iSongHistoryTable.NextL(););

   574         TRAPD(error,iSongHistoryTable.PreviousL());