--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/internetradio2.0/xmlparsersrc/irxmlcontenthandler.cpp Mon Apr 19 14:01:53 2010 +0300
@@ -0,0 +1,1025 @@
+/*
+* Copyright (c) 2006-2007 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: ?Description
+*
+*/
+
+
+#include <f32file.h>
+#include <parser.h>
+#include <utf.h>
+
+#include "iradvertisement.h"
+#include "irbrowsecatagoryitems.h"
+#include "irbrowsechannelitems.h"
+#include "ircachemgmt.h"
+#include "irdebug.h"
+#include "irisdspreset.h"
+#include "irparserobserver.h"
+#include "irotaupdate.h"
+#include "irxmlcontenthandler.h"
+#include "irxmlelements.h"
+
+const TInt KLargeArraySize = 256;
+const TUint8 KAttributeBufferSize = 100;
+const TUint8 KBitRateCounterValue0 = 0;
+const TUint8 KBitRateCounterValue1 = 1;
+const TUint8 KBitRateCounterValue2 = 2;
+const TUint8 KCategoriesItemSelect = 0;
+const TUint8 KChannelItemSelect = 1;
+const TUint8 KPresetItemSelect = 2;
+const TUint8 KOTAUpdateItemSelect = 3;
+const TUint8 KIRIDSelect = 4;
+const TUint8 KTen = 10;
+
+// ---------------------------------------------------------------------------
+// Gets the Filepath of the XML file
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CIRXMLContentHandler::ParseXmlL(const TDesC& aFilePath,
+ const TDesC& aCachePath,
+ const CIRHttpResponseData& aResponseHeaders)
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::ParseXmlL" );
+ iFileToCache.Zero();
+ iFileToCache.Copy(aCachePath);
+
+ RFs fs;
+ CleanupClosePushL(fs);
+ User::LeaveIfError(fs.Connect());
+ Xml::ParseL(*iParser,fs,aFilePath);
+ CleanupStack::PopAndDestroy(&fs);
+
+
+ //! Error in the Document
+ if(iEOD != KErrNone )
+ {
+ ResetValues();
+ iParseObserver.ParseError( iEOD );
+ }
+ else
+ {
+ if(iCategories)
+ {
+ TRAP_IGNORE(iCache->CacheCategoryItemsL(*iPtrCategory,
+ iFileToCache ,aResponseHeaders))
+ ResetValues();
+ iParseObserver.ParsedStructureL(KCategoriesItemSelect);
+ }
+
+ if(iChan)
+ {
+ if(iFileToCache.Length()!=0)
+ {
+ TRAP_IGNORE(iCache->CacheChannelItemsL(*iPtrChannel,
+ iFileToCache ,aResponseHeaders))
+ }
+ ResetValues();
+ iParseObserver.ParsedStructureL(KChannelItemSelect);
+ }
+
+ if(iPresets)
+ {
+ if( 0 < iPtrPreset->Count() )
+ {
+ TRAP_IGNORE(iCache->CachePresetItemL(*iPtrPreset,
+ iFileToCache,aResponseHeaders))
+ ResetValues();
+ iParseObserver.ParsedStructureL(KPresetItemSelect);
+ }
+ }
+ if(iOTAUpdate)
+ {
+ TRAP_IGNORE(iCache->CacheOtaInfoL(*iOTA,
+ iFileToCache,aResponseHeaders))
+ ResetValues();
+ iParseObserver.ParsedStructureL(KOTAUpdateItemSelect);
+ }
+ if(iIRID)
+ {
+ ResetValues();
+ iParseObserver.ParsedStructureL(KIRIDSelect);
+ }
+ if( iTimeStamp )
+ {
+ //session log response is obtained
+ ResetValues();
+ iParseObserver.ParsedStructureL(KSessionLogResponse);
+ }
+ }
+ IRLOG_DEBUG( "CIRXMLContentHandler::ParseXmlL - Exiting." );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler ::NewL
+// Constructor
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CIRXMLContentHandler* CIRXMLContentHandler ::NewL(MIRParserObserver
+ &aObserver,MIRCacheObserver &aCacheObserver)
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::NewL" );
+ CIRXMLContentHandler* self = new (ELeave) CIRXMLContentHandler(aObserver,
+ aCacheObserver);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ IRLOG_DEBUG( "CIRXMLContentHandler::NewL - Exiting." );
+ return(self);
+ }
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler ::CIRXMLContentHandler
+// Default Constructor
+// ---------------------------------------------------------------------------
+//
+CIRXMLContentHandler ::CIRXMLContentHandler(MIRParserObserver &aObserver,
+ MIRCacheObserver &aCacheObserver):iParseObserver(aObserver),
+ iCacheObserver(aCacheObserver)
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::CIRXMLContentHandler" );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler ::ConstructL
+// Two-Phase Constructor
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler ::ConstructL()
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::ConstructL" );
+ ResetValues();
+ TIRXMLElementFormat::OpenStringPoolL(iStringPool);
+
+ iPtrCategory = new (ELeave) CArrayPtrFlat<CIRBrowseCatagoryItems>(
+ KLargeArraySize);
+ iPtrChannel = new (ELeave) CArrayPtrFlat<CIRBrowseChannelItems>(
+ KLargeArraySize);
+ iPtrPreset = new (ELeave) CArrayPtrFlat<CIRIsdsPreset>(KLargeArraySize);
+
+ iParser = CParser::NewL(KFile,*this);
+ iCache = CIRCacheMgmt::OpenL(iCacheObserver);
+
+ iBufGetOperation = HBufC::NewL(0);
+ iSize = HBufC::NewL(0);
+ IRLOG_DEBUG( "CIRXMLContentHandler::ConstructL - Exiting." );
+ }
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler::~CIRXMLContentHandler()
+// Destructing the object
+// ---------------------------------------------------------------------------
+//
+CIRXMLContentHandler::~CIRXMLContentHandler()
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::~CIRXMLContentHandler." );
+ TRAP_IGNORE(TIRXMLElementFormat::CloseStringPoolL(iStringPool))
+ delete iParser;
+ if(iUrlContentForAds)
+ {
+ delete iUrlContentForAds;
+ iUrlContentForAds = NULL;
+ }
+ if(iPtrPreset)
+ {
+ iPtrPreset->ResetAndDestroy();
+ }
+ delete iPtrPreset;
+ if(iPtrCategory)
+ {
+ iPtrCategory->ResetAndDestroy();
+ }
+ delete iPtrCategory;
+ if(iPtrChannel)
+ {
+ iPtrChannel->ResetAndDestroy();
+ }
+ delete iPtrChannel;
+
+ delete iOTA;
+ delete iAdv;
+
+ if (iCache)
+ {
+ iCache->Close();
+ }
+
+ delete iPreset;
+ delete iCategory;
+ delete iChannel;
+ delete iBufGetOperation;
+ delete iSize;
+
+ IRLOG_DEBUG( "CIRXMLContentHandler::~CIRXMLContentHandler - Exiting." );
+ }
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler::ResetValues
+// Reseting the Values
+// ---------------------------------------------------------------------------
+//
+
+void CIRXMLContentHandler::ResetValues()
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::ResetValues" );
+ iFlag = 1;
+ iPresets = EFalse;
+ iCategories=EFalse;
+ iCat=EFalse;
+ iChannels=EFalse;
+ iChan=EFalse;
+ iAdvertisement=EFalse;
+ iOTAUpdate=EFalse;
+ iIRID = EFalse;
+ iTimeStamp = EFalse;
+ iChannel = NULL;
+ iCategory = NULL;
+ iAdvts = EFalse;
+ iAdvertisementTagFlag = EFalse;
+ IRLOG_DEBUG( "CIRXMLContentHandler::ResetValues - Exiting." );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler:: OnStartDocumentL
+// This method is a callback to indicate the start of the document
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler:: OnStartDocumentL(const Xml::RDocumentParameters&
+ /*aDocParam*/ , TInt /*aErrorCode*/ )
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnStartDocumentL" );
+ iEOD = KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler::OnEndDocumentL
+// This method is a callback to indicate the end of the document
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler::OnEndDocumentL(TInt /*aErrorCode*/)
+ {
+ //No Implementation
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnEndDocumentL" );
+ return;
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler::OnStartElementL
+// This method is a callback to indicate an element has been parsed.
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler::OnStartElementL(const Xml::RTagInfo &aElement,
+ const Xml::RAttributeArray &aAttributes, TInt /*aErrorCode*/)
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnStartElementL" );
+ //Compare the element name to identify the type - //TO DO String Pool
+ TInt genre = (aElement.LocalName().DesC()).Compare(KGenre);
+ TInt lang = (aElement.LocalName().DesC()).Compare(KLanguage);
+ TInt country = (aElement.LocalName().DesC()).Compare(KCountry);
+ TInt channel = (aElement.LocalName().DesC()).Compare(KChannel);
+ TInt preset = (aElement.LocalName().DesC()).Compare(KPreset);
+ TInt advertisements = (aElement.LocalName().DesC()).Compare(KAdvertisements);
+ TInt ad = (aElement.LocalName().DesC()).Compare(KAd);
+
+ TInt genres = (aElement.LocalName().DesC()).Compare(KCatGenre);
+ TInt countries = (aElement.LocalName().DesC()).Compare(KCatCountry);
+ TInt languages = (aElement.LocalName().DesC()).Compare(KCatLang);
+ TInt channels = (aElement.LocalName().DesC()).Compare(KChannels);
+ TInt presets = (aElement.LocalName().DesC()).Compare(KPresets);
+
+ TInt IRID = (aElement.LocalName().DesC()).Compare(KIRID);
+ TInt timestamp = (aElement.LocalName().DesC()).Compare(KTimeStamp);
+ TInt irappversion = (aElement.LocalName().DesC()).Compare(KIRVersion);
+ TInt adv = (aElement.LocalName().DesC()).Compare(KAdv);
+ TInt banner = (aElement.LocalName().DesC()).Compare(KBanner);
+
+
+ if(iUrlContentForAds)
+ {
+ delete(iUrlContentForAds);
+ iUrlContentForAds = NULL;
+ }
+
+ TInt bufSize(KTen);
+ iUrlContentForAds = HBufC::NewL( bufSize );//this is because, the OnContentL method gives chunck by chunck
+
+ if(ad == 0)
+ {
+ //We want to take the first Ad only so if an Ad has already been created
+ //iChannel and iCategory will not be NULL hence the new Ad should not be added
+ if( !iChannel && !iCategory )
+ {
+ iChannel = CIRBrowseChannelItems::NewL();
+ iCategory = CIRBrowseCatagoryItems::NewL();
+
+ }
+ }
+ if(advertisements == 0 )
+ {
+ iAdvertisementTagFlag = ETrue;
+ }
+ if(iAdvertisementTagFlag && banner == 0)
+ {
+ iAdvts = ETrue;
+ }
+ // Creates the instance of the class Browse by Genre/Language/Country
+ if(iFlag)
+ {
+ if(genre == 0 || lang == 0 || country == 0)
+ {
+ //If there are ads then destroy the list and put the ads
+ //as ads will the first in the xml
+ if((iAdvts) && (iCategory))
+ {
+ iPtrCategory->ResetAndDestroy();
+ iPtrCategory->AppendL(iCategory);
+ iCategory = NULL;
+ delete iChannel;
+ iChannel = NULL;
+ iAdvts = EFalse;
+ }
+ iCategory = CIRBrowseCatagoryItems::NewL();
+ iCat = ETrue;
+ }
+ }
+ if(iFlag)
+ {
+ // In case of browse by genres, country and lanaguages
+ if(genres == 0 || countries == 0 || languages == 0)
+ {
+ if(iAdvts == EFalse)
+ {
+ iPtrCategory->ResetAndDestroy();
+ }
+ if(genres == 0)
+ {
+ iFileToCache.Zero();
+ iFileToCache.Copy(KCatGenre);
+ }
+ if(countries == 0)
+ {
+ iFileToCache.Zero();
+ iFileToCache.Copy(KCatCountry);
+ }
+ if(languages == 0)
+ {
+ iFileToCache.Zero();
+ iFileToCache.Copy(KCatLang);
+ }
+
+ iCategories = ETrue;
+ }
+ }
+ // Creates the instance of the class Channel
+ if(channel == 0)
+ {
+ //If there are ads then destroy the list and put the ads
+ //as ads will the first in the xml
+ if((iAdvts) && (iChannel))
+ { iPtrChannel->AppendL(iChannel);
+ iChannel = NULL;
+ delete iCategory;
+ iCategory = NULL;
+ iAdvts = EFalse;
+ }
+ iChannel = CIRBrowseChannelItems::NewL();
+ iChannels = ETrue;
+ iBitrateCounter = 0;
+ }
+ if(channels == 0 )
+ {
+ iPtrChannel->ResetAndDestroy();
+ iChan = ETrue;
+ iChannelFlag = 0;
+ }
+ // Creates the instance of the class for Preset Data
+ if(preset == 0)
+ {
+ iPreset = CIRIsdsPreset::NewL();
+ iPresets = ETrue;
+ }
+ if(presets == 0)
+ {
+ iPtrPreset->ResetAndDestroy();
+ iFlag = 0;
+ }
+ if(IRID == 0)
+ {
+ iIRID = ETrue;
+ }
+ if(timestamp == 0)
+ {
+ //time stamp is obtained when session log is obtained in isds
+ iTimeStamp = ETrue;
+ }
+ if(irappversion == 0)
+ {
+ iOTA = CIROTAUpdate::NewL();
+ iOTAUpdate = ETrue;
+ }
+ if(adv == 0)
+ {
+ iAdv = CIRAdvertisement::NewL();
+ iAdvertisement = ETrue;
+ }
+ TBuf<KAttributeBufferSize> BufParam1;
+ TBuf<KAttributeBufferSize> BufParam2;
+
+ // Parses the attributes and the value of the element
+ TInt nAttributes = aAttributes.Count();
+ for (TInt indexofattribute = 0; indexofattribute < nAttributes;
+ ++indexofattribute )
+ {
+ const RAttribute& attribute = aAttributes[indexofattribute];
+ const RTagInfo& nameInfo = attribute.Attribute();
+
+ //!Gets the elementId from the Pool for the specified attributename
+ TIRXMLElement ATTelementId = TIRXMLElementFormat::GetElementIdL(
+ (nameInfo.LocalName().DesC()),iStringPool);
+
+ HBufC* converted = CnvUtfConverter::ConvertToUnicodeFromUtf8L( attribute.Value().DesC() );
+ CleanupStack::PushL(converted);
+
+ switch(ATTelementId)
+ {
+ case EGetOperation:
+ {
+ delete iBufGetOperation;
+ iBufGetOperation = NULL;
+ iBufGetOperation = converted->Des().AllocL();
+ }
+ break;
+
+ case EName:
+ {
+ //if name is parsed
+ if(iCat)
+ {
+ //if category
+ iCategory->SetGetOperation(*iBufGetOperation);
+ BufParam1.Copy(*converted);
+ }
+ if(iChannels)
+ {
+ //if channel
+ iChannel->SetGetOperationL(*iBufGetOperation);
+ iChannel->SetSize(*iSize);
+ BufParam1.Copy(*converted);
+ }
+ if(iPresets)
+ {
+ if((aElement.LocalName().DesC()) == KPreset)
+ {
+ //for preset
+ iPreset->SetName(*converted);
+ }
+ BufParam1.Copy(*converted);
+ }
+ }
+ break;
+
+ case EID:
+ {
+ //getting id
+ if(iCat)
+ {
+ //for category
+ iCategory->SetTextL(BufParam1,*converted);
+ }
+
+ if(iChannels)
+ {
+ //for channel
+ BufParam2.Copy(*converted);
+ }
+ if(iPresets)
+ {
+ //for preset
+ iPreset->SetGenreInfo(*converted,BufParam1);
+ }
+ if(iIRID)
+ {
+ //ir id
+ iRID.Copy(*converted);
+ }
+ }
+ break;
+
+ case ESize:
+ {
+ delete iSize;
+ iSize = NULL;
+ iSize = converted->Des().AllocL();
+ if(iCat)
+ {
+ iCategory->SetSize(*iSize);
+ }
+ }
+ break;
+
+ case EShortDesC:
+ {
+ //getting short description
+ if(iChannels)
+ {
+ iChannel->SetTextL(BufParam1,BufParam2,*converted);
+ }
+ if(iPresets)
+ {
+ iPreset->SetShortDesc(*converted);
+ }
+ }
+ break;
+
+ case EBitrateValue:
+ {
+ //parsing bit rate
+ if(iChannels)
+ {
+ if(iBitrateCounter == KBitRateCounterValue0)
+ {
+ iChannel->SetBitrate(*converted);
+ BufParam1.Copy(*converted);
+ }
+
+ if(iBitrateCounter == KBitRateCounterValue1)
+ {
+ iChannel->SetBitrate(BufParam1,*converted);
+ BufParam2.Copy(*converted);
+ }
+
+ if(iBitrateCounter == KBitRateCounterValue2)
+ {
+ iChannel->SetBitrate(BufParam1,BufParam2,*converted);
+ }
+
+ iBitrateCounter++;
+ }
+ }
+ break;
+
+ case ESdsID:
+ {
+ if(iPresets)
+ {
+ iPreset->SetId(*converted);
+ }
+ }
+ break;
+
+ case ELangCode:
+ {
+ //language code
+ if(iPresets)
+ {
+ iPreset->SetLangCode(*converted);
+ }
+ }
+ break;
+
+ case ELang:
+ {
+ //language
+ if(iPresets)
+ {
+ iPreset->SetLang(*converted);
+ }
+ }
+ break;
+
+ case ECountryCode:
+ {
+ //country code
+ if(iPresets)
+ {
+ iPreset->SetCountryCode(*converted);
+ }
+ }
+ break;
+
+ case ECountry:
+ {
+ //country
+ if(iPresets)
+ {
+ iPreset->SetCountryName(*converted);
+ }
+ }
+ break;
+
+ case ELastUpdated:
+ {
+ //last modified time
+ if(iPresets)
+ {
+ iPreset->SetLastModifiedTime(*converted);
+ }
+ }
+ break;
+
+ case EDesc:
+ {
+ //description
+ if(iPresets)
+ {
+ iPreset->SetDescription(*converted);
+ }
+ }
+ break;
+
+ case EImgURL:
+ {
+ //image url
+ if(iChannels)
+ {
+ iChannel->SetImageUrl(*converted);
+ }
+ if(iPresets)
+ {
+ iPreset->SetImgUrl(*converted);
+ }
+ }
+ break;
+
+ case EAdvImgURL:
+ {
+ //advertisement url
+ if(iPresets)
+ {
+ iPreset->SetAdvertisementUrl(*converted);
+ }
+ }
+ break;
+
+ case EAdvInUse:
+ {
+ //advertisement in use
+ if(iPresets)
+ {
+ iPreset->SetAdvertisementInUse(*converted);
+ }
+ }
+ break;
+
+ case EGenreID:
+ {
+ //genre id
+ if(iPresets)
+ {
+ iPreset->SetGenreInfo(BufParam1,*converted);
+ }
+ }
+ break;
+
+ case EURL:
+ {
+ //url
+ if(iPresets)
+ {
+ BufParam2.Copy(*converted);
+ }
+ if(iAdvertisement)
+ {
+ iAdv->SetURL(*converted);
+ }
+ }
+ break;
+
+ case EMusicStoreEnabled:
+ {
+ if(iPresets)
+ {
+ iPreset->SetMusicStoreStatus(*converted);
+ }
+ }
+ break;
+
+ case EBitrate:
+ {
+ //set url
+ if(iPresets)
+ {
+ iPreset->SetUrlL(BufParam1,BufParam2,*converted);
+ }
+ }
+ break;
+
+ case EIRID:
+ {
+ //irid
+ }
+ break;
+
+ case EVersion:
+ {
+ //for ota update
+ if(iOTAUpdate)
+ {
+ iOTA->SetVersion(*converted);
+ }
+ }
+ break;
+
+ case EUpdateInterval:
+ {
+ //update interval
+ if(iOTAUpdate)
+ {
+ iOTA->SetUpdateInterval(*converted);
+ }
+ }
+ break;
+
+ case EUpdateMethod:
+ {
+ //update method
+ if(iOTAUpdate)
+ {
+ iOTA->SetUpdateMethod(*converted);
+ }
+ }
+ break;
+
+ case EInUse:
+ {
+ //advertisement in use
+ if(iAdvertisement)
+ {
+ iAdv->SetAdvInUse(*converted);
+ }
+ }
+ break;
+
+ case EUsageVisibleTimes:
+ {
+ if(iAdvertisement)
+ {
+ iAdv->SetUsage(*converted);
+ }
+ }
+ break;
+
+ case EVisibleTime:
+ {
+ //advertisement visible time
+ if(iAdvertisement)
+ {
+ iAdv->SetVisibleTime(*converted);
+ }
+ }
+ break;
+
+ case EElementIDUnknown:
+ {
+ //unknown
+ }
+ break;
+
+ default:
+ {
+ break;
+ }
+ }//End of Switch
+ CleanupStack::PopAndDestroy(converted);
+ } //End of for
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnStartElementL - Exiting." );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler::OnEndElementL
+// This method is a callback to indicate the end of the element has been reached.
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler::OnEndElementL(const RTagInfo &aElement, TInt /*aErrorCode*/)
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnEndElementL" );
+ if((aElement.LocalName().DesC()) == KPreset)
+ {
+ if ( iPreset->GetUrlCount() > 0 )
+ {
+ // The ownership is transferred to the array.
+ iPtrPreset->AppendL(iPreset);
+ }
+ else
+ {
+ // If there is not a single URL, we don't let it in.
+ iEOD = KErrCorrupt;
+ delete iPreset;
+ }
+ // Ownership transferred. Remove the pointer.
+ iPreset = NULL;
+ }
+ if((aElement.LocalName().DesC()) == KBanner)
+ {
+ //get the content for the tag "banner"
+ //assign it to "iBanner" of CIRBrowseChannelItems
+ if(iUrlContentForAds)
+ {
+ iChannel->SetBannerUrl(*iUrlContentForAds);
+ iCategory->SetBannerUrl(*iUrlContentForAds);
+ }
+ }
+ if((aElement.LocalName().DesC()) == KClickthroughUrl)
+ {
+ //get the content for the tag "clickthrough-url"
+ //assign it to "iClickThroughUrl" of CIRBrowseChannelItems
+ if(iUrlContentForAds)
+ {
+ iChannel->SetClickThroughUrl(*iUrlContentForAds);
+ iCategory->SetClickThroughUrl(*iUrlContentForAds);
+ }
+ }
+
+ if(iUrlContentForAds)
+ {
+ delete iUrlContentForAds;
+ iUrlContentForAds = NULL;
+
+ }
+ if(iFlag)
+ {
+ if((aElement.LocalName().DesC()) == KGenre ||
+ (aElement.LocalName().DesC()) == KLanguage ||
+ (aElement.LocalName().DesC()) == KCountry)
+ {
+ iPtrCategory->AppendL(iCategory);
+ iCategory = NULL;
+ iCat = EFalse;
+ }
+ }
+
+ if((aElement.LocalName().DesC()) == KChannel)
+ {
+ iPtrChannel->AppendL(iChannel);
+ iChannel = NULL;
+ iChannels = EFalse;
+ }
+ //appends the created channel(ad) to the array
+ /*
+ if((aElement.LocalName().DesC()) == KAd)
+ {
+ iPtrChannel->AppendL(iChannel);
+ iChannel = NULL;
+
+ } */
+
+ if((aElement.LocalName().DesC()) == KServers)
+ {
+ if (iPreset)
+ {
+ iPreset->SetUrlCount();
+ }
+ }
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnEndElementL - Exiting." );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler ::OnContentL
+// This method is a callback that sends the content of the element.The data
+// may be sent in chunks
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler ::OnContentL(const TDesC8 &aBytes, TInt
+ aErrorCode)
+ {
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnContentL" );
+
+ if ( KErrNone == aErrorCode )
+ {
+
+
+ HBufC* buffertmp = HBufC::NewLC( aBytes.Length() + 1 );
+ TPtr buffertmpPtr( buffertmp->Des() );
+ buffertmpPtr.Copy( aBytes );
+
+
+ TInt tempSize;
+ if(iUrlContentForAds)
+ {
+ tempSize = iUrlContentForAds->Length() + aBytes.Length();
+ iUrlContentForAds = iUrlContentForAds->ReAllocL( tempSize );
+ TPtr bufferPtr( iUrlContentForAds->Des() );
+ bufferPtr.Append(buffertmpPtr);
+ }
+
+ CleanupStack::PopAndDestroy(buffertmp); // buffertmp
+ }
+
+ if ( iOTAUpdate )
+ {
+ HBufC* converted = CnvUtfConverter::ConvertToUnicodeFromUtf8L( aBytes );
+ CleanupStack::PushL( converted );
+ converted->Des().TrimAll();
+ if ( converted->Des().Length() )
+ {
+ iOTA->SetOTAUrl( *converted );
+ }
+ CleanupStack::PopAndDestroy( converted );
+ }
+
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnContentL - Exiting." );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler::OnStartPrefixMappingL
+// This method is a notification of the beginning of the scope of a
+// prefix-URI Namespace mapping.
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler::OnStartPrefixMappingL(const RString& /*aPrefix*/,
+ const RString& /*aUri*/, TInt /*aErrorCode*/)
+ {
+ //No Implementaion
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnStartPrefixMappingL" );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler :: OnEndPrefixMappingL
+// This method is a notification of the end of the scope of a prefix-URI mapping
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler :: OnEndPrefixMappingL(const RString& /*aPrefix*/,
+ TInt /*aErrorCode*/)
+ {
+ //No Implementaion
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnEndPrefixMappingL" );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler :: OnIgnorableWhiteSpaceL
+// This method is a notification of ignorable whitespace in element content.
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler :: OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/,
+ TInt /*aErrorCode*/)
+ {
+ //No Implementaion
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnIgnorableWhiteSpaceL" );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler :: OnSkippedEntityL
+// This method is a notification of a skipped entity
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler :: OnSkippedEntityL(const RString& /*aName*/,
+ TInt /*aErrorCode*/)
+ {
+ //No Implementaion
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnSkippedEntityL" );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler :: OnProcessingInstructionL
+// This method is a receive notification of a processing instruction.
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler :: OnProcessingInstructionL(const TDesC8&
+ /*aTarget*/, const TDesC8& /*aData*/, TInt /*aErrorCode*/)
+ {
+ //No Implementaion
+ IRLOG_DEBUG( "CIRXMLContentHandler::OnProcessingInstructionL" );
+ }
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler :: OnError
+// This method indicates an error has occurred.
+// ---------------------------------------------------------------------------
+//
+void CIRXMLContentHandler :: OnError(TInt aErrorCode )
+ {
+ iEOD = aErrorCode;
+ IRLOG_ERROR2( "CIRXMLContentHandler::OnError (%d)", aErrorCode );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CIRXMLContentHandler :: GetExtendedInterface
+// This method obtains the interface matching the specified uid.
+// ---------------------------------------------------------------------------
+//
+TAny* CIRXMLContentHandler :: GetExtendedInterface(const TInt32 /*aUid*/)
+ {
+ //No Implementation
+ IRLOG_DEBUG( "CIRXMLContentHandler::GetExtendedInterface" );
+ return NULL;
+ }
+
+
+
+GLDEF_C TInt E32Dll()
+// DLL entry point
+ {
+ return(KErrNone);
+ }
+
+