--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sapi_location/tsrc/dev/tlocationprovidertest/src/tcompluginblocks.cpp Mon Mar 30 12:51:10 2009 +0300
@@ -0,0 +1,4456 @@
+/*
+* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: ?Description
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include <e32svr.h>
+#include <StifParser.h>
+#include <Stiftestinterface.h>
+#include <LbsRequestor.h>
+#include <LiwServiceHandler.h>
+#include <LiwCommon.h>
+#include <lbs.h>
+
+#include "Tcomplugin.h"
+
+using namespace LIW;
+
+_LIT(LogFileName , "C:\\Notifications.txt") ;
+
+//----------------------------------------------------------------------------
+// CTestProvider :: Delete()
+//----------------------------------------------------------------------------
+void CTestProvider::Delete()
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// CTestProvider::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CTestProvider::RunMethodL(
+ CStifItemParser& aItem )
+ {
+
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ // Copy this line for every implemented function.
+ // First string is the function name used in TestScripter script file.
+ // Second is the actual implementation member function.
+ ENTRY("GetLocation" , CTestProvider :: GetLocation),
+ ENTRY("LocationUpdates" , CTestProvider :: LocationUpdates),
+ ENTRY("GetLocationAsynch" , CTestProvider :: GetLocationAsynch),
+ ENTRY("ServiceFailed" , CTestProvider :: ServiceFailed),
+ ENTRY("ServiceNotAvailable" , CTestProvider :: ServiceNotAvailable),
+ ENTRY("StraySignalTrace" , CTestProvider :: StraySignal),
+ ENTRY("StraySignalGetLoc" , CTestProvider :: StraySignalGetLoc),
+ ENTRY("ConcurrentCallsGetLoc" , CTestProvider:: ConcurrentCallsGetLoc),
+ ENTRY("ConcurrentCallsTrace" , CTestProvider:: ConcurrentCallsTrace),
+ ENTRY("EmptyCancelTraceTest" , CTestProvider:: EmptyCancelTraceTest),
+ ENTRY("EmptyCancelGetLocTest" , CTestProvider:: EmptyCancelGetLocTest),
+ ENTRY("CancelWrongNotification1" , CTestProvider:: CancelWrongNotification1),
+ ENTRY("CancelWrongNotification2" , CTestProvider:: CancelWrongNotification2),
+ ENTRY("GetLocationCancel" , CTestProvider:: GetLocationCancel),
+ ENTRY("TraceLocationCancel" , CTestProvider:: TraceLocationCancel),
+ ENTRY("GetLocationTimedOut" , CTestProvider :: GetLocationTimedOut ),
+ ENTRY("BearingToTest" , CTestProvider :: BearingToTest),
+ ENTRY("FindDistance" , CTestProvider :: FindDistance),
+ ENTRY("FindDistanceAgain" , CTestProvider :: FindDistanceAgain),
+ ENTRY("GetLocationUpdateOpts" , CTestProvider :: GetLocationUpdateOpts),
+ ENTRY("MoveCoordinates" , CTestProvider :: MoveCoordinates),
+ ENTRY("GetLocationSynchWrongUpdateMapType" , CTestProvider :: GetLocationSynchWrongUpdateMapType),
+ ENTRY("CancelWithInvalidTransId" , CTestProvider ::CancelWithInvalidTransId),
+ ENTRY("getlocationPostionbased" , CTestProvider :: getlocationPostionbased),
+ ENTRY("getlocationPostionbasedwithupdateoption" , CTestProvider ::getlocationPostionbasedwithupdateoption),
+ ENTRY("getlocationPostionbasedpdateoption" , CTestProvider :: getlocationPostionbasedpdateoption),
+
+ ENTRY("GetLocationWrongInfoClass" , CTestProvider :: GetLocationWrongInfoClass),
+ ENTRY("TraceWrongInfoClass" , CTestProvider :: TraceWrongInfoClass),
+ ENTRY("GetLocNegativeUpdateoption" , CTestProvider :: GetLocNegativeUpdateoption),
+ ENTRY("TraceNegativeUpdateoption" , CTestProvider :: TraceNegativeUpdateoption),
+ ENTRY("TestWrongInterfaceName" , CTestProvider :: TestWrongInterfaceName),
+ ENTRY("TestAllApi" , CTestProvider :: TestAllApi),
+ ENTRY("CancelTwice" , CTestProvider :: CancelTwice),
+
+
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+
+
+ class ASyncLocCBF : public MLiwNotifyCallback
+{
+
+ public :
+ TInt iRetStatus ;
+
+ TInt HandleNotifyL(
+ TInt aCmdId,
+ TInt aEventId,
+ CLiwGenericParamList& aEventParamList,
+ const CLiwGenericParamList& aInParamList) ;
+
+ ASyncLocCBF() : iRetStatus(KErrGeneral) //Default constructor
+ {
+ ;
+ }
+
+};
+TInt ASyncLocCBF::HandleNotifyL(
+ TInt aCmdId,
+ TInt aEventId,
+ CLiwGenericParamList& aEventParamList,
+ const CLiwGenericParamList& aInParamList)
+{
+ return 0;
+}
+
+
+TInt CTestProvider :: CancelTwice( CStifItemParser& /*aItem*/ )
+{
+__UHEAP_MARK ;
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ ASyncLocCBF* callBack = new(ELeave) ASyncLocCBF;
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptASyncronous, callBack);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ return KErrGeneral ;
+ }
+
+ TInt reqerror = (ErrorParm->Value()).AsTInt32();
+
+ pos = 0;
+
+ _LIT8(KTransactionId, "TransactionID");
+ const TLiwGenericParam *transid = outputlist->FindFirst(pos ,KTransactionId ) ;
+ if(!transid)
+ {
+ return KErrGeneral;
+ }
+ TInt32 trid = (transid->Value()).AsTInt32();
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+
+
+ inputlist->AppendL(TLiwGenericParam(KTransactionId,TLiwVariant(trid)));
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptCancel);
+
+ ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ return KErrGeneral ;
+ }
+
+ reqerror = (ErrorParm->Value()).AsTInt32();
+
+ /*if( SErrNotFound == reqerror )
+ {
+ reqerror = 0;
+ }*/
+
+ //Call cancel again with same transaction id
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+
+
+ inputlist->AppendL(TLiwGenericParam(KTransactionId,TLiwVariant(trid-2)));
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptCancel);
+
+ ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ return KErrGeneral ;
+ }
+
+ reqerror = (ErrorParm->Value()).AsTInt32();
+
+ if( SErrNotFound == reqerror )
+ {
+ reqerror = 0;
+ }
+
+
+
+
+
+
+ locinterface->Close() ;
+ inputlist->Reset();
+ outputlist->Reset();
+ delete callBack;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+ __UHEAP_MARKEND ;
+ return reqerror ;
+
+
+
+
+}
+TInt CTestProvider :: TestAllApi( CStifItemParser& /*aItem*/ )
+ {
+ __UHEAP_MARK ;
+ TInt start = User::CountAllocCells();
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> data ;
+ TRealFormat format ;
+
+
+ if(LogSession.Connect() != KErrNone)
+ {
+ _LIT(KLog , "Failed to connect to file server") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+
+
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)
+ {
+ _LIT(KLog , "Failed to create notifications log file") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ }
+
+ _LIT(KLog , "In CTGetLocation") ;
+ iLog->Log(KLog) ;
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+
+
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ _LIT(Klog , "Success/Failure error code missing from outputlist") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+ _LIT(KLog , "Interface not found");
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ _LIT(KClass,"GenericLocationInfo");
+ inputlist->AppendL( TLiwGenericParam( KNullDesC8,TLiwVariant(KClass ) ) );
+ //inputlist->AppendL(TLiwGenericParam(NULL));
+ CLiwDefaultMap* updatemap = CLiwDefaultMap::NewL();
+
+ _LIT8(KInterval,"UpdateInterval");
+ _LIT8(KTimeout,"UpdateTimeOut");
+ _LIT8(KAge,"UpdateMaxAge");
+ _LIT8(KPartial,"PartialUpdates");
+ const TInt KTime = 1000000;
+
+ updatemap->InsertL(KInterval , TLiwVariant(TInt32(2*KTime)));
+ updatemap->InsertL(KTimeout , TLiwVariant(TInt32(30*KTime)));
+ updatemap->InsertL(KAge , TLiwVariant(TInt32(0)));
+ updatemap->InsertL(KPartial , TLiwVariant(TBool(FALSE)));
+
+ inputlist->AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(updatemap)));
+ updatemap->DecRef();
+
+
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ _LIT(Klog, "Success/Failure state not known") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+ if((ErrorParm->Value()).AsTInt32() )
+ {
+ _LIT(KLog , "ExecutecmdL failed ");
+ iLog->Log(KLog) ;
+ return (ErrorParm->Value()).AsTInt32() ;
+ }
+
+
+
+ TInt index = 0 ;
+
+ const TLiwGenericParam *GenericParam = outputlist->FindFirst(index , KLocationMap);
+
+
+ if(!GenericParam)
+ {
+ _LIT(Klog, "Out Param not found") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ; //Param Error
+ }
+
+ TLiwVariant Variant ;
+
+ Variant = GenericParam->Value() ;
+ const CLiwMap *LocMap = Variant.AsMap() ;
+
+ TLiwVariant PosVariant ;
+
+ LocMap->FindL(KLongitudeKey , PosVariant) ;
+ TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude
+ data.Num(LongData , format) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Write(_L8("Logitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude
+
+ TReal64 LatData = (TReal64)PosVariant.AsTReal() ;
+ data.Num(LatData , format) ;
+ LogFile.Write(_L8(" Latitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude
+ TReal32 AltData = PosVariant.AsTReal() ;
+ data.Num(AltData , format) ;
+
+ LogFile.Write(_L8(" Altitude = ")) ;
+ LogFile.Write(data) ;
+
+
+
+ //Test Calculate
+ //TBuf8<20>CmdBufSet(KRequestCalculate) ;
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+
+ //CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ TLiwGenericParam requesttype(KMathRequest , TLiwVariant(KRequestDistance)) ;
+ inputlist->AppendL(requesttype) ;
+
+
+
+ //Inserting first input param
+ CLiwMap* SourceCoordinate = CLiwDefaultMap::NewL();
+ TReal64 slongitude = 71.03;
+ SourceCoordinate->InsertL(KLongitudeKey,TLiwVariant(slongitude));
+ TReal64 slatitude = 42.37;
+ SourceCoordinate->InsertL(KLatitudeKey,TLiwVariant(slatitude));
+
+ TReal64 saltitude = 1;
+ SourceCoordinate->InsertL(KAltitudeKey,TLiwVariant(saltitude));
+
+
+ TLiwGenericParam scoordinate(KDistanceParmSource,TLiwVariant(SourceCoordinate));
+ inputlist->AppendL(scoordinate) ;
+ SourceCoordinate->DecRef() ;
+
+
+
+ //Inserting 2nd input param
+ CLiwMap* DestCoordinate = CLiwDefaultMap::NewL();
+ TReal64 dlongitude = 83.02;
+ DestCoordinate->InsertL(KLongitudeKey,TLiwVariant(dlongitude));
+ TReal64 dlatitude = 42.42;
+ DestCoordinate->InsertL(KLatitudeKey,TLiwVariant(dlatitude));
+
+ TReal64 daltitude = 1;
+ DestCoordinate->InsertL(KAltitudeKey,TLiwVariant(daltitude));
+
+
+ TLiwGenericParam dcoordinate(KDistanceParmDestination,TLiwVariant(DestCoordinate));
+ inputlist->AppendL(dcoordinate) ;
+ DestCoordinate->DecRef() ;
+
+ //CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+
+
+ TBuf8<20>CmdBufSet(KRequestCalculate) ;
+
+ locinterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist);
+
+
+ pos = 0;
+ const TLiwGenericParam* param = outputlist->FindFirst(pos, KErrorCode);
+
+ if((param->Value()).AsTInt32() )
+ {
+ _LIT(KLog , "Calculate failed ");
+ iLog->Log(KLog) ;
+ return (ErrorParm->Value()).AsTInt32() ;
+ }
+
+ pos = 0;
+ const TLiwGenericParam* paramb = outputlist->FindFirst(pos, KErrorCode);
+
+ if((paramb->Value()).AsTInt32() )
+ {
+ _LIT(KLog , "Calculate failed ");
+ iLog->Log(KLog) ;
+ return (paramb->Value()).AsTInt32() ;
+ }
+ pos = 0;
+ const TLiwGenericParam* resultparam = outputlist->FindFirst(pos, KMathOpResult);
+ TLiwVariant resultvariant = resultparam->Value();
+ TReal64 distance = resultvariant.AsTReal();
+
+ //Test Calculate done
+
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+
+ locinterface->Close() ;
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ TInt end = User::CountAllocCells();
+
+__UHEAP_MARKEND ;
+ return KErrNone ;
+
+
+
+
+ }
+TInt CTestProvider :: TestWrongInterfaceName( CStifItemParser& /*aItem*/ )
+ {
+ __UHEAP_MARK;
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+ _LIT8(KServicename,"abc");
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KServicename);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ //return KErrGeneral ;
+ }
+ TInt error = (errorprm->Value()).AsTInt32();
+ delete ServiceHandler;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+ return KErrNone;
+ __UHEAP_MARKEND;
+ }
+TInt CTestProvider :: TraceNegativeUpdateoption( CStifItemParser& /*aItem*/ )
+ {
+ __UHEAP_MARK;
+ ASyncLocCBF callback;
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ //Append LocationInformation Category
+ TLiwGenericParam informationCategory(KLocationInfoCategory , TLiwVariant(KLocationBasicinfo)) ;
+ InputList->AppendL(informationCategory) ;
+
+ //Appending update options
+ CLiwMap* updateoptionMap = CLiwDefaultMap::NewL();
+
+ TInt32 updateInterval = 30000;
+
+ updateoptionMap->InsertL(KUpdateOptionInterval,TLiwVariant(updateInterval));
+
+ TInt32 updateTimeOut = -10000;
+ updateoptionMap->InsertL(KUpdateOptionTimeOut,TLiwVariant(updateTimeOut));
+
+ TInt32 updateMaxAge = 2000;
+ updateoptionMap->InsertL(KUpdateOptionMaxAge,TLiwVariant(updateMaxAge));
+
+ TLiwGenericParam updateOption(KUpdateOptionMap,TLiwVariant(updateoptionMap));
+ InputList->AppendL(updateOption) ;
+ updateoptionMap->DecRef();
+
+ CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+
+
+ locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList,KLiwOptASyncronous,&callback);
+
+
+
+
+ pos = 0;
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+
+ return KErrGeneral ;
+ }
+ TInt error = (ErrorParm->Value()).AsTInt32();
+ if( SErrBadArgumentType == error )
+ {
+ error = KErrNone;
+
+
+ }
+ locinterface->Close() ;
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ delete ServiceHandler ;
+ delete OutParmList;
+ delete InputList;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ __UHEAP_MARKEND ;
+ return error;
+
+
+
+
+ }
+
+TInt CTestProvider :: GetLocNegativeUpdateoption( CStifItemParser& /*aItem*/ )
+ {
+ __UHEAP_MARK;
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ //Append LocationInformation Category
+ TLiwGenericParam informationCategory(KLocationInfoCategory , TLiwVariant(KLocationBasicinfo)) ;
+ InputList->AppendL(informationCategory) ;
+
+ //Appending update options
+ CLiwMap* updateoptionMap = CLiwDefaultMap::NewL();
+
+ TInt32 updateInterval = 30000;
+
+ updateoptionMap->InsertL(KUpdateOptionInterval,TLiwVariant(updateInterval));
+
+ TInt32 updateTimeOut = -10000;
+ updateoptionMap->InsertL(KUpdateOptionTimeOut,TLiwVariant(updateTimeOut));
+
+ TInt32 updateMaxAge = 2000;
+ updateoptionMap->InsertL(KUpdateOptionMaxAge,TLiwVariant(updateMaxAge));
+
+ TLiwGenericParam updateOption(KUpdateOptionMap,TLiwVariant(updateoptionMap));
+ InputList->AppendL(updateOption) ;
+ updateoptionMap->DecRef();
+
+ CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+
+
+
+
+ locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList);
+
+
+ pos = 0;
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+
+ return KErrGeneral ;
+ }
+ TInt error = (ErrorParm->Value()).AsTInt32();
+ if( SErrBadArgumentType == error )
+ {
+ error = KErrNone;
+
+
+ }
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ delete OutParmList;
+ delete InputList;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ __UHEAP_MARKEND ;
+ return error;
+
+
+
+
+ }
+TInt CTestProvider :: GetLocationWrongInfoClass( CStifItemParser& /*aItem*/ )
+ {
+ __UHEAP_MARK ;
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+
+
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ _LIT8(KClass,"LocationInformationClass");
+ _LIT(KClassArg,"Invalid");
+ inputlist->AppendL(TLiwGenericParam(KClass,TLiwVariant(KClassArg)));
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+
+ return KErrGeneral ;
+ }
+ TInt error = (ErrorParm->Value()).AsTInt32();
+ if( SErrBadArgumentType == error )
+ {
+ error = KErrNone;
+
+
+ }
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ __UHEAP_MARKEND ;
+ return error;
+
+ }
+
+TInt CTestProvider :: TraceWrongInfoClass( CStifItemParser& /*aItem*/ )
+ {
+ __UHEAP_MARK ;
+ TInt start = User::CountAllocCells();
+ ASyncLocCBF callback;
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+
+
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdTraceLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ _LIT8(KClass,"LocationInformationClass");
+ _LIT(KClassArg,"Invalid");
+ inputlist->AppendL(TLiwGenericParam(KClass,TLiwVariant(KClassArg)));
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptASyncronous,&callback);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+
+ return KErrGeneral ;
+ }
+ TInt error = (ErrorParm->Value()).AsTInt32();
+ if( SErrBadArgumentType == error )
+ {
+ error = KErrNone;
+
+
+ }
+ locinterface->Close() ;
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ TInt end = User::CountAllocCells();
+ __UHEAP_MARKEND ;
+ return error;
+
+ }
+
+TInt CTestProvider :: getlocationPostionbasedpdateoption( CStifItemParser& /*aItem*/ )
+{
+__UHEAP_MARK ;
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> data ;
+ TRealFormat format ;
+
+
+ if(LogSession.Connect() != KErrNone)
+ {
+ _LIT(KLog , "Failed to connect to file server") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+
+
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)
+ {
+ _LIT(KLog , "Failed to create notifications log file") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ }
+
+ _LIT(KLog , "In CTGetLocation") ;
+ iLog->Log(KLog) ;
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+
+
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ _LIT(Klog , "Success/Failure error code missing from outputlist") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+ _LIT(KLog , "Interface not found");
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ _LIT(KClass,"GenericLocationInfo");
+ inputlist->AppendL( TLiwGenericParam( KNullDesC8,TLiwVariant( ) ) );
+ //inputlist->AppendL(TLiwGenericParam(NULL));
+ CLiwDefaultMap* updatemap = CLiwDefaultMap::NewL();
+
+ _LIT8(KInterval,"UpdateInterval");
+ _LIT8(KTimeout,"UpdateTimeOut");
+ _LIT8(KAge,"UpdateMaxAge");
+ _LIT8(KPartial,"PartialUpdates");
+ const TInt KTime = 1000000;
+
+ updatemap->InsertL(KInterval , TLiwVariant(TInt32(2*KTime)));
+ updatemap->InsertL(KTimeout , TLiwVariant(TInt32(30*KTime)));
+ updatemap->InsertL(KAge , TLiwVariant(TInt32(0)));
+ updatemap->InsertL(KPartial , TLiwVariant(TBool(FALSE)));
+
+ inputlist->AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(updatemap)));
+ updatemap->DecRef();
+
+
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ _LIT(Klog, "Success/Failure state not known") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+ if((ErrorParm->Value()).AsTInt32() )
+ {
+ _LIT(KLog , "ExecutecmdL failed ");
+ iLog->Log(KLog) ;
+ //return (ErrorParm->Value()).AsTInt32() ;
+ }
+
+
+
+ TInt index = 0 ;
+
+ const TLiwGenericParam *GenericParam = outputlist->FindFirst(index , KLocationMap);
+
+
+ if(!GenericParam)
+ {
+ _LIT(Klog, "Out Param not found") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ; //Param Error
+ }
+
+ TLiwVariant Variant ;
+
+ Variant = GenericParam->Value() ;
+ const CLiwMap *LocMap = Variant.AsMap() ;
+
+ TLiwVariant PosVariant ;
+
+ LocMap->FindL(KLongitudeKey , PosVariant) ;
+ TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude
+ data.Num(LongData , format) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Write(_L8("Logitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude
+
+ TReal64 LatData = (TReal64)PosVariant.AsTReal() ;
+ data.Num(LatData , format) ;
+ LogFile.Write(_L8(" Latitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude
+ TReal32 AltData = PosVariant.AsTReal() ;
+ data.Num(AltData , format) ;
+
+ LogFile.Write(_L8(" Altitude = ")) ;
+ LogFile.Write(data) ;
+
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+__UHEAP_MARKEND ;
+ return KErrNone ;
+
+
+
+}
+
+TInt CTestProvider :: getlocationPostionbasedwithupdateoption( CStifItemParser& /*aItem*/ )
+{
+__UHEAP_MARK ;
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> data ;
+ TRealFormat format ;
+
+
+ if(LogSession.Connect() != KErrNone)
+ {
+ _LIT(KLog , "Failed to connect to file server") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+
+
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)
+ {
+ _LIT(KLog , "Failed to create notifications log file") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ }
+
+ _LIT(KLog , "In CTGetLocation") ;
+ iLog->Log(KLog) ;
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+
+
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ _LIT(Klog , "Success/Failure error code missing from outputlist") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+ _LIT(KLog , "Interface not found");
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ _LIT(KClass,"GenericLocationInfo");
+ inputlist->AppendL( TLiwGenericParam( KNullDesC8,TLiwVariant( KClass ) ) );
+ CLiwDefaultMap* updatemap = CLiwDefaultMap::NewL();
+
+ _LIT8(KInterval,"UpdateInterval");
+ _LIT8(KTimeout,"UpdateTimeOut");
+ _LIT8(KAge,"UpdateMaxAge");
+ _LIT8(KPartial,"PartialUpdates");
+ const TInt KTime = 1000000;
+
+ updatemap->InsertL(KInterval , TLiwVariant(TInt32(2*KTime)));
+ updatemap->InsertL(KTimeout , TLiwVariant(TInt32(30*KTime)));
+ updatemap->InsertL(KAge , TLiwVariant(TInt32(0)));
+ updatemap->InsertL(KPartial , TLiwVariant(TBool(FALSE)));
+
+ inputlist->AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(updatemap)));
+ updatemap->DecRef();
+
+
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ _LIT(Klog, "Success/Failure state not known") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+ if((ErrorParm->Value()).AsTInt32() )
+ {
+ _LIT(KLog , "ExecutecmdL failed ");
+ iLog->Log(KLog) ;
+ return (ErrorParm->Value()).AsTInt32() ;
+ }
+
+
+
+ TInt index = 0 ;
+
+ const TLiwGenericParam *GenericParam = outputlist->FindFirst(index , KLocationMap);
+
+
+ if(!GenericParam)
+ {
+ _LIT(Klog, "Out Param not found") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ; //Param Error
+ }
+
+ TLiwVariant Variant ;
+
+ Variant = GenericParam->Value() ;
+ const CLiwMap *LocMap = Variant.AsMap() ;
+
+ TLiwVariant PosVariant ;
+
+ LocMap->FindL(KLongitudeKey , PosVariant) ;
+ TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude
+ data.Num(LongData , format) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Write(_L8("Logitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude
+
+ TReal64 LatData = (TReal64)PosVariant.AsTReal() ;
+ data.Num(LatData , format) ;
+ LogFile.Write(_L8(" Latitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude
+ TReal32 AltData = PosVariant.AsTReal() ;
+ data.Num(AltData , format) ;
+
+ LogFile.Write(_L8(" Altitude = ")) ;
+ LogFile.Write(data) ;
+
+
+ TLiwVariant Speed ;
+
+ index = LocMap->FindL(_L8("HorizontalSpeed") , Speed ) ;
+
+ if(index )
+ {
+
+ TReal speed = Speed.AsTReal() ;
+
+ data.Num(speed , format) ;
+
+ LogFile.Write(_L8("Speed = ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ TLiwVariant SpeedError ;
+ index = LocMap->FindL( _L8("HorizontalSpeedError") , SpeedError) ;
+
+
+ if(index )
+ {
+
+ TReal speed = SpeedError.AsTReal() ;
+
+ data.Num(speed , format) ;
+
+ LogFile.Write(_L8("Speed = ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+ index = 0 ;
+
+ TLiwVariant SatInfo ;
+
+ index = LocMap->FindL(_L8("SatelliteNumView") , SatInfo) ;
+
+ if(index )
+ {
+
+ TInt satnumView = SatInfo.AsTInt32() ;
+ data.Num(satnumView , format);
+
+ LogFile.Write(_L8("Satellite information")) ;
+
+ LogFile.Write(_L8("Number of visible satellites ")) ;
+ LogFile.Write(data) ;
+ }
+
+ index = 0 ;
+
+ TLiwVariant SatInfoview ;
+
+ index = LocMap->FindL( _L8("SatelliteNumViewUsed") , SatInfoview) ;
+ if(index )
+ {
+
+
+ TInt satnumViewUsed = SatInfoview.AsTInt32() ;
+ data.Num(satnumViewUsed , format);
+
+ LogFile.Write(_L8("\nSatellite information")) ;
+
+ LogFile.Write(_L8("\nSatelliteNumViewUsed")) ;
+ LogFile.Write(data) ;
+ }
+
+ index = 0 ;
+
+ TInt Headinginfo = 0 ;
+
+ TLiwVariant Heading ;
+ Headinginfo = LocMap->FindL(_L8("Heading") ,Heading) ;
+
+ if(Headinginfo)
+ {
+
+
+ TReal heading = Heading.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nHeading")) ;
+ LogFile.Write(data) ;
+ }
+
+
+ if(Headinginfo)
+ {
+ TLiwVariant HeadingError ;
+ index = LocMap->FindL( _L8("HeadingError") , HeadingError ) ;
+
+ if(index)
+ {
+
+
+ TReal heading = HeadingError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+ TLiwVariant MagneticHeading ;
+ index = LocMap->FindL( _L8("MagneticHeading") , MagneticHeading) ;
+
+ if(index)
+ {
+
+
+ TReal heading = MagneticHeading.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\n MagneticHeading ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ TLiwVariant MagneticHeadingError ;
+ index = LocMap->FindL(_L8("MagneticHeadingError") ,MagneticHeadingError) ;
+
+ if(index)
+ {
+
+
+ TReal heading = MagneticHeadingError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ } //End of Heading
+
+
+
+ TLiwVariant TrueCourse ;
+ index = LocMap->FindL( _L8("TrueCourse") , TrueCourse ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = TrueCourse.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\nDirection ")) ;
+
+ LogFile.Write(_L8("\n TrueCourse Error")) ;
+ LogFile.Write(data) ;
+
+
+
+ TLiwVariant TrueCourseError ;
+ index = LocMap->FindL( _L8("TrueCourseError") , TrueCourseError ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = TrueCourseError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ }
+
+
+ TLiwVariant MagneticCourse ;
+ index = LocMap->FindL(_L8("MagneticCourse") , MagneticCourse ) ;
+
+
+ if(index)
+ {
+
+ TReal heading = MagneticCourse.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticCourse ")) ;
+ LogFile.Write(data) ;
+
+
+
+ TLiwVariant MagneticCourseError ;
+ index = LocMap->FindL(_L8("MagneticCourseError") ,MagneticCourseError ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = MagneticCourseError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\n MagneticCourseError Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ }
+
+
+
+ TLiwVariant NmeaNum ;
+ index = LocMap->FindL(_L8("NMEASentence") , NmeaNum ) ;
+
+
+ if(index)
+ {
+
+ TInt32 NMEASentence = NmeaNum.AsTInt32() ;
+ data.Num(NMEASentence , format);
+
+ LogFile.Write(_L8("\nNMEA Information")) ;
+
+ LogFile.Write(_L8("\n number of NMEA Sentences ")) ;
+ LogFile.Write(data) ;
+
+ index = 0 ;
+
+ const TLiwGenericParam *MagneticCourseError = outputlist->FindFirst(index , _L8("NMEASentenceStart") ) ;
+
+ if(-1 != index)
+ {
+ Variant = MagneticCourseError->Value() ;
+
+
+ }
+
+
+ }
+
+
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+__UHEAP_MARKEND ;
+ return KErrNone ;
+
+
+
+}
+
+
+TInt CTestProvider :: getlocationPostionbased( CStifItemParser& /*aItem*/ )
+{
+__UHEAP_MARK ;
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> data ;
+ TRealFormat format ;
+
+
+ if(LogSession.Connect() != KErrNone)
+ {
+ _LIT(KLog , "Failed to connect to file server") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+
+
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)
+ {
+ _LIT(KLog , "Failed to create notifications log file") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ }
+
+ _LIT(KLog , "In CTGetLocation") ;
+ iLog->Log(KLog) ;
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+
+
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ _LIT(Klog , "Success/Failure error code missing from outputlist") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+ _LIT(KLog , "Interface not found");
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ _LIT(KClass,"GenericLocationInfo");
+ inputlist->AppendL( TLiwGenericParam( KNullDesC8,TLiwVariant( KClass ) ) );
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ _LIT(Klog, "Success/Failure state not known") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+ if((ErrorParm->Value()).AsTInt32() )
+ {
+ _LIT(KLog , "ExecutecmdL failed ");
+ iLog->Log(KLog) ;
+ return (ErrorParm->Value()).AsTInt32() ;
+ }
+
+
+
+ TInt index = 0 ;
+
+ const TLiwGenericParam *GenericParam = outputlist->FindFirst(index , KLocationMap);
+
+
+ if(!GenericParam)
+ {
+ _LIT(Klog, "Out Param not found") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ; //Param Error
+ }
+
+ TLiwVariant Variant ;
+
+ Variant = GenericParam->Value() ;
+ const CLiwMap *LocMap = Variant.AsMap() ;
+
+ TLiwVariant PosVariant ;
+
+ LocMap->FindL(KLongitudeKey , PosVariant) ;
+ TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude
+ data.Num(LongData , format) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Write(_L8("Logitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude
+
+ TReal64 LatData = (TReal64)PosVariant.AsTReal() ;
+ data.Num(LatData , format) ;
+ LogFile.Write(_L8(" Latitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude
+ TReal32 AltData = PosVariant.AsTReal() ;
+ data.Num(AltData , format) ;
+
+ LogFile.Write(_L8(" Altitude = ")) ;
+ LogFile.Write(data) ;
+
+
+ TLiwVariant Speed ;
+
+ index = LocMap->FindL(_L8("HorizontalSpeed") , Speed ) ;
+
+ if(index )
+ {
+
+ TReal speed = Speed.AsTReal() ;
+
+ data.Num(speed , format) ;
+
+ LogFile.Write(_L8("Speed = ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ TLiwVariant SpeedError ;
+ index = LocMap->FindL( _L8("HorizontalSpeedError") , SpeedError) ;
+
+
+ if(index )
+ {
+
+ TReal speed = SpeedError.AsTReal() ;
+
+ data.Num(speed , format) ;
+
+ LogFile.Write(_L8("Speed = ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+ index = 0 ;
+
+ TLiwVariant SatInfo ;
+
+ index = LocMap->FindL(_L8("SatelliteNumView") , SatInfo) ;
+
+ if(index )
+ {
+
+ TInt satnumView = SatInfo.AsTInt32() ;
+ data.Num(satnumView , format);
+
+ LogFile.Write(_L8("Satellite information")) ;
+
+ LogFile.Write(_L8("Number of visible satellites ")) ;
+ LogFile.Write(data) ;
+ }
+
+ index = 0 ;
+
+ TLiwVariant SatInfoview ;
+
+ index = LocMap->FindL( _L8("SatelliteNumViewUsed") , SatInfoview) ;
+ if(index )
+ {
+
+
+ TInt satnumViewUsed = SatInfoview.AsTInt32() ;
+ data.Num(satnumViewUsed , format);
+
+ LogFile.Write(_L8("\nSatellite information")) ;
+
+ LogFile.Write(_L8("\nSatelliteNumViewUsed")) ;
+ LogFile.Write(data) ;
+ }
+
+ index = 0 ;
+
+ TInt Headinginfo = 0 ;
+
+ TLiwVariant Heading ;
+ Headinginfo = LocMap->FindL(_L8("Heading") ,Heading) ;
+
+ if(Headinginfo)
+ {
+
+
+ TReal heading = Heading.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nHeading")) ;
+ LogFile.Write(data) ;
+ }
+
+
+ if(Headinginfo)
+ {
+ TLiwVariant HeadingError ;
+ index = LocMap->FindL( _L8("HeadingError") , HeadingError ) ;
+
+ if(index)
+ {
+
+
+ TReal heading = HeadingError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+ TLiwVariant MagneticHeading ;
+ index = LocMap->FindL( _L8("MagneticHeading") , MagneticHeading) ;
+
+ if(index)
+ {
+
+
+ TReal heading = MagneticHeading.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\n MagneticHeading ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ TLiwVariant MagneticHeadingError ;
+ index = LocMap->FindL(_L8("MagneticHeadingError") ,MagneticHeadingError) ;
+
+ if(index)
+ {
+
+
+ TReal heading = MagneticHeadingError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ } //End of Heading
+
+
+
+ TLiwVariant TrueCourse ;
+ index = LocMap->FindL( _L8("TrueCourse") , TrueCourse ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = TrueCourse.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\nDirection ")) ;
+
+ LogFile.Write(_L8("\n TrueCourse Error")) ;
+ LogFile.Write(data) ;
+
+
+
+ TLiwVariant TrueCourseError ;
+ index = LocMap->FindL( _L8("TrueCourseError") , TrueCourseError ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = TrueCourseError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ }
+
+
+ TLiwVariant MagneticCourse ;
+ index = LocMap->FindL(_L8("MagneticCourse") , MagneticCourse ) ;
+
+
+ if(index)
+ {
+
+ TReal heading = MagneticCourse.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticCourse ")) ;
+ LogFile.Write(data) ;
+
+
+
+ TLiwVariant MagneticCourseError ;
+ index = LocMap->FindL(_L8("MagneticCourseError") ,MagneticCourseError ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = MagneticCourseError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\n MagneticCourseError Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ }
+
+
+
+ TLiwVariant NmeaNum ;
+ index = LocMap->FindL(_L8("NMEASentence") , NmeaNum ) ;
+
+
+ if(index)
+ {
+
+ TInt32 NMEASentence = NmeaNum.AsTInt32() ;
+ data.Num(NMEASentence , format);
+
+ LogFile.Write(_L8("\nNMEA Information")) ;
+
+ LogFile.Write(_L8("\n number of NMEA Sentences ")) ;
+ LogFile.Write(data) ;
+
+ index = 0 ;
+
+ const TLiwGenericParam *MagneticCourseError = outputlist->FindFirst(index , _L8("NMEASentenceStart") ) ;
+
+ if(-1 != index)
+ {
+ Variant = MagneticCourseError->Value() ;
+
+
+ }
+
+
+ }
+
+
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+__UHEAP_MARKEND ;
+ return KErrNone ;
+
+
+
+}
+
+
+TInt CTestProvider :: CancelWithInvalidTransId(CStifItemParser& /*aItem*/)
+ {
+ __UHEAP_MARK ;
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> data ;
+ TRealFormat format ;
+
+
+ if(LogSession.Connect() != KErrNone)
+ {
+ _LIT(KLog , "Failed to connect to file server") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+
+ _LIT(LogFileNameCancel , "C:\\cancelinvalid.txt") ;
+
+ if(LogFile.Open(LogSession ,LogFileNameCancel , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ if(LogFile.Create(LogSession ,LogFileNameCancel , EFileWrite | EFileShareAny ) != KErrNone)
+ {
+ _LIT(KLog , "Failed to create log file\n") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ }
+
+ _LIT(KLog , "In CancelWithInvalidTransactionID\n") ;
+ data.Copy(KLog);
+ LogFile.Write(data) ;
+
+ User::After(5000000);
+
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ ASyncLocCBF* callBack ;
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptASyncronous, callBack);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ _LIT(Klog , "Success/Failure error code missing from outputlist\n") ;
+ data.Copy(Klog);
+ LogFile.Write(data) ;
+
+ //LogFile.Write(Klog) ;
+ return KErrGeneral ;
+ }
+
+ TInt reqerror = (ErrorParm->Value()).AsTInt32();
+ _LIT(Klog , "ERRor code from getlocationasynch ") ;
+ data.Copy(Klog);
+ LogFile.Write(data) ;
+
+ //LogFile.Write(Klog) ;
+
+ TReal64 errordata = reqerror ;
+ data.Num(errordata , format) ;
+
+
+ LogFile.Write(data) ;
+
+
+ pos = 0;
+
+ _LIT8(KTransactionId, "TransactionID");
+ const TLiwGenericParam *transid = outputlist->FindFirst(pos ,KTransactionId ) ;
+ if(!transid)
+ {
+ _LIT(KTran,"Missing Transaction ID\n");
+ data.Copy(KTran);
+ LogFile.Write(data) ;
+ //LogFile.Write(KTran);
+ return KErrGeneral;
+ }
+ TInt trid = (transid->Value()).AsTInt32();
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+
+
+ inputlist->AppendL(TLiwGenericParam(KTransactionId,TLiwVariant(trid-2)));
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptCancel);
+
+ ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ _LIT(Klog , "Success/Failure error code missing from outputlist in cancel\n ") ;
+ data.Copy(Klog);
+ LogFile.Write(data) ;
+ //LogFile.Write(Klog);
+ return KErrGeneral ;
+ }
+
+ reqerror = (ErrorParm->Value()).AsTInt32();
+
+ _LIT(Klog1 , "\nERRor code from cancel ") ;
+
+ data.Copy(Klog1);
+ LogFile.Write(data) ;
+ //LogFile.Write(Klog1) ;
+
+ errordata = reqerror ;
+ data.Num(errordata , format) ;
+
+
+ LogFile.Write(data) ;
+ if( SErrNotFound == reqerror )
+ {
+ reqerror = 0;
+ }
+
+
+
+
+
+
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+ __UHEAP_MARKEND ;
+ return reqerror ;
+
+
+
+ }
+
+
+TInt CTestProvider :: GetLocationSynchWrongUpdateMapType(CStifItemParser& /*aItem*/)
+{
+__UHEAP_MARK ;
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+
+
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+ _LIT8(KLocCategory,"LocationInformationClass");
+ _LIT16(KBasic,"BasicLocationInformation");
+ inputlist->AppendL(TLiwGenericParam(KLocCategory,TLiwVariant(KBasic)));
+
+
+
+ _LIT8(KUpdate,"Updateoptions");
+ inputlist->AppendL(TLiwGenericParam(KUpdate,TLiwVariant(30)));
+
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+
+ if(!ErrorParm)
+ {
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ return KErrGeneral ;
+ }
+
+ TInt err = (ErrorParm->Value()).AsTInt32();
+
+ if( SErrBadArgumentType == err )
+ {
+ _LIT8(KErrorMessage,"ErrorMessage");
+ _LIT(KNone,"Error");
+
+ TPtrC errorstring(KNone);
+ pos = 0;
+ const TLiwGenericParam *ErrorParmstring = outputlist->FindFirst(pos ,KErrorMessage ) ;
+ TLiwVariant variant = ErrorParmstring->Value();
+ errorstring.Set( variant.AsDes() );
+
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ __UHEAP_MARKEND ;
+ return KErrNone;
+ }
+
+
+
+
+
+
+
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+__UHEAP_MARKEND ;
+ return err ;
+
+
+
+}
+
+
+TInt CTestProvider :: CTestGetLocation()
+{
+__UHEAP_MARK ;
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> data ;
+ TRealFormat format ;
+
+
+ if(LogSession.Connect() != KErrNone)
+ {
+ _LIT(KLog , "Failed to connect to file server") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+
+
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)
+ {
+ _LIT(KLog , "Failed to create notifications log file") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ }
+
+ _LIT(KLog , "In CTGetLocation") ;
+ iLog->Log(KLog) ;
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+
+
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ _LIT(Klog , "Success/Failure error code missing from outputlist") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ pos = 0 ;
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);
+
+ if(!genericparm)
+ {
+ _LIT(KLog , "Interface not found");
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+
+ locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);
+
+ pos = 0 ;
+
+ const TLiwGenericParam *ErrorParm = outputlist->FindFirst(pos ,KErrorCode ) ;
+
+ if(!ErrorParm)
+ {
+ _LIT(Klog, "Success/Failure state not known") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+ if((ErrorParm->Value()).AsTInt32() )
+ {
+ _LIT(KLog , "ExecutecmdL failed ");
+ iLog->Log(KLog) ;
+ return (ErrorParm->Value()).AsTInt32() ;
+ }
+
+
+
+ TInt index = 0 ;
+
+ const TLiwGenericParam *GenericParam = outputlist->FindFirst(index , KLocationMap);
+
+
+ if(!GenericParam)
+ {
+ _LIT(Klog, "Out Param not found") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ; //Param Error
+ }
+
+ TLiwVariant Variant ;
+
+ Variant = GenericParam->Value() ;
+ const CLiwMap *LocMap = Variant.AsMap() ;
+
+ TLiwVariant PosVariant ;
+
+ LocMap->FindL(KLongitudeKey , PosVariant) ;
+ TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude
+ data.Num(LongData , format) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Write(_L8("Logitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude
+
+ TReal64 LatData = (TReal64)PosVariant.AsTReal() ;
+ data.Num(LatData , format) ;
+ LogFile.Write(_L8(" Latitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude
+ TReal32 AltData = PosVariant.AsTReal() ;
+ data.Num(AltData , format) ;
+
+ LogFile.Write(_L8(" Altitude = ")) ;
+ LogFile.Write(data) ;
+
+
+ TLiwVariant Speed ;
+
+ index = LocMap->FindL(_L8("HorizontalSpeed") , Speed ) ;
+
+ if(index )
+ {
+
+ TReal speed = Speed.AsTReal() ;
+
+ data.Num(speed , format) ;
+
+ LogFile.Write(_L8("Speed = ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ TLiwVariant SpeedError ;
+ index = LocMap->FindL( _L8("HorizontalSpeedError") , SpeedError) ;
+
+
+ if(index )
+ {
+
+ TReal speed = SpeedError.AsTReal() ;
+
+ data.Num(speed , format) ;
+
+ LogFile.Write(_L8("Speed = ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+ index = 0 ;
+
+ TLiwVariant SatInfo ;
+
+ index = LocMap->FindL(_L8("SatelliteNumView") , SatInfo) ;
+
+ if(index )
+ {
+
+ TInt satnumView = SatInfo.AsTInt32() ;
+ data.Num(satnumView , format);
+
+ LogFile.Write(_L8("Satellite information")) ;
+
+ LogFile.Write(_L8("Number of visible satellites ")) ;
+ LogFile.Write(data) ;
+ }
+
+ index = 0 ;
+
+ TLiwVariant SatInfoview ;
+
+ index = LocMap->FindL( _L8("SatelliteNumViewUsed") , SatInfoview) ;
+ if(index )
+ {
+
+
+ TInt satnumViewUsed = SatInfoview.AsTInt32() ;
+ data.Num(satnumViewUsed , format);
+
+ LogFile.Write(_L8("\nSatellite information")) ;
+
+ LogFile.Write(_L8("\nSatelliteNumViewUsed")) ;
+ LogFile.Write(data) ;
+ }
+
+ index = 0 ;
+
+ TInt Headinginfo = 0 ;
+
+ TLiwVariant Heading ;
+ Headinginfo = LocMap->FindL(_L8("Heading") ,Heading) ;
+
+ if(Headinginfo)
+ {
+
+
+ TReal heading = Heading.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nHeading")) ;
+ LogFile.Write(data) ;
+ }
+
+
+ if(Headinginfo)
+ {
+ TLiwVariant HeadingError ;
+ index = LocMap->FindL( _L8("HeadingError") , HeadingError ) ;
+
+ if(index)
+ {
+
+
+ TReal heading = HeadingError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+ TLiwVariant MagneticHeading ;
+ index = LocMap->FindL( _L8("MagneticHeading") , MagneticHeading) ;
+
+ if(index)
+ {
+
+
+ TReal heading = MagneticHeading.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\n MagneticHeading ")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ TLiwVariant MagneticHeadingError ;
+ index = LocMap->FindL(_L8("MagneticHeadingError") ,MagneticHeadingError) ;
+
+ if(index)
+ {
+
+
+ TReal heading = MagneticHeadingError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ } //End of Heading
+
+
+
+ TLiwVariant TrueCourse ;
+ index = LocMap->FindL( _L8("TrueCourse") , TrueCourse ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = TrueCourse.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\nDirection ")) ;
+
+ LogFile.Write(_L8("\n TrueCourse Error")) ;
+ LogFile.Write(data) ;
+
+
+
+ TLiwVariant TrueCourseError ;
+ index = LocMap->FindL( _L8("TrueCourseError") , TrueCourseError ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = TrueCourseError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticHeading Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ }
+
+
+ TLiwVariant MagneticCourse ;
+ index = LocMap->FindL(_L8("MagneticCourse") , MagneticCourse ) ;
+
+
+ if(index)
+ {
+
+ TReal heading = MagneticCourse.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\nMagneticCourse ")) ;
+ LogFile.Write(data) ;
+
+
+
+ TLiwVariant MagneticCourseError ;
+ index = LocMap->FindL(_L8("MagneticCourseError") ,MagneticCourseError ) ;
+
+ if( index)
+ {
+
+
+ TReal heading = MagneticCourseError.AsTReal() ;
+ data.Num(heading , format);
+
+ LogFile.Write(_L8("\ncompass information")) ;
+
+ LogFile.Write(_L8("\n MagneticCourseError Error")) ;
+ LogFile.Write(data) ;
+
+ }
+
+
+ }
+
+
+
+ TLiwVariant NmeaNum ;
+ index = LocMap->FindL(_L8("NMEASentence") , NmeaNum ) ;
+
+
+ if(index)
+ {
+
+ TInt32 NMEASentence = NmeaNum.AsTInt32() ;
+ data.Num(NMEASentence , format);
+
+ LogFile.Write(_L8("\nNMEA Information")) ;
+
+ LogFile.Write(_L8("\n number of NMEA Sentences ")) ;
+ LogFile.Write(data) ;
+
+ index = 0 ;
+
+ const TLiwGenericParam *MagneticCourseError = outputlist->FindFirst(index , _L8("NMEASentenceStart") ) ;
+
+ if(-1 != index)
+ {
+ Variant = MagneticCourseError->Value() ;
+
+
+ }
+
+
+ }
+
+
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+__UHEAP_MARKEND ;
+ return KErrNone ;
+
+
+
+}
+
+
+TInt CTestProvider :: GetLocation(CStifItemParser & /*aItem */)
+{
+ __UHEAP_MARK ;
+ TInt ret = CTestGetLocation() ;
+ __UHEAP_MARKEND ;
+ return ret ;
+
+}
+
+
+TInt CTestProvider :: LocationUpdates(CStifItemParser& /*aItem*/)
+ {
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L(" LocationUpdates Thread") , GetLocUpdates ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);
+
+ if(!ret)
+ {
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ ret = Status.Int() ;
+ }
+ return ret;
+ }
+#if 0
+TInt CTestProvider :: LastKnownLoc(CStifItemParser& /*aItem*/)
+ {
+ return KErrNone ;
+ }
+#endif
+
+TInt CTestProvider ::GetLocationAsynch(CStifItemParser& /*aItem*/)
+ {
+
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ FunctionThread.Create(_L("GetLocationAsynch Thread") , FindLocationAsynch ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);
+
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ return Status.Int() ;
+
+
+ }
+
+
+TInt CTestProvider ::ServiceNotAvailable(CStifItemParser& /*aItem*/)
+{
+
+
+
+ _LIT8(KService, "Service.Location");
+ _LIT8(KIDataSource,"ILocation");
+
+ return KErrNone ; //Manual test case
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KService, KIDataSource);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ _LIT(Klog , "Success/Failure error code missing from outputlist") ;
+ iLog->Log(Klog) ;
+ return KErrGeneral ;
+ }
+
+
+ _LIT8(KDataSource, "ILocation");
+
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+ _LIT(KLog , "Interface not found");
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+ TInt result = KErrGeneral ;
+ TInt error ;
+ TInt index = 0;
+
+
+ // CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+ CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ locinterface->ExecuteCmdL(CmdBuf , *InputList , *InputList );
+ const TLiwGenericParam *GenericParam = InputList->FindFirst(index , KErrorCode ) ;
+
+ if(GenericParam)
+ {
+ TLiwVariant ErrorVariant = GenericParam->Value() ;
+
+ error = ErrorVariant.AsTInt32();
+ }
+
+ if((error == KErrNotFound ) || (error == KPositionQualityLoss))
+ {
+ _LIT(KLog , "positioning technology not available") ;
+ iLog->Log(KLog) ;
+ result = KErrNone ;
+ }
+
+
+ locinterface->Close() ;
+ delete InputList ;
+ delete ServiceHandler ;
+
+ a.ResetAndDestroy() ;
+ // delete OutParmList ;
+
+ return result ;
+
+}
+
+
+
+/*
+ * This is a manual test case were the service was available when the
+ * request was made and then Lost the service (Contact to location servier lost
+ */
+
+
+TInt CTestProvider :: ServiceFailed(CStifItemParser& /*aItem*/)
+{
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+ _LIT(KLog , "In service failed test ") ;
+ iLog->Log(KTLocTest) ;
+
+ return KErrNone ; //Manual test case
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L("ServiceFailed Thread") , ServiceFailedTest ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);;
+
+ if(!ret)
+ {
+
+ _LIT(Klog , "Created the thread ") ;
+ iLog->Log(Klog) ;
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ ret = Status.Int() ;
+ }
+
+
+ if((ret == KErrNotFound ) || (ret == KPositionQualityLoss))
+ {
+ _LIT(KLog , "Service provider crashed or went dowm") ;
+ iLog->Log(KLog) ;
+ }
+
+
+ return ret;
+}
+
+
+
+/**
+ *Stray signal test, tests for any unhandled events from location server
+ */
+
+TInt CTestProvider :: StraySignal(CStifItemParser& /*aItem*/)
+{
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+ _LIT(KLog , "StraySignalTest ") ;
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L("stray signal") , StrayTest ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);;
+
+ if(!ret)
+ {
+
+ _LIT(Klog , "Created the thread ") ;
+ iLog->Log(Klog) ;
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ ret = Status.Int() ;
+ }
+
+ return ret;
+}
+
+
+
+TInt CTestProvider :: StraySignalGetLoc(CStifItemParser& /*aItem*/)
+{
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+ _LIT(KLog , "StraySignalTestGetLoc ") ;
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L("stray signal GetLocation") , StrayTestGetLoc ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);;
+
+ if(!ret)
+ {
+
+ _LIT(Klog , "Created the thread ") ;
+ iLog->Log(Klog) ;
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ ret = Status.Int() ;
+ }
+
+
+ return ret;
+}
+
+TInt CTestProvider :: ConcurrentCallsGetLoc (CStifItemParser& /*aItem*/)
+{
+_LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L(" ConcurrentCallsGetLoc Thread") , ConcurrentGetLocationCalls ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);
+
+ if(ret == KErrNone)
+ {
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+
+
+ ret = Status.Int() ;
+ }
+ FunctionThread.Close();
+
+ if(ret == SErrServiceInUse)
+ return KErrNone ;
+
+ return KErrGeneral;
+}
+
+
+TInt CTestProvider :: ConcurrentCallsTrace (CStifItemParser& /*aItem*/)
+{
+_LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L(" ConcurrentCallsGetLoc Thread") , TraceConcurrent ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);
+
+ if(ret == KErrNone)
+ {
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+
+
+ ret = Status.Int() ;
+ }
+ FunctionThread.Close();
+
+ if(ret == SErrServiceInUse)
+ {
+ _LIT(KLog , "Return Type is valid");
+ iLog->Log(KLog);
+ }
+
+ else
+ {
+ _LIT(KLog , "Return type is not valid\n") ;
+ iLog->Log(KLog) ;
+ }
+ return KErrNone ;
+
+ return KErrGeneral;
+}
+
+
+/**
+ *Cancel test, to test cancel functionality
+ */
+TInt CTestProvider :: EmptyCancelTraceTest(CStifItemParser& /*aItem*/)
+ {
+ __UHEAP_MARK ;
+ _LIT(KLog , "CancellTest") ;
+
+
+ iLog->Log(KLog) ;
+
+
+
+
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+ _LIT8(KCancell , "CancelNotification") ;
+ _LIT8( KType ,"CancelRequestType") ;
+ _LIT8( KTraceCancel ,"TraceCancel") ;
+ inputlist->AppendL(TLiwGenericParam (KType , TLiwVariant (KTraceCancel))) ;
+
+ locinterface->ExecuteCmdL(KCancell , *inputlist , *outputlist) ;
+
+ pos = 0 ;
+ const TLiwGenericParam *errprm = outputlist->FindFirst(pos , KErrCode) ;
+
+ if(!errprm)
+ {
+ _LIT(Kerr, "Success/Failure code missing from outputlist") ;
+ iLog->Log(Kerr) ;
+ }
+
+
+ TInt ret = KErrGeneral ; //Return Code
+ TLiwVariant var = errprm->Value() ;
+
+ if(var.AsTInt32() == SErrBadArgumentType )
+ {
+ ret= KErrNone ;
+ }
+ else
+ {
+ _LIT(KDebugMsg , "Return and expected values are different") ;
+ iLog->Log(KDebugMsg) ;
+ }
+
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+
+__UHEAP_MARKEND ;
+
+
+
+
+ return ret ;
+
+ }
+
+/**
+ *Cancel test, to test cancel functionality
+ */
+TInt CTestProvider :: EmptyCancelGetLocTest(CStifItemParser& /*aItem*/)
+ {
+ _LIT(KLog , "CancellTest") ;
+ iLog->Log(KLog) ;
+
+ __UHEAP_MARK ;
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+
+ _LIT8(KCancell , "CancelNotification") ;
+ _LIT8( KType ,"CancelRequestType") ;
+ _LIT8( KGetLocCancel ,"GetLocCancel") ;
+ inputlist->AppendL(TLiwGenericParam (KType , TLiwVariant (KGetLocCancel))) ;
+
+ locinterface->ExecuteCmdL(KCancell , *inputlist , *outputlist) ;
+
+ pos = 0 ;
+ const TLiwGenericParam *errprm = outputlist->FindFirst(pos , KErrCode) ;
+
+ if(!errprm)
+ {
+ _LIT(Kerr, "Success/Failure code missing from outputlist") ;
+ iLog->Log(Kerr) ;
+ }
+
+
+ TInt ret = KErrGeneral ;
+
+ if((errprm->Value()).AsTInt32() == SErrBadArgumentType)
+ {
+ ret = KErrNone ;
+ }
+
+ locinterface->Close() ;
+
+ //delete inlist ;
+ //Sdelete outlist ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ __UHEAP_MARKEND ;
+
+ return ret ;
+
+ }
+
+/**
+ *Cancel test, with wrong notification
+ */
+TInt CTestProvider :: CancelWrongNotification1(CStifItemParser& /*aItem*/)
+ {
+
+
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+ _LIT(KLog , "StraySignalTest ") ;
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L("Wrong Notification GetLoc cancel") , GetLocWrongCancel ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);;
+
+ if(!ret)
+ {
+
+ _LIT(Klog , "Created the thread ") ;
+ iLog->Log(Klog) ;
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ ret = Status.Int() ;
+ }
+ else
+ {
+ return ret ;
+ }
+
+ if(ret == SErrBadArgumentType)
+ {
+ ret = KErrNone ;
+ }
+ /*else
+ {
+ ret = KErrGeneral ;
+ } */
+ return ret;
+ }
+
+
+
+/**
+ *Cancel test, with wrong notification issues a Trace request and then calls for getlocation
+ * cancellation
+ */
+TInt CTestProvider :: CancelWrongNotification2(CStifItemParser& /*aItem*/)
+ {
+
+
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+ _LIT(KLog , "CancelWrongNotification2 ") ;
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L("Wrong Notification Trace cancel") , TraceLocWrongCancel ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);;
+
+ if(!ret)
+ {
+
+ _LIT(Klog , "Created the thread ") ;
+ iLog->Log(Klog) ;
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ ret = Status.Int() ;
+ }
+ else
+ {
+ return ret ;
+ }
+
+ if(ret == SErrBadArgumentType)
+ {
+ ret = KErrNone ;
+ }
+
+ return ret;
+ }
+
+
+/**
+ *Cancel test, Normal cancel test for getlocation
+ */
+TInt CTestProvider :: GetLocationCancel(CStifItemParser& /*aItem*/)
+ {
+
+
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+ _LIT(KLog , "Getlocationcancel ") ;
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L("Getlocationcancel ") , GetLocCancel ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);;
+
+ if(!ret)
+ {
+
+ _LIT(Klog , "Created the thread ") ;
+ iLog->Log(Klog) ;
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ ret = Status.Int() ;
+ }
+ else
+ {
+ return ret ;
+ }
+
+
+ return ret;
+ }
+
+/**
+ * GetLocation Timeout
+ */
+TInt CTestProvider :: GetLocationTimedOut(CStifItemParser& /*aItem*/)
+ {
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+ _LIT(KLog , "GetLocationTimedOut ") ;
+ iLog->Log(KTLocTest) ;
+
+ return KErrNone ; //This is a manul test case
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+ inputlist->Reset();
+ outputlist->Reset();
+ const TInt Ksecond = 1000000;
+ const TInt KUpdatetimeOut = 100 ; //*Ksecond ;
+
+ //SetUpdate time out less then 2 second(response time) ;
+ CLiwMap *UpdateOptsMap = CLiwDefaultMap :: NewL() ;
+
+ UpdateOptsMap->InsertL(KUpdateOptionTimeOut , (TInt32)KUpdatetimeOut) ;
+
+ inputlist->AppendL(TLiwGenericParam (KUpdateOptionMap , TLiwVariant(UpdateOptsMap)) ) ;
+
+ TBuf8<20>CmdBufSet(KCmdGetLocation) ;
+
+ locinterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist);
+ UpdateOptsMap->DecRef() ;
+
+ pos = 0 ;
+
+ const TLiwGenericParam *errcode = outputlist->FindFirst(pos , KErrCode) ;
+
+ if(pos == KErrNotFound)
+ {
+ _LIT(KLog , "Success/Error Code is missing ") ;
+ iLog->Log(KLog) ;
+ return KErrGeneral ;
+ }
+
+ pos = (errcode->Value()).AsTInt32() ;
+
+ delete ServiceHandler ;
+ delete crit ;
+ locinterface->Close() ;
+
+ if(pos == KErrTimedOut)
+ {
+ return KErrNone ;
+ }
+
+ _LIT(Kerr , "Time out value not set correctly") ;
+ return KErrNone ;
+
+ }
+
+/**
+ *Normal Trace cancell test.
+ */
+TInt CTestProvider :: TraceLocationCancel(CStifItemParser& /*aItem*/)
+ {
+
+
+ _LIT(KTLocTest ,"TLocTest");
+ iLog->Log(KTLocTest) ;
+ _LIT(KLog , "Getlocationcancel ") ;
+ iLog->Log(KTLocTest) ;
+
+ TRequestStatus Status = KRequestPending ;
+ RThread FunctionThread ;
+
+ TInt ret = FunctionThread.Create(_L("Getlocationcancel ") , TraceLocCancel ,KDefaultStackSize ,
+ KMinHeapSize , 0x5000 ,(TAny *) NULL);;
+
+ if(!ret)
+ {
+
+ _LIT(Klog , "Created the thread ") ;
+ iLog->Log(Klog) ;
+ FunctionThread.Logon(Status) ;
+ FunctionThread.Resume() ;
+
+ User :: WaitForRequest (Status) ;
+ FunctionThread.Close();
+
+ ret = Status.Int() ;
+ }
+ else
+ {
+ return ret ;
+ }
+
+
+ return ret;
+ }
+
+/**
+ *Math Operation Find distance : Position based parameter
+ */
+ TInt CTestProvider :: FindDistanceAgain(CStifItemParser& /*aItem*/)
+ {
+ __UHEAP_MARK;
+ TInt start = User::CountAllocCells();
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+
+
+ TBuf8<20>CmdBuf(KRequestCalculate) ;
+
+ CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ TLiwGenericParam requesttype(KNullDesC8 , TLiwVariant(KRequestBearingTo)) ;
+ InputList->AppendL(requesttype) ;
+
+ //Inserting first input param
+ CLiwMap* SourceCoordinate = CLiwDefaultMap::NewL();
+ TReal64 slongitude = 22;
+ SourceCoordinate->InsertL(KLongitudeKey,TLiwVariant(slongitude));
+ TReal64 slatitude = 88;
+ SourceCoordinate->InsertL(KLatitudeKey,TLiwVariant(slatitude));
+ TReal64 saltitude = 1;
+ SourceCoordinate->InsertL(KAltitudeKey,TLiwVariant(slatitude));
+
+ TLiwGenericParam scoordinate(KNullDesC8,TLiwVariant(SourceCoordinate));
+ InputList->AppendL(scoordinate) ;
+ SourceCoordinate->DecRef() ;
+
+
+
+ //Inserting 2nd input param
+ CLiwDefaultMap* DestCoordinate = CLiwDefaultMap::NewL();
+ TReal64 dlongitude = 13;
+ DestCoordinate->InsertL(KLongitudeKey,TLiwVariant(dlongitude));
+ TReal64 dlatitude = 77;
+
+
+ DestCoordinate->InsertL(KLatitudeKey,TLiwVariant(dlatitude));
+ TReal64 daltitude = 1;
+ DestCoordinate->InsertL(KAltitudeKey,TLiwVariant(dlatitude));
+
+ TLiwGenericParam dcoordinate(KNullDesC8,TLiwVariant(DestCoordinate));
+ InputList->AppendL(dcoordinate) ;
+ DestCoordinate->DecRef() ;
+
+
+ CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+
+
+ CmdBuf = KRequestCalculate ;
+
+ locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList);
+
+
+ pos = 0;
+ const TLiwGenericParam* param = OutParmList->FindFirst(pos, KErrorCode);
+
+ pos = 0;
+ const TLiwGenericParam* resultparam = OutParmList->FindFirst(pos, KMathOpResult);
+ TLiwVariant resultvariant = resultparam->Value();
+ TReal32 bearingTo = resultvariant.AsTReal();
+
+
+
+
+ //Logging result into a file
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> Buffer(_L8("BearingTo = ")) ;
+ LogSession.Connect() ;
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) ;
+ }
+
+ TInt End = 0 ;
+
+ LogFile.Seek(ESeekEnd , End) ; //Seek to end of the file before writing
+
+ TBuf8<50> num ;
+ TRealFormat format ;
+
+ num.Num(bearingTo , format) ;
+
+
+ LogFile.Write(_L8("BearingTo= "));
+ LogFile.Write(num) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ locinterface->Close() ;
+ OutParmList->Reset();
+ InputList->Reset();
+ delete OutParmList ;
+ delete InputList ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+
+ TInt end = User::CountAllocCells();
+ __UHEAP_MARKEND ;
+
+
+
+ return KErrNone ;
+
+
+
+
+ }
+/**
+ * Math operation BearingTo Test
+ */
+
+ TInt CTestProvider ::BearingToTest(CStifItemParser& /*aItem*/)
+ {
+ __UHEAP_MARK ;
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+ TBuf8<20>CmdBuf(KRequestCalculate) ;
+
+ CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ TLiwGenericParam requesttype(KMathRequest , TLiwVariant(KRequestBearingTo)) ;
+ InputList->AppendL(requesttype) ;
+
+ //Inserting first input param
+ CLiwMap* SourceCoordinate = CLiwDefaultMap::NewL();
+ TReal64 slongitude = 22;
+ SourceCoordinate->InsertL(KLongitudeKey,TLiwVariant(slongitude));
+ TReal64 slatitude = 88;
+ SourceCoordinate->InsertL(KLatitudeKey,TLiwVariant(slatitude));
+ TReal64 saltitude = 1;
+ SourceCoordinate->InsertL(KAltitudeKey,TLiwVariant(slatitude));
+
+ TLiwGenericParam scoordinate(KDistanceParmSource,TLiwVariant(SourceCoordinate));
+ InputList->AppendL(scoordinate) ;
+ SourceCoordinate->DecRef() ;
+
+
+
+ //Inserting 2nd input param
+ CLiwMap* DestCoordinate = CLiwDefaultMap::NewL();
+ TReal64 dlongitude = 13;
+ DestCoordinate->InsertL(KLongitudeKey,TLiwVariant(dlongitude));
+ TReal64 dlatitude = 77;
+ DestCoordinate->InsertL(KLatitudeKey,TLiwVariant(dlatitude));
+ TReal64 daltitude = 1;
+ DestCoordinate->InsertL(KAltitudeKey,TLiwVariant(dlatitude));
+
+ TLiwGenericParam dcoordinate(KDistanceParmDestination,TLiwVariant(DestCoordinate));
+ InputList->AppendL(dcoordinate) ;
+ DestCoordinate->DecRef() ;
+
+
+ CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+
+
+ CmdBuf = KRequestCalculate ;
+
+ locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList);
+
+
+ pos = 0;
+ const TLiwGenericParam* param = OutParmList->FindFirst(pos, KErrorCode);
+
+ pos = 0;
+ const TLiwGenericParam* resultparam = OutParmList->FindFirst(pos, KMathOpResult);
+ TLiwVariant resultvariant = resultparam->Value();
+ TReal32 bearingTo = resultvariant.AsTReal();
+
+
+
+
+ //Logging result into a file
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> Buffer(_L8("BearingTo = ")) ;
+ LogSession.Connect() ;
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) ;
+ }
+
+ TInt End = 0 ;
+
+ LogFile.Seek(ESeekEnd , End) ; //Seek to end of the file before writing
+
+ TBuf8<50> num ;
+ TRealFormat format ;
+
+ num.Num(bearingTo , format) ;
+
+
+ LogFile.Write(_L8("BearingTo= "));
+ LogFile.Write(num) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ delete OutParmList ;
+ dcoordinate.Reset() ;
+ scoordinate.Reset() ;
+ delete InputList ;
+ locinterface->Close() ;
+ inputlist->Reset() ;
+ outputlist->Reset() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ __UHEAP_MARKEND ;
+ return KErrNone ;
+
+
+ }
+
+ TInt CTestProvider ::FindDistance(CStifItemParser& /*aItem*/)
+ {
+ __UHEAP_MARK ;
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+ //First set the identity information
+
+ ;
+ TBuf8<20>CmdBufSet(KRequestCalculate) ;
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+
+ CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ TLiwGenericParam requesttype(KMathRequest , TLiwVariant(KRequestDistance)) ;
+ InputList->AppendL(requesttype) ;
+
+
+
+ //Inserting first input param
+ CLiwMap* SourceCoordinate = CLiwDefaultMap::NewL();
+ TReal64 slongitude = 71.03;
+ SourceCoordinate->InsertL(KLongitudeKey,TLiwVariant(slongitude));
+ TReal64 slatitude = 42.37;
+ SourceCoordinate->InsertL(KLatitudeKey,TLiwVariant(slatitude));
+ TReal64 saltitude = 1;
+ SourceCoordinate->InsertL(KAltitudeKey,TLiwVariant(slatitude));
+
+ TLiwGenericParam scoordinate(KDistanceParmSource,TLiwVariant(SourceCoordinate));
+ InputList->AppendL(scoordinate) ;
+ SourceCoordinate->DecRef() ;
+
+
+
+ //Inserting 2nd input param
+ CLiwMap* DestCoordinate = CLiwDefaultMap::NewL();
+ TReal64 dlongitude = 83.02;
+ DestCoordinate->InsertL(KLongitudeKey,TLiwVariant(dlongitude));
+ TReal64 dlatitude = 42.42;
+ DestCoordinate->InsertL(KLatitudeKey,TLiwVariant(dlatitude));
+ TReal64 daltitude = 1;
+ DestCoordinate->InsertL(KAltitudeKey,TLiwVariant(dlatitude));
+
+ TLiwGenericParam dcoordinate(KDistanceParmDestination,TLiwVariant(DestCoordinate));
+ InputList->AppendL(dcoordinate) ;
+ DestCoordinate->DecRef() ;
+
+ CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+
+
+ CmdBufSet = KRequestCalculate ;
+
+ locinterface->ExecuteCmdL(CmdBufSet , *InputList , *OutParmList);
+
+
+ pos = 0;
+ const TLiwGenericParam* param = OutParmList->FindFirst(pos, KErrorCode);
+
+
+ pos = 0;
+ const TLiwGenericParam* resultparam = OutParmList->FindFirst(pos, KMathOpResult);
+ TLiwVariant resultvariant = resultparam->Value();
+ TReal64 distance = resultvariant.AsTReal();
+
+
+
+
+ //Logging result into a file
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> Buffer(_L8("Distance = ")) ;
+ LogSession.Connect() ;
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) ;
+
+ }
+
+ TInt End = 0 ;
+
+ LogFile.Seek(ESeekEnd , End) ; //Seek to end of the file before writing
+
+ TBuf8<50> num ;
+ TRealFormat format ;
+ //TReal64 Val = aPosition.Latitude() ;
+ num.Num(distance , format) ;
+
+ //Logging Latitude
+ LogFile.Write(_L8("distance = "));
+ LogFile.Write(num) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ delete InputList ;
+ delete OutParmList ;
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+
+ __UHEAP_MARKEND ;
+ return KErrNone ;
+
+
+
+
+ }
+
+TInt CTestProvider ::GetLocationUpdateOpts(CStifItemParser& /*aItem*/)
+ {
+
+ __UHEAP_MARK;
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> data ;
+ TRealFormat format ;
+ LogSession.Connect() ;
+ _LIT8(KLog , "GetLocationUpdateOPts") ;
+ iLog->Log(KLog) ;
+
+
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) ;
+ }
+
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+ TBuf8<20>CmdBuf(KCmdGetLocation) ;
+
+ CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ //Append LocationInformation Category
+ TLiwGenericParam informationCategory(KLocationInfoCategory , TLiwVariant(KLocationBasicinfo)) ;
+ InputList->AppendL(informationCategory) ;
+
+ //Appending update options
+ CLiwMap* updateoptionMap = CLiwDefaultMap::NewL();
+
+ TInt32 updateInterval = 30000;
+
+ updateoptionMap->InsertL(KUpdateOptionInterval,TLiwVariant(updateInterval));
+
+ TInt32 updateTimeOut = 10000;
+ updateoptionMap->InsertL(KUpdateOptionTimeOut,TLiwVariant(updateTimeOut));
+
+ TInt32 updateMaxAge = 2000;
+ updateoptionMap->InsertL(KUpdateOptionMaxAge,TLiwVariant(updateMaxAge));
+
+ TLiwGenericParam updateOption(KUpdateOptionMap,TLiwVariant(updateoptionMap));
+ InputList->AppendL(updateOption) ;
+
+ CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+
+
+
+
+ locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList);
+
+
+ pos = 0;
+ const TLiwGenericParam* param = OutParmList->FindFirst(pos, KErrorCode);
+
+
+ pos = 0;
+ const TLiwGenericParam* resultparam = OutParmList->FindFirst(pos, KLocationMap);
+ TLiwVariant resultvariant = resultparam->Value();
+
+ const CLiwMap *LocMap = resultvariant.AsMap() ;
+
+ TLiwVariant PosVariant ;
+
+ LocMap->FindL(KLongitudeKey , PosVariant) ;
+
+
+ TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude
+ data.Num(LongData , format) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Write(_L8("Logitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude
+
+ TReal64 LatData = (TReal64)PosVariant.AsTReal() ;
+ data.Num(LatData , format) ;
+ LogFile.Write(_L8(" Latitude = ")) ;
+ LogFile.Write(data) ;
+
+ LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude
+ TReal32 AltData = PosVariant.AsTReal() ;
+ data.Num(AltData , format) ;
+
+ LogFile.Write(_L8(" Altitude = ")) ;
+ LogFile.Write(data) ;
+ LogFile.Close() ;
+ locinterface->Close() ;
+ LogSession.Close() ;
+
+ delete ServiceHandler ;
+ InputList->Reset();
+ OutParmList->Reset();
+ delete InputList ;
+ delete OutParmList ;
+ __UHEAP_MARKEND;
+ return KErrNone ;
+
+ }
+
+
+
+void FillCoordinatesL ( TCoordinate &aCoordinate , const CLiwMap *aMap )
+ {
+ TLiwVariant longitudevar ;
+ TLiwVariant latitudevar ;
+ TLiwVariant altitudevar ;
+
+ aMap->FindL(KLongitudeKey , longitudevar) ;
+ aMap->FindL(KLatitudeKey , latitudevar) ;
+ aMap->FindL(KAltitudeKey , altitudevar ) ;
+
+ TReal64 latitude = (TReal64)latitudevar.AsTReal() ;
+ TReal64 longitude = (TReal64)longitudevar.AsTReal() ;
+ TReal32 altitude = (TReal32)altitudevar.AsTReal() ;
+
+ aCoordinate.SetCoordinate( latitude , longitude , altitude) ;
+
+
+ }
+
+/**
+ * Math Function test Move coordinates
+ */
+
+ TInt CTestProvider :: MoveCoordinates(CStifItemParser& /*aItem*/)
+ {
+
+ __UHEAP_MARK ;
+ CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
+
+ // Input and output parameter list
+ CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
+ CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
+
+
+
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KContents, KService);
+
+
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+
+ RCriteriaArray a;
+ a.AppendL(crit);
+
+ ServiceHandler->AttachL(a) ;
+ ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
+
+
+
+
+ TInt pos = 0;
+
+ const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;
+
+ if(!errorprm)
+ {
+ return KErrGeneral ;
+ }
+
+ pos = 0 ;
+ const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KDataSource );
+
+ if(!genericparm)
+ {
+
+ return KErrGeneral ;
+ }
+
+ MLiwInterface* locinterface = (genericparm->Value()).AsInterface();
+
+ TBuf8<20>CmdBuf(KRequestCalculate) ;
+ outputlist->Reset() ;
+ inputlist->Reset() ;
+
+
+ CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;
+
+ TLiwGenericParam requesttype(KMathRequest , TLiwVariant(KRequestMove)) ;
+ InputList->AppendL(requesttype) ;
+
+
+ //Inserting first input param
+ CLiwMap* SourceCoordinate = CLiwDefaultMap::NewL();
+ TReal64 slongitude = 22;
+ SourceCoordinate->InsertL(KLongitudeKey,TLiwVariant(slongitude));
+ TReal64 slatitude = 88;
+ SourceCoordinate->InsertL(KLatitudeKey,TLiwVariant(slatitude));
+
+ TReal64 saltitude = 1;
+ SourceCoordinate->InsertL(KAltitudeKey,TLiwVariant(saltitude));
+
+
+
+ TLiwGenericParam scoordinate(KDistanceParmSource,TLiwVariant(SourceCoordinate));
+ InputList->AppendL(scoordinate) ;
+ SourceCoordinate->DecRef() ;
+
+
+
+ TReal32 distanceToMove = 345;
+ TReal32 bearingToMove = 45;
+
+
+ //Inserting distance by which coordinate should be moved
+ TLiwVariant distanceVal((TReal)distanceToMove);
+ TLiwGenericParam distanceParam(KDistanceMove,distanceVal);
+ InputList->AppendL(distanceParam);
+
+ //Inserting bearing by which coordinate should be moved
+ TLiwVariant bearingVal((TReal)bearingToMove);
+ TLiwGenericParam bearingParam(KBearingMove,bearingVal);
+ InputList->AppendL(bearingParam);
+
+
+
+
+
+ CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;
+
+
+
+
+ locinterface->ExecuteCmdL(CmdBuf , *InputList , *OutParmList);
+
+
+
+
+
+ TInt mathindex = 0;
+
+ // calculation
+ const TLiwGenericParam *smapparam = OutParmList->FindFirst(mathindex , KLocationMap) ;
+ TLiwVariant mapVariant= smapparam->Value() ;
+ const CLiwMap *map = mapVariant.AsMap() ;
+ TCoordinate source ;
+
+ FillCoordinatesL(source , map) ;
+
+ TReal64 longitudeInputVal = source.Longitude();
+ TReal64 latitudeInputVal = source.Latitude();
+ TReal64 altitudeInputVal = source.Altitude();
+
+
+ //Logging result into a file
+ RFile LogFile ;
+ RFs LogSession ;
+ TBuf8<50> Buffer(_L8("Longitude = ")) ;
+ LogSession.Connect() ;
+
+ if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny ) == KErrNotFound)
+ {
+ LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) ;
+
+ }
+
+ TInt End = 0 ;
+
+ LogFile.Seek(ESeekEnd , End) ; //Seek to end of the file before writing
+
+ TBuf8<50> num ;
+ TRealFormat format ;
+
+ num.Num(longitudeInputVal, format) ;
+
+ //Logging
+ LogFile.Write(_L8("Longitude = "));
+ LogFile.Write(num) ;
+ LogFile.Write(_L8("\n")) ;
+ //LogFile.Seek(ESeekEnd , End) ;
+ num.Num(latitudeInputVal, format) ;
+ LogFile.Write(_L8("Latitude = "));
+ LogFile.Write(num) ;
+ LogFile.Write(_L8("\n")) ;
+ num.Num(altitudeInputVal, format) ;
+ LogFile.Write(_L8("altitude = "));
+ LogFile.Write(num) ;
+ LogFile.Write(_L8("\n")) ;
+ LogFile.Close() ;
+ LogSession.Close() ;
+
+ delete OutParmList ;
+ delete InputList ;
+ locinterface->Close() ;
+ delete ServiceHandler ;
+ a.ResetAndDestroy() ;
+ a.Close() ;
+ __UHEAP_MARKEND ;
+ return KErrNone ;
+ }
+
+
+
+
+
+