// 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 <lbs.h>

#include "lbslocservermessageenums.h"

#include <lbs/epos_mposmodulesobserver.h>

#include <lbs/epos_cposmoduleidlist.h>

#include <lbs/epos_cpositioner.h>

#include "EPos_PositionerConstructParams.h"

#include "lbsdevloggermacros.h"

#include "eposuid.hrh"

#ifdef _DEBUG

#include <lbs/epos_cpostrace.h>

#endif

#include "EPos_CPosSession.h"

#include "EPos_CPosSubSession.h"

#include "EPos_CPosServer.h"

#include "EPos_CPosSubsessionRegistry.h"

#include "EPos_Global.h"

#include "EPos_CPosModulesStatus.h"

#include "epos_cposmodulessettings.h"

// CONSTANTS

#ifdef _DEBUG

_LIT(KTraceFileName, "EPos_CPosSession.cpp");

#endif

const TPositionModuleId KPosDefaultModule = { KPosDefaultPsyImplUid };

const TPositionModuleId KPosStrategyModule = { KPosStrategyPsyImplUid };

const TInt KParamCriteria = 0;

const TInt KParamNumModules = 0;

const TInt KParamModuleIdOpen = 0;

const TInt KParamModuleIdGetInfo = 0;

const TInt KParamModuleIdGetStatus = 0;

const TInt KParamModuleIdGetDefault = 0;

const TInt KParamModuleInfo = 1;

const TInt KParamModuleStatusGet = 1;

const TInt KParamSubsession = 3;

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

/**

 * C++ constructor.

 */

CPosSession::CPosSession(CPosServer& aServer,

                         CPosModuleSettings& aModuleSettings,

                         CPosModulesStatus& aModulesStatus,

                         CPosLocMonitorReqHandlerHub& aLocMonitorReqHandlerHub)

    : iPosServer(aServer),

      iModuleSettings(aModuleSettings),

      iModulesStatus(aModulesStatus),

      iLocMonitorReqHandlerHub(aLocMonitorReqHandlerHub)

    {      

    }

/**

 * C++ destructor.

 */

CPosSession::~CPosSession()

    {

    delete iSubSessionRegistry;

    // The flag iServerShutdown prevents calling the server or its members if

    // it is already destroyed.

    if (!iServerShutdown)

        {

        iModulesStatus.NotifySessionClosed(this); 

        iLocMonitorReqHandlerHub.NotifySessionClosed( const_cast<const CSession2*>( static_cast<CSession2*> (this) ) ); //TODO ????????????????????????????????????????????

        if (iDecrementSessions)

            {

            iPosServer.DecrementSessions();

            }

        }

    }

/**

 * Two-phased constructor.

 *

 * @param aServer Pointer to the server Active Object

 * @param aModules Modules settings.

 * @param aModulesStatus Pointer to the ModulesStatus object.

 * @param aLastPositionHandler Last Position Handler.

 * @return Pointer to a new instance of CPosSession

 */

CPosSession* CPosSession::NewL(CPosServer& aServer,

                               CPosModuleSettings& aModuleSettings,

                               CPosModulesStatus& aModulesStatus,

                               CPosLocMonitorReqHandlerHub& aLocMonitorReqHandlerHub)

    {

    CPosSession* self = new (ELeave)

        CPosSession(

            aServer, 

            aModuleSettings, 

            aModulesStatus, 

            aLocMonitorReqHandlerHub);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

 * Symbian destructor.

 */

void CPosSession::ConstructL()

    {

    iSubSessionRegistry = CPosSubsessionRegistry::NewL();

    // This call will also cancel any server shutdown in progress.

    iPosServer.IncrementSessions();

    iDecrementSessions = ETrue;

    }

/**

 * From CSession2

 *

 * This function services all requests from clients.

 */

void CPosSession::ServiceL(const RMessage2& aMessage)

    {

    LBSLOG2(ELogP1, "CPosSession::ServiceL function called with Function() = %u\n", aMessage.Function());

    switch (aMessage.Function())

        {

        case ELbsPositionerOpenModuleId:

		    OpenFromModuleIdL(aMessage);

		    break;

	    case ELbsPositionerOpen:

		    OpenDefaultPositionerL(aMessage);

		    break;

	    case ELbsPositionerOpenCriteria:

		    OpenPositionerFromCriteriaL(aMessage);

		    break;

	    case ELbsPositionerClose:

		    ClosePositioner(aMessage);

		    break;

	    case ELbsGetDefaultModuleId:

		    GetDefaultModuleIdL(aMessage);

		    break;

	    case ELbsGetNumModules:

		    GetNumModulesL(aMessage);

		    break;

	    case ELbsGetModuleInfoByIndex:

		    GetModuleInfoByIndexL(aMessage);

		    break;

	    case ELbsGetModuleInfoById:

		    GetModuleInfoByIdL(aMessage);

		    break;

	    case ELbsGetModuleStatus:

		    GetModuleStatusL(aMessage);

		    break;

	    case ELbsNotifyModuleStatusEvent:

		    NotifyModuleStatusEventL(aMessage);

		    break;

	    case ELbsEmptyLastKnownPositionStore:

	    	EmptyLastKnownPositionStoreL(aMessage);

	    	break;

	    case ELbsServerCancelAsyncRequest:

			LBS_RDEBUG("Client", "LBS", "CancelAsyncRequest");

            HandleCancelAsyncRequestL(aMessage);

		    break;

        default:

            ForwardToSubSessionL(aMessage);

		    break;

        }

    }

/**

 * From CSession2

 *

 * This function is called when ServiceL leaves.

 */

void CPosSession::ServiceError(const RMessage2& aMessage, TInt aError)

    {

    DEBUG_TRACE("Client's request failed with error", aError)

    CSession2::ServiceError(aMessage, aError);

    }

/**

 * Called when a change has been detected in the location settings. 

 * @param aEvent Event information

 */

void CPosSession::HandleSettingsChangeL(TPosModulesEvent aEvent)

    {

    // For all subSessions, call HandleSettingsChangeL()

    TInt nrOfSubSessions = iSubSessionRegistry->Count();

    for (TInt i = 0; i < nrOfSubSessions; i++)

        {

        CPosSubSession* subSession = 

            static_cast <CPosSubSession*> 

            (iSubSessionRegistry->SubSessionFromIndex(i));

		if (subSession)

			{

			subSession->HandleSettingsChangeL(aEvent);

			}

        }

    }

/**

 * Called when the server class is shutting down.

 */

void CPosSession::NotifyServerShutdown()

    {

    DEBUG_TRACE("NotifyServerShutdown", __LINE__)

    iServerShutdown = ETrue;

    TInt nrOfSubSessions = iSubSessionRegistry->Count();

    iLocMonitorReqHandlerHub.NotifyServerShutDown(); //TODO ????????????????????????????????????????????

    for (TInt i = 0; i < nrOfSubSessions; i++)

        {

        CPosSubSession* subSession = 

            static_cast <CPosSubSession*> 

            (iSubSessionRegistry->SubSessionFromIndex(i));

        if (subSession)

			{

			subSession->NotifyServerShutdown();

			}

        }

    }

void CPosSession::OpenFromModuleIdL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionerOpenModuleId", __LINE__)

	TPckgBuf<TPositionModuleId> moduleIdBuf;

    User::LeaveIfError(Global::Read(aMessage, KParamModuleIdOpen, moduleIdBuf));

    CreateSubSessionL(moduleIdBuf(), EFalse, aMessage);

    RequestComplete(aMessage, KErrNone);

    }

void CPosSession::OpenDefaultPositionerL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionerOpen(Default)", __LINE__)

    CreateSubSessionL(KPosDefaultModule, ETrue, aMessage);

	RequestComplete(aMessage, KErrNone);

    }

void CPosSession::OpenPositionerFromCriteriaL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionerOpenCriteria", __LINE__)

    // Read Criteria

	TPckgBuf<TPositionCriteria> criteria;

    User::LeaveIfError(Global::Read(aMessage, KParamCriteria, criteria));

    CreateSubSessionL(KPosStrategyModule, ETrue, aMessage);

    RequestComplete(aMessage, KErrNone);

    }

void CPosSession::ClosePositioner(const RMessage2& aMessage)

    {

    iLocMonitorReqHandlerHub.NotifySubSessionClosed(aMessage);

    TInt handle = aMessage.Int3();

    iSubSessionRegistry->CloseSubSession(handle);

	RequestComplete(aMessage, KErrNone);

    DEBUG_TRACE("EPositionerClose", __LINE__)

    }

void CPosSession::GetDefaultModuleIdL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionServerGetDefaultModuleId", __LINE__)

    CPosModuleIdList* moduleList = iModuleSettings.ModuleIdListL();

    CleanupStack::PushL( moduleList );

    TInt nrOfModules = moduleList->Count();

    TInt res = KErrNotFound;

    for (TInt i = 0; (i < nrOfModules) && (res == KErrNotFound); i++)

        {

        TPositionModuleInfo candidate;

        iModuleSettings.GetModuleInfoL((*moduleList)[i], candidate);

        if (candidate.IsAvailable())

            {

            TPckg<TPositionModuleId> moduleId(candidate.ModuleId());

            User::LeaveIfError(Global::Write(aMessage, KParamModuleIdGetDefault, moduleId));

            res = KErrNone;

            }

        }

    CleanupStack::PopAndDestroy(moduleList);

    RequestComplete(aMessage, res);

    }   

void CPosSession::GetNumModulesL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionServerGetNumModules", __LINE__)

    CPosModuleIdList* moduleList = iModuleSettings.ModuleIdListL();

    TInt num = moduleList->Count();

    delete moduleList;

    TPckg<TUint> numPackage(num);

    User::LeaveIfError(Global::Write(aMessage, KParamNumModules, numPackage));

    RequestComplete(aMessage, KErrNone);

    }

void CPosSession::GetModuleInfoByIndexL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionServerGetModuleInfoByIndex in", __LINE__)

    // module index

    TInt modIndex = aMessage.Int0();

    CPosModuleIdList* moduleIdList = iModuleSettings.ModuleIdListL();

    CleanupStack::PushL( moduleIdList );

    if (modIndex >= moduleIdList->Count() || modIndex < 0)

        {

        User::Leave(KErrNotFound);

        }

    TPositionModuleId moduleId = (*moduleIdList)[modIndex];

    // module info

    HBufC8* buffer = Global::CopyClientBuffer8LC(aMessage, KParamModuleInfo);

    TPositionModuleInfoBase* moduleInfoBase =

        reinterpret_cast<TPositionModuleInfoBase*>(

        const_cast<TUint8*>(buffer->Ptr()));

    Global::ValidatePositionClassBufferL(*moduleInfoBase, buffer->Des());

    // TPositionModuleInfo is the only class supported by CPosModules

    Global::ValidatePositionClassTypeL(*moduleInfoBase, EPositionModuleInfoClass);

    DEBUG_TRACE("Buffer validation done", __LINE__)

    CleanupStack::PopAndDestroy(2, moduleIdList);

    // TPositionModuleInfo contains descriptor. If it is corrupt 

    // (malicious client) then writing to this will panic server

    // Local instance of TPositionModuleInfo is created to be sure

    // that module name descriptor is not corrupt

    TPositionModuleInfo modInfo;

    iModuleSettings.GetModuleInfoL(moduleId, modInfo);

    TPckg<TPositionModuleInfo> modInfoPack(modInfo);

    User::LeaveIfError(Global::Write(aMessage, KParamModuleInfo, modInfoPack));

    RequestComplete(aMessage, KErrNone);

    DEBUG_TRACE("EPositionServerGetModuleInfoByIndex out", __LINE__)

    }

void CPosSession::GetModuleInfoByIdL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionServerGetModuleInfoById in", __LINE__)

    TPckgBuf<TPositionModuleId> moduleIdBuf;

	User::LeaveIfError(Global::Read(aMessage, KParamModuleIdGetInfo, moduleIdBuf));

    TPositionModuleId moduleId = moduleIdBuf();

    HBufC8* buffer = Global::CopyClientBuffer8LC(aMessage, KParamModuleInfo);

    TPositionModuleInfoBase* moduleInfoBase = 

	    reinterpret_cast<TPositionModuleInfoBase*>(

        const_cast<TUint8*>(buffer->Ptr()));

    Global::ValidatePositionClassBufferL(*moduleInfoBase, buffer->Des());

    // TPositionModuleInfo is the only class supported by CPosModules

    Global::ValidatePositionClassTypeL(*moduleInfoBase, EPositionModuleInfoClass);

    DEBUG_TRACE("Buffer validation done", __LINE__)

    CleanupStack::PopAndDestroy(buffer);

    // TPositionModuleInfo contains descriptor. If it is corrupt 

    // (malicious client) then writing to this will panic server

    // Local instance of TPositionModuleInfo is created to be sure

    // that module name descriptor is not corrupt

    TPositionModuleInfo modInfo;

    iModuleSettings.GetModuleInfoL(moduleId, modInfo);

    TPckg<TPositionModuleInfo> modInfoPack(modInfo);

    User::LeaveIfError(Global::Write(aMessage, KParamModuleInfo, modInfoPack));

    RequestComplete(aMessage, KErrNone);

    DEBUG_TRACE("EPositionServerGetModuleInfoById out", __LINE__)

    }

void CPosSession::GetModuleStatusL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionServerGetModuleStatus in", __LINE__)

    TPckgBuf<TPositionModuleId> moduleIdBuf;

	User::LeaveIfError(Global::Read(aMessage, KParamModuleIdGetStatus, moduleIdBuf));

    TPositionModuleId moduleId = moduleIdBuf();

    HBufC8* buffer = Global::CopyClientBuffer8LC(aMessage, KParamModuleStatusGet);

    // Read module status and write back to client

    TPositionModuleStatusBase* moduleStatusBase = 

	    reinterpret_cast<TPositionModuleStatusBase*>(

        const_cast<TUint8*>(buffer->Ptr()));

    Global::ValidatePositionClassBufferL(*moduleStatusBase, buffer->Des());

    User::LeaveIfError ( 

        iModulesStatus.GetModuleStatus(moduleId, *moduleStatusBase) );

    User::LeaveIfError(Global::Write(aMessage, KParamModuleStatusGet, *buffer));

    CleanupStack::PopAndDestroy(buffer);

	RequestComplete(aMessage, KErrNone);

    DEBUG_TRACE("EPositionServerGetModuleStatus out", __LINE__)

    }

void CPosSession::NotifyModuleStatusEventL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionServerNotifyModuleStatusEvent", __LINE__)

    iModulesStatus.NotifyModuleStatusEventL(aMessage, this);

    }

void CPosSession::NotifyModuleStatusEventCancelL(const RMessage2& aMessage)

    {

    DEBUG_TRACE("EPositionServerNotifyModuleStatusEventCancel", __LINE__)

    iModulesStatus.CancelNotifyModuleStatusEventL(this);

    RequestComplete(aMessage, KErrNone);

    }

void CPosSession::HandleCancelAsyncRequestL(const RMessage2& aMessage)

    {

    switch (aMessage.Int0())

        {

        case KServerNotifyModuleStatusEventSymbian:

        case KServerNotifyModuleStatusEventVariant:

        case ELbsNotifyModuleStatusEvent:                 // TODO Verify

	        NotifyModuleStatusEventCancelL(aMessage);

            break;

        case ELbsEmptyLastKnownPositionStore:

        	EmptyLastKnownPositionStoreCancelL(aMessage); // TODO Verify

        default:

            RequestComplete(aMessage, KErrNotSupported);

            break;

        }

    }

void CPosSession::EmptyLastKnownPositionStoreL(const RMessage2& aMessage)

	{

	iLocMonitorReqHandlerHub.EmptyLastKnownPosStoreReqL(aMessage);

	}

void CPosSession::EmptyLastKnownPositionStoreCancelL(const RMessage2& aMessage)

	{

	iLocMonitorReqHandlerHub.CancelEmptyLastKnownPosStoreReqL(aMessage);

	}

void CPosSession::CreateSubSessionL(TPositionModuleId aId, TBool aIsProxy, const RMessage2& aMessage)

	{

    CPosSubSession* subSession = CPosSubSession::NewLC(

        iModuleSettings, 

        iLocMonitorReqHandlerHub,

        aId,

        aIsProxy,

        &iModulesStatus,

        &iModulesStatus);

    TInt subSessionHandle = iSubSessionRegistry->AddInstanceL(subSession);

    CleanupStack::Pop(subSession); // Now owned by registry

    // Set the client subsession identifier.

    TPckg<TInt> handlePackage(subSessionHandle);

    TInt err = Global::Write(aMessage, KParamSubsession, handlePackage);

    if (err)

        {

        iSubSessionRegistry->CloseSubSession(subSessionHandle);

        User::Leave(err);

        }

    DEBUG_TRACE("Subsession created successfully", __LINE__)

	}

void CPosSession::ForwardToSubSessionL(const RMessage2& aMessage)

    {

    CPosSubSession* subSession =

        iSubSessionRegistry->SubSessionFromHandleL(aMessage.Int3());

    if (!subSession)

		{

        User::Leave(KErrNotSupported);

        }

    subSession->ServiceL(aMessage); 

    }

void CPosSession::RequestComplete(const RMessage2& aMessage, TInt aCompleteCode)

    {

    if (!aMessage.IsNull())

        {

        aMessage.Complete(aCompleteCode);

        }

    }

//  End of File