92        	

    92             ENTRY("GetLastLocation" , CTestProvider :: GetLastLocation),

    93         

    93             ENTRY("GetLocationMultiple" , CTestProvider :: GetLocationMultiple),

    94             ENTRY("TraceMultiple" , CTestProvider :: TraceMultiple),

    95             ENTRY("TraceTimeOut" , CTestProvider :: TraceTimeOut),

    96             ENTRY("TraceMultipleWrongCancel", CTestProvider::TraceMultipleWrongCancel),

    97             ENTRY("EnableAccTrueGetLoc", CTestProvider::EnableAccTrueGetLoc),

    98             ENTRY("EnableAccFalseGetLoc", CTestProvider::EnableAccFalseGetLoc),

    99             ENTRY("EnableAccTrueTrace", CTestProvider::EnableAccTrueTrace),

   100             ENTRY("EnableAccFalseTrace", CTestProvider::EnableAccFalseTrace),

   101             ENTRY("EnableAccPosBasedGetloc", CTestProvider::EnableAccPosBasedGetloc),

   102             ENTRY("EnableAccPosBasedWrongTypeGetloc", CTestProvider::EnableAccPosBasedWrongTypeGetloc),

   103             ENTRY("EnableAccPosBasedTrace", CTestProvider::EnableAccPosBasedTrace),

   104             ENTRY("EnableAccPosBasedWrongTypeTrace", CTestProvider::EnableAccPosBasedWrongTypeTrace),

   105 

   106             ENTRY("CancelWithoutTransId" , CTestProvider ::CancelWithoutTransId),     

   107             ENTRY("CancelTransIdPosBased", CTestProvider::CancelTransIdPosBased),    

   108             ENTRY("GetLocationAsyncPosBasedUpdate" , CTestProvider ::GetLocationAsyncPosBasedUpdate),  

   109             ENTRY("GetLocationPosBasedWrongVal", CTestProvider::GetLocationPosBasedWrongVal),        

   110             ENTRY("GetLocationAsyncWrongUpdate" ,CTestProvider::GetLocationAsyncWrongUpdate),           

   111             ENTRY("GetLocPosBasedWrongVal" , CTestProvider ::GetLocPosBasedWrongVal),       

   112             ENTRY("TracePosBasedWrongVal" , CTestProvider ::TracePosBasedWrongVal),    

   113             ENTRY("TracePosBasedUpdateOpts" , CTestProvider ::TracePosBasedUpdateOpts),   

   114             ENTRY("TracePosBasedUpdateWrongVal" , CTestProvider ::TracePosBasedUpdateWrongVal),  

   115             ENTRY("FindDistancePositionBased" ,CTestProvider ::FindDistancePositionBased),  

   116             ENTRY("MoveCoordinatePosBased",CTestProvider::MoveCoordinatePosBased)    

   106 	

   129     TInt cnt;

   118 				;

   141 			        cnt = 0;

   279 	{

   303     {

   280 	__UHEAP_MARK ;

   304     __UHEAP_MARK ;

   281 	TInt start = User::CountAllocCells();

   305     TInt start = User::CountAllocCells();

   282 	RFile LogFile ;

   306     RFile LogFile ;

   283 	RFs LogSession ;

   307     RFs LogSession ;

   284 	TBuf8<50> data ;

   308     TBuf8<50> data ;

   285 	TRealFormat format ;

   309     TRealFormat format ;

   286 	

   310 

   287 	

   311 

   288 	 if(LogSession.Connect() != KErrNone)

   312     if(LogSession.Connect() != KErrNone)

   289 	 {

   313         {

   290 	 	_LIT(KLog , "Failed to connect to file server") ;

   314         _LIT(KLog , "Failed to connect to file server") ;

   291 	 	iLog->Log(KLog) ;

   315         iLog->Log(KLog) ;

   292 	 	return KErrGeneral ;

   316         return KErrGeneral ;

   293 	 }

   317         }

   294 	 

   318 

   295 	 

   319 

   296 

   320 

   297 

   321 

   298 	if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny )  == KErrNotFound)

   322     if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny )  == KErrNotFound)

   299 	{

   323         {

   300 		if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)

   324         if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)

   301 		{

   325             {

   302 		 	_LIT(KLog , "Failed to create notifications log file") ;

   326             _LIT(KLog , "Failed to create notifications log file") ;

   303 		 	iLog->Log(KLog) ;

   327             iLog->Log(KLog) ;

   304 		 	return KErrGeneral ;

   328             return KErrGeneral ;

   305 		}

   329             }

   306 

   330 

   307 	}

   331         }

   308 	

   332 

   309 	_LIT(KLog , "In CTGetLocation") ;

   333     _LIT(KLog , "In CTGetLocation") ;

   310 	iLog->Log(KLog) ;

   334     iLog->Log(KLog) ;

   311 	

   335 

   312    

   336 

   314   

   338 

   318     

   342 

   319     

   343 

   320 

   344 

   321 

   345 

   322 	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

   346     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

   323 	

   347 

   324 

   348 

   325 	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   349     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   326 

   350 

   327 	RCriteriaArray a;

   351     RCriteriaArray a;

   328 	a.AppendL(crit);

   352     a.AppendL(crit);

   329 	

   353 

   330 	ServiceHandler->AttachL(a) ;

   354     ServiceHandler->AttachL(a) ;

   331    

   355 

   332 	

   356 

   333 	

   357 

   334 	

   358 

   335 	

   359 

   336 	

   360 

   337 	

   361 

   338 	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

   362     ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

   339 

   363 

   340 	 

   364 

   341  	 

   365 

   342 

   366 

   343 	TInt pos = 0;

   367     TInt pos = 0;

   344 	

   368 

   345 	const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

   369     const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

   346 	

   370 

   347 	if(!errorprm)

   371     if(!errorprm)

   348 	{

   372         {

   349 		_LIT(Klog , "Success/Failure error code missing from outputlist") ;

   373         _LIT(Klog , "Success/Failure error code missing from outputlist") ;

   350 		iLog->Log(Klog) ;

   374         iLog->Log(Klog) ;

   351 		return KErrGeneral ;

   375         return KErrGeneral ;

   352 	}

   376         }

   353 	

   377 

   354 

   378 

   355 	_LIT8(KDataSource, "ILocation");

   379     _LIT8(KDataSource, "ILocation");

   356 	 

   380 

   357 	 pos = 0 ;

   381     pos = 0 ;

   358 

   382 

   359  	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

   383     const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

   360 	

   384 

   361 	if(!genericparm)

   385     if(!genericparm)

   362 	{

   386         {

   363 		_LIT(KLog , "Interface not found");

   387         _LIT(KLog , "Interface not found");

   364 		iLog->Log(KLog) ;

   388         iLog->Log(KLog) ;

   365 		return KErrGeneral ;

   389         return KErrGeneral ;

   366 	}

   390         }

   367 	

   391 

   368    MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

   392     MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

   369   

   393 

   370   

   394 

   371     

   395 

   373     

   397 

   380     

   404 

   381 	_LIT8(KInterval,"UpdateInterval");

   405     _LIT8(KInterval,"UpdateInterval");

   382 	_LIT8(KTimeout,"UpdateTimeOut");

   406     _LIT8(KTimeout,"UpdateTimeOut");

   383 	_LIT8(KAge,"UpdateMaxAge");

   407     _LIT8(KAge,"UpdateMaxAge");

   384 	_LIT8(KPartial,"PartialUpdates");

   408     _LIT8(KPartial,"PartialUpdates");

   385 	const TInt KTime = 1000000;

   409     const TInt KTime = 1000000;

   386     

   410 

   391     

   415 

   394     

   418 

   395     

   419 

   396     

   420 

   397 	locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);

   421     locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);

   398 	

   422 

   399 	pos = 0 ;

   423     pos = 0 ;

   400 	

   424 

   401 	const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   425     const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   402 	

   426 

   403 	if(!ErrorParm)

   427     if(!ErrorParm)

   404 	{

   428         {

   405 		_LIT(Klog, "Success/Failure state not known") ;

   429         _LIT(Klog, "Success/Failure state not known") ;

   406 		iLog->Log(Klog) ;

   430         iLog->Log(Klog) ;

   407 		return KErrGeneral ;

   431         return KErrGeneral ;

   408 	}

   432         }

   409 	

   433 

   410 	if((ErrorParm->Value()).AsTInt32() )

   434     if((ErrorParm->Value()).AsTInt32() )

   411 	{

   435         {

   412 		_LIT(KLog , "ExecutecmdL failed ");

   436         _LIT(KLog , "ExecutecmdL failed ");

   413 		iLog->Log(KLog) ;

   437         iLog->Log(KLog) ;

   414 		return (ErrorParm->Value()).AsTInt32() ;	

   438         return (ErrorParm->Value()).AsTInt32() ;	

   415 	}

   439         }

   416 	

   440 

   417 

   441 

   418 	

   442 

   419 	    TInt index = 0 ;

   443     TInt index = 0 ;

   420 

   444 

   421 		const TLiwGenericParam *GenericParam  = outputlist->FindFirst(index , KLocationMap);

   445     const TLiwGenericParam *GenericParam  = outputlist->FindFirst(index , KLocationMap);

   422 

   446 

   423 		

   447 

   424 		if(!GenericParam)

   448     if(!GenericParam)

   425 		{

   449         {

   426 			_LIT(Klog, "Out Param not found") ;

   450         _LIT(Klog, "Out Param not found") ;

   427 	    	iLog->Log(Klog) ;

   451         iLog->Log(Klog) ;

   428 			return KErrGeneral ; //Param Error

   452         return KErrGeneral ; //Param Error

   429 		}	

   453         }	

   430 

   454 

   431 		TLiwVariant Variant ;

   455     TLiwVariant Variant ;

   432 

   456 

   433 		Variant = GenericParam->Value() ;

   457     Variant = GenericParam->Value() ;

   434 		const	CLiwMap *LocMap = Variant.AsMap() ;

   458     const	CLiwMap *LocMap = Variant.AsMap() ;

   435 

   459 

   436 		TLiwVariant PosVariant ;

   460     TLiwVariant PosVariant ;

   437 

   461 

   438 		LocMap->FindL(KLongitudeKey , PosVariant) ;

   462     LocMap->FindL(KLongitudeKey , PosVariant) ;

   439 		TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude

   463     TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude

   440 		data.Num(LongData , format) ;

   464     data.Num(LongData , format) ;

   441 		LogFile.Write(_L8("\n")) ;

   465     LogFile.Write(_L8("\n")) ;

   442 		LogFile.Write(_L8("Logitude = ")) ;

   466     LogFile.Write(_L8("Logitude = ")) ;

   443 		LogFile.Write(data) ;

   467     LogFile.Write(data) ;

   444 

   468 

   445 		LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude 

   469     LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude 

   446 

   470 

   447 		TReal64 LatData = (TReal64)PosVariant.AsTReal() ;

   471     TReal64 LatData = (TReal64)PosVariant.AsTReal() ;

   448 		data.Num(LatData , format) ;

   472     data.Num(LatData , format) ;

   449 		LogFile.Write(_L8("   Latitude = ")) ;

   473     LogFile.Write(_L8("   Latitude = ")) ;

   450 		LogFile.Write(data) ;

   474     LogFile.Write(data) ;

   451 

   475 

   452 		LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude

   476     LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude

   453 		TReal32 AltData = PosVariant.AsTReal() ;

   477     TReal32 AltData = PosVariant.AsTReal() ;

   454 		data.Num(AltData , format) ;

   478     data.Num(AltData , format) ;

   455 

   479 

   456 		LogFile.Write(_L8("   Altitude = "))	 ;

   480     LogFile.Write(_L8("   Altitude = "))	 ;

   457 		LogFile.Write(data) ;

   481     LogFile.Write(data) ;

   458 		

   482 

   459 		

   483 

   460 		

   484 

   461 	//Test Calculate

   485     //Test Calculate

   462 		//TBuf8<20>CmdBufSet(KRequestCalculate) ;

   486     //TBuf8<20>CmdBufSet(KRequestCalculate) ;

   463         outputlist->Reset() ;

   487     outputlist->Reset() ;

   464         inputlist->Reset() ;

   465        

   466         //CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;

   467 

   468         TLiwGenericParam requesttype(KMathRequest , TLiwVariant(KRequestDistance)) ;

   469         inputlist->AppendL(requesttype) ;

   470         

   471         

   472 

   473         //Inserting first input param

   474         CLiwMap* SourceCoordinate = CLiwDefaultMap::NewL();

   475         TReal64 slongitude = 71.03;

   476         SourceCoordinate->InsertL(KLongitudeKey,TLiwVariant(slongitude));

   477         TReal64 slatitude = 42.37;

   478         SourceCoordinate->InsertL(KLatitudeKey,TLiwVariant(slatitude));

   479         

   480         TReal64 saltitude = 1;

   481         SourceCoordinate->InsertL(KAltitudeKey,TLiwVariant(saltitude));

   482 

   483 

   484         TLiwGenericParam scoordinate(KDistanceParmSource,TLiwVariant(SourceCoordinate));

   485         inputlist->AppendL(scoordinate) ;

   486         SourceCoordinate->DecRef() ;

   487 

   488 

   489 

   490         //Inserting 2nd input param

   491         CLiwMap* DestCoordinate = CLiwDefaultMap::NewL();

   492         TReal64 dlongitude = 83.02;

   493         DestCoordinate->InsertL(KLongitudeKey,TLiwVariant(dlongitude));

   494         TReal64 dlatitude = 42.42;

   495         DestCoordinate->InsertL(KLatitudeKey,TLiwVariant(dlatitude));

   496         

   497         TReal64 daltitude = 1;

   498         DestCoordinate->InsertL(KAltitudeKey,TLiwVariant(daltitude));

   499 

   500 

   501         TLiwGenericParam dcoordinate(KDistanceParmDestination,TLiwVariant(DestCoordinate));

   502         inputlist->AppendL(dcoordinate) ;

   503         DestCoordinate->DecRef() ;  

   504 

   505         //CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;

   506 

   507 

   508         TBuf8<20>CmdBufSet(KRequestCalculate) ;

   509 

   510         locinterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist);

   511 

   512 

   513         pos = 0;

   514         const TLiwGenericParam* param = outputlist->FindFirst(pos, KErrorCode);

   515 

   516 		if((param->Value()).AsTInt32() )

   517 			{

   518 			_LIT(KLog , "Calculate failed ");

   519 			iLog->Log(KLog) ;

   520 			return (ErrorParm->Value()).AsTInt32() ;	

   521 			}

   522 		

   523 		pos = 0;

   524         const TLiwGenericParam* paramb = outputlist->FindFirst(pos, KErrorCode);

   525 

   526 		if((paramb->Value()).AsTInt32() )

   527 			{

   528 			_LIT(KLog , "Calculate failed ");

   529 			iLog->Log(KLog) ;

   530 			return (paramb->Value()).AsTInt32() ;	

   531 			}

   532         pos = 0;

   533         const TLiwGenericParam* resultparam = outputlist->FindFirst(pos, KMathOpResult);		

   534         TLiwVariant resultvariant = resultparam->Value();

   535         TReal64 distance = resultvariant.AsTReal();

   536 

   537 	//Test Calculate done	

   538 	 

   539 	 LogFile.Close() ;

   540 	 LogSession.Close() ;

   541   

   542 	

   543 	locinterface->Close() ;

   544 	outputlist->Reset() ;

   546     

   489 

   547    	delete ServiceHandler ;

   490     //CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;

   548 	a.ResetAndDestroy() ;

   491 

   549 	a.Close() ;

   492     TLiwGenericParam requesttype(KMathRequest , TLiwVariant(KRequestDistance)) ;

   550 	TInt end = User::CountAllocCells();

   493     inputlist->AppendL(requesttype) ;

   551 	

   494 

   552 __UHEAP_MARKEND ;

   495 

   553    return KErrNone ;

   496 

   554 

   497     //Inserting first input param

   555 

   498     CLiwMap* SourceCoordinate = CLiwDefaultMap::NewL();

   556 

   499     TReal64 slongitude = 71.03;

   557 		

   500     SourceCoordinate->InsertL(KLongitudeKey,TLiwVariant(slongitude));

   558 	}

   501     TReal64 slatitude = 42.37;

   502     SourceCoordinate->InsertL(KLatitudeKey,TLiwVariant(slatitude));

   503 

   504     TReal64 saltitude = 1;

   505     SourceCoordinate->InsertL(KAltitudeKey,TLiwVariant(saltitude));

   506 

   507 

   508     TLiwGenericParam scoordinate(KDistanceParmSource,TLiwVariant(SourceCoordinate));

   509     inputlist->AppendL(scoordinate) ;

   510     SourceCoordinate->DecRef() ;

   511 

   512 

   513 

   514     //Inserting 2nd input param

   515     CLiwMap* DestCoordinate = CLiwDefaultMap::NewL();

   516     TReal64 dlongitude = 83.02;

   517     DestCoordinate->InsertL(KLongitudeKey,TLiwVariant(dlongitude));

   518     TReal64 dlatitude = 42.42;

   519     DestCoordinate->InsertL(KLatitudeKey,TLiwVariant(dlatitude));

   520 

   521     TReal64 daltitude = 1;

   522     DestCoordinate->InsertL(KAltitudeKey,TLiwVariant(daltitude));

   523 

   524 

   525     TLiwGenericParam dcoordinate(KDistanceParmDestination,TLiwVariant(DestCoordinate));

   526     inputlist->AppendL(dcoordinate) ;

   527     DestCoordinate->DecRef() ;  

   528 

   529     //CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;

   530 

   531 

   532     TBuf8<20>CmdBufSet(KRequestCalculate) ;

   533 

   534     locinterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist);

   535 

   536 

   537     pos = 0;

   538     const TLiwGenericParam* param = outputlist->FindFirst(pos, KErrorCode);

   539 

   540     if((param->Value()).AsTInt32() )

   541         {

   542         _LIT(KLog , "Calculate failed ");

   543         iLog->Log(KLog) ;

   544         return (ErrorParm->Value()).AsTInt32() ;	

   545         }

   546 

   547     pos = 0;

   548     const TLiwGenericParam* paramb = outputlist->FindFirst(pos, KErrorCode);

   549 

   550     if((paramb->Value()).AsTInt32() )

   551         {

   552         _LIT(KLog , "Calculate failed ");

   553         iLog->Log(KLog) ;

   554         return (paramb->Value()).AsTInt32() ;	

   555         }

   556     pos = 0;

   557     const TLiwGenericParam* resultparam = outputlist->FindFirst(pos, KMathOpResult);		

   558     TLiwVariant resultvariant = resultparam->Value();

   559     TReal64 distance = resultvariant.AsTReal();

   560 

   561     //Test Calculate done	

   562 

   563     LogFile.Close() ;

   564     LogSession.Close() ;

   565 

   566 

   567     locinterface->Close() ;

   568     outputlist->Reset() ;

   569     inputlist->Reset() ;

   570 

   571     delete ServiceHandler ;

   572     a.ResetAndDestroy() ;

   573     a.Close() ;

   574     TInt end = User::CountAllocCells();

   575 

   576     __UHEAP_MARKEND ;

   577     return KErrNone ;

   578 

   579 

   580 

   581 

   582     }

   560 	{

   584     {

   561 	__UHEAP_MARK;

   585     __UHEAP_MARK;

   562 	

   586 

   563 	CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();

   587     CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();

   583      

   607 

   584      

   608 

   597 	a.Close() ;

   621     a.Close() ;

   598 	

   622     __UHEAP_MARKEND;	

   599 	return KErrNone;

   623 

   600 	__UHEAP_MARKEND;	

   624     return KErrNone;

   601 	}

   625     }

   626 

   603 	{

   628     {

   604 	__UHEAP_MARK;

   629     __UHEAP_MARK;

   605 	ASyncLocCBF callback;

   630     ASyncLocCBF callback;

   606 	CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();

   631     CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();

   626      

   651 

   627      

   652 

   648     

   673 

   649     	TBuf8<20>CmdBuf(KCmdGetLocation) ;

   674     TBuf8<20>CmdBuf(KCmdGetLocation) ;

   650 

   675 

   651 	CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;

   676     CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;

   652 	

   677 

   653 	//Append LocationInformation Category

   678     //Append LocationInformation Category

   654 	TLiwGenericParam informationCategory(KLocationInfoCategory , TLiwVariant(KLocationBasicinfo)) ;

   679     TLiwGenericParam informationCategory(KLocationInfoCategory , TLiwVariant(KLocationBasicinfo)) ;

   655 	InputList->AppendL(informationCategory) ;

   680     InputList->AppendL(informationCategory) ;

   656 	

   681 

   657 	//Appending update options

   682     //Appending update options

   658 	CLiwMap* updateoptionMap = CLiwDefaultMap::NewL();

   683     CLiwMap* updateoptionMap = CLiwDefaultMap::NewL();

   659 	

   684 

   660 	TInt32 updateInterval = 30000;

   685     TInt32 updateInterval = 30000;

   661 	

   686 

   663 	

   688 

   664 	TInt32 updateTimeOut = -10000;

   689     TInt32 updateTimeOut = -10000;

   665 	updateoptionMap->InsertL(KUpdateOptionTimeOut,TLiwVariant(updateTimeOut));

   690     updateoptionMap->InsertL(KUpdateOptionTimeOut,TLiwVariant(updateTimeOut));

   666 	

   691 

   667 	TInt32 updateMaxAge = 2000;

   692     TInt32 updateMaxAge = 2000;

   668 	updateoptionMap->InsertL(KUpdateOptionMaxAge,TLiwVariant(updateMaxAge));

   693     updateoptionMap->InsertL(KUpdateOptionMaxAge,TLiwVariant(updateMaxAge));

   669 	

   694 

   670 	TLiwGenericParam updateOption(KUpdateOptionMap,TLiwVariant(updateoptionMap));

   695     TLiwGenericParam updateOption(KUpdateOptionMap,TLiwVariant(updateoptionMap));

   671 	InputList->AppendL(updateOption) ;

   696     InputList->AppendL(updateOption) ;

   672 	updateoptionMap->DecRef();

   697     updateoptionMap->DecRef();

   673 	

   698 

   674 	CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;

   699     CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;

   675 	

   700 

   676 	

   701 

   677 	locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList,KLiwOptASyncronous,&callback);

   702     locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList,KLiwOptASyncronous,&callback);

   678 

   703 

   679 	

   704 

   680 	

   705 

   681 

   706 

   682 	 pos = 0;

   707     pos = 0;

   683 	const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   708     const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   684 	

   709 

   685 	if(!ErrorParm)

   710     if(!ErrorParm)

   686 		{

   711         {

   687 		

   712 

   688 		return KErrGeneral ;

   713         return KErrGeneral ;

   689 		}

   714         }

   690 	TInt error = (ErrorParm->Value()).AsTInt32();

   715     TInt error = (ErrorParm->Value()).AsTInt32();

   691 	if( SErrBadArgumentType == error )

   716     if( SErrBadArgumentType == error )

   692 		{

   717         {

   693 		error = KErrNone;	

   718         error = KErrNone;	

   694 		

   719 

   695 		

   720 

   696 		}

   721         }

   697 	locinterface->Close() ;

   722     locinterface->Close() ;

   698 	outputlist->Reset() ;

   723     outputlist->Reset() ;

   700    	delete ServiceHandler ;

   725     delete ServiceHandler ;

   701    	delete OutParmList;

   726     delete OutParmList;

   702    	delete InputList;

   727     delete InputList;

   703 	a.ResetAndDestroy() ;

   728     a.ResetAndDestroy() ;

   704 	a.Close() ;

   729     a.Close() ;

   705 	 __UHEAP_MARKEND ;	

   730     __UHEAP_MARKEND ;	

   706 	return error;

   731     return error;

   707 

   732 

   708 

   733 

   709 	

   734 

   710 		

   735 

   711 	}

   736     }

   714 	{

   739     {

   715 	__UHEAP_MARK;

   740     __UHEAP_MARK;

   716 	CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();

   741     CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();

   736      

   761 

   737      

   762 

   758     	TBuf8<20>CmdBuf(KCmdGetLocation) ;

   783     TBuf8<20>CmdBuf(KCmdGetLocation) ;

   759 

   784 

   760 	CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;

   785     CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;

   761 	

   786 

   762 	//Append LocationInformation Category

   787     //Append LocationInformation Category

   763 	TLiwGenericParam informationCategory(KLocationInfoCategory , TLiwVariant(KLocationBasicinfo)) ;

   788     TLiwGenericParam informationCategory(KLocationInfoCategory , TLiwVariant(KLocationBasicinfo)) ;

   764 	InputList->AppendL(informationCategory) ;

   789     InputList->AppendL(informationCategory) ;

   765 	

   790 

   766 	//Appending update options

   791     //Appending update options

   767 	CLiwMap* updateoptionMap = CLiwDefaultMap::NewL();

   792     CLiwMap* updateoptionMap = CLiwDefaultMap::NewL();

   768 	

   793 

   769 	TInt32 updateInterval = 30000;

   794     TInt32 updateInterval = 30000;

   770 	

   795 

   772 	

   797 

   773 	TInt32 updateTimeOut = -10000;

   798     TInt32 updateTimeOut = -10000;

   774 	updateoptionMap->InsertL(KUpdateOptionTimeOut,TLiwVariant(updateTimeOut));

   799     updateoptionMap->InsertL(KUpdateOptionTimeOut,TLiwVariant(updateTimeOut));

   775 	

   800 

   776 	TInt32 updateMaxAge = 2000;

   801     TInt32 updateMaxAge = 2000;

   777 	updateoptionMap->InsertL(KUpdateOptionMaxAge,TLiwVariant(updateMaxAge));

   802     updateoptionMap->InsertL(KUpdateOptionMaxAge,TLiwVariant(updateMaxAge));

   778 	

   803 

   779 	TLiwGenericParam updateOption(KUpdateOptionMap,TLiwVariant(updateoptionMap));

   804     TLiwGenericParam updateOption(KUpdateOptionMap,TLiwVariant(updateoptionMap));

   780 	InputList->AppendL(updateOption) ;

   805     InputList->AppendL(updateOption) ;

   781 	updateoptionMap->DecRef();

   806     updateoptionMap->DecRef();

   782 	

   807 

   783 	CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;

   808     CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;

   784 	

   809 

   785 	

   810 

   786 	

   811 

   787 

   812 

   788 	locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList);

   813     locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList);

   789 	

   814 

   790 

   815 

   791 	 pos = 0;

   816     pos = 0;

   792 	const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   817     const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   793 	

   818 

   794 	if(!ErrorParm)

   819     if(!ErrorParm)

   795 		{

   820         {

   796 		

   821 

   797 		return KErrGeneral ;

   822         return KErrGeneral ;

   798 		}

   823         }

   799 	TInt error = (ErrorParm->Value()).AsTInt32();

   824     TInt error = (ErrorParm->Value()).AsTInt32();

   800 	if( SErrBadArgumentType == error )

   825     if( SErrBadArgumentType == error )

   801 		{

   826         {

   802 		error = KErrNone;	

   827         error = KErrNone;	

   803 		

   828 

   804 		

   829 

   805 		}

   830         }

   806 	locinterface->Close() ;

   831     locinterface->Close() ;

   807    	delete ServiceHandler ;

   832     delete ServiceHandler ;

   808    	delete OutParmList;

   833     delete OutParmList;

   809    	delete InputList;

   834     delete InputList;

   810 	a.ResetAndDestroy() ;

   835     a.ResetAndDestroy() ;

   811 	a.Close() ;

   836     a.Close() ;

   812 	 __UHEAP_MARKEND ;	

   837     __UHEAP_MARKEND ;	

   813 	return error;

   838     return error;

   814 

   839 

   815 

   840 

   816 	

   841 

   817 		

   842 

   818 	}

   843     }

   820 	{

   845     {

   821 	__UHEAP_MARK ;

   846     __UHEAP_MARK ;

   822 	

   847 

   823    

   848 

   825   

   850 

   829     

   854 

   830     

   855 

   831 

   856 

   832 

   857 

   833 	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

   858     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

   834 	

   859 

   835 

   860 

   836 	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   861     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   837 

   862 

   838 	RCriteriaArray a;

   863     RCriteriaArray a;

   839 	a.AppendL(crit);

   864     a.AppendL(crit);

   840 	

   865 

   841 	ServiceHandler->AttachL(a) ;

   866     ServiceHandler->AttachL(a) ;

   842    

   867 

   843 	

   868 

   844 	

   869 

   845 	

   870 

   846 	

   871 

   847 	

   872 

   848 	

   873 

   849 	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

   874     ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

   850 

   875 

   851 	 

   876 

   852  	 

   877 

   853 

   878 

   854 	TInt pos = 0;

   879     TInt pos = 0;

   855 	

   880 

   856 	const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

   881     const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

   857 	

   882 

   858 	if(!errorprm)

   883     if(!errorprm)

   859 	{

   884         {

   860 		

   885 

   861 		return KErrGeneral ;

   886         return KErrGeneral ;

   862 	}

   887         }

   863 	

   888 

   864 

   889 

   865 	_LIT8(KDataSource, "ILocation");

   890     _LIT8(KDataSource, "ILocation");

   866 	 

   891 

   867 	 pos = 0 ;

   892     pos = 0 ;

   868 

   893 

   869  	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

   894     const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

   870 	

   895 

   871 	if(!genericparm)

   896     if(!genericparm)

   872 	{

   897         {

   873 		

   898 

   874 		return KErrGeneral ;

   899         return KErrGeneral ;

   875 	}

   900         }

   876 	

   901 

   877    MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

   902     MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

   878   

   903 

   879   

   904 

   880     

   905 

   882     

   907 

   888     

   913 

   889 	locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);

   914     locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);

   890 	

   915 

   891 	pos = 0 ;

   916     pos = 0 ;

   892 	

   917 

   893 	const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   918     const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   894 	

   919 

   895 	if(!ErrorParm)

   920     if(!ErrorParm)

   896 		{

   921         {

   897 		

   922 

   898 		return KErrGeneral ;

   923         return KErrGeneral ;

   899 		}

   924         }

   900 	TInt error = (ErrorParm->Value()).AsTInt32();

   925     TInt error = (ErrorParm->Value()).AsTInt32();

   901 	if( SErrBadArgumentType == error )

   926     if( SErrBadArgumentType == error )

   902 		{

   927         {

   903 		error = KErrNone;	

   928         error = KErrNone;	

   904 		

   929 

   905 		

   930 

   906 		}

   931         }

   907 	locinterface->Close() ;

   932     locinterface->Close() ;

   908    	delete ServiceHandler ;

   933     delete ServiceHandler ;

   909 	a.ResetAndDestroy() ;

   934     a.ResetAndDestroy() ;

   910 	a.Close() ;

   935     a.Close() ;

   911 	 __UHEAP_MARKEND ;	

   936     __UHEAP_MARKEND ;	

   912 	return error;

   937     return error;

   913 	

   938 

   914 	}

   939     }

   917 	{

   942     {

   918 	__UHEAP_MARK ;

   943     __UHEAP_MARK ;

   919 	TInt start = User::CountAllocCells();

   944     TInt start = User::CountAllocCells();

   920 	ASyncLocCBF callback;

   945     ASyncLocCBF callback;

   921 	

   946 

   922    

   947 

   929     

   980     const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

   930 

   981     if(!genericparm)

   931 

   982         {

   932 	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

   983 

   933 	

   984         return KErrGeneral ;

   934 

   985         }

   935 	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   986 

   936 

   987     MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

   937 	RCriteriaArray a;

   988 

   938 	a.AppendL(crit);

   989 

   939 	

   940 	ServiceHandler->AttachL(a) ;

   941    

   942 	

   943 	

   944 	

   945 	

   946 	

   947 	

   948 	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

   949 

   950 	 

   951  	 

   952 

   953 	TInt pos = 0;

   954 	

   955 	const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

   956 	

   957 	if(!errorprm)

   958 	{

   959 		

   960 		return KErrGeneral ;

   961 	}

   962 	

   963 

   964 	_LIT8(KDataSource, "ILocation");

   965 	 

   966 	 pos = 0 ;

   967 

   968  	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

   969 	

   970 	if(!genericparm)

   971 	{

   972 		

   973 		return KErrGeneral ;

   974 	}

   975 	

   976    MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

   977   

   978   

   979     

   981     

   991 

   988 	locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptASyncronous,&callback);

  1017     //delete inputlist;

   989 	

  1018     //delete outputlist;

   990 	pos = 0 ;

  1019     

   991 	

   992 	const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

   993 	

   994 	if(!ErrorParm)

   995 		{

   996 		

   997 		return KErrGeneral ;

   998 		}

   999 	TInt error = (ErrorParm->Value()).AsTInt32();

  1000 	if( SErrBadArgumentType == error )

  1001 		{

  1002 		error = KErrNone;	

  1003 		

  1004 		

  1005 		}

  1006 	locinterface->Close() ;

  1007 	outputlist->Reset() ;

  1008     inputlist->Reset() ;

  1010 	a.ResetAndDestroy() ;

  1021     a.ResetAndDestroy() ;

  1011 	a.Close() ;

  1022     a.Close() ;

  1012 	TInt end = User::CountAllocCells();

  1023     TInt end = User::CountAllocCells();

  1013 	 __UHEAP_MARKEND ;	

  1024     __UHEAP_MARKEND ;	

  1014 	return error;

  1025     return error;

  1015 	

  1026 

  1016 	}

  1027     }

  1019 {

  1030     {

  1020 __UHEAP_MARK ;

  1031     __UHEAP_MARK ;

  1021 	RFile LogFile ;

  1032     RFile LogFile ;

  1022 	RFs LogSession ;

  1033     RFs LogSession ;

  1023 	TBuf8<50> data ;

  1034     TBuf8<50> data ;

  1024 	TRealFormat format ;

  1035     TRealFormat format ;

  1025 	

  1036 

  1026 	

  1037 

  1027 	 if(LogSession.Connect() != KErrNone)

  1038     if(LogSession.Connect() != KErrNone)

  1028 	 {

  1039         {

  1029 	 	_LIT(KLog , "Failed to connect to file server") ;

  1040         _LIT(KLog , "Failed to connect to file server") ;

  1030 	 	iLog->Log(KLog) ;

  1041         iLog->Log(KLog) ;

  1031 	 	return KErrGeneral ;

  1042         return KErrGeneral ;

  1032 	 }

  1043         }

  1033 	 

  1044 

  1034 	 

  1045 

  1035 

  1046 

  1036 

  1047 

  1037 	if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny )  == KErrNotFound)

  1048     if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny )  == KErrNotFound)

  1038 	{

  1049         {

  1039 		if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)

  1050         if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)

  1040 		{

  1051             {

  1041 		 	_LIT(KLog , "Failed to create notifications log file") ;

  1052             _LIT(KLog , "Failed to create notifications log file") ;

  1042 		 	iLog->Log(KLog) ;

  1053             iLog->Log(KLog) ;

  1043 		 	return KErrGeneral ;

  1054             return KErrGeneral ;

  1044 		}

  1055             }

  1045 

  1056 

  1046 	}

  1057         }

  1047 	

  1058 

  1048 	_LIT(KLog , "In CTGetLocation") ;

  1059     _LIT(KLog , "In CTGetLocation") ;

  1049 	iLog->Log(KLog) ;

  1060     iLog->Log(KLog) ;

  1050 	

  1061 

  1051    

  1062 

  1053   

  1064 

  1057     

  1068 

  1058     

  1069 

  1059 

  1070 

  1060 

  1071 

  1061 	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

  1072     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

  1062 	

  1073 

  1063 

  1074 

  1064 	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  1075     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  1065 

  1076 

  1066 	RCriteriaArray a;

  1077     RCriteriaArray a;

  1067 	a.AppendL(crit);

  1078     a.AppendL(crit);

  1068 	

  1079 

  1069 	ServiceHandler->AttachL(a) ;

  1080     ServiceHandler->AttachL(a) ;

  1070    

  1081 

  1071 	

  1082 

  1072 	

  1083 

  1073 	

  1084 

  1074 	

  1085 

  1075 	

  1086 

  1076 	

  1087 

  1077 	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

  1088     ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

  1078 

  1089 

  1079 	 

  1090 

  1080  	 

  1091 

  1081 

  1092 

  1082 	TInt pos = 0;

  1093     TInt pos = 0;

  1083 	

  1094 

  1084 	const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

  1095     const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

  1085 	

  1096 

  1086 	if(!errorprm)

  1097     if(!errorprm)

  1087 	{

  1098         {

  1088 		_LIT(Klog , "Success/Failure error code missing from outputlist") ;

  1099         _LIT(Klog , "Success/Failure error code missing from outputlist") ;

  1089 		iLog->Log(Klog) ;

  1100         iLog->Log(Klog) ;

  1090 		return KErrGeneral ;

  1101         return KErrGeneral ;

  1091 	}

  1102         }

  1092 	

  1103 

  1093 

  1104 

  1094 	_LIT8(KDataSource, "ILocation");

  1105     _LIT8(KDataSource, "ILocation");

  1095 	 

  1106 

  1096 	 pos = 0 ;

  1107     pos = 0 ;

  1097 

  1108 

  1098  	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

  1109     const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

  1099 	

  1110 

  1100 	if(!genericparm)

  1111     if(!genericparm)

  1101 	{

  1112         {

  1102 		_LIT(KLog , "Interface not found");

  1113         _LIT(KLog , "Interface not found");

  1103 		iLog->Log(KLog) ;

  1114         iLog->Log(KLog) ;

  1104 		return KErrGeneral ;

  1115         return KErrGeneral ;

  1105 	}

  1116         }

  1106 	

  1117 

  1107    MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

  1118     MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

  1108   

  1119 

  1109   

  1120 

  1110     

  1121 

  1112     

  1123 

  1119     

  1130 

  1120 	_LIT8(KInterval,"UpdateInterval");

  1131     _LIT8(KInterval,"UpdateInterval");

  1121 	_LIT8(KTimeout,"UpdateTimeOut");

  1132     _LIT8(KTimeout,"UpdateTimeOut");

  1122 	_LIT8(KAge,"UpdateMaxAge");

  1133     _LIT8(KAge,"UpdateMaxAge");

  1123 	_LIT8(KPartial,"PartialUpdates");

  1134     _LIT8(KPartial,"PartialUpdates");

  1124 	const TInt KTime = 1000000;

  1135     const TInt KTime = 1000000;

  1125     

  1136 

  1130     

  1141 

  1133     

  1144 

  1134     

  1145 

  1135     

  1146 

  1136 	locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);

  1147     locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);

  1137 	

  1148 

  1138 	pos = 0 ;

  1149     pos = 0 ;

  1139 	

  1150 

  1140 	const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

  1151     const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

  1141 	

  1152 

  1142 	if(!ErrorParm)

  1153     if(!ErrorParm)

  1143 	{

  1154         {

  1144 		_LIT(Klog, "Success/Failure state not known") ;

  1155         _LIT(Klog, "Success/Failure state not known") ;

  1145 		iLog->Log(Klog) ;

  1156         iLog->Log(Klog) ;

  1146 		return KErrGeneral ;

  1157         return KErrGeneral ;

  1147 	}

  1158         }

  1148 	

  1159 

  1149 	if((ErrorParm->Value()).AsTInt32() )

  1160     if((ErrorParm->Value()).AsTInt32() )

  1150 	{

  1161         {

  1151 		_LIT(KLog , "ExecutecmdL failed ");

  1162         _LIT(KLog , "ExecutecmdL failed ");

  1152 		iLog->Log(KLog) ;

  1163         iLog->Log(KLog) ;

  1153 		//return (ErrorParm->Value()).AsTInt32() ;	

  1164         //return (ErrorParm->Value()).AsTInt32() ;	

  1154 	}

  1165         }

  1155 	

  1166 

  1156 

  1167 

  1157 	

  1168 

  1158 	    TInt index = 0 ;

  1169     TInt index = 0 ;

  1159 

  1170 

  1160 		const TLiwGenericParam *GenericParam  = outputlist->FindFirst(index , KLocationMap);

  1171     const TLiwGenericParam *GenericParam  = outputlist->FindFirst(index , KLocationMap);

  1161 

  1172 

  1162 		

  1173 

  1163 		if(!GenericParam)

  1174     if(!GenericParam)

  1164 		{

  1175         {

  1165 			_LIT(Klog, "Out Param not found") ;

  1176         _LIT(Klog, "Out Param not found") ;

  1166 	    	iLog->Log(Klog) ;

  1177         iLog->Log(Klog) ;

  1167 			return KErrGeneral ; //Param Error

  1178         return KErrGeneral ; //Param Error

  1168 		}	

  1179         }	

  1169 

  1180 

  1170 		TLiwVariant Variant ;

  1181     TLiwVariant Variant ;

  1171 

  1182 

  1172 		Variant = GenericParam->Value() ;

  1183     Variant = GenericParam->Value() ;

  1173 		const	CLiwMap *LocMap = Variant.AsMap() ;

  1184     const	CLiwMap *LocMap = Variant.AsMap() ;

  1174 

  1185 

  1175 		TLiwVariant PosVariant ;

  1186     TLiwVariant PosVariant ;

  1176 

  1187 

  1177 		LocMap->FindL(KLongitudeKey , PosVariant) ;

  1188     LocMap->FindL(KLongitudeKey , PosVariant) ;

  1178 		TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude

  1189     TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude

  1179 		data.Num(LongData , format) ;

  1190     data.Num(LongData , format) ;

  1180 		LogFile.Write(_L8("\n")) ;

  1191     LogFile.Write(_L8("\n")) ;

  1181 		LogFile.Write(_L8("Logitude = ")) ;

  1192     LogFile.Write(_L8("Logitude = ")) ;

  1182 		LogFile.Write(data) ;

  1193     LogFile.Write(data) ;

  1183 

  1194 

  1184 		LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude 

  1195     LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude 

  1185 

  1196 

  1186 		TReal64 LatData = (TReal64)PosVariant.AsTReal() ;

  1197     TReal64 LatData = (TReal64)PosVariant.AsTReal() ;

  1187 		data.Num(LatData , format) ;

  1198     data.Num(LatData , format) ;

  1188 		LogFile.Write(_L8("   Latitude = ")) ;

  1199     LogFile.Write(_L8("   Latitude = ")) ;

  1189 		LogFile.Write(data) ;

  1200     LogFile.Write(data) ;

  1190 

  1201 

  1191 		LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude

  1202     LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude

  1192 		TReal32 AltData = PosVariant.AsTReal() ;

  1203     TReal32 AltData = PosVariant.AsTReal() ;

  1193 		data.Num(AltData , format) ;

  1204     data.Num(AltData , format) ;

  1194 

  1205 

  1195 		LogFile.Write(_L8("   Altitude = "))	 ;

  1206     LogFile.Write(_L8("   Altitude = "))	 ;

  1196 		LogFile.Write(data) ;

  1207     LogFile.Write(data) ;

  1197 	 

  1208 

  1198 	 LogFile.Close() ;

  1209     LogFile.Close() ;

  1199 	 LogSession.Close() ;

  1210     LogSession.Close() ;

  1200   

  1211 

  1201 	locinterface->Close() ;

  1212     locinterface->Close() ;

  1202    	delete ServiceHandler ;

  1213     delete ServiceHandler ;

  1203 	a.ResetAndDestroy() ;

  1214     a.ResetAndDestroy() ;

  1204 	a.Close() ;

  1215     a.Close() ;

  1205 	

  1216 

  1206 __UHEAP_MARKEND ;

  1217     __UHEAP_MARKEND ;

  1207    return KErrNone ;

  1218     return KErrNone ;

  1208 

  1219 

  1209 

  1220 

  1210 

  1221 

  1211 }

  1222     }

  1214 {

  1225     {

  1215 __UHEAP_MARK ;

  1226     __UHEAP_MARK ;

  1216 	RFile LogFile ;

  1227     RFile LogFile ;

  1217 	RFs LogSession ;

  1228     RFs LogSession ;

  1218 	TBuf8<50> data ;

  1229     TBuf8<50> data ;

  1219 	TRealFormat format ;

  1230     TRealFormat format ;

  1220 	

  1231 

  1221 	

  1232 

  1222 	 if(LogSession.Connect() != KErrNone)

  1233     if(LogSession.Connect() != KErrNone)

  1223 	 {

  1234         {

  1224 	 	_LIT(KLog , "Failed to connect to file server") ;

  1235         _LIT(KLog , "Failed to connect to file server") ;

  1225 	 	iLog->Log(KLog) ;

  1236         iLog->Log(KLog) ;

  1226 	 	return KErrGeneral ;

  1237         return KErrGeneral ;

  1227 	 }

  1238         }

  1228 	 

  1239 

  1229 	 

  1240 

  1230 

  1241 

  1231 

  1242 

  1232 	if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny )  == KErrNotFound)

  1243     if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny )  == KErrNotFound)

  1233 	{

  1244         {

  1234 		if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)

  1245         if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)

  1235 		{

  1246             {

  1236 		 	_LIT(KLog , "Failed to create notifications log file") ;

  1247             _LIT(KLog , "Failed to create notifications log file") ;

  1237 		 	iLog->Log(KLog) ;

  1248             iLog->Log(KLog) ;

  1238 		 	return KErrGeneral ;

  1249             return KErrGeneral ;

  1239 		}

  1250             }

  1240 

  1251 

  1241 	}

  1252         }

  1242 	

  1253 

  1243 	_LIT(KLog , "In CTGetLocation") ;

  1254     _LIT(KLog , "In CTGetLocation") ;

  1244 	iLog->Log(KLog) ;

  1255     iLog->Log(KLog) ;

  1245 	

  1256 

  1246    

  1257 

  1248   

  1259 

  1252     

  1263 

  1253     

  1264 

  1254 

  1265 

  1255 

  1266 

  1256 	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

  1267     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

  1257 	

  1268 

  1258 

  1269 

  1259 	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  1270     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  1260 

  1271