--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lbs/lbsclient/src/ctlbsclientpostp203.cpp Thu Jan 21 12:53:44 2010 +0000
@@ -0,0 +1,433 @@
+// Copyright (c) 2001-2009 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+
+
+// INCLUDE FILES
+#include "ctlbsclientpostp203.h"
+#include "ctlbsrequester.h"
+#include <LbsPositionInfo.h>
+#include <Lbs.h>
+#include <LbsCommon.h>
+#include <LbsRequestor.h>
+#include <EPos_CPosModules.h>
+#include <EPos_CPosModuleUpdate.h>
+
+// ================= MEMBER FUNCTIONS =======================
+
+// Constructor.
+CT_LbsClientPosTp203::CT_LbsClientPosTp203(CT_LbsServer& aParent): CT_LbsPortedStepBase(aParent)
+ {
+ _LIT(KTestName, "TP203 - Periodic Update, default psy");
+ SetTestStepName(KTestName);
+ }
+
+// Destructor
+CT_LbsClientPosTp203::~CT_LbsClientPosTp203()
+ {
+ RDebug::Print(_L("CT_LbsClientPosTp203::~CT_LbsClientPosTp203"));
+ }
+
+// ---------------------------------------------------------
+// CPosTp203::CloseTest
+//
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+void CT_LbsClientPosTp203::CloseTest()
+ {
+ RDebug::Print(_L("CT_LbsClientPosTp203::CloseTest"));
+
+ delete iPeriodicTimer;
+ iPeriodicTimer = NULL;
+ }
+
+// ---------------------------------------------------------
+// CPosTp203::StartL
+//
+// (other items were commented in a header).
+// ---------------------------------------------------------
+//
+void CT_LbsClientPosTp203::StartL()
+ {
+ const TInt KLongErrorInterval = 3000000;
+
+#ifdef __WINS__
+ const TInt KNormalErrorInterval = 1500000;
+#else
+ const TInt KNormalErrorInterval = 500000;
+#endif
+
+
+ TInt numberOfRuns = 6;
+ TInt normalInterval = 4500000;
+ // Using the same interval as the slow psy (TestPsy3) to make things easy.
+ TTimeIntervalMicroSeconds interval = TTimeIntervalMicroSeconds(normalInterval);
+ TTimeIntervalMicroSeconds shortInterval = TTimeIntervalMicroSeconds(1500000);
+
+ // Will happen the first time when default is changed
+ TInt longInterval = 8500000;
+ TInt errorInterval = KNormalErrorInterval;
+
+ TInt requestUpdate = normalInterval;
+
+ RPositionServer posServer;
+ CleanupClosePushL(posServer);
+ TInt err = posServer.Connect();
+ _LIT(KConnectErr, "Error when connecing to EPos server, %d");
+ AssertTrueL(err == KErrNone, KConnectErr, err);
+
+ SetupPsyL(iUidMultiPsy);
+
+ RPositioner positioner;
+ CleanupClosePushL(positioner);
+ err = positioner.Open(posServer); // Use Default PSY
+ _LIT(KOpenErr, "Error when opening positioner, %d");
+ AssertTrueL(err == KErrNone, KOpenErr, err);
+
+ TPositionInfo positionInfo = TPositionInfo();
+ TPositionUpdateOptions posOption;
+ posOption.SetUpdateInterval(interval);
+
+ err = positioner.SetUpdateOptions(posOption);
+ _LIT(KUpdateErr, "Error when setting update interval, %d");
+ AssertTrueL(err == KErrNone, KUpdateErr, err);
+
+ _LIT(KService ,"Service");
+ positioner.SetRequestor(CRequestor::ERequestorService,
+ CRequestor::EFormatApplication, KService);
+
+ // Do a couple of request and check the times between requests.
+ TTime now, startTime;
+ TTimeIntervalMicroSeconds requestTime;
+ _LIT(KErrorRequest, "Error in request");
+ TRequestStatus status;
+ TInt64 reqTime;
+
+ for (TInt i = 0; i < numberOfRuns; i++)
+ {
+ TBuf<100> info;
+ _LIT(KInfo, "Making request %d");
+ info.Format(KInfo, i);
+ INFO_PRINTF1(info);
+ if (i == 2)
+ {
+ _LIT(KSetTestPSY3, "Setting up TestPsy3");
+ INFO_PRINTF1(KSetTestPSY3);
+ SetupPsyL(iUidTestPsy3);
+ User::After(1000000);
+ requestUpdate = longInterval;
+ errorInterval = KLongErrorInterval;
+ }
+ else
+ {
+ requestUpdate = normalInterval;
+ errorInterval = KNormalErrorInterval;
+ }
+
+ _LIT(KWaitStatus1, "Waiting for status after NotifyPositionUpdate1");
+ INFO_PRINTF1(KWaitStatus1);
+
+ startTime.UniversalTime();
+ positioner.NotifyPositionUpdate(positionInfo, status);
+ User::WaitForRequest(status);
+ now.UniversalTime();
+
+ err = status.Int();
+ AssertTrueL(err == KErrNone, KErrorRequest, err);
+
+ requestTime = now.MicroSecondsFrom(startTime);
+ _LIT(KError, "Request time, %d microsecs.");
+ TBuf<100> buf;
+ reqTime = requestTime.Int64();
+ buf.Format(KError, reqTime);
+ INFO_PRINTF1(buf);
+
+ if (i != 0)
+ {
+ // Check that the time is ok, by accepting an error interval
+ if (reqTime > (requestUpdate + errorInterval) ||
+ reqTime < (requestUpdate - errorInterval))
+ {
+ _LIT(KErrorInterval, "The update is not within valid range");
+ LogErrorAndLeaveL(KErrorInterval);
+ }
+ }
+
+ // Check that position was returned from correct PSY:
+ if (i < 2)
+ {
+ VerifyPositionFromL(positionInfo, iUidMultiPsy);
+ }
+ else
+ {
+ VerifyPositionFromL(positionInfo, iUidTestPsy3);
+ }
+ }
+
+ _LIT(KSetUpdateOptions, "Calling SetUpdateOptions");
+ INFO_PRINTF1(KSetUpdateOptions);
+ posOption.SetUpdateInterval(shortInterval);
+ err = positioner.SetUpdateOptions(posOption);
+ AssertTrueL(err == KErrNone, KUpdateErr, err);
+
+ // Set up three PSYs the two onces with top priorities supports tracking
+ // and the third one does not
+ CPosModules* db = CPosModules::OpenL();
+ CleanupStack::PushL(db);
+ CPosModuleUpdate* moduleUpdate = CPosModuleUpdate::NewLC();
+
+ _LIT(KSetPriority0, "Enabling Tracking PSY with priority 0");
+ INFO_PRINTF1(KSetPriority0);
+ moduleUpdate->SetUpdateAvailability(ETrue);
+ User::After(1000000);
+
+ db->UpdateModuleL(iUidTestTrackingPsy, *moduleUpdate);
+ db->SetModulePriorityL(iUidTestTrackingPsy, 0);
+ User::After(1000000);
+
+
+
+ _LIT(KSetPriority1, "Enabling Timer PSY with priority 1");
+ /*INFO_PRINTF1(KSetPriority1);
+ db->UpdateModuleL(iUidTestTimerPsy, *moduleUpdate);
+ db -> SetModulePriorityL(iUidTestTimerPsy, 1);
+ User::After(1000000);*/
+
+ _LIT(KSetPriority2, "Enabling Multi PSY with priority 2");
+ /*INFO_PRINTF1(KSetPriority2);
+ db->UpdateModuleL(iUidMultiPsy, *moduleUpdate);
+ db -> SetModulePriorityL(iUidMultiPsy, 2);
+ User::After(1000000); // just to let the events happen in the server.*/
+
+
+ // Make one request to ensure that Start tracking is called.
+ positioner.NotifyPositionUpdate(positionInfo, status);
+ _LIT(KWaitStatus2, "Waiting for status after NotifyPositionUpdate2");
+ INFO_PRINTF1(KWaitStatus2);
+ RDebug::Print(KWaitStatus2);
+ User::WaitForRequest(status);
+ err = status.Int();
+ AssertTrueL(err == KErrNone || err == KPositionQualityLoss, KErrorRequest, err);
+
+ TPosition pos;
+ positionInfo.GetPosition(pos);
+ User::After(1000000);
+
+ // TestTrackingPsy returns 65.0 for Tracking requests and 30.0 for ordinary position requests
+ _LIT(KErrorAndLeave, "Wrong position returned from tracking PSY");
+ if (pos.Latitude() != 65.0 || pos.Longitude() != 65.0 || pos.Altitude() != 65.0)
+ {
+ LogErrorAndLeaveL(KErrorAndLeave);
+ }
+
+ INFO_PRINTF1(KSetPriority1);
+ db->UpdateModuleL(iUidTestTimerPsy, *moduleUpdate);
+ db -> SetModulePriorityL(iUidTestTimerPsy, 1);
+ User::After(2000000); // MH move
+
+ // Disable the psy with top priority, should result in switch of psy
+ _LIT(KDisablePSY, "Disabling Tracking PSY");
+ INFO_PRINTF1(KDisablePSY);
+ moduleUpdate->SetUpdateAvailability(EFalse);
+ db->UpdateModuleL(iUidTestTrackingPsy, *moduleUpdate);
+ // To let the events happen in the server.
+ User::After(2000000);
+
+ // Make one request to enable tracking
+ positioner.NotifyPositionUpdate(positionInfo, status);
+ _LIT(KWaitStatus4, "Waiting for status after NotifyPositionUpdate4");
+ INFO_PRINTF1(KWaitStatus4);
+ RDebug::Print(KWaitStatus4);
+ User::WaitForRequest(status);
+ err = status.Int();
+ AssertTrueL(err == KErrNone || err == KPositionQualityLoss, KErrorRequest, err);
+
+ positionInfo.GetPosition(pos);
+
+ // To let the events happen in the server.
+ User::After(2000000);
+
+ // TestTimerPsy returns 55.0 for Tracking requests and 20.0 for ordinary position requests
+ if (pos.Latitude() != 55.0 || pos.Longitude() != 55.0 || pos.Altitude() != 55.0)
+ {
+ LogErrorAndLeaveL(KErrorAndLeave);
+ }
+
+ // Enable the psy with top priority, should result in switch back to that psy
+ _LIT(KEnablePSY, "Enabling tracking PSY");
+ INFO_PRINTF1(KEnablePSY);
+ moduleUpdate->SetUpdateAvailability(ETrue);
+ db->UpdateModuleL(iUidTestTrackingPsy, *moduleUpdate);
+ User::After(2000000); // just to let the events happen in the server.
+
+ // To enable tracking
+ positioner.NotifyPositionUpdate(positionInfo, status);
+ _LIT(KWaitStatus6, "Waiting for status after NotifyPositionUpdate6");
+ INFO_PRINTF1(KWaitStatus6);
+ User::WaitForRequest(status);
+ err = status.Int();
+ AssertTrueL(err == KErrNone || err == KPositionQualityLoss, KErrorRequest, err);
+
+ // To let the events happen in the server.
+ User::After(2000000);
+
+ positionInfo.GetPosition(pos);
+ // TestTrackingPsy returns 65.0 for Tracking requests and 30.0 for ordinary position requests
+ if (pos.Latitude() != 65.0 || pos.Longitude() != 65.0 || pos.Altitude() != 65.0)
+ {
+ LogErrorAndLeaveL(KErrorAndLeave);
+ }
+
+ INFO_PRINTF1(KSetPriority2);
+ db->UpdateModuleL(iUidMultiPsy, *moduleUpdate);
+ db -> SetModulePriorityL(iUidMultiPsy, 2);
+ // To let the events happen in the server. //MH
+ User::After(1000000);
+
+ // Disable two psys with top priority that supports tracking.
+ _LIT(KDisableTimer,"Disabling Timer and Tracking PSY");
+ INFO_PRINTF1(KDisableTimer);
+ moduleUpdate->SetUpdateAvailability(EFalse);
+ db->UpdateModuleL(iUidTestTimerPsy, *moduleUpdate);
+ db->UpdateModuleL(iUidTestTrackingPsy, *moduleUpdate);
+ User::After(2000000); // just to let the events happen in the server.
+
+ positioner.NotifyPositionUpdate(positionInfo, status);
+ _LIT(KWaitStatus8, "Waiting for status after NotifyPositionUpdate8");
+ INFO_PRINTF1(KWaitStatus8);
+ User::WaitForRequest(status);
+ err = status.Int();
+ AssertTrueL(err == KErrNone, KErrorRequest, err);
+
+ if (iUidMultiPsy.iUid != positionInfo.ModuleId().iUid)
+ {
+ _LIT(KIncorrectPsyError,
+ "Position from wrong PSY received");
+ LogErrorAndLeaveL(KIncorrectPsyError);
+ }
+
+ // Disable a PSY during ongoing requesting
+ // Enable the the top three PSYs
+ _LIT(KEnableTimer,"Enabling Timer PSY");
+ INFO_PRINTF1(KEnableTimer);
+ moduleUpdate->SetUpdateAvailability(ETrue);
+ db->UpdateModuleL(iUidTestTimerPsy, *moduleUpdate);
+ db->UpdateModuleL(iUidTestTrackingPsy, *moduleUpdate);
+ moduleUpdate->SetUpdateAvailability(EFalse);
+ db->UpdateModuleL(iUidMultiPsy, *moduleUpdate);
+ // To let the events happen in the server.
+ User::After(2000000);
+
+ const TInt KRequestInterval = 4000000;
+ TCallBack callback(DisablePsyL, this);
+ iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityStandard);
+ TTimeIntervalMicroSeconds32 disableTime = TTimeIntervalMicroSeconds32(2000000);
+ iPeriodicTimer->Start(disableTime, disableTime, callback);
+ CT_LbsRequester* request = CT_LbsRequester::NewL(this, KRequestInterval, Logger()); // TTF = 0s
+ CleanupStack::PushL(request);
+
+ // To enable tracking
+ _LIT(KRequest1, "Calling request->StartRequest1");
+ INFO_PRINTF1(KRequest1);
+ request->StartRequest(); // only one request should exist
+
+ CActiveScheduler::Start();
+
+ err = request ->CompletionCode();
+ _LIT(KErrCode, "Competion code is not KErrNone");
+ AssertTrueL(err == KErrNone, KErrCode, err);
+
+ request->GetPositionInfo(positionInfo);
+ User::After(2000000);
+
+ // Should get tracking data
+ _LIT(KRequest2, "Calling request->StartRequest2");
+ INFO_PRINTF1(KRequest2);
+ request->StartRequest(); // only one request should exist in reqlog
+
+ CActiveScheduler::Start();
+
+ err = request ->CompletionCode();
+ AssertTrueL(err == KErrNone, KErrCode, err);
+
+ request ->GetPositionInfo(positionInfo);
+ positionInfo.GetPosition(pos);
+
+ if (iUidTestTimerPsy.iUid != positionInfo.ModuleId().iUid)
+ {
+ _LIT(KIncorrectPsyError,
+ "Position from wrong PSY received");
+ LogErrorAndLeaveL(KIncorrectPsyError);
+ }
+ // TestTimerPsy returns 55.0 for Tracking requests and 20.0 for ordinary position requests
+ if (pos.Latitude() != 55.0 || pos.Longitude() != 55.0 || pos.Altitude() != 55.0)
+ {
+ LogErrorAndLeaveL(KErrorAndLeave);
+ }
+
+ _LIT(KSetPSY, "Setting up Tracking PSY");
+ INFO_PRINTF1(KSetPSY);
+ SetupPsyL(iUidTestTrackingPsy);
+ User::After(1500000); // just to let the events happen in the server.
+
+ CT_LbsRequester* request2 = CT_LbsRequester::NewL(this, interval, Logger()); // TTF = 0s
+ CleanupStack::PushL(request2);
+
+ iPeriodicTimer->Start(disableTime, disableTime, callback);
+ _LIT(KRequest3, "Calling request2->StartRequest");
+ INFO_PRINTF1(KRequest3);
+ request2->StartRequest(); // only one request should exist in reqlog
+
+ CActiveScheduler::Start();
+
+ err = request2 ->CompletionCode();
+ _LIT(KErrNotFoundCode, "Competion code is not KErrNone");
+ AssertTrueL(err == KErrNone, KErrNotFoundCode, err);
+
+ CleanupStack::PopAndDestroy(request2);
+ CleanupStack::PopAndDestroy(request);
+ CleanupStack::PopAndDestroy(moduleUpdate);
+ CleanupStack::PopAndDestroy(db);
+
+ CleanupStack::PopAndDestroy(&positioner);
+ CleanupStack::PopAndDestroy(&posServer);
+
+ RDebug::Print(_L("CT_LbsClientPosTp203::StartL end"));
+ }
+
+TInt CT_LbsClientPosTp203::DisablePsyL(TAny* aSelf)
+ {
+ // Do not forget to cancel the timer
+ CT_LbsClientPosTp203* self = static_cast<CT_LbsClientPosTp203*> (aSelf);
+ self -> iPeriodicTimer -> Cancel();
+ CPosModules* db = CPosModules::OpenL();
+ CleanupStack::PushL(db);
+ CPosModuleUpdate* moduleUpdate = CPosModuleUpdate::NewLC();
+ moduleUpdate->SetUpdateAvailability(EFalse);
+ TUid trackingId;
+ trackingId.iUid = KUidTestTrackingPsy;
+ db->UpdateModuleL(trackingId, *moduleUpdate);
+ CleanupStack::PopAndDestroy(moduleUpdate);
+ CleanupStack::PopAndDestroy(db);
+ return KErrNone;
+ }
+
+void CT_LbsClientPosTp203::RequestCompleteL()
+ {
+ CActiveScheduler::Stop();
+ }
+
+// End of File