// 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 "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:

//

// 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