diff -r 000000000000 -r 14df0fbfcc4e sapi_location/tsrc/dev/tlocationprovidertest/src/tcompluginblocks.cpp --- /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 +#include +#include +#include +#include +#include +#include + +#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 ; + } + + + + + +