// 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 "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:
// @file ctlbsclientstepmultireq.cpp
// This is the class implementation for the Multi-Request Tests
//
//
#include "ctlbsclientstepmultireq.h"
#include <lbs.h>
#include <lbscommon.h>
#include <lbspositioninfo.h>
#include <lbsipc.h>
#include "tlbsutils.h"
// constant definitions
_LIT(KLbsClientStepMultiReq, "LbsClientStepMultiReq");
/**
* Destructor
*/
CT_LbsClientStep_MultiReq::~CT_LbsClientStep_MultiReq()
{
delete iGetLastKnownPosAO;
delete iNotifyPosUpdateAO;
delete iTimer;
delete iTempPosInfo;
}
/**
* Constructor
*/
CT_LbsClientStep_MultiReq::CT_LbsClientStep_MultiReq(CT_LbsClientServer& aParent) : CT_LbsClientStep(aParent), iState(EStateUnknown), iTempPosInfo(NULL)
{
SetTestStepName(KLbsClientStep_MultiReq);
}
/**
Static Constructor
*/
CT_LbsClientStep_MultiReq* CT_LbsClientStep_MultiReq::NewL(CT_LbsClientServer& aParent)
{
return new(ELeave) CT_LbsClientStep_MultiReq(aParent);
}
/**
Static Constructor
*/
CT_LbsClientStep_MultiReq* CT_LbsClientStep_MultiReq::New(CT_LbsClientServer& aParent)
{
return new CT_LbsClientStep_MultiReq(aParent);
// Note the lack of ELeave.
// This means that having insufficient memory will return NULL;
}
/**
* Callback - called when NotifyPositionUpdate request completes
*/
void CT_LbsClientStep_MultiReq::NotifyPositionUpdateCallback(TRequestStatus& aStatus)
/**
* Called when async NotifyPositionUpdate completes
*/
{
TInt testCaseId;
if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))
{
switch (testCaseId)
{
case 01: // multiple requests of different types
{
if(KErrNone == aStatus.Int())
{
switch(iState)
{
case EStateUnknown:
{
iState = EStateLastNotifyPositionUpdateComplete;
}
break;
case EStateLastKnownPositionComplete:
{
iState = EStateDone;
AsyncTidyUp();
// note: we'll now drop back into the main test step
}
break;
case EStateLastNotifyPositionUpdateComplete:
case EStateDone :
// fall through
default:
{
User::Panic(KLbsClientStepMultiReq, KErrUnknown);
}
break;
}
}
else
{
INFO_PRINTF2(_L("NotifyModuleStatusEvent completed. Status = %d"), aStatus.Int());
SetTestStepResult(EFail);
AsyncTidyUp();
}
}// end case 01
break;
case 02: //
{
switch(iState)
{
case EStateUnknown:
{
iState = EStateLastNotifyPositionUpdateComplete;
}
break;
case EStateLastKnownPositionComplete:
{
iState = EStateDone;
AsyncTidyUp();
}
break;
case EStateLastNotifyPositionUpdateComplete:
case EStateDone :
// fall through
default:
{
User::Panic(KLbsClientStepMultiReq, KErrUnknown);
}
break;
}
}
break;
default:
{
User::Panic(KLbsClientStepMultiReq, KErrUnknown);
}
}// end switch testCaseId
}// end if GetIntFromConfig
}
/**
* Callback - called when GetLastKnownPosition request completes
*/
void CT_LbsClientStep_MultiReq::GetLastKnownPositionCallback(TRequestStatus& aStatus)
/**
* Called when NotifyModuleStatusEvent completes
*/
{
TInt testCaseId;
if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))
{
switch (testCaseId)
{
case 01: // multiple requests of different types
{
if(KErrNone == aStatus.Int())
{
switch(iState)
{
case EStateUnknown:
{
iState = EStateLastKnownPositionComplete;
}
break;
case EStateLastNotifyPositionUpdateComplete:
{
iState = EStateDone;
AsyncTidyUp();
// note: we'll now drop back into the main test step
}
break;
case EStateLastKnownPositionComplete:
case EStateDone :
// fall through
default:
{
User::Panic(KLbsClientStepMultiReq, KErrUnknown);
}
break;
}
}
else
{
INFO_PRINTF2(_L("NotifyModuleStatusEvent completed. Status =%d"), aStatus.Int());
SetTestStepResult(EFail);
AsyncTidyUp();
}
}// end case 01
break;
case 02: // NotifyPositionUpdate then GetLKP, latter cancelled
{
switch(iState)
{
case EStateUnknown:
{
iState = EStateLastKnownPositionComplete;
TInt err = aStatus.Int();
switch(err)
{
case KErrNone:
{
INFO_PRINTF1(_L("MultiReq test: Last Known Position request completed successfully"));
}
break;
case KErrCancel:
{
INFO_PRINTF1(_L("MultiReq test: Last Known Position request completed with KErrCancel"));
}
break;
case KErrUnknown:
{
INFO_PRINTF1(_L("MultiReq test: Last Known Position request completed with KErrUnknown"));
}
break;
default:
{
SetTestStepResult(EFail);
AsyncTidyUp();
}
break;
}
}
break;
case EStateLastNotifyPositionUpdateComplete:
{
iState = EStateDone;
TInt err = aStatus.Int();
if(KErrNone != err)
{
SetTestStepResult(EFail);
}
AsyncTidyUp();
}
break;
case EStateLastKnownPositionComplete:
case EStateDone :
// fall through
default:
{
User::Panic(KLbsClientStepMultiReq, KErrUnknown);
}
}// end switch(iState)
}// end case 2
break;
default:
{
User::Panic(KLbsClientStepMultiReq, KErrUnknown);
}
break;
}
}
}
/**
* tidy up everything
*/
void CT_LbsClientStep_MultiReq::AsyncTidyUp()
{
if ( iTimer->IsActive() )
{
iTimer->Cancel();
}
// Cancel any outstanding requests (to be tested):
if(iNotifyPosUpdateAO->IsActive())
{
iNotifyPosUpdateAO->Cancel();
}
if(iGetLastKnownPosAO->IsActive())
{
iGetLastKnownPosAO->Cancel();
}
CActiveScheduler::Stop();
}
/**
* Callback function - called if timer fires (requests did not all complete in time)
*/
static TInt TimerCallback(TAny* aPointer)
{
//the timer expired and we have not got the responses to our lbs requests
static_cast<CT_LbsClientStep_MultiReq*>(aPointer)->INFO_PRINTF1(_L(">>TEST FAILED: timer fired"));
static_cast<CT_LbsClientStep_MultiReq*>(aPointer)->AsyncTidyUp();
static_cast<CT_LbsClientStep_MultiReq*>(aPointer)->SetTestStepResult(EFail);
return KErrNone;
}
/**
* @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_MultiReq::doTestStepL()
{
// Generic test step used to test the LBS Client Notify position update API.
INFO_PRINTF1(_L(">>CT_LbsClientStep_MultiReq::doTestStepL()"));
if (TestStepResult()==EPass)
{
// Connect to self locate server.
User::LeaveIfError(iServer.Connect());
CleanupClosePushL(iServer);
TInt testCaseId;
if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId))
{
switch (testCaseId)
{
case 01: // multiple requests of different types
{
// Open positioner.
User::LeaveIfError(iPositioner.Open(iServer));
CleanupClosePushL(iPositioner);
// Carry out a notify update to ensure last known cache is filled (note: this blocks!)
TPositionInfo notifyPosInfo;
User::LeaveIfError(DoNotifyUpdateL(notifyPosInfo));
// Create 2 posinfos and store in our shared array for later verification.
RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
TPositionInfo* posInfoLastKnown = new(ELeave) TPositionInfo();
TPositionInfo* posInfoNotifyUpd = new(ELeave) TPositionInfo();
T_LbsUtils utils;
utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended.
// these get deleted by the base class destructor
posInfoArr.Append(posInfoLastKnown);
posInfoArr.Append(posInfoNotifyUpd);
// Start GetLastKnownPosition request:
iGetLastKnownPosAO = CT_LbsClientGetLastKnownPosAO::NewL(*this);
iGetLastKnownPosAO->GetLastKnownPosL(iPositioner, *posInfoLastKnown);
// Start NotifyPositionUpdate request:
iNotifyPosUpdateAO = CT_LbsClientNotifyPosUpdAO::NewL(*this);
iNotifyPosUpdateAO->NotifyPosUpdateL(iPositioner, *posInfoNotifyUpd);
// Start a timer to make sure neither of above times out:
iTimer = CPeriodic::New(CActive::EPriorityStandard);
TCallBack callbackFunction = TCallBack(TimerCallback, this);
iTimer->Start( delay10Seconds, 0, callbackFunction);
// can start the scheduler now as there are async requests issued
CActiveScheduler::Start();
// All requests have now completed (and scheduler stopped)
CleanupStack::PopAndDestroy(&iPositioner);
} // end case 1
break;
case 02: // cancel one of two outstanding requests
{
// Open positioner.
User::LeaveIfError(iPositioner.Open(iServer));
CleanupClosePushL(iPositioner);
// Create a posinfo and store in our shared array for later verification.
RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
TPositionInfo* posInfoNotifyUpd = new(ELeave) TPositionInfo();
T_LbsUtils utils;
utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended.
// this gets deleted by the base class destructor:
posInfoArr.Append(posInfoNotifyUpd);
// Start NotifyPositionUpdate request:
iNotifyPosUpdateAO = CT_LbsClientNotifyPosUpdAO::NewL(*this);
iNotifyPosUpdateAO->NotifyPosUpdateL(iPositioner, *posInfoNotifyUpd);
// Start a GetLastKnownPosition:
// don't put in verify array as this may be cancelled:
iTempPosInfo = new(ELeave) TPositionInfo();
iGetLastKnownPosAO = CT_LbsClientGetLastKnownPosAO::NewL(*this);
iGetLastKnownPosAO->GetLastKnownPosL(iPositioner, *iTempPosInfo);
// cancel the last known position. Note that we do this directly, NOT by calling the AO's cancel()
// so that the AO's RunL(), and therefore our callback, will be called and we can check the result
TInt err;
err = iPositioner.CancelRequest(EPositionerGetLastKnownPosition);
if(KErrNotFound != err)
{
SetTestStepResult(EFail);
}
// Start a timer to make sure neither of above times out:
iTimer = CPeriodic::New(CActive::EPriorityStandard);
TCallBack callbackFunction = TCallBack(TimerCallback, this);
//
//
// NB - THIS VALUE WAS 10 SEC AND THE TIMER EXPIRED, CAUSING THE TEST
// TO FAIL. NEED TO FIND OUT WHY THIS VALUE IS OK BUT THAT ONE WAS NOT.
// PUT BACK TEMPORARILY TO GET RID OF REGRESSION FAILURE
//
iTimer->Start( 22000000, 0, callbackFunction);
// can start the scheduler now as there are async requests issued
CActiveScheduler::Start();
// All requests have now completed
CleanupStack::PopAndDestroy(&iPositioner);
}
break;
default:
{
User::Leave(KErrArgument);
}
}// end switch
}//end if GetIntFromConfig
CleanupStack::PopAndDestroy(&iServer);
} // end if TestStepResult
INFO_PRINTF1(_L("<<CT_LbsClientStep_MultiReq::doTestStepL()"));
return TestStepResult();
}