Mercurial Mercurial > oss > FCL > sf > app > podcatcher / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
engine/src/FeedEngine.cpp
changeset 109 223f270fa7ff
parent 108 554d9980157f
child 110 403412eb5292
equal deleted inserted replaced
108:554d9980157f 109:223f270fa7ff 
    26 #include "OpmlParser.h"
 
    26 #include "OpmlParser.h"
 
    27 #include "PodcastUtils.h"
 
    27 #include "PodcastUtils.h"
 
    28 #include <utf.h>
 
    28 #include <utf.h>
 
    29 
    29 
    30 _LIT(KFeedParseStorePath, "feeds\\");
 
    30 _LIT(KFeedParseStorePath, "feeds\\");
 
    31 // Cleanup stack macro for SQLite3
 
       
    32 // TODO Move this to some common place.
 
       
    33 static void Cleanup_sqlite3_finalize_wrapper(TAny* handle)
 
       
    34 	{
 
       
    35 	sqlite3_finalize(static_cast<sqlite3_stmt*>(handle));
 
       
    36 	}
 
       
    37 #define Cleanup_sqlite3_finalize_PushL(__handle) CleanupStack::PushL(TCleanupItem(&Cleanup_sqlite3_finalize_wrapper, __handle))
 
       
    38 
       
    39 
    31 
    40 CFeedEngine* CFeedEngine::NewL(CPodcastModel& aPodcastModel)
 
    32 CFeedEngine* CFeedEngine::NewL(CPodcastModel& aPodcastModel)
 
    41 	{
 
    33 	{
 
    42 	CFeedEngine* self = new (ELeave) CFeedEngine(aPodcastModel);
 
    34 	CFeedEngine* self = new (ELeave) CFeedEngine(aPodcastModel);
 
    43 	CleanupStack::PushL(self);
 
    35 	CleanupStack::PushL(self);
 
    51 	iParser = new (ELeave) CFeedParser(*this, iPodcastModel.FsSession());
 
    43 	iParser = new (ELeave) CFeedParser(*this, iPodcastModel.FsSession());
 
    52 	
    44 	
    53 	iFeedClient = CHttpClient::NewL(iPodcastModel, *this);
 
    45 	iFeedClient = CHttpClient::NewL(iPodcastModel, *this);
 
    54 	iFeedTimer.ConstructL();
 
    46 	iFeedTimer.ConstructL();
 
    55 	
    47 	
    56 	RunFeedTimer();
 
    48 	TInt err = KErrNone;
 
    57 	
    49 	TInt feedCount = 0;
 
    58     if (DBGetFeedCount() > 0) 
    50 	
       
    51 	TRAP(err, feedCount = DBGetFeedCountL());
 
       
    52     if (err == KErrNone && feedCount > 0)
 
    59     	{
 
    53     	{
 
    60 		DP("Loading feeds from DB");
 
    54 		DP("Loading feeds from DB");
 
    61 		DBLoadFeedsL();
 
    55 		TRAP(err, DBLoadFeedsL());
 
    62 		} 
    56     	}		
       
    57 
    63     
    58     
    64 	if (iPodcastModel.IsFirstStartup()) {
 
    59 	if (err != KErrNone || iPodcastModel.IsFirstStartup()) {
 
    65 		TFileName defaultFile = iPodcastModel.SettingsEngine().DefaultFeedsFileName();
 
    60 		TFileName defaultFile = iPodcastModel.SettingsEngine().DefaultFeedsFileName();
 
    66 		DP1("Loading default feeds from %S", &defaultFile);
 
    61 		DP1("Loading default feeds from %S", &defaultFile);
 
    67 		if (BaflUtils::FileExists(iPodcastModel.FsSession(), defaultFile)) {
 
    62 		if (BaflUtils::FileExists(iPodcastModel.FsSession(), defaultFile)) {
 
    68 			ImportFeedsL(defaultFile);
 
    63 			ImportFeedsL(defaultFile);
 
    69 		}
 
    64 		}
 
    70 	} else {
 
    65 	} 
    71 		// clean out feeds temp directory
 
    66 	
    72 		TFileName feedTempPath;
 
    67 	// clean out feeds temp directory
 
    73 		feedTempPath.Copy (iPodcastModel.SettingsEngine().PrivatePath ());
 
    68 	TFileName feedTempPath;
 
    74 		feedTempPath.Append(KFeedParseStorePath);
 
    69 	feedTempPath.Copy (iPodcastModel.SettingsEngine().PrivatePath ());
 
    75 		feedTempPath.Append(_L("*"));
 
    70 	feedTempPath.Append(KFeedParseStorePath);
 
    76 
    71 	feedTempPath.Append(_L("*"));
 
    77 		BaflUtils::EnsurePathExistsL(iPodcastModel.FsSession(), feedTempPath);
 
    72 
    78 		BaflUtils::DeleteFile(iPodcastModel.FsSession(),feedTempPath);
 
    73 	BaflUtils::EnsurePathExistsL(iPodcastModel.FsSession(), feedTempPath);
 
    79 	}
 
    74 	BaflUtils::DeleteFile(iPodcastModel.FsSession(),feedTempPath);
 
    80     
    75     
    81     TFileName importFile = iPodcastModel.SettingsEngine().ImportFeedsFileName();
 
    76     TFileName importFile = iPodcastModel.SettingsEngine().ImportFeedsFileName();
 
    82     if (BaflUtils::FileExists(iPodcastModel.FsSession(), importFile)) {
 
    77     if (BaflUtils::FileExists(iPodcastModel.FsSession(), importFile)) {
 
    83     	DP("Importing feeds");
 
    78     	DP("Importing feeds");
 
    84     	ImportFeedsL(importFile);
 
    79     	TRAP_IGNORE(ImportFeedsL(importFile));
 
    85 		}
 
    80 		}
 
       
    81     
       
    82 	RunFeedTimer();
 
    86 	}
 
    83 	}
 
    87 
    84 
    88 CFeedEngine::CFeedEngine(CPodcastModel& aPodcastModel)
 
    85 CFeedEngine::CFeedEngine(CPodcastModel& aPodcastModel)
 
    89 		: iClientState(EIdle),
 
    86 		: iClientState(EIdle),
 
    90 		  iFeedTimer(this),
 
    87 		  iFeedTimer(this),
 
   338 	// Save the feeds into DB
 
   335 	// Save the feeds into DB
 
   339 	DBAddFeedL(aItem);
 
   336 	DBAddFeedL(aItem);
 
   340 	return ETrue;
 
   337 	return ETrue;
 
   341 	}
 
   338 	}
 
   342 
   339 
   343 TBool CFeedEngine::DBAddFeedL(const CFeedInfo& aItem)
 
   340 void CFeedEngine::DBAddFeedL(const CFeedInfo& aItem)
 
   344 	{
 
   341 	{
 
   345 	DP2("CFeedEngine::DBAddFeed, title=%S, URL=%S", &aItem.Title(), &aItem.Url());
 
   342 	DP2("CFeedEngine::DBAddFeed, title=%S, URL=%S", &aItem.Title(), &aItem.Url());
 
   346 	
   343 	
   347 	CFeedInfo *info = DBGetFeedInfoByUidL(aItem.Uid());
 
   344 	CFeedInfo *info;
 
   348 	if (info) {
 
   345 	
   349 		DP("Feed already exists!");
 
   346 	TRAPD(err, DBGetFeedInfoByUidL(aItem.Uid()));
 
       
   347 	
       
   348 	if (err == KErrNone && info) {
 
   350 		delete info;
 
   349 		delete info;
 
   351 		return EFalse;
 
   350 		User::Leave(KErrAlreadyExists);
 
   352 	}
 
   351 	}
 
   353 
   352 
   354 	HBufC* titleBuf = HBufC::NewLC(KMaxLineLength);
 
   353 	HBufC* titleBuf = HBufC::NewLC(KMaxLineLength);
 
   355 	TPtr titlePtr(titleBuf->Des());
 
   354 	TPtr titlePtr(titleBuf->Des());
 
   356 	titlePtr.Copy(aItem.Title());
 
   355 	titlePtr.Copy(aItem.Title());
 
   370 	CleanupStack::PopAndDestroy(descBuf);
 
   369 	CleanupStack::PopAndDestroy(descBuf);
 
   371 	CleanupStack::PopAndDestroy(titleBuf);
 
   370 	CleanupStack::PopAndDestroy(titleBuf);
 
   372 	
   371 	
   373 	sqlite3_stmt *st;
 
   372 	sqlite3_stmt *st;
 
   374 	 
   373 	 
   375 	//DP1("SQL statement length=%d", iSqlBuffer.Length());
 
       
   376 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st, (const void**) NULL);
 
   374 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st, (const void**) NULL);
 
   377 	
   375 	
   378 	if (rc==SQLITE_OK)
 
   376 	if (rc==SQLITE_OK)
 
   379 		{
 
   377 		{
 
       
   378 		Cleanup_sqlite3_finalize_PushL(st);
 
   380 		rc = sqlite3_step(st);
 
   379 		rc = sqlite3_step(st);
 
   381 
   380 
   382 		if (rc == SQLITE_DONE)
 
   381 		if (rc != SQLITE_DONE)
 
   383 			{
 
   382 			{
 
   384 			sqlite3_finalize(st);
 
   383 			User::Leave(KErrCorrupt);
 
   385 			return ETrue;
 
   384 			}
 
   386 			}
 
   385 		CleanupStack::PopAndDestroy(); // st
 
   387 		else {
 
   386 		}
 
   388 			sqlite3_finalize(st);
 
   387 	else
 
   389 		}
 
   388 		{
 
   390 	}
 
   389 		User::Leave(KErrCorrupt);
 
   391 
   390 		}
 
   392 	return EFalse;
 
       
   393 	}
 
   391 	}
 
   394 
   392 
   395 EXPORT_C void CFeedEngine::RemoveFeedL(TUint aUid) 
   393 EXPORT_C void CFeedEngine::RemoveFeedL(TUint aUid) 
   396 	{
 
   394 	{
 
   397 	if (iActiveFeed && iActiveFeed->Uid() == aUid)
 
   395 	if (iActiveFeed && iActiveFeed->Uid() == aUid)
 
   425 			delete feedToRemove;
 
   423 			delete feedToRemove;
 
   426 			
   424 			
   427 			DP("Removed feed from array");
 
   425 			DP("Removed feed from array");
 
   428 			
   426 			
   429 			// now remove it from DB
 
   427 			// now remove it from DB
 
   430 			DBRemoveFeed(aUid);
 
   428 			DBRemoveFeedL(aUid);
 
   431 
       
   432 			return;
 
       
   433 		}
 
   429 		}
 
   434 	}
 
   430 	}
 
   435 }
 
   431 }
 
   436 
   432 
   437 
   433 
   438 TBool CFeedEngine::DBRemoveFeed(TUint aUid)
 
   434 void CFeedEngine::DBRemoveFeedL(TUint aUid)
 
   439 	{
 
   435 	{
 
   440 	DP("CFeedEngine::DBRemoveFeed");
 
   436 	DP("CFeedEngine::DBRemoveFeed");
 
   441 	_LIT(KSqlStatement, "delete from feeds where uid=%u");
 
   437 	_LIT(KSqlStatement, "delete from feeds where uid=%u");
 
   442 	iSqlBuffer.Format(KSqlStatement, aUid);
 
   438 	iSqlBuffer.Format(KSqlStatement, aUid);
 
   443 
   439 
   445 	 
   441 	 
   446 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   442 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   447 	
   443 	
   448 	if (rc==SQLITE_OK)
 
   444 	if (rc==SQLITE_OK)
 
   449 		{
 
   445 		{
 
       
   446 		Cleanup_sqlite3_finalize_PushL(st);
 
   450 		rc = sqlite3_step(st);
 
   447 		rc = sqlite3_step(st);
 
   451 		sqlite3_finalize(st);
 
   448 
   452 
   449 		if (rc != SQLITE_DONE)
 
   453 		if (rc == SQLITE_DONE)
 
   450 			{
 
   454 			{
 
   451 			User::Leave(KErrNotFound);
 
   455 			DP("Feed removed from DB");
 
   452 			}
 
   456 			return ETrue;
 
   453 		
   457 			}
 
   454 		CleanupStack::PopAndDestroy(); //st
 
   458 		else
 
   455 		}
 
   459 			{
 
   456 	else
 
   460 			DP("Error when removing feed from DB");
 
   457 		{
 
   461 			}
 
   458 		User::Leave(KErrCorrupt);
 
   462 		}
 
   459 		}
 
   463 	return EFalse;	
   460 	}
 
   464 	}
 
   461 
   465 
   462 void CFeedEngine::DBUpdateFeedL(const CFeedInfo &aItem)
 
   466 TBool CFeedEngine::DBUpdateFeedL(const CFeedInfo &aItem)
 
       
   467 	{
 
   463 	{
 
   468 	DP2("CFeedEngine::DBUpdateFeed, title=%S, URL=%S", &aItem.Title(), &aItem.Url());
 
   464 	DP2("CFeedEngine::DBUpdateFeed, title=%S, URL=%S", &aItem.Title(), &aItem.Url());
 
   469 	
   465 	
   470 	HBufC* titleBuf = HBufC::NewLC(KMaxLineLength);
 
   466 	HBufC* titleBuf = HBufC::NewLC(KMaxLineLength);
 
   471 	TPtr titlePtr(titleBuf->Des());
 
   467 	TPtr titlePtr(titleBuf->Des());
 
   486 	CleanupStack::PopAndDestroy(descBuf);
 
   482 	CleanupStack::PopAndDestroy(descBuf);
 
   487 	CleanupStack::PopAndDestroy(titleBuf);
 
   483 	CleanupStack::PopAndDestroy(titleBuf);
 
   488 	
   484 	
   489 	sqlite3_stmt *st;
 
   485 	sqlite3_stmt *st;
 
   490 	 
   486 	 
   491 	//DP1("SQL statement length=%d", iSqlBuffer.Length());
 
       
   492 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st, (const void**) NULL);
 
   487 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st, (const void**) NULL);
 
   493 	
   488 	
   494 	if (rc==SQLITE_OK)
 
   489 	if (rc==SQLITE_OK)
 
   495 		{
 
   490 		{
 
       
   491 		Cleanup_sqlite3_finalize_PushL(st);
 
   496 		rc = sqlite3_step(st);
 
   492 		rc = sqlite3_step(st);
 
   497 		sqlite3_finalize(st);
 
   493 		
   498 		
   494 		if (rc != SQLITE_DONE)
 
   499 		if (rc == SQLITE_DONE)
 
   495 			{
 
   500 			{
 
   496 			User::Leave(KErrNotFound);
 
   501 			return ETrue;
 
   497 			}
 
   502 			}
 
   498 		CleanupStack::PopAndDestroy(); //st
 
   503 		}
 
   499 		}
 
   504 	else
 
   500 	else
 
   505 		{
 
   501 		{
 
   506 		DP1("SQLite rc=%d", rc);
 
   502 		User::Leave(KErrCorrupt);
 
   507 		}
 
   503 		}
 
   508 
       
   509 	return EFalse;
 
       
   510 	}
 
   504 	}
 
   511 
   505 
   512 void CFeedEngine::ParsingCompleteL(CFeedInfo *item)
 
   506 void CFeedEngine::ParsingCompleteL(CFeedInfo *item)
 
   513 	{
 
   507 	{
 
   514 	TBuf<KMaxLineLength> title;
 
   508 	TBuf<KMaxLineLength> title;
 
   625 			{
 
   619 			{
 
   626 			// change client state to not updating
 
   620 			// change client state to not updating
 
   627 			iClientState = EIdle;
 
   621 			iClientState = EIdle;
 
   628 			if(aError == KErrNone)
 
   622 			if(aError == KErrNone)
 
   629 				{
 
   623 				{
 
   630 				if( BaflUtils::FileExists(CEikonEnv::Static()->FsSession(), iActiveFeed->ImageFileName() ))
 
   624 				// now the image has been downloaded, so we set it again in the FeedInfo to start
 
   631 					{
 
   625 				// converting it
 
   632 						// If this fails, no reason to worry
 
   626 				TRAP_IGNORE(iActiveFeed->SetImageFileNameL(iActiveFeed->ImageFileName(), &iPodcastModel));
 
   633 					TRAP_IGNORE(iPodcastModel.ImageHandler().LoadFileAndScaleL(iActiveFeed->FeedIcon(), iActiveFeed->ImageFileName(), TSize(64,56), *iActiveFeed, iActiveFeed->Uid()));
 
       
   634 					}				
       
   635 				}
 
   627 				}
 
   636 			DBUpdateFeedL(*iActiveFeed);
 
   628 			DBUpdateFeedL(*iActiveFeed);
 
   637 			NotifyFeedUpdateComplete(iActiveFeed->Uid(), aError);
 
   629 			NotifyFeedUpdateComplete(iActiveFeed->Uid(), aError);
 
   638 			UpdateNextFeedL();
 
   630 			UpdateNextFeedL();
 
   639 			}break;
 
   631 			}break;
 
   806 	{
 
   798 	{
 
   807 		//DP2("Comparing %S to %S", &a.Title(), &b.Title());
 
   799 		//DP2("Comparing %S to %S", &a.Title(), &b.Title());
 
   808 		return a.Title().CompareF(b.Title());
 
   800 		return a.Title().CompareF(b.Title());
 
   809 	}
 
   801 	}
 
   810 
   802 
   811 EXPORT_C void CFeedEngine::GetDownloadedStats(TUint &aNumShows, TUint &aNumUnplayed)
 
   803 EXPORT_C void CFeedEngine::GetStatsByFeedL(TUint aFeedUid, TUint &aNumShows, TUint &aNumUnplayed)
 
   812 	{
 
   804 	{
 
   813 	DP("CFeedEngine::GetDownloadedStats");
 
   805 	//DP1("CFeedEngine::GetStatsByFeed, aFeedUid=%u", aFeedUid);
 
   814 	_LIT(KSqlStatement, "select count(*) from shows where downloadstate=%u");
 
   806 	DBGetStatsByFeedL(aFeedUid, aNumShows, aNumUnplayed);
 
   815 	iSqlBuffer.Format(KSqlStatement, EDownloaded);
 
   807 	}
 
       
   808 
       
   809 void CFeedEngine::DBGetStatsByFeedL(TUint aFeedUid, TUint &aNumShows, TUint &aNumUnplayed)
 
       
   810 	{
 
       
   811 	//DP1("CFeedEngine::DBGetStatsByFeed, feedUid=%u", aFeedUid);
 
       
   812 	_LIT(KSqlStatement, "select count(*) from shows where feeduid=%u");
 
       
   813 	iSqlBuffer.Format(KSqlStatement, aFeedUid);
 
   816 
   814 
   817 	sqlite3_stmt *st;
 
   815 	sqlite3_stmt *st;
 
   818 	 
   816 	 
   819 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   817 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   820 	
   818 	
   821 	if( rc==SQLITE_OK ){
 
   819 	if( rc==SQLITE_OK)
 
       
   820 		{
 
       
   821 		Cleanup_sqlite3_finalize_PushL(st);
 
   822 	  	rc = sqlite3_step(st);
 
   822 	  	rc = sqlite3_step(st);
 
   823 	  	
   823 	  	
   824 	  	if (rc == SQLITE_ROW) {
 
   824 	  	if (rc == SQLITE_ROW)
 
       
   825 	  		{
 
   825 	  		aNumShows = sqlite3_column_int(st, 0);
 
   826 	  		aNumShows = sqlite3_column_int(st, 0);
 
   826 	  	}
 
   827 	  		}
 
   827 	}
 
   828 	  	else
 
       
   829 	  		{
 
       
   830 			User::Leave(KErrNotFound);
 
       
   831 	  		}
 
       
   832 	  	CleanupStack::PopAndDestroy(); // st
 
       
   833 		}
 
       
   834 	else
 
       
   835 		{
 
       
   836 		User::Leave(KErrCorrupt);
 
       
   837 		}
 
   828 		  
   838 		  
   829 	sqlite3_finalize(st);
 
   839 	_LIT(KSqlStatement2, "select count(*) from shows where feeduid=%u and playstate=0");
 
   830 
   840 	iSqlBuffer.Format(KSqlStatement2, aFeedUid);
 
   831 	_LIT(KSqlStatement2, "select count(*) from shows where downloadstate=%u and playstate=%u");
 
       
   832 	iSqlBuffer.Format(KSqlStatement2, EDownloaded, ENeverPlayed);
 
       
   833 
   841 
   834 	rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   842 	rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   835 		
   843 		
   836 	if( rc==SQLITE_OK ){
 
   844 	if(rc==SQLITE_OK)
 
       
   845 		{
 
       
   846 		Cleanup_sqlite3_finalize_PushL(st);
 
   837 	  	rc = sqlite3_step(st);
 
   847 	  	rc = sqlite3_step(st);
 
   838 	  	
   848 	  	
   839 	  	if (rc == SQLITE_ROW) {
 
   849 	  	if (rc == SQLITE_ROW)
 
       
   850 	  		{
 
   840 	  		aNumUnplayed = sqlite3_column_int(st, 0);
 
   851 	  		aNumUnplayed = sqlite3_column_int(st, 0);
 
   841 	  	}
 
   852 	  		}
 
   842 	}
 
   853 	  	else
 
   843 		  
   854 	  		{
 
   844 	sqlite3_finalize(st);
 
   855 			User::Leave(KErrNotFound);
 
   845 	}
 
   856 	  		}
 
   846 
   857 	  	CleanupStack::PopAndDestroy(); // st
 
   847 EXPORT_C void CFeedEngine::GetStatsByFeed(TUint aFeedUid, TUint &aNumShows, TUint &aNumUnplayed)
 
   858 	}
 
   848 	{
 
   859 }
 
   849 	//DP1("CFeedEngine::GetStatsByFeed, aFeedUid=%u", aFeedUid);
 
   860 
   850 	DBGetStatsByFeed(aFeedUid, aNumShows, aNumUnplayed);
 
   861 TUint CFeedEngine::DBGetFeedCountL()
 
   851 	}
 
   862 	{
 
   852 
   863 	DP("DBGetFeedCount BEGIN");
 
   853 void CFeedEngine::DBGetStatsByFeed(TUint aFeedUid, TUint &aNumShows, TUint &aNumUnplayed)
 
       
   854 	{
 
       
   855 	//DP1("CFeedEngine::DBGetStatsByFeed, feedUid=%u", aFeedUid);
 
       
   856 	_LIT(KSqlStatement, "select count(*) from shows where feeduid=%u");
 
       
   857 	iSqlBuffer.Format(KSqlStatement, aFeedUid);
 
       
   858 
       
   859 	sqlite3_stmt *st;
 
   864 	sqlite3_stmt *st;
 
       
   865 	int rc = sqlite3_prepare_v2(&iDB,"select count(*) from feeds" , -1, &st, (const char**) NULL);
 
       
   866 	TUint size = 0;
 
   860 	 
   867 	 
   861 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   868 	if( rc==SQLITE_OK )
 
   862 	
   869 		{
 
   863 	if( rc==SQLITE_OK ){
 
   870 		Cleanup_sqlite3_finalize_PushL(st);
 
   864 	  	rc = sqlite3_step(st);
 
   871 		rc = sqlite3_step(st);
 
   865 	  	
   872 			
   866 	  	if (rc == SQLITE_ROW) {
 
   873 		if (rc == SQLITE_ROW)
 
   867 	  		aNumShows = sqlite3_column_int(st, 0);
 
   874 			{
 
   868 	  	}
 
       
   869 	}
 
       
   870 		  
       
   871 	sqlite3_finalize(st);
 
       
   872 
       
   873 	_LIT(KSqlStatement2, "select count(*) from shows where feeduid=%u and playstate=0");
 
       
   874 	iSqlBuffer.Format(KSqlStatement2, aFeedUid);
 
       
   875 
       
   876 	rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
       
   877 		
       
   878 	if( rc==SQLITE_OK ){
 
       
   879 	  	rc = sqlite3_step(st);
 
       
   880 	  	
       
   881 	  	if (rc == SQLITE_ROW) {
 
       
   882 	  		aNumUnplayed = sqlite3_column_int(st, 0);
 
       
   883 	  	}
 
       
   884 	}
 
       
   885 		  
       
   886 	sqlite3_finalize(st);
 
       
   887 }
 
       
   888 
       
   889 TUint CFeedEngine::DBGetFeedCount()
 
       
   890 	{
 
       
   891 	 DP("DBGetFeedCount BEGIN");
 
       
   892 	 sqlite3_stmt *st;
 
       
   893 	 int rc = sqlite3_prepare_v2(&iDB,"select count(*) from feeds" , -1, &st, (const char**) NULL);
 
       
   894 	 TUint size = 0;
 
       
   895 	 
       
   896 	 if( rc==SQLITE_OK ){
 
       
   897 	  	rc = sqlite3_step(st);
 
       
   898 	  	
       
   899 	  	if (rc == SQLITE_ROW) {
 
       
   900 	  		size = sqlite3_column_int(st, 0);
 
   875 	  		size = sqlite3_column_int(st, 0);
 
   901 	  	}
 
   876 	  		}
 
   902 	  }
 
   877 		else
 
   903 	  
   878 			{
 
   904 	  sqlite3_finalize(st);
 
   879 	  		User::Leave(KErrCorrupt);
 
   905 	  DP1("DBGetFeedCount END=%d", size);
 
   880 	  		}
 
   906 	  return size;
 
   881 		CleanupStack::PopAndDestroy(); // st
 
       
   882 		}
 
       
   883 	else
 
       
   884 		{
 
       
   885 		User::Leave(KErrCorrupt);
 
       
   886 		}
 
       
   887 
       
   888 	DP1("DBGetFeedCount END=%d", size);
 
       
   889 	return size;
 
   907 }
 
   890 }
 
   908 
   891 
   909 void CFeedEngine::DBLoadFeedsL()
 
   892 void CFeedEngine::DBLoadFeedsL()
 
   910 	{
 
   893 	{
 
   911 	DP("DBLoadFeeds BEGIN");
 
   894 	DP("DBLoadFeeds BEGIN");
 
   918 	sqlite3_stmt *st;
 
   901 	sqlite3_stmt *st;
 
   919 	 
   902 	 
   920 	TLinearOrder<CFeedInfo> sortOrder( CFeedEngine::CompareFeedsByTitle);
 
   903 	TLinearOrder<CFeedInfo> sortOrder( CFeedEngine::CompareFeedsByTitle);
 
   921 
   904 
   922 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   905 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   923 	Cleanup_sqlite3_finalize_PushL(st);
 
   906 	
   924 	
   907 	if (rc==SQLITE_OK)
 
   925 	if (rc==SQLITE_OK) {
 
   908 		{
 
       
   909 		Cleanup_sqlite3_finalize_PushL(st);
 
   926 		rc = sqlite3_step(st);
 
   910 		rc = sqlite3_step(st);
 
   927 		while(rc == SQLITE_ROW) {
 
   911 		while(rc == SQLITE_ROW) 
       
   912 			{
 
   928 			feedInfo = CFeedInfo::NewLC();
 
   913 			feedInfo = CFeedInfo::NewLC();
 
   929 			
   914 			
   930 			const void *urlz = sqlite3_column_text16(st, 0);
 
   915 			const void *urlz = sqlite3_column_text16(st, 0);
 
   931 			TPtrC16 url((const TUint16*)urlz);
 
   916 			TPtrC16 url((const TUint16*)urlz);
 
   932 			feedInfo->SetUrlL(url);
 
   917 			feedInfo->SetUrlL(url);
 
   943 			TPtrC16 image((const TUint16*)imagez);
 
   928 			TPtrC16 image((const TUint16*)imagez);
 
   944 			feedInfo->SetImageUrlL(image);
 
   929 			feedInfo->SetImageUrlL(image);
 
   945 
   930 
   946 			const void *imagefilez = sqlite3_column_text16(st, 4);
 
   931 			const void *imagefilez = sqlite3_column_text16(st, 4);
 
   947 			TPtrC16 imagefile((const TUint16*)imagefilez);
 
   932 			TPtrC16 imagefile((const TUint16*)imagefilez);
 
   948 			feedInfo->SetImageFileNameL(imagefile, &iPodcastModel);
 
   933 			if (imagefile.Length() > 0)
 
   949 						
   934 				{
 
       
   935 				feedInfo->SetImageFileNameL(imagefile, &iPodcastModel);
 
       
   936 				}
 
       
   937 			
   950 			const void *linkz = sqlite3_column_text16(st, 5);
 
   938 			const void *linkz = sqlite3_column_text16(st, 5);
 
   951 			TPtrC16 link((const TUint16*)linkz);
 
   939 			TPtrC16 link((const TUint16*)linkz);
 
   952 			feedInfo->SetDescriptionL(link);
 
   940 			feedInfo->SetDescriptionL(link);
 
   953 					
   941 					
   954 			sqlite3_int64 built = sqlite3_column_int64(st, 6);
 
   942 			sqlite3_int64 built = sqlite3_column_int64(st, 6);
 
   958 			sqlite3_int64 lastupdated = sqlite3_column_int64(st, 7);
 
   946 			sqlite3_int64 lastupdated = sqlite3_column_int64(st, 7);
 
   959 			TTime lastupdatedtime(lastupdated);
 
   947 			TTime lastupdatedtime(lastupdated);
 
   960 			feedInfo->SetLastUpdated(lastupdatedtime);
 
   948 			feedInfo->SetLastUpdated(lastupdatedtime);
 
   961 			
   949 			
   962 			sqlite3_int64 customtitle = sqlite3_column_int64(st, 10);
 
   950 			sqlite3_int64 customtitle = sqlite3_column_int64(st, 10);
 
   963 			if (customtitle) {
 
   951 			if (customtitle)
 
       
   952 				{
 
   964 				feedInfo->SetCustomTitle();
 
   953 				feedInfo->SetCustomTitle();
 
   965 			}
 
   954 				}
 
   966 			
   955 			
   967 			TInt lasterror = sqlite3_column_int(st, 11);
 
   956 			TInt lasterror = sqlite3_column_int(st, 11);
 
   968 			feedInfo->SetLastError(lasterror);
 
   957 			feedInfo->SetLastError(lasterror);
 
   969 			
   958 			
   970 			TLinearOrder<CFeedInfo> sortOrder( CFeedEngine::CompareFeedsByTitle);
 
   959 			TLinearOrder<CFeedInfo> sortOrder( CFeedEngine::CompareFeedsByTitle);
 
   972 			iSortedFeeds.InsertInOrder(feedInfo, sortOrder);
 
   961 			iSortedFeeds.InsertInOrder(feedInfo, sortOrder);
 
   973 			
   962 			
   974 			CleanupStack::Pop(feedInfo);
 
   963 			CleanupStack::Pop(feedInfo);
 
   975 				
   964 				
   976 			rc = sqlite3_step(st);
 
   965 			rc = sqlite3_step(st);
 
   977 		}
 
   966 			}	
   978 	}
 
   967 		CleanupStack::PopAndDestroy();//st
 
   979 
   968 		}
 
   980 	CleanupStack::PopAndDestroy();//st
 
   969 	else
 
       
   970 		{
 
       
   971 		User::Leave(KErrCorrupt);
 
       
   972 		}
 
   981 
   973 
   982 	DP("DBLoadFeeds END");
 
   974 	DP("DBLoadFeeds END");
 
   983 	}
 
   975 	}
 
   984 
   976 
   985 CFeedInfo* CFeedEngine::DBGetFeedInfoByUidL(TUint aFeedUid)
 
   977 CFeedInfo* CFeedEngine::DBGetFeedInfoByUidL(TUint aFeedUid)
 
   988 	CFeedInfo *feedInfo = NULL;
 
   980 	CFeedInfo *feedInfo = NULL;
 
   989 	_LIT(KSqlStatement, "select url, title, description, imageurl, imagefile, link, built, lastupdated, uid, feedtype, customtitle, lasterror from feeds where uid=%u");
 
   981 	_LIT(KSqlStatement, "select url, title, description, imageurl, imagefile, link, built, lastupdated, uid, feedtype, customtitle, lasterror from feeds where uid=%u");
 
   990 	iSqlBuffer.Format(KSqlStatement, aFeedUid);
 
   982 	iSqlBuffer.Format(KSqlStatement, aFeedUid);
 
   991 
   983 
   992 	sqlite3_stmt *st;
 
   984 	sqlite3_stmt *st;
 
   993 	 
   985 	
   994 	//DP1("SQL statement length=%d", iSqlBuffer.Length());
 
       
   995 
       
   996 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   986 	int rc = sqlite3_prepare16_v2(&iDB, (const void*)iSqlBuffer.PtrZ() , -1, &st,	(const void**) NULL);
 
   997 	
   987 	
   998 	if (rc==SQLITE_OK) {
 
   988 	if (rc==SQLITE_OK)
 
       
   989 		{
 
   999 		Cleanup_sqlite3_finalize_PushL(st);
 
   990 		Cleanup_sqlite3_finalize_PushL(st);
 
  1000 		rc = sqlite3_step(st);
 
   991 		rc = sqlite3_step(st);
 
  1001 		if (rc == SQLITE_ROW) {
 
   992 		if (rc == SQLITE_ROW)
 
       
   993 			{
 
  1002 			feedInfo = CFeedInfo::NewLC();
 
   994 			feedInfo = CFeedInfo::NewLC();
 
  1003 			
   995 			
  1004 			const void *urlz = sqlite3_column_text16(st, 0);
 
   996 			const void *urlz = sqlite3_column_text16(st, 0);
 
  1005 			TPtrC16 url((const TUint16*)urlz);
 
   997 			TPtrC16 url((const TUint16*)urlz);
 
  1006 			feedInfo->SetUrlL(url);
 
   998 			feedInfo->SetUrlL(url);
 
  1040 			
  1032 			
  1041 			TInt lasterror = sqlite3_column_int(st, 11);
 
  1033 			TInt lasterror = sqlite3_column_int(st, 11);
 
  1042 			feedInfo->SetLastError(lasterror);
 
  1034 			feedInfo->SetLastError(lasterror);
 
  1043 						
  1035 						
  1044 			CleanupStack::Pop(feedInfo);
 
  1036 			CleanupStack::Pop(feedInfo);
 
  1045 		}
 
  1037 			}
 
       
  1038 		else
 
       
  1039 			{
 
       
  1040 			User::Leave(KErrNotFound);
 
       
  1041 			}
 
  1046 		CleanupStack::PopAndDestroy();//st	
  1042 		CleanupStack::PopAndDestroy();//st	
  1047 	}
 
  1043 		}
 
       
  1044 	else
 
       
  1045 		{
 
       
  1046 		User::Leave(KErrNotFound);
 
       
  1047 		}
 
  1048 	
  1048 	
  1049 	return feedInfo;
 
  1049 	return feedInfo;
 
  1050 }
 
  1050 }
 
  1051 
  1051 
  1052 EXPORT_C void CFeedEngine::UpdateFeedInfoL(CFeedInfo *aItem)
 
  1052 EXPORT_C void CFeedEngine::UpdateFeedInfoL(CFeedInfo *aItem)
FCL/sf/app/podcatcher