// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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 <e32base.h>

#include <lbspositioninfo.h>

#include <lbs/epos_cpositioner.h>

#include <lbs/epos_cposmodules.h>

#include <lbs/epos_mposmodulesobserver.h>

#include "lbsdevloggermacros.h"

#include "EPos_ServerPanic.h"

#include "EPos_Global.h"

#include "EPos_CPosCallbackTimer.h"

#include "EPos_CPositionRequest.h"

#include "epos_cposmodulessettings.h"

//TODO Verify

#include "EPos_CPosLocMonitorReqHandlerHub.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "EPos_CPositionRequestTraces.h"

#endif

// CONSTANTS

#ifdef _DEBUG

_LIT(KTraceFileName, "EPos_CPositionRequest.cpp");

#endif

const TInt KParamPositionInfo = 0;

// ================= LOCAL FUNCTIONS ========================

void CancelTimerCleanup(TAny* aTimer)

    {

    (static_cast<CPosCallbackTimer*>(aTimer))->Cancel();

    }

inline TPositionInfoBase& PositionInfoBase(HBufC8* aBuffer)

    {

        return reinterpret_cast<TPositionInfoBase&>

        (const_cast<TUint8&>(*aBuffer->Ptr()));

    }

inline TPositionInfo& PositionInfo(HBufC8* aBuffer)

    {

        return reinterpret_cast<TPositionInfo&>

        (const_cast<TUint8&>(*aBuffer->Ptr()));

    }

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CPositionRequest::CPositionRequest(

    CPosModuleSettings& aModuleSettings,

    CPosLocMonitorReqHandlerHub& aLocMonitorReqHandlerHub,

    TProxyPositionerConstructParams& aPositionerParams,

    TBool aIsProxy)

:

    CActive(EPriorityStandard),

    iRequestPhase(EPosReqInactive),

    iPositionerParams(aPositionerParams),

    iHasProxyPositioner(aIsProxy),

    iLocMonitorReqHandler(aLocMonitorReqHandlerHub),

    {

    CActiveScheduler::Add(this);

    }

// EPOC default constructor can leave.

void CPositionRequest::ConstructL()

    {

    TCallBack timeoutCallBack(HandleTimeOut, this);

    iTimeoutTimer = CPosCallbackTimer::NewL(timeoutCallBack);

    TCallBack trackingCallBack(TrackingCallback, this);

    iTrackingTimer = CPosCallbackTimer::NewL(trackingCallBack);

    iModuleSettings.PosModules().GetModuleInfoL(

        iPositionerParams.iImplementationUid, 

        iModuleInfo);

    if (!iModuleInfo.IsAvailable())

        {

        User::Leave(KErrNotFound);

        }

    LoadPositionerL();

    }

/**

 * Two-phased constructor.

 *

 * @param aModules Location Settings reference

 * @param aLocMonitorReqHandlerHub The hub for requests to the location monitor.

 * @param aPositionerParams contruction parameters needed when creating

 *        positioner.

 * @param aIsProxy ETrue if aImplementationUid represents a proxy PSY,

 *        EFalse otherwise.

 */

CPositionRequest* CPositionRequest::NewL(

    CPosModuleSettings& aModuleSettings,

    CPosLocMonitorReqHandlerHub& aLocMonitorReqHandlerHub,

    TProxyPositionerConstructParams& aPositionerParams,

    TBool aIsProxy)

    {

    CPositionRequest* self = new (ELeave) CPositionRequest(

        aModuleSettings,

        aLocMonitorReqHandlerHub,

        aPositionerParams,

        aIsProxy);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

 * Destructor.

 */

CPositionRequest::~CPositionRequest()

    {

    // Panic client if request is outstanding

    if (IsActive())

        {

        iMessage.Panic(KPosClientFault, EPositionRequestsNotCancelled);

        }

    Cancel();

    if (iTrackingState == EPosTracking)

        {

        StopTracking();

        }

    delete iTrackingTimer;

    delete iPositionBuffer;

    delete iTimeoutTimer;

    delete iPositioner;

    }

/**

 * Starts a position request cycle. Should only be called when PSY is 

 * enabled.

 * @param aMessage the request message from the client

 */

void CPositionRequest::MakeRequestL(const RMessage2& aMessage)

    {

    if (!iModuleInfo.IsAvailable())

        {

        User::Leave(KErrNotFound);

        }

    __ASSERT_DEBUG(iPositioner, DebugPanic(EPosServerPanicPositionerNotInitialized));

    iMessage = aMessage; // Store parameter here in case of leave.

    // Clear previous position data

    delete iPositionBuffer;

    iPositionBuffer = NULL;

    HBufC8* clientBuf = Global::CopyClientBuffer8LC(aMessage, KParamPositionInfo);

    CleanupStack::Pop(clientBuf);

    iPositionBuffer = clientBuf;

    TPositionInfoBase& infoBase = PositionInfoBase(iPositionBuffer);

    TUint32 classType = infoBase.PositionClassType();

    TUint32 classesSupported = iModuleInfo.ClassesSupported(EPositionInfoFamily);

    // Check that classtype is supported and is of type TPositionInfo

    if ((classType != (classType & classesSupported)) ||

        !(classType & EPositionInfoClass))

        {

        User::Leave(KErrArgument);

        }

    // Set ModuleId to KNullId to be able to verify that Id is set by PSY.

    infoBase.SetModuleId(KNullUid);

    CleanupStack::PushL(TCleanupItem(CancelTimerCleanup, iTimeoutTimer));

    // Start timer if necessary

    if (iTimeOut.Int64() > 0)

        {

        LBS_RDEBUG_INFO("CPositionRequest::MakeRequestL() Start Timeout Timer");

        iTimeoutTimer->StartTimer(iTimeOut);

        }

    LBS_RDEBUG_VAR_INT("CPositionRequest::MakeRequestL() iTrackingState", iTrackingState);

    switch (iTrackingState)

        {

        case EPosNoTracking:

        case EPosFirstTrackingRequest:

            StartPositionDataRequestPhase();

            break;

        case EPosTracking:

            StartTrackingTimerWaitPhase();

            break;

        case EPosStopTracking:

            // This must have been handled by Cancel or RunL

        default:

            DebugPanic(EPosServerPanicTrackingInconsistency);

        }

    CleanupStack::Pop(iTimeoutTimer);

    }

/**

 * Set the TPositionUpdateOptions object.

 *

 * When this class is constructed, the TPositionUpdateOptions object

 * is constructed using default constructor with no parameters.

 *

 * @param aOptions The update options from the client.

 */

void CPositionRequest::SetUpdateOptions(

    const TPositionUpdateOptionsBase& aOptions)

    {

    iTimeOut = aOptions.UpdateTimeOut();

    TTimeIntervalMicroSeconds newInterval = aOptions.UpdateInterval();

    TTimeIntervalMicroSeconds oldInterval = iTrackingUpdateInterval;

    if (newInterval != iTrackingUpdateInterval)

        {

        iTrackingUpdateInterval = newInterval;

        if (newInterval == 0) // "stop periodic updates"

            {

            switch (iTrackingState)

                {

                case EPosFirstTrackingRequest:

                    iTrackingState = EPosNoTracking;

                    break;

                case EPosTracking:

                    if (!IsActive())

                        {

                        // can stop it right now

                        StopTracking();

                        }

                    else

                        {

                        // mark to stop later

                        iTrackingState = EPosStopTracking;

                        }

                    break;

                case EPosNoTracking:

                case EPosStopTracking:

                    break;

                default:

                    DebugPanic(EPosServerPanicTrackingInconsistency);

                    break;

                }

            }

        else if (oldInterval != 0) // "use another update interval"

            {

            if (iRequestPhase == EPosReqInactive)

                {

                TInt err;

                TRAP(err, RestartTrackingL());

                }

            else

                {

                // can't affect outstanding request

                // postpone until request is completed

                // it will be handled by RunL or DoCancel

                // via HandleTrackingStateL

                iNewTrackingInterval = ETrue;

                }

            }

        else

            {

            // oldInterval == 0

            // newInterval != 0

            // it means - "start periodic updates"

            iTrackingState = EPosFirstTrackingRequest;

            }

        }

    }

/**

 * Get the TPositionUpdateOptions object.

 * @param aOptions The TPositionUpdateOptions object.

 */

void CPositionRequest::GetUpdateOptions(

    TPositionUpdateOptionsBase& aOptions) const

    {

    aOptions.SetUpdateTimeOut(iTimeOut);

    aOptions.SetUpdateInterval(iTrackingUpdateInterval);

    }

/**

 * Stops current tracking session

 */

void CPositionRequest::NewTrackingSessionIfTracking()

    {

    /* Requestor has been changed. Call Privacy Server. */

    }

/**

 * Called when changes in locations settings occur.

 * @param aEvent Event information

 */

void CPositionRequest::HandleSettingsChangeL(TPosModulesEvent aEvent)

    {

    if (aEvent.iModuleId != iModuleInfo.ModuleId())

        {

        return;

        }

    switch (aEvent.iType)

        {

        case EPosModulesEventAvailabilityChanged:

        case EPosModulesEventModuleInstalled:

            iModuleSettings.PosModules().GetModuleInfoL(

                iModuleInfo.ModuleId(), 

                iModuleInfo);

            break;

        case EPosModulesEventModuleRemoved:

            iModuleInfo.SetIsAvailable(EFalse);

            break;

        default:

            return;

        }

        {

        if (IsActive())

            {

            CompleteClient(KErrNotFound);

            Cancel();

            }

        // Unuse positioner and unload it

        if (iTrackingState == EPosTracking)

            {

            StopPsyTracking();

            }

        delete iPositioner;

        iPositioner = NULL;

        }

    else if (!iPositioner)

        {

        // psy is re-enabled after being disabled

        LoadPositionerL();

        if (iTrackingState == EPosTracking)

            {

            StartPsyTrackingL();

            }

        }

    else

        {

        // shouldn't happen, but if it does, ignore it

        }

    }

/**

 * Called when the server class is shutting down.

 */

void CPositionRequest::NotifyServerShutdown()

    {

    if (IsActive())

        {

        DEBUG_TRACE("CPositionRequest::NotifyServerShutdown() with active request", __LINE__)

        CompleteClient(KErrServerTerminated);

        Cancel();

        }

    if (iTrackingState == EPosTracking)

        {

        StopTracking();

        }

    delete iPositioner;

    iPositioner = NULL;

    }

/**

 * From CActive

 */

void CPositionRequest::RunL()

    {

    LBS_RDEBUG_VAR_INT("CPositionRequest::RunL() iRequestPhase", iRequestPhase);

    TInt err = iStatus.Int();

    switch (iRequestPhase)

        {

        case EPosReqPositionRequest:

            {

            LBS_RDEBUG_INFO("CPositionRequest::RunL() EPosReqPositionRequest");

            // Position request finished. Cancel timer.

            iTimeoutTimer->Cancel();

            iRequestPhase = EPosReqInactive;

            CompleteRequest(err);

            HandleTrackingStateL(); // don't care if it leaves

            break;

            }

        case EPosWaitForTracking:

            StartPositionDataRequestPhase();

            break;

        default :

        	DEBUG_TRACE("CPositionRequest::RunL() panicing", __LINE__)

            DebugPanic(EPosServerPanicRequestInconsistency);

        }

    }

/**

 * From CActive

 */

TInt CPositionRequest::RunError(TInt /*aError*/)

    {

    // Happens only if HandleTrackingStateL leaves

    // which in turn means that StartTrackingL leaved somewhere

    // As request is already completed, just ignore the error

    return KErrNone;

    }

/**

 * From CActive

 */

void CPositionRequest::DoCancel()

    {

    OstTraceFunctionEntry1( CPOSITIONREQUEST_DOCANCEL_ENTRY, this );

    LBS_RDEBUG_VAR_INT("CPositionRequest::DoCancel() iRequestPhase", iRequestPhase);

    iTimeoutTimer->Cancel();

    switch (iRequestPhase)

        {

        case EPosReqPositionRequest:

            {

            __ASSERT_DEBUG(iPositioner, DebugPanic(EPosServerPanicPositionerNotInitialized));

            DEBUG_TRACE("calling CPositioner::CancelNotifyPositionUpdate()", __LINE__)

            if(iRequestTimedOut)

            	{

            	iPositioner->CancelNotifyPositionUpdate(KErrTimedOut);

            	}

            else

            	{

            	iPositioner->CancelNotifyPositionUpdate();

            	}

            break;

            }

        case EPosWaitForTracking:

            CompleteSelf(KErrCancel);

            break;

        default:

        	DEBUG_TRACE("CPositionRequest::DoCancel() panicing", __LINE__)

            DebugPanic(EPosServerPanicRequestInconsistency);

        }

    TInt err;

    if (iRequestTimedOut)

        {

        iRequestTimedOut = EFalse;

        CompleteClient(KErrTimedOut);

        TRAP(err, HandleTrackingStateL());

        }

    else

        {

        CompleteClient(KErrCancel);

        // Handle Tracking State

        if (iTrackingState == EPosStopTracking)

            {

            StopTracking();

            }

        }

    iRequestPhase = EPosReqInactive;

    OstTraceFunctionExit1( CPOSITIONREQUEST_DOCANCEL_EXIT, this );

    }