1 /*

     2 * Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  ?Description

    15 *

    16 */

    17 

    18 

    19 #include <escapeutils.h>

    20 #include <tinternetdate.h>

    21 #include <utf.h>

    22 

    23 #include "irbrowsecatagoryitems.h"

    24 #include "irbrowsechannelitems.h"

    25 #include "ircachemgmt.h"

    26 #include "irdataprovider.h"

    27 #include "irdataproviderconstants.h"

    28 #include "irdebug.h"

    29 #include "irhttprequestdata.h"

    30 #include "irotaupdate.h"

    31 #include "irsessionlogger.h"

    32 #include "irsettings.h"

    33 #include "irxmlcontenthandler.h"

    34 #include "isdsclientdll.h"

    35 #include "misdsresponseobserver.h"

    36 

    37 #include "irisdspreset.h"

    38 

    39 const TInt KChannelidMaxLength = 25;

    40 const TInt KTwo = 2;

    41 /*const TInt KDays = 7;

    42 const TInt KHour = 24;

    43 const TInt KMinute = 60;

    44 const TInt KSecond = 60;*/

    45 const TInt KUrlPassMaxLength = 124;

    46 const TInt KChidMaxLength = 6;

    47 const TInt KCopyOfTimeMaxLength = 32;

    48 const TInt KMaxLength = 256;

    49 const TInt KFour = 4;

    50 

    51 _LIT(KBrowseUrl,"/do/directory/browse?type=");

    52 _LIT(KChannelnSearchUrl,"/do/directory/browse?type=channels&searchText=");

    53 

    54 _LIT(KGetIRIDUrl,"/do/service/getIrid");

    55 _LIT(KGenres,"genres");

    56 _LIT(KLanguages,"languages");

    57 _LIT(KCountries,"countries");

    58 _LIT(KHotpicks,"hotpicks");

    59 _LIT(KOtaUpdateUrl,"/do/service/otaUpdate?irid=");

    60 _LIT(KLogUsageUrl,"/do/service/logUsage");

    61 _LIT(KSearchUrl,"&start=1&size=50");

    62 _LIT(KMultiSearchUrl, "/do/directory/browse?type=channels&genreID=%S&countryID=%S&languageID=%S&searchText=");

    63 

    64 

    65 // ---------------------------------------------------------------------------

    66 // CIRIsdsClient::NewL(MIsdsResponseObserver& aobserver)

    67 // Used by UI to create instance of CIRIsdsClient.

    68 // ---------------------------------------------------------------------------

    69 //

    70 EXPORT_C CIRIsdsClient* CIRIsdsClient::NewL(MIsdsResponseObserver& aobserver,

    71 	const TDesC& aISDSBaseUrl)

    72     {

    73 	IRLOG_DEBUG( "CIRIsdsClient::NewL - Entering" );

    74 	CIRIsdsClient* self = CIRIsdsClient::NewLC(aobserver,aISDSBaseUrl);

    75 	

    76 	CleanupStack::Pop( self );

    77 	IRLOG_DEBUG( "CIRIsdsClient::NewL - Exiting." );

    78 	return self;

    79     }

    80 

    81 

    82 // ---------------------------------------------------------------------------

    83 // CIRIsdsClient::NewLC(MIsdsResponseObserver& aobserver)

    84 // Creates instance of CIRIsdsClient.

    85 // ---------------------------------------------------------------------------

    86 //

    87 CIRIsdsClient* CIRIsdsClient::NewLC(MIsdsResponseObserver& aobserver,

    88 									const TDesC& aISDSBaseUrl)

    89     {

    90     IRLOG_DEBUG( "CIRIsdsClient::NewLC - Entering" );

    91     CIRIsdsClient* self = new ( ELeave ) CIRIsdsClient(aobserver);

    92     CleanupStack::PushL( self );

    93     self->ConstructL(aISDSBaseUrl);

    94     IRLOG_DEBUG( "CIRIsdsClient::NewLC - Exiting." );

    95     return self;

    96     }

    97 

    98 

    99 // ---------------------------------------------------------------------------

   100 // CIRIsdsClient::ConstructL()	

   101 // Symbian two phased constructor

   102 // ---------------------------------------------------------------------------

   103 //	

   104 void CIRIsdsClient::ConstructL(const TDesC& aISDSBaseUrl)

   105 	{

   106 	//!	Construsting the DataproviderDLL instance

   107 	IRLOG_DEBUG( "IRIsdsClient::ConstructL - Entering" );

   108 	iSettings=CIRSettings::OpenL();	

   109 	iISDSBaseUrl=aISDSBaseUrl.AllocL();

   110 //Base URL required to browse through the category

   111 	iCatgoryURL.Zero();

   112 	iCatgoryURL.Copy(*iISDSBaseUrl);

   113 	iCatgoryURL.Append(KBrowseUrl);

   114 	//Base URL required to search isds 

   115 	iSearchURL.Zero();

   116 	iSearchURL.Copy(*iISDSBaseUrl);

   117 	iSearchURL.Append(KChannelnSearchUrl);	

   118 	//Base URL required to get IRID

   119 	iGetIridUrl.Zero();

   120 	iGetIridUrl.Copy(*iISDSBaseUrl);

   121 	iGetIridUrl.Append(KGetIRIDUrl);

   122 	//creates DataProvider

   123 	iDataProvider=CIRDataProvider::NewL(*this);

   124 	//creates XML Parser

   125 	iXmlReader=CIRXMLContentHandler::NewL(*this,*this);

   126 	//creates Cache manager

   127 	iCache=CIRCacheMgmt::OpenL(*this);

   128 	iCache->AddObserverL(this);

   129 	//Session Log

   130     iBrowseReport = CIRReportGenerator::OpenL();

   131         // Retrive the current language and set it as an Accept Language

   132 	TLanguage currentLanguage = User::Language();

   133 	iShortLanguageCode = IRLanguageMapper::MapLanguage(currentLanguage);

   134 

   135 	IRLOG_DEBUG( "IRIsdsClient::ConstructL - Exiting." );

   136 

   137     }

   138 	

   139 

   140 // ---------------------------------------------------------------------------

   141 // CIRIsdsClient::CIRIsdsClient(MIsdsResponseObserver& aobserver)	

   142 // Default constructor

   143 // ---------------------------------------------------------------------------

   144 //	

   145 CIRIsdsClient::CIRIsdsClient(MIsdsResponseObserver& aobserver):

   146 	iIsdsResponseObserver(aobserver)

   147 	{

   148 	IRLOG_DEBUG( "CIRIsdsClient::CIRIsdsClient" );

   149 	//No implementation

   150 	}	

   151 	

   152 // ---------------------------------------------------------------------------

   153 // CIRIsdsClient::~CIRIsdsClient()

   154 // Destructor

   155 // ---------------------------------------------------------------------------

   156 //	

   157 CIRIsdsClient::~CIRIsdsClient()

   158 	{

   159 	IRLOG_DEBUG( "CIRIsdsClient::~CIRIsdsClient - Entering" );

   160 	delete iDataProvider;

   161 	delete 	iXmlReader;

   162 	if(iSendPreset)

   163 		{

   164 		iSendPreset->ResetAndDestroy();

   165 		}

   166 	delete iSendPreset;

   167 

   168     if (iCache)

   169         {

   170         iCache->RemoveObserver(this);

   171         iCache->Close();

   172         }

   173 

   174 	if(iSettings)

   175 		{

   176 		iSettings->Close();

   177 		}

   178 	delete iISDSBaseUrl;

   179 	if(iBrowseReport)

   180         {

   181 		iBrowseReport->Close();

   182 		}

   183 	if(iTempRequestObject)

   184 		{

   185 		delete iTempRequestObject;

   186 		iTempRequestObject = NULL;			

   187 		}

   188 

   189 	IRLOG_DEBUG( "CIRIsdsClient::~CIRIsdsClient - Exiting." );

   190 	}

   191 		

   192 

   193 EXPORT_C TBool CIRIsdsClient::IRIsdsIsCategoryCachedL(

   194              TIRIsdsclientInterfaceIDs aISDSClientRequest)

   195 { 

   196     iForceGet=EFalse;  

   197     TInt res = 0;

   198     iCacheReqMade = EFalse;

   199     switch(aISDSClientRequest)

   200         {

   201             //When genre data is requested by user

   202         case EGenre:

   203             {

   204             //set the request type for subsiquent Use           

   205              

   206             iCachePath.Zero();

   207             iCachePath.Copy(KGenres);            

   208             iCache->CheckCacheL(0,KGenres,iForceGet,res);       

   209             }

   210           

   211         break;

   212         //When Language data is requested by user                       

   213         case ELanguages:

   214             {

   215             

   216             iCachePath.Zero();

   217             iCachePath.Copy(KLanguages);            

   218             iCache->CheckCacheL(0,KLanguages,iForceGet,res);          

   219           

   220             }

   221         break;

   222         //When Country data is requested by user                                                    

   223         case  ECountries:

   224             {

   225          

   226             iCachePath.Zero();

   227             iCachePath.Copy(KCountries);          

   228             iCache->CheckCacheL(0,KCountries,iForceGet,res);          

   229             }

   230         break;

   231                     

   232             //When hotpics data is requested by user                                                        

   233         case  Ehotpicks:

   234             {

   235             //set the request type for subsiquent Use            

   236             iCachePath.Zero();

   237             iCachePath.Copy(KHotpicks);

   238             iCache->CheckCacheL(1,KHotpicks,iForceGet,res);

   239             

   240             }

   241         break;   

   242 		default:

   243 		break;    

   244     }

   245     

   246     if (res == CIRCacheMgmt::ECacheUseable)

   247     {

   248         return ETrue;

   249     }

   250      

   251     

   252     return EFalse; 

   253 }

   254 // ---------------------------------------------------------------------------

   255 // void CIRIsdsClientInteface(TIRIsdsclientInterfaceIDs aISDSClientRequest)

   256 // Called by UI to make request to ISDS for catogories

   257 // @param :ENUM value depending on catogory which user wants to explore

   258 // ---------------------------------------------------------------------------

   259 //

   260 

   261 EXPORT_C TBool CIRIsdsClient::IRIsdsClientIntefaceL(TIRIsdsclientInterfaceIDs 

   262 	aISDSClientRequest)

   263 	{  

   264 	//cancels any pending request

   265 	IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Entering" );

   266 	CIRHttpRequestData * requestData= new(ELeave) CIRHttpRequestData;

   267 	CleanupStack::PushL(requestData);

   268 	requestData->iAcceptLanguage.Copy( iShortLanguageCode );

   269 	//Sets the Htpp method to GET

   270 	requestData->iMethod = EIRHttpGET;

   271 	//check for valid cache

   272 	iForceGet=EFalse;  

   273 	 

   274 	TInt res=0;

   275 	  

   276 	switch(aISDSClientRequest)

   277 		{

   278             //When genre data is requested by user

   279 		case EGenre:

   280 			{

   281 			//set the request type for subsiquent Use

   282 			iRequestType=0;

   283 			iDataFrom=EFalse;

   284 			iCachePath.Zero();

   285 			iCachePath.Copy(KGenres);

   286 			iCacheReqMade = ETrue;

   287 			iCache->CheckCacheL(0,KGenres,iForceGet,res);

   288 			if(res==0)//if cache is not available

   289 				{

   290 				requestData->iUri.Copy(iCatgoryURL);

   291 				requestData->iUri.Append(KGenres);

   292 				iConditonalGet=EFalse;

   293 				//issues request for Genre data

   294 				IRHttpIssueRequestL(*requestData);

   295 				iBrowseUrl.Zero();		

   296 				iBrowseUrl.Copy(requestData->iUri);

   297 				iBrowseReport->BrowseUrl(iBrowseUrl,0);    

   298 				iDataFrom=ETrue;				

   299 				}

   300 			if(res ==-1)//i cache is stale

   301 				{

   302 				iConditonalGet=ETrue;

   303 				requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

   304 				requestData->isIfModifiedSet = ETrue;

   305 				requestData->iUri.Copy(iCatgoryURL);

   306 				requestData->iUri.Append(KGenres);

   307 				IRHttpIssueRequestL(*requestData);

   308 				iBrowseUrl.Zero();		

   309 		        iBrowseUrl.Copy(requestData->iUri);

   310 		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    

   311 				iDataFrom=ETrue;	

   312 				}

   313 			if (res == 1)

   314 				{

   315 				requestData->iUri.Copy(iCatgoryURL);

   316 				requestData->iUri.Append(KGenres);

   317 				iBrowseUrl.Zero();		

   318 		        iBrowseUrl.Copy(requestData->iUri);

   319 		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    						

   320 				}

   321 			}

   322 		break;

   323         //When Language data is requested by user			 			

   324 		case ELanguages:

   325 			{

   326 	        //set the request type for subsiquent Use

   327 	        iRequestType=0;

   328 			iDataFrom=EFalse;

   329 			

   330 			iCachePath.Zero();

   331 			iCachePath.Copy(KLanguages);

   332     		iCacheReqMade = ETrue;

   333     		iCache->CheckCacheL(0,KLanguages,iForceGet,res);

   334 

   335 			if(res==0)//if cache is not available

   336 				{

   337 				requestData->iUri.Copy(iCatgoryURL);

   338 				requestData->iUri.Append(KLanguages);

   339 				//Isuues request for language data

   340 				IRHttpIssueRequestL(*requestData);

   341 				iConditonalGet=EFalse;	

   342 				iBrowseUrl.Zero();

   343 				iBrowseUrl.Copy(requestData->iUri);	

   344 				iBrowseReport->BrowseUrl(iBrowseUrl,0);

   345 				iDataFrom=ETrue;					

   346 				}			

   347 			if(res ==-1)//i cache is stale

   348 				{

   349 				iConditonalGet=ETrue;

   350 				requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

   351 				requestData->isIfModifiedSet=ETrue;

   352 				requestData->iUri.Copy(iCatgoryURL);

   353 				requestData->iUri.Append(KLanguages);

   354 				//Isuues request for language data if cache isnt valid

   355 				IRHttpIssueRequestL(*requestData);	

   356 				iBrowseUrl.Zero();

   357 				iBrowseUrl.Copy(requestData->iUri);	

   358 				iBrowseReport->BrowseUrl(iBrowseUrl,0);

   359 				iDataFrom=ETrue;					

   360 				}

   361 			if (res == 1)

   362 				{

   363 				requestData->iUri.Copy(iCatgoryURL);

   364 				requestData->iUri.Append(KLanguages);

   365 				iBrowseUrl.Zero();		

   366 		        iBrowseUrl.Copy(requestData->iUri);

   367 		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    						

   368 				}			

   369 			}

   370 		break;

   371         //When Country data is requested by user			 						      			

   372     	case  ECountries:

   373 			{

   374 			//set the request type for subsiquent Use

   375 			iRequestType=0;

   376 			iDataFrom=EFalse;

   377 			

   378 			iCachePath.Zero();

   379 			iCachePath.Copy(KCountries);

   380 			iCacheReqMade = ETrue;

   381 			iCache->CheckCacheL(0,KCountries,iForceGet,res);

   382 			if(res==0)//if cache is not available

   383                 {

   384 				requestData->iUri.Copy(iCatgoryURL);

   385 				requestData->iUri.Append(KCountries);	

   386 				//Isuues request for country data			

   387 				IRHttpIssueRequestL(*requestData);	

   388 				iConditonalGet=EFalse;

   389 				iBrowseUrl.Zero();

   390 				iBrowseUrl.Copy(requestData->iUri);

   391 				iBrowseReport->BrowseUrl(iBrowseUrl,0);

   392 				iDataFrom=ETrue;					

   393 				}

   394 			if(res ==-1)//i cache is stale

   395 				{

   396 				iConditonalGet=ETrue;

   397 			    requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

   398 				requestData->isIfModifiedSet = ETrue;

   399 				requestData->iUri.Copy(iCatgoryURL);

   400 				requestData->iUri.Append(KCountries);

   401 				//Isuues request for country data if cache isnt valid

   402 				IRHttpIssueRequestL(*requestData);

   403 				iBrowseUrl.Zero();		

   404 			    iBrowseUrl.Copy(requestData->iUri);

   405 				iBrowseReport->BrowseUrl(iBrowseUrl,0);

   406 				iDataFrom=ETrue;					

   407 				}

   408 			if (res == 1)

   409 				{

   410 				requestData->iUri.Copy(iCatgoryURL);

   411 				requestData->iUri.Append(KCountries);

   412 				iBrowseUrl.Zero();		

   413 		        iBrowseUrl.Copy(requestData->iUri);

   414 		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    						

   415 				}

   416 			 

   417 			}

   418 		break;

   419     				

   420     		//When hotpics data is requested by user			 						      				

   421     	case  Ehotpicks:

   422 			{

   423 			//set the request type for subsiquent Use

   424 			iRequestType=1;

   425 			iCacheReqMade = ETrue;

   426 			iCache->CheckCacheL(1,KHotpicks,iForceGet,res);

   427 			iCachePath.Zero();

   428 			iCachePath.Copy(KHotpicks);

   429 			iDataFrom=EFalse;

   430 

   431 			if(res==0)//if cache is not available

   432 				{

   433 				requestData->iUri.Copy(iCatgoryURL);

   434 				requestData->iUri.Append(KHotpicks);

   435 				//Isuues request for hotpics data

   436 				IRHttpIssueRequestL(*requestData);

   437 				iConditonalGet=EFalse;

   438 				iBrowseUrl.Zero();

   439 			    iBrowseUrl.Copy(requestData->iUri);

   440 			        iBrowseReport->BrowseUrl(iBrowseUrl,0);     

   441 				iDataFrom=ETrue;					

   442 				}	

   443 			if(res ==-1)//i cache is stale

   444 			 	{

   445 				 iConditonalGet=ETrue;

   446 				 requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

   447 				 requestData->isIfModifiedSet=ETrue;

   448 				 requestData->iUri.Copy(iCatgoryURL);

   449 				 requestData->iUri.Append(KHotpicks);

   450 				 //Isuues request for hotpics data if cache isnt valid

   451 				 IRHttpIssueRequestL(*requestData);

   452 				 iBrowseUrl.Zero();		

   453 		         iBrowseUrl.Copy(requestData->iUri);

   454 				 iBrowseReport->BrowseUrl(iBrowseUrl,0);     

   455 				 iDataFrom=ETrue;					

   456 				 }	

   457 			if (res == 1)

   458 				{

   459 				requestData->iUri.Copy(iCatgoryURL);

   460 				requestData->iUri.Append(KHotpicks);

   461 				iBrowseUrl.Zero();		

   462 		        iBrowseUrl.Copy(requestData->iUri);

   463 		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    						

   464 				}

   465 			}

   466 		break;

   467        	

   468 	    }

   469 	CleanupStack::PopAndDestroy(requestData); 

   470 	IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Exiting." );

   471 	return iDataFrom;		

   472 	}//end of function	

   473 	

   474 	

   475 EXPORT_C CIRDataProvider* CIRIsdsClient::GetDataProvider()

   476 {

   477 	IRLOG_DEBUG( "CIRIsdsClient::GetDataProvider" );

   478 	return iDataProvider;

   479 }

   480 

   481 	

   482 	

   483 	

   484 

   485 // ---------------------------------------------------------------------------

   486 // void IRHttpContentNotChanged()	

   487 // this is call back funtion called by Dataprovider in case 

   488 // HTTP content isnt changed by ISDS 

   489 // ---------------------------------------------------------------------------

   490 //	

   491 void CIRIsdsClient::IRHttpResponseCodeReceived( TInt aResponseCode,

   492 	CIRHttpResponseData& aResponseHeaders )

   493 	{

   494 	IRLOG_INFO2( "CIRIsdsClient::IRHttpResponseCodeReceived (%d)", aResponseCode );

   495 	TInt res = KErrNotFound;

   496 	switch (aResponseCode)

   497 		{

   498 		case KNotFound://404

   499 			{

   500 			//make channel user defined.

   501 			if(iSyncRequest)

   502 				{

   503 				iSyncRequest = EFalse;

   504 				//make the preset user-defined

   505 				TRAP_IGNORE(iIsdsResponseObserver.IsdsPresetRemovedL(

   506 													iPresetToBeSynced))	

   507 				}

   508 			

   509 			/*if(iOtaReqFrom)

   510 				{

   511 				TRAP_IGNORE(PurgeOtaInfoL())

   512 				}*/

   513 			

   514 			}

   515 			break;

   516 		case KNotModified://304

   517 			{

   518 			if(iConditonalGet)

   519 				{

   520 				//update the trust period 

   521 				//no problem if it leaves

   522 				TRAP_IGNORE(iCache->UpdateTrustPeriodL(iRequestType,iCachePath,

   523 				aResponseHeaders))

   524 				//do a forced get because the data is notmodifed in isds and 

   525 				//trustable

   526 				iForceGet=ETrue;

   527 				iCacheReqMade = ETrue;

   528 				TRAP_IGNORE(iCache->CheckCacheL(iRequestType,iCachePath,

   529 					iForceGet,res))

   530 				}

   531 			/*if(iOtaReqFrom)

   532 				{

   533 				TRAP_IGNORE(PurgeOtaInfoL())

   534 				}*/

   535 			}

   536 			break;

   537 		 default:

   538 		 	{

   539 		 	

   540 		 	}

   541 			break;

   542 		}

   543 	IRLOG_DEBUG( "CIRIsdsClient::IRHttpResponseCodeReceived - Exiting." );

   544 	}

   545 		

   546 

   547 // ---------------------------------------------------------------------------

   548 // void RHttpGeneralError(TInt aErrorCode)

   549 // It is a call back function called by the data provider 

   550 // to return error code in case of some error.

   551 // ---------------------------------------------------------------------------

   552 //

   553 void CIRIsdsClient::IRHttpGeneralError(TInt aErrorCode)

   554 	{

   555 	IRLOG_ERROR2( "CIRIsdsClient::IRHttpGeneralError (%d)", aErrorCode );

   556 	IRRDEBUG2("CIRISDSCLIENT::IRHTTPGENERALERROR",KNullDesC);

   557 	if(iSyncRequest)

   558 		{

   559 		IRRDEBUG2("CIRISDSCLIENT::IRHTTPGENERALERROR--IF ISYNC",KNullDesC);

   560 		iSyncRequest=EFalse;

   561 		if(aErrorCode == KNotModified  ||  aErrorCode == KServiceUnavailable)

   562 			{

   563 			TRAP_IGNORE(iIsdsResponseObserver.IsdsPresetNoChangeL())

   564 			return;			

   565 			}

   566 	    IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (1)." );

   567 		}

   568 

   569 	/*if(iOtaReqFrom)

   570 		{

   571 		//if internal service request

   572 		//reset the flag

   573 		iOtaReqFrom = EFalse

   574 		IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (2)." )

   575 		return	

   576 		}*/

   577 	if(iConditonalGet)

   578 		{

   579 		IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (3). ");

   580 		iConditonalGet = EFalse;

   581 		if(aErrorCode==KNotModified)

   582 			{

   583 			return;

   584 			}

   585 		}

   586 	if(iPostResponsePending)

   587 		{

   588 		IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (4). ");

   589 		IRRDEBUG2("CIRISDSCLIENT::ISDSGENERALERROR--POSTPENDING",KNullDesC);

   590 		iPostResponsePending = EFalse;

   591 		//no action required

   592 		//session log is backed up before sending;

   593 		return;

   594 		}

   595 	if(iIRIDPending)

   596 		{

   597 		IRRDEBUG2("CIRISDSCLIENT::IRHTTPGENERALERROR--IF IRID",KNullDesC);

   598 		IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (7). ");			

   599 		iIRIDPending = EFalse;

   600 //d		TRAP_IGNORE( IRGetIRIDL() )

   601 		}

   602 	IRRDEBUG2("CIRISDSCLIENT::IRHTTPGENERALERROR--BEFORE TRAPD",KNullDesC);

   603 	TRAPD(errd,iIsdsResponseObserver.IsdsErrorL(aErrorCode));

   604 	if(errd)

   605 		{

   606 		IRRDEBUG2("CIRISDSCLIENT::IRHTTPGENERALERROR--IF ERRD",KNullDesC);

   607         IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (5)." );

   608 		return;		

   609 		}

   610     IRLOG_DEBUG( "CIRIsdsClient::IRHttpGeneralError - Exiting (6)." );

   611 	}

   612 

   613 	

   614 // ---------------------------------------------------------------------------

   615 // void IRHttpDataReceived(TDesC& aXmlPath)

   616 // It is a call back function called by the data provider 

   617 // once it recieves the XML data

   618 // ---------------------------------------------------------------------------

   619 //

   620 void CIRIsdsClient::IRHttpDataReceived( const TDesC& aXmlPath, 

   621 										const CIRHttpResponseData& aResponseHeaders)

   622 	{

   623 	IRLOG_DEBUG( "CIRIsdsClient::IRHttpDataReceived - Entering" );

   624 	TBuf<KMaxLength> xmlPath;

   625 	xmlPath.Copy(aXmlPath);

   626 	

   627 	//!Calls XML parser with file path to XML file recieved

   628 	TRAPD(xmlErr,iXmlReader->ParseXmlL(xmlPath,iCachePath,aResponseHeaders))

   629 	if(xmlErr!=KErrNone)

   630 		{

   631 	    IRLOG_DEBUG( "CIRIsdsClient::IRHttpDataReceived - Exiting (1)." );

   632 		return;

   633 		}

   634 

   635 	if(iIRIDPending)

   636 		{

   637 		iIRIDPending = EFalse;

   638 		//if any request is pending by the time IRID response comes

   639 		if(iReqPending)

   640 			{

   641 			//issue the pending request

   642 			TRAP_IGNORE(IRHttpIssueRequestL(*iTempRequestObject))

   643 			}

   644 		}

   645 

   646 	IRLOG_DEBUG( "CIRIsdsClient::IRHttpDataReceived - Exiting (2)." );

   647 	}

   648 

   649 EXPORT_C TBool CIRIsdsClient::IRIsdsIsChannelCachedL(TUint aSelectedOption)

   650 {   

   651     TInt res = 0;

   652     iCacheReqMade = EFalse;

   653     iForceGet=EFalse;

   654      

   655      //previous data from cache

   656     if (iCatDataFrom)

   657     {

   658         if (aSelectedOption >= iCache->iPtrCategory->Count())

   659         {

   660             User::Leave(KErrArgument);

   661         }

   662 

   663         if (iCache->iPtrCategory->Count())

   664         {

   665             iCachePath.Zero();

   666             iCachePath.Copy(

   667                     (*(iCache->iPtrCategory))[aSelectedOption]->iCatId->Des());

   668 

   669             iCache->CheckCacheL(1,

   670                     iCachePath,

   671                     iForceGet, res);

   672         }

   673     }

   674     //previous data from xml

   675     else

   676     {

   677         if (aSelectedOption >= iXmlReader->iPtrCategory->Count())

   678         {

   679             User::Leave(KErrArgument);

   680         }

   681 

   682         if (iXmlReader->iPtrCategory->Count())

   683         {

   684             iCachePath.Zero();

   685             iCachePath.Copy(

   686                     (*(iXmlReader-> iPtrCategory))[aSelectedOption]->iCatId->Des());

   687             iCache->CheckCacheL(

   688                     1,

   689                     iCachePath,

   690                     iForceGet, res);

   691         }

   692     }

   693     

   694      

   695     if( CIRCacheMgmt::ECacheUseable == res )

   696         return ETrue;

   697     

   698     return EFalse;  

   699 }

   700 

   701 // ---------------------------------------------------------------------------

   702 // void CIRIsdsClientInteface(TUint aSelectedOption,TIRIsdsClientInterfaces aChoice)

   703 // This API is used by the UI to make request for isds listed channels

   704 // ---------------------------------------------------------------------------

   705 //

   706 EXPORT_C TBool CIRIsdsClient::IRIsdsClientIntefaceL(TUint aSelectedOption,

   707 	TIRIsdsClientInterfaces aChoice,TInt aHistoryBool)

   708 	{

   709 	IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Entering" );

   710 	iForceGet=EFalse;

   711 	CIRHttpRequestData * requestData= new(ELeave) CIRHttpRequestData;	  	

   712 	CleanupStack::PushL(requestData);

   713 	requestData->iMethod = EIRHttpGET;

   714 	requestData->iAcceptLanguage.Copy( iShortLanguageCode );

   715     requestData->iUri.Copy( *iISDSBaseUrl );

   716     

   717     TBool isAdvPresent = EFalse;

   718     

   719 

   720 	TInt res;

   721 	if(aChoice==ECatagory)

   722 		{

   723 		//set the request type for subsiquent Use

   724 		iRequestType=1;

   725 		//previous data from cache

   726 		if(iCatDataFrom)

   727 			{

   728 			TInt categoryCacheIndex;

   729 

   730 			if (( *(iCache->iPtrCategory))[0]->iCatGetOperation)

   731 				{

   732 				isAdvPresent = EFalse;	

   733 				}

   734 			else

   735 				{

   736 				isAdvPresent = ETrue;	

   737 				}				

   738 			if (!isAdvPresent)

   739 				{

   740 				categoryCacheIndex = 0;				

   741 				}

   742 			else

   743 				{

   744 				categoryCacheIndex = 1;					

   745 				}			

   746  

   747 			if( aSelectedOption >= iCache->iPtrCategory->Count())

   748 			{

   749 			    User::Leave(KErrArgument);

   750 			}

   751 			

   752 			if(iCache->iPtrCategory->Count())

   753 				{

   754 				iCachePath.Zero();

   755 				iCachePath.Copy((*(iCache->iPtrCategory))[aSelectedOption]->iCatId->Des());

   756 				iCacheReqMade = ETrue;

   757 				iCache->CheckCacheL(1,(*(iCache->iPtrCategory))[aSelectedOption]->

   758 					iCatId->Des(),iForceGet,res);

   759 				iDataFrom=EFalse;			

   760 				if(res == 0)	

   761 					{

   762 					requestData->iUri.Append( (*(iCache->

   763 						iPtrCategory))[categoryCacheIndex]->iCatGetOperation->Des());

   764 					requestData->iUri.Append( (*(iCache->

   765 						iPtrCategory))[aSelectedOption]->iCatId->Des());	

   766 					IRHttpIssueRequestL(*requestData);

   767 					iConditonalGet=EFalse;

   768 					iBrowseUrl.Copy(requestData->iUri);

   769 					iBrowseReport->BrowseUrl(iBrowseUrl,0);

   770 					iDataFrom=ETrue;		

   771 					}

   772 				if(res == -1)

   773 					{

   774 					iConditonalGet=ETrue;

   775 					requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

   776 					requestData->isIfModifiedSet = ETrue;

   777 					requestData->iUri.Append( (*(iCache->

   778 						iPtrCategory))[categoryCacheIndex]->iCatGetOperation->Des()); //0

   779 					requestData->iUri.Append( (*(iCache->

   780 						iPtrCategory))[aSelectedOption]->iCatId->Des());	

   781 					IRHttpIssueRequestL(*requestData);

   782 					iBrowseUrl.Copy(requestData->iUri);

   783 					iBrowseReport->BrowseUrl(iBrowseUrl,0);

   784 					iDataFrom=ETrue;		

   785 					}		

   786 				}

   787 			}

   788 		//previous data from xml

   789 		else

   790 			{

   791 			TInt categoryXmlIndex;

   792 			if (( *(iXmlReader->iPtrCategory))[0]->iCatGetOperation)

   793 				{

   794 				isAdvPresent = EFalse;	

   795 				}				

   796 			else

   797 				{

   798 				isAdvPresent = ETrue;	

   799 				}				

   800 			if (!isAdvPresent)

   801 				{

   802 				categoryXmlIndex = 0;				

   803 				}

   804 			else

   805 				{

   806 				categoryXmlIndex = 1;					

   807 				}

   808 			

   809 	        if (aSelectedOption >= iXmlReader->iPtrCategory->Count())

   810 	            {

   811 	            User::Leave(KErrArgument);

   812                 }

   813 	        

   814 			if(iXmlReader->iPtrCategory->Count())

   815 				{

   816 				iCachePath.Zero();

   817 				iCachePath.Copy((*(iXmlReader->

   818 					iPtrCategory))[aSelectedOption]->iCatId->Des());

   819 				iCacheReqMade = ETrue;

   820 				iCache->CheckCacheL(1,(*(iXmlReader->

   821 					iPtrCategory))[aSelectedOption]->iCatId->Des(),iForceGet,res);

   822 				iDataFrom=EFalse;			

   823 				if( res==0 )	

   824 					{

   825 					requestData->iUri.Append( (*(iXmlReader->

   826 						iPtrCategory))[categoryXmlIndex]->iCatGetOperation->Des());			  	  	

   827 					requestData->iUri.Append( (*(iXmlReader->

   828 						iPtrCategory))[aSelectedOption]->iCatId->Des());	

   829 					IRHttpIssueRequestL(*requestData);

   830 					iConditonalGet=EFalse;         

   831 					iBrowseUrl.Copy(requestData->iUri);

   832 					iBrowseReport->BrowseUrl(iBrowseUrl,0);	

   833 					iDataFrom=ETrue;	

   834 					}

   835 				if( res==-1 )

   836 					{

   837 					iConditonalGet=ETrue;

   838 					requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

   839 					requestData->isIfModifiedSet = ETrue;

   840 					requestData->iUri.Append( (*(iXmlReader->

   841 						iPtrCategory))[categoryXmlIndex]->iCatGetOperation->Des());

   842 					requestData->iUri.Append( (*(iXmlReader->

   843 						iPtrCategory))[aSelectedOption]->iCatId->Des());	

   844 					IRHttpIssueRequestL(*requestData);

   845 					iBrowseUrl.Copy(requestData->iUri);

   846 					iBrowseReport->BrowseUrl(iBrowseUrl,0);

   847 					iDataFrom=ETrue;	

   848 					}

   849 				}

   850 			}

   851 		}

   852 	else if(aChoice==EChannels)

   853 		{

   854     

   855 		TBuf<KChannelidMaxLength> channelid;

   856 		//set the request type for subsiquent Use

   857 		iRequestType=KTwo;	 	

   858 		_LIT(KFormat,"%d");

   859 		if(aHistoryBool)

   860 			{

   861 			_LIT(KPresetFetchUrl,"/do/directory/getPreset?channelid=");

   862 			requestData->iUri.Append(KPresetFetchUrl);

   863 			TBuf<KChannelidMaxLength> channelid;

   864 			_LIT(KFormat,"%d");

   865 			channelid.Format(KFormat,aSelectedOption);

   866 			requestData->iUri.Append(channelid);	

   867 			IRHttpIssueRequestL(*requestData);

   868 			iConditonalGet=EFalse;

   869 			//Session Log

   870 			iBrowseUrl.Zero();

   871 			iBrowseUrl.Copy(requestData->iUri);

   872 			iBrowseReport->BrowseUrl(iBrowseUrl,1);

   873 			iDataFrom=ETrue;

   874 			CleanupStack::PopAndDestroy(requestData); 

   875 			return iDataFrom;

   876 			}

   877 		

   878 		//previous data from cache

   879 		if( iChannelDataFrom)

   880 			{

   881 			TInt channelCacheIndex;

   882 			if (( *(iCache->iPtrChannel))[0]->iChannelGetOperation)

   883 				{

   884 				isAdvPresent = EFalse;	

   885 				}				

   886 			else

   887 				{

   888 				isAdvPresent = ETrue;	

   889 				}				

   890 			if (!isAdvPresent)

   891 				{

   892 				channelCacheIndex = 0;				

   893 				}

   894 			else

   895 				{

   896 				channelCacheIndex = 1;					

   897 				}

   898 			

   899 

   900             if( aSelectedOption >= iCache->iPtrChannel->Count())

   901             {

   902                 User::Leave(KErrArgument);

   903             }

   904             

   905 			if(iCache->iPtrChannel->Count())

   906 				{

   907 				channelid.Format(KFormat,(*(iCache->

   908 					iPtrChannel))[aSelectedOption]->iChannelID);

   909 				iCachePath.Zero();

   910 				iCachePath.Copy(channelid); 

   911 				iCacheReqMade = ETrue;

   912 				iCache->CheckCacheL(KTwo,channelid,iForceGet,res);

   913 				iDataFrom=EFalse;			

   914 				if( res == 0 || res==-1)	

   915 					{

   916 					requestData->iUri.Append( (*(iCache->

   917 						iPtrChannel))[channelCacheIndex]->iChannelGetOperation->Des());

   918 					requestData->iUri.Append(channelid);	

   919 					IRHttpIssueRequestL(*requestData);

   920 					iConditonalGet=EFalse;

   921 	        		//Session Log	

   922 					iBrowseUrl.Copy(requestData->iUri);				

   923 					iBrowseReport->BrowseUrl(iBrowseUrl,1);

   924 					iDataFrom=ETrue;		

   925 					}

   926 				}

   927 			}

   928 		//previous data from xml

   929 		else

   930 			{

   931 			TInt channelXmlIndex;

   932 			if( 0 == ( *(iXmlReader->iPtrChannel)).Count() )

   933 			{

   934 			    CleanupStack::PopAndDestroy(requestData); 

   935 			    IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Error!" );

   936 			    return iDataFrom;

   937 			}

   938 			

   939 			if (( *(iXmlReader->iPtrChannel))[0]->iChannelGetOperation)

   940 				{

   941 				isAdvPresent = EFalse;

   942 				}

   943 			else

   944 				{

   945 				isAdvPresent = ETrue;	

   946 				}				

   947 			if (!isAdvPresent)

   948 				{

   949 				channelXmlIndex = 0;				

   950 				}

   951 			else

   952 				{

   953 				channelXmlIndex = 1;					

   954 				}

   955 			

   956             if( aSelectedOption >= iXmlReader->iPtrChannel->Count())

   957             {

   958                 User::Leave(KErrArgument);

   959             }

   960             

   961 			if(iXmlReader->iPtrChannel->Count())

   962 				{

   963 				channelid.Format(KFormat,(*(iXmlReader->

   964 					iPtrChannel))[aSelectedOption]->iChannelID);

   965 				iCachePath.Zero();

   966 				iCachePath.Copy(channelid); 

   967 				iCacheReqMade = ETrue;

   968 				iCache->CheckCacheL(KTwo,channelid,iForceGet,res);

   969 				iDataFrom=EFalse;			

   970 				if(res == 0 || res==-1)	

   971 					{

   972 					requestData->iUri.Append( (*(iXmlReader->

   973 						iPtrChannel))[channelXmlIndex]->iChannelGetOperation->Des());

   974 					requestData->iUri.Append(channelid);	

   975 					IRHttpIssueRequestL(*requestData);

   976 					iConditonalGet=EFalse;

   977 	                //Session Log

   978 					iBrowseUrl.Copy(requestData->iUri);

   979 					iBrowseReport->BrowseUrl(iBrowseUrl,1);

   980 					iDataFrom=ETrue;		

   981 					}

   982 				}

   983 			}

   984 		}

   985 	else

   986 		{

   987 			

   988 		}		

   989 	CleanupStack::PopAndDestroy(requestData); 

   990 	IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Exiting" );

   991 	return iDataFrom;

   992 	}

   993 

   994 

   995 

   996 // ---------------------------------------------------------------------------

   997 // void CIRGetIRID()

   998 // This API is used by the UI to get IR ID from 

   999 // isds if it doesnt have one

  1000 // ---------------------------------------------------------------------------

  1001 //

  1002 EXPORT_C void CIRIsdsClient::IRGetIRIDL()

  1003 	{

  1004 	IRLOG_DEBUG( "CIRIsdsClient::IRGetIRIDL - Entering" );

  1005 	//if irid is not available fetch it

  1006 	 if(iSettings->GetIRIDL().Length()==0)

  1007 	 	{

  1008 		 iReqFromGetIRIDFunc = ETrue;

  1009 		 iIRIDPending = EFalse;

  1010 		 CIRHttpRequestData *requestData= new(ELeave) CIRHttpRequestData(); 	

  1011 		 CleanupStack::PushL(requestData);		  

  1012 		 requestData->iMethod = EIRHttpGET;

  1013 		 requestData->iAcceptLanguage.Copy( iShortLanguageCode );

  1014 		 requestData->iUri.Copy(iGetIridUrl);		

  1015 		 IRHttpIssueRequestL(*requestData);			

  1016 		 CleanupStack::PopAndDestroy(requestData);

  1017 		 iIRIDPending = ETrue;

  1018          IRLOG_DEBUG( "CIRIsdsClient::IRGetIRIDL - Exiting (1)." );

  1019 		 return;	

  1020 	 	}

  1021 	IRLOG_DEBUG( "CIRIsdsClient::IRGetIRIDL - Exiting (2)." );

  1022 	}

  1023 // ---------------------------------------------------------------------------

  1024 // void GetOtaStatus()

  1025 // This API is used by the UI to query for ota update 

  1026 // ---------------------------------------------------------------------------

  1027 //

  1028 EXPORT_C void CIRIsdsClient::GetOtaStatusL(TBool& aDataFrom)

  1029 	{

  1030 	IRLOG_DEBUG( "CIRIsdsClient::GetOtaStatusL - Entering" );

  1031 	

  1032  	CIRHttpRequestData *requestData= new(ELeave) CIRHttpRequestData();

  1033   	

  1034 	CleanupStack::PushL(requestData);

  1035 

  1036 	requestData->iMethod = EIRHttpGET;

  1037 	requestData->iAcceptLanguage.Copy(iShortLanguageCode);

  1038 	iGetOtaStatus.Zero();

  1039 	iGetOtaStatus.Copy(*iISDSBaseUrl);

  1040 	iGetOtaStatus.Append(KOtaUpdateUrl);

  1041 	iGetOtaStatus.Append(	iSettings->GetIRIDL());

  1042 	

  1043 	//set the request type for subsiquent Use

  1044 	iRequestType = EOtaInfo;

  1045 	iDataFrom=EFalse;

  1046 	iCachePath.Zero();

  1047 	iCachePath.Copy(KOtaUpdateUrl);

  1048 	TInt res = 0;

  1049 	//check cache if it is a genral service request

  1050 	//not initiated by the user.

  1051 	if(iOtaReqFrom)

  1052 		{

  1053 		iCacheReqMade = ETrue;

  1054 		iCache->CheckCacheL(EOtaInfo,KOtaUpdateUrl,iForceGet,res);

  1055 		}

  1056 	if(res == 1)

  1057 		{

  1058 		aDataFrom = EFalse;

  1059 		}

  1060 	//if cache is not available or stale(dont use the trust period val)

  1061 	if(res == 0 || res == -1)

  1062 		{

  1063 		requestData->iUri.Copy(iGetOtaStatus);

  1064 		iConditonalGet=EFalse;

  1065 		//issues request for ota data

  1066 		iDataProvider->IRHttpIssueRequestL(*requestData);

  1067 		iDataFrom=ETrue;

  1068 		aDataFrom = ETrue;				

  1069 		}	

  1070 	CleanupStack::PopAndDestroy(requestData);	

  1071 	

  1072 	IRLOG_DEBUG( "CIRIsdsClient::GetOtaStatusL - Exiting." );

  1073 	}	

  1074 

  1075 // ---------------------------------------------------------------------------

  1076 // CIRIsdsClient::IRISDSPostL()

  1077 // This API is used to Post Irapp usage report to isds

  1078 // ---------------------------------------------------------------------------

  1079 //

  1080 EXPORT_C void CIRIsdsClient::IRISDSPostL(TFileName &/*aFileName*/)

  1081 	{

  1082 	IRLOG_DEBUG( "CIRIsdsClient::IRISDSPostL - Entering" );

  1083 	IRRDEBUG2("CIRISDSCLIENT::ISDSPOSTL",KNullDesC);

  1084 	//Cancels any pending requests

  1085 	IRISDSCancelRequest();

  1086 	CIRHttpRequestData * requestData= new(ELeave) CIRHttpRequestData;

  1087 	CleanupStack::PushL(requestData);	 

  1088 	//Sets the Http Method to POST

  1089 	requestData->iMethod = EIRHttpPOST;

  1090 	requestData->iAcceptLanguage.Copy(iShortLanguageCode);

  1091 	requestData->iUri.Copy(*iISDSBaseUrl);

  1092 	requestData->iUri.Append(KLogUsageUrl);

  1093 	//issues request to post the log usage report to isds

  1094 	iPostResponsePending = ETrue;

  1095 	IRHttpIssueRequestL(*requestData);

  1096 	CleanupStack::PopAndDestroy(requestData);

  1097 	IRLOG_DEBUG( "CIRIsdsClient::IRISDSPostL - Exiting" );

  1098 	}

  1099 	

  1100 // ---------------------------------------------------------------------------

  1101 // void CIRISDSCancelRequest()

  1102 // This API is used by the UI to cancel a request made.

  1103 // ---------------------------------------------------------------------------

  1104 //

  1105 EXPORT_C void CIRIsdsClient::IRISDSCancelRequest()

  1106 	{

  1107 	IRLOG_DEBUG( "CIRIsdsClient::IRISDSCancelRequest - Entering" );

  1108 	iSyncRequest = EFalse;

  1109 	iReqFromSync = EFalse;

  1110 	iOtaReqFrom = EFalse;

  1111 	iConditonalGet = EFalse;

  1112 	iPostResponsePending = EFalse;

  1113 	iIRIDPending = EFalse;

  1114 	iDataProvider->IRHttpCancelRequest();

  1115 	IRLOG_DEBUG( "CIRIsdsClient::IRISDSCancelRequest - Exiting" );

  1116 	}

  1117 

  1118 EXPORT_C void CIRIsdsClient::IRISDSMultiSearchL(const TDesC& aGenreID, const TDesC& aCountryID, const TDesC& aLanguageID, const TDesC& aSearchText)

  1119 {

  1120     IRLOG_DEBUG( "CIRIsdsClient::IRISDSMultiSearch - Entering" );

  1121     CIRHttpRequestData * requestData= new(ELeave) CIRHttpRequestData();

  1122     iCachePath.Zero();  

  1123     CleanupStack::PushL(requestData);

  1124     

  1125     requestData->iMethod = EIRHttpGET;

  1126     requestData->iAcceptLanguage.Copy( iShortLanguageCode );

  1127     

  1128     HBufC8* utfEncodedSearchText = CnvUtfConverter::ConvertFromUnicodeToUtf8L( aSearchText );     

  1129     CleanupStack::PushL( utfEncodedSearchText );    

  1130     

  1131      

  1132     HBufC8 *encodedQuery = NULL; 

  1133     encodedQuery = EscapeUtils::EscapeEncodeL(*utfEncodedSearchText, EscapeUtils::EEscapeQuery);       

  1134