// Copyright (c) 2006-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 "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:
// @file ctlbsclientstep_cellbasednpud.cpp
// This is the class implementation for the Notify Position Update Tests
//
//
#include "ctlbsclientstepcellbasednpud.h"
#include <lbs.h>
#include <lbssatellite.h>
#include "tlbsutils.h"
#include "ctlbsasyncwaiter.h"
// constant definitions
_LIT(KLbsClientStepCellBasedNotifyPosUpdate, "LbsClientStepCellBasedNotifyPosUpdate");
// by default, a test case will abort after this time if all callbacks not completed:
// Note that this must be less than the TEF timeout in the script to be of any value
TTimeIntervalMicroSeconds32 KDefaultAbortTimerPeriod = 90*1000000; // 1.5 mins
// by default, a test case running with real gps hardware will abort after this time
// Note that this must be less than the TEF timeout in the script to be of any value
TTimeIntervalMicroSeconds32 KDefaultAbortTimerPeriod_real = 100*1000000; // 5 mins
/**
* Destructor
*/
CT_LbsClientStep_CellBasedNotifyPosUpdate::~CT_LbsClientStep_CellBasedNotifyPosUpdate()
{
iDoPosUpdate->Cancel();
delete iDoPosUpdate;
}
/**
* Constructor
*/
CT_LbsClientStep_CellBasedNotifyPosUpdate::CT_LbsClientStep_CellBasedNotifyPosUpdate(CT_LbsClientServer& aParent) : iParent(aParent)
{
SetTestStepName(KLbsClientStep_CellBasedNotifyPosUpdate);
}
/**
Static Constructor
*/
CT_LbsClientStep_CellBasedNotifyPosUpdate* CT_LbsClientStep_CellBasedNotifyPosUpdate::New(CT_LbsClientServer& aParent)
{
// Can't leave, so return NULL if insufficient memory
CT_LbsClientStep_CellBasedNotifyPosUpdate* testStep = new CT_LbsClientStep_CellBasedNotifyPosUpdate(aParent);
if (testStep)
{
TInt err = KErrNone;
TRAP(err, testStep->ConstructL());
if (err)
{
delete testStep;
testStep = NULL;
}
}
return testStep;
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::ConstructL()
{
// Create the base class object.
CT_LbsNetSimStep::ConstructL();
// Active object wrapper for the notify position update.
iDoPosUpdate = CT_LbsDoPosUpdate::NewL(this, TPositionModuleInfo::ETechnologyNetwork);
}
/**
* @return - TVerdict code
* Override of base class pure virtual
* Our implementation only gets called if the base class doTestStepPreambleL() did
* not leave. That being the case, the current test result value will be EPass.
*/
TVerdict CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL()
{
// Generic test step used to test the LBS Client Notify position update API.
INFO_PRINTF1(_L(">>CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL()"));
if (TestStepResult()==EPass) // TODO still don't see why we need this...
{
iNetworkUnavailable = FALSE;
iIsCancelTest = FALSE;
iCancel = FALSE;
iCancelOnPosUpdate = FALSE;
iCancelBeforePosUpdate = FALSE;
iMultiReq = EFalse;
iNumNPUDs = iParent.iSharedData->iVerifyPosInfoArr.Count(); // how many NPUDs to do
// Expected callbacks flags
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_NetworkBasedLocation |
KLbsCallback_Got_NotifyPositionUpdate; // notifypositionupdate completed.
TTimeIntervalMicroSeconds32 abortInterval;
if(iParent.iSharedData->iTestModuleInUse)
{
abortInterval = KDefaultAbortTimerPeriod;
}
else
{
abortInterval = KDefaultAbortTimerPeriod_real;
}
// Carryout unique test actions.
TInt testCaseId;
if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))
{
switch (testCaseId)
{
case 1: // LBS-NotifyPosUpdateCellBased-0001 Request a cell-based location
{
// nothing to do
}
break;
case 2: // LBS-NotifyPosUpdateCellBased-0002 Request a cell-based location and cancel before it completes
{
iCancel = ETrue;
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_Got_NotifyPositionUpdate;
}
break;
case 3: // LBS-NotifyPosUpdateCellBased-0003 Request a cell-based location, when network unavailable
{
iNetworkUnavailable = ETrue;
// TO DO - are these the right flags (get NO NetSIm callbacks while network unavailable)?
iFlagsToHaltOn &= ~KLbsCallback_NetworkBasedLocation;
}
break;
case 4: // LBS-NotifyPosUpdateCellBased-0004 multiple sequential npuds
{
iMultiReq = ETrue;
}
break;
case 5: // LBS-NotifyPosUpdateCellBased-0005 Request a cell-based location and attempt to cancel when the update is received
{
iCancelOnPosUpdate = ETrue;
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_Got_NotifyPositionUpdate;
}
break;
case 6: // LBS-NotifyPosUpdateCellBased-0006 Request a cell-based location and cancel before a position update is generated
{
iCancelBeforePosUpdate = ETrue;
iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect |
KLbsCallback_Got_NotifyPositionUpdate;
}
break;
default:
User::Panic(KLbsClientStepCellBasedNotifyPosUpdate, KErrUnknown);
}
}
else
{
User::Panic(KLbsClientStepCellBasedNotifyPosUpdate, KErrUnknown);
}
iIsCancelTest = (iCancel || iCancelBeforePosUpdate || iCancelOnPosUpdate);
// Steps common to all tests:
// Connect to net sim
iNetSim.ConnectL(this);
// Configure NetSim:
// Set reference location:
RPointerArray<TAny>& srcPosInfoArr = iParent.iSharedData->iVerifyPosInfoArr;
TPositionInfo* srcPosInfo = reinterpret_cast<TPositionInfo*>(srcPosInfoArr[0]);
TPosition srcPos;
srcPosInfo->GetPosition(srcPos);
if (!iNetSim.SetReferenceLocation(srcPos))
{
INFO_PRINTF1(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL() Failed: Can't set NetSim's reference location."));
SetTestStepResult(EFail);
}
// Set plugin to use for getting assistance data:
TUid pluginUid;
if(iParent.iSharedData->iTestModuleInUse)
{
pluginUid = TUid::Uid(KSimpleAssistanceDataProviderPluginUidValue);
}
else
{
pluginUid = TUid::Uid(KSuplAssistanceDataProviderPluginUidValue);
}
if (!iNetSim.SetAssistanceDataProvider(pluginUid))
{
INFO_PRINTF1(_L("Can't set NetSim's assistance data plugin uid."));
SetTestStepResult(EFail);
}
// make network unavailable if appropriate:
if(iNetworkUnavailable)
{
// Tell netsim to make network unavailable until further notice:
if(!iNetSim.SetResponseError(RLbsNetSimTest::KNetSimNetworkNotAvailable, ETrue)) //sticky
{
INFO_PRINTF1(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL() Failed: Can't set NetSim's response error."));
SetTestStepResult(EFail);
}
}
// Kick off the keep alive timer - do last to ensure NetSim is ready otherwise the
// timer callback may start a MO-LR if the NetSim connected too early.
TTimeIntervalMicroSeconds32 interval(KLbsKeepAlivePeriod);
iKeepAliveTimer->SetTimer(interval);
// don't wait for TEF to timeout and abort
iAbortTimer->SetTimer(abortInterval);
// Kick off test.
CActiveScheduler::Start();
if(EDone != iState)
{
INFO_PRINTF2(_L("Failed test, finished in state %d"), iState);
INFO_PRINTF3(_L("Callback flags currently set = 0x%x. Expecting 0x%x"), iCallbackFlags, iFlagsToHaltOn);
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF2(_L("Got all expected callbacks (0x%x)"), iCallbackFlags);
}
iNetSim.Close();
}
INFO_PRINTF1(_L("<<CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL()"));
return TestStepResult();
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::Connected()
{
// Call base implementation.
CT_LbsNetSimStep::Connected();
if(iCancelBeforePosUpdate)
{
TPositionInfo* posInfo = new(ELeave) TPositionInfo();
iDoPosUpdate->StartL(*posInfo);
iNumNPUDs--;
// Wait for all expected callback flags to be set:
iState = CT_LbsNetSimStep::EWaiting;
// Cancel the request for the cancel test.
iDoPosUpdate->CancelRequest();
delete posInfo;
}
else
{
T_LbsUtils utils;
// Create a posinfo and store in our shared array for later verification.
RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
TPositionInfo* posInfo = new(ELeave) TPositionInfo();
utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended.
posInfoArr.Append(posInfo);
iDoPosUpdate->StartL(*posInfo);
iNumNPUDs--;
// Wait for all expected callback flags to be set:
iState = CT_LbsNetSimStep::EWaiting;
// Cancel the request for the cancel test.
if(iCancel)
{
User::After((TTimeIntervalMicroSeconds32)100000); // arbitrary delay as workaround for DEF107349
iDoPosUpdate->CancelRequest();
}
}
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::Disconnected()
{
// Call base implementation.
CT_LbsNetSimStep::Disconnected();
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyRegisterLcsMoLr(const TDesC& aData)
{
if (!iIsCancelTest)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyRegisterLcsMoLr(aData);
}
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyReleaseLcsMoLr(TInt aReason)
{
if (!iIsCancelTest)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyReleaseLcsMoLr(aReason);
}
}
// Measurement Control has been received from Network:
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyMeasurementControlLocation(const TPositionInfo& aPosition, const RLbsAssistanceDataBuilderSet& aData, const TLbsNetPosRequestQuality& aQuality)
{
if (!iIsCancelTest)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyMeasurementControlLocation(aPosition, aData, aQuality);
}
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyReleaseLcsLocationNotification(const CLbsNetworkProtocolBase::TLbsPrivacyResponse& aResult)
{
if (!iIsCancelTest)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyReleaseLcsLocationNotification(aResult);
}
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyFacilityLcsMoLrResult(TInt aReason, const TPositionInfo& aPosition)
{
if (!iIsCancelTest)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyFacilityLcsMoLrResult(aReason, aPosition);
}
}
// Our position has been reported to network
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyMeasurementReportLocation(const TPositionInfo& aPosition)
{
if(iCancelOnPosUpdate)
{
iDoPosUpdate->CancelRequest();
}
if (!iIsCancelTest)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyMeasurementReportLocation(aPosition);
}
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyMeasurementReportRequestMoreAssistanceData(const TLbsAssistanceDataGroup& aFilter)
{
if (!iIsCancelTest)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyMeasurementReportRequestMoreAssistanceData(aFilter);
}
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyMeasurementReportControlFailure(TInt aReason)
{
if (!iIsCancelTest && !iMultiReq)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyMeasurementReportControlFailure(aReason);
}
else if (iMultiReq && ! ((aReason == KErrPositionHighPriorityReceive) || (aReason == KErrServerBusy)))
{
INFO_PRINTF2(_L("FAILED: NotifyMeasurementReportControlFailure with reason = %d"), aReason);
SetTestStepResult(EFail);
}
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyError(MLbsNetSimTestObserver::EFunction aFunction, int aError)
{
// Call base implementation.
CT_LbsNetSimStep::NotifyError(aFunction, aError);
}
void CT_LbsClientStep_CellBasedNotifyPosUpdate::ProcessMeasurementControlLocationError(TInt aError)
{
// Call base implementation.
CT_LbsNetSimStep::ProcessMeasurementControlLocationError(aError);
}
/** Notify position update callback.
*/
void CT_LbsClientStep_CellBasedNotifyPosUpdate::MT_LbsDoPosUpdateCallback(TRequestStatus& aStatus)
{
TInt err = aStatus.Int();
INFO_PRINTF2(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::MT_LbsDoPosUpdateCallback: Got - Notify Update - Callback Event. Error = %d"), err);
if(!iNumNPUDs) // only set the flag when we've got them all
{
SetCallbackFlag(KLbsCallback_Got_NotifyPositionUpdate);
}
if(iNetworkUnavailable)
{
if(KErrTimedOut != err && KErrDisconnected != err)
{
INFO_PRINTF2(_L("FAILED: MT_LbsDoPosUpdateCallback with error %d, expecting KErrTimedOut"), err);
SetTestStepResult(EFail);
}
}
else
{
if(iCancel)
{
if(KErrCancel != err && KErrNone != err)
{
INFO_PRINTF2(_L("FAILED: MT_LbsDoPosUpdateCallback with error = %d"), err);
SetTestStepResult(EFail);
}
}
else
{
if(iCancelBeforePosUpdate)
{
if(KErrCancel != err)
{
INFO_PRINTF2(_L("FAILED: MT_LbsDoPosUpdateCallback with error = %d"), err);
SetTestStepResult(EFail);
}
}
else
{
if(KErrNone != err)
{
INFO_PRINTF2(_L("FAILED: MT_LbsDoPosUpdateCallback with error = %d"), err);
SetTestStepResult(EFail);
}
}
}
}
if(iNumNPUDs--)
{
// Create another posinfo and store in our shared array for later verification.
RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
TPositionInfo* posInfo = new(ELeave) TPositionInfo();
posInfoArr.Append(posInfo);
iDoPosUpdate->StartL(*posInfo);
}
}