diff -r 608f67c22514 -r 896e9dbc5f19 internetradio2.0/irisdsclient/src/irisdsclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/internetradio2.0/irisdsclient/src/irisdsclient.cpp Wed Aug 18 09:40:26 2010 +0300 @@ -0,0 +1,1764 @@ +/* +* Copyright (c) 2009 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: The implementation for presentation elements. +* +*/ + + +#include +#include +#include + +#include "irbrowsecatagoryitems.h" +#include "irbrowsechannelitems.h" +#include "ircachemgmt.h" +#include "irdataprovider.h" +#include "irdataproviderconstants.h" +#include "irdebug.h" +#include "irhttprequestdata.h" +#include "irotaupdate.h" +#include "irsessionlogger.h" +#include "irsettings.h" +#include "irxmlcontenthandler.h" +#include "isdsclientdll.h" +#include "misdsresponseobserver.h" +#include "irisdspreset.h" + +const TInt KChannelidMaxLength = 25; +const TInt KTwo = 2; +/*const TInt KDays = 7; +const TInt KHour = 24; +const TInt KMinute = 60; +const TInt KSecond = 60;*/ +const TInt KUrlPassMaxLength = 124; +const TInt KChidMaxLength = 6; +const TInt KCopyOfTimeMaxLength = 32; +const TInt KMaxLength = 256; +const TInt KFour = 4; + +_LIT(KBrowseUrl,"/do/directory/browse?type="); +_LIT(KChannelnSearchUrl,"/do/directory/browse?type=channels&searchText="); +_LIT(KGetIRIDUrl,"/do/service/getIrid"); +_LIT(KGenres,"genres"); +_LIT(KLanguages,"languages"); +_LIT(KCountries,"countries"); +_LIT(KHotpicks,"hotpicks"); +_LIT(KOtaUpdateUrl,"/do/service/otaUpdate?irid="); +_LIT(KLogUsageUrl,"/do/service/logUsage"); +_LIT(KSearchUrl,"&start=1&size=50"); +_LIT(KMultiSearchUrl, "/do/directory/browse?type=channels&genreID=%S&countryID=%S&languageID=%S&searchText="); + +// --------------------------------------------------------------------------- +// CIRIsdsClient::NewL(MIsdsResponseObserver& aobserver) +// Used by UI to create instance of CIRIsdsClient. +// --------------------------------------------------------------------------- +// +EXPORT_C CIRIsdsClient* CIRIsdsClient::NewL( MIsdsResponseObserver& aobserver, + const TDesC& aISDSBaseUrl ) + { + IRLOG_DEBUG( "CIRIsdsClient::NewL - Entering" ); + CIRIsdsClient* self = CIRIsdsClient::NewLC( aobserver, aISDSBaseUrl ); + + CleanupStack::Pop( self ); + IRLOG_DEBUG( "CIRIsdsClient::NewL - Exiting." ); + return self; + } + +// --------------------------------------------------------------------------- +// CIRIsdsClient::NewLC(MIsdsResponseObserver& aobserver) +// Creates instance of CIRIsdsClient. +// --------------------------------------------------------------------------- +// +CIRIsdsClient* CIRIsdsClient::NewLC( MIsdsResponseObserver& aobserver, + const TDesC& aISDSBaseUrl ) + { + IRLOG_DEBUG( "CIRIsdsClient::NewLC - Entering" ); + CIRIsdsClient* self = new ( ELeave ) CIRIsdsClient( aobserver ); + CleanupStack::PushL( self ); + self->ConstructL( aISDSBaseUrl ); + IRLOG_DEBUG( "CIRIsdsClient::NewLC - Exiting." ); + return self; + } + +// --------------------------------------------------------------------------- +// CIRIsdsClient::ConstructL() +// Symbian two phased constructor +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::ConstructL( const TDesC& aISDSBaseUrl ) + { + //!Construsting the DataproviderDLL instance + IRLOG_DEBUG( "IRIsdsClient::ConstructL - Entering" ); + iSettings = CIRSettings::OpenL(); + iISDSBaseUrl = aISDSBaseUrl.AllocL(); + //Base URL required to browse through the category + iCatgoryURL.Zero(); + iCatgoryURL.Copy( *iISDSBaseUrl ); + iCatgoryURL.Append( KBrowseUrl ); + //Base URL required to search isds + iSearchURL.Zero(); + iSearchURL.Copy( *iISDSBaseUrl ); + iSearchURL.Append( KChannelnSearchUrl ); + //Base URL required to get IRID + iGetIridUrl.Zero(); + iGetIridUrl.Copy( *iISDSBaseUrl ); + iGetIridUrl.Append( KGetIRIDUrl ); + //creates DataProvider + iDataProvider = CIRDataProvider::NewL( *this ); + //creates XML Parser + iXmlReader = CIRXMLContentHandler::NewL( *this, *this ); + //creates Cache manager + iCache = CIRCacheMgmt::OpenL( *this ); + iCache->AddObserverL( this ); + //Session Log + iBrowseReport = CIRReportGenerator::OpenL(); + // Retrive the current language and set it as an Accept Language + TLanguage currentLanguage = User::Language(); + iShortLanguageCode = IRLanguageMapper::MapLanguage( currentLanguage ); + + IRLOG_DEBUG( "IRIsdsClient::ConstructL - Exiting." ); + } + +// --------------------------------------------------------------------------- +// CIRIsdsClient::CIRIsdsClient(MIsdsResponseObserver& aobserver) +// Default constructor +// --------------------------------------------------------------------------- +// +CIRIsdsClient::CIRIsdsClient( MIsdsResponseObserver& aobserver ) + : iIsdsResponseObserver( aobserver ) + { + IRLOG_DEBUG( "CIRIsdsClient::CIRIsdsClient" ); + //No implementation + } + +// --------------------------------------------------------------------------- +// CIRIsdsClient::~CIRIsdsClient() +// Destructor +// --------------------------------------------------------------------------- +// +CIRIsdsClient::~CIRIsdsClient() + { + IRLOG_DEBUG( "CIRIsdsClient::~CIRIsdsClient - Entering" ); + delete iDataProvider; + delete iXmlReader; + if ( iSendPreset ) + { + iSendPreset->ResetAndDestroy(); + } + delete iSendPreset; + + if ( iCache ) + { + iCache->RemoveObserver( this ); + iCache->Close(); + } + + if ( iSettings ) + { + iSettings->Close(); + } + delete iISDSBaseUrl; + if ( iBrowseReport ) + { + iBrowseReport->Close(); + } + if ( iTempRequestObject ) + { + delete iTempRequestObject; + iTempRequestObject = NULL; + } + + IRLOG_DEBUG( "CIRIsdsClient::~CIRIsdsClient - Exiting." ); + } + +// --------------------------------------------------------------------------- +// CIRIsdsClient::IRIsdsIsCategoryCachedL +// Destructor +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CIRIsdsClient::IRIsdsIsCategoryCachedL( + TIRIsdsclientInterfaceIDs aISDSClientRequest) + { + iForceGet=EFalse; + TInt res = 0; + iCacheReqMade = EFalse; + switch( aISDSClientRequest ) + { + //When genre data is requested by user + case EGenre: + { + //set the request type for subsiquent Use + + iCachePath.Zero(); + iCachePath.Copy( KGenres ); + iCache->CheckCacheL( 0, KGenres, iForceGet, res ); + } + + break; + //When Language data is requested by user + case ELanguages: + { + + iCachePath.Zero(); + iCachePath.Copy( KLanguages ); + iCache->CheckCacheL( 0, KLanguages, iForceGet, res ); + + } + break; + //When Country data is requested by user + case ECountries: + { + + iCachePath.Zero(); + iCachePath.Copy( KCountries ); + iCache->CheckCacheL( 0, KCountries, iForceGet, res ); + } + break; + + //When hotpics data is requested by user + case Ehotpicks: + { + //set the request type for subsiquent Use + iCachePath.Zero(); + iCachePath.Copy( KHotpicks ); + iCache->CheckCacheL( 1, KHotpicks, iForceGet, res ); + + } + break; + default: + break; + } + + if ( res == CIRCacheMgmt::ECacheUseable ) + { + return ETrue; + } + + return EFalse; + } +// --------------------------------------------------------------------------- +// void CIRIsdsClientInteface(TIRIsdsclientInterfaceIDs aISDSClientRequest) +// Called by UI to make request to ISDS for catogories +// @param :ENUM value depending on catogory which user wants to explore +// --------------------------------------------------------------------------- +// + +EXPORT_C TBool CIRIsdsClient::IRIsdsClientIntefaceL( + TIRIsdsclientInterfaceIDs aISDSClientRequest ) + { + //cancels any pending request + IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Entering" ); + CIRHttpRequestData * requestData = new ( ELeave ) CIRHttpRequestData; + CleanupStack::PushL( requestData ); + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + //Sets the Htpp method to GET + requestData->iMethod = EIRHttpGET; + //check for valid cache + iForceGet = EFalse; + + TInt res = 0; + + switch ( aISDSClientRequest ) + { + //When genre data is requested by user + case EGenre: + { + //set the request type for subsiquent Use + iRequestType = 0; + iDataFrom = EFalse; + iCachePath.Zero(); + iCachePath.Copy( KGenres ); + iCacheReqMade = ETrue; + iCache->CheckCacheL( 0, KGenres, iForceGet, res ); + if ( res == 0 )//if cache is not available + { + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KGenres ); + iConditonalGet = EFalse; + //issues request for Genre data + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == -1 )//i cache is stale + { + iConditonalGet = ETrue; + requestData->iIfModifiedSince = iLastModifiedTime.DateTime(); + requestData->isIfModifiedSet = ETrue; + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KGenres ); + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == 1 ) + { + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KGenres ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + } + } + break; + //When Language data is requested by user + case ELanguages: + { + //set the request type for subsiquent Use + iRequestType = 0; + iDataFrom = EFalse; + + iCachePath.Zero(); + iCachePath.Copy( KLanguages ); + iCacheReqMade = ETrue; + iCache->CheckCacheL( 0, KLanguages, iForceGet, res ); + + if ( res == 0 )//if cache is not available + { + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KLanguages ); + //Isuues request for language data + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == -1 )//i cache is stale + { + iConditonalGet = ETrue; + requestData->iIfModifiedSince = iLastModifiedTime.DateTime(); + requestData->isIfModifiedSet = ETrue; + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KLanguages ); + //Isuues request for language data if cache isnt valid + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == 1 ) + { + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KLanguages ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + } + } + break; + //When Country data is requested by user + case ECountries: + { + //set the request type for subsiquent Use + iRequestType = 0; + iDataFrom = EFalse; + + iCachePath.Zero(); + iCachePath.Copy( KCountries ); + iCacheReqMade = ETrue; + iCache->CheckCacheL( 0, KCountries, iForceGet, res ); + if ( res == 0 )//if cache is not available + { + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KCountries ); + //Isuues request for country data + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == -1 )//i cache is stale + { + iConditonalGet = ETrue; + requestData->iIfModifiedSince = iLastModifiedTime.DateTime(); + requestData->isIfModifiedSet = ETrue; + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KCountries ); + //Isuues request for country data if cache isnt valid + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == 1 ) + { + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KCountries ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + } + + } + break; + + //When hotpics data is requested by user + case Ehotpicks: + { + //set the request type for subsiquent Use + iRequestType = 1; + iCacheReqMade = ETrue; + iCache->CheckCacheL( 1, KHotpicks, iForceGet, res ); + iCachePath.Zero(); + iCachePath.Copy( KHotpicks ); + iDataFrom = EFalse; + + if ( res == 0 )//if cache is not available + { + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KHotpicks ); + //Isuues request for hotpics data + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == -1 )//i cache is stale + { + iConditonalGet = ETrue; + requestData->iIfModifiedSince = iLastModifiedTime.DateTime(); + requestData->isIfModifiedSet = ETrue; + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KHotpicks ); + //Isuues request for hotpics data if cache isnt valid + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == 1 ) + { + requestData->iUri.Copy( iCatgoryURL ); + requestData->iUri.Append( KHotpicks ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + } + } + break; + + } + CleanupStack::PopAndDestroy( requestData ); + IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Exiting." ); + return iDataFrom; + }//end of function + +// --------------------------------------------------------------------------- +// CIRIsdsClient::GetDataProvider +// +// --------------------------------------------------------------------------- +// +EXPORT_C CIRDataProvider* CIRIsdsClient::GetDataProvider() + { + IRLOG_DEBUG( "CIRIsdsClient::GetDataProvider" ); + return iDataProvider; + } + +// --------------------------------------------------------------------------- +// void IRHttpContentNotChanged() +// this is call back funtion called by Dataprovider in case +// HTTP content isnt changed by ISDS +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::IRHttpResponseCodeReceived( TInt aResponseCode, + CIRHttpResponseData& aResponseHeaders ) + { + IRLOG_INFO2( "CIRIsdsClient::IRHttpResponseCodeReceived (%d)", aResponseCode ); + TInt res = KErrNotFound; + switch ( aResponseCode ) + { + case KNotFound://404 + { + //make channel user defined. + if ( iSyncRequest ) + { + iSyncRequest = EFalse; + //make the preset user-defined + TRAP_IGNORE(iIsdsResponseObserver.IsdsPresetRemovedL( + iPresetToBeSynced)) + } + + /*if(iOtaReqFrom) + { + TRAP_IGNORE(PurgeOtaInfoL()) + }*/ + + } + break; + case KNotModified://304 + { + if ( iConditonalGet ) + { + //update the trust period + //no problem if it leaves + TRAP_IGNORE( iCache->UpdateTrustPeriodL( iRequestType,iCachePath, + aResponseHeaders ) ) + //do a forced get because the data is notmodifed in isds and + //trustable + iForceGet = ETrue; + iCacheReqMade = ETrue; + TRAP_IGNORE( iCache->CheckCacheL( iRequestType,iCachePath, + iForceGet,res ) ) + } + /*if(iOtaReqFrom) + { + TRAP_IGNORE(PurgeOtaInfoL()) + }*/ + } + break; + default: + { + + } + break; + } + IRLOG_DEBUG( "CIRIsdsClient::IRHttpResponseCodeReceived - Exiting." ); + } + +// --------------------------------------------------------------------------- +// void RHttpGeneralError(TInt aErrorCode) +// It is a call back function called by the data provider +// to return error code in case of some error. +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::IRHttpGeneralError( TInt aErrorCode ) + { + IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Entering" ); + IRLOG_ERROR2( "CIRIsdsClient::IRHttpGeneralError (%d)", aErrorCode ); + if ( iSyncRequest ) + { + IRLOG_DEBUG( "CIRISDSCLIENT::IRHTTPGENERALERROR--IF ISYNC" ); + iSyncRequest = EFalse; + if ( aErrorCode == KNotModified || aErrorCode == KServiceUnavailable ) + { + TRAP_IGNORE( iIsdsResponseObserver.IsdsPresetNoChangeL() ) + return; + } + IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (1)." ); + } + + /*if(iOtaReqFrom) + { + //if internal service request + //reset the flag + iOtaReqFrom = EFalse + IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (2)." ) + return + }*/ + if ( iConditonalGet ) + { + IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (3)." ); + iConditonalGet = EFalse; + if ( aErrorCode == KNotModified ) + { + return; + } + } + if ( iPostResponsePending ) + { + IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (4)." ); + IRLOG_DEBUG( "CIRISDSCLIENT::ISDSGENERALERROR--POSTPENDING" ); + iPostResponsePending = EFalse; + //no action required + //session log is backed up before sending; + return; + } + if ( iIRIDPending ) + { + IRRDEBUG2("CIRISDSCLIENT::IRHTTPGENERALERROR--IF IRID",KNullDesC ); + IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (7)." ); + iIRIDPending = EFalse; + //dTRAP_IGNORE( IRGetIRIDL() ) + } + IRLOG_DEBUG("CIRISDSCLIENT::IRHTTPGENERALERROR--BEFORE TRAPD" ); + TRAPD( errd, iIsdsResponseObserver.IsdsErrorL( aErrorCode ) ); + if ( errd ) + { + IRLOG_DEBUG("CIRISDSCLIENT::IRHTTPGENERALERROR--IF ERRD" ); + IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (5)." ); + return; + } + IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (6)." ); + } + +// --------------------------------------------------------------------------- +// void IRHttpDataReceived(TDesC& aXmlPath) +// It is a call back function called by the data provider +// once it recieves the XML data +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::IRHttpDataReceived( const TDesC& aXmlPath, + const CIRHttpResponseData& aResponseHeaders ) + { + IRLOG_DEBUG( "CIRIsdsClient::IRHttpDataReceived - Entering" ); + TBuf xmlPath; + xmlPath.Copy( aXmlPath ); + //!Calls XML parser with file path to XML file recieved + TRAPD( xmlErr,iXmlReader->ParseXmlL( xmlPath, iCachePath, aResponseHeaders ) ) + if ( xmlErr != KErrNone ) + { + IRLOG_DEBUG( "CIRIsdsClient::IRHttpDataReceived - Exiting (1)." ); + return; + } + + if ( iIRIDPending ) + { + iIRIDPending = EFalse; + //if any request is pending by the time IRID response comes + if ( iReqPending ) + { + //issue the pending request + TRAP_IGNORE( IRHttpIssueRequestL( *iTempRequestObject ) ) + } + } + + IRLOG_DEBUG( "CIRIsdsClient::IRHttpDataReceived - Exiting (2)." ); + } + +// --------------------------------------------------------------------------- +// CIRIsdsClient::IRIsdsIsChannelCachedL +// +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CIRIsdsClient::IRIsdsIsChannelCachedL( TUint aSelectedOption ) + { + TInt res = 0; + iCacheReqMade = EFalse; + iForceGet=EFalse; + + //previous data from cache + if (iCatDataFrom) + { + if (aSelectedOption >= iCache->iPtrCategory->Count()) + { + User::Leave(KErrArgument); + } + + if (iCache->iPtrCategory->Count()) + { + iCachePath.Zero(); + iCachePath.Copy( + (*(iCache->iPtrCategory))[aSelectedOption]->iCatId->Des()); + + iCache->CheckCacheL(1, + iCachePath, + iForceGet, res); + } + } + //previous data from xml + else + { + if (aSelectedOption >= iXmlReader->iPtrCategory->Count()) + { + User::Leave( KErrArgument ); + } + + if (iXmlReader->iPtrCategory->Count()) + { + iCachePath.Zero(); + iCachePath.Copy( + (*(iXmlReader-> iPtrCategory))[aSelectedOption]->iCatId->Des()); + iCache->CheckCacheL( + 1, + iCachePath, + iForceGet, res ); + } + } + + if( CIRCacheMgmt::ECacheUseable == res ) + return ETrue; + + return EFalse; + } + +// --------------------------------------------------------------------------- +// void CIRIsdsClientInteface(TUint aSelectedOption,TIRIsdsClientInterfaces aChoice) +// This API is used by the UI to make request for isds listed channels +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CIRIsdsClient::IRIsdsClientIntefaceL( TUint aSelectedOption, + TIRIsdsClientInterfaces aChoice, TInt aHistoryBool ) + { + IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Entering" ); + iForceGet = EFalse; + CIRHttpRequestData * requestData = new ( ELeave ) CIRHttpRequestData; + CleanupStack::PushL( requestData ); + requestData->iMethod = EIRHttpGET; + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + requestData->iUri.Copy( *iISDSBaseUrl ); + + TBool isAdvPresent = EFalse; + + TInt res( 0 ); + if ( aChoice == ECatagory ) + { + //set the request type for subsiquent Use + iRequestType = 1; + //previous data from cache + if ( iCatDataFrom ) + { + TInt categoryCacheIndex; + + if ( ( *( iCache->iPtrCategory ) )[0]->iCatGetOperation ) + { + isAdvPresent = EFalse; + } + else + { + isAdvPresent = ETrue; + } + if ( !isAdvPresent ) + { + categoryCacheIndex = 0; + } + else + { + categoryCacheIndex = 1; + } + + if ( aSelectedOption >= iCache->iPtrCategory->Count() ) + { + User::Leave( KErrArgument ); + } + + if ( iCache->iPtrCategory->Count() ) + { + iCachePath.Zero(); + iCachePath.Copy( + ( *( iCache->iPtrCategory ) )[aSelectedOption]->iCatId->Des() ); + iCacheReqMade = ETrue; + iCache->CheckCacheL( + 1, + ( *( iCache->iPtrCategory ) )[aSelectedOption]-> iCatId->Des(), + iForceGet, res ); + iDataFrom = EFalse; + if ( res == 0 ) + { + requestData->iUri.Append( + ( *( iCache-> iPtrCategory ) )[categoryCacheIndex]->iCatGetOperation->Des() ); + requestData->iUri.Append( + ( *( iCache-> iPtrCategory ) )[aSelectedOption]->iCatId->Des() ); + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == -1 ) + { + iConditonalGet = ETrue; + requestData->iIfModifiedSince + = iLastModifiedTime.DateTime(); + requestData->isIfModifiedSet = ETrue; + requestData->iUri.Append( + ( *( iCache-> iPtrCategory ) )[categoryCacheIndex]->iCatGetOperation->Des() ); //0 + requestData->iUri.Append( + ( *( iCache-> iPtrCategory ) )[aSelectedOption]->iCatId->Des() ); + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + } + } + //previous data from xml + else + { + TInt categoryXmlIndex; + if ( ( *( iXmlReader->iPtrCategory ) )[0]->iCatGetOperation ) + { + isAdvPresent = EFalse; + } + else + { + isAdvPresent = ETrue; + } + if ( !isAdvPresent ) + { + categoryXmlIndex = 0; + } + else + { + categoryXmlIndex = 1; + } + + if ( aSelectedOption >= iXmlReader->iPtrCategory->Count() ) + { + User::Leave( KErrArgument ); + } + + if ( iXmlReader->iPtrCategory->Count() ) + { + iCachePath.Zero(); + iCachePath.Copy( + ( *( iXmlReader-> iPtrCategory ) )[aSelectedOption]->iCatId->Des() ); + iCacheReqMade = ETrue; + iCache->CheckCacheL( + 1, + ( *( iXmlReader-> iPtrCategory ) )[aSelectedOption]->iCatId->Des(), + iForceGet, res ); + iDataFrom = EFalse; + if ( res == 0 ) + { + requestData->iUri.Append( + ( *( iXmlReader-> iPtrCategory ) )[categoryXmlIndex]->iCatGetOperation->Des() ); + requestData->iUri.Append( + ( *( iXmlReader-> iPtrCategory ) )[aSelectedOption]->iCatId->Des() ); + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + if ( res == -1 ) + { + iConditonalGet = ETrue; + requestData->iIfModifiedSince + = iLastModifiedTime.DateTime(); + requestData->isIfModifiedSet = ETrue; + requestData->iUri.Append( + ( *( iXmlReader-> iPtrCategory ) )[categoryXmlIndex]->iCatGetOperation->Des() ); + requestData->iUri.Append( + ( *( iXmlReader-> iPtrCategory ) )[aSelectedOption]->iCatId->Des() ); + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 0 ); + iDataFrom = ETrue; + } + } + } + } + else if ( aChoice == EChannels ) + { + + TBuf channelid; + //set the request type for subsiquent Use + iRequestType = KTwo; + _LIT(KFormat,"%d"); + if ( aHistoryBool ) + { + _LIT(KPresetFetchUrl,"/do/directory/getPreset?channelid="); + requestData->iUri.Append( KPresetFetchUrl ); + TBuf channelid; + _LIT(KFormat,"%d"); + channelid.Format( KFormat, aSelectedOption ); + requestData->iUri.Append( channelid ); + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + //Session Log + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + iDataFrom = ETrue; + CleanupStack::PopAndDestroy( requestData ); + return iDataFrom; + } + + //previous data from cache + if ( iChannelDataFrom ) + { + TInt channelCacheIndex; + if ( ( *( iCache->iPtrChannel ) )[0]->iChannelGetOperation ) + { + isAdvPresent = EFalse; + } + else + { + isAdvPresent = ETrue; + } + if ( !isAdvPresent ) + { + channelCacheIndex = 0; + } + else + { + channelCacheIndex = 1; + } + + if( aSelectedOption >= iCache->iPtrChannel->Count()) + { + User::Leave( KErrArgument ); + } + + if ( iCache->iPtrChannel->Count() ) + { + channelid.Format( + KFormat, + ( *( iCache-> iPtrChannel ) )[aSelectedOption]->iChannelID ); + iCachePath.Zero(); + iCachePath.Copy( channelid ); + iCacheReqMade = ETrue; + iCache->CheckCacheL( KTwo, channelid, iForceGet, res ); + iDataFrom = EFalse; + if ( res == 0 || res == -1 ) + { + requestData->iUri.Append( + ( *( iCache-> iPtrChannel ) )[channelCacheIndex]->iChannelGetOperation->Des() ); + requestData->iUri.Append( channelid ); + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + //Session Log + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + iDataFrom = ETrue; + } + } + } + //previous data from xml + else + { + TInt channelXmlIndex; + if ( 0 == ( *( iXmlReader->iPtrChannel ) ).Count() ) + { + CleanupStack::PopAndDestroy( requestData ); + IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Error!" ); + return iDataFrom; + } + + if ( ( *( iXmlReader->iPtrChannel ) )[0]->iChannelGetOperation ) + { + isAdvPresent = EFalse; + } + else + { + isAdvPresent = ETrue; + } + if ( !isAdvPresent ) + { + channelXmlIndex = 0; + } + else + { + channelXmlIndex = 1; + } + + if( aSelectedOption >= iXmlReader->iPtrChannel->Count()) + { + User::Leave( KErrArgument ); + } + + if ( iXmlReader->iPtrChannel->Count() ) + { + channelid.Format( + KFormat, + ( *( iXmlReader-> iPtrChannel ) )[aSelectedOption]->iChannelID ); + iCachePath.Zero(); + iCachePath.Copy( channelid ); + iCacheReqMade = ETrue; + iCache->CheckCacheL( KTwo, channelid, iForceGet, res ); + iDataFrom = EFalse; + if ( res == 0 || res == -1 ) + { + requestData->iUri.Append( + ( *( iXmlReader-> iPtrChannel ) )[channelXmlIndex]->iChannelGetOperation->Des() ); + requestData->iUri.Append( channelid ); + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + //Session Log + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + iDataFrom = ETrue; + } + } + } + } + else + { + + } + CleanupStack::PopAndDestroy( requestData ); + IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Exiting" ); + return iDataFrom; + } + +// --------------------------------------------------------------------------- +// void CIRGetIRID() +// This API is used by the UI to get IR ID from +// isds if it doesnt have one +// --------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::IRGetIRIDL() + { + IRLOG_DEBUG( "CIRIsdsClient::IRGetIRIDL - Entering" ); + //if irid is not available fetch it + if ( iSettings->GetIRIDL().Length() == 0 ) + { + iReqFromGetIRIDFunc = ETrue; + iIRIDPending = EFalse; + CIRHttpRequestData *requestData = new ( ELeave ) CIRHttpRequestData(); + CleanupStack::PushL( requestData ); + requestData->iMethod = EIRHttpGET; + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + requestData->iUri.Copy( iGetIridUrl ); + IRHttpIssueRequestL( *requestData ); + CleanupStack::PopAndDestroy( requestData ); + iIRIDPending = ETrue; + IRLOG_DEBUG( "CIRIsdsClient::IRGetIRIDL - Exiting (1)." ); + return; + } + IRLOG_DEBUG( "CIRIsdsClient::IRGetIRIDL - Exiting (2)." ); + } + +// --------------------------------------------------------------------------- +// void GetOtaStatus() +// This API is used by the UI to query for ota update +// --------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::GetOtaStatusL(TBool& aDataFrom) + { + IRLOG_DEBUG( "CIRIsdsClient::GetOtaStatusL - Entering" ); + + CIRHttpRequestData *requestData = new ( ELeave ) CIRHttpRequestData(); + + CleanupStack::PushL( requestData ); + + requestData->iMethod = EIRHttpGET; + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + iGetOtaStatus.Zero(); + iGetOtaStatus.Copy( *iISDSBaseUrl ); + iGetOtaStatus.Append( KOtaUpdateUrl ); + iGetOtaStatus.Append( iSettings->GetIRIDL() ); + + //set the request type for subsiquent Use + iRequestType = EOtaInfo; + iDataFrom = EFalse; + iCachePath.Zero(); + iCachePath.Copy( KOtaUpdateUrl ); + TInt res = 0; + //check cache if it is a genral service request + //not initiated by the user. + if ( iOtaReqFrom ) + { + iCacheReqMade = ETrue; + iCache->CheckCacheL( EOtaInfo, KOtaUpdateUrl, iForceGet, res ); + } + if ( res == 1 ) + { + aDataFrom = EFalse; + } + //if cache is not available or stale(dont use the trust period val) + if ( res == 0 || res == -1 ) + { + requestData->iUri.Copy( iGetOtaStatus ); + iConditonalGet = EFalse; + //issues request for ota data + iDataProvider->IRHttpIssueRequestL( *requestData ); + iDataFrom = ETrue; + aDataFrom = ETrue; + } + CleanupStack::PopAndDestroy( requestData ); + + IRLOG_DEBUG( "CIRIsdsClient::GetOtaStatusL - Exiting." ); + } + +// --------------------------------------------------------------------------- +// CIRIsdsClient::IRISDSPostL() +// This API is used to Post Irapp usage report to isds +// --------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::IRISDSPostL(TFileName &/*aFileName*/) + { + IRLOG_DEBUG( "CIRIsdsClient::IRISDSPostL - Entering" ); + IRRDEBUG2("CIRISDSCLIENT::ISDSPOSTL",KNullDesC); + //Cancels any pending requests + IRISDSCancelRequest(); + CIRHttpRequestData * requestData = new ( ELeave ) CIRHttpRequestData; + CleanupStack::PushL( requestData ); + //Sets the Http Method to POST + requestData->iMethod = EIRHttpPOST; + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + requestData->iUri.Copy( *iISDSBaseUrl ); + requestData->iUri.Append( KLogUsageUrl ); + //issues request to post the log usage report to isds + iPostResponsePending = ETrue; + IRHttpIssueRequestL( *requestData ); + CleanupStack::PopAndDestroy( requestData ); + IRLOG_DEBUG( "CIRIsdsClient::IRISDSPostL - Exiting" ); + } + +// --------------------------------------------------------------------------- +// void CIRISDSCancelRequest() +// This API is used by the UI to cancel a request made. +// --------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::IRISDSCancelRequest() + { + IRLOG_DEBUG( "CIRIsdsClient::IRISDSCancelRequest - Entering" ); + iSyncRequest = EFalse; + iReqFromSync = EFalse; + iOtaReqFrom = EFalse; + iConditonalGet = EFalse; + iPostResponsePending = EFalse; + iIRIDPending = EFalse; + iDataProvider->IRHttpCancelRequest(); + IRLOG_DEBUG( "CIRIsdsClient::IRISDSCancelRequest - Exiting" ); + } + +// --------------------------------------------------------------------------- +// void IRISDSMultiSearchL() +// This API is used by the UI to search a channel. +// --------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::IRISDSMultiSearchL(const TDesC& aGenreID, + const TDesC& aCountryID, + const TDesC& aLanguageID, + const TDesC& aSearchText) + { + IRLOG_DEBUG( "CIRIsdsClient::IRISDSMultiSearch - Entering" ); + CIRHttpRequestData * requestData= new(ELeave) CIRHttpRequestData(); + iCachePath.Zero(); + CleanupStack::PushL(requestData); + + requestData->iMethod = EIRHttpGET; + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + + HBufC8* utfEncodedSearchText = CnvUtfConverter::ConvertFromUnicodeToUtf8L( aSearchText ); + CleanupStack::PushL( utfEncodedSearchText ); + + + HBufC8 *encodedQuery = NULL; + encodedQuery = EscapeUtils::EscapeEncodeL(*utfEncodedSearchText, + EscapeUtils::EEscapeQuery); + + HBufC* searchURL = HBufC::NewLC(iISDSBaseUrl->Length() + + KMultiSearchUrl().Length() + + aGenreID.Length() + + aLanguageID.Length() + + aCountryID.Length() + + KSearchUrl().Length() + + utfEncodedSearchText->Size()/2+1 ); + + HBufC* searchPartURL = HBufC::NewLC( KMultiSearchUrl().Length() + + aGenreID.Length() + + aLanguageID.Length() + + aCountryID.Length() ); + + searchPartURL->Des().Format( KMultiSearchUrl, &aGenreID, &aCountryID, + &aLanguageID ); + + HBufC* searchText = HBufC::NewLC( utfEncodedSearchText->Size()/2+1 ); + TPtr searchTextPtr( searchText->Des() ); + searchTextPtr.Copy( *utfEncodedSearchText ); + + TPtr uriPtr( searchURL->Des() ); + uriPtr.Append( *iISDSBaseUrl ); + uriPtr.Append( *searchPartURL ); + uriPtr.Append( searchTextPtr ); + uriPtr.Append( KSearchUrl ); + + if ( encodedQuery ) + { + delete encodedQuery; + } + + requestData->iUri.Copy( searchURL->Left( requestData->iUri.MaxLength() ) ); + IRHttpIssueRequestL( *requestData ); + CleanupStack::PopAndDestroy( searchText ); + CleanupStack::PopAndDestroy( searchPartURL ); + CleanupStack::PopAndDestroy( searchURL ); + CleanupStack::PopAndDestroy( utfEncodedSearchText ); + + + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + EncodeUrlL( iBrowseUrl ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + CleanupStack::PopAndDestroy( requestData ); + + IRLOG_DEBUG( "CIRIsdsClient::IRISDSMultiSearch - Exiting." ); + } + +// --------------------------------------------------------------------------- +// void CIRISDSSearch(TDesC& aSearchString) +// This API is used by the UI to search channels from isds +// --------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::IRISDSSearchL(const TDesC& aSearchString) + { + IRLOG_DEBUG( "CIRIsdsClient::IRISDSSearchL - Entering" ); + CIRHttpRequestData * requestData = new ( ELeave ) CIRHttpRequestData(); + iCachePath.Zero(); + CleanupStack::PushL( requestData ); + //Sets the Http method to GET + requestData->iMethod = EIRHttpGET; + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + + // This is a blatant hack to circumvent the fact that the application has hard-coded + // 256 to be the maximum length of the URI everywhere. Due to time-restraints it is + // not feasible to fix the actual issue here, so every search query that would exceed + // the said limit is truncated to fit it. + // + // The practical impacts of this hack is that should the maximum length be exceeded, + // a connection timed out query is most often displayed. + // + // The scope of this quick hack is to enable users to perform search with UTF-8 characters + // with no possibility of application panics due to descriptor overflows, not to fix + // the actual problem with the hard-coded TBufs in the application. + + HBufC8* utfEncoded = CnvUtfConverter::ConvertFromUnicodeToUtf8L( + aSearchString ); + CleanupStack::PushL( utfEncoded ); + HBufC8* uri = HBufC8::NewL( iSearchURL.Size() + utfEncoded->Size() + + KSearchUrl().Size() ); + TPtr8 uriPtr( uri->Des() ); + uriPtr.Copy( iSearchURL ); + + HBufC8 *encodedQuery = NULL; + encodedQuery = EscapeUtils::EscapeEncodeL( *utfEncoded, + EscapeUtils::EEscapeQuery ); + uriPtr.Append( *encodedQuery ); + uriPtr.Append( KSearchUrl ); + if ( encodedQuery ) + { + delete encodedQuery; + } + CleanupStack::PopAndDestroy( utfEncoded ); + requestData->iUri.Copy( uri->Left( requestData->iUri.MaxLength() ) ); + delete uri; + + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Zero(); + iBrowseUrl.Copy( requestData->iUri ); + EncodeUrlL( iBrowseUrl ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + CleanupStack::PopAndDestroy( requestData ); + IRLOG_DEBUG( "CIRIsdsClient::IRISDSSearchL - Exiting." ); + } + +// --------------------------------------------------------------------------- +//void ParsedStructure(TInt aChoice) +//Call back funtion called by XML parser after parsing is over +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::ParsedStructureL(TInt aChoice) + { + IRLOG_DEBUG( "CIRIsdsClient::ParsedStructureL - Entering" ); + //if catogory info is recieved + if ( aChoice == ECategoryInfoRecieved ) + { + iCatDataFrom = EFalse; + iIsdsResponseObserver.IsdsCatogoryDataReceivedL( + *( iXmlReader-> iPtrCategory ) ); + } + // if channels list is recieved + else if ( aChoice == EChannelListRecieved ) + { + iChannelDataFrom = EFalse; + iIsdsResponseObserver.IsdsChannelDataReceivedL( + *( iXmlReader->iPtrChannel ) ); + } + + //if preset data is recieved + else if ( aChoice == EPresetDataRecieved ) + { + if ( iSyncRequest ) + { + iSyncRequest = EFalse; + //update the preset(replace it) + iIsdsResponseObserver.IsdsPresetChangedL( + *iXmlReader->iPtrPreset->At( 0 ) ); + } + else + { + iIsdsResponseObserver.IsdsPresetDataReceivedL( + *( iXmlReader-> iPtrPreset ) ); + } + } + /*else if(aChoice==EOtaInfoRecieved) + { + if(!iOtaReqFrom) + { + iIsdsResponseObserver.IsdsOtaInfoRecieved(*iXmlReader->iOTA) + } + else + { + iOtaReqFrom=EFalse; + //update settings + if(iXmlReader->iOTA->iUpdateInterval!=0) + { + iSettings->SetSilencePeriodL(iXmlReader->iOTA->iUpdateInterval) + } + else + { + iSettings->SetSilencePeriodL(KDays*KHour*KMinute*KSecond) + } + } + }*/ + else if ( aChoice == EIridRecieved ) + { + iSettings->SetIRIDL( iXmlReader->iRID ); + } + else if ( aChoice == ESessionLogRecieved ) + { + //session log is recieved in ISDS + iPostResponsePending = EFalse; + iBrowseReport->ReponseFromISDSObtained(); + } + + else + { + TRAPD(errd,iIsdsResponseObserver.IsdsErrorL( KDataProviderTimeout) ); + if ( errd ) + { + IRLOG_DEBUG( "CIRIsdsClient::ParsedStructureL - Exiting ." ); + return; + } + } + IRLOG_DEBUG( "CIRIsdsClient::ParsedStructureL - Exiting." ); + } + +// --------------------------------------------------------------------------- +// void ParseError() +// Call back funtion called by XML parser in case of parsing error +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::ParseError( TInt aErrorCode ) + { + IRLOG_ERROR( "CIRIsdsClient::ParseError - Entering" ); + + IRHttpGeneralError( aErrorCode ); + IRLOG_DEBUG( "CIRIsdsClient::ParseError - Exiting." ); + } + +// --------------------------------------------------------------------------- +// void CacheError() +// +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::CacheError() + { + IRLOG_ERROR( "CIRIsdsClient::CacheError" ); + } + +// --------------------------------------------------------------------------- +// void CacheFailed() +// +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::CacheFailed() + { + IRLOG_WARNING( "CIRIsdsClient::CacheFailed" ); + } + +// --------------------------------------------------------------------------- +// cache is present but Stale. +// called by cache mgmt as a callback. +// after copying the lastmodified time into its variable +// here it is copied into the variable ilastModifiedTime +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::CacheInvalid() + { + IRLOG_DEBUG( "CIRIsdsClient::CacheInvalid - Entering" ); + iLastModifiedTime = iCache->iLastModified; + IRLOG_DEBUG( "CIRIsdsClient::CacheInvalid - Exiting" ); + } + +// --------------------------------------------------------------------------- +// void CachedStructureL() +// +// --------------------------------------------------------------------------- +// +void CIRIsdsClient::CachedStructureL( TInt aChoice ) + { + IRLOG_DEBUG( "CIRIsdsClient::CachedStructureL - Entering" ); + if ( iCacheReqMade ) + { + iCacheReqMade = EFalse; + //if catogory info is recieved + if ( aChoice == ECategoryInfoRecieved ) + { + iCatDataFrom = ETrue; + iIsdsResponseObserver.IsdsCatogoryDataReceivedL( + *( iCache->iPtrCategory ) ); + } + + // if channels list is recieved + else if ( aChoice == EChannelListRecieved ) + { + iChannelDataFrom = ETrue; + iIsdsResponseObserver.IsdsChannelDataReceivedL( + *( iCache->iPtrChannel ) ); + } + + //if preset data is recieved + else if ( aChoice == EPresetDataRecieved ) + { + //multiple presets can be presented to the UI. + iIsdsResponseObserver.IsdsPresetDataReceivedL( + *( iCache->iPtrPreset ) ); + } + + //if ota data is recieved + /*else if(aChoice==EOtaInfoRecieved) + { + if(!iOtaReqFrom) + { + iIsdsResponseObserver.IsdsOtaInfoRecieved(*iCache->iOTA) + } + else + { + iOtaReqFrom=EFalse; + //update settings + if(iCache->iOTA->iUpdateInterval!=0) + { + iSettings->SetSilencePeriodL(iCache->iOTA->iUpdateInterval) + } + else + { + iSettings->SetSilencePeriodL(KDays*KHour*KMinute*KSecond) + } + } + }*/ + //if logo data is recieved + else if ( aChoice == KFour ) + { + //No implementation + } + else + { + TRAPD( errd, iIsdsResponseObserver.IsdsErrorL( KDataProviderTimeout ) ); + if ( errd ) + { + IRLOG_DEBUG( "CIRIsdsClient::CachedStructureL- Exiting ." ); + return; + } + } + } + IRLOG_DEBUG( "CIRIsdsClient::CachedStructureL - Exiting." ); + } + +// --------------------------------------------------------------------------- +// void CIRIsdsClient::SyncPresetL() +// Used to syncronize presets +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CIRIsdsClient::SyncPresetL(TInt aPresetId,const TDesC& + aIfModifiedSince ) + { + IRLOG_DEBUG( "CIRIsdsClient::SyncPresetL - Entering" ); + IRRDEBUG2("CIRISDCLIENT::SYNCPRESETL",KNullDesC); + iReqFromSync = ETrue; + iPresetToBeSynced = aPresetId; + CIRHttpRequestData * requestData = new ( ELeave ) CIRHttpRequestData; + CleanupStack::PushL( requestData ); + requestData->iMethod = EIRHttpGET; + + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + TDateTime lastModified; + ConvertToTimeDate( aIfModifiedSince, lastModified ); + requestData->isIfModifiedSet = ETrue; + requestData->iIfModifiedSince.Set( lastModified.Year(), + lastModified.Month(), lastModified.Day(), + lastModified.Hour(), lastModified.Minute(), + lastModified.Second(), lastModified.MicroSecond() ); + _LIT(KPresetFetchUrl,"/do/directory/getPreset?channelid="); + + TBuf urlPass( iSettings->GetISDSBaseUrlL() ); + urlPass.Append( KPresetFetchUrl ); + + TBuf chid; + _LIT(KFormat,"%d"); + chid.Format( KFormat, aPresetId ); + urlPass.Append( chid ); + requestData->iUri.Copy( urlPass ); + + IRHttpIssueRequestL( *requestData ); + CleanupStack::PopAndDestroy( requestData ); + IRLOG_DEBUG( "CIRIsdsClient::SyncPresetL - Exiting." ); + return 1; + } + +// --------------------------------------------------------------------------- +// void ReleaseResources() +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::ReleaseResources() + { + IRLOG_DEBUG( "CIRIsdsClient::ReleaseResources - Entering" ); + iDataProvider->ReleaseResources(); + IRLOG_DEBUG( "CIRIsdsClient::ReleaseResources - Exiting" ); + } + +//--------------------------------------------------------------------------- +//CIRIsdsClient::GetMultiplePresetsL +//for multiple selected presets to be saved +// +//--------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::GetMultiplePresetsL( + const RArray& aIndexArray, TBool& aDataFrom ) + { + IRLOG_DEBUG( "CIRIsdsClient::GetMultiplePresetsL - Entering" ); + _LIT(KSeparator,","); + //get the count of the no of requested presets + TInt multiSelectedCount = aIndexArray.Count(); + //allocate space for the request url + HBufC8* channelIds = HBufC8::NewLC( multiSelectedCount + * KDefaultRealWidth + multiSelectedCount ); + //http request data + CIRHttpRequestData* requestData = new ( ELeave ) CIRHttpRequestData; + requestData->iUri.Copy( *iISDSBaseUrl ); + CleanupStack::PushL( requestData ); + requestData->iAcceptLanguage.Copy( iShortLanguageCode ); + //create a tptr to modify it + TPtr8 channelIdPtr = channelIds->Des(); + //set the request type + iRequestType = EPresets; + //result + TInt res; + _LIT8(KFormat,"%d"); + //if from cache + if ( iChannelDataFrom ) + { + for ( TInt i = 0; i < multiSelectedCount; i++ ) + { + ASSERT( aIndexArray[i] >= 0 && aIndexArray[i] < iCache->iPtrChannel->Count() ); + TInt channelID = iCache->iPtrChannel->At( aIndexArray[i] )->iChannelID; + if ( i != 0 ) + { + channelIdPtr.Append( KSeparator ); + } + TBuf8 channelIdBuf; + channelIdBuf.Format( KFormat, channelID ); + channelIdPtr.Append( channelIdBuf ); + } + iCachePath.Zero(); + iCachePath.Copy( *channelIds ); + //check if cache is available + iCacheReqMade = ETrue; + iCache->CheckCacheL( EPresets, iCachePath, iForceGet, res ); + aDataFrom = EFalse; + if ( res == KErrNone ) + { + requestData->iUri.Append( + ( *( iCache-> iPtrChannel ) )[0]->iChannelGetOperation->Des() ); + requestData->iUri.Append( *channelIds ); + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + //Session Log + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + aDataFrom = ETrue; + } + if ( res == KErrNotFound ) + { + iConditonalGet = ETrue; + requestData->iIfModifiedSince = iLastModifiedTime.DateTime(); + requestData->isIfModifiedSet = ETrue; + requestData->iUri.Append( + ( *( iCache-> iPtrChannel ) )[0]->iChannelGetOperation->Des() ); + requestData->iUri.Append( *channelIds ); + IRHttpIssueRequestL( *requestData ); + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + aDataFrom = ETrue; + } + } + //if from xml file + else + { + for ( TInt i = 0; i < multiSelectedCount; i++ ) + { + ASSERT( aIndexArray[i] >= 0 && aIndexArray[i] < iXmlReader->iPtrChannel->Count() ); + TInt channelID = iXmlReader->iPtrChannel->At( aIndexArray[i] )->iChannelID; + if ( i != 0 ) + { + channelIdPtr.Append( KSeparator ); + } + TBuf8 channelIdBuf; + channelIdBuf.Format( KFormat, channelID ); + channelIdPtr.Append( channelIdBuf ); + } + iCachePath.Zero(); + iCachePath.Copy( *channelIds ); + iCacheReqMade = ETrue; + iCache->CheckCacheL( EPresets, iCachePath, iForceGet, res ); + aDataFrom = EFalse; + if ( res == KErrNone ) + { + requestData->iUri.Append( + ( *( iXmlReader-> iPtrChannel ) )[0]->iChannelGetOperation->Des() ); + requestData->iUri.Append( *channelIds ); + IRHttpIssueRequestL( *requestData ); + iConditonalGet = EFalse; + //Session Log + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + aDataFrom = ETrue; + } + if ( res == KErrNotFound ) + { + iConditonalGet = ETrue; + requestData->iIfModifiedSince = iLastModifiedTime.DateTime(); + requestData->isIfModifiedSet = ETrue; + requestData->iUri.Append( + ( *( iXmlReader-> iPtrChannel ) )[0]->iChannelGetOperation->Des() ); + requestData->iUri.Append( *channelIds ); + IRHttpIssueRequestL( *requestData ); + //Session Log + iBrowseUrl.Copy( requestData->iUri ); + iBrowseReport->BrowseUrl( iBrowseUrl, 1 ); + aDataFrom = ETrue; + } + } + CleanupStack::PopAndDestroy( requestData ); + CleanupStack::PopAndDestroy( channelIds ); + IRLOG_DEBUG( "CIRIsdsClient::GetMultiplePresetsL - Exiting" ); + } + +//--------------------------------------------------------------------------- +//CIRIsdsClient::ConvertToTimeDate +//converts the date-time stamp (last modified) to Symbian DateTime format +//--------------------------------------------------------------------------- +void CIRIsdsClient::ConvertToTimeDate( const TDesC& aTime, + TDateTime& aDateTime ) const + { + IRLOG_DEBUG( "CIRIsdsClient::ConvertToTimeDate - Entering" ); + TBuf8 copyOfTime; + copyOfTime.Copy( aTime ); + TInternetDate time; + TRAPD( error,time.SetDateL( copyOfTime ) ); + if ( !error ) + { + aDateTime = time.DateTime(); + } + + IRLOG_DEBUG( "CIRIsdsClient::ConvertToTimeDate - Exiting." ); + } + +//--------------------------------------------------------------------------- +//CIRIsdsClient::IRHttpIssueRequestL +//Issues Http Request to DataProvider to get data from URL in Request object +//The Request URL is also encoded here +//--------------------------------------------------------------------------- +// +void CIRIsdsClient::IRHttpIssueRequestL( CIRHttpRequestData &aRequestObject ) + { + IRLOG_DEBUG( "CIRIsdsClient::IRHttpIssueRequestL - Entering" ); + IRRDEBUG2("CIRISDSCLIENT::IRHTTPISSUEREQUESTL",KNullDesC); + if ( iIRIDPending ) + { + //if IRID reqeust is pending then queue the reuest + //till IRID response comes + iReqPending = ETrue; + //temporary request object + iTempRequestObject = new ( ELeave ) CIRHttpRequestData; + iTempRequestObject->iMethod = aRequestObject.iMethod; + iTempRequestObject->iIfModifiedSince + = aRequestObject.iIfModifiedSince; + iTempRequestObject->isIfModifiedSet = aRequestObject.isIfModifiedSet; + iTempRequestObject->iAcceptLanguage = aRequestObject.iAcceptLanguage; + iTempRequestObject->iContentType = aRequestObject.iContentType; + iTempRequestObject->iUri = aRequestObject.iUri; + } + else + { + if ( iSettings->GetIRIDL().Length() == 0 ) + { + if ( iReqFromGetIRIDFunc ) + { + iReqFromGetIRIDFunc = EFalse; + iDataProvider->IRHttpIssueRequestL( aRequestObject ); + } + else + { + //When the user cancels the http req,irid is not present. + //On next request,automatically first irid req is made. + //save the actual request + //get irid from isds + //once irid is received send the saved request to isds + iReqPending = ETrue; + //temporary request object + iTempRequestObject = new ( ELeave ) CIRHttpRequestData; + iTempRequestObject->iMethod = aRequestObject.iMethod; + iTempRequestObject->iIfModifiedSince + = aRequestObject.iIfModifiedSince; + iTempRequestObject->isIfModifiedSet + = aRequestObject.isIfModifiedSet; + iTempRequestObject->iAcceptLanguage + = aRequestObject.iAcceptLanguage; + iTempRequestObject->iContentType + = aRequestObject.iContentType; + iTempRequestObject->iUri = aRequestObject.iUri; + IRGetIRIDL(); + } + } + else + { + iReqPending = EFalse; + if ( iReqFromSync ) + { + iReqFromSync = EFalse; + iSyncRequest = ETrue; + } + iDataProvider->IRHttpIssueRequestL( aRequestObject ); + } + } + IRLOG_DEBUG( "CIRIsdsClient::IRHttpIssueRequestL - Exiting." ); + } + +//--------------------------------------------------------------------------- +//CIRIsdsClient::EncodeUrlL +//This url encoding is for session log +//--------------------------------------------------------------------------- +// +void CIRIsdsClient::EncodeUrlL( TDes &aQuery ) + { + IRLOG_DEBUG( "CIRIsdsClient::EncodeUrlL - Entering" ); + //Encodes the URL inside the request object + HBufC *encodedurl = NULL; + encodedurl = EscapeUtils::EscapeEncodeL( aQuery, + EscapeUtils::EEscapeUrlEncoded ); + aQuery.Copy( encodedurl->Left( aQuery.MaxLength() ) ); + //encoded url is released + if ( encodedurl ) + { + delete encodedurl; + } + IRLOG_DEBUG( "CIRIsdsClient::EncodeUrlL - Exiting." ); + } + +//--------------------------------------------------------------------------- +//CIRIsdsClient::PurgeOtaInfoL +//delete all the data cached wrt OTA +//--------------------------------------------------------------------------- +// +EXPORT_C void CIRIsdsClient::PurgeOtaInfoL() + { + IRLOG_DEBUG( "CIRIsdsClient::PurgeOtaInfoL - Entering" ); + //reset update available flag to 0 + iSettings->ReSetUpdateAvailableL(); + //reset silence period to 0 + iSettings->SetSilencePeriodL( 0 ); + //reset silence period start time to a zero string + iSettings->SetSilencePeriodStartL( KNullDesC ); + //clear the cache info if any + TRAP_IGNORE( iCache->RemoveOtaInfoL() ) + IRLOG_DEBUG( "CIRIsdsClient::PurgeOtaInfoL - Exiting" ); + }